This source file includes following definitions.
- ADIOI_Malloc_async_node
- ADIOI_Free_async_node
- ADIOI_Add_req_to_list
- ADIOI_Complete_async
- ADIOI_Del_req_from_list
   1 
   2 
   3 
   4 
   5 
   6 
   7 
   8 #include "adio.h"
   9 #include "adio_extern.h"
  10 
  11 ADIOI_Async_node *ADIOI_Malloc_async_node(void)
  12 {
  13 
  14 
  15 
  16 
  17 
  18 
  19 #define NUM 100
  20 
  21     ADIOI_Async_node *curr, *ptr;
  22     int i;
  23 
  24     if (!ADIOI_Async_avail_head) {
  25         ADIOI_Async_avail_head = (ADIOI_Async_node *)
  26                       ADIOI_Malloc(NUM*sizeof(ADIOI_Async_node));  
  27         curr = ADIOI_Async_avail_head;
  28         for (i=1; i<NUM; i++) {
  29             curr->next = ADIOI_Async_avail_head+i;
  30             curr = curr->next;
  31         }
  32         curr->next = NULL;
  33         ADIOI_Async_avail_tail = curr;
  34 
  35         
  36         if (!ADIOI_Malloc_async_tail) {
  37             ADIOI_Malloc_async_tail = (ADIOI_Malloc_async *)
  38                 ADIOI_Malloc(sizeof(ADIOI_Malloc_async)); 
  39             ADIOI_Malloc_async_head = ADIOI_Malloc_async_tail;
  40             ADIOI_Malloc_async_head->ptr = ADIOI_Async_avail_head;
  41             ADIOI_Malloc_async_head->next = NULL;
  42         }
  43         else {
  44             ADIOI_Malloc_async_tail->next = (ADIOI_Malloc_async *)
  45                 ADIOI_Malloc(sizeof(ADIOI_Malloc_async));
  46             ADIOI_Malloc_async_tail = ADIOI_Malloc_async_tail->next;
  47             ADIOI_Malloc_async_tail->ptr = ADIOI_Async_avail_head;
  48             ADIOI_Malloc_async_tail->next = NULL;
  49         }
  50     }
  51 
  52     ptr = ADIOI_Async_avail_head;
  53     ADIOI_Async_avail_head = ADIOI_Async_avail_head->next;
  54     if (!ADIOI_Async_avail_head) ADIOI_Async_avail_tail = NULL;
  55 
  56     return ptr;
  57 }
  58 
  59 
  60 void ADIOI_Free_async_node(ADIOI_Async_node *node)
  61 {
  62 
  63 
  64     if (!ADIOI_Async_avail_tail)
  65         ADIOI_Async_avail_head = ADIOI_Async_avail_tail = node;
  66     else {
  67         ADIOI_Async_avail_tail->next = node;
  68         ADIOI_Async_avail_tail = node;
  69     }
  70     node->next = NULL;
  71 }
  72 
  73 
  74 void ADIOI_Add_req_to_list(ADIO_Request *request)
  75 {
  76 
  77 
  78     ADIOI_Async_node *curr;
  79 
  80     if (!ADIOI_Async_list_head) {
  81         ADIOI_Async_list_head = ADIOI_Malloc_async_node();
  82         ADIOI_Async_list_head->request = request;
  83         ADIOI_Async_list_head->prev = ADIOI_Async_list_head->next = NULL;
  84         ADIOI_Async_list_tail = ADIOI_Async_list_head;
  85         (*request)->ptr_in_async_list = ADIOI_Async_list_head;
  86     }
  87     else {
  88         curr = ADIOI_Async_list_tail;
  89         curr->next = ADIOI_Malloc_async_node();
  90         ADIOI_Async_list_tail = curr->next;
  91         ADIOI_Async_list_tail->request = request;
  92         ADIOI_Async_list_tail->prev = curr;
  93         ADIOI_Async_list_tail->next = NULL;
  94         (*request)->ptr_in_async_list = ADIOI_Async_list_tail;
  95     }
  96 }
  97         
  98 
  99 
 100 
 101 void ADIOI_Complete_async(int *error_code)
 102 {
 103 
 104 
 105 
 106     ADIO_Status status;
 107     ADIO_Request *request;
 108     ADIOI_Async_node *tmp;
 109     static char myname[] = "ADIOI_Complete_async";
 110 
 111     *error_code = MPI_SUCCESS;
 112 
 113     while (ADIOI_Async_list_head) {
 114         request = ADIOI_Async_list_head->request;
 115         (*request)->queued = -1; 
 116 
 117 
 118 
 119         switch ((*request)->optype) {
 120         case ADIOI_READ:
 121 
 122 
 123             ADIO_ReadComplete(request, &status, error_code);
 124             break;
 125         case ADIOI_WRITE:
 126 
 127 
 128             ADIO_WriteComplete(request, &status, error_code);
 129             break;
 130         default:
 131             
 132             *error_code = MPIO_Err_create_code(MPI_SUCCESS,
 133                                                MPIR_ERR_RECOVERABLE,
 134                                                myname, __LINE__,
 135                                                MPI_ERR_INTERN,
 136                                                "Unknown request optype", 0);
 137             return;
 138             
 139         }
 140         (*request)->queued = 0;  
 141 
 142 
 143         tmp = ADIOI_Async_list_head;
 144         ADIOI_Async_list_head = ADIOI_Async_list_head->next;
 145         ADIOI_Free_async_node(tmp);
 146     }
 147     ADIOI_Async_list_tail = NULL;
 148 }
 149 
 150 
 151 void ADIOI_Del_req_from_list(ADIO_Request *request)
 152 {
 153 
 154 
 155  
 156 
 157     ADIOI_Async_node *curr, *prev, *next;
 158 
 159     curr = (*request)->ptr_in_async_list;
 160     prev = curr->prev;
 161 
 162     if (prev) prev->next = curr->next;
 163     else ADIOI_Async_list_head = curr->next;
 164 
 165     next = curr->next;
 166     if (next) next->prev = prev;
 167     else ADIOI_Async_list_tail = prev;
 168 
 169     ADIOI_Free_async_node(curr);
 170 }