Linux的非同步IO

    Linux非同步I/O是Linux核心中提供的一個相當新的增強。它是2.6版本核心的一個標準特性，但是我們在2.4版本核心的補丁中也可以找到它。AIO背後的基本思想是允許進程發起很多I/O操作，而不用阻塞或等待任何操作完成。稍後或在接收到I/O操作完成的通知時，進程就可以檢索I/O操作的結果。

    1、 I/O 模型
    在深入介紹AIO API之前，讓我們先來探索一下Linux上可以使用的不同I/O模型。這並不是一個詳盡的介紹，但是我們將試圖介紹最常用的一些模型來解釋它們與非同步I/O之間的區別。圖 1給出了同步和非同步模型，以及阻塞和非阻塞的模型。

圖1 基本Linux I/O模型的簡單矩陣

    每個 I/O 模型都有自己的使用模式，它們對於特定的應用程式都有自己的優點。本節將簡要對其一一進行介紹。

    注意：I/O密集型進程所執行的I/O操作比執行的處理操作更多。CPU密集型的進程所執行的處理操作比I/O操作更多。Linux 2.6的調度器實際上更加偏愛I/O密集型的進程，因為它們通常會發起一個I/O操作，然後進行阻塞，這就意味著其他工作都可以在兩者之間有效地交錯進行。

    （1）同步阻塞 I/O

    最常用的一個模型是同步阻塞I/O模型。在這個模型中，使用者空間的應用程式執行一個系統調用，這會導致應用程式阻塞。這意味著應用程式會一直阻塞，直到系統調用完成為止（資料轉送完成或發生錯誤）。調用應用程式處於一種不再消費 CPU 而只是簡單等待響應的狀態，因此從處理的角度來看，這是非常有效。
    圖 2 給出了傳統的阻塞I/O模型，這也是目前應用程式中最為常用的一種模型。其行為非常容易理解，其用法對於典型的應用程式來說都非常有效。在調用read系統調用時，應用程式會阻塞並對核心進行環境切換。然後會觸發讀操作，當響應返回時（從我們正在從中讀取的裝置中返回），資料就被移動到使用者空間的緩衝區中。然後應用程式就會解除阻塞（read調用返回）。

圖2 同步阻塞I/O模型的典型流程

    從應用程式的角度來說，read 調用會延續很長時間。實際上，在核心執行讀操作和其他工作時，應用程式的確會被阻塞。
    （2）同步非阻塞I/O
    同步阻塞I/O的一種效率稍低的變種是同步非阻塞I/O。在這種模型中，裝置是以非阻塞的形式開啟的。這意味著I/O操作不會立即完成，read操作可能會返回一個錯誤碼，說明這個命令不能立即滿足（EAGAIN或EWOULDBLOCK），3所示。

圖3 同步非阻塞I/O模型的典型流程

    非阻塞的實現是I/O命令可能並不會立即滿足，需要應用程式調用許多次來等待操作完成。這可能效率不高，因為在很多情況下，當核心執行這個命令時，應用程式必須要進行忙碌等待，直到資料可用為止，或者試圖執行其他工作。正3所示的一樣，這個方法可以引入I/O操作的延時，因為資料在核心中變為可用到使用者調用read返回資料之間存在一定的間隔，這會導致整體資料輸送量的降低。
    （3）非同步阻塞 I/O
    另外一個阻塞解決方案是帶有阻塞通知的非阻塞 I/O。在這種模型中，配置的是非阻塞I/O，然後使用阻塞select系統調用來確定一個I/O描述符何時有操作。使select調用非常有趣的是它可以用來為多個描述符提供通知，而不僅僅為一個描述符提供通知。對於每個提示符來說，我們可以請求這個描述符可以寫資料、有讀資料可用以及是否發生錯誤的通知。

圖4 非同步阻塞I/O模型的典型流程 (select)

    select調用的主要問題是它的效率不是非常高。儘管這是非同步通知使用的一種方便模型，但是對於高效能的I/O操作來說不建議使用。
    （4）非同步非阻塞 I/O（AIO）
    最後，非同步非阻塞I/O模型是一種處理與I/O重疊進行的模型。讀請求會立即返回，說明read請求已經成功發起了。在後台完成讀操作時，應用程式然後會執行其他處理操作。當read的響應到達時，就會產生一個訊號或執行一個基於線程的回呼函數來完成這次I/O處理過程。

