refactor server.h

CMakeLists.txt

@@ -15,7 +15,7 @@ option(LCI_WITH_BENCHMARKS "Build LCI benchmarks" ON)
 option(LCI_WITH_DOC "Build LCI documentation" ON)
 
 set(LCI_SERVER ofi CACHE STRING "Fabric")
-set_property(CACHE LCI_SERVER PROPERTY STRINGS ofi ibv psm2)
+set_property(CACHE LCI_SERVER PROPERTY STRINGS ofi ibv)
 option(LCI_DEBUG "LCI Debug Mode" OFF)
 option(LCI_OPTIMIZE_FOR_NATIVE "Build with -march=native" OFF)
 option(LCI_USE_AVX "Use GCC vector extension for the immediate field" ON)
@@ -52,8 +52,6 @@ if(LCI_SERVER STREQUAL "ofi")
   set(LCI_USE_SERVER_OFI ON)
 elseif(LCI_SERVER STREQUAL "ibv")
   set(LCI_USE_SERVER_IBV ON)
-elseif(LCI_SERVER STREQUAL "psm2")
-  set(LCI_USE_SERVER_PSM ON)
 else()
   message(FATAL_ERROR "Fabric ${LCI_SERVER} not supported")
 endif()

benchmarks/archive/Makefile

@@ -24,11 +24,6 @@ ifeq ($(LC_SERVER), ibv)
 	# LDFLAGS += -L$(HOME)/tcmalloc_sb/lib -ltcmalloc
 endif
 
-ifeq ($(LC_SERVER), psm)
-	CFLAGS += -DLC_USE_SERVER_PSM
-	LDFLAGS += -lpsm2 # -L$(HOME)/libfab/lib -lfabric
-endif
-
 ### FOR TESTING HASH TABLE ###
 #FACEBOOK_INC = -I$(HOME)/facebook/include -I$(HOME)/glog/include -I$(HOME)/folly/folly/double-conversion #-DNDEBUG
 #FACEBOOK_LIB = -L$(HOME)/gflags/lib -lgflags -L$(HOME)/glog/lib -lglog -L$(HOME)/facebook/lib -lfolly -lpthread

liblci.pc

@@ -7,5 +7,4 @@ Name: liblci
 Description: The LCI library
 Version: 0.2.0
 Cflags: -I${includedir}
-Libs: -L${libdir} -llci
-Libs.private: -lpsm2
+Libs: -L${libdir} -llci

src/1sided.c

@@ -9,7 +9,7 @@ LCI_error_t LCI_puts(LCI_endpoint_t ep, LCI_short_t src, int rank,
                  "Only support default remote completion "
                  "(set by LCI_plist_set_default_comp, "
                  "the default value is LCI_UR_CQ)\n");
-  return lc_server_sends(ep->device->server, rank, &src, sizeof(LCI_short_t),
+  return LCIS_post_sends(ep->device->server, rank, &src, sizeof(LCI_short_t),
                          LCII_MAKE_PROTO(ep->gid, LCI_MSG_RDMA_SHORT, tag));
 }
 
@@ -21,7 +21,7 @@ LCI_error_t LCI_putm(LCI_endpoint_t ep, LCI_mbuffer_t mbuffer, int rank,
 //  lc_pk_init(ep, (size > 1024) ? lc_pool_get_local(ep->pkpool) : -1, LC_PROTO_DATA, p);
 //  struct lc_rep* rep = &(ep->rep[rank]);
 //  memcpy(p->data.buffer, src, size);
-//  lc_server_put(ep->server, rep->handle, rep->base, offset, rep->rkey, size, LCII_MAKE_PROTO(ep->gid, LC_PROTO_LONG, meta), p);
+//  LCIS_post_put(ep->server, rep->handle, rep->base, offset, rep->rkey, size, LCII_MAKE_PROTO(ep->gid, LC_PROTO_LONG, meta), p);
   return LCI_ERR_FEATURE_NA;
 }
 
