void
bfs_stinger (const struct stinger *G, const int64_t nv, const int64_t ne,
const int64_t startV,
int64_t * marks, const int64_t numSteps,
int64_t * Q, int64_t * QHead, int64_t * neighbors)
{
int64_t j, k, s;
int64_t nQ, Qnext, Qstart, Qend;
int64_t w_start;
MTA ("mta assert nodep")
for (j = 0; j < nv; j++) {
marks[j] = 0;
}
s = startV;
/* Push node s onto Q and set bounds for first Q sublist */
Q[0] = s;
Qnext = 1;
nQ = 1;
QHead[0] = 0;
QHead[1] = 1;
marks[s] = 1;
PushOnStack: /* Push nodes onto Q */
/* Execute the nested loop for each node v on the Q AND
for each neighbor w of v */
Qstart = QHead[nQ - 1];
Qend = QHead[nQ];
w_start = 0;
MTA ("mta assert no dependence")
MTA ("mta block dynamic schedule")
for (j = Qstart; j < Qend; j++) {
int64_t v = Q[j];
size_t d;
size_t deg_v = stinger_outdegree (G, v);
int64_t my_w = stinger_int64_fetch_add (&w_start, deg_v);
stinger_gather_typed_successors (G, 0, v, &d, &neighbors[my_w], deg_v);
assert (d == deg_v);
MTA ("mta assert nodep")
for (k = 0; k < deg_v; k++) {
int64_t d, w, l;
w = neighbors[my_w + k];
/* If node has not been visited, set distance and push on Q */
if (stinger_int64_fetch_add (marks + w, 1) == 0) {
Q[stinger_int64_fetch_add (&Qnext, 1)] = w;
}
}
}
if (Qnext != QHead[nQ] && nQ < numSteps) {
nQ++;
QHead[nQ] = Qnext;
goto PushOnStack;
}
}
int64_t
st_conn_csr (const int64_t nv, const int64_t ne, const int64_t * off,
const int64_t * ind, const int64_t * sources, const int64_t num,
const int64_t numSteps)
{
int64_t k, x;
int64_t *Q_big = (int64_t *) xmalloc (INC * nv * sizeof (int64_t));
int64_t *marks_s_big = (int64_t *) xmalloc (INC * nv * sizeof (int64_t));
int64_t *marks_t_big = (int64_t *) xmalloc (INC * nv * sizeof (int64_t));
int64_t *QHead_big =
(int64_t *) xmalloc (INC * 2 * numSteps * sizeof (int64_t));
int64_t *neighbors_big = (int64_t *) xmalloc (INC * ne * sizeof (int64_t));
int64_t count = 0;
k = 0;
MTA ("mta assert parallel")
MTA ("mta loop future")
for (x = 0; x < INC; x++) {
int64_t *Q = Q_big + x * nv;
int64_t *marks_s = marks_s_big + x * nv;
int64_t *marks_t = marks_t_big + x * nv;
int64_t *QHead = QHead_big + x * 2 * numSteps;
int64_t *neighbors = neighbors_big + x * ne;
for (int64_t claimedk = stinger_int64_fetch_add (&k, 2);
claimedk < 2 * num; claimedk = stinger_int64_fetch_add (&k, 2)) {
int64_t s = sources[claimedk];
int64_t t = sources[claimedk + 1];
bfs_csr (nv, ne, off, ind, s, marks_s, numSteps, Q, QHead);
bfs_csr (nv, ne, off, ind, t, marks_t, numSteps, Q, QHead);
int64_t local_count = 0;
MTA ("mta assert nodep")
for (int64_t j = 0; j < nv; j++) {
if (marks_s[j] && marks_t[j])
stinger_int64_fetch_add (&local_count, 1);
}
if (local_count == 0)
stinger_int64_fetch_add (&count, 1);
}
}
free (neighbors_big);
free (QHead_big);
free (marks_t_big);
free (marks_s_big);
free (Q_big);
return count;
}
void
bfs_csr (const int64_t nv, const int64_t ne, const int64_t * off,
const int64_t * ind, const int64_t startV, int64_t * marks,
const int64_t numSteps, int64_t * Q, int64_t * QHead)
{
int64_t j, k, s;
int64_t nQ, Qnext, Qstart, Qend;
MTA ("mta assert nodep")
for (j = 0; j < nv; j++) {
marks[j] = 0;
}
s = startV;
/* Push node s onto Q and set bounds for first Q sublist */
Q[0] = s;
Qnext = 1;
nQ = 1;
QHead[0] = 0;
QHead[1] = 1;
marks[s] = 1;
PushOnStack: /* Push nodes onto Q */
/* Execute the nested loop for each node v on the Q AND
for each neighbor w of v */
Qstart = QHead[nQ - 1];
Qend = QHead[nQ];
MTA ("mta assert no dependence")
MTA ("mta block dynamic schedule")
for (j = Qstart; j < Qend; j++) {
int64_t v = Q[j];
int64_t myStart = off[v];
int64_t myEnd = off[v + 1];
MTA ("mta assert nodep")
for (k = myStart; k < myEnd; k++) {
int64_t d, w, l;
w = ind[k];
/* If node has not been visited, set distance and push on Q */
if (stinger_int64_fetch_add (marks + w, 1) == 0) {
Q[stinger_int64_fetch_add (&Qnext, 1)] = w;
}
}
}
if (Qnext != QHead[nQ] && nQ < numSteps) {
nQ++;
QHead[nQ] = Qnext;
goto PushOnStack;
}
}
double
toc (void)
{
double out;
#if defined(__MTA__)
long ts;
MTA("mta fence")
ts = mta_get_clock (tic_ts);
out = ((double)ts) * mta_clock_period ();
/*fprintf (stderr, "%ld %g %g %g\n", ts, out, mta_clock_period(), mta_clock_freq());*/
#elif defined(HAVE_MACH_ABSOLUTE_TIME)
uint64_t ts, nanosec;
static mach_timebase_info_data_t info = {0,0};
if (info.denom == 0) {
mach_timebase_info(&info);
}
ts = mach_absolute_time();
nanosec = (ts - tic_ts) * (info.numer / info.denom);
out = 1.0e-9 * nanosec;
#else
struct timespec ts;
clock_gettime (TICTOC_CLOCK, &ts);
out = (ts.tv_nsec - (double)tic_ts.tv_nsec) * 1.0e-9;
out += (ts.tv_sec - (double)tic_ts.tv_sec);
#endif
return out;
}
void
tic (void)
{
#if defined(__MTA__)
MTA("mta fence")
tic_ts = mta_get_clock (0);
#elif defined(HAVE_MACH_ABSOLUTE_TIME)
tic_ts = mach_absolute_time();
#else
clock_gettime (TICTOC_CLOCK, &tic_ts);
#endif
}
void
tic (void)
{
#if defined(__MTA__)
MTA("mta fence")
tic_ts = mta_get_clock (0);
#elif defined(__MacOSX__)
tic_ts = UpTime ();
#else
clock_gettime (TICTOC_CLOCK, &tic_ts);
#endif
}
stinger_return_t
binary_stream_batch(stinger_t * S, stinger_workflow_t * wkflow, void ** workspace, int64_t batch, edge_action_t ** actions, int64_t * count) {
binary_stream_t * stream = binary_stream_from_void(S, workspace);
if(stream->actno < stream->nbatch * stream->batch_size) {
const int64_t endact = (stream->actno + stream->batch_size > stream->naction ? stream->naction : stream->actno + stream->batch_size);
int64_t *acts = &stream->action[2*stream->actno];
int64_t numActions = endact - stream->actno;
if(*count < numActions) {
*actions = xrealloc(*actions, sizeof(edge_action_t) * numActions);
if(!(*actions))
return STINGER_ALLOC_FAILED;
}
*count = numActions;
MTA("mta assert parallel")
MTA("mta block dynamic schedule")
OMP("omp parallel for")
for(uint64_t k = 0; k < numActions; k++) {
const int64_t i = acts[2 * k];
const int64_t j = acts[2 * k + 1];
(*actions)[k].type = 0;
(*actions)[k].source = i;
(*actions)[k].dest = j;
(*actions)[k].weight = 1;
(*actions)[k].time = batch;
}
stream->actno += stream->batch_size;
if(stream->actno >= stream->nbatch * stream->batch_size || stream->actno >= stream->naction)
return STINGER_REMOVE;
else
return STINGER_SUCCESS;
} else {
return STINGER_REMOVE;
unsigned int create_send_setup( const ibBoard_t *board,
const Addr4882_t addressList[], uint8_t *cmdString )
{
unsigned int i, j;
unsigned int board_pad;
int board_sad;
if( addressList == NULL )
{
fprintf(stderr, "libgpib: bug! addressList NULL in create_send_setup()\n");
return 0;
}
if( addressListIsValid( addressList ) == 0 )
{
fprintf(stderr, "libgpib: bug! bad address list\n");
return 0;
}
i = 0;
/* controller's talk address */
if(query_pad(board, &board_pad) < 0) return 0;
cmdString[i++] = MTA(board_pad);
if(query_sad(board, &board_sad) < 0) return 0;
if(board_sad >= 0 )
cmdString[i++] = MSA(board_sad);
cmdString[ i++ ] = UNL;
for( j = 0; j < numAddresses( addressList ); j++ )
{
unsigned int pad;
int sad;
pad = extractPAD( addressList[ j ] );
sad = extractSAD( addressList[ j ] );
cmdString[ i++ ] = MLA( pad );
if( sad >= 0)
cmdString[ i++ ] = MSA( sad );
}
return i;
}
static void
get_stats (struct stats *s)
{
MTA("mta fence")
s->clock = mta_get_task_counter(RT_CLOCK);
MTA("mta fence")
s->issues = mta_get_task_counter(RT_ISSUES);
MTA("mta fence")
s->concurrency = mta_get_task_counter(RT_CONCURRENCY);
MTA("mta fence")
s->load = mta_get_task_counter(RT_LOAD);
MTA("mta fence")
s->store = mta_get_task_counter(RT_STORE);
MTA("mta fence")
s->ifa = mta_get_task_counter(RT_INT_FETCH_ADD);
MTA("mta fence")
}
double
toc (void)
{
double out;
#if defined(__MTA__)
long ts;
MTA("mta fence")
ts = mta_get_clock (tic_ts);
out = ((double)ts) * mta_clock_period ();
/*fprintf (stderr, "%ld %g %g %g\n", ts, out, mta_clock_period(), mta_clock_freq());*/
#elif defined(__MacOSX__)
AbsoluteTime ts;
ts = UpTime ();
out = 1.0e-9 * AbsoluteDeltaToNanoseconds (ts, tic_ts);
#else
struct timespec ts;
clock_gettime (TICTOC_CLOCK, &ts);
out = (ts.tv_nsec - (double)tic_ts.tv_nsec) * 1.0e-9;
out += (ts.tv_sec - (double)tic_ts.tv_sec);
#endif
return out;
}
int64_t
st_conn_stinger (const struct stinger *G, const int64_t nv, const int64_t ne,
const int64_t * sources, const int64_t num,
const int64_t numSteps)
{
int64_t k, x;
int64_t *Q_big = (int64_t *) xmalloc (INC * nv * sizeof (int64_t));
int64_t *marks_s_big = (int64_t *) xmalloc (INC * nv * sizeof (int64_t));
int64_t *marks_t_big = (int64_t *) xmalloc (INC * nv * sizeof (int64_t));
int64_t *QHead_big =
(int64_t *) xmalloc (INC * 2 * numSteps * sizeof (int64_t));
int64_t *neighbors_big = (int64_t *) xmalloc (INC * ne * sizeof (int64_t));
int64_t count = 0;
k = 0;
x = 0;
OMP ("omp parallel for")
MTA ("mta assert parallel")
MTA ("mta loop future")
MTA ("mta assert nodep")
MTA ("mta assert no alias")
for (x = 0; x < INC; x++) {
int64_t *Q = Q_big + x * nv;
int64_t *marks_s = marks_s_big + x * nv;
int64_t *marks_t = marks_t_big + x * nv;
int64_t *QHead = QHead_big + x * 2 * numSteps;
int64_t *neighbors = neighbors_big + x * ne;
for (int64_t claimedk = stinger_int64_fetch_add (&k, 2);
claimedk < 2 * num; claimedk = stinger_int64_fetch_add (&k, 2)) {
int64_t s = sources[claimedk];
int64_t deg_s = stinger_outdegree (G, s);
int64_t t = sources[claimedk + 1];
int64_t deg_t = stinger_outdegree (G, t);
if (deg_s == 0 || deg_t == 0) {
stinger_int64_fetch_add (&count, 1);
} else {
bfs_stinger (G, nv, ne, s, marks_s, numSteps, Q, QHead, neighbors);
bfs_stinger (G, nv, ne, t, marks_t, numSteps, Q, QHead, neighbors);
int64_t local_count = 0;
MTA ("mta assert nodep")
for (int64_t j = 0; j < nv; j++) {
if (marks_s[j] && marks_t[j])
stinger_int64_fetch_add (&local_count, 1);
}
if (local_count == 0)
stinger_int64_fetch_add (&count, 1);
}
}
}
free (neighbors_big);
free (QHead_big);
free (marks_t_big);
free (marks_s_big);
free (Q_big);
return count;
}
static void poll_rx(struct atm_dev *dev,int mbx)
{
struct zatm_dev *zatm_dev;
unsigned long pos;
u32 x;
int error;
EVENT("poll_rx\n",0,0);
zatm_dev = ZATM_DEV(dev);
pos = (zatm_dev->mbx_start[mbx] & ~0xffffUL) | zin(MTA(mbx));
while (x = zin(MWA(mbx)), (pos & 0xffff) != x) {
u32 *here;
struct sk_buff *skb;
struct atm_vcc *vcc;
int cells,size,chan;
EVENT("MBX: host 0x%lx, nic 0x%x\n",pos,x);
here = (u32 *) pos;
if (((pos += 16) & 0xffff) == zatm_dev->mbx_end[mbx])
pos = zatm_dev->mbx_start[mbx];
cells = here[0] & uPD98401_AAL5_SIZE;
#if 0
printk("RX IND: 0x%x, 0x%x, 0x%x, 0x%x\n",here[0],here[1],here[2],here[3]);
{
unsigned long *x;
printk("POOL: 0x%08x, 0x%08x\n",zpeekl(zatm_dev,
zatm_dev->pool_base),
zpeekl(zatm_dev,zatm_dev->pool_base+1));
x = (unsigned long *) here[2];
printk("[0..3] = 0x%08lx, 0x%08lx, 0x%08lx, 0x%08lx\n",
x[0],x[1],x[2],x[3]);
}
#endif
error = 0;
if (here[3] & uPD98401_AAL5_ERR) {
error = (here[3] & uPD98401_AAL5_ES) >>
uPD98401_AAL5_ES_SHIFT;
if (error == uPD98401_AAL5_ES_DEACT ||
error == uPD98401_AAL5_ES_FREE) continue;
}
EVENT("error code 0x%x/0x%x\n",(here[3] & uPD98401_AAL5_ES) >>
uPD98401_AAL5_ES_SHIFT,error);
skb = ((struct rx_buffer_head *) bus_to_virt(here[2]))->skb;
__net_timestamp(skb);
#if 0
printk("[-3..0] 0x%08lx 0x%08lx 0x%08lx 0x%08lx\n",((unsigned *) skb->data)[-3],
((unsigned *) skb->data)[-2],((unsigned *) skb->data)[-1],
((unsigned *) skb->data)[0]);
#endif
EVENT("skb 0x%lx, here 0x%lx\n",(unsigned long) skb,
(unsigned long) here);
#if 0
printk("dummy: 0x%08lx, 0x%08lx\n",dummy[0],dummy[1]);
#endif
size = error ? 0 : ntohs(((__be16 *) skb->data)[cells*
ATM_CELL_PAYLOAD/sizeof(u16)-3]);
EVENT("got skb 0x%lx, size %d\n",(unsigned long) skb,size);
chan = (here[3] & uPD98401_AAL5_CHAN) >>
uPD98401_AAL5_CHAN_SHIFT;
if (chan < zatm_dev->chans && zatm_dev->rx_map[chan]) {
int pos;
vcc = zatm_dev->rx_map[chan];
pos = ZATM_VCC(vcc)->pool;
if (skb == zatm_dev->last_free[pos])
zatm_dev->last_free[pos] = NULL;
skb_unlink(skb, zatm_dev->pool + pos);
}
else {
printk(KERN_ERR DEV_LABEL "(itf %d): RX indication "
"for non-existing channel\n",dev->number);
size = 0;
vcc = NULL;
event_dump();
}
if (error) {
static unsigned long silence = 0;
static int last_error = 0;
if (error != last_error ||
time_after(jiffies, silence) || silence == 0){
printk(KERN_WARNING DEV_LABEL "(itf %d): "
"chan %d error %s\n",dev->number,chan,
err_txt[error]);
last_error = error;
silence = (jiffies+2*HZ)|1;
}
size = 0;
}
if (size && (size > cells*ATM_CELL_PAYLOAD-ATM_AAL5_TRAILER ||
size <= (cells-1)*ATM_CELL_PAYLOAD-ATM_AAL5_TRAILER)) {
printk(KERN_ERR DEV_LABEL "(itf %d): size %d with %d "
"cells\n",dev->number,size,cells);
size = 0;
event_dump();
}
if (size > ATM_MAX_AAL5_PDU) {
printk(KERN_ERR DEV_LABEL "(itf %d): size too big "
"(%d)\n",dev->number,size);
size = 0;
event_dump();
}
if (!size) {
dev_kfree_skb_irq(skb);
if (vcc) atomic_inc(&vcc->stats->rx_err);
continue;
}
if (!atm_charge(vcc,skb->truesize)) {
dev_kfree_skb_irq(skb);
continue;
}
skb->len = size;
ATM_SKB(skb)->vcc = vcc;
vcc->push(vcc,skb);
atomic_inc(&vcc->stats->rx);
}
}
if (!size) {
dev_kfree_skb_irq(skb);
if (vcc) atomic_inc(&vcc->stats->rx_err);
continue;
}
if (!atm_charge(vcc,skb->truesize)) {
dev_kfree_skb_irq(skb);
continue;
}
skb->len = size;
ATM_SKB(skb)->vcc = vcc;
vcc->push(vcc,skb);
atomic_inc(&vcc->stats->rx);
}
zout(pos & 0xffff,MTA(mbx));
#if 0 /* probably a stupid idea */
refill_pool(dev,zatm_vcc->pool);
/* maybe this saves us a few interrupts */
#endif
}
static int open_rx_first(struct atm_vcc *vcc)
{
struct zatm_dev *zatm_dev;
struct zatm_vcc *zatm_vcc;
unsigned long flags;
unsigned short chan;
int cells;
int
main (int argc, char **argv)
{
MTA (argc + !!argv);
}
static _Noreturn void
Charlie (int n)
{
MTA (n - 1);
}