圖5 非同步非阻塞I/O模型的典型流程

    在一個進程中為了執行多個I/O請求而對計算操作和I/O處理進行重疊處理的能力利用了處理速度與I/O速度之間的差異。當一個或多個I/O請求掛起時，CPU可以執行其他任務；或者更為常見的是，在發起其他I/O的同時對已經完成的I/O進行操作。

    從前面I/O模型的分類中，我們可以看出AIO的動機。這種阻塞模型需要在I/O操作開始時阻塞應用程式。這意味著不可能同時重疊進行處理和I/O操作。同步非阻塞模型允許處理和I/O操作重疊進行，但是這需要應用程式根據重現的規則來檢查I/O操作的狀態。這樣就剩下非同步非阻塞I/O了，它允許處理和I/O操作重疊進行，包括I/O操作完成的通知。
    除了需要阻塞之外，select函數所提供的功能（非同步阻塞I/O）與AIO類似。不過，它是對通知事件進行阻塞，而不是對I/O調用進行阻塞。

    2、Linux上的AIO簡介
    在傳統的I/O模型中，有一個使用惟一控制代碼標識的I/O通道。在 UNIX中，這些控制代碼是檔案描述符（這對等同於檔案、管道、通訊端等等）。在阻塞I/O中，我們發起了一次傳輸操作，當傳輸操作完成或發生錯誤時，系統調用就會返回。

    在非同步非阻塞I/O中，我們可以同時發起多個傳輸操作。這需要每個傳輸操作都有惟一的上下文，這樣我們才能在它們完成時區分到底是哪個傳輸操作完成了。在AIO中，這是一個aiocb結構（AIO Control Block）。這個結構包含了有關傳輸的所有資訊，包括為資料準備的使用者緩衝區。在產生I/O（稱為完成）通知時，aiocb結構就被用來惟一標識所完成的I/O操作。這個API的展示顯示了如何使用它。

    AIO在2.5版本的核心中首次出現，現在已經是2.6版本的產品核心的一個標準特性了。 AIO介面的API非常簡單，但是它為資料轉送提供了必需的功能，並給出了兩個不同的通知模型。表1給出了AIO的介面函數。

表1. AIO介面API

API 函數	說明
aio_read	請求非同步讀操作
aio_error	檢查非同步請求的狀態
aio_return	獲得完成的非同步請求的返回狀態
aio_write	請求非同步寫操作
aio_suspend	掛起調用進程，直到一個或多個非同步請求已經完成（或失敗）
aio_cancel	取消非同步I/O請求
lio_listio	發起一系列I/O操作

    每個API函數都使用aiocb結構開始或檢查。這個結構有很多元素，但是清單1僅僅給出了需要（或可以）使用的元素。

清單1. aiocb結構中相關的域

struct aiocb {  int aio_fildes;               // File Descriptor  int aio_lio_opcode;           // Valid only for lio_listio (r/w/nop)  volatile void *aio_buf;       // Data Buffer  size_t aio_nbytes;            // Number of Bytes in Data Buffer  struct sigevent aio_sigevent; // Notification Structure  /* Internal fields */  ...};

    sigevent 結構告訴AIO在I/O操作完成時應該執行什麼操作。我們將在 AIO 的展示中對這個結構進行探索。現在我們將展示各個AIO的API函數是如何工作的，以及我們應該如何使用它們。
    （1）aio_read
    aio_read函數請求對一個有效檔案描述符進行非同步讀操作。這個檔案描述符可以表示一個檔案、通訊端甚至管道。aio_read函數的原型如下：
    int aio_read( struct aiocb *aiocbp );
    aio_read函數在請求進行排隊之後會立即返回。如果執行成功，傳回值就為0；如果出現錯誤，傳回值就為-1，並設定errno的值。
    要執行讀操作，應用程式必須對aiocb結構進行初始化。下面這個簡短的例子就展示了如何填充aiocb請求結構，並使用aio_read來執行非同步讀請求（現在暫時忽略通知）操作。它還展示了aio_error的用法。
清單 2. 使用aio_read進行非同步讀操作的例子 

#include <aio.h>...  int fd, ret;  struct aiocb my_aiocb;  fd = open( "file.txt", O_RDONLY );  if (fd < 0) perror("open");  /* Zero out the aiocb structure (recommended) */  bzero( (char *)&my_aiocb, sizeof(struct aiocb) );  /* Allocate a data buffer for the aiocb request */  my_aiocb.aio_buf = malloc(BUFSIZE+1);  if (!my_aiocb.aio_buf) perror("malloc");  /* Initialize the necessary fields in the aiocb */  my_aiocb.aio_fildes = fd;  my_aiocb.aio_nbytes = BUFSIZE;  my_aiocb.aio_offset = 0;  ret = aio_read( &my_aiocb );  if (ret < 0) perror("aio_read");  while ( aio_error( &my_aiocb ) == EINPROGRESS ) ;  if ((ret = aio_return( &my_iocb )) > 0) {    /* got ret bytes on the read */  } else {    /* read failed, consult errno */  }

