This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "aesop Repository".
The branch, master has been updated
via 0f22e7e3c4153388575f8756ae9ec203e1b5d42e (commit)
from 513de654559cf1a43539dac0abf8674825302b6b (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
commit 0f22e7e3c4153388575f8756ae9ec203e1b5d42e
Author: Kevin Harms <harms(a)alcf.anl.gov>
Date: Tue Mar 20 17:15:26 2012 -0500
Initial module for SSM, based on r944 of nebula repo
-----------------------------------------------------------------------
Summary of changes:
configure.ac | 2 +
src/ssm/aessm.ae | 614 +++++++++++++++++++++++++++++++++++++++++++++
src/ssm/aessm.hae | 31 +++
src/ssm/module.mk.in | 8 +
src/ssm/test/module.mk.in | 10 +
src/ssm/test/ssmget.ae | 122 +++++++++
src/ssm/test/ssmmsg.ae | 113 +++++++++
src/ssm/test/ssmping.ae | 82 ++++++
src/ssm/test/ssmput.ae | 120 +++++++++
9 files changed, 1102 insertions(+), 0 deletions(-)
create mode 100644 src/ssm/aessm.ae
create mode 100644 src/ssm/aessm.hae
create mode 100644 src/ssm/module.mk.in
create mode 100644 src/ssm/test/module.mk.in
create mode 100644 src/ssm/test/ssmget.ae
create mode 100644 src/ssm/test/ssmmsg.ae
create mode 100644 src/ssm/test/ssmping.ae
create mode 100644 src/ssm/test/ssmput.ae
Diff of changes:
diff --git a/configure.ac b/configure.ac
index d5db947..7309f82 100644
--- a/configure.ac
+++ b/configure.ac
@@ -316,6 +316,8 @@ parser/module.mk
parser/tests/blocking/module.mk
src/socket/module.mk
src/socket/test/module.mk
+src/ssm/module.mk
+src/ssm/test/module.mk
doc/module.mk
])
diff --git a/src/ssm/aessm.ae b/src/ssm/aessm.ae
new file mode 100644
index 0000000..4ff90e6
--- /dev/null
+++ b/src/ssm/aessm.ae
@@ -0,0 +1,614 @@
+#include "aesop.h"
+#include "ae-error.h"
+#include "resources/resourcebuilder/resourcebuilder.hae"
+#include "aessm.hae"
+
+#include "ssm.h"
+#include "ssmdef.h"
+#include "ssmp_unix_tcp.h"
+#include "ssmp_localmem.h"
+
+#include <pthread.h>
+#include <sys/time.h>
+
+/*
+ * Struct: aessm_cb_s
+ * Members:
+ * slot1 - holds RB slot for initial call
+ * slot2 - holds RB slot for cancellation call
+ * evt - results of SSM event structure
+ * completion_count - expected number of local completions
+ * completion_error - number of local completions that were errors.
+ * Comments:
+ * This structure holds data needed to track the state of the blocking
+ * operation and is used in the <aessm_callback>.
+ */
+typedef struct aessm_cb_s
+{
+ rb_slot_t slot1;
+ rb_slot_t slot2;
+ ssm_evt_t evt;
+ uint64_t completion_expected;
+ uint64_t completion_count;
+ uint64_t completion_error;
+} aessm_cb_t;
+
+/*
+ * Function: aessm_callback
+ * Generic callback used from all SSM calls generated from within
+ * the aessm module.
+ *
+ * Parameters:
+ * cbdata - data supplied in ssm_cb()
+ * evdata - data supplied from SSM event.
+ *
+ * Returns:
+ * void
+ */
+static void aessm_callback (void *cbdata, void *evdata)
+{
+ ssm_evt_p evtp;
+ aessm_cb_t *data;
+
+ evtp = (ssm_evt_p) evdata;
+ data = (aessm_cb_t *) cbdata;
+
+//printf ("cb: op=0x%x owner=%d result=%d\n",
+// evtp->op, evtp->owner, evtp->result);
+
+ if (evtp->op == SSM_OP_UNLINK)
+ {
+ data->evt = *evtp;
+ rb_slot_complete(&data->slot1);
+ rb_slot_complete(&data->slot2);
+ }
+ else if ((evtp->op == SSM_OP_PUT) ||
+ (evtp->op == SSM_OP_GET) ||
+ (evtp->op == SSM_OP_MSG) ||
+ (evtp->op == SSM_OP_PING))
+ {
+ data->evt = *evtp;
+ switch (evtp->result)
+ {
+ case SSM_RESULT_NO_MATCH:
+ case SSM_RESULT_CANCELLED:
+ case SSM_RESULT_TIMEOUT:
+ case SSM_RESULT_NETWORK_FAILURE:
+ data->completion_error += 1;
+ case SSM_RESULT_SUCCESS:
+ data->completion_count += 1;
+ if (evtp->owner == SSM_OWNER_REMOTE)
+ {
+ if (data->completion_count >= data->completion_expected)
+ {
+ rb_slot_complete(&data->slot1);
+ rb_slot_complete(&data->slot2);
+ }
+ }
+ else
+ {
+ rb_slot_complete(&data->slot1);
+ rb_slot_complete(&data->slot2);
+ }
+ break;
+ case SSM_RESULT_INIT:
+ default:
+ break;
+ }
+ }
+ else
+ {
+ // unknown operation
+ assert(0);
+ }
+ return;
+}
+
+/*
+ * Function: aessm_link
+ * Wraps the ssm_link call. All aessm operations must use <aessm_link>.
+ *
+ * Parameters:
+ * id - SSM instance id.
+ * flags - ssm_link flags.
+ * match_bits - ssm_link match bits.
+ * mask_bits - ssm_link mask bits.
+ * data_iovec - buffer to associate with match or data movement operation.
+ * pos - position to insert into match list.
+ * anchor - reference to us for pos.
+ * count - expected number of local completions.
+ * me_id - generated match entry.
+ *
+ * Returns:
+ * AE_SUCCESS - on success
+ * AE_ERR_SYSTEM - on failure
+ * me - The generated match entry is returned in this parameter.
+ *
+ * Comments:
+ * A standard callback is associated with all ssm operations.
+ * This callback handles waking up the correct blocking functions.
+ */
+int aessm_link (ssm_id ssm,
+ ssm_flags16 flags,
+ ssm_match_bits match_bits,
+ ssm_match_bits mask_bits,
+ ssm_iovec_p data_iovec,
+ ssm_me_pos pos,
+ ssm_me_id anchor,
+ uint64_t count,
+ ssm_me_id *me_id)
+{
+ aessm_cb_t *cb_dt;
+ ssm_cb_id cb_id;
+
+ cb_dt = malloc(sizeof(aessm_cb_t));
+ if (cb_dt == NULL)
+ {
+ return AE_ERR_SYSTEM;
+ }
+
+ memset(cb_dt, 0, sizeof(aessm_cb_t));
+ rb_slot_initialize(&cb_dt->slot1);
+ rb_slot_initialize(&cb_dt->slot2);
+ cb_dt->completion_expected = count;
+
+ cb_id = ssm_cb (aessm_callback, cb_dt, SSM_CB_NO_FLAGS);
+ if (cb_id == NULL)
+ {
+ return AE_ERR_SYSTEM;
+ }
+
+ *me_id = ssm_link (ssm, flags, match_bits, mask_bits,
+ data_iovec, pos, anchor, cb_id);
+ if (*me_id == SSM_ME_NONE)
+ {
+ return AE_ERR_SYSTEM;
+ }
+
+ return AE_SUCCESS;
+}
+
+/*
+ * Function: aessm_unlink
+ * Wraps the ssm_unlink fuction.
+ *
+ * Parameters:
+ * me_id - the match entry created by an <aessm_link> call.
+ * evt_id - detailed results of the operation. Can be NULL.
+ *
+ * Returns:
+ * AE_SUCCESS - if the call completed successfully.
+ * AE_ERR_CANCELLED - if the call was cancelled.
+ * evt - filled with results of completion callback if not NULL.
+ */
+__blocking int aessm_unlink(ssm_me_id me_id, ssm_evt_p evt_id)
+{
+ aessm_cb_t *cb_dt;
+ ssm_cb_id cb_id;
+ int rc;
+
+ cb_id = ssm_me_cb(me_id);
+ assert(cb_id);
+
+ cb_dt = ssm_cb_data(cb_id);
+ assert(cb_dt);
+
+ assert(rb_slot_reinitialize(&cb_dt->slot1));
+ assert(rb_slot_reinitialize(&cb_dt->slot2));
+
+ ssm_unlink(me_id);
+
+ rc = rb_slot_capture(&cb_dt->slot1);
+ if (rc == AE_ERR_CANCELLED)
+ {
+ rc = rb_slot_capture(&cb_dt->slot2);
+ assert(rc == AE_SUCCESS);
+ }
+ else
+ {
+ rc = rb_slot_capture(&cb_dt->slot2);
+ }
+
+ if (evt_id)
+ {
+ *evt_id = cb_dt->evt;
+ }
+
+ rb_slot_destroy(&cb_dt->slot1);
+ rb_slot_destroy(&cb_dt->slot2);
+
+ free(cb_id);
+ free(cb_dt);
+
+ return rc;
+}
+
+/*
+ * Function: aessm_put
+ * Wraps ssm_put.
+ *
+ * Parameters:
+ * me_id - The match entry that describes the memory to put.
+ * raddr_id - the address of the remote target.
+ * evt_id - detailed results of the operation. Can be NULL.
+ *
+ * Returns:
+ * AE_SUCCESS - if the operation was successful.
+ * AE_ERR_CANCELLED - if the operation was cancelled.
+ * AE_ERR_* - other error conditions.
+ */
+__blocking int aessm_put (ssm_me_id me_id,
+ ssm_addr_id raddr_id,
+ ssm_evt_p evt_id)
+{
+ aessm_cb_t *cb_dt;
+ ssm_tx_id tx_id;
+ ssm_cb_id cb_id;
+ ssm_id ssm;
+ int rc;
+
+ cb_id = ssm_me_cb(me_id);
+ assert(cb_id);
+
+ cb_dt = ssm_cb_data(cb_id);
+ assert(cb_dt);
+
+ assert(rb_slot_reinitialize(&cb_dt->slot1));
+ assert(rb_slot_reinitialize(&cb_dt->slot2));
+
+ tx_id = ssm_put (me_id, raddr_id);
+ if (tx_id == SSM_TX_NONE)
+ {
+ rb_slot_clear(&cb_dt->slot1);
+ rb_slot_clear(&cb_dt->slot2);
+ return AE_ERR_SYSTEM;
+ }
+
+ rc = rb_slot_capture(&cb_dt->slot1);
+ if (rc == AE_ERR_CANCELLED)
+ {
+ ssm = ssm_me_owner(me_id);
+ (void) ssm_cancel(ssm, tx_id);
+ rc = rb_slot_capture(&cb_dt->slot2);
+ assert(rc == AE_SUCCESS);
+ }
+ else
+ {
+ rc = rb_slot_capture(&cb_dt->slot2);
+ }
+
+ if (evt_id)
+ {
+ *evt_id = cb_dt->evt;
+ }
+
+ rb_slot_destroy(&cb_dt->slot1);
+ rb_slot_destroy(&cb_dt->slot2);
+
+ return rc;
+}
+
+/*
+ * Function: aessm_get
+ * Wraps ssm_get.
+ *
+ * Parameters:
+ * me_id - The match entry that describes the memory to get.
+ * raddr_id - the address of the remote target.
+ * evt - detailed results of the operation. Can be NULL.
+ *
+ * Returns:
+ * AE_SUCCESS - if the operation was successful.
+ * AE_ERR_CANCELLED - if the operation was cancelled.
+ * AE_ERR_* - other error conditions.
+ */
+__blocking int aessm_get (ssm_me_id me_id,
+ ssm_addr_id raddr_id,
+ ssm_evt_p evt_id)
+{
+ aessm_cb_t *cb_dt;
+ ssm_tx_id tx_id;
+ ssm_cb_id cb_id;
+ ssm_id ssm;
+ int rc;
+
+ cb_id = ssm_me_cb(me_id);
+ assert(cb_id);
+
+ cb_dt = ssm_cb_data(cb_id);
+ assert(cb_dt);
+
+ assert(rb_slot_reinitialize(&cb_dt->slot1));
+ assert(rb_slot_reinitialize(&cb_dt->slot2));
+
+ tx_id = ssm_get (me_id, raddr_id);
+ if (tx_id == SSM_TX_NONE)
+ {
+ rb_slot_clear(&cb_dt->slot1);
+ rb_slot_clear(&cb_dt->slot2);
+ return AE_ERR_SYSTEM;
+ }
+
+ rc = rb_slot_capture(&cb_dt->slot1);
+ if (rc == AE_ERR_CANCELLED)
+ {
+ ssm = ssm_me_owner(me_id);
+ (void) ssm_cancel(ssm, tx_id);
+ rc = rb_slot_capture(&cb_dt->slot2);
+ assert(rc == AE_SUCCESS);
+ }
+ else
+ {
+ rc = rb_slot_capture(&cb_dt->slot2);
+ }
+
+ if (evt_id)
+ {
+ *evt_id = cb_dt->evt;
+ }
+
+ rb_slot_destroy(&cb_dt->slot1);
+ rb_slot_destroy(&cb_dt->slot2);
+
+ return rc;
+}
+
+/*
+ * Function: aessm_msg
+ * Wraps ssm_msg.
+ *
+ * Parameters:
+ * me_id - The match entry that describes the remote host to send to.
+ * raddr_id - the address of the remote target.
+ * info_a - 64bit piece of data to pass to other end.
+ * info_b - 64bit piece of data to pass to other end.
+ * evt - detailed results of the operation. Can be NULL.
+ *
+ * Returns:
+ * AE_SUCCESS - if the operation was successful.
+ * AE_ERR_CANCELLED - if the operation was cancelled.
+ * AE_ERR_* - other error conditions.
+ */
+__blocking int aessm_msg (ssm_me_id me_id,
+ ssm_addr_id raddr_id,
+ uint64_t info_a,
+ uint64_t info_b,
+ ssm_evt_p evt_id)
+{
+ aessm_cb_t *cb_dt;
+ ssm_tx_id tx_id;
+ ssm_cb_id cb_id;
+ ssm_id ssm;
+ int rc;
+
+ cb_id = ssm_me_cb(me_id);
+ assert(cb_id);
+
+ cb_dt = ssm_cb_data(cb_id);
+ assert(cb_dt);
+
+ assert(rb_slot_reinitialize(&cb_dt->slot1));
+ assert(rb_slot_reinitialize(&cb_dt->slot2));
+
+ // right now it is assumed this can't fail.
+ (void) ssm_msg (me_id, raddr_id, info_a, info_b);
+
+ rc = rb_slot_capture(&cb_dt->slot1);
+ if (rc == AE_ERR_CANCELLED)
+ {
+ ssm = ssm_me_owner(me_id);
+ (void) ssm_cancel(ssm, tx_id);
+ rc = rb_slot_capture(&cb_dt->slot2);
+ assert(rc == AE_SUCCESS);
+ }
+ else
+ {
+ rc = rb_slot_capture(&cb_dt->slot2);
+ }
+
+ if (evt_id)
+ {
+ *evt_id = cb_dt->evt;
+ }
+
+ rb_slot_destroy(&cb_dt->slot1);
+ rb_slot_destroy(&cb_dt->slot2);
+
+ return rc;
+}
+
+/*
+ * Function: aessm_ping
+ * Wraps ssm_ping.
+ *
+ * Parameters:
+ * me_id - The match entry that describes the host to ping.
+ * raddr_id - the address of the remote target.
+ * evt - detailed results of the operation. Can be NULL.
+ *
+ * Returns:
+ * AE_SUCCESS - if the operation was successful.
+ * AE_ERR_CANCELLED - if the operation was cancelled.
+ * AE_ERR_* - other error conditions.
+ */
+__blocking int aessm_ping (ssm_me_id me_id,
+ ssm_addr_id raddr_id,
+ ssm_evt_p evt_id)
+{
+ aessm_cb_t *cb_dt;
+ ssm_tx_id tx_id;
+ ssm_cb_id cb_id;
+ ssm_id ssm;
+ int rc;
+
+ cb_id = ssm_me_cb(me_id);
+ assert(cb_id);
+
+ cb_dt = ssm_cb_data(cb_id);
+ assert(cb_dt);
+
+ assert(rb_slot_reinitialize(&cb_dt->slot1));
+ assert(rb_slot_reinitialize(&cb_dt->slot2));
+
+ // right now, assume this can not fail.
+ (void) ssm_ping (me_id, raddr_id);
+
+ rc = rb_slot_capture(&cb_dt->slot1);
+ if (rc == AE_ERR_CANCELLED)
+ {
+ ssm = ssm_me_owner(me_id);
+ (void) ssm_cancel(ssm, tx_id);
+ rc = rb_slot_capture(&cb_dt->slot2);
+ assert(rc == AE_SUCCESS);
+ }
+ else
+ {
+ rc = rb_slot_capture(&cb_dt->slot2);
+ }
+
+ if (evt_id)
+ {
+ *evt_id = cb_dt->evt;
+ }
+
+ rb_slot_destroy(&cb_dt->slot1);
+ rb_slot_destroy(&cb_dt->slot2);
+
+ return rc;
+}
+
+/*
+ * Function: aessm_wait
+ * This function waits for a given number of local completions on the
+ * match entry and then returns.
+ *
+ * Parameters:
+ * me - match entry generated by <aessm_link>.
+ *
+ * Returns:
+ * AE_SUCCESS - if the call was successful.
+ * AE_ERR_CANCELLED - if tthe call was cancelled.
+ * AE_ERR_* - if other error.
+ */
+__blocking int aessm_wait (ssm_me_id me_id, ssm_evt_p evt_id)
+{
+ aessm_cb_t *cb_dt;
+ ssm_id ssm;
+ ssm_cb_id cb_id;
+ int rc;
+
+ cb_id = ssm_me_cb (me_id);
+ assert(cb_id);
+
+ cb_dt = ssm_cb_data(cb_id);
+ assert(cb_dt);
+
+ assert(rb_slot_reinitialize(&cb_dt->slot1));
+ assert(rb_slot_reinitialize(&cb_dt->slot2));
+
+ rc = rb_slot_capture(&cb_dt->slot1);
+ if (rc == AE_ERR_CANCELLED)
+ {
+ rc = rb_slot_capture(&cb_dt->slot2);
+ assert(rc == AE_SUCCESS);
+ }
+ else
+ {
+ rc = rb_slot_capture(&cb_dt->slot2);
+ }
+
+ if (evt_id)
+ {
+ *evt_id = cb_dt->evt;
+ }
+
+ rb_slot_destroy(&cb_dt->slot1);
+ rb_slot_destroy(&cb_dt->slot2);
+
+ return rc;
+}
+
+/*
+ * Function: aessm_poll
+ * This function calls ssm_wait in a loop from a dedicated thread.
+ *
+ * Parameters:
+ * arg - ssm instance to drive.
+ *
+ * Returns:
+ * nothing.
+ */
+static void * aessm_poll (void *arg)
+{
+ struct timeval tv;
+ aessm_t *aessm_id;
+ int rc;
+
+ aessm_id = (aessm_t*) arg;
+
+ tv.tv_sec = 0;
+ tv.tv_usec = 500;
+
+ while (aessm_id->state)
+ {
+ rc = ssm_wait(aessm_id->ssm, &tv);
+ assert(rc >= 0);
+ }
+
+ return NULL;
+}
+
+/*
+ * Function: aessm_initialize
+ * Initialize an SSM context, spawns a thread to push ssm_poll.
+ *
+ * Parameters:
+ * aessm_id - container for aessm data
+ *
+ * Returns:
+ * AE_SUCCESS - on success
+ */
+int aessm_initialize (aessm_t *aessm_id)
+{
+ ssmp_localmem_init_id id;
+ ssm_net_proc np;
+ ssm_addr_id la;
+ ssm_flags16 fl;
+ int rc;
+
+ /* this would be handled through configurable init parameters */
+ id = ssmp_localmem_init();
+ np = ssmp_localmem_proc;
+ la = ssmp_localmem_addr(id);
+ fl = 0;
+
+ aessm_id->laddr_id = la;
+ aessm_id->ssm = ssm_start(np, la, fl, NULL);
+ aessm_id->state = 1;
+
+ rc = pthread_create(&aessm_id->thread_id, NULL, aessm_poll, aessm_id);
+ assert(rc == 0);
+
+ return AE_SUCCESS;
+}
+
+/*
+ * Function: aessm_finalize
+ * Finalize an SSM context, joins thread created by <aessm_initailize>
+ *
+ * Parameters:
+ * aessm_id - container for aessm data
+ *
+ * Returns:
+ * AE_SUCCESS - on success
+ */
+int aessm_finalize (aessm_t *aessm_id)
+{
+ aessm_id->state = 0;
+ pthread_join(aessm_id->thread_id, NULL);
+
+ ssm_stop(aessm_id->ssm);
+ SSM_DELETE(aessm_id->laddr_id);
+
+ return AE_SUCCESS;
+}
diff --git a/src/ssm/aessm.hae b/src/ssm/aessm.hae
new file mode 100644
index 0000000..497aee9
--- /dev/null
+++ b/src/ssm/aessm.hae
@@ -0,0 +1,31 @@
+#ifndef __SSM_HAE__
+#define __SSM_HAE__
+
+#include "ssm.h"
+#include "ssmdef.h"
+#include <pthread.h>
+
+typedef struct aessm_s
+{
+ ssm_id ssm;
+ ssm_addr_id laddr_id;
+ pthread_t thread_id;
+ int state;
+} aessm_t;
+
+int aessm_initalize (aessm_t *aessm_id);
+int aessm_finalize (aessm_t *aessm_id);
+
+int aessm_link (ssm_id ssm, ssm_flags16 flags,
+ ssm_match_bits match_bits, ssm_match_bits mask_bits,
+ ssm_iovec_p data_iovec, ssm_me_pos pos, ssm_me_id anchor,
+ uint64_t count, ssm_me_id *me);
+
+__blocking int aessm_unlink(ssm_me_id me, ssm_evt_p evt);
+__blocking int aessm_put (ssm_me_id me, ssm_addr_id target_addr, ssm_evt_p evt);
+__blocking int aessm_get (ssm_me_id me, ssm_addr_id target_addr, ssm_evt_p evt);
+__blocking int aessm_msg (ssm_me_id me, ssm_addr_id target_addr, uint64_t info_a, uint64_t info_b, ssm_evt_p evt);
+__blocking int aessm_ping (ssm_me_id me, ssm_addr_id target_addr, ssm_evt_p evt);
+__blocking int aessm_wait (ssm_me_id me, ssm_evt_p evt);
+
+#endif
diff --git a/src/ssm/module.mk.in b/src/ssm/module.mk.in
new file mode 100644
index 0000000..e54fa08
--- /dev/null
+++ b/src/ssm/module.mk.in
@@ -0,0 +1,8 @@
+DIR := src/ssm
+
+ifeq ($(BUILD_SSM),1)
+
+AELIBSRC += $(DIR)/aessm.ae
+AESOP_HDR += $(DIR)/aessm.hae
+
+endif
diff --git a/src/ssm/test/module.mk.in b/src/ssm/test/module.mk.in
new file mode 100644
index 0000000..f572936
--- /dev/null
+++ b/src/ssm/test/module.mk.in
@@ -0,0 +1,10 @@
+DIR := src/ssm/test
+
+ifeq ($(BUILD_SSM),1)
+
+AETESTSRC += $(DIR)/ssmput.ae \
+ $(DIR)/ssmget.ae \
+ $(DIR)/ssmmsg.ae \
+ $(DIR)/ssmping.ae
+
+endif
diff --git a/src/ssm/test/ssmget.ae b/src/ssm/test/ssmget.ae
new file mode 100644
index 0000000..9afebe8
--- /dev/null
+++ b/src/ssm/test/ssmget.ae
@@ -0,0 +1,122 @@
+#include "aesop.h"
+#include "aesop-support.hae"
+#include "src/ssm/aessm.hae"
+
+#define DATAVAL 0xffbaffabffbaffab
+
+/*
+ * This test demonstrates a get from a remote buffer.
+ */
+static __blocking int test_main (int argc, char **argv)
+{
+ aessm_t ssm1;
+ ssm_me_id me1;
+ ssm_iovec_t iovec1;
+ uint64_t data1 = DATAVAL;
+ ssm_evt_t evt1;
+ int rc1;
+
+ aessm_t ssm2;
+ ssm_me_id me2;
+ ssm_iovec_t iovec2;
+ uint64_t data2 = 0;
+ ssm_evt_t evt2;
+ int rc2;
+
+
+ // publish buffer to get from
+
+ rc1 = aessm_initialize(&ssm1);
+ assert(rc1 == AE_SUCCESS);
+
+ iovec1.data = &data1;
+ iovec1.len = sizeof(data1);
+ iovec1.next = NULL;
+
+ rc1 = aessm_link (ssm1.ssm,
+ 0,
+ 0x1234,
+ 0,
+ &iovec1,
+ SSM_ME_POS_HEAD,
+ SSM_ME_NONE,
+ 1,
+ &me1);
+ assert(rc1 == AE_SUCCESS);
+
+ pwait
+ {
+ // wait for get
+ pbranch
+ {
+ memset(&evt1, 0, sizeof(evt1));
+
+ rc1 = aessm_wait (me1, &evt1);
+ assert(rc1 == AE_SUCCESS);
+ assert(evt1.result == SSM_RESULT_SUCCESS);
+ assert(data1 == DATAVAL);
+
+ memset(&evt1, 0, sizeof(evt1));
+
+ rc1 = aessm_unlink (me1, &evt1);
+ assert(rc1 == AE_SUCCESS);
+ assert(evt1.result == SSM_RESULT_SUCCESS);
+
+ rc1 = aessm_finalize(&ssm1);
+ assert(rc1 == AE_SUCCESS);
+ }
+
+ // get from remote
+ pbranch
+ {
+ memset(&evt2, 0, sizeof(evt2));
+
+ iovec2.data = &data2;
+ iovec2.len = sizeof(data2);
+ iovec2.next = NULL;
+
+ rc2 = aessm_initialize(&ssm2);
+ assert(rc2 == AE_SUCCESS);
+
+ rc2 = aessm_link (ssm2.ssm,
+ //SSM_ME_SEND_ONLY, // this should work?
+ 0,
+ 0x1234,
+ 0,
+ &iovec2,
+ SSM_ME_POS_HEAD,
+ SSM_ME_NONE,
+ 0,
+ &me2);
+ assert(rc2 == AE_SUCCESS);
+
+ rc2 = aessm_get(me2, ssm1.laddr_id, &evt2);
+ assert(rc2 == AE_SUCCESS);
+ assert(evt2.result == SSM_RESULT_SUCCESS);
+ assert(data2 == DATAVAL);
+
+ memset(&evt2, 0, sizeof(evt2));
+
+ rc2 = aessm_unlink(me2, &evt2);
+ assert(rc2 == AE_SUCCESS);
+ assert(evt2.result == SSM_RESULT_SUCCESS);
+
+ rc2 = aessm_finalize(&ssm2);
+ assert(rc2 == AE_SUCCESS);
+ }
+ }
+
+ printf("SUCCESS\n");
+ return 0;
+}
+
+aesop_main_set(test_main);
+
+/*
+ * Local variables:
+ * c-indent-level: 4
+ * c-basic-offset: 4
+ * End:
+ *
+ * vim: ft=c ts=8 sts=4 sw=4 expandtab
+ */
diff --git a/src/ssm/test/ssmmsg.ae b/src/ssm/test/ssmmsg.ae
new file mode 100644
index 0000000..5c23dd9
--- /dev/null
+++ b/src/ssm/test/ssmmsg.ae
@@ -0,0 +1,113 @@
+#include "aesop.h"
+#include "aesop-support.hae"
+#include "src/ssm/aessm.hae"
+
+#define DATAVAL 0xffbaffabffbaffab
+
+/*
+ * This test demonstrates a msg to a remote host.
+ */
+static __blocking int test_main (int argc, char **argv)
+{
+ aessm_t ssm1;
+ ssm_me_id me1;
+ ssm_evt_t evt1;
+ int rc1;
+
+ aessm_t ssm2;
+ ssm_me_id me2;
+ ssm_evt_t evt2;
+ int rc2;
+
+ // publish match for msg
+
+ rc1 = aessm_initialize(&ssm1);
+ assert(rc1 == AE_SUCCESS);
+
+ rc1 = aessm_link (ssm1.ssm,
+ 0,
+ 0x1234,
+ 0,
+ NULL,
+ SSM_ME_POS_HEAD,
+ SSM_ME_NONE,
+ 1,
+ &me1);
+ assert(rc1 == AE_SUCCESS);
+
+ pwait
+ {
+ // wait for match
+ pbranch
+ {
+ memset(&evt1, 0, sizeof(evt1));
+
+ rc1 = aessm_wait (me1, &evt1);
+ assert(rc1 == AE_SUCCESS);
+ assert(evt1.result == SSM_RESULT_SUCCESS);
+ assert(evt1.info_a == DATAVAL);
+ assert(evt1.info_b == ~DATAVAL);
+
+ memset(&evt1, 0, sizeof(evt1));
+
+ rc1 = aessm_unlink (me1, &evt1);
+ assert(rc1 == AE_SUCCESS);
+ assert(evt1.result == SSM_RESULT_SUCCESS);
+
+ rc1 = aessm_finalize(&ssm1);
+ assert(rc1 == AE_SUCCESS);
+ }
+
+ // post msg to remote
+ pbranch
+ {
+ uint64_t dataA = DATAVAL;
+ uint64_t dataB = ~DATAVAL;
+
+ memset(&evt2, 0, sizeof(evt2));
+
+ rc2 = aessm_initialize(&ssm2);
+ assert(rc2 == AE_SUCCESS);
+
+ rc2 = aessm_link (ssm2.ssm,
+ SSM_ME_SEND_ONLY,
+ 0x1234,
+ 0,
+ NULL,
+ SSM_ME_POS_HEAD,
+ SSM_ME_NONE,
+ 0,
+ &me2);
+ assert(rc2 == AE_SUCCESS);
+
+ rc2 = aessm_msg(me2, ssm1.laddr_id, dataA, dataB, &evt2);
+ assert(rc2 == AE_SUCCESS);
+ assert(evt2.result == SSM_RESULT_SUCCESS);
+ assert(dataA == DATAVAL);
+ assert(dataB == ~DATAVAL);
+
+ memset(&evt2, 0, sizeof(evt2));
+
+ rc2 = aessm_unlink(me2, &evt2);
+ assert(rc2 == AE_SUCCESS);
+ assert(evt2.result == SSM_RESULT_SUCCESS);
+
+ rc2 = aessm_finalize(&ssm2);
+ assert(rc2 == AE_SUCCESS);
+ }
+ }
+
+ printf("SUCCESS\n");
+ return 0;
+}
+
+aesop_main_set(test_main);
+
+/*
+ * Local variables:
+ * c-indent-level: 4
+ * c-basic-offset: 4
+ * End:
+ *
+ * vim: ft=c ts=8 sts=4 sw=4 expandtab
+ */
diff --git a/src/ssm/test/ssmping.ae b/src/ssm/test/ssmping.ae
new file mode 100644
index 0000000..5f511d4
--- /dev/null
+++ b/src/ssm/test/ssmping.ae
@@ -0,0 +1,82 @@
+#include "aesop.h"
+#include "aesop-support.hae"
+#include "src/ssm/aessm.hae"
+
+/*
+ * This test demonstrates a ping to a remote host.
+ */
+static __blocking int test_main (int argc, char **argv)
+{
+ aessm_t ssm1;
+ int rc1;
+
+ aessm_t ssm2;
+ ssm_me_id me2;
+ ssm_evt_t evt2;
+ int rc2;
+
+ // initialize for ping
+
+ rc1 = aessm_initialize(&ssm1);
+ assert(rc1 == AE_SUCCESS);
+
+ pwait
+ {
+ // wait for ping
+ pbranch
+ {
+ aesop_timer(1000);
+
+ rc1 = aessm_finalize(&ssm1);
+ assert(rc1 == AE_SUCCESS);
+ }
+
+ // post ping to remote
+ pbranch
+ {
+ memset(&evt2, 0, sizeof(evt2));
+
+ rc2 = aessm_initialize(&ssm2);
+ assert(rc2 == AE_SUCCESS);
+
+ rc2 = aessm_link (ssm2.ssm,
+ //SSM_ME_SEND_ONLY,
+ 0,
+ 0,
+ 0,
+ NULL,
+ SSM_ME_POS_HEAD,
+ SSM_ME_NONE,
+ 0,
+ &me2);
+ assert(rc2 == AE_SUCCESS);
+
+ rc2 = aessm_ping(me2, ssm1.laddr_id, &evt2);
+ assert(rc2 == AE_SUCCESS);
+ assert(evt2.result == SSM_RESULT_SUCCESS);
+
+ memset(&evt2, 0, sizeof(evt2));
+
+ rc2 = aessm_unlink(me2, &evt2);
+ assert(rc2 == AE_SUCCESS);
+ assert(evt2.result == SSM_RESULT_SUCCESS);
+
+ rc2 = aessm_finalize(&ssm2);
+ assert(rc2 == AE_SUCCESS);
+ }
+ }
+
+ printf("SUCCESS\n");
+ return 0;
+}
+
+aesop_main_set(test_main);
+
+/*
+ * Local variables:
+ * c-indent-level: 4
+ * c-basic-offset: 4
+ * End:
+ *
+ * vim: ft=c ts=8 sts=4 sw=4 expandtab
+ */
diff --git a/src/ssm/test/ssmput.ae b/src/ssm/test/ssmput.ae
new file mode 100644
index 0000000..4d58d77
--- /dev/null
+++ b/src/ssm/test/ssmput.ae
@@ -0,0 +1,120 @@
+#include "aesop.h"
+#include "aesop-support.hae"
+#include "src/ssm/aessm.hae"
+
+#define DATAVAL 0xffbaffabffbaffab
+
+/*
+ * This test demonstrates a put into a remote buffer.
+ */
+static __blocking int test_main (int argc, char **argv)
+{
+ pwait
+ {
+ aessm_t ssm1;
+ ssm_me_id me1;
+ ssm_iovec_t iovec1;
+ uint64_t data1 = 0;
+ ssm_evt_t evt1;
+ int rc1;
+
+ aessm_t ssm2;
+ ssm_me_id me2;
+ ssm_iovec_t iovec2;
+ uint64_t data2 = DATAVAL;
+ ssm_evt_t evt2;
+ int rc2;
+
+ // publish buffer
+
+ rc1 = aessm_initialize(&ssm1);
+ assert(rc1 == AE_SUCCESS);
+
+ iovec1.data = &data1;
+ iovec1.len = sizeof(data1);
+ iovec1.next = NULL;
+
+ rc1 = aessm_link (ssm1.ssm,
+ 0,
+ 0x1234,
+ 0,
+ &iovec1,
+ SSM_ME_POS_HEAD,
+ SSM_ME_NONE,
+ 1,
+ &me1);
+ assert(rc1 == AE_SUCCESS);
+
+ // wait for put
+ pbranch
+ {
+ memset(&evt1, 0, sizeof(evt1));
+
+ rc1 = aessm_wait (me1, &evt1);
+ assert(rc1 == AE_SUCCESS);
+ assert(evt1.result == SSM_RESULT_SUCCESS);
+ assert(data1 == DATAVAL);
+
+ memset(&evt1, 0, sizeof(evt1));
+
+ rc1 = aessm_unlink (me1, &evt1);
+ assert(rc1 == AE_SUCCESS);
+ assert(evt1.result == SSM_RESULT_SUCCESS);
+
+ rc1 = aessm_finalize(&ssm1);
+ assert(rc1 == AE_SUCCESS);
+ }
+
+ // post put to remote
+ pbranch
+ {
+ memset(&evt2, 0, sizeof(evt2));
+
+ iovec2.data = &data2;
+ iovec2.len = sizeof(data2);
+ iovec2.next = NULL;
+
+ rc2 = aessm_initialize(&ssm2);
+ assert(rc2 == AE_SUCCESS);
+
+ rc2 = aessm_link (ssm2.ssm,
+ SSM_ME_SEND_ONLY,
+ 0x1234,
+ 0,
+ &iovec2,
+ SSM_ME_POS_HEAD,
+ SSM_ME_NONE,
+ 0,
+ &me2);
+ assert(rc2 == AE_SUCCESS);
+
+ rc2 = aessm_put(me2, ssm1.laddr_id, &evt2);
+ assert(rc2 == AE_SUCCESS);
+ assert(evt2.result == SSM_RESULT_SUCCESS);
+ assert(data2 == DATAVAL);
+
+ memset(&evt2, 0, sizeof(evt2));
+
+ rc2 = aessm_unlink(me2, &evt2);
+ assert(rc2 == AE_SUCCESS);
+ assert(evt2.result == SSM_RESULT_SUCCESS);
+
+ rc2 = aessm_finalize(&ssm2);
+ assert(rc2 == AE_SUCCESS);
+ }
+ }
+
+ printf("SUCCESS\n");
+ return 0;
+}
+
+aesop_main_set(test_main);
+
+/*
+ * Local variables:
+ * c-indent-level: 4
+ * c-basic-offset: 4
+ * End:
+ *
+ * vim: ft=c ts=8 sts=4 sw=4 expandtab
+ */
hooks/post-receive
--
aesop Repository
