int qthread_multinode_run(void)
{
aligned_t val;
if (0 == initialized) { return 1; }
qthread_debug(MULTINODE_CALLS, "[%d] begin qthread_multinode_run\n", my_rank);
qthread_internal_net_driver_barrier();
if (0 != my_rank) {
struct die_msg_t msg;
qthread_readFE(&val, &time_to_die);
qthread_debug(MULTINODE_DETAILS, "[%d] time to die\n", my_rank);
msg.my_rank = my_rank;
qthread_internal_net_driver_send(0, DIE_MSG_TAG, &msg, sizeof(msg));
qthread_finalize();
exit(0);
}
qthread_debug(MULTINODE_CALLS, "[%d] end qthread_multinode_run\n", my_rank);
return QTHREAD_SUCCESS;
}
void Qthread::initialize( int thread_count )
{
// Environment variable: QTHREAD_NUM_SHEPHERDS
// Environment variable: QTHREAD_NUM_WORKERS_PER_SHEP
// Environment variable: QTHREAD_HWPAR
{
char buffer[256];
snprintf(buffer,sizeof(buffer),"QTHREAD_HWPAR=%d",thread_count);
putenv(buffer);
}
const bool ok_init = ( QTHREAD_SUCCESS == qthread_initialize() ) &&
( thread_count == qthread_num_shepherds() * qthread_num_workers_local(NO_SHEPHERD) ) &&
( thread_count == qthread_num_workers() );
bool ok_symmetry = true ;
if ( ok_init ) {
Impl::s_number_shepherds = qthread_num_shepherds();
Impl::s_number_workers_per_shepherd = qthread_num_workers_local(NO_SHEPHERD);
Impl::s_number_workers = Impl::s_number_shepherds * Impl::s_number_workers_per_shepherd ;
for ( int i = 0 ; ok_symmetry && i < Impl::s_number_shepherds ; ++i ) {
ok_symmetry = ( Impl::s_number_workers_per_shepherd == qthread_num_workers_local(i) );
}
}
if ( ! ok_init || ! ok_symmetry ) {
std::ostringstream msg ;
msg << "Kokkos::Qthread::initialize(" << thread_count << ") FAILED" ;
msg << " : qthread_num_shepherds = " << qthread_num_shepherds();
msg << " : qthread_num_workers_per_shepherd = " << qthread_num_workers_local(NO_SHEPHERD);
msg << " : qthread_num_workers = " << qthread_num_workers();
if ( ! ok_symmetry ) {
msg << " : qthread_num_workers_local = {" ;
for ( int i = 0 ; i < Impl::s_number_shepherds ; ++i ) {
msg << " " << qthread_num_workers_local(i) ;
}
msg << " }" ;
}
Impl::s_number_workers = 0 ;
Impl::s_number_shepherds = 0 ;
Impl::s_number_workers_per_shepherd = 0 ;
if ( ok_init ) { qthread_finalize(); }
Kokkos::Impl::throw_runtime_exception( msg.str() );
}
Impl::QthreadExec::resize_worker_scratch( 256 , 256 );
// Init the array for used for arbitrarily sized atomics
Impl::init_lock_array_host_space();
}
void Qthread::finalize()
{
Impl::QthreadExec::clear_workers();
if ( Impl::s_number_workers ) {
qthread_finalize();
}
Impl::s_number_workers = 0 ;
Impl::s_number_shepherds = 0 ;
Impl::s_number_workers_per_shepherd = 0 ;
}
static void *initializer(void *junk)
{
qthread_initialize();
MACHINE_FENCE;
chpl_qthread_done_initializing = 1;
qthread_syncvar_readFF(NULL, &canexit);
qthread_finalize();
MACHINE_FENCE;
done_finalizing = 1;
return NULL;
}
static void *initializer(void *junk)
{
qthread_initialize();
(void) pthread_mutex_lock(&done_init_final_mux); // implicit memory fence
chpl_qthread_done_initializing = 1;
(void) pthread_mutex_unlock(&done_init_final_mux);
qthread_syncvar_readFF(NULL, &canexit);
qthread_finalize();
(void) pthread_mutex_lock(&done_init_final_mux); // implicit memory fence
done_finalizing = 1;
(void) pthread_mutex_unlock(&done_init_final_mux);
return NULL;
}
int main(int argc,
char *argv[])
{
CHECK_VERBOSE();
aligned_t tmp, ret = 0;
int retval;
long foobar = 1234567890;
setenv("QT_MULTINODE","yes",1);
qthread_initialize();
my_id = qthread_multinode_rank();
world_size = qthread_multinode_size();
iprintf("(%03d) Rank %d of %d is alive\n", my_id, my_id, world_size);
retval = qthread_multinode_register(2, returner);
if (retval != 0){
fprintf(stderr, "(%03d) multinode_register returned %d\n", my_id, retval);
return 1;
}
qthread_multinode_run();
if (my_id != 0) return 2;
int target = (world_size > 1) ? 1 : 0;
retval = qthread_fork_remote(returner, &foobar, &ret, target, sizeof(long));
if (retval != 0) {
fprintf(stderr, "(%03d) fork_remote returned %d\n", my_id, retval);
return 3;
}
retval = qthread_readFE(&tmp, &ret);
iprintf("(%03d) returner returned %ld\n", my_id, (long) tmp);
if (retval != 0) {
fprintf(stderr, "(%03d) readFE returned %d (%d)\n", my_id, retval, (int) tmp);
return 4;
}
qthread_finalize();
return (tmp == foobar) ? 0 : 5;
}
int main(int argc,
char *argv[])
{
qtimer_t t;
assert(qthread_initialize() == QTHREAD_SUCCESS);
CHECK_VERBOSE();
t = qtimer_create();
assert(t);
qtimer_start(t);
qtimer_stop(t);
if (qtimer_secs(t) == 0) {
fprintf(stderr, "qtimer_secs(t) reported zero length time.\n");
} else if (qtimer_secs(t) < 0) {
fprintf(stderr, "qtimer_secs(t) thinks time went backwards (%g).\n",
qtimer_secs(t));
}
iprintf("time to find self and assert it: %g secs\n", qtimer_secs(t));
qtimer_start(t);
qtimer_stop(t);
assert(qtimer_secs(t) >= 0.0);
if (qtimer_secs(t) == 0.0) {
iprintf("inlining reduces calltime to zero (apparently)\n");
} else {
iprintf("smallest measurable time: %g secs\n", qtimer_secs(t));
}
qtimer_destroy(t);
// Now to test fastrand
ks_test();
runs();
autocorrelation();
qthread_finalize();
return 0;
}
