/* Terminate any kind of dripback landing. */ void SNetTermDripBack(landing_t *land, fifo_t *fifo) { trace(__func__); if (land->type == LAND_dripback1) { landing_dripback1_t *db1 = LAND_SPEC(land, dripback1); if (db1->controldesc) { snet_record_t *rec = SNetRecCreate(REC_terminate); land->worker = SNetThreadGetSelf(); SNetWrite(&db1->controldesc, rec, false); SNetFifoPut(fifo, db1->controldesc); } else { SNetLandingDone(db1->dripback2); } SNetFreeLanding(land); } else if (land->type == LAND_dripback2) { landing_dripback2_t *db2 = LAND_SPEC(land, dripback2); if (db2->instdesc) { fprintf(stderr, "%s: Premature termination of dripback2\n", __func__); SNetFifoPut(fifo, db2->instdesc); db2->instdesc = NULL; } if (db2->outdesc) { SNetFifoPut(fifo, db2->outdesc); db2->outdesc = NULL; } SNetFreeLanding(land); } else { assert(0); } }
/* Terminate any kind of feedback landing. */ void SNetTermFeedback(landing_t *land, fifo_t *fifo) { trace(__func__); if (land->type == LAND_feedback1) { landing_feedback1_t *fb1 = LAND_SPEC(land, feedback1); landing_feedback3_t *fb3 = LAND_SPEC(fb1->feedback3, feedback3); assert(fb3->terminate == FeedbackInitial); if (fb1->outdesc) { SNetFifoPut(fifo, fb1->outdesc); } if (fb1->instdesc) { snet_record_t *recdet = SNetRecCreate(REC_detref, -1L, fb1->feedback3, NULL); land->worker = SNetThreadGetSelf(); SNetWrite(&fb1->instdesc, recdet, false); SNetFifoPut(fifo, fb1->instdesc); } SNetLandingDone(fb1->feedback2); SNetLandingDone(fb1->feedback4); SNetLandingDone(fb1->feedback3); SNetFreeLanding(land); } else if (land->type == LAND_feedback2) { landing_feedback2_t *fb2 = LAND_SPEC(land, feedback2); if (fb2->instdesc) { SNetFifoPut(fifo, fb2->instdesc); } SNetLandingDone(fb2->feedback3); SNetFreeLanding(land); } else if (land->type == LAND_feedback3) { landing_feedback3_t *fb3 = LAND_SPEC(land, feedback3); SNetLandingDone(fb3->feedback4); SNetFreeLanding(land); } else if (land->type == LAND_feedback4) { landing_feedback4_t *fb4 = LAND_SPEC(land, feedback4); if (fb4->outdesc) { SNetFifoPut(fifo, fb4->outdesc); } SNetFreeLanding(land); } else { assert(0); } }
/* Enqueue a record to a stream and add a note to the todo list. */ void SNetWrite(snet_stream_desc_t **desc_ptr, snet_record_t *rec, bool last) { snet_stream_desc_t *desc = *desc_ptr; landing_t *land = desc->landing; worker_t *worker = desc->source->worker; /* Test if we can garbage collect this stream together with its landing. */ if (land->type == LAND_identity && trylock_landing(land, worker)) { desc = SNetMergeStreams(desc_ptr); land = desc->landing; } /* Increase the reference count to the destination stream. */ DESC_INCR(desc); /* If this write was the last statement in the caller function and we can * lock the destination landing then process the record right away. */ if (last && land->id == 0 && trylock_landing(land, worker)) { /* Make sure we process records in stream FIFO order. */ worker->continue_rec = (snet_record_t *) SNetFifoPutGet(&desc->fifo, rec); assert(worker->continue_rec); worker->continue_desc = desc; } else { /* Store the record into the destination stream. */ SNetFifoPut(&desc->fifo, rec); /* Add a todo item to this worker's todo queue. */ SNetWorkerTodo(worker, desc); } }
/* Enqueue a record to a stream and add a note to the todo list. */ void SNetStreamWrite(snet_stream_desc_t *desc, snet_record_t *rec) { DESC_INCR(desc); SNetFifoPut(&desc->fifo, rec); assert(desc->source->worker); SNetWorkerTodo(desc->source->worker, desc); }
/* Terminate a garbage landing: decrease references to subsequent resources. */ void SNetTermGarbage(landing_t *land, fifo_t *fifo) { snet_stream_desc_t *desc = LAND_SPEC(land, siso)->outdesc; trace(__func__); assert(desc); assert(desc->refs > 0); SNetLandingDone(desc->landing); SNetFifoPut(fifo, desc); SNetFreeLanding(land); }
/* Terminate a star landing. */ void SNetTermStar(landing_t *land, fifo_t *fifo) { landing_star_t *lstar = LAND_SPEC(land, star); trace(__func__); if (lstar->instdesc) { SNetFifoPut(fifo, lstar->instdesc); } if (lstar->colldesc) { SNetFifoPut(fifo, lstar->colldesc); } if (lstar->instland) { SNetLandingDone(lstar->instland); } SNetLandingDone(lstar->collland); SNetFreeLanding(land); }
/* Terminate an identity landing. */ void SNetTermIdentity(landing_t *land, fifo_t *fifo) { trace(__func__); SNetFifoPut(fifo, LAND_SPEC(land, identity)->outdesc); SNetFreeLanding(land); }
/* DripBack process a record. */ void SNetNodeDripBack(snet_stream_desc_t *desc, snet_record_t *rec) { landing_t *land = desc->landing; dripback_arg_t *darg = LAND_NODE_SPEC(land, dripback); trace(__func__); if (land->type == LAND_dripback1) { landing_dripback1_t *db1 = LAND_SPEC(land, dripback1); landing_dripback2_t *db2 = LAND_SPEC(db1->dripback2, dripback2); SNetFifoPut(db1->recfifo, rec); if (FAA(&db2->queued, 1) == 0) { if (db1->controldesc == NULL) { SNetPushLanding(desc, db1->dripback2); db1->controldesc = SNetStreamOpen(darg->selfref, desc); } rec = SNetRecCreate(REC_wakeup); SNetWrite(&db1->controldesc, rec, true); } } else if (land->type == LAND_dripback2) { landing_dripback2_t *db2 = LAND_SPEC(land, dripback2); bool via_access = (DESC_STREAM(desc) == darg->selfref); assert(via_access || DESC_STREAM(desc) == darg->dripback); while (rec) { switch (REC_DESCR( rec)) { case REC_data: /* Test if record should go to the instance. */ if (SNetFeedbackMatch( rec, darg->back_patterns, darg->guards)) { if (via_access) { /* Because record came from outside add a detref counter. */ assert(db2->detfifo.head->next == NULL); SNetRecDetrefAdd(rec, ++(db2->entered), land, &db2->detfifo); } else { /* Record came from the instance. */ assert(DATA_REC(rec, detref)); } if (db2->instdesc == NULL) { /* Instance should come back to this landing. */ if (SNetTopLanding(desc) != land) { SNetPushLanding(desc, land); } db2->instdesc = SNetStreamOpen(darg->instance, desc); if (SNetTopLanding(desc) == land) { SNetPopLanding(desc); SNetLandingDone(land); } } SNetWrite(&db2->instdesc, rec, false); } else { if (!via_access) { /* Record leaves the dripback loop. */ assert(DATA_REC(rec, detref)); SNetFeedbackLeave(rec, land, &db2->detfifo); } if (db2->outdesc == NULL) { db2->outdesc = SNetStreamOpen(darg->output, desc); } SNetWrite(&db2->outdesc, rec, false); } break; case REC_wakeup: assert(via_access); SNetRecDestroy(rec); break; case REC_terminate: assert(via_access); assert(db2->terminate == DripBackInitial); db2->terminate = DripBackDraining; SNetRecDestroy(rec); break; case REC_detref: if (DETREF_REC( rec, leave) == land && DETREF_REC( rec, location) == SNetDistribGetNodeId()) { assert(!via_access); SNetDetLeaveCheckDetref(rec, &db2->detfifo); if (DETREF_REC( rec, detref) == SNetFifoPeekFirst(&db2->detfifo)) { DripBackCheckBusy(db2); } SNetRecDestroy(rec); } else { assert(via_access); if (db2->outdesc == NULL) { db2->outdesc = SNetStreamOpen(darg->output, desc); } SNetWrite(&db2->outdesc, rec, false); } break; case REC_sync: SNetRecDestroy(rec); break; default: SNetRecUnknownEnt(__func__, rec, darg->entity); } rec = NULL; if (db2->state == DripBackBusy) { if (DripBackCheckBusy(db2) == false) { assert(db2->queued > 0); if (SAF(&db2->queued, 1) == 0) { db2->state = DripBackIdle; } else { rec = SNetFifoGet(&db2->recfifo); assert(rec); via_access = true; } } } else { assert(db2->state == DripBackIdle); assert(SNetFifoPeekFirst(&db2->detfifo) == NULL); if (db2->queued > 0) { rec = SNetFifoGet(&db2->recfifo); assert(rec); via_access = true; db2->state = DripBackBusy; } } } if (db2->terminate == DripBackDraining) { if (db2->state == DripBackIdle) { assert(db2->queued == 0 && DripBackCheckBusy(db2) == false); db2->terminate = DripBackTerminated; } } if (db2->terminate == DripBackTerminated) { if (db2->instdesc) { snet_stream_desc_t *desc = db2->instdesc; db2->instdesc = NULL; SNetDescDone(desc); SNetLandingDone(land); } } } else { assert(0); } }
/* Deallocate a stream, but remember it's destination node. */ void SNetStopStream(snet_stream_t *stream, fifo_t *fifo) { SNetFifoPut(fifo, STREAM_DEST(stream)); SNetStreamDestroy(stream); }