static int _jacobi_main_handler(int n, int nsteps) {
double h = 1.0/n;
// allocate and initialize arrays
hpx_addr_t u = hpx_gas_calloc_local_attr((n+1), BSIZE, 0, HPX_GAS_ATTR_LB);
hpx_addr_t f = hpx_gas_alloc_local((n+1), BSIZE, 0);
hpx_addr_t and = hpx_lco_and_new(n+1);
for (int i = 0; i <= n; ++i) {
double val = i*h;
hpx_gas_memput_lsync(IDX(f,i), &val, sizeof(val), and);
}
hpx_lco_wait(and);
hpx_lco_delete(and, HPX_NULL);
printf("starting jacobi iterations...\n");
hpx_time_t start = hpx_time_now();
jacobi(n, nsteps, u, f);
double elapsed = hpx_time_elapsed_ms(start)/1e3;
// run the solver
printf("n: %d\n", n);
printf("nsteps: %d\n", nsteps);
printf("seconds: %.7f\n", elapsed);
// write the results
if (fname) {
write_solution(n, u, fname);
}
hpx_gas_free(f, HPX_NULL);
hpx_gas_free(u, HPX_NULL);
hpx_exit(HPX_SUCCESS);
}
static int _cswitch_main_action(int *args, size_t size) {
int n = *args;
printf("cswitch(%d)\n", n); fflush(stdout);
for(int i = 0; i < n; i++){
hpx_thread_yield();
}
hpx_exit(HPX_SUCCESS);
}
static int _main_action(int iters, size_t size) {
printf("collbench(iters=%d, size=%zu)\n", iters, size);
printf("time resolution: milliseconds\n");
fflush(stdout);
_BENCHMARK(_allreduce_set_get, iters, size);
_BENCHMARK(_allreduce_join, iters, size);
_BENCHMARK(_allreduce_join_sync, iters, size);
hpx_exit(HPX_SUCCESS);
}
static int _nqueens_main_action(int *args, size_t size)
{
int n = *args;
int hist[n];
hpx_time_t start;
start = hpx_time_now();
parallel_nqueens(n, 0, hist);
printf("%d-Queens: %.7f (s)\n", n, hpx_time_elapsed_ms(start)/1e3);
verify_queens(n);
hpx_exit(HPX_SUCCESS);
}
static int _uts_main_action(void *args, size_t size)
{
Node *root = (Node *)args;
Node temp;
uts_initRoot(&temp, type);
//mutex = hpx_lco_sema_new(1);
bots_number_of_tasks = parallel_uts(&temp);
uts_show_stats();
uts_check_result();
hpx_exit(HPX_SUCCESS);
}
static int _main_action(int *args, size_t size) {
int n = *args;
printf("seqspawn(%d)\n", n); fflush(stdout);
hpx_addr_t and = hpx_lco_and_new(n);
hpx_time_t now = hpx_time_now();
for (int i = 0; i < n; i++)
hpx_call(HPX_HERE, _nop, and, 0, 0);
hpx_lco_wait(and);
double elapsed = hpx_time_elapsed_ms(now)/1e3;
hpx_lco_delete(and, HPX_NULL);
printf("seconds: %.7f\n", elapsed);
printf("localities: %d\n", HPX_LOCALITIES);
printf("threads: %d\n", HPX_THREADS);
hpx_exit(HPX_SUCCESS);
}
static int _main_action(void *args, size_t n) {
hpx_addr_t local, global, calloc_global;
hpx_time_t t;
int size = HPX_LOCALITIES;
int ranks = hpx_get_num_ranks();
uint32_t blocks = size;
fprintf(stdout, HEADER);
fprintf(stdout, "localities: %d, ranks and blocks per rank = %d, %d\n",
size, ranks, blocks/ranks);
fprintf(stdout, "%s\t%*s%*s%*s%*s%*s%*s\n", "# Size ", HEADER_FIELD_WIDTH,
" LOCAL_ALLOC ", HEADER_FIELD_WIDTH, " FREE ", HEADER_FIELD_WIDTH,
" GLOBAL_ALLOC ", HEADER_FIELD_WIDTH, " FREE ", HEADER_FIELD_WIDTH,
" GLOBAL_CALLOC ", HEADER_FIELD_WIDTH, " FREE ");
for (size_t size = 1; size <= MAX_BYTES; size*=2) {
t = hpx_time_now();
local = hpx_gas_alloc_local(1, size, 0);
fprintf(stdout, "%-*zu%*g", 10, size, FIELD_WIDTH, hpx_time_elapsed_ms(t));
t = hpx_time_now();
hpx_gas_free(local, HPX_NULL);
fprintf(stdout, "%*g", FIELD_WIDTH, hpx_time_elapsed_ms(t));
t = hpx_time_now();
global = hpx_gas_alloc_cyclic(blocks, size, 0);
fprintf(stdout, "%*g", FIELD_WIDTH, hpx_time_elapsed_ms(t));
t = hpx_time_now();
hpx_gas_free(global, HPX_NULL);
fprintf(stdout, "%*g", FIELD_WIDTH, hpx_time_elapsed_ms(t));
t = hpx_time_now();
calloc_global = hpx_gas_calloc_cyclic(blocks, size, 0);
fprintf(stdout, "%*g", FIELD_WIDTH, hpx_time_elapsed_ms(t));
t = hpx_time_now();
hpx_gas_free(calloc_global, HPX_NULL);
fprintf(stdout, "%*g", FIELD_WIDTH, hpx_time_elapsed_ms(t));
fprintf(stdout, "\n");
}
hpx_exit(HPX_SUCCESS);
}
static int _health_main_action(void *args, size_t size)
{
char *ptr = (char *)args;
struct Village *top;
hpx_time_t start;
printf("initial top = %p, %u\n", top, top);
read_input_data(ptr);
allocate_village(&top, ((void *)0), ((void *)0), sim_level, 0);;
printf("\ninitial top = %p, %u\n", top, top);
start = hpx_time_now();
sim_village_main_hpx(top);;
printf("HPX-5 health took: %.7f (s)\n", hpx_time_elapsed_ms(start)/1e3);
check_village(top);
hpx_exit(HPX_SUCCESS);
}
// Test code -- ThreadCreate
static int thread_create_handler(int *args, size_t size) {
printf("Starting the Threads test\n");
// Start the timer
hpx_time_t t1 = hpx_time_now();
hpx_addr_t addr = hpx_gas_alloc_cyclic(NUM_THREADS, sizeof(initBuffer_t), 0);
// HPX Threads are spawned as a result of hpx_parcel_send() / hpx_parcel_
// sync().
for (int t = 0; t < NUM_THREADS; t++) {
hpx_addr_t done = hpx_lco_and_new(1);
hpx_parcel_t *p = hpx_parcel_acquire(NULL, sizeof(initBuffer_t));
// Fill the buffer
initBuffer_t *init = hpx_parcel_get_data(p);
init->index = t;
strcpy(init->message, "Thread creation test");
// Set the target address and action for the parcel
hpx_parcel_set_target(p, hpx_addr_add(addr, sizeof(initBuffer_t) * t, sizeof(initBuffer_t)));
hpx_parcel_set_action(p, _initData);
// Set the continuation target and action for parcel
hpx_parcel_set_cont_target(p, done);
hpx_parcel_set_cont_action(p, hpx_lco_set_action);
// and send the parcel, this spawns the HPX thread
hpx_parcel_send(p, HPX_NULL);
hpx_lco_wait(done);
hpx_lco_delete(done, HPX_NULL);
}
hpx_gas_free(addr, HPX_NULL);
printf(" Elapsed: %g\n", hpx_time_elapsed_ms(t1));
hpx_exit(HPX_SUCCESS);
}
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 _hpx_143_fix_handler(void) {
_hpx_143 = hpx_gas_alloc_cyclic(sizeof(void*), HPX_LOCALITIES, 0);
hpx_exit(HPX_SUCCESS);
return LIBHPX_OK;
}
