gaspi_return_t
pgaspi_notify_reset (const gaspi_segment_id_t segment_id_local,
const gaspi_notification_id_t notification_id,
gaspi_notification_t * const old_notification_val)
{
gaspi_verify_init("gaspi_notify_reset");
gaspi_verify_segment(segment_id_local);
gaspi_verify_null_ptr(glb_gaspi_ctx.rrmd[segment_id_local]);
#ifdef DEBUG
if(old_notification_val == NULL)
{
gaspi_print_warning("NULL pointer on parameter old_notification_val (gaspi_notify_reset).");
}
#endif
volatile unsigned char *segPtr;
#ifdef GPI2_CUDA
if(glb_gaspi_ctx.rrmd[segment_id_local][glb_gaspi_ctx.rank].cudaDevId >= 0)
segPtr = (volatile unsigned char*)glb_gaspi_ctx.rrmd[segment_id_local][glb_gaspi_ctx.rank].host_addr;
else
#endif
segPtr = (volatile unsigned char *)
glb_gaspi_ctx.rrmd[segment_id_local][glb_gaspi_ctx.rank].addr;
volatile unsigned int *p = (volatile unsigned int *) segPtr;
const unsigned int res = __sync_val_compare_and_swap (&p[notification_id], p[notification_id], 0);
if(old_notification_val != NULL)
*old_notification_val = res;
return GASPI_SUCCESS;
}
gaspi_return_t
gaspi_threads_get_num_cores(gaspi_int * const cores)
{
int i,n;
cpu_set_t tmask;
gaspi_verify_null_ptr(cores);
if(sched_getaffinity(0, sizeof(cpu_set_t), &tmask) < 0)
{
gaspi_printf("sched_getaffinity failed !\n");
return GASPI_ERROR;
}
for(i = n = 0; i < CPU_SETSIZE; i++)
{
if(CPU_ISSET(i,&tmask))
{
n++;
}
}
*cores = n;
return GASPI_SUCCESS;
}
gaspi_return_t
pgaspi_queue_num (gaspi_number_t * const queue_num)
{
gaspi_verify_null_ptr(queue_num);
*queue_num = glb_gaspi_cfg.queue_num;
return GASPI_SUCCESS;
}
gaspi_return_t
pgaspi_queue_size_max (gaspi_number_t * const queue_size_max)
{
gaspi_verify_null_ptr(queue_size_max);
*queue_size_max = glb_gaspi_cfg.queue_depth;
return GASPI_SUCCESS;
}
gaspi_return_t
pgaspi_transfer_size_min (gaspi_size_t * const transfer_size_min)
{
gaspi_verify_null_ptr(transfer_size_min);
*transfer_size_min = 1;
return GASPI_SUCCESS;
}
gaspi_return_t
pgaspi_notification_num (gaspi_number_t * const notification_num)
{
gaspi_verify_null_ptr(notification_num);
*notification_num = ((1 << 16) - 1);
return GASPI_SUCCESS;
}
gaspi_return_t
pgaspi_rw_list_elem_max (gaspi_number_t * const elem_max)
{
gaspi_verify_null_ptr(elem_max);
*elem_max = ((1 << 8) - 1);
return GASPI_SUCCESS;
}
gaspi_return_t
pgaspi_version (float *const version)
{
gaspi_verify_null_ptr(version);
*version = GASPI_VERSION;
return GASPI_SUCCESS;
}
gaspi_return_t
pgaspi_network_type (gaspi_network_t * const network_type)
{
gaspi_verify_null_ptr(network_type);
*network_type = glb_gaspi_cfg.network;
return GASPI_SUCCESS;
}
gaspi_return_t
pgaspi_time_ticks (gaspi_cycles_t * const ticks)
{
gaspi_verify_null_ptr(ticks);
*ticks = gaspi_get_cycles ();
return GASPI_SUCCESS;
}
gaspi_return_t
pgaspi_transfer_size_max (gaspi_size_t * const transfer_size_max)
{
gaspi_verify_null_ptr(transfer_size_max);
*transfer_size_max = GASPI_MAX_TSIZE_C;
return GASPI_SUCCESS;
}
gaspi_return_t
pgaspi_passive_transfer_size_max (gaspi_size_t * const passive_transfer_size_max)
{
gaspi_verify_null_ptr(passive_transfer_size_max);
*passive_transfer_size_max = GASPI_MAX_TSIZE_P;
return GASPI_SUCCESS;
}
gaspi_return_t
pgaspi_statistic_counter_max(gaspi_number_t* counter_max)
{
gaspi_verify_null_ptr(counter_max);
*counter_max = GASPI_STATS_COUNTER_NUM_MAX;
return GASPI_SUCCESS;
}
gaspi_return_t
pgaspi_initialized (int *initialized)
{
gaspi_verify_null_ptr(initialized);
*initialized = (glb_gaspi_init != 0);
return GASPI_SUCCESS;
}
gaspi_return_t
pgaspi_proc_local_rank(gaspi_rank_t * const local_rank)
{
gaspi_verify_init("gaspi_proc_local_rank");
gaspi_verify_null_ptr(local_rank);
*local_rank = (gaspi_rank_t) glb_gaspi_ctx.localSocket;
return GASPI_SUCCESS;
}
gaspi_return_t
pgaspi_machine_type (char const machine_type[16])
{
gaspi_verify_null_ptr(machine_type);
memset ((void *) machine_type, 0, 16);
snprintf ((char *) machine_type, 16, "%s", glb_gaspi_ctx.mtyp);
return GASPI_SUCCESS;
}
gaspi_return_t
pgaspi_proc_num (gaspi_rank_t * const proc_num)
{
gaspi_verify_init("gaspi_proc_num");
gaspi_verify_null_ptr(proc_num);
*proc_num = (gaspi_rank_t) glb_gaspi_ctx.tnc;
return GASPI_SUCCESS;
}
gaspi_return_t
pgaspi_queue_size (const gaspi_queue_id_t queue,
gaspi_number_t * const queue_size)
{
gaspi_verify_queue(queue);
gaspi_verify_null_ptr(queue_size);
*queue_size = (gaspi_number_t) glb_gaspi_ctx.ne_count_c[queue];
return GASPI_SUCCESS;
}
gaspi_return_t
pgaspi_proc_rank (gaspi_rank_t * const rank)
{
gaspi_verify_init("gaspi_proc_rank");
gaspi_verify_null_ptr(rank);
*rank = (gaspi_rank_t) glb_gaspi_ctx.rank;
return GASPI_SUCCESS;
}
gaspi_return_t
gaspi_threads_register(gaspi_int * tid)
{
gaspi_verify_null_ptr(tid);
const int tID = __sync_fetch_and_add(&__gaspiThreadsGlobalIDCnt,1);
__gaspi_thread_tid = tID;
__gaspi_thread_tnc = __gaspiThreadsActivated;
*tid = tID;
return GASPI_SUCCESS;
}
gaspi_return_t
gaspi_threads_get_tid(gaspi_int *const tid)
{
gaspi_verify_null_ptr(tid);
if(__gaspiThreadsGlobalIDCnt == -1)
{
gaspi_printf("gaspi_threads: not initialized !\n");
return GASPI_ERROR;
}
*tid = __gaspi_thread_tid;
return GASPI_SUCCESS;
}
gaspi_return_t
gaspi_threads_get_total(gaspi_int *const num)
{
gaspi_verify_null_ptr(num);
if(__gaspiThreadsGlobalIDCnt == -1)
{
gaspi_printf("gaspi_threads: not initialized !\n");
return GASPI_ERROR;
}
*num = __gaspi_thread_tnc;
return GASPI_SUCCESS;
}
gaspi_return_t
gaspi_number_of_GPUs(gaspi_gpu_num *gpus)
{
gaspi_verify_init("gaspi_number_of_GPUs");
gaspi_verify_null_ptr(gpus);
if( 0 == glb_gaspi_ctx.use_gpus )
{
gaspi_print_error("GPUs are not initialized.");
return GASPI_ERROR;
}
*gpus = glb_gaspi_ctx.gpu_count;
return GASPI_SUCCESS;
}
gaspi_return_t
gaspi_gpu_number(gaspi_number_t* num_gpus)
{
gaspi_verify_init("gaspi_gpu_number");
gaspi_verify_null_ptr(num_gpus);
gaspi_context_t const * const gctx = &glb_gaspi_ctx;
if( 0 == gctx->use_gpus )
{
gaspi_print_error("GPUs are not initialized.");
return GASPI_ERROR;
}
*num_gpus = gctx->gpu_count;
return GASPI_SUCCESS;
}
gaspi_return_t
pgaspi_proc_local_num(gaspi_rank_t * const local_num)
{
gaspi_rank_t rank;
gaspi_verify_init("gaspi_proc_local_num");
gaspi_verify_null_ptr(local_num);
if(pgaspi_proc_rank(&rank) != GASPI_SUCCESS)
return GASPI_ERROR;
while(glb_gaspi_ctx.poff[rank + 1] != 0)
rank++;
*local_num = (gaspi_rank_t) ( glb_gaspi_ctx.poff[rank] + 1);
return GASPI_SUCCESS;
}
/* TODO: Not clear to me why we need this function */
gaspi_return_t
gaspi_GPU_ids(gaspi_gpu_t *gpu_ids)
{
gaspi_verify_init("gaspi_GPU_ids");
gaspi_verify_null_ptr(gpu_ids);
if( 0 == glb_gaspi_ctx.use_gpus )
{
gaspi_print_error("GPUs are not initialized.");
return GASPI_ERROR;
}
int i;
for (i = 0; i < glb_gaspi_ctx.gpu_count; i++)
gpu_ids[i] = gpus[i].device_id;
return GASPI_SUCCESS;
}
gaspi_return_t
pgaspi_state_vec_get (gaspi_state_vector_t state_vector)
{
int i, j;
gaspi_verify_null_ptr(state_vector);
gaspi_verify_init("gaspi_state_vec_get");
memset (state_vector, 0, (size_t) glb_gaspi_ctx.tnc);
for (i = 0; i < glb_gaspi_ctx.tnc; i++)
{
for (j = 0; j < (GASPI_MAX_QP + 3); j++)
{
state_vector[i] |= glb_gaspi_ctx.qp_state_vec[j][i];
}
}
return GASPI_SUCCESS;
}
gaspi_return_t
pgaspi_notify (const gaspi_segment_id_t segment_id_remote,
const gaspi_rank_t rank,
const gaspi_notification_id_t notification_id,
const gaspi_notification_t notification_value,
const gaspi_queue_id_t queue,
const gaspi_timeout_t timeout_ms)
{
gaspi_verify_init("gaspi_notify");
gaspi_verify_segment(segment_id_remote);
gaspi_verify_null_ptr(glb_gaspi_ctx.rrmd[segment_id_remote]);
gaspi_verify_rank(rank);
gaspi_verify_queue(queue);
if(notification_value == 0)
return GASPI_ERR_INV_NOTIF_VAL;
gaspi_return_t eret = GASPI_ERROR;
if(lock_gaspi_tout (&glb_gaspi_ctx.lockC[queue], timeout_ms))
return GASPI_TIMEOUT;
if( GASPI_ENDPOINT_DISCONNECTED == glb_gaspi_ctx.ep_conn[rank].cstat )
{
eret = pgaspi_connect((gaspi_rank_t) rank, timeout_ms);
if ( eret != GASPI_SUCCESS)
{
goto endL;
}
}
eret = pgaspi_dev_notify(segment_id_remote, rank,
notification_id, notification_value,
queue);
glb_gaspi_ctx.ne_count_c[queue]++;
endL:
unlock_gaspi (&glb_gaspi_ctx.lockC[queue]);
return eret;
}
gaspi_return_t
pgaspi_cpu_frequency (gaspi_float * const cpu_mhz)
{
gaspi_verify_null_ptr(cpu_mhz);
if (!glb_gaspi_init)
{
*cpu_mhz = gaspi_get_cpufreq ();
}
else
{
*cpu_mhz = glb_gaspi_ctx.mhz;
}
if (*cpu_mhz == 0.0f)
{
gaspi_print_error ("Failed to get CPU frequency");
return GASPI_ERROR;
}
return GASPI_SUCCESS;
}
gaspi_return_t
pgaspi_time_get (gaspi_time_t * const wtime)
{
gaspi_verify_null_ptr(wtime);
float cycles_to_msecs;
if (!glb_gaspi_init)
{
const float cpu_mhz = gaspi_get_cpufreq ();
cycles_to_msecs = 1.0f / (cpu_mhz * 1000.0f);
}
else
{
cycles_to_msecs = glb_gaspi_ctx.cycles_to_msecs;
}
const gaspi_cycles_t s1 = gaspi_get_cycles ();
*wtime = (gaspi_time_t) (s1 * cycles_to_msecs);
return GASPI_SUCCESS;
}
