void DaoMT_Select( DaoProcess *proc, DaoValue *par[], int n )
{
DNode *it;
DaoTaskEvent *event = NULL;
DaoFuture *future = DaoProcess_GetInitFuture( proc );
DaoMap *selects = (DaoMap*) par[0];
float timeout = par[1]->xFloat.value;
for(it=DaoMap_First(selects); it; it=DaoMap_Next(selects,it)){
DaoValue *value = it->key.pValue;
int isfut = DaoValue_CheckCtype( value, dao_type_future );
int ischan = DaoValue_CheckCtype( value, dao_type_channel );
if( isfut == 0 && ischan == 0 ){
DaoProcess_RaiseError( proc, "Param", "invalid type selection" );
return;
}
}
event = DaoCallServer_MakeEvent();
DaoTaskEvent_Init( event, DAO_EVENT_WAIT_SELECT, DAO_EVENT_WAIT, future, NULL );
GC_Assign( & event->selects, selects );
proc->status = DAO_PROCESS_SUSPENDED;
proc->pauseType = DAO_PAUSE_CHANFUT_SELECT;
DaoCallServer_AddTimedWait( proc, event, timeout );
/* Message may have been sent before this call: */
DMutex_Lock( & daoCallServer->mutex );
DaoChannel_ActivateEvent( NULL, DAO_EVENT_WAIT_SELECT );
DCondVar_Signal( & daoCallServer->condv );
DMutex_Unlock( & daoCallServer->mutex );
}
static void DaoState_Waitlist( DaoProcess *proc, DaoValue *p[], int N )
{
DaoState *self = (DaoState*)DaoValue_CastCstruct( p[0], NULL );
DaoList *list = DaoProcess_PutList( proc );
DNode *node;
DaoMutex_Lock( self->lock );
node = DaoMap_First( self->demands );
while( node ){
DaoList_PushBack( list, DNode_Key( node ) );
node = DaoMap_Next( self->demands, node );
}
DaoMutex_Unlock( self->lock );
}
static void DaoState_Set( DaoProcess *proc, DaoValue *p[], int N )
{
DaoState *self = (DaoState*)DaoValue_CastCstruct( p[0], NULL );
DNode *node;
DaoMutex_Lock( self->lock );
DaoValue_Copy( p[1], &self->state );
node = DaoMap_First( self->demands );
while( node && DaoValue_Compare( DNode_Key( node ), self->state ) )
node = DaoMap_Next( self->demands, node );
if( node ){
DaoCondVar_BroadCast( (DaoCondVar*)DNode_Value( node ) );
DaoMap_Erase( self->demands, DNode_Key( node ) );
}
DaoMutex_Unlock( self->lock );
}
static void DaoState_TestSet( DaoProcess *proc, DaoValue *p[], int N )
{
DaoState *self = (DaoState*)DaoValue_CastCstruct( p[0], NULL );
int set = 0;
DNode *node;
DaoMutex_Lock( self->lock );
if( !DaoValue_Compare( self->state, p[1] ) ){
DaoValue_Copy( p[2], &self->state );
set = 1;
node = DaoMap_First( self->demands );
while( node && DaoValue_Compare( DNode_Key( node ), self->state ) )
node = DaoMap_Next( self->demands, node );
if( node )
DaoCondVar_BroadCast( (DaoCondVar*)DNode_Value( node ) );
}
DaoMutex_Unlock( self->lock );
DaoProcess_PutInteger( proc, set );
}
static int DaoTaskEvent_CheckSelect( DaoTaskEvent *self )
{
DNode *it;
int closed = 0;
int move = 0;
for(it=DaoMap_First(self->selects); it; it=DaoMap_Next(self->selects,it)){
if( DaoValue_CheckCtype( it->key.pValue, dao_type_channel ) ){
DaoChannel *chan = (DaoChannel*) it->key.pValue;
move = chan->buffer->size > 0;
closed += chan->cap == 0;
}else{
DaoFuture *fut = (DaoFuture*) it->key.pValue;
move = fut->state == DAO_CALL_FINISHED;
}
if( move ) break;
}
if( self->selects->value->size == closed ) move = 1;
return move;
}
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;
}
