/**
* Collector task for dynamic combinators (star/split)
* and the static parallel combinator
*/
void CollectorTask(snet_entity_t *ent, void *arg)
{
coll_arg_t *carg = (coll_arg_t *)arg;
snet_streamset_t readyset, waitingset;
snet_stream_iter_t *wait_iter;
snet_stream_desc_t *outstream;
snet_stream_desc_t *curstream = NULL;
snet_stream_desc_t *last = NULL; // when the paired parallel terminate, it sends the sort_end record to the last branch
snet_record_t *sort_rec = NULL;
snet_record_t *term_rec = NULL;
int incount;
bool terminate = false;
/* open outstream for writing */
outstream = SNetStreamOpen(carg->output, 'w');
readyset = waitingset = NULL;
if (carg->is_static) {
int i;
incount = CARG_ST(carg, num);
/* fill initial readyset of collector */
for (i=0; i<incount; i++) {
snet_stream_desc_t *tmp;
/* open each stream in listening set for reading */
tmp = SNetStreamOpen( CARG_ST(carg, inputs[i]), 'r');
/* add each stream instreams[i] to listening set of collector */
SNetStreamsetPut( &readyset, tmp);
}
SNetMemFree( CARG_ST(carg, inputs) );
} else {
incount = 1;
/* Open initial stream and put into readyset */
SNetStreamsetPut( &readyset,
SNetStreamOpen(CARG_DYN(carg, input), 'r')
);
}
/* create an iterator for waiting set, is reused within main loop*/
wait_iter = SNetStreamIterCreate( &waitingset);
/* MAIN LOOP */
while( !terminate) {
/* get a record */
snet_record_t *rec = GetRecord(&readyset, incount, &curstream);
/* process the record */
switch( SNetRecGetDescriptor( rec)) {
case REC_data:
/* data record: forward to output */
SNetStreamWrite( outstream, rec);
break;
case REC_sort_end:
/* curstream == last, this is the last branch and the paired parallel already terminates
* increase the level by one because it was not increased by the paired parallel as it should be
* Also later when last becomes the only waiting branch, the collector should terminate. However before terminating, it should pretend that parallel has sent the sort end from all branches
*/
if (curstream == last) { // imply last != NULL, this will be the last branch and the paired parallel already terminates
SNetRecSetLevel(rec, SNetRecGetLevel(rec) + 1); // increase the level by one because it was not increased by the paired parallel as it should be
}
if (last == NULL && SNetRecGetLevel(rec) == 0 && SNetRecGetNum(rec) == -1) { // if last was not set, and collector receives a sort_end (l0, c-1) --> set the curstream as last
last = curstream; // from now on, any sort_end from last will be increased level by 1
SNetRecDestroy( rec);
break; // ignore the sort_end
}
ProcessSortRecord(ent, rec, &sort_rec, curstream, &readyset, &waitingset);
/* end processing this stream */
curstream = NULL;
break;
case REC_sync:
SNetStreamReplace( curstream, SNetRecGetStream( rec));
SNetRecDestroy( rec);
break;
case REC_collect:
/* only for dynamic collectors! */
assert( false == carg->is_static );
/* collect: add new stream to ready set */
#ifdef DESTROY_TERM_IN_WAITING_UPON_COLLECT
/* but first, check if we can free resources by checking the
waiting set for arrival of termination records */
incount -= DestroyTermInWaitingSet(wait_iter, &waitingset);
assert(incount > 0);
#endif
/* finally, add new stream to ready set */
SNetStreamsetPut(
&readyset,
SNetStreamOpen( SNetRecGetStream( rec), 'r')
);
/* update incoming counter */
incount++;
/* destroy collect record */
SNetRecDestroy( rec);
break;
case REC_terminate:
/* termination record: close stream and remove from ready set */
ProcessTermRecord(rec, &term_rec, curstream, &readyset, &incount);
/* stop processing this stream */
curstream = NULL;
break;
default:
assert(0);
/* if ignore, at least destroy ... */
SNetRecDestroy( rec);
} /* end switch */
/************* termination conditions *****************/
if ( SNetStreamsetIsEmpty( &readyset)) {
/* the streams which had a sort record are in the waitingset */
if ( !SNetStreamsetIsEmpty( &waitingset)) {
if ( carg->is_static && (1 == incount) ) { // stat
snet_stream_desc_t *in = (waitingset != NULL) ? waitingset : readyset;
/* if last is the only one in the waitingset --> pretends that the already-terminated paired parallel has sent the sort end to all branches
* Therefore restore the waitingset before terminating (so that a relevant sort_end is sent out) */
if (in == last)
RestoreFromWaitingset(&waitingset, &readyset, &sort_rec, outstream);
SNetStreamWrite( outstream,
SNetRecCreate( REC_sync, SNetStreamGet(in))
);
SNetStreamClose( in, false);
terminate = true;
#ifdef DEBUG_PRINT_GC
/* terminating due to GC */
SNetUtilDebugNoticeEnt( ent,
"[COLL] Terminate static collector as only one branch left!"
);
#endif
} else
RestoreFromWaitingset(&waitingset, &readyset, &sort_rec, outstream);
} else {
/* both ready set and waitingset are empty */
#ifdef DEBUG_PRINT_GC
if (carg->is_static) {
SNetUtilDebugNoticeEnt( ent,
"[COLL] Terminate static collector as no inputs left!");
}
#endif
assert(term_rec != NULL);
SNetStreamWrite( outstream, term_rec);
term_rec = NULL;
terminate = true;
}
}
/************* end of termination conditions **********/
} /* MAIN LOOP END */
if (term_rec != NULL) {
SNetRecDestroy(term_rec);
}
if (sort_rec != NULL) {
SNetRecDestroy(sort_rec);
}
/* close outstream */
SNetStreamClose( outstream, false);
/* destroy iterator */
SNetStreamIterDestroy( wait_iter);
/* destroy argument */
SNetMemFree( carg);
} /* END of DYNAMIC COLLECTOR TASK */
/**
* Split box task.
*
* Implements both the non-deterministic and deterministic variants.
*/
static void SplitBoxTask(snet_entity_t *ent, void *arg)
{
int i;
split_arg_t *sarg = (split_arg_t *)arg;
snet_stream_desc_t *initial, *instream;
int ltag_val, utag_val;
snet_info_t *info;
snet_record_t *rec;
snet_locvec_t *locvec;
bool terminate = false;
/* a list of all outstreams for all yet created instances */
snet_streamset_t repos_set = NULL;
snet_stream_iter_t *iter = SNetStreamIterCreate( &repos_set);
/* a hashtable for fast lookup, initial capacity = 2^4 = 16 */
hashtab_t *repos_tab = HashtabCreate( 4);
(void) ent; /* NOT USED */
/* for deterministic variant: */
int counter = 0;
initial = SNetStreamOpen(sarg->output, 'w');
instream = SNetStreamOpen(sarg->input, 'r');
/* MAIN LOOP START */
while( !terminate) {
/* read from input stream */
rec = SNetStreamRead( instream);
switch( SNetRecGetDescriptor( rec)) {
case REC_data:
/* get lower and upper tag values */
ltag_val = SNetRecGetTag( rec, sarg->ltag);
utag_val = SNetRecGetTag( rec, sarg->utag);
/* for all tag values */
for( i = ltag_val; i <= utag_val; i++) {
snet_stream_desc_t *outstream = HashtabGet( repos_tab, i);
if( outstream == NULL) {
snet_stream_t *temp_stream;
snet_stream_t *newstream_addr = SNetStreamCreate(0);
/* instance does not exist yet, create it */
outstream = SNetStreamOpen(newstream_addr, 'w');
/* add to lookup table */
HashtabPut( repos_tab, i, outstream);
/* add to list */
SNetStreamsetPut( &repos_set, outstream);
/* create info and location vector for creation of this replica */
info = SNetInfoCopy(sarg->info);
locvec = SNetLocvecSplitSpawn(SNetLocvecGet(sarg->info), i);
SNetLocvecSet(info, locvec);
if( sarg->is_byloc) {
SNetRouteDynamicEnter(info, i, i, sarg->boxfun);
temp_stream = sarg->boxfun(newstream_addr, info, i);
temp_stream = SNetRouteUpdate(info, temp_stream, sarg->location);
SNetRouteDynamicExit(info, i, i, sarg->boxfun);
} else {
SNetRouteDynamicEnter(info, i, sarg->location, sarg->boxfun);
temp_stream = sarg->boxfun(newstream_addr, info, sarg->location);
temp_stream = SNetRouteUpdate(info, temp_stream, sarg->location);
SNetRouteDynamicExit(info, i, sarg->location, sarg->boxfun);
}
/* destroy info and location vector */
SNetLocvecDestroy(locvec);
SNetInfoDestroy(info);
if(temp_stream != NULL) {
/* notify collector about the new instance via initial */
SNetStreamWrite( initial,
SNetRecCreate( REC_collect, temp_stream));
}
} /* end if (outstream==NULL) */
/* multicast the record */
SNetStreamWrite( outstream,
/* copy record for all but the last tag value */
(i!=utag_val) ? SNetRecCopy( rec) : rec
);
} /* end for all tags ltag_val <= i <= utag_val */
/* If deterministic, append a sort record to *all* registered
* instances and the initial stream.
*/
if( sarg->is_det ) {
/* reset iterator */
SNetStreamIterReset( iter, &repos_set);
while( SNetStreamIterHasNext( iter)) {
snet_stream_desc_t *cur_stream = SNetStreamIterNext( iter);
SNetStreamWrite( cur_stream,
SNetRecCreate( REC_sort_end, 0, counter));
}
/* Now also send a sort record to initial,
after the collect records for new instances have been sent */
SNetStreamWrite( initial,
SNetRecCreate( REC_sort_end, 0, counter));
}
/* increment counter for deterministic variant */
counter += 1;
break;
case REC_sync:
{
snet_stream_t *newstream = SNetRecGetStream( rec);
SNetStreamReplace( instream, newstream);
SNetRecDestroy( rec);
}
break;
case REC_sort_end:
/* broadcast the sort record */
SNetStreamIterReset( iter, &repos_set);
/* all instances receive copies of the record */
while( SNetStreamIterHasNext( iter)) {
snet_stream_desc_t *cur_stream = SNetStreamIterNext( iter);
SNetStreamWrite( cur_stream,
SNetRecCreate( REC_sort_end,
/* we have to increase level */
SNetRecGetLevel( rec)+1,
SNetRecGetNum( rec))
);
}
/* send the original record to the initial stream,
but with increased level */
SNetRecSetLevel( rec, SNetRecGetLevel( rec) + 1);
SNetStreamWrite( initial, rec);
break;
case REC_terminate:
SNetStreamIterReset( iter, &repos_set);
/* all instances receive copies of the record */
while( SNetStreamIterHasNext( iter)) {
snet_stream_desc_t *cur_stream = SNetStreamIterNext( iter);
SNetStreamWrite( cur_stream, SNetRecCopy( rec));
SNetStreamIterRemove( iter);
/* close the stream to the instance */
SNetStreamClose( cur_stream, false);
}
/* send the original record to the initial stream */
SNetStreamWrite( initial, rec);
/* note that no sort record has to be appended */
terminate = true;
break;
case REC_collect:
/* invalid control record */
default:
assert( 0);
/* if ignore, at least destroy it */
SNetRecDestroy( rec);
}
} /* MAIN LOOP END */
/* destroy repository */
HashtabDestroy( repos_tab);
SNetStreamIterDestroy( iter);
/* close and destroy initial stream */
SNetStreamClose( initial, false);
/* close instream */
SNetStreamClose( instream, true);
SNetLocvecDestroy(SNetLocvecGet(sarg->info));
SNetInfoDestroy(sarg->info);
/* destroy the argument */
SNetMemFree( sarg);
} /* END of SPLIT BOX TASK */
snet_stream_desc_t *SNetStreamPoll(snet_streamset_t *set)
{
assert( *set != NULL);
snet_stream_desc_t *result = NULL;
/* get 'self', i.e. the task calling SNetStreamPoll()
* the set is a simple pointer to the last element
*/
snet_thread_t *self = SNetThreadingSelf();
snet_stream_iter_t *iter;
int cnt = 0;
//self = (*set)->thr;
iter = SNetStreamIterCreate(set);
/* fast path: there is something anywhere */
{
while( SNetStreamIterHasNext(iter)) {
snet_stream_desc_t *sd = SNetStreamIterNext( iter);
snet_stream_t *s = sd->stream;
pthread_mutex_lock(&s->lock);
if (s->count > 0) result = sd;
pthread_mutex_unlock(&s->lock);
}
if (result != NULL) {
goto poll_fastpath;
}
}
/* reset wakeup_sd */
pthread_mutex_lock( &self->lock );
self->wakeup_sd = NULL;
pthread_mutex_unlock( &self->lock );
/* for each stream in the set */
SNetStreamIterReset(iter, set);
while( SNetStreamIterHasNext(iter)) {
snet_stream_desc_t *sd = SNetStreamIterNext( iter);
snet_stream_t *s = sd->stream;
/* lock stream (prod-side) */
pthread_mutex_lock( &s->lock);
{ /* CS BEGIN */
/* check if there is something in the buffer */
if ( s->count > 0 ) {
/* yes, we can stop iterating through streams. */
pthread_mutex_lock( &self->lock );
if (self->wakeup_sd == NULL) {
self->wakeup_sd = sd;
}
/* unlock self */
pthread_mutex_unlock( &self->lock );
/* unlock stream */
pthread_mutex_unlock( &s->lock);
/* exit loop */
break;
} else {
/* nothing in the buffer, register stream as activator */
s->is_poll = 1;
cnt++;
}
} /* CS END */
/* unlock stream */
pthread_mutex_unlock( &s->lock);
} /* end for each stream */
/* wait until wakeup_sd is set */
pthread_mutex_lock( &self->lock );
while( self->wakeup_sd == NULL ) {
pthread_cond_wait(&self->pollcond, &self->lock);
}
result = self->wakeup_sd;
self->wakeup_sd = NULL;
pthread_mutex_unlock( &self->lock );
SNetStreamIterReset(iter, set);
while( SNetStreamIterHasNext(iter)) {
snet_stream_t *s = (SNetStreamIterNext(iter))->stream;
pthread_mutex_lock(&s->lock);
s->is_poll = 0;
pthread_mutex_unlock(&s->lock);
if (--cnt == 0) break;
}
poll_fastpath:
SNetStreamIterDestroy(iter);
/* 'rotate' list to stream descriptor for non-empty buffer */
*set = result;
return result;
}
