void Pane_ghost_connectivity:: build_pconn(){ // Determine the total node ordering get_node_total_order(); vector< pane_i_vector > gelem_lists; pane_i_vector comm_sizes; vector<vector<map<pair<int,int>,int> > > nodes_to_send; vector<vector<deque<int> > > elems_to_send; get_ents_to_send(gelem_lists, nodes_to_send, elems_to_send, comm_sizes); // Communicate calculated ghost information vector<pane_i_vector> recv_info; send_gelem_lists(gelem_lists, recv_info, comm_sizes); vector<vector<int> > elem_renumbering; vector<vector<map<pair<int,int>,int> > > nodes_to_recv; process_received_data(recv_info, elem_renumbering, nodes_to_recv); finalize_pconn( nodes_to_send, nodes_to_recv, elems_to_send, elem_renumbering, recv_info); }
//------------------------------------------------------------------------------ static void * received_data_processing_thread_func(void * arg) { railCorePlugin * plugin; struct wait_obj * listobj[2]; int numobj; plugin = (railCorePlugin *) arg; plugin->thread_status = 1; LLOGLN(10, ("rail_core_plugin:received_data_processing_thread_func: in")); while (1) { listobj[0] = plugin->term_event; listobj[1] = plugin->data_in_event; numobj = 2; wait_obj_select(listobj, numobj, NULL, 0, 500); if (wait_obj_is_set(plugin->term_event)) { break; } if (wait_obj_is_set(plugin->data_in_event)) { wait_obj_clear(plugin->data_in_event); /* process data in */ process_received_data(plugin); } } LLOGLN(10, ("rail_core_plugin:received_data_processing_thread_func: out")); plugin->thread_status = -1; return 0; }
static int do_transfer(struct psh_ext_if* psh_if_info, void* lp_send, int send_size, int* lp_is_received_data) { int ret_value; int received_size = 0; u64 current_ts_ns; /*let's run SPI!! */ INIT_SPI_IO_CONTEXT(&psh_if_info->send_data_list.low_spi_io_context); GET_TIMESTAMP_NANO(current_ts_ns); //dev_info(&psh_if_info->pshc->dev,"+++++++++++do_io_transaction++++++++++\n"); ret_value = do_io_transaction(psh_if_info->pshc, &psh_if_info->send_data_list.low_spi_io_context, lp_send, send_size, psh_if_info->psh_frame, sizeof(psh_if_info->psh_frame), &received_size); //dev_info(&psh_if_info->pshc->dev,"-----------do_io_transaction----------\n"); /* by yy: below part should move to high level component...just workaround here */ #if 0 if (ch == 0 && cmd->cmd_id == CMD_RESET) { /*wait to let psh reset*/ dev_err(&psh_if_info->pshc->dev,"Send CMD_RESET\n"); msleep(1000); } else if (ch == 0 && cmd->cmd_id == CMD_FW_UPDATE) { /*wait to let psh reset*/ dev_err(&psh_if_info->pshc->dev,"Send CMD_FW_UPDATE\n"); msleep(1000); } #endif lp_is_received_data ? *lp_is_received_data = FALSE : 0; if (IS_SUCCESS(ret_value)) { /*received something, let's check it*/ if (0 != received_size) { process_received_data(psh_if_info, psh_if_info->psh_frame, received_size, current_ts_ns); lp_is_received_data ? *lp_is_received_data = TRUE : 0; } } return ret_value; }
/** * Function to process post requests. * @param server_struct is the main structure for the server. * @param connection is the connection in MHD * @param url is the requested url * @param con_cls is a pointer used to know if this is the first call or not * @param upload_data is a char * pointer to the data being uploaded at this call * @param upload_size is a pointer to an size_t value that says how many data * is ti be copied from upload_data string. * @returns an int that is either MHD_NO or MHD_YES upon failure or not. */ static int process_post_request(server_struct_t *server_struct, struct MHD_Connection *connection, const char *url, void **con_cls, const char *upload_data, size_t *upload_data_size) { int success = MHD_NO; upload_t *pp = (upload_t *) *con_cls; guint64 len = 0; /* print_debug("%ld, %s, %p\n", *upload_data_size, url, pp); */ /* This is for early debug only ! */ if (pp == NULL) { /* print_headers(connection); */ /* Used for debugging */ /* Initialzing the structure at first connection */ len = get_content_length(connection); pp = (upload_t *) g_malloc(sizeof(upload_t)); pp->pos = 0; pp->buffer = g_malloc(sizeof(gchar) * (len + 1)); /* not using g_malloc0 here because it's 1000 times slower */ pp->number = 0; *con_cls = pp; success = MHD_YES; } else if (*upload_data_size != 0) { /* Getting data whatever they are */ memcpy(pp->buffer + pp->pos, upload_data, *upload_data_size); pp->pos = pp->pos + *upload_data_size; pp->number = pp->number + 1; *con_cls = pp; *upload_data_size = 0; success = MHD_YES; } else { /* reset when done */ *con_cls = NULL; pp->buffer[pp->pos] = '\0'; /* Do something with received_data */ success = process_received_data(server_struct, connection, url, pp->buffer); free_variable(pp->buffer); free_variable(pp); } return success; }
/** * AT Command receiving thread. ( ** AT Command Server ** ) * This thread keeps calling a callback function stored * in 'func_ptrs.read' to fetch data, accumulates these data until * a full AT command has been received, and then call the AT decoder. * */ DEFINE_THREAD_ROUTINE_STACK(ATcodec_Commands_Server,data,ATCODEC_STACK_SIZE) { ATcodec_Tree_t *tree = &default_tree; AT_CODEC_ERROR_CODE res; int32_t v_loop, v_read, len, nb_cmd = 0; char buffer[INTERNAL_BUFFER_SIZE]; // user-defined char global_buffer[INTERNAL_BUFFER_SIZE]; char safety[16]; // Absorbs data overflowing from global_buffer. int global_len=0; v_continue = 1; PRINT("Thread AT Commands Server Start\n"); while(!atcodec_lib_init_ok) { vp_os_thread_yield(); } while(v_continue) { vp_os_memset(buffer,0,sizeof(buffer)); vp_os_memset(global_buffer,0,sizeof(global_buffer));global_len=0; vp_os_memset(safety,0,sizeof(safety)); // open and init if((res = func_ptrs.open()) != AT_CODEC_OPEN_OK){ v_continue = 0; } for ( v_loop = 1 ; v_loop && func_ptrs.enable() == AT_CODEC_ENABLE_OK; ) { v_read = 1; do { // wait so that thread can give the hand : delay user-defined / OS-dependent //vp_os_thread_yield(); // -> we do a blocking read few lines after, thus // other threads will be able to run during the I/O /* In case of reading from packets, we clear the incoming buffer. * Splitting AT commands into several packets would be a bad idea since packet order in not guaranteed in UDP. */ if (at_codec_reading_mode==ATCODEC_READ_FROM_PACKETS){ vp_os_memset(global_buffer,0,sizeof(global_buffer)); global_len=0; } /* * Read some bytes; this function blocks until some data are made * available by the VP_COM thread. */ len = sizeof(buffer); //INTERNAL_BUFFER_SIZE/*/2*/; // user-defined res = func_ptrs.read((uint8_t*)&buffer[0], (int32_t*)&len); if(res == AT_CODEC_READ_OK) { if(len > 0) { // process characters and update v_read // \todo Do not use nb_cmd ? /* Data are accumulated in the global buffer until at least one '\r' is found. */ if((nb_cmd = append_reception(&buffer[0], len, &global_buffer[0], &global_len,sizeof(global_buffer))) > 0) { v_read = 0; } else if(nb_cmd == -1) /* no \r found in the global_buffer*/ { // a buffer overflow occurs switch(at_codec_reading_mode) { case ATCODEC_READ_FROM_STREAM: PRINT("AT Codec buffer was filled before a full AT commands was received."); break; case ATCODEC_READ_FROM_PACKETS: PRINT("AT Codec received a packet with no complete AT command or buffer was too small to store the whole packet."); break; } //ATCODEC_PRINT("Overflow\n"); /* In case of overflow, a TCP connection should be reinitialized in order to resynchronize * the client and the server. Otherwise there is no way to find the beginning of the next AT Command. * For a UDP connection, we assume all packets begin with an AT Command, and we just wait * for the next packet to arrive. */ if (at_codec_reading_mode==ATCODEC_READ_FROM_STREAM) { v_loop = 0; } } else { v_read = 1; } } else { if(len < 0) { ATCODEC_PRINT("read returns a neg length\n"); v_loop = 0; } } } else /* if (res == AT_CODEC_READ_OK) */ { // an error occurred ATCODEC_PRINT("an error occurs\n"); v_loop = 0; } } while (v_read && v_loop); // process what has been received if no error occurs if(v_loop) { // ... if(process_received_data(tree, nb_cmd, &global_buffer[0], &global_len) != ATCODEC_TRUE) { ATCODEC_PRINT("process_received returns false\n"); v_loop = 0; } } } /*for*/ // close and un-init : user-defined if((res = func_ptrs.close()) != AT_CODEC_CLOSE_OK) v_continue = 0; }/* while */ if ((res = func_ptrs.shutdown()) != AT_CODEC_SHUTDOWN_OK) { ATCODEC_PRINT("ATcodec Shutdown error\n"); } return((THREAD_RET)0); }