    在清單2中，在開啟要從中讀取資料的檔案之後，我們就清空了aiocb結構，然後分配一個資料緩衝區。並將對這個資料緩衝區的引用放到aio_buf中。然後，我們將aio_nbytes初始化成緩衝區的大小。並將aio_offset設定成0（該檔案中的第一個位移量）。我們將aio_fildes設定為從中讀取資料的檔案描述符。在設定這些域之後，就調用aio_read請求進行讀操作。我們然後可以調用aio_error來確定aio_read的狀態。只要狀態是EINPROGRESS，就一直忙碌等待，直到狀態發生變化為止。現在，請求可能成功，也可能失敗。

    注意使用這個API與標準的庫函數從檔案中讀取內容是非常相似的。除了aio_read的一些非同步特性之外，另外一個區別是讀操作位移量的設定。在傳統的read調用中，位移量是在檔案描述符上下文中進行維護的。對於每個讀操作來說，位移量都需要進行更新，這樣後續的讀操作才能對下一塊資料進行定址。對於非同步I/O操作來說這是不可能的，因為我們可以同時執行很多讀請求，因此必須為每個特定的讀請求都指定位移量。

    我們可以在aio.h標頭檔中找到函數原型和其他需要的符號。在編譯使用這種介面的程式時，我們必須使用POSIX即時擴充庫（librt）。

    （2） aio_error
    aio_error函數被用來確定請求的狀態。其原型如下：
    int aio_error( struct aiocb *aiocbp );
    這個函數可以返回以下內容：
    * EINPROGRESS，說明請求尚未完成
    * ECANCELLED，說明請求被應用程式取消了
    * -1，說明發生了錯誤，具體錯誤原因可以查閱errno
    （3）aio_return
    非同步I/O和標準塊I/O之間的另外一個區別是我們不能立即訪問這個函數的返回狀態，因為我們並沒有阻塞在read調用上。在標準的read調用中，返回狀態是在該函數返回時提供的。但是在非同步I/O中，我們要使用aio_return函數。這個函數的原型如下：
    ssize_t aio_return( struct aiocb *aiocbp );
    只有在aio_error調用確定請求已經完成（可能成功，也可能發生了錯誤）之後，才會調用這個函數。aio_return的傳回值就等價於同步情況中read或write系統調用的傳回值（所傳輸的位元組數，如果發生錯誤，傳回值就為-1）。
    （4）aio_write
    aio_write函數用來請求一個非同步寫操作。其函數原型如下：
    int aio_write( struct aiocb *aiocbp );
    aio_write函數會立即返回，說明請求已經進行排隊（成功時傳回值為0，失敗時傳回值為-1，並相應地設定errno）。
    這與read系統調用類似，但是有一點不一樣的行為需要注意。回想一下對於read調用來說，要使用的位移量是非常重要的。然而，對於write來說，這個位移量只有在沒有設定O_APPEND選項的檔案上下文中才會非常重要。如果設定了O_APPEND，那麼這個位移量就會被忽略，資料都會被附加到檔案的末尾。否則，aio_offset域就確定了資料在要寫入的檔案中的位移量。
    （5）aio_suspend
    我們可以使用aio_suspend函數來掛起（或阻塞）調用進程，直到非同步請求完成為止，此時會產生一個訊號，或者發生其他逾時操作。調用者提供了一個aiocb引用列表，其中任何一個完成都會導致aio_suspend返回。 aio_suspend的函數原型如下：
    int aio_suspend( const struct aiocb *const cblist[], int n, const struct timespec *timeout );
    aio_suspend的使用非常簡單。我們要提供一個aiocb引用列表。如果任何一個完成了，這個調用就會返回0。否則就會返回-1，說明發生了錯誤。請參看清單3。

清單 3. 使用aio_suspend函數阻塞非同步I/O

struct aioct *cblist[MAX_LIST]/* Clear the list. */bzero( (char *)cblist, sizeof(cblist) );/* Load one or more references into the list */cblist[0] = &my_aiocb;ret = aio_read( &my_aiocb );ret = aio_suspend( cblist, MAX_LIST, NULL );

