int main(int argc, char * argv[]) {
int status;
PV_Init initObj(&argc, &argv, false/*allowUnrecognizedArguments*/);
int rank = 0;
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
if (initObj.getParamsFile()!=NULL) {
if (rank==0) {
pvErrorNoExit().printf("%s runs a number of params files in sequence. Do not include a '-p' option when running this program.\n", argv[0]);
}
MPI_Barrier(MPI_COMM_WORLD); /* Can't use `initObj.getComm()->communicator()` because initObj.initialize hasn't been called. */
exit(EXIT_FAILURE);
}
initObj.setParams("input/LayerRestartTest-Write.params");
status = rebuildandrun(&initObj);
if( status == PV_SUCCESS ) {
char const * checkParamsFile = "input/LayerRestartTest-Check.params";
if (rank==0) {
pvInfo().printf("*** %s: running params file %s\n", initObj.getProgramName(), checkParamsFile);
}
initObj.setParams("input/LayerRestartTest-Check.params");
status = rebuildandrun(&initObj, NULL, &checkComparisonNonzero);
if( status == PV_SUCCESS ) {
char const * readParamsFile = "input/LayerRestartTest-Read.params";
if (rank==0) {
pvInfo().printf("*** %s: running params file %s\n", initObj.getProgramName(), checkParamsFile);
}
initObj.setParams(readParamsFile);
status = rebuildandrun(&initObj, NULL, &checkComparisonZero);
}
}
#ifdef PV_USE_MPI
// Output status from each process, but go through root process since we might be using MPI across several machines
// and only have a console on the root process
if (rank == 0) {
int otherprocstatus = status;
int commsize;
MPI_Comm_size(MPI_COMM_WORLD, &commsize);
for(int r=0; r<commsize; r++) {
if( r!= 0) MPI_Recv(&otherprocstatus, 1, MPI_INT, r, 59, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
if( otherprocstatus == PV_SUCCESS ) {
pvInfo().printf("%s: rank %d process succeeded.\n", argv[0], r);
}
else {
pvErrorNoExit().printf("%s: rank %d process FAILED with return code %d\n", argv[0], r, otherprocstatus);
status = PV_FAILURE;
}
}
}
else {
MPI_Send(&status, 1, MPI_INT, 0, 59, MPI_COMM_WORLD);
}
//if( !mpi_initialized_on_entry ) MPI_Finalize();
#endif // PV_USE_MPI
return status;
}
int main(int argc, char * argv[]) {
int rank = 0;
PV_Init initObj(&argc, &argv, false/*allowUnrecognizedArguments*/);
rank = initObj.getWorldRank();
char const * paramFile1 = "input/timeBatch.params";
char const * paramFile2 = "input/dimBatch.params";
int status = PV_SUCCESS;
if (pv_getopt_str(argc, argv, "-p", NULL, NULL)==0) {
if (rank==0) {
pvErrorNoExit().printf("%s should be run without the params file argument.\n", argv[0]);
}
status = PV_FAILURE;
}
if (pv_getopt_str(argc, argv, "-c", NULL, NULL)==0) {
if (rank==0) {
pvErrorNoExit().printf("%s should be run without the checkpoint directory argument.\n", argv[0]);
}
status = PV_FAILURE;
}
if (pv_getopt(argc, argv, "-r", NULL)==0) {
if (rank==0) {
pvErrorNoExit().printf("%s should be run without the checkpoint directory argument.\n", argv[0]);
}
status = PV_FAILURE;
}
if (status != PV_SUCCESS) {
if (rank==0) {
pvErrorNoExit().printf("This test uses two hard-coded params files, %s and %s. The second run is started from a checkpoint from the first run, and the results of the two runs are compared.\n",
paramFile1, paramFile2);
}
MPI_Barrier(MPI_COMM_WORLD);
exit(EXIT_FAILURE);
}
if (rank==0) {
char const * rmcommand = "rm -rf checkpoints1 checkpoints2 output";
status = system(rmcommand);
if (status != 0) {
pvError().printf("deleting old checkpoints and output directories failed: \"%s\" returned %d\n", rmcommand, status);
}
}
initObj.setParams(paramFile1);
status = rebuildandrun(&initObj);
if( status != PV_SUCCESS ) {
pvError().printf("%s: rank %d running with params file %s returned status code %d.\n", initObj.getProgramName(), rank, paramFile1, status);
}
initObj.setParams(paramFile2);
status = rebuildandrun(&initObj);
if( status != PV_SUCCESS ) {
pvError().printf("%s: rank %d running with params file %s returned status code %d.\n", initObj.getProgramName(), rank, paramFile2, status);
}
return status==PV_SUCCESS ? EXIT_SUCCESS : EXIT_FAILURE;
}
int main(int argc, char * argv[]) {
const char * paramfile1 = "input/RandStateSystemTest1.params";
const char * paramfile2 = "input/RandStateSystemTest2.params";
int rank=0;
PV_Init* initObj = new PV_Init(&argc, &argv, false/*allowUnrecognizedArguments*/);
MPI_Comm_rank(MPI_COMM_WORLD, &rank); /* Can't use `initObj->getComm()->communicator()` because initObj->initialize hasn't been called. */
PV_Arguments * arguments = initObj->getArguments();
if (arguments->getParamsFile() != NULL) {
if (rank==0) {
fprintf(stderr, "%s does not take -p as an option. Instead the necessary params files are hard-coded.\n", arguments->getProgramName());
}
MPI_Barrier(MPI_COMM_WORLD);
exit(EXIT_FAILURE);
}
arguments->setParamsFile(paramfile1);
int status1 = rebuildandrun(initObj, NULL, NULL, NULL, 0);
if (status1 != PV_SUCCESS) {
fprintf(stderr, "%s failed on param file %s with return code %d.\n", arguments->getProgramName(), paramfile1, status1);
return EXIT_FAILURE;
}
arguments->setParamsFile(paramfile2);
int status2 = rebuildandrun(initObj, NULL, &customexit, NULL);
if (status2 != PV_SUCCESS) {
fprintf(stderr, "%s failed on param file %s.\n", arguments->getProgramName(), paramfile2);
}
int status = status1==PV_SUCCESS && status2==PV_SUCCESS ? EXIT_SUCCESS : EXIT_FAILURE;
#ifdef PV_USE_MPI
if (status == EXIT_SUCCESS) {
printf("Test complete. %s passed on process rank %d.\n", arguments->getProgramName(), rank);
}
else {
fprintf(stderr, "Test complete. %s FAILED on process rank %d.\n", arguments->getProgramName(), rank);
}
#else
if (status == EXIT_SUCCESS) {
printf("Test complete. %s passed.\n", arguments->getProgramName());
}
else {
fprintf(stderr, "Test complete. %s FAILED.\n", arguments->getProgramName());
}
#endif // PV_USE_MPI
delete initObj;
return status;
}
int testioparams(PV_Init* initObj, int rank) {
PV_Arguments * arguments = initObj->getArguments();
arguments->resetState();
// Ignore -r and -c switches
arguments->setRestartFlag(false);
arguments->setCheckpointReadDir(NULL);
initObj->initialize();
HyPerCol * hc = build(initObj, NULL, 0);
if (hc == NULL) {
fprintf(stderr, "testioparams error: unable to build HyPerCol.\n");
exit(EXIT_FAILURE);
}
int status = hc->run(); // Needed to generate pv.params file
if (status != PV_SUCCESS) {
fprintf(stderr, "testioparams error: run to generate pv.params file failed.\n");
exit(EXIT_FAILURE);
}
const char * paramsfile = hc->getPrintParamsFilename();
std::string paramsfileString = paramsfile;
if (paramsfile[0]!='/') {
const char * outputPath = hc->getOutputPath();
paramsfileString.insert(0, "/");
paramsfileString.insert(0, outputPath);
}
delete hc;
arguments->setParamsFile(paramsfileString.c_str());
if (rank==0) {
printf("%s --testioparams running PetaVision with arguments\n", arguments->getProgramName());
arguments->printState();
}
status = rebuildandrun(initObj, NULL, &assertAllZeroes, NULL, 0);
return status;
}
int testioparams(PV_Init* initObj, int rank) {
initObj->resetState();
// Ignore -r and -c switches
initObj->setRestartFlag(false);
initObj->setCheckpointReadDir(NULL);
HyPerCol * hc = build(initObj, NULL, 0);
if (hc == NULL) {
pvError().printf("testioparams error: unable to build HyPerCol.\n");
}
int status = hc->run(); // Needed to generate pv.params file
if (status != PV_SUCCESS) {
pvError().printf("testioparams error: run to generate pv.params file failed.\n");
}
const char * paramsfile = hc->getPrintParamsFilename();
std::string paramsfileString = paramsfile;
if (paramsfile[0]!='/') {
const char * outputPath = hc->getOutputPath();
paramsfileString.insert(0, "/");
paramsfileString.insert(0, outputPath);
}
delete hc;
initObj->setParams(paramsfileString.c_str());
if (rank==0) {
pvInfo().printf("Running --testioparams with effective command line\n");
initObj->printState();
}
status = rebuildandrun(initObj, NULL, &assertAllZeroes, NULL, 0);
return status;
}
int main(int argc, char * argv[]) {
int rank = 0;
PV_Init initObj(&argc, &argv, false/*allowUnrecognizedArguments*/);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
char const * paramFile1 = "input/GenerateOutput.params";
char const * paramFile2 = "input/TestOutput.params";
char const * outputDir1 = "outputGenerate";
char const * outputDir2 = "outputTest";
int status = PV_SUCCESS;
if (initObj.getParams()!=NULL) {
if (rank==0) {
pvErrorNoExit(errorMessage);
errorMessage.printf("%s should be run without the params file argument.\n", initObj.getProgramName());
errorMessage.printf("This test uses two hard-coded params files, %s and %s. The first generates an output pvp file, and the second checks whether the output is consistent with the input.\n",
paramFile1, paramFile2);
}
MPI_Barrier(MPI_COMM_WORLD);
exit(EXIT_FAILURE);
}
if (rank==0) {
char const * rmcommand = "rm -rf outputGenerate outputTest";
status = system(rmcommand);
if (status != 0) {
pvError().printf("deleting old output directories failed: \"%s\" returned %d\n", rmcommand, status);
}
}
initObj.registerKeyword("TestNotAlwaysAllZerosProbe", createTestNotAlwaysAllZerosProbe);
initObj.registerKeyword("TestAllZerosProbe", createTestAllZerosProbe);
initObj.setParams(paramFile1);
status = rebuildandrun(&initObj);
if( status != PV_SUCCESS ) {
pvError().printf("%s: rank %d running with params file %s returned error %d.\n", initObj.getProgramName(), rank, paramFile1, status);
}
initObj.setParams(paramFile2);
status = rebuildandrun(&initObj, NULL, &checkProbesOnExit);
if( status != PV_SUCCESS ) {
pvErrorNoExit().printf("%s: rank %d running with params file %s returned status %d.\n", initObj.getProgramName(), rank, paramFile2, status);
}
return status==PV_SUCCESS ? EXIT_SUCCESS : EXIT_FAILURE;
}
int main(int argc, char * argv[]) {
PV_Init* initObj = new PV_Init(&argc, &argv, false/*allowUnrecognizedArguments*/);
int rank = initObj->getWorldRank();
char const * paramFile1 = "input/DtAdaptController_ANNNormalized.params";
char const * paramFile2 = "input/DtAdaptController_dtAdaptController.params";
char const * paramFileCompare = "input/DtAdaptController_Comparison.params";
int status = PV_SUCCESS;
if (pv_getopt_str(argc, argv, "-p", NULL, NULL)==0) {
if (rank==0) {
fprintf(stderr, "%s should be run without the params file argument, as it uses hard-coded params files.\n", argv[0]);
}
MPI_Barrier(MPI_COMM_WORLD);
exit(EXIT_FAILURE);
}
PV_Arguments * arguments = initObj->getArguments();
arguments->setParamsFile(paramFile1);
status = rebuildandrun(initObj, NULL, NULL, NULL, 0);
if( status != PV_SUCCESS ) {
fprintf(stderr, "%s: rank %d running with params file %s returned error %d.\n", arguments->getProgramName(), rank, paramFile1, status);
exit(status);
}
arguments->setParamsFile(paramFile2);
status = rebuildandrun(initObj, NULL, NULL, NULL, 0);
if( status != PV_SUCCESS ) {
fprintf(stderr, "%s: rank %d running with params file %s returned error %d.\n", arguments->getProgramName(), rank, paramFile2, status);
exit(status);
}
arguments->setParamsFile(paramFileCompare);
status = rebuildandrun(initObj, NULL, &assertAllZeroes, NULL, 0);
if( status != PV_SUCCESS ) {
fprintf(stderr, "%s: rank %d running with params file %s returned error %d.\n", arguments->getProgramName(), rank, paramFileCompare, status);
exit(status);
}
delete initObj;
return status==PV_SUCCESS ? EXIT_SUCCESS : EXIT_FAILURE;
}
int testrun(PV_Init * initObj, int rank) {
initObj->resetState();
// Ignore restart flag and checkpoint directory
initObj->setRestartFlag(false);
initObj->setCheckpointReadDir(NULL);
if (rank==0) {
pvInfo().printf("Running --testrun with effective command line\n", initObj->getProgramName());
initObj->printState();
}
int status = rebuildandrun(initObj, NULL, &assertAllZeroes, NULL, 0);
return status;
}
int testrun(PV_Init * initObj, int rank) {
PV_Arguments * arguments = initObj->getArguments();
arguments->resetState();
// Ignore restart flag and checkpoint directory
arguments->setRestartFlag(false);
arguments->setCheckpointReadDir(NULL);
if (rank==0) {
printf("%s --testrun running PetaVision with arguments\n", arguments->getProgramName());
arguments->printState();
}
int status = rebuildandrun(initObj, NULL, &assertAllZeroes, NULL, 0);
return status;
}
int main(int argc, char * argv[]) {
int status;
PV_Init initObj(&argc, &argv, false/*allowUnrecognizedArguments*/);
if (initObj.getParams()==NULL) {
initObj.setParams("input/KernelActivationTest-fullData.params");
status = buildandrun(&initObj);
if (status==PV_SUCCESS) {
initObj.setParams("input/KernelActivationTest-maskData.params");
status = rebuildandrun(&initObj);
}
}
else {
status = buildandrun(&initObj);
}
return status;
}
int testcheckpoint(PV_Init * initObj, int rank) {
initObj->resetState();
// Make sure either restartFlag or checkpointReadDir are set (both cannot be set or PV_Arguments will error out).
bool hasrestart = (initObj->getRestartFlag() || initObj->getCheckpointReadDir()!=NULL);
if (!hasrestart) {
if (rank==0) {
pvErrorNoExit().printf("%s: --testcheckpoint requires either the -r or the -c option.\n", initObj->getProgramName());
}
MPI_Barrier(MPI_COMM_WORLD);
exit(EXIT_FAILURE);
}
if (rank==0) {
pvInfo().printf("Running --testcheckpoint with effective command line\n", initObj->getProgramName());
initObj->printState();
}
int status = rebuildandrun(initObj, NULL, &assertAllZeroes, NULL, 0);
return status;
}
int testcheckpoint(PV_Init * initObj, int rank) {
PV_Arguments * arguments = initObj->getArguments();
arguments->resetState();
// Make sure either restartFlag or checkpointReadDir are set (both cannot be set or PV_Arguments will error out).
bool hasrestart = (arguments->getRestartFlag() || arguments->getCheckpointReadDir()!=NULL);
if (!hasrestart) {
if (rank==0) {
fprintf(stderr, "%s error: --testcheckpoint requires either the -r or the -c option.\n", arguments->getProgramName());
}
MPI_Barrier(MPI_COMM_WORLD);
exit(EXIT_FAILURE);
}
if (rank==0) {
printf("%s --testcheckpoint running PetaVision with arguments\n", arguments->getProgramName());
arguments->printState();
}
int status = rebuildandrun(initObj, NULL, &assertAllZeroes, NULL, 0);
return status;
}
int generate(PV_Init* initObj, int rank) {
// Remove -r and -c
initObj->setRestartFlag(false);
initObj->setCheckpointReadDir(NULL);
if (rank==0) {
pvInfo().printf("Running --generate with effective command line\n", initObj->getProgramName());
initObj->printState();
}
if (rank==0) {
PV_Stream * emptyinfile = PV_fopen("input/correct.pvp", "w", false/*verifyWrites*/);
// Data for a CORRECT_PVP_NX-by-CORRECT_PVP_NY layer with CORRECT_PVP_NF features.
// Sparse activity with no active neurons so file size doesn't change with number of features
int emptydata[] = {80, 20, 2, CORRECT_PVP_NX, CORRECT_PVP_NY, CORRECT_PVP_NF, 1, 0, 4, 2, 1, 1, CORRECT_PVP_NX, CORRECT_PVP_NY, 0, 0, 0, 1, 0, 0, 0, 0, 0};
size_t numwritten = PV_fwrite(emptydata, 23, sizeof(int), emptyinfile);
if (numwritten != 23) {
pvErrorNoExit().printf("%s failure to write placeholder data into input/correct.pvp file.\n", initObj->getProgramName());
}
PV_fclose(emptyinfile);
}
int status = rebuildandrun(initObj, NULL, ©CorrectOutput, NULL, 0);
return status;
}
int generate(PV_Init* initObj, int rank) {
PV_Arguments * arguments = initObj->getArguments();
// Remove -r and -c
arguments->setRestartFlag(false);
arguments->setCheckpointReadDir(NULL);
if (rank==0) {
printf("%s --generate running PetaVision with arguments\n", arguments->getProgramName());
arguments->printState();
}
if (rank==0) {
PV_Stream * emptyinfile = PV_fopen("input/correct.pvp", "w", false/*verifyWrites*/);
// Data for a CORRECT_PVP_NX-by-CORRECT_PVP_NY layer with CORRECT_PVP_NF features.
// Sparse activity with no active neurons so file size doesn't change with number of features
int emptydata[] = {80, 20, 2, CORRECT_PVP_NX, CORRECT_PVP_NY, CORRECT_PVP_NF, 1, 0, 4, 2, 1, 1, CORRECT_PVP_NX, CORRECT_PVP_NY, 0, 0, 0, 1, 0, 0, 0, 0, 0};
size_t numwritten = PV_fwrite(emptydata, 23, sizeof(int), emptyinfile);
if (numwritten != 23) {
fprintf(stderr, "%s error writing placeholder data into input/correct.pvp file.\n", arguments->getProgramName());
}
PV_fclose(emptyinfile);
}
int status = rebuildandrun(initObj, NULL, ©CorrectOutput, NULL, 0);
return status;
}
int main(int argc, char * argv[]) {
int rank = 0;
PV_Init * initObj = new PV_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
char const * paramFile1 = "input/CheckpointParameters1.params";
char const * paramFile2 = "input/CheckpointParameters2.params";
int status = PV_SUCCESS;
if (pv_getopt_str(argc, argv, "-p", NULL, NULL)==0) {
if (rank==0) {
fprintf(stderr, "%s should be run without the params file argument.\n", argv[0]);
}
status = PV_FAILURE;
}
if (pv_getopt_str(argc, argv, "-c", NULL, NULL)==0) {
if (rank==0) {
fprintf(stderr, "%s should be run without the checkpoint directory argument.\n", argv[0]);
}
status = PV_FAILURE;
}
if (pv_getopt(argc, argv, "-r", NULL)==0) {
if (rank==0) {
fprintf(stderr, "%s should be run without the checkpoint directory argument.\n", argv[0]);
}
status = PV_FAILURE;
}
if (status != PV_SUCCESS) {
if (rank==0) {
fprintf(stderr, "This test uses two hard-coded params files, %s and %s. The second run is started from a checkpoint from the first run, and the results of the two runs are compared.\n",
paramFile1, paramFile2);
}
MPI_Barrier(MPI_COMM_WORLD);
exit(EXIT_FAILURE);
}
if (rank==0) {
char const * rmcommand = "rm -rf checkpoints1 checkpoints2 output";
status = system(rmcommand);
if (status != 0) {
fprintf(stderr, "deleting old checkpoints and output directories failed: \"%s\" returned %d\n", rmcommand, status);
exit(EXIT_FAILURE);
}
}
ParamGroupHandler * customGroupHandler = new CustomGroupHandler;
int pv_argc1 = 4 + argc; // command line arguments, plus "-p" plus paramFile1, plus -batchwidth and number
int pv_argc2 = 6 + argc; // pv_argc1 arguments with paramFile2 in place of paramFile1, plus "-c", plus checkpoint directory, plus -batchwidth and number
assert(pv_argc1 < pv_argc2); // so we can allocate based on pv_argc2 and be sure it will hold pv_argc1 arguments.
char ** pv_argv = (char **) calloc((pv_argc2+1), sizeof(char *));
assert(pv_argv!=NULL);
int pv_arg=0;
for (pv_arg = 0; pv_arg < argc; pv_arg++) {
pv_argv[pv_arg] = strdup(argv[pv_arg]);
assert(pv_argv[pv_arg]);
}
assert(pv_arg==argc);
pv_argv[pv_arg++] = strdup("-p");
pv_argv[pv_arg++] = strdup(paramFile1);
pv_argv[pv_arg++] = strdup("-batchwidth");
pv_argv[pv_arg++] = strdup("2");
assert(pv_arg==pv_argc1 && pv_arg==argc+4);
assert(pv_argv[argc]!=NULL && pv_argv[argc+1]!=NULL && pv_argv[argc+2]!=NULL && pv_argv[argc+3]!=NULL && pv_argv[argc+4]==NULL);
status = rebuildandrun((int) pv_argc1, pv_argv, initObj, NULL, NULL, &customGroupHandler, 1);
if( status != PV_SUCCESS ) {
fprintf(stderr, "%s: rank %d running with params file %s returned error %d.\n", pv_argv[0], rank, paramFile1, status);
exit(status);
}
free(pv_argv[argc+1]);
pv_argv[argc+1] = strdup(paramFile2);
assert(pv_argv[argc+1]);
assert(pv_arg==argc+4);
pv_argv[pv_arg++] = strdup("-c");
pv_argv[pv_arg++] = strdup("checkpoints1/batchsweep_00/Checkpoint12:checkpoints1/batchsweep_01/Checkpoint12");
assert(pv_arg==pv_argc2 && pv_arg==argc+6);
assert(pv_argv[argc+4]!=NULL && pv_argv[argc+5]!=NULL && pv_argv[argc+6]==NULL);
status = rebuildandrun(pv_argc2, pv_argv, initObj, NULL, &customexit, &customGroupHandler, 1);
if( status != PV_SUCCESS ) {
fprintf(stderr, "%s: rank %d running with params file %s returned error %d.\n", pv_argv[0], rank, paramFile2, status);
}
delete customGroupHandler;
for (size_t arg=0; arg<pv_argc2; arg++) {
free(pv_argv[arg]);
}
free(pv_argv);
delete initObj;
return status==PV_SUCCESS ? EXIT_SUCCESS : EXIT_FAILURE;
}
int runKernelActivationTest(PV_Init* initObj) {
int status = rebuildandrun(initObj, NULL, &dumpweights);
return status;
}
int main(int argc, char * argv[]) {
int rank = 0;
PV_Init * initObj = new PV_Init(&argc, &argv, false/*allowUnrecognizedArguments*/);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
char const * paramFile1 = "input/CheckpointParameters1.params";
char const * paramFile2 = "input/CheckpointParameters2.params";
int status = PV_SUCCESS;
PV_Arguments * arguments = initObj->getArguments();
if (arguments->getParamsFile()!=NULL) {
if (rank==0) {
fprintf(stderr, "%s should be run without the params file argument.\n", arguments->getProgramName());
}
status = PV_FAILURE;
}
if (arguments->getCheckpointReadDir()!=NULL) {
if (rank==0) {
fprintf(stderr, "%s should be run without the checkpoint directory argument.\n", argv[0]);
}
status = PV_FAILURE;
}
if (arguments->getRestartFlag()) {
if (rank==0) {
fprintf(stderr, "%s should be run without the restart flag.\n", argv[0]);
}
status = PV_FAILURE;
}
if (status != PV_SUCCESS) {
if (rank==0) {
fprintf(stderr, "This test uses two hard-coded params files, %s and %s. The second run is started from a checkpoint from the first run, and the results of the two runs are compared.\n",
paramFile1, paramFile2);
}
MPI_Barrier(MPI_COMM_WORLD);
exit(EXIT_FAILURE);
}
if (rank==0) {
char const * rmcommand = "rm -rf checkpoints1 checkpoints2 output";
status = system(rmcommand);
if (status != 0) {
fprintf(stderr, "deleting old checkpoints and output directories failed: \"%s\" returned %d\n", rmcommand, status);
exit(EXIT_FAILURE);
}
}
ParamGroupHandler * customGroupHandler = new CustomGroupHandler;
arguments->setParamsFile(paramFile1);
arguments->setBatchWidth(2);
status = rebuildandrun(initObj, NULL, NULL, &customGroupHandler, 1);
if( status != PV_SUCCESS ) {
fprintf(stderr, "%s: rank %d running with params file %s returned error %d.\n", arguments->getProgramName(), rank, paramFile1, status);
exit(status);
}
arguments->setParamsFile(paramFile2);
arguments->setCheckpointReadDir("checkpoints1/batchsweep_00/Checkpoint12:checkpoints1/batchsweep_01/Checkpoint12");
status = rebuildandrun(initObj, NULL, &customexit, &customGroupHandler, 1);
if( status != PV_SUCCESS ) {
fprintf(stderr, "%s: rank %d running with params file %s returned error %d.\n", arguments->getProgramName(), rank, paramFile2, status);
}
delete customGroupHandler;
delete initObj;
return status==PV_SUCCESS ? EXIT_SUCCESS : EXIT_FAILURE;
}
int main(int argc, char * argv[]) {
int rank = 0;
PV_Init initObj(&argc, &argv, false/*do not allow unrecognized arguments*/);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
char const * paramFile1 = "input/CheckpointParameters1.params";
char const * paramFile2 = "input/CheckpointParameters2.params";
int status = PV_SUCCESS;
if (initObj.getParamsFile()!=NULL) {
if (rank==0) {
pvErrorNoExit().printf("%s should be run without the params file argument.\n", initObj.getProgramName());
}
status = PV_FAILURE;
}
if (initObj.getCheckpointReadDir()!=NULL) {
if (rank==0) {
pvErrorNoExit().printf("%s should be run without the checkpoint directory argument.\n", argv[0]);
}
status = PV_FAILURE;
}
if (initObj.getRestartFlag()) {
if (rank==0) {
pvErrorNoExit().printf("%s should be run without the restart flag.\n", argv[0]);
}
status = PV_FAILURE;
}
if (status != PV_SUCCESS) {
if (rank==0) {
pvErrorNoExit().printf("This test uses two hard-coded params files, %s and %s. The second run is started from a checkpoint from the first run, and the results of the two runs are compared.\n",
paramFile1, paramFile2);
}
MPI_Barrier(MPI_COMM_WORLD);
exit(EXIT_FAILURE);
}
if (rank==0) {
char const * rmcommand = "rm -rf checkpoints1 checkpoints2 output";
status = system(rmcommand);
if (status != 0) {
pvError().printf("deleting old checkpoints and output directories failed: \"%s\" returned %d\n", rmcommand, status);
}
}
initObj.registerKeyword("CPTestInputLayer", createCPTestInputLayer);
initObj.registerKeyword("VaryingHyPerConn", createVaryingHyPerConn);
initObj.setMPIConfiguration(0/*numRows unspecified*/, 0/*numColumns unspecified*/, 2/*batchWidth*/);
initObj.setParams(paramFile1);
status = rebuildandrun(&initObj);
if( status != PV_SUCCESS ) {
pvError().printf("%s: rank %d running with params file %s returned error %d.\n", initObj.getProgramName(), rank, paramFile1, status);
}
initObj.setParams(paramFile2);
initObj.setCheckpointReadDir("checkpoints1/batchsweep_00/Checkpoint12:checkpoints1/batchsweep_01/Checkpoint12");
status = rebuildandrun(&initObj);
if( status != PV_SUCCESS ) {
pvError().printf("%s: rank %d running with params file %s returned error %d.\n", initObj.getProgramName(), rank, paramFile2, status);
}
return status==PV_SUCCESS ? EXIT_SUCCESS : EXIT_FAILURE;
}
