massive changes to switch from bake-bulk => bake

Makefile.am

@@ -13,7 +13,7 @@ CLEANFILES = $(bin_SCRIPTS)
 MAINTAINERCLEANFILES =
 EXTRA_DIST =
 BUILT_SOURCES =
-include_HEADERS = include/bake-bulk.h include/bake-bulk-client.h include/bake-bulk-server.h
+include_HEADERS = include/bake.h include/bake-client.h include/bake-server.h
 TESTS_ENVIRONMENT =
 
 EXTRA_DIST += \
@@ -27,15 +27,16 @@ AM_LIBS =
 
 AM_CXXFLAGS = $(AM_CFLAGS)
 
-lib_LTLIBRARIES = src/libbake-bulk-client.la src/libbake-bulk-server.la
-src_libbake_bulk_client_la_SOURCES =
-src_libbake_bulk_server_la_SOURCES =
+lib_LTLIBRARIES = src/libbake-client.la src/libbake-server.la
+src_libbake_client_la_SOURCES =
+src_libbake_server_la_SOURCES =
 
-LDADD = src/libbake-bulk-client.la
+LDADD = src/libbake-client.la
 
 pkgconfigdir = $(libdir)/pkgconfig
-pkgconfig_DATA = maint/bake-bulk-client.pc \
-		 maint/bake-bulk-server.pc
+pkgconfig_DATA = \
+ maint/bake-client.pc \
+ maint/bake-server.pc
 
 
 include Make.rules

configure.ac

@@ -80,6 +80,6 @@ LIBS="$UUID_LIBS $LIBS"
 CPPFLAGS="$UUID_CFLAGS $CPPFLAGS"
 CFLAGS="$UUID_CFLAGS $CFLAGS"
 
-AC_CONFIG_FILES([Makefile maint/bake-bulk-client.pc maint/bake-bulk-server.pc])
+AC_CONFIG_FILES([Makefile maint/bake-client.pc maint/bake-server.pc])
 AC_OUTPUT
  

include/bake-bulk-client.h → include/bake-client.h

@@ -4,19 +4,19 @@
  * See COPYRIGHT in top-level directory.
  */
 
-#ifndef __BAKE_BULK_CLIENT_H
-#define __BAKE_BULK_CLIENT_H
+#ifndef __BAKE_CLIENT_H
+#define __BAKE_CLIENT_H
 
 #include <stdint.h>
 #include "margo.h"
-#include "bake-bulk.h"
+#include "bake.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 /**
- * Obtain identifying information for a bake target through the provided
+ * Obtains identifying information for a BAKE target through the provided
  * remote mercury address.
  *
  * @param [in] mid margo instance
@@ -30,25 +30,25 @@ int bake_probe_instance(
     bake_target_id_t *bti);
   
 /**
- * Create a bounded-size bulk data region.  The resulting region can be
- * written using bulk write operations, and can be persisted (once writes are
- * complete) with a a bulk persist operation.  The region is not valid for
- * read access until persisted.
+ * Creates a bounded-size BAKE data region.  The resulting region can be
+ * written using BAKE write operations, and can be persisted (once writes
+ * are complete) with a a BAKE persist operation.  The region is not valid
+ * for read access until persisted.
  *
  * @param [in] bti BAKE target identifier
  * @param [in] region_size size of region to be created
  * @param [out] rid identifier for new region
  * @returns 0 on success, -1 on failure
  */
-int bake_bulk_create(
+int bake_create(
     bake_target_id_t bti,
     uint64_t region_size,
-    bake_bulk_region_id_t *rid);
+    bake_region_id_t *rid);
  
 /**
- * Writes into a region that was previously created with bake_bulk_create().
+ * Writes into a BAKE region that was previously created with bake_create().
  * Result is not guaranteed to be persistent until explicit
- * bake_bulk_persist() call.
+ * bake_persist() call.
  *
  * Results are undefined if multiple writers (from same process or different
  * processes) perform overlapping writes.
@@ -60,15 +60,15 @@ int bake_bulk_create(
  * @param [in] buf_size size of local memory buffer to write
  * @returns 0 on success, -1 on failure
  */