    注意，aio_suspend的第二個參數是cblist中元素的個數，而不是aiocb引用的個數。cblist中任何NULL元素都會被aio_suspend忽略。
    如果為aio_suspend提供了逾時，而逾時情況的確發生了，那麼它就會返回 -1，errno中會包含EAGAIN。
    （6）aio_cancel
    aio_cancel函數允許我們取消對某個檔案描述符執行的一個或所有I/O請求。其原型如下：
    int aio_cancel( int fd, struct aiocb *aiocbp );
    要取消一個請求，我們需要提供檔案描述符和aiocb引用。如果這個請求被成功取消了，那麼這個函數就會返回AIO_CANCELED。如果請求完成了，這個函數就會返回AIO_NOTCANCELED。
    要取消對某個給定檔案描述符的所有請求，我們需要提供這個檔案的描述符，以及一個對aiocbp的NULL引用。如果所有的請求都取消了，這個函數就會返回AIO_CANCELED；如果至少有一個請求沒有被取消，那麼這個函數就會返回AIO_NOT_CANCELED；如果沒有一個請求可以被取消，那麼這個函數就會返回AIO_ALLDONE。我們然後可以使用aio_error來驗證每個AIO請求。如果這個請求已經被取消了，那麼aio_error就會返回 -1，並且errno會被設定為ECANCELED。
    （7）lio_listio
    最後，AIO提供了一種方法使用lio_listio API函數同時發起多個傳輸。這個函數非常重要，因為這意味著我們可以在一個系統調用（一次核心環境切換）中啟動大量的I/O操作。從效能的角度來看，這非常重要，因此值得我們花點時間探索一下。lio_listio API函數的原型如下：
    int lio_listio( int mode, struct aiocb *list[], int nent, struct sigevent *sig );
    mode參數可以是LIO_WAIT或LIO_NOWAIT。LIO_WAIT會阻塞這個調用，直到所有的I/O都完成為止。在操作進行排隊之後，LIO_NOWAIT就會返回。list 是一個aiocb引用的列表，最大元素的個數是由nent定義的。注意list的元素可以為NULL，lio_listio會將其忽略。sigevent引用定義了在所有I/O操作都完成時產生訊號的方法。
    對於lio_listio的請求與傳統的read或write請求在必須指定的操作方面稍有不同，如清單4所示。
清單 4. 使用lio_listio函數發起一系列請求

struct aiocb aiocb1, aiocb2;struct aiocb *list[MAX_LIST];.../* Prepare the first aiocb */aiocb1.aio_fildes = fd;aiocb1.aio_buf = malloc( BUFSIZE+1 );aiocb1.aio_nbytes = BUFSIZE;aiocb1.aio_offset = next_offset;aiocb1.aio_lio_opcode = LIO_READ;...bzero( (char *)list, sizeof(list) );list[0] = &aiocb1;list[1] = &aiocb2;ret = lio_listio( LIO_WAIT, list, MAX_LIST, NULL );

    對於讀操作來說，aio_lio_opcode域的值為LIO_READ。對於寫操作來說，我們要使用LIO_WRITE，不過LIO_NOP對於不執行操作來說也是有效。
    3、 AIO通知
    現在我們已經看過了可用的AIO函數，本節將深入介紹對非同步通知可以使用的方法。我們將通過訊號和函數回調來探索非同步函數的通知機制。
    （1）使用訊號進行非同步通知
    使用訊號進行處理序間通訊（IPC）是UNIX中的一種傳統機制，AIO也可以支援這種機制。在這種範例中，應用程式需要定義訊號處理常式，在產生指定的訊號時就會調用這個處理常式。應用程式然後配置一個非同步請求將在請求完成時產生一個訊號。作為訊號內容相關的一部分，特定的aiocb請求被提供用來記錄多個可能會出現的請求。清單5展示了這種通知方法。
清單 5. 使用訊號作為AIO請求的通知

void setup_io( ... ){  int fd;  struct sigaction sig_act;  struct aiocb my_aiocb;  ...  /* Set up the signal handler */  sigemptyset(&sig_act.sa_mask);  sig_act.sa_flags = SA_SIGINFO;  sig_act.sa_sigaction = aio_completion_handler;  /* Set up the AIO request */  bzero( (char *)&my_aiocb, sizeof(struct aiocb) );  my_aiocb.aio_fildes = fd;  my_aiocb.aio_buf = malloc(BUF_SIZE+1);  my_aiocb.aio_nbytes = BUF_SIZE;  my_aiocb.aio_offset = next_offset;  /* Link the AIO request with the Signal Handler */  my_aiocb.aio_sigevent.sigev_notify = SIGEV_SIGNAL;  my_aiocb.aio_sigevent.sigev_signo = SIGIO;  my_aiocb.aio_sigevent.sigev_value.sival_ptr = &my_aiocb;  /* Map the Signal to the Signal Handler */  ret = sigaction( SIGIO, &sig_act, NULL );  ...  ret = aio_read( &my_aiocb );}void aio_completion_handler( int signo, siginfo_t *info, void *context ){  struct aiocb *req;  /* Ensure it's our signal */  if (info->si_signo == SIGIO) {    req = (struct aiocb *)info->si_value.sival_ptr;    /* Did the request complete? */    if (aio_error( req ) == 0) {      /* Request completed successfully, get the return status */      ret = aio_return( req );    }  }  return;}

