| // ************************************************************************ |
| // |
| // miniAMR: stencil computations with boundary exchange and AMR. |
| // |
| // Copyright (2014) Sandia Corporation. Under the terms of Contract |
| // DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government |
| // retains certain rights in this software. |
| // |
| // This library is free software; you can redistribute it and/or modify |
| // it under the terms of the GNU Lesser General Public License as |
| // published by the Free Software Foundation; either version 2.1 of the |
| // License, or (at your option) any later version. |
| // |
| // This library is distributed in the hope that it will be useful, but |
| // WITHOUT ANY WARRANTY; without even the implied warranty of |
| // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| // Lesser General Public License for more details. |
| // |
| // You should have received a copy of the GNU Lesser General Public |
| // License along with this library; if not, write to the Free Software |
| // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| // Questions? Contact Courtenay T. Vaughan (ctvaugh@sandia.gov) |
| // Richard F. Barrett (rfbarre@sandia.gov) |
| // |
| // ************************************************************************ |
| |
| #include <stdlib.h> |
| #include <stdio.h> |
| #include <string.h> |
| |
| #include "block.h" |
| #include "timer.h" |
| #include "proto.h" |
| |
| int main(int argc, char** argv) |
| { |
| int i, ierr, object_num; |
| int params[35]; |
| double *objs; |
| #include "param.h" |
| |
| my_pe = 0; |
| num_pes = 1; |
| |
| counter_malloc = 0; |
| size_malloc = 0.0; |
| |
| /* set initial values */ |
| for (i = 1; i < argc; i++) |
| if (!strcmp(argv[i], "--max_blocks")) |
| max_num_blocks = atoi(argv[++i]); |
| else if (!strcmp(argv[i], "--target_active")) |
| target_active = atoi(argv[++i]); |
| else if (!strcmp(argv[i], "--target_max")) |
| target_max = atoi(argv[++i]); |
| else if (!strcmp(argv[i], "--target_min")) |
| target_min = atoi(argv[++i]); |
| else if (!strcmp(argv[i], "--num_refine")) |
| num_refine = atoi(argv[++i]); |
| else if (!strcmp(argv[i], "--block_change")) |
| block_change = atoi(argv[++i]); |
| else if (!strcmp(argv[i], "--uniform_refine")) |
| uniform_refine = atoi(argv[++i]); |
| else if (!strcmp(argv[i], "--nx")) |
| x_block_size = atoi(argv[++i]); |
| else if (!strcmp(argv[i], "--ny")) |
| y_block_size = atoi(argv[++i]); |
| else if (!strcmp(argv[i], "--nz")) |
| z_block_size = atoi(argv[++i]); |
| else if (!strcmp(argv[i], "--num_vars")) |
| num_vars = atoi(argv[++i]); |
| else if (!strcmp(argv[i], "--comm_vars")) |
| comm_vars = atoi(argv[++i]); |
| else if (!strcmp(argv[i], "--init_x")) |
| init_block_x = atoi(argv[++i]); |
| else if (!strcmp(argv[i], "--init_y")) |
| init_block_y = atoi(argv[++i]); |
| else if (!strcmp(argv[i], "--init_z")) |
| init_block_z = atoi(argv[++i]); |
| else if (!strcmp(argv[i], "--refine_freq")) |
| refine_freq = atoi(argv[++i]); |
| else if (!strcmp(argv[i], "--report_diffusion")) |
| report_diffusion = atoi(argv[++i]); |
| else if (!strcmp(argv[i], "--error_tol")) |
| error_tol = atoi(argv[++i]); |
| else if (!strcmp(argv[i], "--num_tsteps")) |
| num_tsteps = atoi(argv[++i]); |
| else if (!strcmp(argv[i], "--stages_per_ts")) |
| stages_per_ts = atoi(argv[++i]); |
| else if (!strcmp(argv[i], "--checksum_freq")) |
| checksum_freq = atoi(argv[++i]); |
| else if (!strcmp(argv[i], "--stencil")) |
| stencil = atoi(argv[++i]); |
| else if (!strcmp(argv[i], "--permute")) |
| permute = 1; |
| else if (!strcmp(argv[i], "--report_perf")) |
| report_perf = atoi(argv[++i]); |
| else if (!strcmp(argv[i], "--plot_freq")) |
| plot_freq = atoi(argv[++i]); |
| else if (!strcmp(argv[i], "--code")) |
| code = atoi(argv[++i]); |
| else if (!strcmp(argv[i], "--refine_ghost")) |
| refine_ghost = 1; |
| else if (!strcmp(argv[i], "--num_objects")) { |
| num_objects = atoi(argv[++i]); |
| objects = (object *) ma_malloc(num_objects*sizeof(object), |
| __FILE__, __LINE__); |
| object_num = 0; |
| } else if (!strcmp(argv[i], "--object")) { |
| if (object_num >= num_objects) { |
| printf("object number greater than num_objects\n"); |
| exit(-1); |
| } |
| objects[object_num].type = atoi(argv[++i]); |
| objects[object_num].bounce = atoi(argv[++i]); |
| objects[object_num].cen[0] = atof(argv[++i]); |
| objects[object_num].cen[1] = atof(argv[++i]); |
| objects[object_num].cen[2] = atof(argv[++i]); |
| objects[object_num].move[0] = atof(argv[++i]); |
| objects[object_num].move[1] = atof(argv[++i]); |
| objects[object_num].move[2] = atof(argv[++i]); |
| objects[object_num].size[0] = atof(argv[++i]); |
| objects[object_num].size[1] = atof(argv[++i]); |
| objects[object_num].size[2] = atof(argv[++i]); |
| objects[object_num].inc[0] = atof(argv[++i]); |
| objects[object_num].inc[1] = atof(argv[++i]); |
| objects[object_num].inc[2] = atof(argv[++i]); |
| object_num++; |
| } else if (!strcmp(argv[i], "--help")) { |
| print_help_message(); |
| exit(0); |
| } else { |
| printf("** Error ** Unknown input parameter %s\n", argv[i]); |
| print_help_message(); |
| exit(-1); |
| } |
| if (check_input()) |
| exit(-1); |
| |
| if (!block_change) |
| block_change = num_refine; |
| |
| for (object_num = 0; object_num < num_objects; object_num++) |
| for (i = 0; i < 3; i++) { |
| objects[object_num].orig_cen[i] = objects[object_num].cen[i]; |
| objects[object_num].orig_move[i] = objects[object_num].move[i]; |
| objects[object_num].orig_size[i] = objects[object_num].size[i]; |
| } |
| |
| allocate(); |
| |
| driver(); |
| |
| profile(); |
| |
| deallocate(); |
| |
| exit(0); |
| } |
| |
| // =================================== print_help_message ==================== |
| |
| void print_help_message(void) |
| { |
| printf("(Optional) command line input is of the form: \n\n"); |
| |
| printf("--nx - block size x (even && > 0)\n"); |
| printf("--ny - block size y (even && > 0)\n"); |
| printf("--nz - block size z (even && > 0)\n"); |
| printf("--init_x - initial blocks in x (> 0)\n"); |
| printf("--init_y - initial blocks in y (> 0)\n"); |
| printf("--init_z - initial blocks in z (> 0)\n"); |
| printf("--reorder - ordering of blocks if initial number > 1\n"); |
| printf("--max_blocks - maximun number of blocks per core\n"); |
| printf("--num_refine - (>= 0) number of levels of refinement\n"); |
| printf("--block_change - (>= 0) number of levels a block can change in a timestep\n"); |
| printf("--uniform_refine - if 1, then grid is uniformly refined\n"); |
| printf("--refine_freq - frequency (in timesteps) of checking for refinement\n"); |
| printf("--target_active - (>= 0) target number of blocks per core, none if 0\n"); |
| printf("--target_max - (>= 0) max number of blocks per core, none if 0\n"); |
| printf("--target_min - (>= 0) min number of blocks per core, none if 0\n"); |
| printf("--num_vars - number of variables (> 0)\n"); |
| printf("--comm_vars - number of vars to communicate together\n"); |
| printf("--num_tsteps - number of timesteps (> 0)\n"); |
| printf("--stages_per_ts - number of comm/calc stages per timestep\n"); |
| printf("--checksum_freq - number of stages between checksums\n"); |
| printf("--stencil - 7 or 27 point (27 will not work with refinement (except uniform))\n"); |
| printf("--error_tol - (e^{-error_tol} ; >= 0) \n"); |
| printf("--report_diffusion - (>= 0) none if 0\n"); |
| printf("--report_perf - 0, 1, 2\n"); |
| printf("--refine_freq - frequency (timesteps) of plotting (0 for none)\n"); |
| printf("--code - closely minic communication of different codes\n"); |
| printf(" 0 minimal sends, 1 send ghosts, 2 send ghosts and process on send\n"); |
| printf("--permute - altenates directions in communication\n"); |
| printf("--refine_ghost - use full extent of block (including ghosts) to determine if block is refined\n"); |
| printf("--num_objects - (>= 0) number of objects to cause refinement\n"); |
| printf("--object - type, position, movement, size, size rate of change\n"); |
| |
| printf("All associated settings are integers except for objects\n"); |
| } |
| |
| // =================================== allocate ============================== |
| |
| void allocate(void) |
| { |
| int i, j, k, m, n; |
| |
| num_blocks = (int *) ma_malloc((num_refine+1)*sizeof(int), |
| __FILE__, __LINE__); |
| num_blocks[0] = num_pes*init_block_x*init_block_y*init_block_z; |
| num_blocks[0] = init_block_x*init_block_y*init_block_z; |
| |
| blocks = (block *) ma_malloc(max_num_blocks*sizeof(block), |
| __FILE__, __LINE__); |
| |
| for (n = 0; n < max_num_blocks; n++) { |
| blocks[n].number = -1; |
| blocks[n].array = (double ****) ma_malloc(num_vars*sizeof(double ***), |
| __FILE__, __LINE__); |
| for (m = 0; m < num_vars; m++) { |
| blocks[n].array[m] = (double ***) |
| ma_malloc((x_block_size+2)*sizeof(double **), |
| __FILE__, __LINE__); |
| for (i = 0; i < x_block_size+2; i++) { |
| blocks[n].array[m][i] = (double **) |
| ma_malloc((y_block_size+2)*sizeof(double *), |
| __FILE__, __LINE__); |
| for (j = 0; j < y_block_size+2; j++) |
| blocks[n].array[m][i][j] = (double *) |
| ma_malloc((z_block_size+2)*sizeof(double), |
| __FILE__, __LINE__); |
| } |
| } |
| } |
| |
| sorted_list = (sorted_block *)ma_malloc(max_num_blocks*sizeof(sorted_block), |
| __FILE__, __LINE__); |
| sorted_index = (int *) ma_malloc((num_refine+2)*sizeof(int), |
| __FILE__, __LINE__); |
| |
| max_num_parents = max_num_blocks; // Guess at number needed |
| parents = (parent *) ma_malloc(max_num_parents*sizeof(parent), |
| __FILE__, __LINE__); |
| for (n = 0; n < max_num_parents; n++) |
| parents[n].number = -1; |
| |
| grid_sum = (double *)ma_malloc(num_vars*sizeof(double), __FILE__, __LINE__); |
| |
| p8 = (int *) ma_malloc((num_refine+2)*sizeof(int), __FILE__, __LINE__); |
| p2 = (int *) ma_malloc((num_refine+2)*sizeof(int), __FILE__, __LINE__); |
| block_start = (int *) ma_malloc((num_refine+1)*sizeof(int), |
| __FILE__, __LINE__); |
| } |
| |
| // =================================== deallocate ============================ |
| |
| void deallocate(void) |
| { |
| int i, j, m, n; |
| |
| for (n = 0; n < max_num_blocks; n++) { |
| for (m = 0; m < num_vars; m++) { |
| for (i = 0; i < x_block_size+2; i++) { |
| for (j = 0; j < y_block_size+2; j++) |
| free(blocks[n].array[m][i][j]); |
| free(blocks[n].array[m][i]); |
| } |
| free(blocks[n].array[m]); |
| } |
| free(blocks[n].array); |
| } |
| free(blocks); |
| |
| free(sorted_list); |
| free(sorted_index); |
| |
| free(objects); |
| |
| free(grid_sum); |
| |
| free(p8); |
| free(p2); |
| } |
| |
| int check_input(void) |
| { |
| int error = 0; |
| |
| if (init_block_x < 1 || init_block_y < 1 || init_block_z < 1) { |
| printf("initial blocks on processor must be positive\n"); |
| error = 1; |
| } |
| if (max_num_blocks < init_block_x*init_block_y*init_block_z) { |
| printf("max_num_blocks not large enough\n"); |
| error = 1; |
| } |
| if (x_block_size < 1 || y_block_size < 1 || z_block_size < 1) { |
| printf("block size must be positive\n"); |
| error = 1; |
| } |
| if (((x_block_size/2)*2) != x_block_size) { |
| printf("block size in x direction must be even\n"); |
| error = 1; |
| } |
| if (((y_block_size/2)*2) != y_block_size) { |
| printf("block size in y direction must be even\n"); |
| error = 1; |
| } |
| if (((z_block_size/2)*2) != z_block_size) { |
| printf("block size in z direction must be even\n"); |
| error = 1; |
| } |
| if (target_active && target_max) { |
| printf("Only one of target_active and target_max can be used\n"); |
| error = 1; |
| } |
| if (target_active && target_min) { |
| printf("Only one of target_active and target_min can be used\n"); |
| error = 1; |
| } |
| if (target_active < 0 || target_active > max_num_blocks) { |
| printf("illegal value for target_active\n"); |
| error = 1; |
| } |
| if (target_max < 0 || target_max > max_num_blocks || |
| target_max < target_active) { |
| printf("illegal value for target_max\n"); |
| error = 1; |
| } |
| if (target_min < 0 || target_min > max_num_blocks || |
| target_min > target_active || target_min > target_max) { |
| printf("illegal value for target_min\n"); |
| error = 1; |
| } |
| if (num_refine < 0) { |
| printf("number of refinement levels must be non-negative\n"); |
| error = 1; |
| } |
| if (block_change < 0) { |
| printf("number of refinement levels must be non-negative\n"); |
| error = 1; |
| } |
| if (num_vars < 1) { |
| printf("number of variables must be positive\n"); |
| error = 1; |
| } |
| if (num_pes != npx*npy*npz) { |
| printf("number of processors used does not match number allocated\n"); |
| error = 1; |
| } |
| if (stencil != 7 && stencil != 27) { |
| printf("illegal value for stencil\n"); |
| error = 1; |
| } |
| if (stencil == 27 && num_refine && !uniform_refine) |
| printf("WARNING: 27 point stencil with non-uniform refinement: answers may diverge\n"); |
| if (comm_vars == 0 || comm_vars > num_vars) |
| comm_vars = num_vars; |
| if (code < 0 || code > 2) { |
| printf("code must be 0, 1, or 2\n"); |
| error = 1; |
| } |
| |
| return (error); |
| } |
