| /* |
| * Copyright (c) 2011-2012, Los Alamos National Security, LLC. |
| * All rights Reserved. |
| * |
| * Copyright 2011-2012. Los Alamos National Security, LLC. This software was produced |
| * under U.S. Government contract DE-AC52-06NA25396 for Los Alamos National |
| * Laboratory (LANL), which is operated by Los Alamos National Security, LLC |
| * for the U.S. Department of Energy. The U.S. Government has rights to use, |
| * reproduce, and distribute this software. NEITHER THE GOVERNMENT NOR LOS |
| * ALAMOS NATIONAL SECURITY, LLC MAKES ANY WARRANTY, EXPRESS OR IMPLIED, OR |
| * ASSUMES ANY LIABILITY FOR THE USE OF THIS SOFTWARE. If software is modified |
| * to produce derivative works, such modified software should be clearly marked, |
| * so as not to confuse it with the version available from LANL. |
| * |
| * Additionally, redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are met: |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * * Neither the name of the Los Alamos National Security, LLC, Los Alamos |
| * National Laboratory, LANL, the U.S. Government, nor the names of its |
| * contributors may be used to endorse or promote products derived from |
| * this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE LOS ALAMOS NATIONAL SECURITY, LLC AND |
| * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT |
| * NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL LOS ALAMOS NATIONAL |
| * SECURITY, LLC OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
| * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; |
| * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, |
| * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
| * POSSIBILITY OF SUCH DAMAGE. |
| * |
| * CLAMR -- LA-CC-11-094 |
| * This research code is being developed as part of the |
| * 2011 X Division Summer Workshop for the express purpose |
| * of a collaborative code for development of ideas in |
| * the implementation of AMR codes for Exascale platforms |
| * |
| * AMR implementation of the Wave code previously developed |
| * as a demonstration code for regular grids on Exascale platforms |
| * as part of the Supercomputing Challenge and Los Alamos |
| * National Laboratory |
| * |
| * Authors: Bob Robey XCP-2 brobey@lanl.gov |
| * Neal Davis davis68@lanl.gov, davis68@illinois.edu |
| * David Nicholaeff dnic@lanl.gov, mtrxknight@aol.com |
| * Dennis Trujillo dptrujillo@lanl.gov, dptru10@gmail.com |
| * |
| * |
| * This file and the associated header is based on a file from the capablanca |
| * project available under the MIT open-source license. As author of that code, |
| * I, Neal Davis, permit repurposing and redistribution for CLAMR under the New |
| * BSD License used above. |
| * http://code.google.com/p/capablanca/ |
| */ |
| |
| #ifdef HAVE_CONFIG_H |
| #include "config.h" |
| #endif |
| |
| #include "state.h" |
| #include "partition.h" |
| #include "mesh.h" |
| #include "hash.h" |
| #include "crux.h" |
| //#include "graphics/display.h" |
| #include "graphics.h" |
| |
| #include <fstream> |
| #include <iostream> |
| #include <cmath> |
| #include <cstdio> |
| #include <cstdlib> |
| #include <cstring> |
| #include <sys/stat.h> |
| #include <limits.h> |
| |
| #define OUTPUT_INTERVAL 100 |
| #define COARSE_GRID_RES 128 |
| #define MAX_TIME_STEP 3000 |
| |
| using namespace std; |
| |
| // Global variables. |
| char progName[12]; // Program name. |
| char progVers[8]; // Program version. |
| |
| // External global variables. |
| extern bool verbose, |
| localStencil, |
| outline, |
| face_based, |
| dynamic_load_balance_on, |
| h5_spoutput, |
| neighbor_remap, |
| restart; |
| extern int outputInterval, |
| crux_type, |
| enhanced_precision_sum, |
| tmax, |
| levmx, |
| nx, |
| ny, |
| niter, |
| measure_type, |
| lttrace_on, |
| do_quo_setup, |
| calc_neighbor_type, |
| choose_hash_method, |
| initial_order, |
| graphic_outputInterval, |
| graphics_type, |
| checkpoint_outputInterval, |
| num_of_rollback_states, |
| cycle_reorder; |
| extern float |
| mem_opt_factor; |
| extern double |
| upper_mass_diff_percentage; |
| |
| extern char* restart_file; |
| |
| void outputHelp() |
| { cout << "CLAMR is an experimental adaptive mesh refinement code for the GPU." << endl |
| #ifdef PACKAGE_VERSION |
| << "Version is " << PACKAGE_VERSION << endl << endl |
| #endif |
| << "Usage: " << progName << " [options]..." << endl |
| << " -b <B> Number of rollback images, disk or in memory (default 2);" << endl |
| << " -c <C> Checkpoint to disk at interval specified;" << endl |
| << " -C <C> Checkpoint to memory at interval specified;" << endl |
| << " -d turn on LTTRACE;" << endl |
| << " -D turn on dynamic load balancing using LTTRACE;" << endl |
| << " -e <E> force hash_method, ie linear, quadratic..." <<endl |
| << " \"perfect\"" << endl |
| << " \"linear\"" << endl |
| << " \"quadratic\"" << endl |
| << " \"prime_jump\"" << endl |
| << " -f face-based finite difference;" << endl |
| << " -g <g> specify I step between saving graphics information for post processing;" << endl |
| << " -G <G> specify graphics file type for post processing;" << endl |
| << " \"bmp\"" << endl |
| << " \"gif\"" << endl |
| << " \"jpeg\"" << endl |
| << " \"mpeg\"" << endl |
| << " \"pdf\"" << endl |
| << " \"png\"" << endl |
| << " \"svg\"" << endl |
| << " \"data\"" << endl |
| << " -h display this help message;" << endl |
| << " -i <I> specify I steps between output files;" << endl |
| << " -l <l> max number of levels;" << endl |
| << " -M <M> memory optimization factor 1.0 <= M <=100.0 (default 1.0 -- represents 1/20 perfect hash);" << endl |
| << " -m <m> specify partition measure type;" << endl |
| << " \"with_duplicates\"" << endl |
| << " \"without_duplicates\"" << endl |
| << " -N <n> specify calc neighbor type;" << endl |
| << " \"hash_table\"" << endl |
| << " \"kdtree\"" << endl |
| << " -n <N> specify coarse grid resolution of NxN;" << endl |
| << " -o turn off outlines;" << endl |
| << " -P <P> specify initial order P;" << endl |
| << " \"original_order\"" << endl |
| << " \"hilbert_sort\"" << endl |
| << " \"hilbert_partition\"" << endl |
| << " \"z_order\"" << endl |
| << " -p <p> specify ordering P every cycle;" << endl |
| << " \"original_order\"" << endl |
| << " \"hilbert_sort\"" << endl |
| << " \"hilbert_partition\"" << endl |
| << " \"local_hilbert\"" << endl |
| << " \"local_fixed\"" << endl |
| << " \"z_order\"" << endl |
| << " -q turn on quo;" << endl |
| << " -r regular sum instead of enhanced precision sum (Kahan sum);" << endl |
| << " -R restart simulation from the backup file specified;" << endl |
| << " -s <s> specify space-filling curve method S;" << endl |
| << " -S write out double precision data as single precision;" << endl |
| << " -T execute with TVD;" << endl |
| << " -t <t> specify T time steps to run;" << endl |
| << " -u allowed percentage of difference between total mass between iterations." << endl |
| << " the default value for this parameter is 2.6e-13;" << endl |
| << " -V use verbose output;" << endl |
| << " -v display version information." << endl |
| << " -z force recalculation of neighbors." << endl; } |
| |
| void outputVersion() |
| { cout << progName << " " << progVers << endl; } |
| |
| /* parseInput(const int argc, char** argv) |
| * |
| * Interpret the command line input. |
| */ |
| void parseInput(const int argc, char** argv) |
| { strcpy(progName, "clamr"); |
| #ifdef PACKAGE_VERSION |
| strcpy(progVers, PACKAGE_VERSION); |
| #endif |
| // Reconstruct command line argument as a string. |
| char progCL[256]; // Complete program command line. |
| strcpy(progCL, argv[0]); |
| for (int i = 1; i < argc; i++) |
| { strcat(progCL, " "); |
| strcat(progCL, argv[i]); } |
| |
| // Set variables to defaults, which may be overridden by CLI. |
| verbose = false; |
| localStencil = true; |
| outline = true; |
| #ifdef HAVE_LTTRACE |
| lttrace_on = 0; |
| #endif |
| #ifdef HAVE_QUO |
| do_quo_setup = 0; |
| #endif |
| dynamic_load_balance_on = false; |
| crux_type = CRUX_NONE; |
| face_based = false; |
| restart = false; |
| restart_file = NULL; |
| outputInterval = OUTPUT_INTERVAL; |
| nx = COARSE_GRID_RES; |
| ny = COARSE_GRID_RES; |
| niter = MAX_TIME_STEP; |
| neighbor_remap = true; |
| //measure_type = CSTARVALUE; |
| measure_type = NO_PARTITION_MEASURE; |
| calc_neighbor_type = HASH_TABLE; |
| choose_hash_method = METHOD_UNSET; |
| initial_order = HILBERT_SORT; |
| cycle_reorder = ORIGINAL_ORDER; |
| graphic_outputInterval = INT_MAX; |
| graphics_type = GRAPHICS_NONE; |
| checkpoint_outputInterval = INT_MAX; |
| num_of_rollback_states = 2; |
| levmx = 1; |
| mem_opt_factor = 1.0; |
| upper_mass_diff_percentage = -1.0; |
| enhanced_precision_sum = SUM_KAHAN; |
| |
| char *val; |
| if (argc > 1) |
| { int i = 1; |
| val = strtok(argv[i++], " ,.-"); |
| while (val != NULL){ |
| switch (val[0]){ |
| case 'b': // Number of rollback images, disk or in memory (default 2) |
| sprintf(val,"0"); |
| if (i < argc) val = strtok(argv[i++], " ,"); |
| if(atoi(val) < 1){ |
| printf("backup number must be at least 1, setting to default value 2\n"); |
| } |
| else{ |
| num_of_rollback_states = atoi(val); |
| } |
| break; |
| case 'c': // Checkpoint to disk at interval specified |
| val = strtok(argv[i++], " ,.-"); |
| checkpoint_outputInterval = atoi(val); |
| crux_type = CRUX_DISK; |
| break; |
| |
| case 'C': // Checkpoint to memory at interval specified |
| val = strtok(argv[i++], " ,.-"); |
| checkpoint_outputInterval = atoi(val); |
| crux_type = CRUX_IN_MEMORY; |
| break; |
| |
| case 'd': // Turn on lttrace. |
| // This is provided as a separate option to measure |
| // the overhead of having lttrace on. |
| #ifdef HAVE_LTTRACE |
| lttrace_on = 1; |
| #endif |
| break; |
| |
| case 'D': // Turn on dynamic load balancing. |
| // This forces on lttrace. |
| #ifdef HAVE_LTTRACE |
| lttrace_on = true; |
| dynamic_load_balance_on = true; |
| #endif |
| break; |
| |
| case 'e': // hash method specified. |
| val = strtok(argv[i++], " ,"); |
| if (! strcmp(val,"perfect") ) { |
| choose_hash_method = PERFECT_HASH; |
| } else if (! strcmp(val,"linear") ) { |
| choose_hash_method = LINEAR; |
| } else if (! strcmp(val,"quadratic") ) { |
| choose_hash_method = QUADRATIC; |
| } else if (! strcmp(val,"prime_jump") ) { |
| choose_hash_method = PRIME_JUMP; |
| } |
| break; |
| |
| case 'f': // Use face-based finite difference |
| face_based = true; |
| break; |
| |
| case 'g': // Save graphics data to files during simulation. |
| val = strtok(argv[i++], " ,.-"); |
| graphic_outputInterval = atoi(val); |
| if (graphics_type == GRAPHICS_NONE) graphics_type = GRAPHICS_DATA; |
| break; |
| |
| case 'G': // Graphics data file type. |
| val = strtok(argv[i++], " ,.-"); |
| if (! strcmp(val,"none") ) { |
| graphics_type = GRAPHICS_NONE; |
| graphic_outputInterval = INT_MAX; |
| } else if (! strcmp(val,"data") ) { |
| graphics_type = GRAPHICS_DATA; |
| #ifdef HAVE_MAGICKWAND |
| } else if (! strcmp(val,"bmp") ) { |
| graphics_type = GRAPHICS_BMP; |
| } else if (! strcmp(val,"gif") ) { |
| graphics_type = GRAPHICS_GIF; |
| } else if (! strcmp(val,"jpeg") ) { |
| graphics_type = GRAPHICS_JPEG; |
| } else if (! strcmp(val,"mpeg") ) { |
| graphics_type = GRAPHICS_MPEG; |
| } else if (! strcmp(val,"pdf") ) { |
| graphics_type = GRAPHICS_PDF; |
| } else if (! strcmp(val,"png") ) { |
| graphics_type = GRAPHICS_PNG; |
| } else if (! strcmp(val,"svg") ) { |
| graphics_type = GRAPHICS_SVG; |
| #endif |
| } else { |
| printf("Unrecognized option for graphics file type %s\n",val); |
| exit(-1); |
| } |
| break; |
| |
| case 'h': // Output help. |
| outputHelp(); |
| cout.flush(); |
| exit(EXIT_SUCCESS); |
| break; |
| |
| case 'i': // Output interval specified. |
| val = strtok(argv[i++], " ,.-"); |
| outputInterval = atoi(val); |
| break; |
| |
| case 'l': // max level specified. |
| val = strtok(argv[i++], " ,"); |
| levmx = atoi(val); |
| break; |
| |
| case 'M': // memory optimization factor |
| val = strtok(argv[i++], " ,"); |
| mem_opt_factor = atof(val); |
| break; |
| |
| case 'm': // partition measure specified. |
| val = strtok(argv[i++], " ,"); |
| if (! strcmp(val,"no_partition_measure") ) { |
| measure_type = NO_PARTITION_MEASURE; |
| } else if (! strcmp(val,"with_duplicates") ) { |
| measure_type = WITH_DUPLICATES; |
| } else if (! strcmp(val,"without_duplicates") ) { |
| measure_type = WITHOUT_DUPLICATES; |
| } else if (! strcmp(val,"cvalue") ) { |
| measure_type = CVALUE; |
| } else if (! strcmp(val,"cstarvalue") ) { |
| measure_type = CSTARVALUE; |
| } |
| break; |
| |
| case 'N': // calc neighbor type specified. |
| val = strtok(argv[i++], " ,"); |
| if (! strcmp(val,"hash_table") ) { |
| calc_neighbor_type = HASH_TABLE; |
| } else if (! strcmp(val,"kdtree") ) { |
| calc_neighbor_type = KDTREE; |
| } |
| break; |
| |
| case 'n': // Domain grid resolution specified. |
| val = strtok(argv[i++], " ,"); |
| nx = atoi(val); |
| ny = nx; |
| break; |
| |
| case 'o': // Turn off outlines on mesh drawing. |
| outline = false; |
| break; |
| |
| case 'P': // Initial order specified. |
| val = strtok(argv[i++], " ,"); |
| if (! strcmp(val,"original_order") ) { |
| initial_order = ORIGINAL_ORDER; |
| } else if (! strcmp(val,"hilbert_sort") ) { |
| initial_order = HILBERT_SORT; |
| } else if (! strcmp(val,"hilbert_partition") ) { |
| initial_order = HILBERT_PARTITION; |
| } else if (! strcmp(val,"z_order") ) { |
| initial_order = ZORDER; |
| } |
| break; |
| |
| case 'p': // Initial order specified. |
| val = strtok(argv[i++], " ,"); |
| if (! strcmp(val,"original_order") ) { |
| cycle_reorder = ORIGINAL_ORDER; |
| localStencil = false; |
| } else if (! strcmp(val,"hilbert_sort") ) { |
| cycle_reorder = HILBERT_SORT; |
| localStencil = false; |
| } else if (! strcmp(val,"hilbert_partition") ) { |
| cycle_reorder = HILBERT_PARTITION; |
| localStencil = false; |
| } else if (! strcmp(val,"local_hilbert") ) { |
| cycle_reorder = ORIGINAL_ORDER; |
| localStencil = true; |
| } else if (! strcmp(val,"local_fixed") ) { |
| cycle_reorder = ORIGINAL_ORDER; |
| localStencil = false; |
| } else if (! strcmp(val,"z_order") ) { |
| cycle_reorder = ZORDER; |
| localStencil = false; |
| } |
| break; |
| |
| case 'q': // turn on quo package. |
| #ifdef HAVE_QUO |
| do_quo_setup = 1; |
| #endif |
| break; |
| |
| case 'r': // Regular sum instead of enhanced precision sum. |
| val = strtok(argv[i++], " ,"); |
| if (! strcmp(val,"regular_sum") ) { |
| enhanced_precision_sum = SUM_REGULAR; |
| } else if (! strcmp(val,"kahan_sum") ) { |
| enhanced_precision_sum = SUM_KAHAN; |
| } else { |
| printf("Error with sum argument %s\n",val); |
| exit(0); |
| } |
| break; |
| |
| case 'R': // Restart application from last checkpoint |
| restart = true; |
| restart_file = strtok(argv[i++], " ,"); |
| |
| #ifndef HDF5_FF |
| struct stat stat_descriptor; |
| if (stat(restart_file,&stat_descriptor) == -1){ |
| printf("Error -- restart file %s does not exist\n",restart_file); |
| exit(0); |
| } |
| #endif |
| break; |
| |
| case 's': // Space-filling curve method specified (default HILBERT_SORT). |
| // Add different problem setups such as sloped wave in x, y and diagonal directions to help check algorithm |
| // HILBERT_SORT |
| break; |
| |
| case 'T': // TVD inclusion specified. |
| break; |
| |
| case 't': // Number of time steps specified. |
| val = strtok(argv[i++], " ,.-"); |
| niter = atoi(val); |
| break; |
| |
| case 'u': // Allowed percentage of difference in mass per iteration |
| val = strtok(argv[i++], " ,"); |
| upper_mass_diff_percentage = atof(val); |
| break; |
| |
| case 'V': // Verbose output desired. |
| verbose = true; |
| break; |
| |
| case 'v': // Version. |
| outputVersion(); |
| cout.flush(); |
| exit(EXIT_SUCCESS); |
| break; |
| |
| case 'z': // Neighbor remap -- default is true, -z sets to false |
| neighbor_remap = false; |
| break; |
| |
| default: // Unknown parameter encountered. |
| cout << "⚠ Unknown input parameter " << val << endl; |
| outputHelp(); |
| cout.flush(); |
| exit(EXIT_FAILURE); |
| break; } |
| |
| val = strtok(argv[i++], " ,.-"); |
| } |
| } |
| |
| /* |
| if(upper_mass_diff_percentage < 0){ |
| upper_mass_diff_percentage = 1.0e-12; |
| } |
| */ |
| } |
