void thread_stub(void (*thread_main)(void *), void *arg) {
interrupts_set(1);
Tid ret;
thread_main(arg); // call thread_main() function with arg
ret = thread_exit(THREAD_SELF);
assert(ret == THREAD_NONE);
exit(0);
}
int main()
{
thread_main(0);
// The dtor for a in the main thread is run after main exits, so we
// return 1 now and override the return value with _exit above.
return 1;
}
void thread_stub(void (*thread_main)(void *), void *arg)
{
Tid ret;
thread_main(arg);
ret = thread_exit(THREAD_SELF);
assert(ret == THREAD_NONE);
free(running_thread);
running_thread = NULL;
free(array_of_threadids);
array_of_threadids = NULL;
free(queue);
queue = NULL;
exit(0);
}
int main()
{
pthread_t thread;
thread_main(0);
pthread_create (&thread, 0, thread_main, 0);
pthread_join(thread, 0);
pthread_create (&thread, 0, thread_main, 0);
pthread_join(thread, 0);
// The dtor for a in the main thread is run after main exits, so we
// return 1 now and override the return value with _exit above.
if (c != 3 || d != 2)
__builtin_abort();
return 1;
}
void ConsoleMode(void *mem)
{
/*** Console Mode *********************************************/
while (AKD_TRUE) {
/* Select operation */
switch (Menu_Main()) {
case MODE_Measure:
/* Reset flag */
g_stopRequest = 0;
/* Measurement routine */
thread_main(mem);
break;
case MODE_Quit:
return;
default:
AKMERROR_STR("Unknown operation mode.\n");
break;
}
}
}
int main(int argc, char** argv)
{
mc_param_t param;
mc_result_t result;
double t1, t2;
long seed;
int nthreads;
srandom(clock());
process_args(argc, argv, ¶m);
mc_result_init(&result);
t1 = omp_get_wtime();
#pragma offload target(mic)
#pragma omp parallel shared(result, param, nthreads) private(seed)
{
#pragma omp single
nthreads = omp_get_num_threads();
#pragma omp critical
seed = random();
thread_main(&result, ¶m, seed);
}
t2 = omp_get_wtime();
/* Print results */
if (param.verbose) {
print_params(¶m);
print_results(&result);
printf("%d threads (OpenMP): %e s\n", nthreads, t2-t1);
} else {
printf("%e\n", t2-t1);
}
return 0;
}
//-- main
//
int main(void)
{
uint8_t i;
drv_pwm_config_t pwm_params;
drv_adc_config_t adc_params;
serialPort_t* loopbackPort = NULL;
//-- 하드웨어 초기화
//
systemInit();
#ifdef USE_LAME_PRINTF
init_printf(NULL, _putc);
#endif
checkFirstTime(false);
readEEPROM();
// configure power ADC
if (mcfg.power_adc_channel > 0 && (mcfg.power_adc_channel == 1 || mcfg.power_adc_channel == 9))
adc_params.powerAdcChannel = mcfg.power_adc_channel;
else
{
adc_params.powerAdcChannel = 0;
mcfg.power_adc_channel = 0;
}
adcInit(&adc_params);
initBoardAlignment();
// We have these sensors; SENSORS_SET defined in board.h depending on hardware platform
sensorsSet(SENSORS_SET);
mixerInit(); // this will set core.useServo var depending on mixer type
// when using airplane/wing mixer, servo/motor outputs are remapped
if (mcfg.mixerConfiguration == MULTITYPE_AIRPLANE || mcfg.mixerConfiguration == MULTITYPE_FLYING_WING)
pwm_params.airplane = true;
else
pwm_params.airplane = false;
//pwm_params.useUART = feature(FEATURE_GPS) || feature(FEATURE_SERIALRX); // spektrum/sbus support uses UART too
pwm_params.useUART = 0;
pwm_params.useSoftSerial = feature(FEATURE_SOFTSERIAL);
pwm_params.usePPM = feature(FEATURE_PPM);
pwm_params.enableInput = !feature(FEATURE_SERIALRX); // disable inputs if using spektrum
pwm_params.useServos = core.useServo;
pwm_params.extraServos = cfg.gimbal_flags & GIMBAL_FORWARDAUX;
pwm_params.motorPwmRate = mcfg.motor_pwm_rate;
pwm_params.servoPwmRate = mcfg.servo_pwm_rate;
pwm_params.idlePulse = PULSE_1MS; // standard PWM for brushless ESC (default, overridden below)
if (feature(FEATURE_3D))
pwm_params.idlePulse = mcfg.neutral3d;
if (pwm_params.motorPwmRate > 500)
pwm_params.idlePulse = 0; // brushed motors
pwm_params.servoCenterPulse = mcfg.midrc;
pwm_params.failsafeThreshold = cfg.failsafe_detect_threshold;
switch (mcfg.power_adc_channel) {
case 1:
pwm_params.adcChannel = PWM2;
break;
case 9:
pwm_params.adcChannel = PWM8;
break;
default:
pwm_params.adcChannel = 0;
break;
}
pwmInit(&pwm_params);
// configure PWM/CPPM read function and max number of channels. spektrum or sbus below will override both of these, if enabled
for (i = 0; i < RC_CHANS; i++)
rcData[i] = 1502;
rcReadRawFunc = pwmReadRawRC;
core.numRCChannels = MAX_INPUTS;
if (feature(FEATURE_SERIALRX)) {
switch (mcfg.serialrx_type) {
case SERIALRX_SPEKTRUM1024:
case SERIALRX_SPEKTRUM2048:
spektrumInit(&rcReadRawFunc);
break;
case SERIALRX_SBUS:
sbusInit(&rcReadRawFunc);
break;
case SERIALRX_SUMD:
sumdInit(&rcReadRawFunc);
break;
#if defined(SKYROVER)
case SERIALRX_HEXAIRBOT:
hexairbotInit(&rcReadRawFunc);
break;
#endif
}
} else { // spektrum and GPS are mutually exclusive
// Optional GPS - available in both PPM and PWM input mode, in PWM input, reduces number of available channels by 2.
// gpsInit will return if FEATURE_GPS is not enabled.
// Sanity check below - protocols other than NMEA do not support baud rate autodetection
if (mcfg.gps_type > 0 && mcfg.gps_baudrate < 0)
mcfg.gps_baudrate = 0;
gpsInit(mcfg.gps_baudrate);
}
#ifdef SONAR
// sonar stuff only works with PPM
if (feature(FEATURE_PPM)) {
if (feature(FEATURE_SONAR))
Sonar_init();
}
#endif
LED1_ON;
LED0_OFF;
for (i = 0; i < 10; i++) {
LED1_TOGGLE;
LED0_TOGGLE;
delay(25);
BEEP_ON;
delay(25);
BEEP_OFF;
}
LED0_OFF;
LED1_OFF;
serialInit(mcfg.serial_baudrate);
#if _DEF_MW_PORT == PORT_UART1
core.menuport = uartOpen(USART1, NULL, mcfg.serial_baudrate, MODE_RXTX);
core.debugport = core.menuport;
#else
core.menuport = uartOpen(USART1, NULL, mcfg.serial_baudrate, MODE_RXTX);
core.debugport = core.menuport;
#endif
DEBUG_PRINT("Booting.. V140926R1\r\n");
// drop out any sensors that don't seem to work, init all the others. halt if gyro is dead.
sensorsAutodetect();
imuInit(); // Mag is initialized inside imuInit
// Check battery type/voltage
if (feature(FEATURE_VBAT))
batteryInit();
if (feature(FEATURE_SOFTSERIAL)) {
setupSoftSerial1(mcfg.softserial_baudrate, mcfg.softserial_inverted);
#ifdef SOFTSERIAL_LOOPBACK
loopbackPort = (serialPort_t*)&(softSerialPorts[0]);
serialPrint(loopbackPort, "LOOPBACK ENABLED\r\n");
#endif
}
if (feature(FEATURE_TELEMETRY))
initTelemetry();
previousTime = micros();
if (mcfg.mixerConfiguration == MULTITYPE_GIMBAL)
calibratingA = CALIBRATING_ACC_CYCLES;
calibratingG = CALIBRATING_GYRO_CYCLES;
calibratingB = CALIBRATING_BARO_CYCLES; // 10 seconds init_delay + 200 * 25 ms = 15 seconds before ground pressure settles
f.SMALL_ANGLES_25 = 1;
//-- 센서초기화 루틴때문에 USB 통신안되는것 때문에 마지막으로 순서 변경
//
Hw_VCom_Init();
DEBUG_PRINT("Start\r\n");
//-- thread 시작
//
thread_main();
while(1)
{
}
}
int main(void)
{
return thread_main();
}
int main(){
while(1){ __CPROVER_ASYNC_01: thread_main(); }
}
int main(){
EBStack_init();
while(1){ __CPROVER_ASYNC_01: thread_main(); }
}
int main(int argc, char *argv[])
{
int ch;
extern char *optarg;
int i, j, r;
thread_t threads[MAX_TPP];
/* init MP */
MP_INIT(argc,argv);
MP_PROCS(&size);
MP_MYID(&rank);
while ((ch = getopt(argc, argv, "t:s:i:d:h")) != -1) {
switch(ch) {
case 't': /* # of threads */
tpp = atoi(optarg);
if (tpp < 1 || tpp > MAX_TPP) {
PRINTF0("\"%s\" is improper value for -t, should be a "
"number between 1 and %d(MAX_TPP)\n",
optarg, MAX_TPP);
usage();
}
break;
case 'i': /* # of iterations */
iters = atoi(optarg);
if (iters < 1) {
PRINTF0("\"%s\" is improper value for -t, should be a "
"number equal or larger than 1\n", optarg);
usage();
}
break;
case 's': /* # of elements in the array */
asize = atoi(optarg);
if (iters < 1) {
PRINTF0("\"%s\" is improper value for -s, should be a "
"number equal or larger than 1\n", optarg);
usage();
}
break;
case 'd': delay = atoi(optarg); break; /* delay before start */
case 'h': usage(); break; /* print usage info */
}
}
#ifdef NOTHREADS
tpp = 1;
PRINTF0("Warning: NOTHREADS debug symbol is set -- running w/o threads\n");
#endif
th_size = size * tpp;
PRINTF0("\nTest of multi-threaded capabilities:\n"
"%d threads per process (%d threads total),\n"
"%d array elements of size %d,\n"
"%d iteration(s)\n\n", tpp, th_size, asize, sizeof(atype_t), iters);
if (delay) {
printf("%d: %d\n", rank, getpid());
fflush(stdout);
sleep(delay);
MP_BARRIER();
}
TH_INIT(size,tpp);
for (i = 0; i < tpp; i++) th_rank[i] = rank * tpp + i;
#if defined(DEBUG) && defined(LOG2FILE)
for (i = 0; i < tpp; i++) {
fname[10] = '0' + th_rank[i] / 100;
fname[11] = '0' + th_rank[i] % 100 / 10;
fname[12] = '0' + th_rank[i] % 10;
dbg[i] = fopen(fname, "w");
}
#endif
for (i = 0; i < tpp; i++)
prndbg(i, "proc %d, thread %d(%d):\n", rank, i, th_rank[i]);
/* init ARMCI */
ARMCI_Init();
/* set global seed (to ensure same random sequence across procs) */
time_seed = (unsigned)time(NULL);
armci_msg_brdcst(&time_seed, sizeof(time_seed), 0);
srand(time_seed); rand();
prndbg(0, "seed = %u\n", time_seed);
/* random pairs */
pairs = calloc(th_size, sizeof(int));
for (i = 0; i < th_size; i++) pairs[i] = -1;
for (i = 0; i < th_size; i++) {
if (pairs[i] != -1) continue;
r = RND(0, th_size);
while (i == r || pairs[r] != -1 ) r = RND(0, th_size);
pairs[i] = r; pairs[r] = i;
}
for (i = 0, cbufl = 0; i < th_size; i++)
cbufl += sprintf(cbuf + cbufl, " %d->%d|%d->%d",
i, pairs[i], pairs[i], pairs[pairs[i]]);
prndbg(0, "random pairs:%s\n", cbuf);
/* random targets */
rnd_tgts = calloc(th_size, sizeof(int));
for (i = 0, cbufl = 0; i < th_size; i++) {
rnd_tgts[i] = RND(0, th_size);
if (rnd_tgts[i] == i) { i--; continue; }
cbufl += sprintf(cbuf + cbufl, " %d", rnd_tgts[i]);
}
prndbg(0, "random targets:%s\n", cbuf);
/* random one */
rnd_one = RND(0, th_size);
prndbg(0, "random one = %d\n", rnd_one);
assert(ptrs1 = calloc(th_size, sizeof(void *)));
assert(ptrs2 = calloc(th_size, sizeof(void *)));
#ifdef NOTHREADS
thread_main((void *)(long)0);
#else
for (i = 0; i < tpp; i++) THREAD_CREATE(threads + i, thread_main, (void *)(long)i);
for (i = 0; i < tpp; i++) THREAD_JOIN(threads[i], NULL);
#endif
MP_BARRIER();
PRINTF0("Tests Completed\n");
/* clean up */
#if defined(DEBUG) && defined(LOG2FILE)
for (i = 0; i < tpp; i++) fclose(dbg[i]);
#endif
ARMCI_Finalize();
TH_FINALIZE();
MP_FINALIZE();
return 0;
}
void rt_entry_thread_main(void* parameter)
{
extern int thread_main(void);
thread_main();
}
static void main_thread_entry(void* parameter)
{
extern void thread_main(void);
thread_main();
}
int main(int argc, char **argv)
{
static int *A, *B, *C, *D, *E, *F, *G;
gasnet_node_t myproc, i;
int pollers = 0;
int j;
/* call startup */
GASNET_Safe(gasnet_init(&argc, &argv));
int arg = 1;
int help = 0;
while (argc > arg) {
if (!strcmp(argv[arg], "-p")) {
#if GASNET_PAR
++arg;
if (argc > arg) { pollers = atoi(argv[arg]); arg++; }
else help = 1;
#else
if (0 == gasnet_mynode()) {
fprintf(stderr, "testcoll %s\n", GASNET_CONFIG_STRING);
fprintf(stderr, "ERROR: The -p option is only available in the PAR configuration.\n");
fflush(NULL);
}
sleep(1);
gasnet_exit(1);
#endif
} else if (argv[arg][0] == '-') {
help = 1;
++arg;
} else break;
}
if (argc > arg) {
iters = atoi(argv[arg]);
++arg;
}
if (iters < 1) {
iters = 1000;
}
#if GASNET_PAR
if (argc > arg) {
threads = atoi(argv[arg]);
++arg;
}
threads = test_thread_limit(threads);
if (threads < 1) {
printf("ERROR: Threads must be between 1 and %d\n", TEST_MAXTHREADS);
exit(EXIT_FAILURE);
}
#endif
/* get SPMD info */
myproc = gasnet_mynode();
numprocs = gasnet_nodes();
images = numprocs * threads;
datasize = iters * (3 + 4 * images);
GASNET_Safe(gasnet_attach(NULL, 0, TEST_SEGSZ_REQUEST, TEST_MINHEAPOFFSET));
#if GASNET_PAR
#define USAGE "[options] (iters) (threadcnt)\n" \
" The -p option gives the number of polling threads, specified as\n" \
" a non-negative integer argument (default is no polling threads).\n"
#else
#define USAGE "(iters)\n"
#endif
test_init("testcoll",0,USAGE);
TEST_SET_WAITMODE(threads + pollers);
if (argc > arg || help) test_usage();
MSG0("Running coll test(s) with %d iterations.", iters);
R = test_malloc(iters*sizeof(int));
/* Number if ints to store */
/* Carve some variables out of the (aligned) segment: */
Aw = test_malloc(iters * sizeof(int *));
Bw = test_malloc(iters * sizeof(int *));
Cw = test_malloc(iters * sizeof(int *));
Dw = test_malloc(iters * sizeof(int *));
Ew = test_malloc(iters * sizeof(int *));
Fw = test_malloc(iters * sizeof(int *));
Gw = test_malloc(iters * sizeof(int *));
A = (int *)TEST_MYSEG(); /* int [1*iters] */
B = A + 1*iters; /* int [1*iters] */
C = B + 1*iters; /* int [N*iters] */
D = C + images*iters; /* int [N*iters] */
E = D + images*iters; /* int [1*iters] */
F = E + 1*iters; /* int [N*iters] */
G = F + images*iters; /* int [N*iters] */
for (j = 0; j < iters; ++j) {
Aw[j] = A + j;
Bw[j] = B + j;
Cw[j] = C + j*images;
Dw[j] = D + j*images;
Ew[j] = E + j;
Fw[j] = F + j*images;
Gw[j] = G + j*images;
}
/* The unaligned equivalents */
Av = test_malloc_2D(iters, images * sizeof(int *));
Bv = test_malloc_2D(iters, images * sizeof(int *));
Cv = test_malloc_2D(iters, images * sizeof(int *));
Dv = test_malloc_2D(iters, images * sizeof(int *));
Ev = test_malloc_2D(iters, images * sizeof(int *));
Fv = test_malloc_2D(iters, images * sizeof(int *));
Gv = test_malloc_2D(iters, images * sizeof(int *));
for (i = 0; i < images; ++i) {
/* Using (TEST_SEG(n) + n) yields unaligned even when the segments are aligned.
This is to help catch any case where addresses might have been misused that
might go undetected if the addresses were aligned */
A = (int *)TEST_SEG(i/threads) + (i/threads) + datasize*(i%threads);
B = A + 1*iters;
C = B + 1*iters;
D = C + images*iters;
E = D + images*iters;
F = E + 1*iters;
G = F + images*iters;
for (j = 0; j < iters; ++j) {
Av[j][i] = A + j;
Bv[j][i] = B + j;
Cv[j][i] = C + j*images;
Dv[j][i] = D + j*images;
Ev[j][i] = E + j;
Fv[j][i] = F + j*images;
Gv[j][i] = G + j*images;
}
}
BARRIER();
#if GASNET_PAR
MSG("Forking %d gasnet threads (%d active, %d polling)", threads+pollers, threads, pollers);
{
int i;
thread_data_t* tt_thread_data = test_malloc(threads*sizeof(thread_data_t));
for (i = 0; i < threads; i++) {
tt_thread_data[i].myproc = myproc;
tt_thread_data[i].local_id = i;
tt_thread_data[i].mythread = i + threads * myproc;
tt_thread_data[i].peerthread = i + threads * (((myproc ^ 1) == numprocs) ? myproc : (myproc ^ 1));
}
test_createandjoin_pthreads(threads, &thread_main, tt_thread_data, sizeof(tt_thread_data[0]));
test_free(tt_thread_data);
}
#else
{ thread_data_t td;
td.myproc = myproc;
td.local_id = 0;
td.mythread = myproc;
td.peerthread = ((myproc ^ 1) == numprocs) ? myproc : (myproc ^ 1);
thread_main(&td);
}
#endif
BARRIER();
test_free(Aw);
test_free(Bw);
test_free(Cw);
test_free(Dw);
test_free_2D(Av);
test_free_2D(Bv);
test_free_2D(Cv);
test_free_2D(Dv);
test_free(R);
MSG("done.");
gasnet_exit(0);
return 0;
}
int main(int argc, char **argv)
{
static int *A, *B, *C, *D, *E, *F, *G;
gasnet_node_t myproc, i;
int j;
/* call startup */
GASNET_Safe(gasnet_init(&argc, &argv));
if (argc > 1) {
iters = atoi(argv[1]);
}
if (iters < 1) {
iters = 1000;
}
#if GASNET_PAR
if (argc > 2) {
threads = atoi(argv[2]);
}
threads = test_thread_limit(threads);
if (threads < 1) {
printf("ERROR: Threads must be between 1 and %d\n", TEST_MAXTHREADS);
exit(EXIT_FAILURE);
}
#endif
/* get SPMD info */
myproc = gasnet_mynode();
numprocs = gasnet_nodes();
images = numprocs * threads;
datasize = iters * (3 + 4 * images);
GASNET_Safe(gasnet_attach(NULL, 0, TEST_SEGSZ_REQUEST, TEST_MINHEAPOFFSET));
test_init("testcoll",0,"(iters) (threadcnt)");
TEST_SET_WAITMODE(threads);
if (argc > 3) test_usage();
MSG0("Running coll test(s) with %d iterations.", iters);
R = test_malloc(iters*sizeof(int));
TEST_SRAND(1);
/* Number if ints to store */
/* Carve some variables out of the (aligned) segment: */
Aw = test_malloc(iters * sizeof(int *));
Bw = test_malloc(iters * sizeof(int *));
Cw = test_malloc(iters * sizeof(int *));
Dw = test_malloc(iters * sizeof(int *));
Ew = test_malloc(iters * sizeof(int *));
Fw = test_malloc(iters * sizeof(int *));
Gw = test_malloc(iters * sizeof(int *));
A = (int *)TEST_MYSEG(); /* int [1*iters] */
B = A + 1*iters; /* int [1*iters] */
C = B + 1*iters; /* int [N*iters] */
D = C + images*iters; /* int [N*iters] */
E = D + images*iters; /* int [1*iters] */
F = E + 1*iters; /* int [N*iters] */
G = F + images*iters; /* int [N*iters] */
for (j = 0; j < iters; ++j) {
Aw[j] = A + j;
Bw[j] = B + j;
Cw[j] = C + j*images;
Dw[j] = D + j*images;
Ew[j] = E + j;
Fw[j] = F + j*images;
Gw[j] = G + j*images;
}
/* The unaligned equivalents */
Av = test_malloc_2D(iters, images * sizeof(int *));
Bv = test_malloc_2D(iters, images * sizeof(int *));
Cv = test_malloc_2D(iters, images * sizeof(int *));
Dv = test_malloc_2D(iters, images * sizeof(int *));
Ev = test_malloc_2D(iters, images * sizeof(int *));
Fv = test_malloc_2D(iters, images * sizeof(int *));
Gv = test_malloc_2D(iters, images * sizeof(int *));
for (i = 0; i < images; ++i) {
/* Using (TEST_SEG(n) + n) yields unaligned even when the segments are aligned.
This is to help catch any case where addresses might have been misused that
might go undetected if the addresses were aligned */
A = (int *)TEST_SEG(i/threads) + (i/threads) + datasize*(i%threads);
B = A + 1*iters;
C = B + 1*iters;
D = C + images*iters;
E = D + images*iters;
F = E + 1*iters;
G = F + images*iters;
for (j = 0; j < iters; ++j) {
Av[j][i] = A + j;
Bv[j][i] = B + j;
Cv[j][i] = C + j*images;
Dv[j][i] = D + j*images;
Ev[j][i] = E + j;
Fv[j][i] = F + j*images;
Gv[j][i] = G + j*images;
}
}
BARRIER();
#if GASNET_PAR
MSG("Forking %d gasnet threads", threads);
{
int i;
thread_data_t* tt_thread_data = test_malloc(threads*sizeof(thread_data_t));
for (i = 0; i < threads; i++) {
tt_thread_data[i].myproc = myproc;
tt_thread_data[i].local_id = i;
tt_thread_data[i].mythread = i + threads * myproc;
tt_thread_data[i].peerthread = i + threads * (((myproc ^ 1) == numprocs) ? myproc : (myproc ^ 1));
}
test_createandjoin_pthreads(threads, &thread_main, tt_thread_data, sizeof(tt_thread_data[0]));
test_free(tt_thread_data);
}
#else
{ thread_data_t td;
td.myproc = myproc;
td.local_id = 0;
td.mythread = myproc;
td.peerthread = ((myproc ^ 1) == numprocs) ? myproc : (myproc ^ 1);
thread_main(&td);
}
#endif
BARRIER();
test_free(Aw);
test_free(Bw);
test_free(Cw);
test_free(Dw);
test_free_2D(Av);
test_free_2D(Bv);
test_free_2D(Cv);
test_free_2D(Dv);
test_free(R);
MSG("done.");
gasnet_exit(0);
return 0;
}
int main(int argc, char **argv) {
int i,j;
static uint8_t *A, *B;
thread_data_t *td_arr;
GASNET_Safe(gasnet_init(&argc, &argv));
performance_iters = DEFAULT_PERFORMANCE_ITERS;
for(i=1; i<argc; i++) {
if(strcmp("-i", argv[i])==0 || strcmp("-iters", argv[i])==0) {
performance_iters = atoi(argv[i+1]);
i++;
} else if(strcmp("-f", argv[i])==0 || strcmp("-tune-file", argv[i])==0) {
outputfile = test_malloc(strlen(argv[i+1])+1);
strcpy(outputfile, argv[i+1]);
i++;
} else if(strcmp("-p", argv[i])==0 || strcmp("-profile", argv[i])==0) {
profile_file = test_malloc(strlen(argv[i+1])+1);
strcpy(profile_file, argv[i+1]);
i++;
} else if(strcmp("-h", argv[i])==0 || strcmp("-help", argv[i])==0) {
MSG0("usage: %s (-i iters) (-f output file)\n", argv[0]);
gasnet_exit(0);
}
}
max_data_size = 0;
threads_per_node = 0;
profile_info = load_file(profile_file);
fill_meta_data(profile_info);
printf("data loaded: %d %d\n", (int)max_data_size, threads_per_node);
if(max_data_size <=0) {
fprintf(stderr, "max data size(%d) should be >=0\n", (int) max_data_size);
gasnet_exit(1);
}
if(threads_per_node<1) {
fprintf(stderr, "threads_per_node (%d) should be > 0\n", threads_per_node);
gasnet_exit(1);
}
if(performance_iters <=0) {
gasnet_exit(0);
}
mynode = gasnet_mynode();
nodes = gasnet_nodes();
THREADS = nodes * threads_per_node;
GASNET_Safe(gasnet_attach(NULL, 0, TEST_SEGSZ_REQUEST, TEST_MINHEAPOFFSET));
/* ?? test_init("testcolltuner",0,"(-i iters) (-f output_file)"); */
A = TEST_MYSEG();
B = A+(SEG_PER_THREAD*threads_per_node);
my_srcs = (uint8_t**) test_malloc(sizeof(uint8_t*)*threads_per_node);
my_dsts = (uint8_t**) test_malloc(sizeof(uint8_t*)*threads_per_node);
all_srcs = (uint8_t**) test_malloc(sizeof(uint8_t*)*THREADS);
all_dsts = (uint8_t**) test_malloc(sizeof(uint8_t*)*THREADS);
td_arr = (thread_data_t*) test_malloc(sizeof(thread_data_t)*threads_per_node);
TEST_SET_WAITMODE(threads_per_node);
for(i=0; i<threads_per_node; i++) {
my_srcs[i] = A + i*SEG_PER_THREAD;
my_dsts[i] = B + i*SEG_PER_THREAD;
td_arr[i].my_local_thread = i;
td_arr[i].mythread = mynode*threads_per_node+i;
td_arr[i].mysrc = my_srcs[i];
td_arr[i].mydest = my_dsts[i];
}
for(i=0; i<nodes; i++) {
/* assert_always(TEST_SEG(i).size >= SEG_PER_THREAD*threads_per_node); */
for(j=0; j<threads_per_node; j++) {
all_srcs[i*threads_per_node+j] = (uint8_t*) TEST_SEG(i) + j*SEG_PER_THREAD;
all_dsts[i*threads_per_node+j] = (uint8_t*) TEST_SEG(i) + SEG_PER_THREAD*threads_per_node + j*SEG_PER_THREAD;
}
}
#if GASNET_PAR
test_createandjoin_pthreads(threads_per_node, &thread_main, td_arr, sizeof(thread_data_t));
#else
thread_main(&td_arr[0]);
#endif
test_free(td_arr);
BARRIER();
gasnet_exit(0);
return 0;
}
int main(int argc, char **argv) {
int i = 0;
thread_data_t *td_arr;
GASNET_Safe(gasnet_init(&argc, &argv));
GASNET_Safe(gasnet_attach(NULL, 0, TEST_SEGSZ_REQUEST, TEST_MINHEAPOFFSET));
mynode = gasnet_mynode();
nodes = gasnet_nodes();
if (argc > 1) iters = atoi(argv[1]);
if (!iters) iters = 10000;
#if GASNET_PAR
test_init("testteambarrier", 2, "(iters) (threadcount) (test sections)");
if (argc > 2) {
threads_per_node = atoi(argv[2]);
} else {
if (gasnett_getenv_yesno_withdefault("GASNET_TEST_POLITE_SYNC",0)) {
/* May overcommit only if somebody already expected it */
threads_per_node = gasnett_cpu_count();
} else {
threads_per_node = gasnett_cpu_count() / TEST_LOCALPROCS();
}
threads_per_node = MIN(threads_per_node, 8);
threads_per_node = test_thread_limit(threads_per_node);
threads_per_node = MAX(threads_per_node, 1);
}
if (threads_per_node > TEST_MAXTHREADS || threads_per_node < 1) {
printf("ERROR: Threads must be between 1 and %d\n", TEST_MAXTHREADS);
exit(EXIT_FAILURE);
}
if (argc > 3) TEST_SECTION_PARSE(argv[3]);
if (argc > 4) test_usage();
#else
test_init("testteambarrier", 1, "(iters) (test sections)");
threads_per_node = 1;
if (argc > 3) test_usage();
if (argc > 2) TEST_SECTION_PARSE(argv[2]);
#endif
TEST_SET_WAITMODE(threads_per_node);
td_arr = (thread_data_t*) test_malloc(sizeof(thread_data_t)*threads_per_node);
for(i=0; i<threads_per_node; i++) {
td_arr[i].my_local_thread = i;
td_arr[i].mythread = mynode*threads_per_node+i;
}
#if GASNET_PAR
test_createandjoin_pthreads(threads_per_node, &thread_main, td_arr, sizeof(thread_data_t));
#else
thread_main(&td_arr[0]);
#endif
test_free(td_arr);
gasnet_coll_barrier_notify(GASNET_TEAM_ALL, 0, GASNET_BARRIERFLAG_ANONYMOUS);
GASNET_Safe(gasnet_coll_barrier_wait(GASNET_TEAM_ALL, 0, GASNET_BARRIERFLAG_ANONYMOUS));
MSG("done.");
gasnet_exit(0);
return 0;
}
