/* open the specified url in the configured browser */ static int command_open_url(char *text, int len) { text = getparams(text); if (*text) open_web_link(text); return 1; }
//Constructor TritechMicron(ros::NodeHandle & nh) { getparams(nh); if ( !simulate_ ) { scan_line_pub_ = nh.advertise<_ScanLineMsgType>( "scan_line", 1 ); driver_ = new TritechMicronDriver( num_bins_, range_, velocity_of_sound_,angle_step_size_, leftLimit_, rightLimit_,use_debug_mode ); reconfigserver = nh.advertiseService("Sonar_Reconfiguration", &TritechMicron::reconfig, this); driver_->registerScanLineCallback( std::bind( &TritechMicron::publish,this,std::placeholders::_1, std::placeholders::_2,std::placeholders::_3 ) ); uint8_t angle_step_size_byte = std::max(1, std::min(255, angle_step_size_)); if ( !driver_->connect( port_.c_str()) ) { ROS_ERROR( "Could not connect to device; simulating instead." ); simulate_ = true; } } }
int command_accept_buddy(char *text, int len) { /* This command is here to make sure the requests queue is up to date */ text = getparams(text); /* Make sure a name is given */ if(*text) accept_buddy_console_command(text); return 0; // also pass to server }
/* set the command queues wait time between commands */ static int command_set_user_menu_wait_time_ms(char *text, int len) { text = getparams(text); if (*text) set_command_queue_wait_time_ms(atol(text)); else set_command_queue_wait_time_ms(0); return 1; }
Parse_stat MCComref::parse(MCScriptPoint &sp) { initpoint(sp); if (getparams(sp, ¶ms) != PS_NORMAL) { MCperror->add(PE_STATEMENT_BADPARAMS, sp); return PS_ERROR; } return PS_NORMAL; }
/* pretend the specified key has been pressed - allows user menu to trigger keypress events */ int command_keypress(char *text, int len) { text = getparams(text); if (*text) { Uint32 value = get_key_value(text); if (value) do_keypress(value); } return 1; }
/* pretend the specified key has been pressed - allows user menu to trigger keypress events */ int command_keypress(char *text, int len) { text = getparams(text); if (*text) { Uint32 value = get_key_value(text); if (value) keypress_root_common(value, 0); } return 1; }
Parse_stat MCSampleVariance::parse(MCScriptPoint &sp, Boolean the) { initpoint(sp); if (getparams(sp, ¶ms) != PS_NORMAL) { MCperror->add (PE_VARIANCE_BADPARAM, line, pos); return PS_ERROR; } return PS_NORMAL; }
Parse_stat MCAvgDev::parse(MCScriptPoint &sp, Boolean the) { initpoint(sp); if (getparams(sp, ¶ms) != PS_NORMAL) { MCperror->add (PE_AVGDEV_BADPARAM, line, pos); return PS_ERROR; } return PS_NORMAL; }
Parse_stat MCHarmonicMean::parse(MCScriptPoint &sp, Boolean the) { initpoint(sp); if (getparams(sp, ¶ms) != PS_NORMAL) { MCperror->add (PE_HAR_MEAN_BADPARAM, line, pos); return PS_ERROR; } return PS_NORMAL; }
/* parse the command parameters for a spell message, then cast it */ static int command_cast_spell(char *text, int len) { int index = 0; int valid_looking_message = 1; Uint8 str[30]; /* valid messages start with the CAST_SPELL message of 39 or 0x27 */ text = getparams(text); if (!*text || strstr(text, "27")==NULL) valid_looking_message = 0; /* skip past everything until the CAST_SPELL message type */ else text = strstr(text, "27"); /* while we have hex digit pairs to process */ while (valid_looking_message && strlen(text)>0 && index<30) { int i; Uint8 d[2]; while (*text==' ') text++; if (strlen(text)<2) break; for (i=0; i<2; i++) { d[i] = *text++; if (d[i] >= '0' && d[i] <= '9') d[i] -= '0'; else if (d[i] >= 'a' && d[i] <= 'f') d[i] -= 'a'-10; else if (d[i] >= 'A' && d[i] <= 'F') d[i] -= 'A'-10; else { valid_looking_message = 0; break; } } /* store the spell message byte */ if (valid_looking_message) str[index++] = d[1] + 16*d[0]; } /* if we're now at the end of the text, we have some message bytes and it looks valid */ if (!*text && index && valid_looking_message) send_spell(str, index); else LOG_TO_CONSOLE(c_red2, invalid_spell_string_str); return 1; }
// TODO: make this automatic or a better command, m is too short int command_msg(char *text, int len) { int no; // find first space, then skip any spaces text = getparams(text); if(my_strncompare(text, "all", 3)) { print_all_messages(); } else { no = atoi(text) - 1; print_message(no); } return 1; }
// TODO: make this automatic or a better command, m is too short int command_msg(char *text, int len) { int no;//, m=-1; // find first space, then skip any spaces text = getparams(text); if(my_strncompare(text, "all", 3)) { for(no = 0; no < pm_log.ppl; no++) { print_message(no); } } else { no = atoi(text) - 1; if(no < pm_log.ppl && no >= 0) { print_message(no); } } return 1; }
int command_accept_buddy(char *text, int len) { /* This command is here to make sure the requests queue is up to date */ text = getparams(text); /* Make sure a name is given */ if(*text && !queue_isempty(buddy_request_queue)) { node_t *node = queue_front_node(buddy_request_queue); /* Search for the node in the queue */ while(node != NULL) { if(strcasecmp(text, node->data) == 0) { /* This is the node we're looking for, delete it */ queue_delete_node(buddy_request_queue, node); break; } node = node->next; } } return 0; }
/* display or test the md5sum of the current map or the specified file */ int command_ckdata(char *text, int len) { const int DIGEST_LEN = 16; Uint8 digest[DIGEST_LEN]; char digest_str[DIGEST_LEN*2+1]; char expected_digest_str[DIGEST_LEN*2+1]; char result_str[256]; char filename[256]; /* paramters are optional, first is expected checksum value, second is filename */ /* if only a filename is specfied, we display checksum rather than do match */ filename[0] = digest_str[0] = expected_digest_str[0] = '\0'; text = getparams(text); if (*text) { /* if we have at least one space and the first string is of digest length, assume we matching */ char *tempstr = safe_strcasestr(text, strlen(text), " ", 1); if ((tempstr != NULL) && (strlen(text) - strlen(tempstr) == DIGEST_LEN*2)) { safe_strncpy2(expected_digest_str, text, DIGEST_LEN*2+1, DIGEST_LEN*2 ); /* trim leading space from filename */ while (*tempstr == ' ') tempstr++; if (*tempstr) safe_strncpy(filename, tempstr, 256); } /* else we only have a filename */ else safe_strncpy(filename, text, 256 ); } /* if no parameters default to current map elm file */ else safe_strncpy(filename, continent_maps[cur_map].name, 256 ); /* calculate, display checksum if we're not matching */ if (*filename && el_file_exists(filename) && get_file_digest(filename, digest)) { int i; for(i=0; i<DIGEST_LEN; i++) sprintf(&digest_str[2*i], "%02x", (int)digest[i]); digest_str[DIGEST_LEN*2] = 0; if (! *expected_digest_str) { safe_snprintf(result_str, sizeof(result_str), "#ckdata %s %s", digest_str, filename ); LOG_TO_CONSOLE(c_grey1,result_str); } } /* show help if something fails */ else { LOG_TO_CONSOLE(c_red2, "ckdata: invalid file or command syntax."); LOG_TO_CONSOLE(c_red1, "Show current map (elm): #ckdata"); LOG_TO_CONSOLE(c_red1, "Show specified file: #ckdata file_name"); LOG_TO_CONSOLE(c_red1, "Check specified file: #ckdata expected_checksum file_name"); return 1; } /* if we have an expected value, compare then display an appropriate message */ if (*expected_digest_str) { if (my_strcompare(digest_str, expected_digest_str)) LOG_TO_CONSOLE(c_green2,"ckdata: File matches expected checksum"); else LOG_TO_CONSOLE(c_red2,"ckdata: File does not match expected checksum"); } return 1; } /* end command_ckdata() */
int main (void) { sei(); uart_init(UART_BAUD_SELECT(9600, F_CPU)); uart_puts("\r\n\r\nTHIS PROGRAM USES 57600 BAUD - PLEASE CHANGE\r\n\r\n"); _delay_ms(100); uart_init(UART_BAUD_SELECT(57600, F_CPU)); cmd_clear(); uart_puts_P("\n\n\n\n\r"); uart_puts_P("--------------------------\r\n"); uart_puts_P("System [OK]\r\n"); systimer_init(); uart_puts_P("System Timer [OK]\r\n"); /* SD Karte Initilisieren */ cmd_init(); uart_puts_P("--------------------------\r\n\r\n"); _delay_ms(100); char input[50]={0}; static char parameters[10][32]; while(1) { for (uint8_t i = 0; i<=10; *parameters[++i]=0x00); // Input uart_puts_P("> "); uart_input(input); // Process Input getparams(input, 10, 32, parameters); char *cmd = parameters[0]; // Call Functions if (strings_equal(cmd, "ls")) { uint32_t cluster = 0; if (parameters[1][0] != 0x00) cluster = str2num(parameters[1], 16); cmd_ls(cluster); } else if (strings_equal(cmd, "cat")) { if (parameters[1][0] == 0x00 || parameters[2][0] == 0x00) cmd_help("cat"); else { uint64_t cluster = str2num(parameters[1], 16); uint64_t size = str2num(parameters[2], 16); cmd_cat(cluster, size); } } else if (strings_equal(cmd, "readtest")) { if (parameters[1][0] == 0x00 || parameters[2][0] == 0x00) cmd_help("readtest"); else { uint64_t cluster = str2num(parameters[1], 16); uint64_t size = str2num(parameters[2], 16); cmd_readtest(cluster, size); } } else if (strings_equal(cmd, "write")) { if (parameters[1][0] == 0x00 || parameters[2][0] == 0x00) cmd_help("write"); else { uint64_t cluster = str2num(parameters[1], 16); uint8_t adcport = str2num(parameters[2], 10); uint64_t maxsize = str2num(parameters[3], 16); uint8_t speed = str2num(parameters[4], 10); if (parameters[3][0] == 0x00) maxsize = 512; if (parameters[4][0] == 0x00) speed = 50; cmd_write(cluster, adcport, maxsize, speed); } } else if (strings_equal(cmd, "clear")) cmd_clear(); else if (strings_equal(cmd, "time")) cmd_time(); else if (strings_equal(cmd, "init")) cmd_init(); else if (strings_equal(cmd, "help")) cmd_help(parameters[1]); else uart_puts_P("Error: Command not found\n\r"); } while (1); return (1); }
/* Display book names that match the specified string, or all if * no string specified. Highlighing the books that have been read. */ int knowledge_command(char *text, int len) { char this_string[80], count_str[60]; char *cr; int num_read = 0, num_total = 0; int show_read = 1, show_unread = 1, show_help = 0; size_t i; char * pstr[3] = { knowledge_param_read, knowledge_param_unread, knowledge_param_total }; size_t plen[3] = { strlen(knowledge_param_read), strlen(knowledge_param_unread), strlen(knowledge_param_total) }; // find first space, then skip any spaces text = getparams(text); // use the short form of the params (-r -u -t) if valid and different if ((plen[0] > 1) && (plen[1] > 1) && (plen[2] > 1) && (pstr[0][0] == '-') && (pstr[1][0] == '-') && (pstr[2][0] == '-') && (pstr[0][1] != pstr[1][1]) && (pstr[0][1] != pstr[2][1]) && (pstr[1][1] != pstr[2][1])) plen[0] = plen[1] = plen[2] = 2; // show the help if no paramaters specified if (strlen(text) == 0) show_help = 1; // Look for -read, -unread or -total paramaters and vary the output appropriately else if (strncmp(text, knowledge_param_read, plen[0]) == 0) { show_unread = 0; text = getparams(text+plen[0]); } else if (strncmp(text, knowledge_param_unread, plen[1]) == 0) { show_read = 0; text = getparams(text+plen[1]); } else if (strncmp(text, knowledge_param_total, plen[2]) == 0) { show_read = show_unread = 0; text = getparams(text+plen[2]); } if (show_read || show_unread) LOG_TO_CONSOLE(c_green2,knowledge_cmd_str); for (i=0; i<KNOWLEDGE_LIST_SIZE; i++) { // only display books that contain the specified parameter string // shows all books if no string specified if ((strlen(knowledge_list[i].name) > 0) && (get_string_occurance(text, knowledge_list[i].name, strlen(knowledge_list[i].name), 1) != -1)) { // remove any trailing carrage return safe_strncpy(this_string, knowledge_list[i].name, sizeof(this_string)); if ( (cr = strchr(this_string, '\n')) != NULL) *cr = '\0'; // highlight books that have been read if (knowledge_list[i].present) { if (show_read) LOG_TO_CONSOLE(c_grey1,this_string); ++num_read; } else if (show_unread) LOG_TO_CONSOLE(c_grey2,this_string); ++num_total; } } safe_snprintf(count_str, sizeof(count_str), book_count_str, num_read, num_total); LOG_TO_CONSOLE(c_grey1, count_str); // give help only if no parameters specified if (show_help) LOG_TO_CONSOLE(c_grey1, know_help_str); return 1; }
BOOST_FORCEINLINE result_type operator()( A0& a0, A1& a1 ) const { bool first = true; getparams(a0, first, N0()); compute(a0, a1, first, N1()); }
int main(int argc, const char* argv[]) { if (argc < 2) { printf("Usage: ./dinneuro filename\n"); return -1; } //подготавливаем выборки if (csv2fann2(argv[1], 59, 50, 100, true)) { printf("Converted\n"); } //получим данные о количестве входных и выходных параметров int *params; const char * filename; const char * normfilename; filename = "data.data"; //filename = "scaling.data"; normfilename = "normalized.train"; params = getparams(filename); unsigned int num_threads = omp_get_thread_num(); float error; const unsigned int num_input = params[1]; const unsigned int num_output = params[2]; //printf("num_input=%d num_output=%d\n", num_input, num_output); const unsigned int num_layers = 4; //const unsigned int num_neurons_hidden = num_output; const unsigned int num_neurons_hidden = 5; const float desired_error = (const float) 0.0001; const unsigned int max_epochs = 5000; const unsigned int epochs_between_reports = 1000; struct fann_train_data * data = NULL; struct fann *ann = fann_create_standard(num_layers, num_input, num_neurons_hidden, num_neurons_hidden, num_output); fann_set_activation_function_hidden(ann, FANN_LINEAR); fann_set_activation_function_output(ann, FANN_SIGMOID_SYMMETRIC); fann_set_training_algorithm(ann, FANN_TRAIN_RPROP); //printf("test\n"); data = fann_read_train_from_file(filename); printf("Readed train from %s\n", filename); fann_set_scaling_params( ann, data, -1, /* New input minimum */ 1, /* New input maximum */ -1, /* New output minimum */ 1); /* New output maximum */ fann_scale_train( ann, data ); printf("Scaled\n"); //сохраним нормализованную обучающу выборку в файл fann_save_train(data, normfilename); printf("Saved scaled file %s\n", normfilename); unsigned int i; printf("Start learning...\n"); for(i = 1; i <= max_epochs; i++) { error = num_threads > 1 ? fann_train_epoch_irpropm_parallel(ann, data, num_threads) : fann_train_epoch(ann, data); //если ошибка обучения меньше или равно заданной - выходим из цикла обучения //if (error <= desired_error) { printf ("Desired error detected. Finishing teaching.\n"); break; } //если текущий счетчик делится без остатка на epochs_between_reports - пишем лог //if (i % epochs_between_reports == 0) { printf("Epochs %8d. Current error: %.10f\n", i, error); } } printf("End learning.\n"); printf("MSE = %f\n", fann_get_MSE(ann)); //fann_train_on_data(ann, data, max_epochs, epochs_between_reports, desired_error); fann_destroy_train( data ); fann_save(ann, "scaling.net"); fann_destroy(ann); //проверка printf("Testing...\n"); fann_type *calc_out; //printf("fann_length_train_data=%d\n",fann_length_train_data(data)); printf("Creating network.\n"); ann = fann_create_from_file("scaling.net"); if(!ann) { printf("Error creating ann --- ABORTING.\n"); return 0; } //печатаем параметры сети //fann_print_connections(ann); //fann_print_parameters(ann); printf("Testing network.\n"); data = fann_read_train_from_file(filename); for(i = 0; i < fann_length_train_data(data); i++) { fann_reset_MSE(ann); fann_scale_input( ann, data->input[i] ); calc_out = fann_run( ann, data->input[i] ); fann_descale_output( ann, calc_out ); printf("Result %f original %f error %f or %.2f%%\n", calc_out[0], data->output[i][0], (float) fann_abs(calc_out[0] - data->output[i][0]), (100*(float) fann_abs(calc_out[0] - data->output[i][0]))/(float)calc_out[0]); } fann_destroy_train( data ); fann_destroy(ann); return 0; }
int main(int argc, char *argv[]) { MPI_Comm comm = MPI_COMM_WORLD; /* Communicator. */ MPI_Datatype pparams_mpi; /* Contains all the parameters. */ MPI_Status time_sts; int nnodes = 5; /* Total number of nodes. */ int gsize[2] = {0}; /* Grid size. */ int periods[2] = {false, false}; int rank = 0; int coord[2]; /* We are interested in the diffusion process in two directions. */ const size_t dims = 2; int status; int offset[2]; size_t grains[2]; int coord_lneigh[2]; int coord_rneigh[2]; int coord_uneigh[2]; int coord_dneigh[2]; int rank_lneigh; int rank_rneigh; int rank_uneigh; int rank_dneigh; MPI_Status xdown_status; MPI_Status xup_status; MPI_Status yleft_status; MPI_Status yright_status; double time_start_comm = 0; double time_start_comp = 0; double time_start_init = 0; double time_end_init = 0; double time_end_comm = 0; double time_end_comp = 0; double time_start_total = 0; double time_end_total = 0; double time_recv_buf; size_t yend; size_t ystart; #ifndef NO_SSE grid_simd_type sse_ratio; grid_simd_type sse_ratio1; grid_simd_type curr_grid; grid_simd_type currr_grid; grid_simd_type currl_grid; grid_simd_type curru_grid; grid_simd_type currd_grid; grid_simd_type ngrid_sse; #endif /* NO_SSE */ grid_type **grid = NULL; grid_type **ngrid = NULL; grid_type *xdown = NULL; grid_type *xup = NULL; grid_type ratio; grid_type ratio1; /* Arguments. */ pparams params; FILE *profilefile = NULL; FILE *statusfile = NULL; size_t i; size_t x, y; #ifndef NO_SSE size_t y_qdl; size_t y_qdl_r; #endif /* NO_SSE */ long time = 0; MPI_Init(&argc, &argv); time_start_init = MPI_Wtime(); time_start_total = MPI_Wtime(); MPI_Comm_rank(comm, &rank); /* Parse the parameters. The function only parses parameters if this * processor has rank zero. */ if ((status = getparams(argc, argv, ¶ms, &profilefile, &statusfile, &pparams_mpi, rank)) != EX_OK) MPI_Abort(comm, status); /* Send all the parameters to the remaining nodes in the comm. */ MPI_Bcast(¶ms, 1, pparams_mpi, 0, MPI_COMM_WORLD); /* Determine the number of nodes in the communicator. */ MPI_Comm_size(comm, &nnodes); /* Check whether the number of nodes can be used to form a two dimensional * grid equal height and length. */ if (rank == 0 && nnodes / params.l != params.h) { usage(); } /* The grid should be the same on each node. */ if (rank == 0 && params.ntotal % (params.l * params.h) != 0) { usage(); } /* Compute the grid form. */ gsize[X_COORD] = params.l; gsize[Y_COORD] = params.h; /* Create a get information of a Cartesian grid topology. */ if (MPI_Cart_create(comm, dims, gsize, periods, true, &comm) != MPI_SUCCESS) MPI_Abort(comm, EX_UNAVAILABLE); /* Translate the current rank to the coordinate in the Cartesian * topology. */ MPI_Cart_coords(comm, rank, dims, coord); /* Using the coordinate of the current node we can determine the amount of * points this node has to compute and the offset of the points. */ for (i = 0; i < dims; i++) { grains[i] = params.ntotal / gsize[i] + (params.ntotal % gsize[i] + gsize[i] - coord[i] - 1) / gsize[i]; if (grains[i] > (size_t)params.ntotal / gsize[i]) offset[i] = (params.ntotal / gsize[i] + 1) * coord[i]; else offset[i] = params.ntotal / gsize[i] * coord[i] + params.ntotal % gsize[i]; } /* With the current dimensions arrays which represent the grid can be * allocated. Two more entries are used to store neighbouring points. * * Grids are composed as follows: * * | | | | | | | | * | | | | | | | | * | | | | | | | | * | | | | | | | | * | | | | | | | | * 0 1 2 .. .. .. grains[x] grains[x] + 1 * | | | | | | | | * | | | | | | | | * | | | | | | | | * | | | | | | | | * | | | | | | | | * */ if ((grid = calloc(grains[X_COORD] + 2, sizeof(grid_type *))) == NULL || (ngrid = calloc(grains[X_COORD] + 2, sizeof(grid_type *))) == NULL) MPI_Abort(comm, EX_OSERR); for (i = 0; i < grains[X_COORD] + 2; i++) if ((grid[i] = calloc(grains[Y_COORD] + 2, sizeof(grid_type))) == NULL || (ngrid[i] = calloc(grains[Y_COORD] + 2, sizeof(grid_type))) == NULL) MPI_Abort(comm, EX_OSERR); /* Create temporary storage to prevent iterating through the entire grid. */ if ((xdown = calloc(grains[X_COORD], sizeof(grid_type))) == NULL || (xup = calloc(grains[X_COORD], sizeof(grid_type))) == NULL) MPI_Abort(comm, EX_OSERR); if ((params.dt * params.D * 4 / (params.dx * params.dx)) > 1) ratio = 1; else ratio = params.dt * params.D / (params.dx * params.dx); ratio = 1.0 / 4.0; ratio1 = 1.0 - 4.0 * ratio; #ifndef NO_SSE # ifdef DOUBLE sse_ratio = _mm_set1_pd(ratio); /* This variable is used to reduce the number of computations when computing * the finite difference scheme. */ sse_ratio1 = _mm_set1_pd(1.0 - 4.0 * ratio); # else sse_ratio = _mm_set_ps1(ratio); sse_ratio1 = _mm_set_ps1(1.0 - 4.0 * ratio); # endif /* DOUBLE */ #endif /* NO_SSE */ /* All the coordinates are translated to ranks by first computing the * coordinate of the appropriate neighbours. Then the coordinates are * used to determine the rank. These ranks can be used for the * communication. */ coord_lneigh[X_COORD] = (coord[X_COORD] + gsize[X_COORD] - 1) % gsize[X_COORD]; coord_rneigh[X_COORD] = (coord[X_COORD] + 1) % gsize[X_COORD]; coord_lneigh[Y_COORD] = coord[Y_COORD]; coord_rneigh[Y_COORD] = coord[Y_COORD]; coord_dneigh[Y_COORD] = (coord[Y_COORD] + gsize[Y_COORD] - 1) % gsize[Y_COORD]; coord_uneigh[Y_COORD] = (coord[Y_COORD] + 1) % gsize[Y_COORD]; coord_dneigh[X_COORD] = coord[X_COORD]; coord_uneigh[X_COORD] = coord[X_COORD]; MPI_Cart_rank(comm, coord_lneigh, &rank_lneigh); MPI_Cart_rank(comm, coord_rneigh, &rank_rneigh); MPI_Cart_rank(comm, coord_dneigh, &rank_dneigh); MPI_Cart_rank(comm, coord_uneigh, &rank_uneigh); /* Compute by how much the loop iterators have to be adjusted. */ yend = 1; ystart = 1; if (coord[Y_COORD] == (gsize[Y_COORD] - 1)) { yend--; for (x = 1; x < grains[X_COORD] + 1; ++x) grid[x][grains[Y_COORD]] = 1; } if (grains[Y_COORD] - yend - ystart < 1) MPI_Abort(MPI_COMM_WORLD, EX_USAGE); if (coord[Y_COORD] == 0) ystart++; #ifndef NO_SSE /* Compute the loop start and end for the SSE instructions. */ y_qdl = (grains[Y_COORD] - ystart + yend) / SIMD_CAPACITY; y_qdl_r = (grains[Y_COORD] - ystart + yend) % SIMD_CAPACITY; #endif /* NO_SSE */ time_end_init = MPI_Wtime() - time_start_init; for (time = 0; time < params.ttotal; time++) { /* Create two new arrays to prevent bad memory access. */ for (i = 0; i < grains[X_COORD]; i++) { xup[i] = grid[i + 1][grains[Y_COORD]]; xdown[i] = grid[i + 1][1]; } time_start_comm = MPI_Wtime(); MPI_Send((void *)xdown, grains[X_COORD], MPI_GRID_TYPE, rank_dneigh, X_DOWN_TAG, comm); MPI_Send((void *)xup, grains[X_COORD], MPI_GRID_TYPE, rank_uneigh, X_UP_TAG, comm); MPI_Recv((void *)xdown, grains[X_COORD], MPI_GRID_TYPE, rank_dneigh, X_UP_TAG, comm, &xdown_status); MPI_Recv((void *)xup, grains[X_COORD], MPI_GRID_TYPE, rank_uneigh, X_DOWN_TAG, comm, &xup_status); time_end_comm += MPI_Wtime() - time_start_comm; /* The freshly received xup and xdown have to be put in the grid. */ for (i = 0; i < grains[X_COORD]; i++) { grid[i + 1][grains[Y_COORD] + 1] = xup[i]; grid[i + 1][0] = xdown[i]; } time_start_comm = MPI_Wtime(); MPI_Send((void *)(grid[grains[X_COORD]] + 1), grains[Y_COORD], MPI_GRID_TYPE, rank_rneigh, Y_RIGHT_TAG, comm); MPI_Send((void *)(grid[1] + 1), grains[Y_COORD], MPI_GRID_TYPE, rank_lneigh, Y_LEFT_TAG, comm); MPI_Recv((void *)(grid[0] + 1), grains[Y_COORD], MPI_GRID_TYPE, rank_lneigh, Y_RIGHT_TAG, comm, &yright_status); MPI_Recv((void *)(grid[grains[X_COORD] + 1] + 1), grains[Y_COORD], MPI_GRID_TYPE, rank_rneigh, Y_LEFT_TAG, comm, &yleft_status); time_end_comm += MPI_Wtime() - time_start_comm; /* Do a non blocking send of the current grid for printing. */ if ((time % params.freq) == 0) send_grid(grid, grains, offset, rank, comm, &time_end_comm, PRINT_COMM); time_start_comp = MPI_Wtime(); /* Process the grid per column. */ for (x = 1; x < grains[X_COORD] + 1; x++) { #ifdef NO_SSE for (y = ystart; y < grains[Y_COORD] + yend; y++) { /* Do the finite difference computation. */ ngrid[x][y] = ratio * (grid[x][y + 1] + grid[x][y - 1] + grid[x + 1][y] + grid[x - 1][y]) + ratio1 * grid[x][y]; } #else for (i = 0, y = ystart; i < y_qdl; ++i, y += SIMD_CAPACITY) { # ifdef DOUBLE /* Load all the necessary values to SSE2 variables. */ /* r1 = (x, y + 1) * r0 = (x, y) */ curr_grid = _mm_loadu_pd(grid[x] + y); /* rr0 = (x + 1, y + 1) * rr0 = (x + 1, y) */ currr_grid = _mm_loadu_pd(grid[x + 1] + y); /* rl0 = (x - 1, y + 1) * rl0 = (x - 1, y) */ currl_grid = _mm_loadu_pd(grid[x - 1] + y); /* ru0 = (x, y + 2) * ru0 = (x, y + 1) */ curru_grid = _mm_loadu_pd(grid[x] + y + 1); /* rd0 = (x, y) * rd0 = (x, y - 1) */ currd_grid = _mm_loadu_pd(grid[x] + y - 1); /* Perform arithmetic in an order which should reduce the number of * bubbles in the processor pipeline. */ /* rr = rr + rl */ currr_grid = _mm_add_pd(currr_grid, currl_grid); /* ru = ru + rd */ curru_grid = _mm_add_pd(curru_grid, currd_grid); /* nr = (1 - 4 * ratio) * rr */ ngrid_sse = _mm_mul_pd(curr_grid, sse_ratio1); /* rr = rr + ru */ currr_grid = _mm_add_pd(currr_grid, curru_grid); /* rr += ratio */ currr_grid = _mm_mul_pd(currr_grid, sse_ratio); /* nr += rr */ ngrid_sse = _mm_add_pd(currr_grid, ngrid_sse); /* (x, y + 1) = nr1 * (x, y) = nr0 */ _mm_storeu_pd(ngrid[x] + y, ngrid_sse); # else /* Load all the necessary values to SSE variables. */ /* r3 = (x, y + 3) * r2 = (x, y + 2) * r1 = (x, y + 1) * r0 = (x, y) */ curr_grid = _mm_loadu_ps(grid[x] + y); currr_grid = _mm_loadu_ps(grid[x + 1] + y); currl_grid = _mm_loadu_ps(grid[x - 1] + y); curru_grid = _mm_loadu_ps(grid[x] + y + 1); currd_grid = _mm_loadu_ps(grid[x] + y - 1); /* Perform arithmetic in an order which should reduce the number of * bubbles in the processor pipeline. */ currr_grid = _mm_add_ps(currr_grid, currl_grid); curru_grid = _mm_add_ps(curru_grid, currd_grid); ngrid_sse = _mm_mul_ps(curr_grid, sse_ratio1); currr_grid = _mm_add_ps(currr_grid, curru_grid); currr_grid = _mm_mul_ps(currr_grid, sse_ratio); ngrid_sse = _mm_add_ps(currr_grid, ngrid_sse); _mm_storeu_ps(ngrid[x] + y, ngrid_sse); # endif /* DOUBLE */ } /* Compute the remaining points. */ for (i = 0; i < y_qdl_r; ++i) { ngrid[x][y] = ratio * (grid[x][y + 1] + grid[x][y - 1] + grid[x + 1][y] + grid[x - 1][y]) + ratio1 * grid[x][y]; y++; } #endif /* NO_SSE */ } time_end_comp += MPI_Wtime() - time_start_comp; if (time % params.freq == 0) recv_grid(grid, grains, offset, time, rank, nnodes, comm, &time_end_comm, PRINT_COMM, &print_elem, (void *)profilefile); /* Copy the new grid to the current grid. Use the previously computed * y-offsets to determine where copying should start. */ for (x = 1; x < grains[X_COORD] + 1; ++x) memcpy((void *)(grid[x] + ystart), (void *)(ngrid[x] + ystart), (grains[Y_COORD] - (ystart - yend)) * sizeof(grid_type)); /* Ensure that all the processes are at the same point. */ MPI_Barrier(comm); } /* Free the memory used for the grid. */ for (i = 0; i < grains[X_COORD] + 2; i++) { free(grid[i]); free(ngrid[i]); } free(grid); free(ngrid); free(xup); free(xdown); if (rank != 0) { MPI_Send(&time_end_comm, 1, MPI_DOUBLE, 0, TIME_COMM_TAG, MPI_COMM_WORLD); MPI_Send(&time_end_comp, 1, MPI_DOUBLE, 0, TIME_COMP_TAG, MPI_COMM_WORLD); MPI_Send(&time_end_init, 1, MPI_DOUBLE, 0, TIME_INIT_TAG, MPI_COMM_WORLD); } /* Get all the information on the running time. */ if (rank == 0) { for (i = 1; i < (size_t)nnodes; ++i) { MPI_Recv(&time_recv_buf, 1, MPI_DOUBLE, i, TIME_COMM_TAG, MPI_COMM_WORLD, &time_sts); time_end_comm += time_recv_buf; MPI_Recv(&time_recv_buf, 1, MPI_DOUBLE, i, TIME_COMP_TAG, MPI_COMM_WORLD, &time_sts); time_end_comp += time_recv_buf; MPI_Recv(&time_recv_buf, 1, MPI_DOUBLE, i, TIME_INIT_TAG, MPI_COMM_WORLD, &time_sts); time_end_init += time_recv_buf; } if (statusfile != NULL) { time_end_total = MPI_Wtime() - time_start_total; fprintf(statusfile, "%s %i %i %i %li %lf %lf %lf %lf %li\n", argv[0], nnodes, gsize[X_COORD], gsize[Y_COORD], sizeof(grid_type), time_end_total, time_end_comp, time_end_init, time_end_comm, time); fclose(statusfile); } fclose(profilefile); } MPI_Finalize(); return EX_OK; }
/* show counters for this session */ static int session_counters(char *text, int len) { text = getparams(text); print_session_counters(text); return 1; }
void CTextView::OnEditAsciiart() { CAsciiArtDlg dlg; dlg.m_strText = App.m_strAsciiArtText; dlg.m_iLayout = App.m_iAsciiArtLayout; dlg.m_strFont = App.m_strAsciiArtFont; if (dlg.DoModal () != IDOK) return; // remember text but don't save in registry App.m_strAsciiArtText = dlg.m_strText; // remember layout in registry if (dlg.m_iLayout != (int) App.m_iAsciiArtLayout) App.db_write_int ("prefs", "AsciiArtLayout", dlg.m_iLayout); App.m_iAsciiArtLayout = dlg.m_iLayout; // remember font in registry if (dlg.m_strFont != App.m_strAsciiArtFont) App.db_write_string ("prefs", "AsciiArtFont", dlg.m_strFont); App.m_strAsciiArtFont = dlg.m_strFont; CString str = dlg.m_strText; switch (dlg.m_iLayout) { case 1: // full smush smushmode = SM_SMUSH; smushoverride = SMO_FORCE; break; case 2: // kern smushmode = SM_KERN; smushoverride = SMO_YES; break; case 3: // full width smushmode = 0; smushoverride = SMO_YES; break; case 4: // overlap smushmode = SM_SMUSH; smushoverride = SMO_YES; break; default: // default is normal smush smushoverride = SMO_NO; break; } // end of switch inchr c; int i; try { getparams (); readfont (dlg.m_strFont); linealloc(); for (i = 0; i < str.GetLength (); i++) { c = str [i]; if (isascii(c)&&isspace(c)) { c = (c=='\t'||c==' ') ? ' ' : '\n'; } if ((c>'\0' && c<' ' && c!='\n') || c==127) continue; addchar (c); } // end of processing each character for (i=0;i<charheight;i++) { CString strLine = Replace (outputline[i], hardblank, " "); GetEditCtrl ().ReplaceSel (CFormat ("%s%s", (LPCTSTR) strLine, ENDLINE), true); } linefree (); fontfree (); } catch (CException* e) { e->ReportError(); e->Delete(); linefree (); // free memory used fontfree (); } }