Line data    Source code

       1             : #include "netio/netio.h"
       2             : 
       3             : #include <string.h>
       4             : #include <stdio.h>
       5             : #include "log.h"
       6             : 
       7             : #if defined DEBUG || defined DEBUG_MR
       8             : #define __FILENAME__ (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__)
       9             : #define log_dbg(...) log_log(LOG_DEBUG, __FILENAME__, __LINE__, __VA_ARGS__)
      10             : #define log_trc(...) log_log(LOG_TRACE, __FILENAME__, __LINE__, __VA_ARGS__)
      11             : #else
      12             : #define log_dbg(...)
      13             : #define log_trc(...)
      14             : #endif
      15             : 
      16             : 
      17             : static void
      18         328 : init_bufferstack(struct netio_buffer_stack* stack, unsigned num, size_t bufsize)
      19             : {
      20         328 :   stack->buffers = malloc(num*sizeof(struct netio_buffer*));
      21         328 :   stack->buffer_addresses = malloc(num*sizeof(struct netio_buffer*));
      22         328 :   stack->num_buffers = num;
      23         328 :   stack->available_buffers = num;
      24       82552 :   for(unsigned int i=0; i<num; i++) {
      25       82224 :     stack->buffers[i] = malloc(sizeof(struct netio_buffer));
      26       82224 :     stack->buffers[i]->data = malloc(bufsize);
      27       82224 :     stack->buffers[i]->size = bufsize;
      28       82224 :     stack->buffers[i]->mr = NULL;
      29       82224 :     stack->buffer_addresses[i] = stack->buffers[i];
      30             :   }
      31             :   
      32         328 : }
      33             : 
      34             : 
      35      103520 : void netio_register_recv_buffer(struct netio_recv_socket* socket, struct netio_buffer* buf, uint64_t  flags)
      36             : {
      37      103520 :   log_trc("registering recv buffer number: %d", socket->reg_mr);
      38      103520 :   uint64_t access = FI_RECV;
      39      103520 :   int ret = 0;
      40      103520 :   if((ret = fi_mr_reg(socket->domain, buf->data, buf->size, access, 0, socket->req_key++, 0, &buf->mr, NULL)))
      41             :   {
      42           0 :     log_fatal("Failed to register recv buffer (key %lu) failed. Error %d: %s",socket->req_key, ret, fi_strerror(-ret));
      43             :     //exit(2);
      44             :   }
      45           0 :   if(ret==0){
      46      103520 :     if (socket->reg_mr >= NETIO_DOMAIN_MAX_MR){
      47           0 :       log_fatal("Trying to register recv buffer number %u. MR array size %lu.", socket->reg_mr, NETIO_DOMAIN_MAX_MR);
      48           0 :       exit(1);
      49             :     }
      50      103520 :     socket->mr[socket->reg_mr]=&buf->mr->fid;
      51      103520 :     socket->reg_mr+=1;
      52             :   }
      53      103520 : }
      54             : 
      55             : 
      56       82911 : void netio_register_send_buffer(struct netio_send_socket* socket, struct netio_buffer* buf, uint64_t flags)
      57             : {
      58       82911 :   uint64_t access = FI_SEND;
      59       82911 :   int ret = 0;
      60       82911 :   if((ret = fi_mr_reg(socket->domain->domain, buf->data, buf->size, access, 0, socket->domain->req_key++, 0, &buf->mr, NULL)))
      61             :   {
      62           0 :     log_fatal("Failed to register send buffer failed. Error %d: %s.", ret, fi_strerror(-ret));
      63           0 :     exit(2);
      64             :   }
      65       82911 :   if(ret==0){
      66       82911 :     if (socket->domain->reg_mr >= NETIO_DOMAIN_MAX_MR){
      67           0 :       log_fatal("Trying to register send buffer number %u. MR array size %lu.", socket->domain->reg_mr, NETIO_DOMAIN_MAX_MR);
      68           0 :       exit(1);
      69             :     }
      70       82911 :     socket->domain->mr[socket->domain->reg_mr]=&buf->mr->fid;
      71       82911 :     socket->domain->reg_mr+=1;
      72             :   }
      73       82911 : }
      74             : 
      75             : 
      76             : void
      77         328 : netio_bufferstack_send_init(struct netio_buffer_stack* stack, struct netio_send_socket* socket, size_t num, size_t bufsize, uint64_t flags)
      78             : {
      79         328 :   log_dbg("Initializing memory: %d pages", num);
      80         328 :   init_bufferstack(stack, num, bufsize);
      81         328 :   socket->domain->reg_mr=0;
      82       82552 :   for(unsigned i=0; i<num; i++) {
      83       82224 :     netio_register_send_buffer(socket, stack->buffers[i], flags);
      84             :   }
      85         328 : }
      86             : 
      87             : void
      88         310 : netio_bufferstack_close(struct netio_buffer_stack* stack, size_t num)
      89             : {
      90         310 :   log_dbg("Freeing memory: %d pages", num);
      91       78406 :   for(unsigned int i=0; i < num; i++) {
      92       78096 :     if(stack->buffers == NULL){log_warn("Buffer already released."); return;}
      93       78096 :     free(stack->buffer_addresses[i]->data);
      94       78096 :     free(stack->buffer_addresses[i]);
      95             :   }
      96         310 :   free(stack->buffers);
      97         310 :   free(stack->buffer_addresses);
      98         310 :   stack->buffers = NULL;
      99             : }
     100             : 
     101             : 
     102             : int
     103     1515764 : netio_bufferstack_pop(struct netio_buffer_stack* stack, struct netio_buffer** buffer)
     104             : {
     105     1515764 :   log_trc("pop: available %lu", stack->available_buffers);
     106     1515764 :   if(stack->available_buffers > 0) {
     107     1087083 :     stack->available_buffers--;
     108     1087083 :     *buffer = stack->buffers[stack->available_buffers];
     109     1087083 :     return 0;
     110             :   } else {
     111             :     return 1;
     112             :   }
     113             : }
     114             : 
     115             : 
     116             : int
     117     1084072 : netio_bufferstack_push(struct netio_buffer_stack* stack, struct netio_buffer* buffer)
     118             : {
     119     1084072 :   log_trc("push: available %lu", stack->available_buffers);
     120     1084072 :   if(stack->available_buffers < stack->num_buffers) {
     121     1084072 :     stack->buffers[stack->available_buffers] = buffer;
     122     1084072 :     stack->available_buffers++;
     123     1084072 :     return 0;
     124             :   } else {
     125             :     return 1;
     126             :   }
     127             : }