/* some function somewhere */
void func_ayam(void) {
int rc;
MyMessageType *msg = NULL;
MBt_Iterator iterator;
/* assuming myboard has been created and populated */
/* create and iterator myBoard */
MB_Iterator_Create(myBoard, &iterator);
rc = MB_Iterator_GetMessage(iterator, (void **)&msg);
while (msg) /* loop till end of Iterator */
{
do_something_with_message(msg);
free(msg); /* free allocated message */
/* get next message from iterator */
rc = MB_Iterator_GetMessage(iterator, (void **)&msg);
if (rc != MB_SUCCESS)
{
fprintf(stderr, "Oh no! Error while traversing iterator.\n");
/* check valur of rc to determine reason of failure. Handle error */
/* don't continue if error can't be handled */
exit(1);
}
}
}
/* this example was meant to be brief, so we've omitted checks for
* Message Board routines' return code.
* In practice, you would want to check all return code, and handle any
* erroneous conditions
*/
int main(int argc, char **argv) {
int rc;
void *msg;
int id, pcount;
MBt_Board mboard;
MBt_Iterator iter;
double mypi, pi, sum, h;
/* Initialise Message Board environment */
MB_Env_Init();
/* get my ID and proc count */
id = MB_Env_GetProcID();
pcount = MB_Env_GetProcCount();
/* Create a board that can store doubles */
MB_Create(&mboard, sizeof(double));
/* calculate my portion of pi */
h = 1.0 / (double)NR;
pi = sum = 0.0;
for (i = id + 1; i <= NR; i += pcount)
{
sum += FUNC_X(((double)i - 0.5)*h);
}
/* Everyone adds their sum to the board */
MB_AddMessage(mboard, &sum);
/* Synchornise boards */
/* If there are more things to do that does not involved the board
* we can run them between SyncStart() and SyncComplete(). That will
* overlap the communication time with your own computation.
*/
MB_SyncStart(mboard);
MB_SyncComplete(mboard);
/* Master node reads message and prints out result */
if (id == 0)
{
MB_Iterator_Create(mboard, &iter);
MB_Iterator_GetMessage(iter, msg);
while (msg)
{
pi += *((double *)msg);
MB_Iterator_GetMessage(iter, msg);
}
MB_Iterator_Delete(&iter);
printf("Pi is approximately %.16f\n", pi);
}
/* Delete board */
MB_Delete(&mboard);
/* Finalise Message Board environment */
return MB_Env_Finalise();
}
/* Test MB_Iterator_GetMessage on Sorted Iterator */
void test_mb_p_iter_sorted_getmsg(void) {
int rc, errfound, i, prev;
dummy_msg *msg_ptr;
void *obj;
if (mb_s == MB_NULL_MBOARD || itr_s == MB_NULL_ITERATOR)
{
CU_FAIL("mboard/iterator not yet created");
return;
}
/* try getting message from sorted iterator */
errfound = 0;
prev = -1;
for (i = 0; i < PARALLEL_TEST_MSG_COUNT; i++)
{
rc = MB_Iterator_GetMessage(itr_s, &obj);
if (rc != MB_SUCCESS || obj == NULL) errfound++;
msg_ptr = (dummy_msg*)obj;
if (msg_ptr->ernet != i + 1) errfound++;
free(obj);
if (errfound != 0) break;
}
CU_ASSERT_EQUAL(errfound, 0);
/* next message should be empty */
rc = MB_Iterator_GetMessage(itr_s, &obj);
CU_ASSERT_EQUAL(rc, MB_SUCCESS);
CU_ASSERT_PTR_NULL(obj);
/* We're done. Delete iterator */
rc = MB_Iterator_Delete(&itr_s);
CU_ASSERT_EQUAL(rc, MB_SUCCESS);
CU_ASSERT_EQUAL(itr_s, MB_NULL_ITERATOR);
/* Delete mboard */
rc = MB_Delete(&mb_s);
CU_ASSERT_EQUAL(rc, MB_SUCCESS);
CU_ASSERT_EQUAL(mb_s, MB_NULL_MBOARD);
}
inline static m_nestInformation* getInternalMessage_nestInformation(void)
{
static m_nestInformation *msg_prev = NULL;
m_nestInformation *msg;
int rc;
/* deallocate previously returned message */
if (msg_prev != NULL)
{
free(msg_prev);
}
else
{
rc = MB_Iterator_Rewind(i_nestInformation);
#ifdef ERRCHECK
if (rc != MB_SUCCESS)
{
fprintf(stderr, "ERROR: Could not rewind 'nestInformation' Iterator\n");
switch(rc) {
case MB_ERR_INVALID:
fprintf(stderr, "\t reason: 'nestInformation' Iterator has not been created?\n");
break;
default:
fprintf(stderr, "\t MB_Iterator_Rewind returned error code: %d (see libmboard docs for details)\n", rc);
break;
}
exit(rc);
}
#endif
}
/* get next message from iterator */
rc = MB_Iterator_GetMessage(i_nestInformation, (void **)&msg);
#ifdef ERRCHECK
if (rc != MB_SUCCESS)
{
fprintf(stderr, "ERROR: Could not get message from 'nestInformation' Iterator\n");
switch(rc) {
case MB_ERR_INVALID:
fprintf(stderr, "\t reason: 'nestInformation' Iterator has not been created?\n");
break;
case MB_ERR_MEMALLOC:
fprintf(stderr, "\t reason: out of memory\n");
break;
default:
fprintf(stderr, "\t MB_Iterator_GetMessage returned error code: %d (see libmboard docs for details)\n", rc);
break;
}
exit(rc);
}
#endif
/* store pointer so memory can be deallocated later */
msg_prev = msg;
return msg;
}
/* Test MB_Iterator_Rewind */
void test_mb_s_iter_rewind(void) {
int rc, checkval;
MBt_Board mb;
MBt_Iterator itr;
MBIt_Iterator *iter_obj;
void *obj;
/* testing invalid iterator */
itr = 999999;
rc = MB_Iterator_Rewind(itr);
CU_ASSERT_EQUAL(rc, MB_ERR_INVALID);
/* testing null iterator */
itr = MB_NULL_ITERATOR;
rc = MB_Iterator_Rewind(itr);
CU_ASSERT_EQUAL(rc, MB_ERR_INVALID);
/* Create empty iterator/board */
rc = MB_Create(&mb, sizeof(dummy_msg));
CU_ASSERT_EQUAL_FATAL(rc, MB_SUCCESS);
rc = MB_Iterator_Create(mb, &itr);
CU_ASSERT_EQUAL_FATAL(rc, MB_SUCCESS);
/* rewind empty iterator */
rc = MB_Iterator_Rewind(itr);
CU_ASSERT_EQUAL(rc, MB_SUCCESS);
/* check internal values */
iter_obj = (MBIt_Iterator *)MBI_getIteratorRef(itr);
CU_ASSERT_PTR_NOT_NULL_FATAL(iter_obj);
CU_ASSERT_EQUAL(iter_obj->iterating, 0);
CU_ASSERT_PTR_NULL(iter_obj->cursor);
/* clean up */
iter_obj = NULL;
MB_Iterator_Delete(&itr);
MB_Delete(&mb);
/* create and populate board */
rc = init_mb_with_content(&mb);
CU_ASSERT_EQUAL_FATAL(rc, MB_SUCCESS);
/* create iterator */
rc = MB_Iterator_Create(mb, &itr);
CU_ASSERT_EQUAL_FATAL(rc, MB_SUCCESS);
/* check internal values (before starting iteration) */
iter_obj = (MBIt_Iterator *)MBI_getIteratorRef(itr);
CU_ASSERT_PTR_NOT_NULL_FATAL(iter_obj);
CU_ASSERT_EQUAL(iter_obj->iterating, 0);
CU_ASSERT_PTR_NULL(iter_obj->cursor);
/* get first message */
rc = MB_Iterator_GetMessage(itr, &obj);
CU_ASSERT_EQUAL_FATAL(rc, MB_SUCCESS);
CU_ASSERT_EQUAL(iter_obj->iterating, 1);
CU_ASSERT_PTR_NOT_NULL(iter_obj->cursor);
checkval = ((dummy_msg *)obj)->ernet;
while(obj) { /* iterate till the end */
free(obj); /* release mem */
MB_Iterator_GetMessage(itr, &obj);
}
/* rewind and check content */
rc = MB_Iterator_Rewind(itr);
CU_ASSERT_EQUAL(rc, MB_SUCCESS);
CU_ASSERT_EQUAL(iter_obj->iterating, 0);
CU_ASSERT_PTR_NULL(iter_obj->cursor);
/* get another object and compare with obj_first */
rc = MB_Iterator_GetMessage(itr, &obj);
CU_ASSERT_EQUAL_FATAL(rc, MB_SUCCESS);
CU_ASSERT_EQUAL(checkval, ((dummy_msg *)obj)->ernet);
/* clean up */
free(obj);
MB_Iterator_Delete(&itr);
MB_Delete(&mb);
}
/* Test MB_Iterator_GetMessage on Filtered Iterator */
void test_mb_p_iter_filtered_getmsg(void) {
int rc, errfound, i, count;
dummy_msg *msg_ptr;
MBIt_Board *board;
MBIt_Iterator *iter;
void *obj;
if (mb_f == MB_NULL_MBOARD || itr_f == MB_NULL_ITERATOR)
{
CU_FAIL("mboard/iterator not yet created");
return;
}
/* manually check all messages to see how many messages fit the bill */
board = (MBIt_Board *)MBI_getMBoardRef(mb_f);
CU_ASSERT_PTR_NOT_NULL_FATAL(board);
count = 0;
for (i = 0; i < (int)board->data->count_current; i++)
{
rc = pl_getnode(board->data, i, &obj);
if (rc != PL_SUCCESS) CU_FAIL("corrupted board?");
msg_ptr = (dummy_msg *)obj;
if (msg_ptr->ernet >= TEST_FILTER_LB && \
msg_ptr->ernet <= TEST_FILTER_UB) count++;
}
/* check number of elems in iterator */
iter = (MBIt_Iterator *)MBI_getIteratorRef(itr_f);
CU_ASSERT_PTR_NOT_NULL_FATAL(iter);
CU_ASSERT_EQUAL(count, (int)iter->data->count_current);
/* try getting message from sorted iterator */
errfound = 0;
for (i = 0; i < count; i++)
{
rc = MB_Iterator_GetMessage(itr_f, &obj);
if (rc != MB_SUCCESS || obj == NULL) errfound++;
msg_ptr = (dummy_msg*)obj;
if (msg_ptr->ernet < TEST_FILTER_LB || \
msg_ptr->ernet > TEST_FILTER_UB) errfound++;
free(obj);
if (errfound != 0) break;
}
CU_ASSERT_EQUAL(errfound, 0);
/* next message should be empty */
rc = MB_Iterator_GetMessage(itr_f, &obj);
CU_ASSERT_EQUAL(rc, MB_SUCCESS);
CU_ASSERT_PTR_NULL(obj);
/* We're done. Delete iterator */
rc = MB_Iterator_Delete(&itr_f);
CU_ASSERT_EQUAL(rc, MB_SUCCESS);
CU_ASSERT_EQUAL(itr_f, MB_NULL_ITERATOR);
/* Delete mboard */
rc = MB_Delete(&mb_f);
CU_ASSERT_EQUAL(rc, MB_SUCCESS);
CU_ASSERT_EQUAL(mb_f, MB_NULL_MBOARD);
}
