void DList_Erase( DList *self, daoint start, daoint n )
{
void **buf = self->items.pVoid - self->offset;
daoint rest;
if( start >= self->size ) return;
if( n < 0 ) n = self->size;
if( n > self->size - start ) n = self->size - start;
if( n == 1 ){
if( start == 0 ){
DList_PopFront( self );
return;
}else if( start == self->size -1 ){
DList_PopBack( self );
return;
}
}
DList_DeleteItems( self, start, start+n );
if( self->type == DAO_DATA_VALUE ) DaoGC_LockData();
rest = self->size - start - n;
memmove( self->items.pVoid + start, self->items.pVoid + start + n, rest * sizeof(void*) );
self->size -= n;
if( self->size < 0.5*self->bufsize && self->size + 10 < self->bufsize ){
if( self->offset ) memmove( buf, self->items.pVoid, self->size * sizeof(void*));
self->bufsize = 0.6 * self->bufsize + 1;
self->items.pVoid = (void**) dao_realloc( buf, (self->bufsize+1)*sizeof(void*) );
self->offset = 0;
}
if( self->type == DAO_DATA_VALUE ) DaoGC_UnlockData();
}
void DCondVar_Signal( DCondVar *self )
{
DThread *thread;
DMutex_Lock( & self->thdMutex );
if( self->thdWaiting->size > 0 ){
thread = (DThread*) self->thdWaiting->items.pVoid[0];
SetEvent( thread->condv.myCondVar );
DList_PopFront( self->thdWaiting );
}
DMutex_Unlock( & self->thdMutex );
}
static void NODE_Search( DaoProcess *proc, DaoValue *p[], int N )
{
DList *nodes;
DaoList *list = DaoProcess_PutList( proc );
DaoxNode *self = (DaoxNode*) p[0];
DaoVmCode *sect = DaoProcess_InitCodeSection( proc, 1 );
daoint method = p[1]->xEnum.value;
daoint which = p[2]->xEnum.value;
daoint i, j, entry;
if( sect == NULL ) return;
for(i=0; i<self->graph->nodes->size; i++){
DaoxNode *node = (DaoxNode*) self->graph->nodes->items.pVoid[i];
node->state = 0;
}
nodes = DList_New(0);
DList_PushBack( nodes, self );
entry = proc->topFrame->entry;
while( nodes->size ){
DaoxNode *node = NULL;
if( method ){
node = (DaoxNode*) DList_Front( nodes );
DList_PopFront( nodes );
}else{
node = (DaoxNode*) DList_Back( nodes );
DList_PopBack( nodes );
}
if( node->state ) continue;
node->state = 1;
if( sect->b >0 ) DaoProcess_SetValue( proc, sect->a, (DaoValue*) node );
proc->topFrame->entry = entry;
DaoProcess_Execute( proc );
if( proc->status == DAO_PROCESS_ABORTED ) break;
if( proc->stackValues[0]->xInteger.value ){
DaoList_PushBack( list, (DaoValue*) node );
if( which == 0 ) break;
}
for(j=0; j<node->outs->size; j++){
DaoxEdge *edge = (DaoxEdge*) node->outs->items.pVoid[j];
DaoxNode *node2 = node == edge->first ? edge->second : edge->first;
DList_PushBack( nodes, node2 );
}
}
DaoProcess_PopFrame( proc );
DList_Delete( nodes );
}
static void DaoSTD_Load( DaoProcess *proc, DaoValue *p[], int N )
{
DaoNamespace *ns;
DaoVmSpace *vms = proc->vmSpace;
DString *name = p[0]->xString.value;
int import = p[1]->xInteger.value;
int runim = p[2]->xInteger.value;
int res = 0;
DList_PushFront( vms->pathLoading, proc->activeNamespace->path );
ns = DaoVmSpace_LoadEx( vms, DString_GetData( name ), runim );
DaoProcess_PutValue( proc, (DaoValue*) ns );
if( ns == NULL ) DaoProcess_RaiseError( proc, NULL, "loading failed" );
DList_PopFront( vms->pathLoading );
if( import && ns ) DaoNamespace_AddParent( proc->activeNamespace, ns );
}
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;
}
