EC_BOOL cproc_free(CPROC *cproc)
{
if(NULL_PTR != cproc)
{
cproc_clean_by_rank(cproc, TASK_BRD_RANK(task_brd_default_get()));
cproc_clean(cproc);
munmap(cproc, CPROC_TOTAL_SIZE(CPROC_SIZE(cproc)));
}
return (EC_TRUE);
}
void cproc_abort_default()
{
CPROC *cproc;
cproc = TASK_BRD_CPROC(task_brd_default_get());
if(NULL_PTR != cproc)
{
cproc_abort(cproc);
}
return;
}
/**
*
* start VMATRIXR module
*
**/
UINT32 vmatrix_r_start( )
{
VMATRIXR_MD *vmatrixr_md;
UINT32 vmatrixr_md_id;
UINT32 matrixr_md_id;
UINT32 vmm_md_id;
MOD_MGR *mod_mgr;
TASK_BRD *task_brd;
MOD_NODE *local_mod_node;
vmatrixr_md_id = cbc_md_new(MD_VMATRIXR, sizeof(VMATRIXR_MD));
if(ERR_MODULE_ID == vmatrixr_md_id)
{
return (ERR_MODULE_ID);
}
/* initilize new one VMATRIXR module */
vmatrixr_md = (VMATRIXR_MD *)cbc_md_get(MD_VMATRIXR, vmatrixr_md_id);
vmatrixr_md->usedcounter = 0;
vmatrixr_md->matrixr_md_id = ERR_MODULE_ID;
vmatrixr_md->vmm_md_id = ERR_MODULE_ID;
/* create a new module node */
matrixr_md_id = ERR_MODULE_ID;
vmm_md_id = ERR_MODULE_ID;
init_static_mem();
/*default setting which will be override after vmatrix_r_set_mod_mgr calling*/
mod_mgr = mod_mgr_new(vmatrixr_md_id, LOAD_BALANCING_LOOP);
task_brd = task_brd_default_get();
local_mod_node = &(vmatrixr_md->local_mod_node);
MOD_NODE_TCID(local_mod_node) = TASK_BRD_TCID(task_brd);
MOD_NODE_COMM(local_mod_node) = TASK_BRD_COMM(task_brd);
MOD_NODE_RANK(local_mod_node) = TASK_BRD_RANK(task_brd);
MOD_NODE_MODI(local_mod_node) = vmatrixr_md_id;
matrixr_md_id = matrix_r_start();
vmm_md_id = vmm_start();
vmatrixr_md->mod_mgr = mod_mgr;
vmatrixr_md->task_brd = task_brd;
vmatrixr_md->matrixr_md_id = matrixr_md_id;
vmatrixr_md->vmm_md_id = vmm_md_id;
vmatrixr_md->usedcounter = 1;
return ( vmatrixr_md_id );
}
TASK_NODE *cproc_fetch_task_node(CPROC *cproc, CPROC_ITEM *cproc_item)
{
UINT32 size;
size = csocket_encode_actual_size();
if(size <= cproc_probe_read_len(cproc, cproc_item))
{
UINT32 pos;
UINT32 len;
UINT32 tag;
UINT8 out_buff[32];
UINT32 out_size;
TASK_NODE *task_node;
TASK_BRD *task_brd;
out_size = 0;
if(EC_FALSE == cproc_probe(cproc, cproc_item, out_buff, size, &out_size))
{
return (NULL_PTR);
}
//sys_log(LOGSTDOUT, "[DEBUG] cproc_fetch_task_node: [rank: %ld => %ld] out_size = %ld\n", CPROC_ITEM_ROW_RANK(cproc_item), CPROC_ITEM_COL_RANK(cproc_item),out_size);
//PRINT_BUFF("[DEBUG] cproc_fetch_task_node: ", out_buff, out_size);
task_brd = task_brd_default_get();
pos = 0;
cmpi_decode_uint32(TASK_BRD_COMM(task_brd), out_buff, out_size, &pos, &len);
cmpi_decode_uint32(TASK_BRD_COMM(task_brd), out_buff, out_size, &pos, &tag);
//sys_log(LOGSTDOUT, "[DEBUG] cproc_fetch_task_node: len = %ld, tag = %ld\n", len, tag);
task_node = task_node_new(len, LOC_CPROC_0002);
if(NULL_PTR == task_node)
{
sys_log(LOGSTDOUT, "error:cproc_fetch_task_node: new task_node with %ld bytes failed\n", len);
return (NULL_PTR);
}
TASK_NODE_TAG(task_node) = tag;
cproc_recv(cproc, cproc_item, TASK_NODE_BUFF(task_node), TASK_NODE_BUFF_LEN(task_node), &(TASK_NODE_BUFF_POS(task_node)));
return (task_node);
}
return (NULL_PTR);
}
EC_BOOL cproc_recving_handle(CPROC *cproc, CLIST *save_to_list)
{
UINT32 send_rank;
UINT32 recv_rank;
//sys_log(LOGSTDOUT, "cproc_recving_handle: pid %d cproc %lx\n", getpid(), cproc);
recv_rank = TASK_BRD_RANK(task_brd_default_get());
for(send_rank = 0; send_rank < CPROC_SIZE(cproc); send_rank ++)
{
CPROC_ITEM *cproc_item;
cproc_item = CPROC_ITEM(cproc, send_rank, recv_rank);
cproc_irecv_on_item(cproc, cproc_item, save_to_list);
}
return (EC_TRUE);
}
EC_BOOL cproc_sending_handle(CPROC *cproc)
{
UINT32 send_rank;
UINT32 recv_rank;
send_rank = TASK_BRD_RANK(task_brd_default_get());
for(recv_rank = 0; recv_rank < CPROC_SIZE(cproc); recv_rank ++)
{
CPROC_ITEM *cproc_item;
cproc_item = CPROC_ITEM(cproc, send_rank, recv_rank);
#if 0
sys_log(LOGSTDNULL, "[DEBUG] cproc_sending_handle: check cproc_item %lx: send_rank %ld, recv_rank %ld, while row %ld, col %ld\n",
cproc_item, send_rank, recv_rank, CPROC_ITEM_ROW_RANK(cproc_item), CPROC_ITEM_COL_RANK(cproc_item));
#endif
cproc_isend_on_item(cproc, cproc_item);
}
return (EC_TRUE);
}
EC_BOOL csrv_unix_accept_once(CSRV *csrv, EC_BOOL *continue_flag)
{
UINT32 client_ipaddr;
EC_BOOL ret;
int client_conn_sockfd;
ret = csocket_unix_accept(CSRV_UNIX_SOCKFD(csrv), &(client_conn_sockfd), CSOCKET_IS_NONBLOCK_MODE);
if(EC_TRUE == ret)
{
CSOCKET_CNODE *csocket_cnode;
client_ipaddr = c_ipv4_to_word((const char *)"127.0.0.1");
dbg_log(SEC_0112_CSRV, 1)(LOGSTDOUT, "csrv_unix_accept_once: handle new sockfd %d\n", client_conn_sockfd);
csocket_cnode = csocket_cnode_unix_new(CMPI_ERROR_TCID, client_conn_sockfd, CSOCKET_TYPE_TCP, client_ipaddr, CMPI_ERROR_SRVPORT);/*here do not know the remote client srv port*/
if(NULL_PTR == csocket_cnode)
{
dbg_log(SEC_0112_CSRV, 0)(LOGSTDOUT, "error:csrv_unix_accept_once:failed to alloc csocket cnode for sockfd %d, hence close it\n", client_conn_sockfd);
csocket_close(client_conn_sockfd);
return (EC_FALSE);
}
if(NULL_PTR != CSRV_ADD_CSOCKET_CNODE(csrv))
{
CSRV_ADD_CSOCKET_CNODE(csrv)(CSRV_MD_ID(csrv), csocket_cnode);
}
#if (SWITCH_OFF == TASK_BRD_CEPOLL_SWITCH)
if(1)
{
TASK_BRD *task_brd;
CROUTINE_NODE *croutine_node;
task_brd = task_brd_default_get();
croutine_node = croutine_pool_load(TASK_REQ_CTHREAD_POOL(task_brd), (UINT32)csrv_handle, 2, csrv, csocket_cnode);
if(NULL_PTR == croutine_node)
{
dbg_log(SEC_0112_CSRV, 0)(LOGSTDOUT, "error:csrv_unix_accept_once: cthread load failed\n");
csocket_cnode_close(csocket_cnode);
return (EC_FALSE);
}
CROUTINE_NODE_COND_RELEASE(croutine_node, LOC_CSRV_0004);
}
#endif/*(SWITCH_OFF == TASK_BRD_CEPOLL_SWITCH)*/
#if (SWITCH_ON == TASK_BRD_CEPOLL_SWITCH)
/*note: CSOCKET_CNODE_PKT_HDR will be used for specific purpose*/
BSET(CSOCKET_CNODE_PKT_HDR(csocket_cnode), 0, CSOCKET_CNODE_PKT_HDR_SIZE);
CSOCKET_CNODE_MODI(csocket_cnode) = CSRV_MD_ID(csrv);
cepoll_set_event(task_brd_default_get_cepoll(),
CSOCKET_CNODE_SOCKFD(csocket_cnode),
CEPOLL_RD_EVENT,
(CEPOLL_EVENT_HANDLER)CSRV_RD_EVENT_HANDLER(csrv),
(void *)csocket_cnode);
cepoll_set_complete(task_brd_default_get_cepoll(),
CSOCKET_CNODE_SOCKFD(csocket_cnode),
(CEPOLL_EVENT_HANDLER)CSRV_COMPLETE_HANDLER(csrv),
(void *)csocket_cnode);
cepoll_set_shutdown(task_brd_default_get_cepoll(),
CSOCKET_CNODE_SOCKFD(csocket_cnode),
(CEPOLL_EVENT_HANDLER)CSRV_CLOSE_HANDLER(csrv),
(void *)csocket_cnode);
cepoll_set_timeout(task_brd_default_get_cepoll(),
CSOCKET_CNODE_SOCKFD(csocket_cnode),
CSRV_TIMEOUT_NSEC(csrv),
(CEPOLL_EVENT_HANDLER)CSRV_TIMEOUT_HANDLER(csrv),
(void *)csocket_cnode);
#endif/*(SWITCH_ON == TASK_BRD_CEPOLL_SWITCH)*/
}
(*continue_flag) = ret;
return (EC_TRUE);
}
