X-Git-Url: https://gapil.gnulinux.it/gitweb/?p=gapil.git;a=blobdiff_plain;f=fileadv.tex;h=578f867f0d011bd03e4fce75c534232245314ea6;hp=531aaa0b7af806ecc604a6e7a88b15791426c5c7;hb=52958c279452903b8c4edea25643096a32c67235;hpb=3e4b9977d8398f32d2637106cb2b26d5988e6769 diff --git a/fileadv.tex b/fileadv.tex index 531aaa0..578f867 100644 --- a/fileadv.tex +++ b/fileadv.tex @@ -373,8 +373,6 @@ invier in eccesso, e si dovrà determinare al solito modo quali sono i file diventati attivi. - - Benché la modalità di apertura asincrona di un file possa risultare utile in varie occasioni (in particolar modo con i socket e gli altri file per i quali le funzioni di I/O sono system call lente), essa è comunque limitata alla @@ -392,9 +390,122 @@ di thread. Al momento\footnote{fino ai kernel della serie 2.4.x, nella serie asincrono.} esiste una sola versione stabile di questa interfaccia, quella delle \acr{glibc}, che è realizzata completamente in user space. Esistono comunque vari progetti sperimentali (come il KAIO della SGI, o i patch di -Benjamin La Haise) che prevedono una interfaccia che utilizza un supporto -diretto da parte del kernel. +Benjamin La Haise) che prevedono un supporto diretto da parte del kernel. + +Lo standard prevede che tutte le operazioni di I/O asincrono siano controllate +attraverso l'uso di una apposita struttura \type{aiocb} (il cui nome sta per +\textit{asyncronous I/O control block}), che viene passata come argomento a +tutte le funzioni dell'interfaccia. La sua definizione, come effettuata in +\file{aio.h}, è riportata in \figref{fig:file_aiocb}. Nello steso file è +definita la macro \macro{\_POSIX\_ASYNCHRONOUS\_IO}, che dichiara la +disponibilità di questa funzionalità. + +\begin{figure}[!htb] + \footnotesize \centering + \begin{minipage}[c]{15cm} + \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{} +struct aiocb +{ + int aio_fildes; /* File descriptor. */ + off_t aio_offset; /* File offset */ + int aio_lio_opcode; /* Operation to be performed. */ + int aio_reqprio; /* Request priority offset. */ + volatile void *aio_buf; /* Location of buffer. */ + size_t aio_nbytes; /* Length of transfer. */ + struct sigevent aio_sigevent; /* Signal number and value. */ +}; + \end{lstlisting} + \end{minipage} + \normalsize + \caption{La struttura \type{aiocb}, usata per il controllo dell'I/O + asincrono.} + \label{fig:file_aiocb} +\end{figure} + +Le operazioni di I/O asincrono possono essere effettuate solo su un file già +aperto, il cui file descriptor deve essere specificato tramite il campo +\var{aio\_fildes}; il file deve inolte supportare la funzione \func{lseek}, +pertanto terminali e pipe sono esclusi. Non c'è limite al numero di operazioni +contemporanee effettuabili su un singolo file. + +Dato che più operazioni possono essere eseguita in maniera asincrona, il +concetto di posizione corrente sul file viene a mancare; pertanto ciascuna +operazione deve sempre specificare nel campo \var{aio\_offset} la posizione +sul file da cui i dati saranno letti o scritti. Nel campo \var{aio\_buf} poi +andrà specificato l'indirizzo del buffer usato per l'I/O, ed in +\var{aio\_nbytes} la lunghezza del trasferimento. + +Il campo \var{aio\_reqprio} permette di settare la priorità delle operazioni +di I/O.\footnote{in generale perché ciò sia possibile occorre che la + piattaforma supporti questa caratteristica, questo viene indicato definendo + le macro \macro{\_POSIX\_PRIORITIZED\_IO}, e + \macro{\_POSIX\_PRIORITY\_SCHEDULING}.} La priorità viene settata a partire +da quella del processo chiamante (vedi \secref{sec:proc_priority}), cui viene +sottratto il valore di questo campo. + +Il campo \var{aio\_lio\_opcode} è usato dalla funzione \func{lio\_listio}, che +permette di attivare far partire una serie di operazioni in contemporanea su +una lista di file. Tramite questo campo si specifica quale è la natura di +ciascuna di esse. + +\begin{figure}[!htb] + \footnotesize \centering + \begin{minipage}[c]{15cm} + \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{} +struct sigevent +{ + sigval_t sigev_value; + int sigev_signo; + int sigev_notify; + sigev_notify_function; + sigev_notify_attributes; +}; + \end{lstlisting} + \end{minipage} + \normalsize + \caption{La struttura \type{sigevent}, usata per .} + \label{fig:file_sigevent} +\end{figure} + +Infine il campo \var{aio\_sigevent} serve a specificare il modo in cui si +vuole che la notifica del completamento delle operazioni richieste venga +effettuata. La struttura è riportata in \secref{fig:file_sigevent}; il campo +\var{sigev\_notify} è quello che indica le modalità della notifica, esso può +assumere i tre valori: +\begin{basedescript}{\desclabelwidth{3.0cm}} +\item[\macro{SIGEV\_NONE}] Non viene inviata nessuna notifica. +\item[\macro{SIGEV\_SIGNAL}] La notifica viene effettuata usando il segnale + specificato nel campo \var{sigev\_signo}. +\item[\macro{SIGEV\_THREAD}] La notifica viene effettuata creando un nuovo + thread che esegue la funzione specificata da \var{sigev\_notify\_function}, + con gli attributi specificati da \var{sigev\_notify\_attribute}. +\end{basedescript} + + +Le due funzioni principali dell'interfaccia sono quelle per la lettura e +scrittura, \func{aio\_read} e \func{aio\_write}, i cui prototipi sono: +\begin{functions} + \headdecl{aio.h} + \funcdecl{int aio\_read(struct aiocb *aiocbp)} + Richiede una lettura asincrona sul file specificato tramite \param{aiocbp}. + + \funcdecl{int aio\_write(struct aiocb *aiocbp)} + Richiede una scrittura asincrona sul file specificato tramite + \param{aiocbp}. + + \bodydesc{Le funzioni restituiscono 0 in caso di successo, e -1 in caso di + errore, nel qual caso \var{errno} viene settata ai valori: + \begin{errlist} + \item[\macro{EBADF}] Si è specificato un file descriptor sbagliato in uno + degli insiemi. + \item[\macro{ENOSYS}] La funzione è implementata. + \item[\macro{EINVAL}] Si è specificato un valore negativo non valido per i + campi \var{aio\_offset} o \var{aio\_reqprio}, di \param{aiocbp}. + \end{errlist} + ed inoltre \macro{ENOMEM}.} + +\end{functions} @@ -403,7 +514,7 @@ diretto da parte del kernel. Un caso abbastanza comune è quello in cui ci si trova a dover affrontare una serie multipla di operazioni di I/O, come una serie di letture o scritture di -vari buffer. In questo caso +vari buffer. In questo caso