t_stat pclk_reset (DEVICE *dptr)
{
pclk_csr = 0; /* clear reg */
pclk_csb = 0;
pclk_ctr = 0;
CLR_INT (PCLK); /* clear int */
sim_cancel (&pclk_unit); /* cancel */
return auto_config (0, 0);
}
t_stat ptp_reset (DEVICE *dptr)
{
ptp_unit.buf = 0;
ptp_csr = CSR_DONE;
if ((ptp_unit.flags & UNIT_ATT) == 0)
ptp_csr = ptp_csr | CSR_ERR;
CLR_INT (PTP);
sim_cancel (&ptp_unit); /* deactivate unit */
return auto_config (dptr->name, 1);
}
t_stat ptr_reset (DEVICE *dptr)
{
ptr_unit.buf = 0;
ptr_csr = 0;
if ((ptr_unit.flags & UNIT_ATT) == 0)
ptr_csr = ptr_csr | CSR_ERR;
CLR_INT (PTR);
sim_cancel (&ptr_unit);
return auto_config (dptr->name, 1);
}
t_stat
ng_reset(DEVICE *dptr)
{
DEVICE *dptr2;
t_stat r;
if (dptr->flags & DEV_DIS) {
sim_cancel (dptr->units);
return auto_config ("NG", (dptr->flags & DEV_DIS) ? 0 : 1);;
}
dptr2 = find_dev ("VT");
if ((dptr2 != NULL) && !(dptr2->flags & DEV_DIS)) {
dptr->flags |= DEV_DIS;
return sim_messagef (SCPE_NOFNC, "NG and VT device can't both be enabled\n");
}
dptr2 = find_dev ("CH");
if ((dptr2 != NULL) && !(dptr2->flags & DEV_DIS)) {
dptr->flags |= DEV_DIS;
return sim_messagef (SCPE_ALATT, "NG device in conflict with CH.\n");
}
r = auto_config ("NG", (dptr->flags & DEV_DIS) ? 0 : 1);;
if (r != SCPE_OK) {
dptr->flags |= DEV_DIS;
return r;
}
if (!ng_inited && !ng_init(dptr, DEB_TRC))
return sim_messagef (SCPE_ALATT, "Display already in use.\n");
ng_inited = TRUE;
CLR_INT (NG);
ng_unit.wait = 100;
sim_activate (dptr->units, 1);
set_cmd (0, "DZ DISABLED"); /* Conflict with NG. */
set_cmd (0, "HK DISABLED"); /* Conflict with RF. */
vid_register_quit_callback (&ng_quit_callback);
return SCPE_OK;
}
t_stat
vt_reset(DEVICE *dptr)
{
if (!(dptr->flags & DEV_DIS))
vt11_reset();
CLR_INT (VTST);
CLR_INT (VTLP);
CLR_INT (VTCH);
CLR_INT (VTNM);
sim_cancel (&vt_unit); /* deactivate unit */
return auto_config ("VT", (dptr->flags & DEV_DIS) ? 0 : 1);
}
t_stat rx_reset (DEVICE *dptr)
{
rx_csr = rx_dbr = 0; /* clear regs */
rx_esr = rx_ecode = 0; /* clear error */
rx_track = rx_sector = 0; /* clear addr */
rx_state = IDLE; /* ctrl idle */
CLR_INT (RX); /* clear int req */
sim_cancel (&rx_unit[1]); /* cancel drive 1 */
if (dptr->flags & DEV_DIS) sim_cancel (&rx_unit[0]); /* disabled? */
else if (rx_unit[0].flags & UNIT_BUF) { /* attached? */
rx_state = INIT_COMPLETE; /* yes, sched init */
sim_activate (&rx_unit[0], rx_swait * abs (1 - rx_unit[0].TRACK));
}
else rx_done (0, 0010); /* no, error */
return auto_config (0, 0); /* run autoconfig */
}
t_stat ry_reset (DEVICE *dptr)
{
ry_csr = ry_dbr = 0; /* clear registers */
ry_esr = ry_ecode = 0; /* clear error */
ry_ba = ry_wc = 0; /* clear wc, ba */
ry_track = ry_sector = 0; /* clear trk, sector */
ry_state = IDLE; /* ctrl idle */
CLR_INT (RY); /* clear int req */
sim_cancel (&ry_unit[1]); /* cancel drive 1 */
if (dptr->flags & UNIT_DIS) /* disabled? */
sim_cancel (&ry_unit[0]);
else if (ry_unit[0].flags & UNIT_BUF) { /* attached? */
ry_state = INIT_COMPLETE; /* yes, sched init */
sim_activate (&ry_unit[0], ry_swait * abs (1 - ry_unit[0].TRACK));
}
else ry_done (RYES_ID, 0010); /* no, error */
return auto_config (0, 0); /* run autoconfig */
}
int
main(int argc, char *argv[])
{
int i;
int j;
int pages = 256; /* 1MB */
int buffers = 2;
int sets = 2;
int stages = 2;
int *status;
line_info_t *line_info;
line_info_t *lp;
stage_info_t *stage_info;
stage_info_t *sp;
kern_return_t ret;
int c;
/* Do switch parsing: */
while ((c = getopt (argc, argv, "ab:chi:p:s:twv:")) != -1) {
switch (c) {
case 'a':
#ifdef AVAILABLE_MAC_OS_X_VERSION_10_5_AND_LATER
affinity = !affinity;
break;
#else
usage();
#endif
case 'b':
buffers = atoi(optarg);
break;
case 'c':
cache_config = TRUE;
break;
case 'i':
iterations = atoi(optarg);
break;
case 'p':
pages = atoi(optarg);
break;
case 's':
stages = atoi(optarg);
if (stages >= WORKERS_MAX)
usage();
break;
case 't':
halting = TRUE;
break;
case 'w':
consumer_fnp = &reader_writer_fn;
break;
case 'v':
verbosity = atoi(optarg);
break;
case '?':
case 'h':
default:
usage();
}
}
argc -= optind; argv += optind;
if (argc > 0)
sets = atoi(*argv);
if (cache_config)
auto_config(pages, &buffers, &sets);
pthread_mutex_init(&funnel, NULL);
pthread_cond_init(&barrier, NULL);
/*
* Fire up the worker threads.
*/
threads = sets * stages;
mutter("Launching %d set%s of %d threads with %saffinity, "
"consumer reads%s data\n",
sets, s_if_plural(sets), stages, affinity? "": "no ",
(consumer_fnp == &reader_writer_fn)? " and writes" : "");
if (pages < 256)
mutter(" %dkB bytes per buffer, ", pages * 4);
else
mutter(" %dMB bytes per buffer, ", pages / 256);
mutter("%d buffer%s per set ",
buffers, s_if_plural(buffers));
if (buffers * pages < 256)
mutter("(total %dkB)\n", buffers * pages * 4);
else
mutter("(total %dMB)\n", buffers * pages / 256);
mutter(" processing %d buffer%s...\n",
iterations, s_if_plural(iterations));
line_info = (line_info_t *) malloc(sets * sizeof(line_info_t));
stage_info = (stage_info_t *) malloc(sets * stages * sizeof(stage_info_t));
for (i = 0; i < sets; i++) {
work_t *work_array;
lp = &line_info[i];
lp->setnum = i + 1;
lp->isize = pages * 4096 / sizeof(int);
lp->data = (int *) malloc(buffers * pages * 4096);
/* Set up the queue for the workers of this thread set: */
for (j = 0; j < stages; j++) {
sp = &stage_info[(i*stages) + j];
sp->stagenum = j;
sp->set = lp;
lp->stage[j] = sp;
pthread_mutex_init(&sp->bufq.mtx, NULL);
pthread_cond_init(&sp->bufq.cnd, NULL);
TAILQ_INIT(&sp->bufq.queue);
sp->bufq.waiters = FALSE;
}
/*
* Take a second pass through the stages
* to define what the workers are and to interconnect their input/outputs
*/
for (j = 0; j < stages; j++) {
sp = lp->stage[j];
if (j == 0) {
sp->fn = producer_fnp;
sp->name = "producer";
} else {
sp->fn = consumer_fnp;
sp->name = "consumer";
}
sp->input = &lp->stage[j]->bufq;
sp->output = &lp->stage[(j + 1) % stages]->bufq;
}
/* Set up the buffers on the first worker of the set. */
work_array = (work_t *) malloc(buffers * sizeof(work_t));
for (j = 0; j < buffers; j++) {
work_array[j].data = lp->data + (lp->isize * j);
TAILQ_INSERT_TAIL(&lp->stage[0]->bufq.queue, &work_array[j], link);
DBG(" empty work item %p for set %d data %p\n",
&work_array[j], i, work_array[j].data);
}
/* Create this set of threads */
for (j = 0; j < stages; j++) {
if (ret = pthread_create(&lp->stage[j]->thread, NULL,
&manager_fn,
(void *) lp->stage[j]))
err(1, "pthread_create %d,%d", i, j);
}
}
/*
* We sit back anf wait for the slave to finish.
*/
for (i = 0; i < sets; i++) {
lp = &line_info[i];
for (j = 0; j < stages; j++) {
if(ret = pthread_join(lp->stage[j]->thread, (void **)&status))
err(1, "pthread_join %d,%d", i, j);
DBG("Thread %d,%d status %d\n", i, j, status);
}
}
/*
* See how long the work took.
*/
timer = mach_absolute_time() - timer;
timer = timer / 1000000ULL;
printf("%d.%03d seconds elapsed.\n",
(int) (timer/1000ULL), (int) (timer % 1000ULL));
return 0;
}
