/*
// Activate all events waiting on a future value:
*/
void DaoFuture_ActivateEvent( DaoFuture *self )
{
DaoCallServer *server = daoCallServer;
DList *array = DList_New(0);
DNode *node;
daoint i;
DMutex_Lock( & server->mutex );
for(i=0; i<server->events2->size; ++i){
DaoTaskEvent *event = (DaoTaskEvent*) server->events2->items.pVoid[i];
if( DaoCallServer_CheckEvent( event, self, NULL ) ){
event->state = DAO_EVENT_RESUME;
DList_Append( server->events, event );
DList_Erase( server->events2, i, 1 );
i -= 1;
}
}
for(node=DMap_First(server->waitings); node; node=DMap_Next(server->waitings,node)){
DaoTaskEvent *event = (DaoTaskEvent*) node->value.pValue;
/* remove from timed waiting list: */
if( DaoCallServer_CheckEvent( event, self, NULL ) ){
event->state = DAO_EVENT_RESUME;
DList_Append( server->events, event );
DList_Append( array, node->key.pVoid );
}
}
for(i=0; i<array->size; i++) DMap_Erase( server->waitings, array->items.pVoid[i] );
DCondVar_Signal( & server->condv );
DMutex_Unlock( & server->mutex );
DList_Delete( array );
}
/*
// Only activate one event per channel:
*/
void DaoChannel_ActivateEvent( DaoChannel *self, int type )
{
DaoCallServer *server = daoCallServer;
DNode *node;
daoint i;
for(i=0; i<server->events2->size; ++i){
DaoTaskEvent *event = (DaoTaskEvent*) server->events2->items.pVoid[i];
if( event->type != type ) continue;
if( DaoCallServer_CheckEvent( event, NULL, self ) ){
DList_Append( server->events, event );
DList_Erase( server->events2, i, 1 );
return;
}
}
for(node=DMap_First(server->waitings); node; node=DMap_Next(server->waitings,node)){
DaoTaskEvent *event = (DaoTaskEvent*) node->value.pValue;
if( event->type != type ) continue;
if( DaoCallServer_CheckEvent( event, NULL, self ) ){
DList_Append( server->events, event );
DMap_EraseNode( server->waitings, node );
return;
}
}
}
static void DaoCallServer_ActivateEvents()
{
DaoCallServer *server = daoCallServer;
char message[128];
daoint i, j, count = 0;
if( server->finishing == 0 ) return;
if( server->idle != server->total ) return;
if( server->events->size != 0 ) return;
if( server->events2->size == 0 ) return;
#ifdef DEBUG
sprintf( message, "WARNING: try activating events (%i,%i,%i,%i)!\n", server->total,
server->idle, (int)server->events->size, (int)server->events2->size );
DaoStream_WriteChars( mainVmSpace->errorStream, message );
#endif
for(i=0; i<server->events2->size; ++i){
DaoTaskEvent *event = (DaoTaskEvent*) server->events2->items.pVoid[i];
DaoChannel *chan = event->channel;
DaoFuture *fut = event->future;
int move = 0, closed = 0;
switch( event->type ){
case DAO_EVENT_WAIT_TASKLET :
move = fut->precond == NULL || fut->precond->state == DAO_CALL_FINISHED;
break;
case DAO_EVENT_WAIT_RECEIVING :
move = chan->buffer->size > 0;
if( chan->cap <= 0 && chan->buffer->size == 0 ) move = 1;
break;
case DAO_EVENT_WAIT_SENDING :
move = chan->buffer->size < chan->cap;
break;
case DAO_EVENT_WAIT_SELECT :
if( event->selects == NULL ) continue;
move = DaoTaskEvent_CheckSelect( event );
break;
default: break;
}
if( move ){
DList_Append( server->events, event );
DList_Erase( server->events2, i, 1 );
count += 1;
i -= 1;
}
}
DCondVar_Signal( & server->condv );
if( count == 0 ){
DaoStream *stream = mainVmSpace->errorStream;
DaoStream_WriteChars( stream, "ERROR: All tasklets are suspended - deadlock!\n" );
#if DEBUG
fprintf( stderr, "ERROR: All tasklets are suspended - deadlock!\n" );
#endif
exit(1);
}
}
static double DaoxGraph_MaxFlow_PRTF_Float( DaoxGraph *self, DaoxNode *source, DaoxNode *sink )
{
daoint i, n;
double inf = 1.0;
DList *list = DList_New(0);
for(i=0,n=source->outs->size; i<n; i++){
DaoxEdge *edge = source->outs->items.pgEdge[i];
if( source == edge->first ) inf += edge->X.MF->capacity;
}
for(i=0,n=self->nodes->size; i<n; i++){
DaoxNode *node = self->nodes->items.pgNode[i];
node->X.MF->nextpush = 0;
node->X.MF->height = 0;
node->X.MF->excess = 0.0;
if( node != source && node != sink ) DList_PushBack( list, node );
}
source->X.MF->nextpush = 0;
source->X.MF->height = n;
source->X.MF->excess = inf;
for(i=0,n=self->edges->size; i<n; i++){
DaoxEdge *edge = self->edges->items.pgEdge[i];
edge->X.MF->flow_fw = 0.0;
edge->X.MF->flow_bw = 0.0;
}
for(i=0,n=source->outs->size; i<n; i++){
DaoxEdge *edge = source->outs->items.pgEdge[i];
if( source == edge->first ) MaxFlow_PushFloat( source, edge );
}
i = 0;
while( i < list->size ){
DaoxNode *U = list->items.pgNode[i];
daoint old_height = U->X.MF->height;
MaxFlow_DischargeFloat( U );
if( U->X.MF->height > old_height ){
DList_Erase( list, i, 1 );
DList_PushFront( list, U );
i = 0;
}else{
i += 1;
}
}
DList_Delete( list );
inf = 0.0;
for(i=0,n=source->outs->size; i<n; i++){
DaoxEdge *edge = source->outs->items.pgEdge[i];
if( source == edge->first ) inf += edge->X.MF->flow_fw;
}
return inf;
}
static void DaoSTD_Exec( DaoProcess *proc, DaoValue *p[], int n )
{
DaoVmCode *sect = DaoProcess_InitCodeSection( proc, 0 );
int ecount = proc->exceptions->size;
if( sect == NULL ) return;
DaoProcess_Execute( proc );
DaoProcess_PopFrame( proc );
if( proc->exceptions->size > ecount ){
if( n > 0 ){
DaoProcess_PutValue( proc, p[0] );
DList_Erase( proc->exceptions, ecount, -1 );
}
}else{
DaoProcess_PutValue( proc, proc->stackValues[0] );
}
}
static void DaoSTD_Try( DaoProcess *proc, DaoValue *p[], int n )
{
DaoVmCode *sect = DaoProcess_InitCodeSection( proc, 0 );
int i, ecount = proc->exceptions->size;
if( sect == NULL ) return;
DaoProcess_Execute( proc );
DaoProcess_PopFrame( proc );
if( proc->exceptions->size > (ecount+1) ){
DaoList *list = DaoProcess_PutList( proc );
for(i=ecount; i<proc->exceptions->size; ++i){
DaoList_Append( list, proc->exceptions->items.pValue[i] );
}
DList_Erase( proc->exceptions, ecount, -1 );
}else if( proc->exceptions->size > ecount ){
DaoProcess_PutValue( proc, proc->exceptions->items.pValue[proc->exceptions->size-1] );
DList_PopBack( proc->exceptions );
}else{
DaoProcess_PutValue( proc, proc->stackValues[0] );
}
}
static void DaoCallThread_Run( DaoCallThread *self )
{
DaoCallServer *server = daoCallServer;
double wt = 0.001;
daoint i, count, timeout;
self->thdData = DThread_GetSpecific();
if( self->taskFunc ){
self->taskFunc( self->taskParam );
self->taskOwner = NULL;
}
while( server->vmspace->stopit == 0 ){
DaoProcess *process = NULL;
DaoFuture *future = NULL;
DThreadTask function = NULL;
void *parameter = NULL;
if( self->thdData != NULL ) self->thdData->state = 0;
DMutex_Lock( & server->mutex );
server->idle += 1;
server->vacant += self->taskOwner == NULL;
while( server->pending->size == (server->events2->size + server->waitings->size) ){
//printf( "%p %i %i %i %i\n", self, server->events->size, server->pending->size, server->events2->size, server->waitings->size );
if( server->vmspace->stopit ) break;
if( server->finishing && server->vacant == server->total ){
if( (server->events2->size + server->waitings->size) == 0 ) break;
}
wt = 0.01*(server->idle == server->total) + 0.001;
timeout = DCondVar_TimedWait( & server->condv, & server->mutex, wt );
}
for(i=0; i<server->parameters->size; ++i){
void *param = server->parameters->items.pVoid[i];
if( DMap_Find( server->active, param ) ) continue;
DMap_Insert( server->active, param, NULL );
self->taskOwner = server->owners->items.pVoid[i];
function = (DThreadTask) server->functions->items.pVoid[i];
parameter = param;
DList_Erase( server->functions, i, 1 );
DList_Erase( server->parameters, i, 1 );
DList_Erase( server->owners, i, 1 );
DMap_Erase( server->pending, parameter );
server->idle -= 1;
server->vacant -= 1;
break;
}
DMutex_Unlock( & server->mutex );
if( server->vmspace->stopit ) break;
if( function ){
(*function)( parameter );
self->taskOwner = NULL;
DMutex_Lock( & server->mutex );
DMap_Erase( server->active, parameter );
DMutex_Unlock( & server->mutex );
continue;
}
if( server->pending->size == 0 && server->finishing && server->vacant == server->total ) break;
DMutex_Lock( & server->mutex );
server->idle -= 1;
server->vacant -= self->taskOwner == NULL;
future = DaoCallServer_GetNextFuture();
DMutex_Unlock( & server->mutex );
if( future == NULL ) continue;
process = future->process;
if( process == NULL ){
GC_DecRC( future );
continue;
}
count = process->exceptions->size;
future->state = DAO_CALL_RUNNING;
DaoProcess_InterceptReturnValue( process );
DaoProcess_Start( process );
if( process->exceptions->size > count ) DaoProcess_PrintException( process, NULL, 1 );
if( process->status <= DAO_PROCESS_ABORTED ) self->taskOwner = NULL;
if( future->actor ){
int erase = 1;
DMutex_Lock( & server->mutex );
if( future->actor->rootObject->isAsync ){
erase = process->status == DAO_PROCESS_FINISHED;
}
if( erase ) DMap_Erase( server->active, future->actor->rootObject );
DMutex_Unlock( & server->mutex );
}
DMutex_Lock( & server->mutex );
DMap_Erase( server->active, process );
process->active = 0;
DMutex_Unlock( & server->mutex );
DaoProcess_ReturnFutureValue( process, future );
if( future->state == DAO_CALL_FINISHED ) DaoFuture_ActivateEvent( future );
GC_DecRC( future );
}
DMutex_Lock( & server->mutex );
server->stopped += 1;
DMutex_Unlock( & server->mutex );
}
static DaoFuture* DaoCallServer_GetNextFuture()
{
DaoCallServer *server = daoCallServer;
DaoFuture *first, *future, *precond;
DList *events = server->events;
DMap *pending = server->pending;
DMap *active = server->active;
DNode *it;
daoint i, j;
for(i=0; i<events->size; i++){
DaoTaskEvent *event = (DaoTaskEvent*) events->items.pVoid[i];
DaoFuture *future = event->future;
DaoObject *actor = future->actor;
DaoChannel *channel = event->channel;
DaoChannel *closed = NULL;
DaoChannel *chselect = NULL;
DaoFuture *futselect = NULL;
DaoValue *selected = NULL;
DaoValue *message = NULL;
int type = event->type;
if( event->state == DAO_EVENT_WAIT && future->precond != NULL ){
if( future->precond->state != DAO_CALL_FINISHED ) goto MoveToWaiting;
}
switch( event->type ){
case DAO_EVENT_WAIT_SENDING :
if( channel->buffer->size >= channel->cap ){
if( event->state == DAO_EVENT_WAIT ){
DaoChannel_ActivateEvent( channel, DAO_EVENT_WAIT_RECEIVING );
DaoChannel_ActivateEvent( channel, DAO_EVENT_WAIT_SELECT );
goto MoveToWaiting;
}
}
event->type = DAO_EVENT_RESUME_TASKLET;
break;
case DAO_EVENT_WAIT_RECEIVING :
if( channel->buffer->size == 0 ){
if( channel->cap > 0 && event->state == DAO_EVENT_WAIT ){
DaoChannel_ActivateEvent( channel, DAO_EVENT_WAIT_SENDING );
goto MoveToWaiting;
}
message = dao_none_value;
}else{
message = channel->buffer->items.pValue[0];
}
GC_Assign( & event->message, message );
event->auxiliary = channel->cap <= 0 && channel->buffer->size == 0;
event->type = DAO_EVENT_RESUME_TASKLET;
DList_PopFront( channel->buffer );
if( channel->buffer->size < channel->cap )
DaoChannel_ActivateEvent( channel, DAO_EVENT_WAIT_SENDING );
if( channel->buffer->size )
DaoChannel_ActivateEvent( channel, DAO_EVENT_WAIT_RECEIVING );
break;
case DAO_EVENT_WAIT_SELECT :
message = dao_none_value;
for(it=DaoMap_First(event->selects); it; it=DaoMap_Next(event->selects,it)){
if( DaoValue_CheckCtype( it->key.pValue, dao_type_channel ) ){
DaoChannel *chan = (DaoChannel*) it->key.pValue;
if( chan->buffer->size > 0 ){
chselect = chan;
selected = it->key.pValue;
message = chan->buffer->items.pValue[0];
closed = NULL;
break;
}else if( chan->cap == 0 ){
closed = chan;
}
}else{
DaoFuture *fut = (DaoFuture*) it->key.pValue;
if( fut->state == DAO_CALL_FINISHED ){
futselect = fut;
selected = it->key.pValue;
message = fut->value;
break;
}
}
}
if( selected == NULL ) selected = (DaoValue*) closed;
if( event->state == DAO_EVENT_WAIT && event->selects->value->size ){
if( selected == NULL ) goto MoveToWaiting;
}
GC_Assign( & event->message, message );
GC_Assign( & event->selected, selected );
event->auxiliary = event->selects->value->size == 0;
event->type = DAO_EVENT_RESUME_TASKLET;
/* change status to not finished: */
if( chselect != NULL || futselect != NULL ) event->auxiliary = 0;
if( chselect ){
DList_PopFront( chselect->buffer );
if( chselect->buffer->size < chselect->cap )
DaoChannel_ActivateEvent( chselect, DAO_EVENT_WAIT_SENDING );
if( chselect->buffer->size )
DaoChannel_ActivateEvent( chselect, DAO_EVENT_WAIT_SELECT );
}
if( futselect != NULL || closed != NULL ){
void *key = futselect ? (void*)futselect : (void*)closed;
DMap_Erase( event->selects->value, key );
}
break;
default: break;
}
if( actor ){
DNode *it = DMap_Find( active, actor->rootObject );
if( actor->rootObject->isAsync ){
if( it && it->value.pVoid != (void*) future ) continue;
}else if( it ){
continue;
}
}
if( future->process && DMap_Find( active, future->process ) ) continue;
DList_Erase( events, i, 1 );
DMap_Erase( pending, event );
if( actor ){
void *value = actor->rootObject->isAsync ? future : NULL;
DMap_Insert( active, actor->rootObject, value );
}
if( future->process ){
DMap_Insert( active, future->process, NULL );
future->process->active = 1;
}
/*
// DaoValue_Move() should be used instead of GC_Assign() for thread safety.
// Because using GC_Assign() here, may caused "future->message" of primitive
// type being deleted, right after DaoFuture_GetGCFields() has retrieved it
// for GC scanning.
*/
DaoValue_Move( event->message, & future->message, NULL );
DaoValue_Move( event->selected, & future->selected, NULL );
future->aux1 = event->auxiliary;
future->timeout = event->timeout;
GC_IncRC( future ); /* To be decreased at the end of tasklet; */
DaoCallServer_CacheEvent( event );
return future;
MoveToWaiting:
if( event->expiring >= 0.0 && event->expiring < MIN_TIME ) continue;
if( event->expiring >= MIN_TIME ){
dao_complex com = {0.0,0.0};
com.real = event->expiring;
DMap_Insert( server->waitings, & com, event );
DCondVar_Signal( & server->condv2 );
}else{
DList_Append( server->events2, event );
}
DList_Erase( server->events, i, 1 );
i -= 1;
}
return NULL;
}
