.. _program_listing_file_memory_registration.c:

Program Listing for File memory_registration.c
==============================================

|exhale_lsh| :ref:`Return to documentation for file <file_memory_registration.c>` (``memory_registration.c``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   #include "netio/netio.h"
   
   #include <string.h>
   #include <stdio.h>
   #include "log.h"
   
   #if defined DEBUG || defined DEBUG_MR
   #define __FILENAME__ (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__)
   #define log_dbg(...) log_log(LOG_DEBUG, __FILENAME__, __LINE__, __VA_ARGS__)
   #define log_trc(...) log_log(LOG_TRACE, __FILENAME__, __LINE__, __VA_ARGS__)
   #else
   #define log_dbg(...)
   #define log_trc(...)
   #endif
   
   
   static void
   init_bufferstack(struct netio_buffer_stack* stack, unsigned num, size_t bufsize)
   {
     stack->buffers = malloc(num*sizeof(struct netio_buffer*));
     stack->buffer_addresses = malloc(num*sizeof(struct netio_buffer*));
     stack->num_buffers = num;
     stack->available_buffers = num;
     for(unsigned int i=0; i<num; i++) {
       stack->buffers[i] = malloc(sizeof(struct netio_buffer));
       stack->buffers[i]->data = malloc(bufsize);
       stack->buffers[i]->size = bufsize;
       stack->buffers[i]->mr = NULL;
       stack->buffer_addresses[i] = stack->buffers[i];
     }
   
   }
   
   
   void netio_register_recv_buffer(struct netio_recv_socket* socket, struct netio_buffer* buf, uint64_t  flags)
   {
     if (socket->tcp_fi_mode != NETIO_MODE_LIBFABRIC) {
       return;
     }
   
     log_trc("registering recv buffer number: %d", socket->reg_mr);
     uint64_t access = FI_RECV;
     int ret = 0;
     if((ret = fi_mr_reg(socket->domain, buf->data, buf->size, access, 0, socket->req_key++, 0, &buf->mr, NULL)))
     {
       log_fatal("Failed to register recv buffer (key %lu) failed. Error %d: %s",socket->req_key, ret, fi_strerror(-ret));
       //exit(2);
     }
     if(ret==0){
       if (socket->reg_mr >= NETIO_DOMAIN_MAX_MR){
         log_fatal("Trying to register recv buffer number %u. MR array size %lu.", socket->reg_mr, NETIO_DOMAIN_MAX_MR);
         exit(1);
       }
       socket->mr[socket->reg_mr]=&buf->mr->fid;
       socket->reg_mr+=1;
     }
   }
   
   
   void netio_register_send_buffer(struct netio_send_socket* socket, struct netio_buffer* buf, uint64_t flags)
   {
     if (socket->tcp_fi_mode != NETIO_MODE_LIBFABRIC) {
       return;
     }
   
     uint64_t access = FI_SEND;
     int ret = 0;
     if((ret = fi_mr_reg(socket->domain->domain, buf->data, buf->size, access, 0, socket->domain->req_key++, 0, &buf->mr, NULL)))
     {
       log_fatal("Failed to register send buffer failed. Error %d: %s.", ret, fi_strerror(-ret));
       exit(2);
     }
     if(ret==0){
       if (socket->domain->reg_mr >= NETIO_DOMAIN_MAX_MR){
         log_fatal("Trying to register send buffer number %u. MR array size %lu.", socket->domain->reg_mr, NETIO_DOMAIN_MAX_MR);
         exit(1);
       }
       socket->domain->mr[socket->domain->reg_mr]=&buf->mr->fid;
       socket->domain->reg_mr+=1;
     }
   }
   
   
   void
   netio_bufferstack_send_init(struct netio_buffer_stack* stack, struct netio_send_socket* socket, size_t num, size_t bufsize, uint64_t flags)
   {
     log_dbg("Initializing memory: %d pages", num);
     init_bufferstack(stack, num, bufsize);
     if (socket->tcp_fi_mode==NETIO_MODE_LIBFABRIC) {
       socket->domain->reg_mr=0;
       for(unsigned i=0; i<num; i++) {
         netio_register_send_buffer(socket, stack->buffers[i], flags);
       }
     }
   }
   
   void
   netio_bufferstack_close(struct netio_buffer_stack* stack, size_t num)
   {
     log_dbg("Freeing memory: %d pages", num);
     for(unsigned int i=0; i < num; i++) {
       if(stack->buffers == NULL){log_warn("Buffer already released."); return;}
       free(stack->buffer_addresses[i]->data);
       free(stack->buffer_addresses[i]);
     }
     free(stack->buffers);
     free(stack->buffer_addresses);
     stack->buffers = NULL;
   }
   
   
   int
   netio_bufferstack_pop(struct netio_buffer_stack* stack, struct netio_buffer** buffer)
   {
     log_trc("pop: available %lu", stack->available_buffers);
     if(stack->available_buffers > 0) {
       stack->available_buffers--;
       *buffer = stack->buffers[stack->available_buffers];
       return 0;
     } else {
       return 1;
     }
   }
   
   
   int
   netio_bufferstack_push(struct netio_buffer_stack* stack, struct netio_buffer* buffer)
   {
     log_trc("push: available %lu", stack->available_buffers);
     if(stack->available_buffers < stack->num_buffers) {
       stack->buffers[stack->available_buffers] = buffer;
       stack->available_buffers++;
       return 0;
     } else {
       return 1;
     }
   }