en ordre de code asynchrone IO

Je suggère de prendre un coup d'oeil sur: http://www.kegel.com/c10k.html, deuxième de prendre un coup d'oeil sur les bibliothèques existantes comme libevent, coup de pouce.Asio qui ont déjà fait le travail et de voir comment ils travaillent.

Le point est que l'approche peut être différente pour chaque type de système d'appel:

• sélectionnez est simple réacteur
• epoll ont à la fois le bord ou le niveau déclenché interface qui nécessitent une approche différente
• iocp est proactor exigent une autre approche

Suggestion: utiliser une bonne bibliothèque existante comme Boost.Asio pour le C++ ou libevent pour C.

EDIT: c'est de Cette façon ASIO gère ce

class connection {
   boost::asio:ip::tcp::socket socket_;
public:
   void run()
   {
         //for variable length chunks
         async_read_until(socket_,resizable_buffer,'\n',
               boost::bind(&run::on_line_recieved,this,errorplacehplder);
         //or constant length chunks
         async_read(socket_,buffer(some_buf,buf_size),
               boost::bind(&run::on_line_recieved,this,errorplacehplder);
   }
   void on_line_recieved(error e)
   {
        //handle it
        run();
   }

};

Car ASIO fonctionne comme proactor il vous avertit lorsque l'opération est terminée et
poignées EWOULDBLOCK en interne.

Si vous word en tant que réacteur, vous pouvez simuler ce comportement:

 class conn {
    //Application logic

    void run() {
       read_chunk(&conn::on_chunk_read,size);
    }
    void on_chunk_read() {
         /* do something;*/
    }

    //Proactor wrappers

    void read_chunk(void (conn::*callback),int size, int start_point=0) {
       read(socket,buffer+start,size)
       if( complete )
          (this->*callback()
       else {
          this -> tmp_size-=size-read;
          this -> tmp_start=start+read;
          this -> tmp_callback=callback
          your_event_library_register_op_on_readable(callback,socket,this);
       }
    }
    void callback()
    {
       read_chunk(tmp_callback,tmp_size,tmp_start);
    }
 }

Quelque chose comme ça.

Grand modèle de conception "coroutine" existe pour résoudre ce problème.

C'est le meilleur des deux mondes: bien rangé code, exactement comme synchrone io flux et d'excellentes performances sans changement de contexte, comme async io donne. Coroutine regarde à l'intérieur comme une odinary synchrone fil, avec un seul pointeur d'instruction. Mais beaucoup de coroutines pouvez exécuter dans un délai d'un OS thread (soi-disant "multitâche coopératif").

Exemple coroutine code:

void do_some_io() {
   blocking_read(something,sizeof(something));
   blocking_read(something_else,sizeof(something_else));
   blocking_write(something,sizeof(something));
}

Ressemble à du code synchrone, mais en fait, le contrôle de flux d'utiliser une autre façon, comme ceci:

void do_some_io() {
   //return control to network io scheduler, to handle another coroutine
   blocking_read(something,sizeof(something)); 
   //when "something" is read, scheduler fill given buffer and resume this coroutine 

   //return control to network io scheduler, to handle another coroutine
   CoroSleep( 1000 );
   //scheduler create async timer and when it fires, scheduler pass control to this coroutine
    ...
   //and so on 

Donc à thread unique planificateur de contrôler un grand nombre de coroutines avec code défini par l'utilisateur et bien rangé synchrone comme des appels à io.

C++ coroutines exemple de mise en œuvre est de "stimuler.coroutine" (en réalité pas une partie de boost 🙂
http://www.crystalclearsoftware.com/soc/coroutine/
Cette bibliothèque met en œuvre coroutine mécanique et peut utiliser boost.asio en tant que planificateur et async io couche.

Vous souhaitez dissocier "io" de traitement, à quel point le code de vous lire deviendra très lisible. Fondamentalement, vous devez:

    int read_io_event(...) { /* triggers when we get a read event from epoll/poll/whatever */

     /* read data from "fd" into a vstr/buffer/whatever */

     if (/* read failed */) /* return failure code to event callback */ ;

     if (/* "message" received */) return process_io_event();

     if (/* we've read "too much" */) /* return failure code to event callback */ ;

     return /* keep going code for event callback */ ;
    }


    int process_io_event(...) {
       /* this is where you process the HTTP request/whatever */
    }

...puis le vrai code est dans le processus de l'événement, et même si vous avez plusieurs demandes de réponses c'est assez lisible, il suffit de le faire "retour read_io_event()" après la définition d'un état ou quoi que ce soit.