    在清單5中，我們在aio_completion_handler函數中設定訊號處理常式來捕獲SIGIO訊號。然後初始化aio_sigevent結構，通過產生SIGIO訊號來進行通知（這是通過sigev_notify中的SIGEV_SIGNAL定義來指定的）。當讀操作完成時，訊號處理常式就從該訊號的si_value結構中提取出aiocb，並檢查錯誤狀態和返回狀態來確定I/O操作是否完成。
    對於效能來說，這個處理常式也是通過請求下一次非同步傳輸而繼續進行I/O操作的理想地方。採用這種方式，在一次資料轉送完成時，我們就可以立即開始下一次資料轉送操作。
    （2）使用回呼函數進行非同步通知
    另外一種通知方式是系統回呼函數。這種機制不會為通知而產生一個訊號，而是會調用使用者空間的一個函數來實現通知功能。我們在sigevent結構中設定了對aiocb的引用，從而可以惟一標識正在完成的特定請求。請參看清單6。
清單 6. 對AIO請求使用線程回調通知

void setup_io( ... ){  int fd;  struct aiocb my_aiocb;  ...  /* Set up the AIO request */  bzero( (char *)&my_aiocb, sizeof(struct aiocb) );  my_aiocb.aio_fildes = fd;  my_aiocb.aio_buf = malloc(BUF_SIZE+1);  my_aiocb.aio_nbytes = BUF_SIZE;  my_aiocb.aio_offset = next_offset;  /* Link the AIO request with a thread callback */  my_aiocb.aio_sigevent.sigev_notify = SIGEV_THREAD;  my_aiocb.aio_sigevent.notify_function = aio_completion_handler;  my_aiocb.aio_sigevent.notify_attributes = NULL;  my_aiocb.aio_sigevent.sigev_value.sival_ptr = &my_aiocb;  ...  ret = aio_read( &my_aiocb );}void aio_completion_handler( sigval_t sigval ){  struct aiocb *req;  req = (struct aiocb *)sigval.sival_ptr;  /* Did the request complete? */  if (aio_error( req ) == 0) {    /* Request completed successfully, get the return status */    ret = aio_return( req );  }  return;}

    在清單6中，在建立自己的aiocb請求之後，我們使用SIGEV_THREAD請求了一個線程回呼函數來作為通知方法。然後我們將指定特定的通知處理常式，並將要傳輸的上下文載入到處理常式中（在這種情況中，是個對aiocb請求自己的引用）。在這個處理常式中，我們簡單地引用到達的sigval指標並使用AIO函數來驗證請求已經完成。
    4、對AIO進行系統最佳化
    proc檔案系統包含了兩個虛擬檔案，它們可以用來對非同步I/O的效能進行最佳化：
    /proc/sys/fs/aio-nr檔案：提供了系統範圍非同步I/O請求現在的數目。
    /proc/sys/fs/aio-max-nr檔案：是所允許的並發請求的最大個數。最大個數通常是64KB，這對於大部分應用程式來說都已經足夠了。
    5、 結束語

    使用非同步I/O可以協助我們構建I/O速度更快、效率更高的應用程式。如果我們的應用程式可以對處理和I/O操作重疊進行，那麼AIO就可以協助我們構建可以更高效地使用可用CPU資源的應用程式。儘管這種I/O模型與在大部分Linux應用程式中使用的傳統阻塞模式都不同，但是非同步通知模型在概念上來說卻非常簡單，可以簡化我們的設計。

    本文整理自：http://www.ibm.com/developerworks/linux/library/l-async/

    中文翻譯參考這裡：http://www.ibm.com/developerworks/cn/linux/l-async/