-int bake_bulk_write(
+int bake_write(
     bake_target_id_t bti,
-    bake_bulk_region_id_t rid,
+    bake_region_id_t rid,
     uint64_t region_offset,
     void const *buf,
     uint64_t buf_size);
 
 /**
- * Write data into a previously created BAKE region like bake_bulk_write(),
+ * Writes data into a previously created BAKE region like bake_write(),
  * except the write is performed on behalf of some remote entity.
  *
  * @param [in] bti BAKE target identifier
@@ -80,9 +80,9 @@ int bake_bulk_write(
  * @param [in] size size to write from remote bulk handle
  * @returns 0 on success, -1 on failure
  */
-int bake_bulk_proxy_write(
+int bake_proxy_write(
     bake_target_id_t bti,
-    bake_bulk_region_id_t rid,
+    bake_region_id_t rid,
     uint64_t region_offset,
     hg_bulk_t remote_bulk,
     uint64_t remote_offset,
@@ -90,32 +90,32 @@ int bake_bulk_proxy_write(
     uint64_t size);
 
 /**
- * Persist a bulk region. The region is considered immutable at this point 
+ * Persists a BAKE region. The region is considered immutable at this point 
  * and reads may be performed on the region.
  *
  * @param [in] bti BAKE target identifier
  * @param [in] rid identifier for region
  * @returns 0 on success, -1 on failure
  */
-int bake_bulk_persist(
+int bake_persist(
     bake_target_id_t bti,
-    bake_bulk_region_id_t rid);
-  
+    bake_region_id_t rid);
+
 /**
- * Check the size of an existing region. 
+ * Checks the size of an existing BAKE region. 
  *
  * @param [in] bti BAKE target identifier
  * @param [in] rid identifier for region
- * @param [out] size sizes of region
+ * @param [out] size size of region
  * @returns 0 on success, -1 on failure
  */
-int bake_bulk_get_size(
+int bake_get_size(
     bake_target_id_t bti,
-    bake_bulk_region_id_t rid,
-    uint64_t *region_size);
+    bake_region_id_t rid,
+    uint64_t *size);
 
 /**
- * Reads from a region that was previously persisted with bake_bulk_persist().
+ * Reads from a BAKE region that was previously persisted with bake_persist().
  *
  * NOTE: for now at least, this call does not support "short" reads.  It
  * either succeeds in reading the requested size or not.
@@ -127,15 +127,15 @@ int bake_bulk_get_size(
  * @param [in] buf_size size of local memory buffer to read into
  * @returns 0 on success, -1 on failure
  */
-int bake_bulk_read(
+int bake_read(
     bake_target_id_t bti,
-    bake_bulk_region_id_t rid,
+    bake_region_id_t rid,
     uint64_t region_offset,
     void *buf,
     uint64_t buf_size);
 
 /**
- * Read data from a previously persisted BAKE region like bake_bulk_read(),
+ * Reads data from a previously persisted BAKE region like bake_read(),
  * except the read is performed on behalf of some remote entity.
  *
  * @param [in] bti BAKE target identifier
@@ -147,9 +147,9 @@ int bake_bulk_read(
  * @param [in] size size to read to remote bulk handle
  * @returns 0 on success, -1 on failure
  */
-int bake_bulk_proxy_read(
+int bake_proxy_read(
     bake_target_id_t bti,
-    bake_bulk_region_id_t rid,
+    bake_region_id_t rid,
     uint64_t region_offset,
     hg_bulk_t remote_bulk,
     uint64_t remote_offset,
@@ -157,8 +157,8 @@ int bake_bulk_proxy_read(
     uint64_t size);
 
 /**
- * Release local resources associated with access to a target; does not
- * modify the target in any way.
+ * Releases local resources associated with access to a BAKE target;
+ * does not modify the target in any way.
  *
  * @param [in] bti BAKE target_identifier
  */
@@ -166,28 +166,25 @@ void bake_release_instance(
     bake_target_id_t bti);
 
 /**
- * Utility function to shut down a remote service
+ * Shuts down a remote BAKE service (given a target ID).
  *
- * @param [in] bti Bake target identifier
+ * @param [in] bti BAKE target identifier
  * @returns 0 on success, -1 on fialure 
  */
-int bake_shutdown_service(bake_target_id_t bti);
-
-/* NOTE: code below is a copy of the bulk portion of the proposed BAKE API.
- * Commented out for now but leaving it in place for reference
- */
+int bake_shutdown_service(
+    bake_target_id_t bti);
 
 /**
- * Issue a no-op 
+ * Issues a BAKE no-op operation.
  *
  * @param [in] bti BAKE target identifier
  * @returns 0 on success, -1 on failure
  */
-int bake_bulk_noop(
+int bake_noop(
     bake_target_id_t bti);
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif /* __BAKE_BULK__CLIENT_H */
+#endif /* __BAKE_CLIENT_H */

include/bake-bulk-server.h → include/bake-server.h

@@ -4,23 +4,24 @@
  * See COPYRIGHT in top-level directory.
  */
 
-#ifndef __BAKE_BULK_SERVER_H
-#define __BAKE_BULK_SERVER_H
+#ifndef __BAKE_SERVER_H
+#define __BAKE_SERVER_H
 
 #include <margo.h>
 #include <libpmemobj.h>
-#include "bake-bulk.h"
+#include "bake.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 /**
- * Creates a bake-bulk pool to use for backend PMEM storage.
- * NOTE: this function must be called on a pool before the pool
- *       can be passed to 'bake_server_init'
+ * Creates a BAKE pool to use for backend PMEM storage.
+ * 
+ * NOTE: This function must be called on a pool before the pool
+ * can be passed to 'bake_server_init'.
  *
- * @param[in] pool_name path to pmem backend file
+ * @param[in] pool_name path to PMEM backend file
  * @param[in] pool_size size of the created pool
  * @param[in] pool_mode mode of the created pool
  * @returns 0 on success, -1 otherwise
@@ -31,10 +32,10 @@ int bake_server_makepool(
     mode_t pool_mode);
 
 /**
- * Register a bake server instance for a given Margo instance.
+ * Initializes a BAKE server instance.
  *
  * @param[in] mid Margo instance identifier
- * @param[in] pool_name path to pmem backend file
+ * @param[in] pool_name path to PMEM backend file
  * @returns 0 on success, -1 otherwise
  */
 int bake_server_init(
@@ -42,16 +43,20 @@ int bake_server_init(
     const char *pool_name);
 
 /**
- * Shuts down a bake server and frees all associated resources.
+ * Shuts down a BAKE server and frees all associated resources.
  */
-void bake_server_shutdown(void);
+void bake_server_shutdown(
+    void);
 
 /**
- * Suspends the server process until some other entity calls bake_server_shutdown.
+ * Suspends a BAKE server process until some other entity calls
+ * bake_server_shutdown().
  */
-void bake_server_wait_for_shutdown(void);
+void bake_server_wait_for_shutdown(
+    void);
 
 #ifdef __cplusplus
 }
 #endif
-#endif /* __BAKE_BULK_SERVER_H */
+
+#endif /* __BAKE_SERVER_H */

include/bake-bulk.h → include/bake.h

@@ -4,8 +4,8 @@
  * See COPYRIGHT in top-level directory.
  */
 
-#ifndef __BAKE_BULK_H
-#define __BAKE_BULK_H
+#ifndef __BAKE_H
+#define __BAKE_H
 
 #include <uuid/uuid.h>
 #include <stdint.h>
@@ -23,16 +23,16 @@ typedef struct {
 } bake_target_id_t;
 
 /**
- * Persistent, opaque identifier for a bulk region within a BAKE target.
+ * Persistent, opaque identifier for a region within a BAKE target.
  */
-#define BAKE_BULK_REGION_ID_DATA_SIZE 24
+#define BAKE_REGION_ID_DATA_SIZE 24
 typedef struct {
     uint32_t type;
-    char data[BAKE_BULK_REGION_ID_DATA_SIZE];
-} bake_bulk_region_id_t;
+    char data[BAKE_REGION_ID_DATA_SIZE];
+} bake_region_id_t;
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif /* __BAKE_BULK_H */
+#endif /* __BAKE_H */

src/Makefile.subdir

-src_libbake_bulk_client_la_SOURCES += \
- src/bake-bulk-client.c
+src_libbake_client_la_SOURCES += \
+ src/bake-client.c
 
-src_libbake_bulk_server_la_SOURCES += \
- src/bake-bulk-server.c
+src_libbake_server_la_SOURCES += \
+ src/bake-server.c
 
-src_bake_bulk_server_daemon_LDADD = src/libbake-bulk-server.la
-src_bake_bulk_mkpool_LDADD = src/libbake-bulk-server.la
+src_bake_server_daemon_LDADD = src/libbake-server.la
+src_bake_mkpool_LDADD = src/libbake-server.la
 
 bin_PROGRAMS += \
- src/bake-bulk-server-daemon \
- src/bake-bulk-mkpool \
- src/bb-shutdown \
- src/bb-copy-to \
- src/bb-copy-from \
- src/bb-latency-bench
+ src/bake-server-daemon \
+ src/bake-mkpool \
+ src/bake-shutdown \
+ src/bake-copy-to \
+ src/bake-copy-from \
+ src/bake-latency-bench

src/bake-bulk-client.c → src/bake-client.c

@@ -5,34 +5,34 @@
  */
 
 #include <assert.h>
-#include <bake-bulk-client.h>
 #include <margo.h>
+#include <bake-client.h>
 #include "uthash.h"
-#include "bake-bulk-rpc.h"
+#include "bake-rpc.h"
 
-#define BAKE_BULK_EAGER_LIMIT 2048
+#define BAKE_EAGER_LIMIT 2048
 
 /* Refers to a single Margo initialization, for now this is shared by
- * all remote targets.  In the future we probably need to support multiple in
- * case we run atop more than one transport at a time.
+ * all remote BAKE targets.  In the future we probably need to support
+ * multiple in case we run atop more than one transport at a time.
  */
 struct bake_margo_instance
 {
     margo_instance_id mid;  
 
-    hg_id_t bake_bulk_probe_id;
-    hg_id_t bake_bulk_shutdown_id; 
-    hg_id_t bake_bulk_create_id;
-    hg_id_t bake_bulk_eager_write_id;
-    hg_id_t bake_bulk_eager_read_id;
-    hg_id_t bake_bulk_write_id;
-    hg_id_t bake_bulk_persist_id;
-    hg_id_t bake_bulk_get_size_id;
-    hg_id_t bake_bulk_read_id;
-    hg_id_t bake_bulk_noop_id;
+    hg_id_t bake_probe_id;
+    hg_id_t bake_shutdown_id; 
+    hg_id_t bake_create_id;
+    hg_id_t bake_eager_write_id;
+    hg_id_t bake_eager_read_id;
+    hg_id_t bake_write_id;
+    hg_id_t bake_persist_id;
+    hg_id_t bake_get_size_id;
+    hg_id_t bake_read_id;
+    hg_id_t bake_noop_id;
 };
 
-/* Refers to an instance connected to a specific target */
+/* Refers to an instance connected to a specific BAKE target */
 struct bake_instance
 {
     bake_target_id_t bti;   /* persistent identifier for this target */
@@ -56,61 +56,45 @@ static int bake_margo_instance_init(margo_instance_id mid)
     g_margo_inst.mid = mid;
 
     /* register RPCs */
-    g_margo_inst.bake_bulk_probe_id = 
+    g_margo_inst.bake_probe_id = 
         MARGO_REGISTER(g_margo_inst.mid, 
-        "bake_bulk_probe_rpc", void, bake_bulk_probe_out_t, 
+        "bake_probe_rpc", void, bake_probe_out_t, 
         NULL);
-    g_margo_inst.bake_bulk_shutdown_id = 
+    g_margo_inst.bake_shutdown_id = 
         MARGO_REGISTER(g_margo_inst.mid, 
-        "bake_bulk_shutdown_rpc", void, void, 
+        "bake_shutdown_rpc", void, void, 
         NULL);
-    g_margo_inst.bake_bulk_create_id = 
+    g_margo_inst.bake_create_id = 
         MARGO_REGISTER(g_margo_inst.mid, 
-        "bake_bulk_create_rpc", 
-        bake_bulk_create_in_t,
-        bake_bulk_create_out_t,
+        "bake_create_rpc", bake_create_in_t, bake_create_out_t,
         NULL);
-    g_margo_inst.bake_bulk_write_id = 
+    g_margo_inst.bake_write_id = 
         MARGO_REGISTER(g_margo_inst.mid, 
-        "bake_bulk_write_rpc", 
-        bake_bulk_write_in_t,
-        bake_bulk_write_out_t,
+        "bake_write_rpc", bake_write_in_t, bake_write_out_t,
         NULL);
-    g_margo_inst.bake_bulk_eager_write_id = 
+    g_margo_inst.bake_eager_write_id = 
         MARGO_REGISTER(g_margo_inst.mid, 
-        "bake_bulk_eager_write_rpc", 
-        bake_bulk_eager_write_in_t,
-        bake_bulk_eager_write_out_t,
+        "bake_eager_write_rpc", bake_eager_write_in_t, bake_eager_write_out_t,
         NULL);
-    g_margo_inst.bake_bulk_eager_read_id = 
+    g_margo_inst.bake_eager_read_id = 
         MARGO_REGISTER(g_margo_inst.mid, 
-        "bake_bulk_eager_read_rpc", 
-        bake_bulk_eager_read_in_t,
-        bake_bulk_eager_read_out_t,
+        "bake_eager_read_rpc", bake_eager_read_in_t, bake_eager_read_out_t,
         NULL);
-    g_margo_inst.bake_bulk_persist_id = 
+    g_margo_inst.bake_persist_id = 
         MARGO_REGISTER(g_margo_inst.mid, 
-        "bake_bulk_persist_rpc", 
-        bake_bulk_persist_in_t,
-        bake_bulk_persist_out_t,
+        "bake_persist_rpc", bake_persist_in_t, bake_persist_out_t,
         NULL);
-    g_margo_inst.bake_bulk_get_size_id = 
+    g_margo_inst.bake_get_size_id = 
         MARGO_REGISTER(g_margo_inst.mid, 
-        "bake_bulk_get_size_rpc", 
-        bake_bulk_get_size_in_t,
-        bake_bulk_get_size_out_t,
+        "bake_get_size_rpc", bake_get_size_in_t, bake_get_size_out_t,
         NULL);
-    g_margo_inst.bake_bulk_read_id = 
+    g_margo_inst.bake_read_id = 
         MARGO_REGISTER(g_margo_inst.mid, 
-        "bake_bulk_read_rpc", 
-        bake_bulk_read_in_t,
-        bake_bulk_read_out_t,
+        "bake_read_rpc", bake_read_in_t, bake_read_out_t,
         NULL);
-    g_margo_inst.bake_bulk_noop_id = 
+    g_margo_inst.bake_noop_id = 
         MARGO_REGISTER(g_margo_inst.mid, 
-        "bake_bulk_noop_rpc", 
-        void,
-        void,
+        "bake_noop_rpc", void, void,
         NULL);
 
     return(0);
@@ -123,7 +107,7 @@ int bake_probe_instance(
 {
     hg_return_t hret;
     int ret;
-    bake_bulk_probe_out_t out;
+    bake_probe_out_t out;
     hg_handle_t handle;
     struct bake_instance *new_instance;
 
@@ -144,7 +128,7 @@ int bake_probe_instance(
 
     /* create handle */
     hret = margo_create(g_margo_inst.mid, new_instance->dest, 
-        g_margo_inst.bake_bulk_probe_id, &handle);
+        g_margo_inst.bake_probe_id, &handle);
     if(hret != HG_SUCCESS)
     {
         margo_addr_free(g_margo_inst.mid, new_instance->dest);
@@ -218,7 +202,7 @@ int bake_shutdown_service(bake_target_id_t bti)
         return(-1);
 
     hret = margo_create(g_margo_inst.mid, instance->dest, 
-        g_margo_inst.bake_bulk_shutdown_id, &handle);
+        g_margo_inst.bake_shutdown_id, &handle);
     if(hret != HG_SUCCESS)
         return(-1);
 
@@ -233,17 +217,17 @@ int bake_shutdown_service(bake_target_id_t bti)
     return(0);
 }
 
-static int bake_bulk_eager_write(
+static int bake_eager_write(
     bake_target_id_t bti,
-    bake_bulk_region_id_t rid,
+    bake_region_id_t rid,
     uint64_t region_offset,
     void const *buf,
     uint64_t buf_size)
 {
     hg_return_t hret;
     hg_handle_t handle;
-    bake_bulk_eager_write_in_t in;
-    bake_bulk_eager_write_out_t out;
+    bake_eager_write_in_t in;
+    bake_eager_write_out_t out;
     int ret;
     struct bake_instance *instance = NULL;
 
@@ -258,7 +242,7 @@ static int bake_bulk_eager_write(
     in.buffer = (char*)buf;
   
     hret = margo_create(g_margo_inst.mid, instance->dest, 
-        g_margo_inst.bake_bulk_eager_write_id, &handle);
+        g_margo_inst.bake_eager_write_id, &handle);
     if(hret != HG_SUCCESS)
         return(-1);
 
@@ -284,22 +268,22 @@ static int bake_bulk_eager_write(
     return(ret);
 }
 
-int bake_bulk_write(
+int bake_write(
     bake_target_id_t bti,
-    bake_bulk_region_id_t rid,
+    bake_region_id_t rid,
     uint64_t region_offset,
     void const *buf,
     uint64_t buf_size)
 {
     hg_return_t hret;
     hg_handle_t handle;
-    bake_bulk_write_in_t in;
-    bake_bulk_write_out_t out;
+    bake_write_in_t in;
+    bake_write_out_t out;
     int ret;
     struct bake_instance *instance = NULL;
 
-    if(buf_size <= BAKE_BULK_EAGER_LIMIT)
-        return(bake_bulk_eager_write(bti, rid, region_offset, buf, buf_size));
+    if(buf_size <= BAKE_EAGER_LIMIT)
+        return(bake_eager_write(bti, rid, region_offset, buf, buf_size));
 
     HASH_FIND(hh, instance_hash, &bti, sizeof(bti), instance);
     if(!instance)
@@ -318,7 +302,7 @@ int bake_bulk_write(
         return(-1);
    
     hret = margo_create(g_margo_inst.mid, instance->dest, 
-        g_margo_inst.bake_bulk_write_id, &handle);
+        g_margo_inst.bake_write_id, &handle);
     if(hret != HG_SUCCESS)
     {
         margo_bulk_free(in.bulk_handle);
@@ -349,9 +333,9 @@ int bake_bulk_write(
     return(ret);
 }
 
-int bake_bulk_proxy_write(
+int bake_proxy_write(
     bake_target_id_t bti,
-    bake_bulk_region_id_t rid,
+    bake_region_id_t rid,
     uint64_t region_offset,
     hg_bulk_t remote_bulk,
     uint64_t remote_offset,
@@ -360,8 +344,8 @@ int bake_bulk_proxy_write(
 {
     hg_return_t hret;
     hg_handle_t handle;
-    bake_bulk_write_in_t in;
-    bake_bulk_write_out_t out;
+    bake_write_in_t in;
+    bake_write_out_t out;
     struct bake_instance *instance = NULL;
     int ret;
 
@@ -378,7 +362,7 @@ int bake_bulk_proxy_write(
     in.remote_addr_str = (char*)remote_addr;
 
     hret = margo_create(g_margo_inst.mid, instance->dest,
-        g_margo_inst.bake_bulk_write_id, &handle);
+        g_margo_inst.bake_write_id, &handle);
     if(hret != HG_SUCCESS)
         return(-1);
 
@@ -403,15 +387,15 @@ int bake_bulk_proxy_write(
     return(ret);
 }
 
-int bake_bulk_create(
+int bake_create(