main (int argc, char *argv[])
{
int ncorr, t1arg, t0arg, orig_ncorr;
thread_t tid1, tid0;
float rate;
if (argc != 6)
{
printf ("usage: %s t0_bound t0_new_lwp t1_bound t1_new_lwp ncorr\n", argv[0]);
exit (1);
}
t0arg = THR_DETACHED;
if (atoi (argv[1]))
t0arg |= THR_BOUND;
if (atoi (argv[2]))
t0arg |= THR_NEW_LWP;
t1arg = THR_DETACHED;
if (atoi (argv[3]))
t1arg |= THR_BOUND;
if (atoi (argv[4]))
t1arg |= THR_NEW_LWP;
ncorr = atoi (argv[5]);
if (thr_create (0, 0, work, 0, t0arg, &tid0) != 0)
perror ("couldn't create thread 0");
if (thr_create (0, 0, work, (void *) 1, t1arg, &tid1) != 0)
perror ("couldn't create thread 1");
orig_ncorr = thr_getconcurrency ();
if (ncorr)
thr_setconcurrency (ncorr);
sleep (NSLEEP);
rate = (count[0] + count[1]) / ((float) NSLEEP);
printf ("\n------------------------------------------------------------------------\n");
printf ("t0arg 0x%x (%s, %s, %s)\nt1arg 0x%x (%s, %s, %s)\ncount[0] %d count[1] %d\n\
ncorr_orig %d ncorr_set %d ncorr_end %d rate %.3f per_cxt %.2f usec\n",
t0arg,
(t0arg & THR_DETACHED) ? "THR_DETACHED" : "Not Detached",
(t0arg & THR_BOUND) ? "THR_BOUND" : "Not Bound",
(t0arg & THR_NEW_LWP) ? "THR_NEW_LWP" : "No New_LWP",
t1arg,
(t1arg & THR_DETACHED) ? "THR_DETACHED" : "Not Detached",
(t1arg & THR_BOUND) ? "THR_BOUND" : "Not Bound",
(t1arg & THR_NEW_LWP) ? "THR_NEW_LWP" : "No New_LWP",
count[0], count[1],
orig_ncorr, ncorr, thr_getconcurrency (), rate, 1.0e6 / rate);
}
int
ldap_pvt_thread_get_concurrency(void)
{
#ifdef HAVE_PTHREAD_GETCONCURRENCY
return pthread_getconcurrency();
#elif defined(HAVE_THR_GETCONCURRENCY)
return thr_getconcurrency();
#else
return 0;
#endif
}
int
ParallelInit(int n, pxgstrf_relax_t *pxgstrf_relax,
pdgstrf_options_t *pdgstrf_options,
pxgstrf_shared_t *pxgstrf_shared)
{
int *etree = pdgstrf_options->etree;
register int w, dad, ukids, i, j, k, rs, panel_size, relax;
register int P, w_top, do_split = 0;
panel_t panel_type;
int *panel_histo = pxgstrf_shared->Gstat->panel_histo;
register int nthr, concurrency, info;
#if ( MACH==SUN )
register int sync_type = USYNC_THREAD;
/* Set concurrency level. */
nthr = sysconf(_SC_NPROCESSORS_ONLN);
thr_setconcurrency(nthr); /* number of LWPs */
concurrency = thr_getconcurrency();
#if ( PRNTlevel==1 )
printf(".. CPUs %d, concurrency (#LWP) %d, P %d\n",
nthr, concurrency, P);
#endif
/* Initialize mutex variables. */
pxgstrf_shared->lu_locks = (mutex_t *)
SUPERLU_MALLOC(NO_GLU_LOCKS * sizeof(mutex_t));
for (i = 0; i < NO_GLU_LOCKS; ++i)
mutex_init(&pxgstrf_shared->lu_locks[i], sync_type, 0);
#elif ( MACH==DEC || MACH==PTHREAD )
pxgstrf_shared->lu_locks = (pthread_mutex_t *)
SUPERLU_MALLOC(NO_GLU_LOCKS * sizeof(pthread_mutex_t));
for (i = 0; i < NO_GLU_LOCKS; ++i)
pthread_mutex_init(&pxgstrf_shared->lu_locks[i], NULL);
#else
pxgstrf_shared->lu_locks = (mutex_t *) SUPERLU_MALLOC(NO_GLU_LOCKS * sizeof(mutex_t));
#endif
#if ( PRNTlevel==1 )
printf(".. ParallelInit() ... nprocs %2d\n", pdgstrf_options->nprocs);
#endif
pxgstrf_shared->spin_locks = intCalloc(n);
pxgstrf_shared->pan_status =
(pan_status_t *) SUPERLU_MALLOC((n+1)*sizeof(pan_status_t));
pxgstrf_shared->fb_cols = intMalloc(n+1);
panel_size = pdgstrf_options->panel_size;
relax = pdgstrf_options->relax;
w = MAX(panel_size, relax) + 1;
for (i = 0; i < w; ++i) panel_histo[i] = 0;
pxgstrf_shared->num_splits = 0;
if ( (info = queue_init(&pxgstrf_shared->taskq, n)) ) {
fprintf(stderr, "ParallelInit(): %d\n", info);
ABORT("queue_init fails.");
}
/* Count children of each node in the etree. */
for (i = 0; i <= n; ++i) pxgstrf_shared->pan_status[i].ukids = 0;
for (i = 0; i < n; ++i) {
dad = etree[i];
++pxgstrf_shared->pan_status[dad].ukids;
}
/* Find the panel partitions and initialize each panel's status */
#ifdef PROFILE
num_panels = 0;
#endif
pxgstrf_shared->tasks_remain = 0;
rs = 1;
w_top = panel_size/2;
if ( w_top == 0 ) w_top = 1;
P = 12;
for (i = 0; i < n; ) {
if ( pxgstrf_relax[rs].fcol == i ) {
w = pxgstrf_relax[rs++].size;
panel_type = RELAXED_SNODE;
pxgstrf_shared->pan_status[i].state = CANGO;
} else {
w = MIN(panel_size, pxgstrf_relax[rs].fcol - i);
#ifdef SPLIT_TOP
if ( !do_split ) {
if ( (n-i) < panel_size * P ) do_split = 1;
}
if ( do_split && w > w_top ) { /* split large panel */
w = w_top;
++pxgstrf_shared->num_splits;
}
#endif
for (j = i+1; j < i + w; ++j)
/* Do not allow panel to cross a branch point in the etree. */
if ( pxgstrf_shared->pan_status[j].ukids > 1 ) break;
w = j - i; /* j should start a new panel */
panel_type = REGULAR_PANEL;
pxgstrf_shared->pan_status[i].state = UNREADY;
#ifdef DOMAINS
if ( in_domain[i] == TREE_DOMAIN ) panel_type = TREE_DOMAIN;
#endif
}
if ( panel_type == REGULAR_PANEL ) {
++pxgstrf_shared->tasks_remain;
/*printf("nondomain panel %6d -- %6d\n", i, i+w-1);
fflush(stdout);*/
}
ukids = k = 0;
for (j = i; j < i + w; ++j) {
pxgstrf_shared->pan_status[j].size = k--;
pxgstrf_shared->pan_status[j].type = panel_type;
ukids += pxgstrf_shared->pan_status[j].ukids;
}
pxgstrf_shared->pan_status[i].size = w; /* leading column */
/* only count those kids outside the panel */
pxgstrf_shared->pan_status[i].ukids = ukids - (w-1);
panel_histo[w]++;
#ifdef PROFILE
panstat[i].size = w;
++num_panels;
#endif
pxgstrf_shared->fb_cols[i] = i;
i += w;
} /* for i ... */
/* Dummy root */
pxgstrf_shared->pan_status[n].size = 1;
pxgstrf_shared->pan_status[n].state = UNREADY;
#if ( PRNTlevel==1 )
printf(".. Split: P %d, #nondomain panels %d\n", P, pxgstrf_shared->tasks_remain);
#endif
#ifdef DOMAINS
EnqueueDomains(&pxgstrf_shared->taskq, list_head, pxgstrf_shared);
#else
EnqueueRelaxSnode(&pxgstrf_shared->taskq, n, pxgstrf_relax, pxgstrf_shared);
#endif
#if ( PRNTlevel==1 )
printf(".. # tasks %d\n", pxgstrf_shared->tasks_remain);
fflush(stdout);
#endif
#ifdef PREDICT_OPT
/* Set up structure describing children */
for (i = 0; i <= n; cp_firstkid[i++] = EMPTY);
for (i = n-1; i >= 0; i--) {
dad = etree[i];
cp_nextkid[i] = cp_firstkid[dad];
cp_firstkid[dad] = i;
}
#endif
return 0;
} /* ParallelInit */
main(int argc,char **argv)
{
int *ev, len, i, j, status, numread, totalread=0, nevents_max, event_size, chunk;
int con[ET_STATION_SELECT_INTS];
et_event **pe;
et_openconfig openconfig;
et_statconfig sconfig;
et_att_id attach;
et_stat_id my_stat;
et_sys_id id;
sigset_t sigblock;
struct timespec timeout;
pthread_t tid;
BOSIOptr BIOstream;
char *ch;
char *str1 =
"OPEN UNIT=11 FILE='/scratch/boiarino/test.A00' WRITE RECL=32768 SPLITMB=2047 RAW SEQ NEW BINARY";
/*"OPEN UNIT=11 FILE='/work/clas/disk1/boiarino/test.A00' WRITE RECL=32768 SPLITMB=2047 RAW SEQ NEW BINARY";*/
if(argc != 3) {
printf("Usage: et2bos_test <et_filename> <station_name>\n");
exit(1);
}
timeout.tv_sec = 0;
timeout.tv_nsec = 1;
/* setup signal handling */
sigfillset(&sigblock);
/* block all signals */
status = pthread_sigmask(SIG_BLOCK, &sigblock, NULL);
if (status != 0) {
printf("et2bos: pthread_sigmask failure\n");
exit(1);
}
#ifdef sun
thr_setconcurrency(thr_getconcurrency() + 1);
#endif
/* spawn signal handling thread */
pthread_create(&tid, NULL, signal_thread, (void *)NULL);
restartLinux:
/* open ET system */
et_open_config_init(&openconfig);
et_open_config_setwait(openconfig, ET_OPEN_WAIT);
if (et_open(&id, argv[1], openconfig) != ET_OK) {
printf("et2bos: et_open problems\n");
exit(1);
}
et_open_config_destroy(openconfig);
/*
* Now that we have access to an ET system, find out how many
* events it has and what size they are. Then allocate an array
* of pointers to use for reading, writing, and modifying these events.
*/
if (et_system_getnumevents(id, &nevents_max) != ET_OK)
{
printf("et2bos: ET has died\n");
exit(1);
}
if (et_system_geteventsize(id, &event_size) != ET_OK)
{
printf("et2bos: ET has died\n");
exit(1);
}
if ( (pe = (et_event **) calloc(nevents_max, sizeof(et_event *))) == NULL)
{
printf("et2bos: cannot allocate memory\n");
exit(1);
}
et_station_config_init(&sconfig);
et_station_config_setuser(sconfig, ET_STATION_USER_MULTI);
et_station_config_setrestore(sconfig, ET_STATION_RESTORE_OUT);
et_station_config_setprescale(sconfig, 1);
/* old "all" mode */
et_station_config_setselect(sconfig, ET_STATION_SELECT_ALL);
et_station_config_setblock(sconfig, ET_STATION_BLOCKING);
et_station_config_setcue(sconfig, 150); /* if ET_STATION_NONBLOCKING */
/* set debug level */
et_system_setdebug(id, ET_DEBUG_INFO);
/* create station */
if ((status = et_station_create(id, &my_stat, argv[2], sconfig)) < 0)
{
if (status == ET_ERROR_EXISTS)
{
/* my_stat contains pointer to existing station */;
printf("et2bos: set ptr to the existing station\n");
}
else if (status == ET_ERROR_TOOMANY)
{
printf("et2bos: too many stations created\n");
goto error;
}
else
{
printf("et2bos: error in station creation\n");
goto error;
}
}
printf("et2bos: station ready\n");
if (et_station_attach(id, my_stat, &attach) < 0)
{
printf("et2bos: error in station attach\n");
goto error;
}
/* open FPACK file for writing */
/*if( (status = FParm(str1,&fd)) !=0)
{
printf("FParm status %d \n",status);
printf("command was >%s<\n",str1);
exit(1);
}*/
/* set file descriptor pointer */
BIOstream = (BOSIOptr)fd;
/* initialize BOS array */
bosInit(jw,NBCS);
while (et_alive(id))
{
/**************/
/* read data */
/**************/
/* example of single, timeout read */
/* status = et_event_get(&id, attach, &pe[0], ET_TIMED, &timeout); */
/* example of single, asynchronous read */
/* status = et_event_get(&id, attach, &pe[0], ET_ASYNC, NULL);*/
/* example of reading array of up to "chunk" events */
/* chunk = 500; */
/* numread = status = et_events_get(&id, attach, pe, ET_SLEEP, NULL, chunk, &numread);*/
chunk = 500;
status = et_events_get(id, attach, pe, ET_SLEEP, NULL, chunk, &numread);
if (status == ET_OK) {
;
}
else if (status == ET_ERROR_DEAD) {
printf("et2bos: ET system is dead\n");
goto end;
}
else if (status == ET_ERROR_TIMEOUT) {
printf("et2bos: got timeout\n");
goto end;
}
else if (status == ET_ERROR_EMPTY) {
printf("et2bos: no events\n");
goto end;
}
else if (status == ET_ERROR_BUSY) {
printf("et2bos: station is busy\n");
goto end;
}
else if (status == ET_ERROR_WAKEUP) {
printf("et2bos: someone told me to wake up\n");
goto end;
}
else if ((status == ET_ERROR_WRITE) || (status == ET_ERROR_READ)) {
printf("et2bos: socket communication error\n");
goto end;
}
else if (status != ET_OK) {
printf("et2bos: get error\n");
goto error;
}
/****************************************/
/* print data, write data to FPACK file */
/****************************************/
for (j=0; j<numread; j++)
{
et_event_getdata(pe[j], (void **) &ev);
/*
et_event_getlength(pe[j], &len);
printf("et2bos: recname=>%4.4s%4.4s<, run#=%d, event#=%d, reclen=%d\n",
(char *)&ev[3],(char *)&ev[4],ev[5],ev[6],ev[10]);
printf(" temp = %d, pri = %d, len = %d\n",
pe[j]->temp,et_event_getpriority(pe[j]),len);
et_event_getcontrol(pe[j], con);
for (i=0; i < ET_STATION_SELECT_INTS; i++)
{
printf("control[%d] = %d\n",i,con[i]);
}
*/
/* drop banks from previous event */
bosLdrop(jw, "E");
bosNgarbage(jw);
bosWgarbage(jw);
/* create banks in BOS array */
status = et2bos(ev, jw, "E");
if (status != 0)
{
printf ("et2bos_test: error %d in et2bos()\n",status);
exit(1);
}
/* call next if want to use ET record header; otherwise
record name will be "RUNEVENT" and other info from HEAD bank */
/*bosWriteRecord(fd,&ev[3],ev[5],ev[6],ev[8]);*/
/* write down BOS banks to file */
/*
status = bosWrite(fd, jw, "E");
if (status != 0)
{
printf ("et2bos_test: error %d in bosWrite()\n",status);
exit(1);
}
*/
}
/*********************/
/* return data to ET */
/*********************/
/* example of writing single event */
/* status = et_event_put(id, attach, pe[0]);*/
/* example of writing array of events */
status = et_events_put(id, attach, pe, numread);
if (status == ET_ERROR_DEAD) {
printf("et2bos: ET is dead\n");
goto end;
}
else if ((status == ET_ERROR_WRITE) || (status == ET_ERROR_READ)) {
printf("et2bos: socket communication error\n");
goto end;
}
else if (status != ET_OK) {
printf("et2bos: put error\n");
goto error;
}
totalread += numread;
end:
/* print something out after having read NUMEVENTS events */
if (totalread >= NUMEVENTS)
{
totalread = 0;
printf(" et2bos: %d events\n", NUMEVENTS);
}
/* if ET system is dead, wait here until it comes back */
while (!et_alive(id)) {
status = et_wait_for_alive(id);
if (status == ET_OK) {
int locality;
et_system_getlocality(id, &locality);
/* if Linux, re-establish connection to ET system since socket broken */
if (locality == ET_LOCAL_NOSHARE) {
printf("et2bos: try to reconnect Linux client\n");
et_forcedclose(id);
goto restartLinux;
}
}
}
} /* while(alive) */
error:
free(pe);
printf("et2bos: ERROR\n");
exit(0);
}
int
ldap_pvt_thread_get_concurrency(void)
{
return thr_getconcurrency();
}