void insertSparseGVarientTableMonte(SparseGVarientTableMonte *table,GControlInfoMonte *element,const int row,const int col)
{
SparseGControlInfoMonte *rowTarget = table->rowIndex[row];
SparseGControlInfoMonte *colTarget = table->colIndex[col];
// set rowTarget
while(rowTarget->rowLink != NULL)
{
if(rowTarget->rowLink->col >= col) break;
else rowTarget = rowTarget->rowLink;
}
// set colTarget
while(colTarget->colLink != NULL)
{
if(colTarget->colLink->row >= row) break;
else colTarget = colTarget->colLink;
}
// allocate memory if necessary
if(rowTarget->rowLink==NULL || rowTarget->rowLink->col!=col)
{
SparseGControlInfoMonte *insert = createSparseGControlInfoMonte();
insert->row = row;
insert->col = col;
insert->rowLink = rowTarget->rowLink;
insert->colLink = colTarget->colLink;
// insert element into insert->queue
gdsl_queue_insert(insert->queue,element);
// update the information of target
rowTarget->rowLink = insert;
colTarget->colLink = insert;
}
else
{
gdsl_queue_insert(rowTarget->rowLink->queue,element);
}
}
static void getInitSinkList(gdsl_queue_t freeSinkList, const ParallelETree *tree)
{
int i;
for(i=0;i<tree->size;i++)
// for(i=tree->size-1;i>-1;i--)
{
if(tree->node[i]!=NULL)
{
if(tree->node[i]->type == lu)
{
gdsl_queue_insert(freeSinkList,&i);
}
}
}
}
//Connect to the remote host
cnaccess_t * centernode_connect (centernode_t *cn, const char *host, uint16_t port,
cnaccess_t *a, int type, int isp)
{
int fd = 0;
struct sockaddr_in server;
if ((fd = socket(PF_INET, SOCK_STREAM, 0)) == -1)
{
#ifdef CDNDEBUG
LOG("ER", "create sock-(%d)%s.\n", errno, strerror(errno));
#endif
return 0;
}
//nonblocking connect call
fcntl(fd, F_SETFL, O_NONBLOCK | fcntl(fd, F_GETFL, 0));
memset((uint8_t *)&server, 0, sizeof(server));
server.sin_family = PF_INET;
server.sin_port = htons(port);
server.sin_addr.s_addr = inet_addr(host);
int r = connect(fd, (struct sockaddr *) &server, sizeof(server));
if (r == -1 && errno != EINPROGRESS)
{
#ifdef CDNDEBUG
LOG("ER", "conn to %s.%d-(%d)%s.\n", host, port, errno, strerror(errno));
#endif
return (close(fd), NULL);
}
cnaccess_t *ca = a;
if (ca) { /* reconnect */
ca->fd = fd;
ca->interaction = time(0);
strncpy(ca->host,host,strlen(host));
ca->port = port;
} else ca = cnaccess_create(cn, fd, host, port, type, isp);
if (r == -1 && ++ca->retry > 4)
ca->retry = 1;
ca->status = r ? NS_CONNECTING: NS_NORMAL;
printf("cat %d\n", ca->status);
pthread_mutex_lock(&cn->objlock), /* add it to sesstion table */
gdsl_hash_insert(cn->accesses, ca);
pthread_mutex_unlock(&cn->objlock);
pthread_mutex_lock(&cn->reglock), /* register it to libevent */
gdsl_queue_insert(cn->registration, INT2PTR(ca->fd)),
pthread_mutex_unlock(&cn->reglock);
return ca;
}
//create TCP server
cnaccess_t * centernode_server (centernode_t *cn, const char *host, uint16_t port, uint32_t type, int isp)
{
int fd = 0;
struct sockaddr_in self;
printf("Host %s port %u\n", host, port);
//Create listen socket
if ((fd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
{
#ifdef CDNDEBUG
LOG("WR", "ct sock(%d)%s.\n", errno, strerror(errno));
#endif
return 0;
}
memset((uint8_t *)&self, 0, sizeof(self));
self.sin_family = PF_INET;
self.sin_port = htons(port);
self.sin_addr.s_addr = inet_addr(host);
int val = 1;
if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (void*)&val, sizeof(val)) == -1)
{
#ifdef CDNDEBUG
LOG("WR", "set SO_REUSEADDR option - (%d) %s.\n", errno, strerror(errno));
#endif
return (close(fd), NULL);
}
if (bind(fd, (struct sockaddr *)&self, sizeof(self)) == -1)
{
#ifdef CDNDEBUG
LOG("WR", "bind the address %s.%d - (%d) %s.\n", host, port,
errno, strerror(errno));
#endif
return (close(fd), NULL);
}
if (listen(fd, 200) < 0)
{
#ifdef CDNDEBUG
LOG("WR", "listen on %s.%d - (%d) %s.\n", host, port, errno, strerror(errno));
#endif
return (close(fd), NULL);
}
cnaccess_t *ca = cnaccess_create(cn, fd, host, port, type, isp);
gdsl_hash_insert(cn->accesses, ca);
gdsl_queue_insert(cn->registration, INT2PTR(ca->fd));
return ca;
}
SparseNetlistQuad *parseSparseQuadInput(SparseNetlistQuad *ptr, const char *filename)
{
FILE *fp = fopen(filename,"r");
char line[1024];
char *status;
int i,j,k;
//==========================================================
ptr->a = createSparseQuadMatrix(ptr->nodeNum,ptr->nodeNum,ptr->gvNum);
ptr->b = createSparseQuadMatrix(ptr->nodeNum,ptr->nodeNum,ptr->gvNum);
ptr->c = createSparseQuadMatrix(ptr->nodeNum,ptr->nodeNum,ptr->gvNum);
ptr->u = createQuadMatrix(ptr->nodeNum,ptr->stepNum,ptr->gvNum);
ptr->gVarientTable = createSparseGVarientTable(ptr->nodeNum,ptr->nodeNum);
gdsl_queue_t voltageInNode = gdsl_queue_alloc("voltageInNode",allocInt,freeInt);
double maxG = 10;
LinearNodeList *linearNodeList = createLinearNodeList();
ptr->nonlinearNodeList = createNonlinearNodeList();
while( (status=fgetl(line,1024,fp))!=NULL )
{
if(line[0] == 'G' || line[0] == 'g')
{
CircuitEntryQuad *circuit = createCircuitEntryQuad();
setCircuitEntryQuad(circuit,line);
QuadElement *tempQuadElement = createQuadElement(ptr->gvNum);
const QuadElement *quadElementInList = getLinearNodeList(linearNodeList,circuit->val,circuit->alphaName,circuit->betaName,circuit->gammaName);
if(quadElementInList == NULL)
{
tempQuadElement->m = circuit->val;
tempQuadElement->alpha = getAlpha(circuit->alphaName);
gsl_matrix *betaFromDlmread = gsl_matrix_alloc(ptr->gvNum,1);
dlmread(betaFromDlmread,circuit->betaName," ",0,0,ptr->gvNum-1,0);
gsl_matrix_to_double(tempQuadElement->beta,betaFromDlmread);
gsl_matrix_free(betaFromDlmread);
gsl_matrix *gammaFromDlmread = gsl_matrix_alloc(ptr->gvNum,ptr->gvNum);
dlmread(gammaFromDlmread,circuit->gammaName," ",0,0,ptr->gvNum-1,ptr->gvNum-1);
gsl_matrix_to_double(tempQuadElement->gamma,gammaFromDlmread);
gsl_matrix_free(gammaFromDlmread);
insertLinearNodeList(linearNodeList,circuit->val,circuit->alphaName,circuit->betaName,circuit->gammaName,tempQuadElement);
}
else
{
copyQuadElement(tempQuadElement,quadElementInList);
}
const int pos = toZeroBase(circuit->pos);
const int neg = toZeroBase(circuit->neg);
if(pos != -1)
{
decSparseQuadMatrix(ptr->a,tempQuadElement,pos,pos);
}
if(neg != -1)
{
decSparseQuadMatrix(ptr->a,tempQuadElement,neg,neg);
}
if(pos!=-1 && neg!=-1)
{
incSparseQuadMatrix(ptr->a,tempQuadElement,neg,pos);
incSparseQuadMatrix(ptr->a,tempQuadElement,pos,neg);
}
if(abs(circuit->val) > maxG ) maxG = abs(circuit->val);
freeCircuitEntryQuad(circuit);
freeQuadElement(tempQuadElement);
}
else if(line[0] == 'C' || line[0] == 'c')
{
CircuitEntryQuad *circuit = createCircuitEntryQuad();
setCircuitEntryQuad(circuit,line);
QuadElement *tempQuadElement = createQuadElement(ptr->gvNum);
const QuadElement *quadElementInList = getLinearNodeList(linearNodeList,circuit->val,circuit->alphaName,circuit->betaName,circuit->gammaName);
if(quadElementInList == NULL)
{
tempQuadElement->m = circuit->val;
tempQuadElement->alpha = getAlpha(circuit->alphaName);
gsl_matrix *betaFromDlmread = gsl_matrix_alloc(ptr->gvNum,1);
dlmread(betaFromDlmread,circuit->betaName," ",0,0,ptr->gvNum-1,0);
gsl_matrix_to_double(tempQuadElement->beta,betaFromDlmread);
gsl_matrix_free(betaFromDlmread);
gsl_matrix *gammaFromDlmread = gsl_matrix_alloc(ptr->gvNum,ptr->gvNum);
dlmread(gammaFromDlmread,circuit->gammaName," ",0,0,ptr->gvNum-1,ptr->gvNum-1);
gsl_matrix_to_double(tempQuadElement->gamma,gammaFromDlmread);
gsl_matrix_free(gammaFromDlmread);
insertLinearNodeList(linearNodeList,circuit->val,circuit->alphaName,circuit->betaName,circuit->gammaName,tempQuadElement);
}
else
{
copyQuadElement(tempQuadElement,quadElementInList);
}
const int pos = toZeroBase(circuit->pos);
const int neg = toZeroBase(circuit->neg);
if(pos != -1)
{
incSparseQuadMatrix(ptr->c,tempQuadElement,pos,pos);
}
if(neg != -1)
{
incSparseQuadMatrix(ptr->c,tempQuadElement,neg,neg);
}
if(pos!=-1 && neg!=-1)
{
decSparseQuadMatrix(ptr->c,tempQuadElement,pos,neg);
decSparseQuadMatrix(ptr->c,tempQuadElement,neg,pos);
}
freeCircuitEntryQuad(circuit);
freeQuadElement(tempQuadElement);
}
else if(line[0] =='V' || line[0] =='v')
{
CircuitEntryQuad *circuit = createCircuitEntryQuad();
setVoltageIn(circuit,line);
gsl_matrix *tempM = gsl_matrix_calloc(1,ptr->stepNum);
gsl_matrix *tempAlpha = gsl_matrix_calloc(1,ptr->stepNum);
gsl_matrix *tempBeta = gsl_matrix_calloc(ptr->gvNum,ptr->stepNum);
gsl_matrix *tempGamma = gsl_matrix_calloc(ptr->gvNum*ptr->gvNum,ptr->stepNum);
dlmread(tempM,circuit->mName,",",0,0,0,ptr->stepNum-1);
dlmread(tempAlpha,circuit->alphaName,",",0,0,0,ptr->stepNum-1);
dlmread(tempBeta,circuit->betaName,",",0,0,ptr->gvNum-1,ptr->stepNum-1);
dlmread(tempGamma,circuit->gammaName,",",0,0,ptr->gvNum*ptr->gvNum-1,ptr->stepNum-1);
const int pos = toZeroBase(circuit->pos);
const int neg = toZeroBase(circuit->neg);
if(neg == -1)
{
// save the pos to the voltageInNode ~ used in pass 2 , to setup B
gdsl_queue_insert(voltageInNode,&(circuit->pos));
// for each step, set m, alpha, beta, and gamma
for(i=0;i<ptr->stepNum;i++)
{
QuadElement *tempVin = createQuadElement(ptr->gvNum);
gsl_matrix *betaVin = gsl_matrix_calloc(ptr->gvNum,1);
gsl_matrix *gammaVin = gsl_matrix_calloc(ptr->gvNum,ptr->gvNum);
// set beta
for(j=0;j<ptr->gvNum;j++)
{
const double temp = gsl_matrix_get(tempBeta,j,i);
gsl_matrix_set(betaVin,j,0,temp);
}
// set gamma
for(j=0;j<ptr->gvNum;j++)
{
for(k=0;k<ptr->gvNum;k++)
{
const double temp = gsl_matrix_get(tempGamma,j*ptr->gvNum+k,i);
gsl_matrix_set(gammaVin,j,k,temp);
}
}
double *betaVinDouble = getMempoolSet(sizeof(double)*ptr->gvNum);
double *gammaVinDouble = getMempoolSet(sizeof(double)*ptr->gvNum*ptr->gvNum);
gsl_matrix_to_double(betaVinDouble,betaVin);
gsl_matrix_to_double(gammaVinDouble,gammaVin);
setQuadElement(tempVin,gsl_matrix_get(tempM,0,i),gsl_matrix_get(tempAlpha,0,i),betaVinDouble,gammaVinDouble);
setQuadMatrix(ptr->u,tempVin,pos,i);
freeQuadElement(tempVin);
gsl_matrix_free(betaVin);
gsl_matrix_free(gammaVin);
retMempoolSet(betaVinDouble,sizeof(double)*ptr->gvNum);
retMempoolSet(gammaVinDouble,sizeof(double)*ptr->gvNum*ptr->gvNum);
}
}
else
{
fprintf(stderr,"voltage source does not connect to gnd\n");
}
gsl_matrix_free(tempM);
gsl_matrix_free(tempAlpha);
gsl_matrix_free(tempBeta);
gsl_matrix_free(tempGamma);
freeCircuitEntryQuad(circuit);
}
else if(line[0] == 'M' || line[0] =='m')
{
// ========================================================
MosName *mosName = createMosName();
setMosName(mosName,line);
const NonlinearInfo *nonlinearNodeInList = getNonlinearNodeList(ptr->nonlinearNodeList,mosName->mName,mosName->alphaName,mosName->betaName,mosName->gammaName,mosName->configName);
const NonlinearInfo *data = NULL;
if(nonlinearNodeInList == NULL)
{
MosInfo *mosInfo = createAndSetMosInfo(mosName,ptr->gvNum);
NonlinearInfo *input = createNonlinearInfo(mosInfo->vdsListSize,mosInfo->vgsListSize,mosInfo->vdsList,mosInfo->vgsList,mosInfo->ivTable,mosInfo->cgs,mosInfo->cgd);
insertNonlinearNodeList(ptr->nonlinearNodeList,mosName->mName,mosName->alphaName,mosName->betaName,mosName->gammaName,mosName->configName,input);
freeMosInfo(mosInfo);
freeNonlinearInfo(input);
data = getNonlinearNodeList(ptr->nonlinearNodeList,mosName->mName,mosName->alphaName,mosName->betaName,mosName->gammaName,mosName->configName);
}
else
{
data = nonlinearNodeInList;
}
GControlInfo *newGControlInfo = createGControlInfo(data->vdsListSize,data->vgsListSize,ptr->gvNum);
newGControlInfo->gate = mosName->gate;
newGControlInfo->drain = mosName->drain;
newGControlInfo->source = mosName->source;
newGControlInfo->vdsList = data->vdsList;
newGControlInfo->vgsList = data->vgsList;
freeMosName(mosName);
const int drain = toZeroBase(newGControlInfo->drain);
const int gate = toZeroBase(newGControlInfo->gate);
const int source = toZeroBase(newGControlInfo->source);
newGControlInfo->type = gm;
newGControlInfo->partialIdsVxs = data->partialIdsVgs;
if(drain!=-1 && gate!=-1)
{
newGControlInfo->sign = -1;
insertSparseGVarientTable(ptr->gVarientTable,newGControlInfo,drain,gate);
}
if(source!=-1)
{
newGControlInfo->sign = -1;
insertSparseGVarientTable(ptr->gVarientTable,newGControlInfo,source,source);
}
if(drain!=-1 && source!=-1)
{
newGControlInfo->sign = 1;
insertSparseGVarientTable(ptr->gVarientTable,newGControlInfo,drain,source);
}
if(gate!=-1 && source!=-1)
{
newGControlInfo->sign = 1;
insertSparseGVarientTable(ptr->gVarientTable,newGControlInfo,gate,source);
}
newGControlInfo->type = ro_1;
newGControlInfo->partialIdsVxs = data->partialIdsVds;
if(drain!=-1)
{
newGControlInfo->sign = -1;
insertSparseGVarientTable(ptr->gVarientTable,newGControlInfo,drain,drain);
}
if(source!=-1)
{
newGControlInfo->sign = -1;
insertSparseGVarientTable(ptr->gVarientTable,newGControlInfo,source,source);
}
if(drain!=-1 && source!=-1)
{
newGControlInfo->sign = 1;
insertSparseGVarientTable(ptr->gVarientTable,newGControlInfo,drain,source);
insertSparseGVarientTable(ptr->gVarientTable,newGControlInfo,source,drain);
}
freeGControlInfo(newGControlInfo);
// ===== cgd =====
QuadElement *cgd = createQuadElement(ptr->gvNum);
copyQuadElement(cgd,data->cgd);
if(gate!=-1 && drain!=-1)
{
decSparseQuadMatrix(ptr->c,cgd,gate,drain);
decSparseQuadMatrix(ptr->c,cgd,drain,gate);
}
if(gate!=-1)
{
incSparseQuadMatrix(ptr->c,cgd,gate,gate);
}
if(drain!=-1)
{
incSparseQuadMatrix(ptr->c,cgd,drain,drain);
}
freeQuadElement(cgd);
// ===== cgs =====
QuadElement *cgs = createQuadElement(ptr->gvNum);
copyQuadElement(cgs,data->cgs);
if(gate!=-1 && source!=-1)
{
decSparseQuadMatrix(ptr->c,cgs,gate,source);
decSparseQuadMatrix(ptr->c,cgs,source,gate);
}
if(gate!=-1)
{
incSparseQuadMatrix(ptr->c,cgs,gate,gate);
}
if(source!=-1)
{
incSparseQuadMatrix(ptr->c,cgs,source,source);
}
freeQuadElement(cgs);
}
else
{
// fprintf(stderr,"%s",line);
// fprintf(stderr,"not defined yet\n");
}
}
// the while loop of the first pass
fclose(fp);
// dumpLinearNodeList(stdout,linearNodeList);
freeLinearNodeList(linearNodeList);
// pass 2 , to setup B and the diagonal of A
QuadElement *maxGQuad = createQuadElement(ptr->gvNum);
addConstantQuadElement(maxGQuad,maxG,maxGQuad);
scaleQuadElement(maxGQuad,100,maxGQuad);
while(!gdsl_queue_is_empty(voltageInNode))
{
int *ret = gdsl_queue_remove(voltageInNode);
const int posNodeIndex = toZeroBase(*ret);
// set A
decSparseQuadMatrix(ptr->a,maxGQuad,posNodeIndex,posNodeIndex);
// set B
incSparseQuadMatrix(ptr->b,maxGQuad,posNodeIndex,posNodeIndex);
}
freeQuadElement(maxGQuad);
gdsl_queue_free(voltageInNode);
return ptr;
}
int main (void)
{
int choice = 0;
gdsl_queue_t q = gdsl_queue_alloc ("Q", alloc_integer, free_integer);
do
{
printf ("\t\tMENU - QUEUE\n\n");
printf ("\t1> Put\n");
printf ("\t2> Pop\n");
printf ("\t3> Get Head\n");
printf ("\t4> Get Tail\n");
printf ("\t5> Flush\n");
printf ("\t6> Search\n");
printf ("\t7> Display\n");
printf ("\t8> Dump\n");
printf ("\t9> XML display\n");
printf ("\t0> Quit\n\n" );
printf ("\t\tYour choice: " );
scanf ("%d", &choice );
switch (choice)
{
case 1:
{
int value;
printf ("Enter an integer value: ");
scanf ("%d", &value);
gdsl_queue_insert (q, (void*) &value);
}
break;
case 2:
if (!gdsl_queue_is_empty (q))
{
int* value = (int*) gdsl_queue_remove (q);
printf ("Value: %d\n", *value);
free_integer (value);
}
else
{
printf ("The queue '%s' is empty\n", gdsl_queue_get_name (q));
}
break;
case 3:
{
if (!gdsl_queue_is_empty (q))
{
int head = *(int*) gdsl_queue_get_head (q);
printf ("Head = %d\n", head);
}
else
{
printf ("The queue '%s' is empty\n", gdsl_queue_get_name (q));
}
}
break;
case 4:
{
if (!gdsl_queue_is_empty (q))
{
int tail = *(int*) gdsl_queue_get_tail (q);
printf ("Tail = %d\n", tail);
}
else
{
printf ("The queue '%s' is empty\n", gdsl_queue_get_name (q));
}
}
break;
case 5:
if (gdsl_queue_is_empty (q))
{
printf ("The queue '%s' is empty\n", gdsl_queue_get_name (q));
}
else
{
gdsl_queue_flush (q);
}
break;
case 6:
{
int pos;
int* value;
printf ("Enter an integer value to search an element by its position: ");
scanf ("%d", &pos);
value = (int*) gdsl_queue_search_by_position (q, pos);
if (value != NULL)
{
printf ("Value found at position %d = %d\n", pos, *value);
}
}
break;
case 7:
if (gdsl_queue_is_empty (q))
{
printf ("The queue '%s' is empty\n", gdsl_queue_get_name (q));
}
else
{
printf ("%s = ", gdsl_queue_get_name (q));
gdsl_queue_map_forward (q, my_display_integer, NULL);
}
break;
case 8:
gdsl_queue_dump (q, my_write_integer, stdout, NULL);
break;
case 9:
gdsl_queue_write_xml (q, my_write_integer, stdout, NULL);
break;
}
}
while (choice != 0);
gdsl_queue_free (q);
exit (EXIT_SUCCESS);
}
//Message-Handling Function
void centernode_dispatch (centernode_t *cn, cnaccess_t *ca)
{
int i=0;
cdnmsg_t *req = 0, *res = 0;
if (ca->status == NS_DISUSE)
return;
while (++i < 5 && ca->status != NS_INVALID) {
pthread_mutex_lock(&ca->lock),
req = res = gdsl_list_remove_head(ca->recv_queue),
pthread_mutex_unlock(&ca->lock);
if (!res) break;
//Handle the request for CDN application by plugin.
//fprintf (stderr, "dispatch msg\n");
//LOG("INFO", "Cmd:%08X, R, (%s.%d)\n", ntohl(res->pdu.cmd), ca->host, ca->port);
switch (ntohs(res->pdu.cmd)) {
case CMD_LOGIN:
centernode_cmd_load(cn, ca, req);
break;
case CMD_NTP_RES:
centernode_cmd_ntp_res (cn, ca, res);
break;
case CMD_SMOKY_ALARM:
centernode_cmd_smoky_alarm (cn, ca, req);
break;
case CMD_TMPTURE_ALARM:
centernode_cmd_tmpture_alarm (cn, ca, req);
break;
case CMD_WTPRESURE_ALARM:
centernode_cmd_wtpresure_alarm (cn, ca, req);
break;
case CMD_SMEXHAUST_ALARM:
centernode_cmd_smexhaust_alarm (cn, ca, req);
break;
case CMD_SPRINKLER_ALARM:
centernode_cmd_sprinkler_alarm (cn, ca, req);
break;
case CMD_FIREDV_ALARM:
centernode_cmd_firedv_alarm (cn, ca, req);
break;
case CMD_EMERLIGHT_ALARM:
centernode_cmd_emerlight_alarm (cn, ca, req);
break;
case CMD_ELEFIRE_ALARM:
centernode_cmd_elefire_alarm (cn, ca, req);
break;
case CMD_SMOKY:
//break;
case CMD_TMPTURE:
//break;
case CMD_WTPRESURE:
//break;
case CMD_SMEXHAUST:
//break;
case CMD_SPRINKLER:
// break;
case CMD_FIREDV:
//break;
case CMD_EMERLIGHT:
//break;
case CMD_ELEFIRE:
centernode_timer_task(cn, ca, req);
break;
default: goto disuse; /* unknown command */
}
free(res), res = 0;
}
if (ca->status != NS_INVALID && centernode_timeout(cn, ca))
goto disuse;
pthread_mutex_lock(&ca->lock);
if (ca->status != NS_INVALID) {
if (gdsl_list_get_size(ca->recv_queue) >0)
{
pthread_mutex_unlock(&ca->lock);
threadpool_invoke_add_task(cn->tpool, (void(*)(void *))cbdispatch, ca);
pthread_mutex_lock(&ca->lock);
}
else
ca->status = NS_NORMAL;
if (gdsl_list_get_size(ca->send_queue) >0) {
pthread_mutex_unlock(&ca->lock);
pthread_mutex_lock(&cn->reglock), /* Active the socket. */
gdsl_queue_insert(cn->registration, INT2PTR(ca->fd)),
pthread_mutex_unlock(&cn->reglock);
if (write(cn->notify_send_fd, " ", 1) != 1) {
perror("Error writing to notify pipe");
}
}
else
pthread_mutex_unlock(&ca->lock);
return;
} else pthread_mutex_unlock(&ca->lock);
nodeerror:
centernode_error(cn, ca);
return;
disuse: /* invalid connection */
if (res) free(res);
pthread_mutex_lock(&ca->lock);
if (ca->status == NS_INVALID) {
pthread_mutex_unlock(&ca->lock);
goto nodeerror;
} else ca->status=NS_DISUSE;
pthread_mutex_unlock(&ca->lock);
}
static void updateFreeSinkList(gdsl_queue_t freeSinkList, ParallelETree *tree, const int currentNodeIndex,const int treeInternalSize,const int *priorityTable)
{
int rootIndex = currentNodeIndex/2;
const int leftIndex = rootIndex*2;
const int rightIndex = rootIndex*2 + 1;
int *mark = getMempoolSet(sizeof(int)*(treeInternalSize+1));
memset(mark,0,sizeof(int)*(treeInternalSize+1));
tree->node[currentNodeIndex]->visitLog = visit;
if(tree->node[rootIndex]==NULL)
{
retMempoolSet(mark,sizeof(int)*(treeInternalSize+1));
return;
}
// reorder the queue .... suck implement
if( tree->node[leftIndex]->visitLog==visit && tree->node[rightIndex]->visitLog==visit )
{
int i,j;
int nnz = 0;
while(gdsl_queue_get_size(freeSinkList)!=0)
{
int *indexInQueue = gdsl_queue_get_head(freeSinkList);
gdsl_queue_remove(freeSinkList);
mark[*indexInQueue] = 1;
nnz++;
retMempoolSet(indexInQueue,sizeof(int));
}
mark[rootIndex] = 1;
nnz++;
for(i=0;i<nnz;i++)
{
int maxIndex = -1;
int maxPri = -1;
for(j=1;j<treeInternalSize+1;j++)
{
if( (mark[j]==1) && (priorityTable[j] > maxPri))
{
maxPri = priorityTable[j];
maxIndex = j;
}
}
mark[maxIndex] = 0;
gdsl_queue_insert(freeSinkList,&maxIndex);
}
}
if( tree->node[leftIndex]->visitLog==visit && tree->node[rightIndex]->visitLog==visit )
{
int temp1,temp2;
temp1 = GSL_MIN(tree->node[leftIndex]->doneRowBegin,tree->node[rightIndex]->doneRowBegin);
temp2 = GSL_MIN(tree->node[leftIndex]->rowBegin,tree->node[rightIndex]->rowBegin);
//
tree->node[rootIndex]->doneRowBegin = GSL_MIN(temp1,temp2);
temp1 = GSL_MAX(tree->node[leftIndex]->doneRowEnd,tree->node[rightIndex]->doneRowEnd);
temp2 = GSL_MAX(tree->node[leftIndex]->rowEnd,tree->node[rightIndex]->rowEnd);
tree->node[rootIndex]->doneRowEnd = GSL_MAX(temp1,temp2);
}
retMempoolSet(mark,sizeof(int)*(treeInternalSize+1));
}
