// Testcase to test hpx_lco_get_all function
static int _getAll_handler(uint32_t *args, size_t size) {
uint32_t n = *args;
if (n < 2) {
return HPX_THREAD_CONTINUE(n);
}
hpx_addr_t peers[] = {
HPX_HERE,
HPX_HERE
};
uint32_t ns[] = {
n - 1,
n - 2
};
hpx_addr_t futures[] = {
hpx_lco_future_new(sizeof(uint32_t)),
hpx_lco_future_new(sizeof(uint32_t))
};
uint32_t ssn[] = {
0,
0
};
void *addrs[] = {
&ssn[0],
&ssn[1]
};
size_t sizes[] = {
sizeof(uint32_t),
sizeof(uint32_t)
};
hpx_call(peers[0], _getAll, futures[0], &ns[0], sizeof(uint32_t));
hpx_call(peers[1], _getAll, futures[1], &ns[1], sizeof(uint32_t));
hpx_lco_get_all(2, futures, sizes, addrs, NULL);
hpx_lco_wait(futures[0]);
hpx_lco_wait(futures[1]);
hpx_addr_t wait = hpx_lco_future_new(0);
hpx_lco_delete_all(2, futures, wait);
hpx_lco_wait(wait);
hpx_lco_delete(wait, HPX_NULL);
uint32_t sn = ssn[0] * ssn[0] + ssn[1] * ssn[1];
return HPX_THREAD_CONTINUE(sn);
}
int _hpx_process_call(hpx_addr_t process, hpx_addr_t addr, hpx_action_t id,
hpx_addr_t result, int n, ...) {
va_list args;
va_start(args, n);
hpx_action_t set = hpx_lco_set_action;
hpx_parcel_t *p = action_new_parcel_va(id, addr, result, set, n, &args);
va_end(args);
if (hpx_thread_current_pid() == hpx_process_getpid(process)) {
hpx_parcel_send_sync(p);
return HPX_SUCCESS;
}
hpx_addr_t sync = hpx_lco_future_new(0);
hpx_parcel_t *q = hpx_parcel_acquire(NULL, parcel_size(p));
q->target = process;
q->action = _proc_call;
q->c_target = sync;
q->c_action = hpx_lco_set_action;
hpx_parcel_set_data(q, p, parcel_size(p));
q->pid = 0;
q->credit = 0;
EVENT_PROCESS_CALL(process, q->pid);
hpx_parcel_send_sync(q);
parcel_delete(p);
hpx_lco_wait(sync);
hpx_lco_delete(sync, HPX_NULL);
return HPX_SUCCESS;
}
static int _test_set_lsync_handler(hpx_addr_t lco) {
hpx_addr_t rsync = hpx_lco_future_new(4);
printf("\ttesting ... ");
{
_cpy(_set, ONES);
hpx_lco_set_lsync(lco, sizeof(ONES), ONES, HPX_NULL);
_cpy(_set, ZEROS);
hpx_lco_get(lco, sizeof(_get), &_get);
_verify_get();
_reset(_set, _get, HPX_NULL, lco);
}
printf("ok\n");
printf("\ttesting rsync ... ");
{
_cpy(_set, ONES);
hpx_lco_set_lsync(lco, sizeof(ONES), ONES, rsync);
_cpy(_set, ZEROS);
hpx_lco_wait(rsync);
hpx_lco_get(lco, sizeof(_get), &_get);
_verify_get();
_reset(_set, _get, rsync, lco);
}
printf("ok\n");
return hpx_call_cc(rsync, hpx_lco_delete_action);
}
static int lco_error_handler(void) {
printf("Starting the HPX LCO get all test\n");
hpx_time_t t1 = hpx_time_now();
hpx_addr_t lco = hpx_lco_future_new(0);
hpx_addr_t done = hpx_lco_future_new(0);
hpx_call(HPX_HERE, _errorset, done, &lco, sizeof(lco));
hpx_status_t status = hpx_lco_wait(lco);
printf("status == %d\n", status);
assert(status == HPX_ERROR);
hpx_lco_wait(done);
hpx_lco_delete(lco, HPX_NULL);
hpx_lco_delete(done, HPX_NULL);
printf(" Elapsed: %.7f\n", hpx_time_elapsed_ms(t1)/1e3);
return HPX_SUCCESS;
}
/// Use the join_async operation in the allreduce leaf.
static int
_join_async_leaf_handler(hpx_addr_t allreduce, int i, int j, hpx_addr_t sum) {
int r;
hpx_addr_t f = hpx_lco_future_new(0);
CHECK( hpx_lco_allreduce_join_async(allreduce, i, sizeof(j), &j, &r, f) );
CHECK( hpx_lco_wait(f) );
hpx_lco_delete(f, HPX_NULL);
test_assert(r == HPX_LOCALITIES * N * (N + 1) / 2);
return hpx_call_cc(sum, hpx_lco_set_action, &r, sizeof(r));
}
static counter_t _uts_action(void *args, size_t size)
{
int i, j;
struct thread_data *my_data;
struct thread_data temp, input;
my_data = (struct thread_data *)args;
Node n[my_data->numChildren], *nodePtr;
counter_t subtreesize = 1, partialCount[my_data->numChildren];
temp.depth = my_data->depth;
memcpy(&temp.parent, &my_data->parent, sizeof(Node));
temp.numChildren = my_data->numChildren;
//hpx_lco_sema_p (mutex);
//printf("D: %d; child: %d; spawns:%.0f\n", temp.depth, temp.numChildren, spawns_counter++);
//hpx_lco_sema_v_sync (mutex);
/*
printf("\n[Node] height = %d; numChildren = %d\n"
, temp.parent.height
, temp.parent.numChildren);
*/
hpx_addr_t theThread = HPX_HERE;
hpx_addr_t done = hpx_lco_future_new(sizeof(uint64_t));
// Recurse on the children
for (i = 0; i < temp.numChildren; i++) {
nodePtr = &n[i];
nodePtr->height = temp.parent.height + 1;
// The following line is the work (one or more SHA-1 ops)
for (j = 0; j < computeGranularity; j++) {
rng_spawn(temp.parent.state.state, nodePtr->state.state, i);
}
nodePtr->numChildren = uts_numChildren(nodePtr);
input.depth = temp.depth+1;
memcpy(&input.parent, nodePtr, sizeof(Node));
input.numChildren = nodePtr->numChildren;
//partialCount[i] = parTreeSearch(depth+1, nodePtr, nodePtr->numChildren);
hpx_call_sync(theThread, _uts, &partialCount[i], sizeof(partialCount[i]), &input, sizeof(input));
}
for (i = 0; i < temp.numChildren; i++) {
subtreesize += partialCount[i];
}
HPX_THREAD_CONTINUE(subtreesize);
return HPX_SUCCESS;
}
static int _spawn_handler(hpx_addr_t termination_lco) {
int e;
for (size_t i = 0; i < LCOS_PER_LOCALITY; ++i) {
// test futures
const hpx_addr_t test_futures[3] = {
hpx_lco_future_new(0),
termination_lco,
hpx_lco_and_new(WAITERS)
};
e = hpx_call(HPX_THERE(rand() % HPX_LOCALITIES), _set, HPX_NULL,
&test_futures[0], sizeof(hpx_addr_t));
assert(e == HPX_SUCCESS);
for(size_t j = 0; j < WAITERS; ++j) {
e = hpx_call(HPX_THERE(rand() % HPX_LOCALITIES), _wait, test_futures[2],
&test_futures[0], sizeof(hpx_addr_t));
assert(e == HPX_SUCCESS);
}
e = hpx_call(HPX_THERE(rand() % HPX_LOCALITIES), _delete, HPX_NULL,
test_futures, sizeof(test_futures));
assert(e == HPX_SUCCESS);
// test and lco
const hpx_addr_t test_ands[3] = {
hpx_lco_and_new(PARTICIPANTS),
termination_lco,
hpx_lco_and_new(WAITERS)
};
for(size_t j = 0; j < PARTICIPANTS; ++j) {
e = hpx_call(HPX_THERE(rand() % HPX_LOCALITIES), _set, HPX_NULL,
&test_ands[0], sizeof(hpx_addr_t));
assert(e == HPX_SUCCESS);
}
for(size_t j = 0; j < WAITERS; ++j) {
e = hpx_call(HPX_THERE(rand() % HPX_LOCALITIES), _wait, test_ands[2],
&test_ands[0], sizeof(hpx_addr_t));
assert(e == HPX_SUCCESS);
}
e = hpx_call(HPX_THERE(rand() % HPX_LOCALITIES), _delete, HPX_NULL,
test_ands, sizeof(test_ands));
assert(e == HPX_SUCCESS);
}
return HPX_SUCCESS;
}
/// Use a synchronous join for the allreduce operation.
static int
_allreduce_join_handler(hpx_addr_t allreduce, int iters, size_t size) {
unsigned char sbuf[size];
unsigned char rbuf[size];
for (int i = 0, e = size; i < e; ++i) {
sbuf[i] = rand();
}
int id = (HPX_LOCALITY_ID * HPX_THREADS) + HPX_THREAD_ID;
hpx_addr_t f = hpx_lco_future_new(0);
for (int i = 0; i < iters; ++i) {
hpx_lco_allreduce_join_async(allreduce, id, size, sbuf, rbuf, f);
hpx_lco_wait_reset(f);
}
hpx_lco_delete(f, HPX_NULL);
return HPX_SUCCESS;
}
int parallel_nqueens(int n, int col, int *hist)
{
hpx_addr_t theThread = HPX_HERE;
struct thread_data td;
//td.lyst = hist;
td.n = n;
td.col = col;
memcpy(td.lyst, hist, MAX_SIZE*sizeof(int));
//printf("thread_data size:%d\n", sizeof(struct thread_data));
mutex = hpx_lco_sema_new(1);
//solve(td.n, td.col, td.lyst);
hpx_addr_t done = hpx_lco_future_new(sizeof(uint64_t));
hpx_call(theThread, _nqueens, done, &td, sizeof(td));
hpx_lco_wait(done);
hpx_lco_delete(done, HPX_NULL);
return HPX_SUCCESS;
}
counter_t parallel_uts ( Node *root )
{
struct thread_data input;
hpx_time_t start;
hpx_addr_t theThread = HPX_HERE;
counter_t num_nodes;
input.depth = 0;
memcpy(&input.parent, root, sizeof(Node));
input.numChildren = getNumRootChildren(root);
printf("Computing Unbalance Tree Search algorithm ");
hpx_addr_t done = hpx_lco_future_new(sizeof(uint64_t));
start = hpx_time_now();
hpx_call_sync(theThread, _uts, &num_nodes, sizeof(num_nodes), &input, sizeof(input));
bots_time_program = hpx_time_elapsed_ms(start)/1e3;
printf(" completed!");
return num_nodes;
}
int future_at_handler(void) {
hpx_addr_t f = hpx_lco_future_new(0);
return HPX_THREAD_CONTINUE(f);
}
static int _new_future_at_handler(void) {
hpx_addr_t future = hpx_lco_future_new(sizeof(ONES));
return HPX_THREAD_CONTINUE(future);
}
static int _main_action(int *args, size_t size) {
hpx_time_t t;
int count;
fprintf(stdout, HEADER);
fprintf(stdout, "# Latency in (ms)\n");
t = hpx_time_now();
hpx_addr_t done = hpx_lco_future_new(0);
fprintf(stdout, "Creation time: %g\n", hpx_time_elapsed_ms(t));
value = 1234;
t = hpx_time_now();
hpx_call(HPX_HERE, _set_value, done, &value, sizeof(value));
fprintf(stdout, "Value set time: %g\n", hpx_time_elapsed_ms(t));
t = hpx_time_now();
hpx_lco_wait(done);
fprintf(stdout, "Wait time: %g\n", hpx_time_elapsed_ms(t));
t = hpx_time_now();
hpx_lco_delete(done, HPX_NULL);
fprintf(stdout, "Deletion time: %g\n", hpx_time_elapsed_ms(t));
fprintf(stdout, "%s\t%*s%*s%*s\n", "# NumReaders " , FIELD_WIDTH,
"Get_Value ", FIELD_WIDTH, " LCO_Getall ", FIELD_WIDTH, "Delete");
for (int i = 0; i < sizeof(num_readers)/sizeof(num_readers[0]); i++) {
fprintf(stdout, "%d\t\t", num_readers[i]);
count = num_readers[i];
int values[count];
void *addrs[count];
size_t sizes[count];
hpx_addr_t futures[count];
for (int j = 0; j < count; j++) {
addrs[j] = &values[j];
sizes[j] = sizeof(int);
futures[j] = hpx_lco_future_new(sizeof(int));
}
t = hpx_time_now();
for (int j = 0; j < count; j++) {
t = hpx_time_now();
hpx_call(HPX_HERE, _get_value, futures[j], NULL, 0);
hpx_lco_wait(futures[j]);
}
fprintf(stdout, "%*g", FIELD_WIDTH, hpx_time_elapsed_ms(t));
t = hpx_time_now();
hpx_lco_get_all(count, futures, sizes, addrs, NULL);
fprintf(stdout, "%*g", FIELD_WIDTH, hpx_time_elapsed_ms(t));
t = hpx_time_now();
for (int j = 0; j < count; j++)
hpx_lco_delete(futures[j], HPX_NULL);
fprintf(stdout, "%*g\n", FIELD_WIDTH, hpx_time_elapsed_ms(t));
}
hpx_exit(HPX_SUCCESS);
}
static int _nqueens_action(void *args, size_t size)
{
int i, j;
struct thread_data *my_data;
my_data = (struct thread_data *) args;
/*
printf("n = %d, col = %d, count = %d\n", my_data->n
, my_data->col
, count);
*/
if (my_data->col == my_data->n) {
hpx_lco_sema_p(mutex);
++count;
/*
printf("\nNo. %d\n-----\n", count);
for (i = 0; i < my_data->n; i++, putchar('\n'))
for(j = 0; j < my_data->n; j++)
putchar(j == my_data->lyst[i] ? 'Q' : ((i + j) & 1) ? ' ' : '.');
*/
hpx_lco_sema_v_sync(mutex);
hpx_thread_exit(HPX_SUCCESS);
//hpx_thread_continue(NULL, 0);
//return HPX_SUCCESS;
}
#define p_attack(i, j) (my_data->lyst[j] == i || abs(my_data->lyst[j] - i) == my_data->col - j)
int dummy=0;
int num_spawns=0;
for(i = 0, j = 0; i < my_data->n; i++) {
for (j = 0; j < my_data->col && !p_attack(i, j); j++);
if (j < my_data->col) {
dummy++;
}
}
//printf("dummy/spawns: %d/%d\n", dummy, my_data->n);
num_spawns = my_data->n - dummy;
bool D_CALL = false;
//printf("num_spawns = %d\n", num_spawns);
if( num_spawns == 0 ) {
num_spawns = 1;
D_CALL = true;
}
//num_spawns = my_data->n;
struct thread_data temp[num_spawns];
hpx_addr_t futures[num_spawns];
hpx_addr_t threads[num_spawns];
int pqs[num_spawns];
size_t p_size[num_spawns];
void *addrs[num_spawns];
for(i = 0; i < num_spawns; i++) {
futures[i] = hpx_lco_future_new(sizeof(int));
threads[i] = HPX_HERE;
pqs[i] = 0;
addrs[i] = &pqs[i];
p_size[i] = sizeof(size_t);
}
int k=0; // counter for hpx data
for(i = 0, j = 0; i < my_data->n; i++) {
for (j = 0; j < my_data->col && !p_attack(i, j); j++);
if (j < my_data->col) {
//printf("[%d] call continue.\n", i);
continue;
}
//printf("[%d] call nqueens %d\n", i, k);
my_data->lyst[my_data->col] = i;
memcpy(temp[k].lyst, my_data->lyst, MAX_SIZE*sizeof(int));
temp[k].n = my_data->n;
temp[k].col = my_data->col+1;
//solve(n, col + 1, hist);
hpx_call(threads[k], _nqueens, futures[k], (void *)&temp[k], sizeof(temp[k]));
k++;
}
if( !D_CALL ) {
hpx_lco_get_all(num_spawns, futures, p_size, addrs, NULL);
for(i = 0; i < num_spawns; i++)
hpx_lco_delete(futures[i], HPX_NULL);
}
return HPX_SUCCESS;
}
static int
_new_future_handler(void) {
hpx_addr_t f = hpx_lco_future_new(sizeof(int));
return hpx_thread_continue(&f, sizeof(f));
}