@@ -46,7 +46,7 @@ LCI_error_t LCI_putma(LCI_endpoint_t ep, LCI_mbuffer_t buffer, int rank,
   LCII_initilize_comp_attr(ctx->comp_attr);
   LCII_comp_attr_set_free_packet(ctx->comp_attr, 1);
 
-  LCI_error_t ret = lc_server_send(ep->device->server, rank, packet->data.address, buffer.length,
+  LCI_error_t ret = LCIS_post_send(ep->device->server, rank, packet->data.address, buffer.length,
                                    *(ep->device->heap.segment),
                                    LCII_MAKE_PROTO(ep->gid, LCI_MSG_RDMA_MEDIUM, tag), ctx);
   if (ret == LCI_ERR_RETRY) {
@@ -73,7 +73,7 @@ LCI_error_t LCI_putmna(LCI_endpoint_t ep, LCI_mbuffer_t buffer, int rank,
   LCII_initilize_comp_attr(ctx->comp_attr);
   LCII_comp_attr_set_free_packet(ctx->comp_attr, 1);
 
-  LCI_error_t ret = lc_server_send(ep->device->server, rank, packet->data.address, buffer.length,
+  LCI_error_t ret = LCIS_post_send(ep->device->server, rank, packet->data.address, buffer.length,
                                    *(ep->device->heap.segment),
                                    LCII_MAKE_PROTO(ep->gid, LCI_MSG_RDMA_MEDIUM, tag), ctx);
   if (ret == LCI_ERR_RETRY) {
@@ -128,7 +128,7 @@ LCI_error_t LCI_putla(LCI_endpoint_t ep, LCI_lbuffer_t buffer,
   LCM_DBG_Log_default(LCM_LOG_DEBUG, "send rts: type %d sctx %p size %lu\n",
               packet->data.rts.msg_type, (void*) packet->data.rts.send_ctx,
               packet->data.rts.size);
-  LCI_error_t ret = lc_server_send(ep->device->server, rank, packet->data.address,
+  LCI_error_t ret = LCIS_post_send(ep->device->server, rank, packet->data.address,
                                    sizeof(struct packet_rts), *(ep->device->heap.segment),
                                    LCII_MAKE_PROTO(ep->gid, LCI_MSG_RTS, tag), rts_ctx);
   if (ret == LCI_ERR_RETRY) {
@@ -202,7 +202,7 @@ LCI_error_t LCI_putva(LCI_endpoint_t ep, LCI_iovec_t iovec,
               (void*) packet->data.rts.send_ctx, packet->data.rts.count,
               packet->data.rts.piggy_back_size);
   size_t length = (uintptr_t) &packet->data.rts.size_p[iovec.count] - (uintptr_t) packet->data.address + iovec.piggy_back.length;
-  LCI_error_t ret = lc_server_send(ep->device->server, rank, packet->data.address,
+  LCI_error_t ret = LCIS_post_send(ep->device->server, rank, packet->data.address,
                                    length, *(ep->device->heap.segment),
                                    LCII_MAKE_PROTO(ep->gid, LCI_MSG_RTS, tag), rts_ctx);
   if (ret == LCI_ERR_RETRY) {

src/CMakeLists.txt

@@ -25,7 +25,6 @@ if(LCI_USE_SERVER_OFI)
   target_sources_relative(LCI PRIVATE server_ofi.c)
 elseif(LCI_USE_SERVER_IBV)
   target_sources_relative(LCI PRIVATE server_ibv.c)
-elseif(LCI_USE_SERVER_PSM)
 endif()
 
 add_subdirectory(dreg)

src/device.c

@@ -5,7 +5,7 @@ LCI_error_t LCI_device_init(LCI_device_t * device_ptr)
   LCI_device_t device = LCIU_malloc(sizeof(struct LCI_device_s));
   *device_ptr = device;
   device->recv_posted = 0;
-  lc_server_init(device, &device->server);
+  LCIS_init(device, &device->server);
 
   LCII_mt_init(&device->mt, 0);
   LCM_archive_init(&(device->ctx_archive), 16);
@@ -47,7 +47,7 @@ LCI_error_t LCI_device_free(LCI_device_t *device_ptr)
   LCIU_spinlock_fina(&device->bq_spinlock);
   LCI_lbuffer_free(device->heap);
   lc_pool_destroy(device->pkpool);
-  lc_server_finalize(device->server);
+  LCIS_finalize(device->server);
   LCIU_free(device);
   *device_ptr = NULL;
   return LCI_OK;
@@ -62,17 +62,17 @@ static inline LCI_error_t LCII_progress_bq(LCI_device_t device) {
   LCII_bq_entry_t *entry = LCII_bq_top(&device->bq);
   if (entry != NULL) {
     if (entry->bqe_type == LCII_BQ_SENDS) {
-      ret = lc_server_sends(entry->s, entry->rank, entry->buf, entry->size,
+      ret = LCIS_post_sends(entry->s, entry->rank, entry->buf, entry->size,
                            entry->meta);
     } else if (entry->bqe_type == LCII_BQ_SEND) {
-      ret = lc_server_send(entry->s, entry->rank, entry->buf, entry->size,
+      ret = LCIS_post_send(entry->s, entry->rank, entry->buf, entry->size,
                            entry->mr, entry->meta, entry->ctx);
     } else if (entry->bqe_type == LCII_BQ_PUT) {
-      ret = lc_server_put(entry->s, entry->rank, entry->buf, entry->size,
+      ret = LCIS_post_put(entry->s, entry->rank, entry->buf, entry->size,
                           entry->mr, entry->base, entry->offset, entry->rkey,
                           entry->ctx);
     } else if (entry->bqe_type == LCII_BQ_PUTIMM) {
-      ret = lc_server_putImm(entry->s, entry->rank, entry->buf, entry->size,
+      ret = LCIS_post_putImm(entry->s, entry->rank, entry->buf, entry->size,
                           entry->mr, entry->base, entry->offset, entry->rkey,
                           entry->meta, entry->ctx);
     } else {
@@ -92,7 +92,7 @@ LCI_error_t LCI_progress(LCI_device_t device)
 {
   int ret = LCI_ERR_RETRY;
   LCIS_cq_entry_t entry[LCI_CQ_MAX_POLL];
-  int count = LCID_poll_cq(device->server, entry);
+  int count = LCIS_poll_cq(device->server, entry);
   LCM_DBG_Assert(count >= 0, "ibv_poll_cq returns error %d\n", count);
   if (count > 0) {
     ret = LCI_OK;
@@ -102,20 +102,20 @@ LCI_error_t LCI_progress(LCI_device_t device)
       // two-sided recv.
       LCM_DBG_Log_default(LCM_LOG_DEBUG, "complete recv: packet %p rank %d length %lu imm_data %u\n",
                   entry[i].ctx, entry[i].rank, entry[i].length, entry[i].imm_data);
-      lc_serve_recv((lc_packet*)entry[i].ctx, entry[i].rank, entry[i].length, entry[i].imm_data);
+      LCIS_serve_recv((lc_packet*)entry[i].ctx, entry[i].rank, entry[i].length, entry[i].imm_data);
       --device->recv_posted;
     } else if (entry[i].opcode == LCII_OP_RDMA_WRITE) {
       LCM_DBG_Log_default(LCM_LOG_DEBUG, "complete write: imm_data %u\n", entry[i].imm_data);
       if (entry[i].ctx != NULL) {
         LCII_free_packet((lc_packet*)entry[i].ctx);
         --device->recv_posted;
       }
-      lc_serve_rdma(entry[i].imm_data);
+      LCIS_serve_rdma(entry[i].imm_data);
     } else {
       // entry[i].opcode == LCII_OP_SEND
       LCM_DBG_Log_default(LCM_LOG_DEBUG, "complete send: address %p\n", (void*) entry[i].ctx);
       if (entry[i].ctx == NULL) continue;
-      lc_serve_send((void*)entry[i].ctx);
+      LCIS_serve_send((void*)entry[i].ctx);
     }
   }
   // make progress on backlog queue
@@ -135,7 +135,7 @@ LCI_error_t LCI_progress(LCI_device_t device)
       break;
     }
     packet->context.poolid = lc_pool_get_local(device->pkpool);
-    lc_server_post_recv(device->server, packet->data.address, LCI_MEDIUM_SIZE,
+    LCIS_post_recv(device->server, packet->data.address, LCI_MEDIUM_SIZE,
                         *(device->heap.segment), packet);
     ++device->recv_posted;
   }

src/include/lcii_config.h.in

@@ -5,7 +5,6 @@
 
 #cmakedefine LCI_USE_SERVER_OFI
 #cmakedefine LCI_USE_SERVER_IBV
-#cmakedefine LCI_USE_SERVER_PSM
 
 #cmakedefine LCI_SERVER_HAS_SYNC
 #cmakedefine LCI_SERVER_HAS_CQ

src/include/lcii_rdv.h

@@ -2,12 +2,12 @@
 #define LCI_LCII_RDV_H
 
 // wrapper for send and put
-static inline void lc_server_sends_bq(LCII_backlog_queue_t *bq_p,
+static inline void LCIS_post_sends_bq(LCII_backlog_queue_t *bq_p,
                                      LCIU_spinlock_t *bq_spinlock_p,
                                      LCIS_server_t s, int rank, void* buf,
                                      size_t size, LCIS_meta_t meta) {
   if (LCII_bq_is_empty(bq_p)) {
-    LCI_error_t ret = lc_server_sends(s, rank, buf, size, meta);
+    LCI_error_t ret = LCIS_post_sends(s, rank, buf, size, meta);
     if (ret == LCI_OK) return;
     else {
       LCM_Assert(ret == LCI_ERR_RETRY, "fatal error!\n");
@@ -27,14 +27,14 @@ static inline void lc_server_sends_bq(LCII_backlog_queue_t *bq_p,
   LCIU_release_spinlock(bq_spinlock_p);
 }
 
-static inline void lc_server_send_bq(LCII_backlog_queue_t *bq_p,
+static inline void LCIS_post_send_bq(LCII_backlog_queue_t *bq_p,
                                      LCIU_spinlock_t *bq_spinlock_p,
                                      LCIS_server_t s, int rank, void* buf,
                                      size_t size, LCIS_mr_t mr,
                                      LCIS_meta_t meta,
                                      void* ctx) {
   if (LCII_bq_is_empty(bq_p)) {
-    LCI_error_t ret = lc_server_send(s, rank, buf, size, mr, meta, ctx);
+    LCI_error_t ret = LCIS_post_send(s, rank, buf, size, mr, meta, ctx);
     if (ret == LCI_OK) return;
     else {
       LCM_Assert(ret == LCI_ERR_RETRY, "fatal error!\n");
@@ -55,14 +55,14 @@ static inline void lc_server_send_bq(LCII_backlog_queue_t *bq_p,
   LCIU_release_spinlock(bq_spinlock_p);
 }
 
-static inline void lc_server_put_bq(LCII_backlog_queue_t *bq_p,
+static inline void LCIS_post_put_bq(LCII_backlog_queue_t *bq_p,
                                     LCIU_spinlock_t *bq_spinlock_p,
                                     LCIS_server_t s, int rank, void* buf,
                                     size_t size, LCIS_mr_t mr, uintptr_t base,
                                     uint32_t offset,LCIS_rkey_t rkey,
                                     void* ctx) {
   if (LCII_bq_is_empty(bq_p)) {
-    LCI_error_t ret = lc_server_put(s, rank, buf, size, mr, base, offset, rkey, ctx);
+    LCI_error_t ret = LCIS_post_put(s, rank, buf, size, mr, base, offset, rkey, ctx);
     if (ret == LCI_OK) return;
     else {
       LCM_Assert(ret == LCI_ERR_RETRY, "fatal error!\n");
@@ -85,14 +85,14 @@ static inline void lc_server_put_bq(LCII_backlog_queue_t *bq_p,
   LCIU_release_spinlock(bq_spinlock_p);
 }
 
-static inline void lc_server_putImm_bq(LCII_backlog_queue_t *bq_p,
+static inline void LCIS_post_putImm_bq(LCII_backlog_queue_t *bq_p,
                                     LCIU_spinlock_t *bq_spinlock_p,
                                     LCIS_server_t s, int rank, void* buf,
                                     size_t size, LCIS_mr_t mr, uintptr_t base,
                                     uint32_t offset,LCIS_rkey_t rkey,
                                     LCIS_meta_t meta, void* ctx) {
   if (LCII_bq_is_empty(bq_p)) {
-    LCI_error_t ret = lc_server_putImm(s, rank, buf, size, mr, base, offset, rkey, meta, ctx);
+    LCI_error_t ret = LCIS_post_putImm(s, rank, buf, size, mr, base, offset, rkey, meta, ctx);
     if (ret == LCI_OK) return;
     else {
       LCM_Assert(ret == LCI_ERR_RETRY, "fatal error!\n");
@@ -151,9 +151,9 @@ static inline void LCII_handle_2sided_rts(LCI_endpoint_t ep, lc_packet* packet,
   packet->data.rtr.remote_addr_base = (uintptr_t) rdv_ctx->data.lbuffer.segment->address;
   packet->data.rtr.remote_addr_offset =
       (uintptr_t) rdv_ctx->data.lbuffer.address - packet->data.rtr.remote_addr_base;
-  packet->data.rtr.rkey = lc_server_rma_rkey(*(rdv_ctx->data.lbuffer.segment));
+  packet->data.rtr.rkey = LCIS_rma_rkey(*(rdv_ctx->data.lbuffer.segment));
 
-  lc_server_send_bq(ep->bq_p, ep->bq_spinlock_p,
+  LCIS_post_send_bq(ep->bq_p, ep->bq_spinlock_p,
                     ep->device->server, rdv_ctx->rank, packet->data.address,
                     sizeof(struct packet_rtr), *(ep->device->heap.segment),
                     LCII_MAKE_PROTO(ep->gid, LCI_MSG_RTR, 0), rtr_ctx);
@@ -171,7 +171,7 @@ static inline void LCII_handle_2sided_rtr(LCI_endpoint_t ep, lc_packet* packet)
   } else {
     LCM_DBG_Assert(LCII_comp_attr_get_dereg(ctx->comp_attr) == 0, "\n");
   }
-  lc_server_putImm_bq(ep->bq_p, ep->bq_spinlock_p, ep->device->server, ctx->rank,
+  LCIS_post_putImm_bq(ep->bq_p, ep->bq_spinlock_p, ep->device->server, ctx->rank,
                    ctx->data.lbuffer.address, ctx->data.lbuffer.length,
                    *(ctx->data.lbuffer.segment),
                    packet->data.rtr.remote_addr_base, packet->data.rtr.remote_addr_offset,
@@ -223,14 +223,14 @@ static inline void LCII_handle_1sided_rts(LCI_endpoint_t ep, lc_packet* packet,
   packet->data.rtr.remote_addr_base = (uintptr_t) rdv_ctx->data.lbuffer.segment->address;
   packet->data.rtr.remote_addr_offset =
       (uintptr_t) rdv_ctx->data.lbuffer.address - packet->data.rtr.remote_addr_base;
-  packet->data.rtr.rkey = lc_server_rma_rkey(*(rdv_ctx->data.lbuffer.segment));
+  packet->data.rtr.rkey = LCIS_rma_rkey(*(rdv_ctx->data.lbuffer.segment));
 
   LCM_DBG_Log_default(LCM_LOG_DEBUG, "send rtr: type %d sctx %p base %p offset %d "
               "rkey %lu rctx_key %u\n", packet->data.rtr.msg_type,
               (void*) packet->data.rtr.send_ctx, (void*) packet->data.rtr.remote_addr_base,
               packet->data.rtr.remote_addr_offset, packet->data.rtr.rkey,
               packet->data.rtr.recv_ctx_key);
-  lc_server_send_bq(ep->bq_p, ep->bq_spinlock_p,
+  LCIS_post_send_bq(ep->bq_p, ep->bq_spinlock_p,
                     ep->device->server, rdv_ctx->rank, packet->data.address,
                     sizeof(struct packet_rtr), *(ep->device->heap.segment),
                     LCII_MAKE_PROTO(ep->gid, LCI_MSG_RTR, 0), rtr_ctx);
@@ -247,7 +247,7 @@ static inline void LCII_handle_1sided_rtr(LCI_endpoint_t ep, lc_packet* packet)
   } else {
     LCM_DBG_Assert(LCII_comp_attr_get_dereg(ctx->comp_attr) == 0, "\n");
   }
-  lc_server_putImm_bq(ep->bq_p, ep->bq_spinlock_p, ep->device->server, ctx->rank,
+  LCIS_post_putImm_bq(ep->bq_p, ep->bq_spinlock_p, ep->device->server, ctx->rank,
                    ctx->data.lbuffer.address, ctx->data.lbuffer.length,
                    *(ctx->data.lbuffer.segment),
                    packet->data.rtr.remote_addr_base, packet->data.rtr.remote_addr_offset,
@@ -307,14 +307,14 @@ static inline void LCII_handle_iovec_rts(LCI_endpoint_t ep, lc_packet* packet,
         (uintptr_t) rdv_ctx->data.iovec.lbuffers[i].address -
         packet->data.rtr.remote_iovecs_p[i].remote_addr_base;
     packet->data.rtr.remote_iovecs_p[i].rkey =
-        lc_server_rma_rkey(*(rdv_ctx->data.iovec.lbuffers[i].segment));
+        LCIS_rma_rkey(*(rdv_ctx->data.iovec.lbuffers[i].segment));
   }
 
   LCM_DBG_Log_default(LCM_LOG_DEBUG, "send rtr: type %d sctx %p count %d rctx %p\n",
               packet->data.rtr.msg_type, (void*) packet->data.rtr.send_ctx,
               rdv_ctx->data.iovec.count, (void*) packet->data.rtr.recv_ctx);
   size_t length = (uintptr_t) &packet->data.rtr.remote_iovecs_p[rdv_ctx->data.iovec.count] - (uintptr_t) packet->data.address;
-  lc_server_send_bq(ep->bq_p, ep->bq_spinlock_p,
+  LCIS_post_send_bq(ep->bq_p, ep->bq_spinlock_p,
                     ep->device->server, rdv_ctx->rank, packet->data.address,
                     length, *(ep->device->heap.segment),
                     LCII_MAKE_PROTO(ep->gid, LCI_MSG_RTR, 0), rtr_ctx);
@@ -341,7 +341,7 @@ static inline void LCII_handle_iovec_rtr(LCI_endpoint_t ep, lc_packet* packet)
     } else {
       LCM_DBG_Assert(LCII_comp_attr_get_dereg(ectx->comp_attr) == 0, "\n");
     }
-    lc_server_put_bq(ep->bq_p, ep->bq_spinlock_p, ep->device->server, ctx->rank,
+    LCIS_post_put_bq(ep->bq_p, ep->bq_spinlock_p, ep->device->server, ctx->rank,
                      ctx->data.iovec.lbuffers[i].address, ctx->data.iovec.lbuffers[i].length,
                      *(ctx->data.iovec.lbuffers[i].segment),
                      packet->data.rtr.remote_iovecs_p[i].remote_addr_base,
@@ -366,7 +366,7 @@ static inline void LCII_handle_iovec_put_comp(LCII_extended_context_t *ectx)
     }
   }
   LCM_DBG_Log_default(LCM_LOG_DEBUG, "send FIN: rctx %p\n", (void*) ectx->recv_ctx);
-  lc_server_sends_bq(ectx->ep->bq_p, ectx->ep->bq_spinlock_p,
+  LCIS_post_sends_bq(ectx->ep->bq_p, ectx->ep->bq_spinlock_p,
                      ectx->ep->device->server, ctx->rank, &ectx->recv_ctx,
                   sizeof(ectx->recv_ctx),
                   LCII_MAKE_PROTO(ectx->ep->gid, LCI_MSG_FIN, 0));

src/include/proto.h

@@ -58,7 +58,7 @@ static inline void lc_ce_dispatch(LCII_context_t *ctx)
   }
 }
 
-static inline void lc_serve_recv(void* p,
+static inline void LCIS_serve_recv(void* p,
                                  int src_rank, size_t length,
                                  uint32_t imm_data)
 {
@@ -199,7 +199,7 @@ static inline void lc_serve_recv(void* p,
   }
 }
 
-static inline void lc_serve_rdma(uint32_t imm_data)
+static inline void LCIS_serve_rdma(uint32_t imm_data)
 {
   LCII_proto_t proto = imm_data;
   LCI_endpoint_t ep = LCI_ENDPOINTS[PROTO_GET_RGID(proto)];
@@ -221,7 +221,7 @@ static inline void lc_serve_rdma(uint32_t imm_data)
 }
 
 // local completion
-static inline void lc_serve_send(void* raw_ctx)
+static inline void LCIS_serve_send(void* raw_ctx)
 {
   LCII_context_t *ctx = raw_ctx;
   lc_ce_dispatch(ctx);