int detectFileMPISize(Options& options, Dimensions &fileMPISizeDim) { int result = RESULT_OK; DataCollector *dc = NULL; #if (SPLASH_SUPPORTED_PARALLEL==1) if (options.parallelFile) dc = new ParallelDataCollector(MPI_COMM_WORLD, MPI_INFO_NULL, Dimensions(options.mpiSize, 1, 1), 1); else #endif dc = new SerialDataCollector(1); DataCollector::FileCreationAttr fileCAttr; DataCollector::initFileCreationAttr(fileCAttr); fileCAttr.fileAccType = DataCollector::FAT_READ; try { dc->open(options.filename.c_str(), fileCAttr); dc->getMPISize(fileMPISizeDim); dc->close(); } catch (DCException e) { std::cerr << "[0] Detecting file MPI size failed!" << std::endl << e.what() << std::endl; fileMPISizeDim.set(0, 0, 0); result = RESULT_ERROR; } delete dc; dc = NULL; return result; }
bool Parallel_SimpleDataTest::subtestFill(int32_t iteration, int currentMpiRank, const Dimensions mpiSize, const Dimensions mpiPos, uint32_t elements, MPI_Comm mpiComm) { bool results_correct = true; DataCollector::FileCreationAttr fileCAttr; #if defined TESTS_DEBUG if (currentMpiRank == 0) std::cout << "iteration: " << iteration << std::endl; #endif // write data to file DataCollector::initFileCreationAttr(fileCAttr); fileCAttr.fileAccType = DataCollector::FAT_CREATE; fileCAttr.enableCompression = false; parallelDataCollector->open(HDF5_FILE, fileCAttr); int dataWrite = currentMpiRank + 1; uint32_t num_elements = (currentMpiRank + 1) * elements; Dimensions grid_size(num_elements, 1, 1); #if defined TESTS_DEBUG std::cout << "[" << currentMpiRank << "] " << num_elements << " elements" << std::endl; #endif Dimensions globalOffset, globalSize; parallelDataCollector->reserve(iteration, grid_size, &globalSize, &globalOffset, 1, ctInt, "reserved/reserved_data"); int attrVal = currentMpiRank; parallelDataCollector->writeAttribute(iteration, ctInt, "reserved/reserved_data", "reserved_attr", &attrVal); uint32_t elements_written = 0; uint32_t global_max_elements = mpiSize.getScalarSize() * elements; for (size_t i = 0; i < global_max_elements; ++i) { Dimensions write_size(1, 1, 1); if (i >= num_elements) write_size.set(0, 0, 0); Dimensions write_offset(globalOffset + Dimensions(elements_written, 0, 0)); parallelDataCollector->append(iteration, write_size, 1, write_offset, "reserved/reserved_data", &dataWrite); if (i < num_elements) elements_written++; } MPI_CHECK(MPI_Barrier(mpiComm)); attrVal = -1; parallelDataCollector->readAttribute(iteration, "reserved/reserved_data", "reserved_attr", &attrVal, NULL); CPPUNIT_ASSERT(attrVal == currentMpiRank); parallelDataCollector->close(); MPI_CHECK(MPI_Barrier(mpiComm)); // test written data using various mechanisms fileCAttr.fileAccType = DataCollector::FAT_READ; // need a complete filename here std::stringstream filename_stream; filename_stream << HDF5_FILE << "_" << iteration << ".h5"; Dimensions size_read; Dimensions full_grid_size = globalSize; // test using SerialDataCollector if (currentMpiRank == 0) { int *data_read = new int[full_grid_size.getScalarSize()]; memset(data_read, 0, sizeof (int) * full_grid_size.getScalarSize()); DataCollector *dataCollector = new SerialDataCollector(1); dataCollector->open(filename_stream.str().c_str(), fileCAttr); dataCollector->read(iteration, "reserved/reserved_data", size_read, data_read); dataCollector->close(); delete dataCollector; CPPUNIT_ASSERT(size_read == full_grid_size); CPPUNIT_ASSERT(size_read[1] == size_read[2] == 1); int this_rank = 0; uint32_t elements_this_rank = num_elements; for (uint32_t i = 0; i < size_read.getScalarSize(); ++i) { if (i == elements_this_rank) { this_rank++; elements_this_rank += num_elements * (this_rank + 1); } CPPUNIT_ASSERT(data_read[i] == this_rank + 1); } delete[] data_read; } MPI_CHECK(MPI_Barrier(mpiComm)); return results_correct; }
bool Parallel_SimpleDataTest::subtestWriteRead(int32_t iteration, int currentMpiRank, const Dimensions mpiSize, const Dimensions mpiPos, const Dimensions gridSize, uint32_t dimensions, MPI_Comm mpiComm) { bool results_correct = true; DataCollector::FileCreationAttr fileCAttr; std::set<std::string> datasetNames; #if defined TESTS_DEBUG if (currentMpiRank == 0) std::cout << "iteration: " << iteration << std::endl; #endif size_t bufferSize = gridSize[0] * gridSize[1] * gridSize[2]; // write data to file DataCollector::initFileCreationAttr(fileCAttr); fileCAttr.fileAccType = DataCollector::FAT_CREATE; fileCAttr.enableCompression = false; parallelDataCollector->open(HDF5_FILE, fileCAttr); int *dataWrite = new int[bufferSize]; for (uint32_t i = 0; i < bufferSize; i++) dataWrite[i] = currentMpiRank + 1; parallelDataCollector->write(iteration, ctInt, dimensions, gridSize, "deep/folder/data", dataWrite); datasetNames.insert("deep/folder/data"); parallelDataCollector->write(iteration, ctInt, dimensions, gridSize, "deep/folder/data2", dataWrite); datasetNames.insert("deep/folder/data2"); parallelDataCollector->write(iteration, ctInt, dimensions, gridSize, "another_dataset", dataWrite); datasetNames.insert("another_dataset"); parallelDataCollector->close(); delete[] dataWrite; dataWrite = NULL; MPI_CHECK(MPI_Barrier(mpiComm)); // test written data using various mechanisms fileCAttr.fileAccType = DataCollector::FAT_READ; // need a complete filename here std::stringstream filename_stream; filename_stream << HDF5_FILE << "_" << iteration << ".h5"; Dimensions size_read; Dimensions full_grid_size = gridSize * mpiSize; int *data_read = new int[full_grid_size.getScalarSize()]; memset(data_read, 0, sizeof (int) * full_grid_size.getScalarSize()); // test using SerialDataCollector if (currentMpiRank == 0) { DataCollector *dataCollector = new SerialDataCollector(1); dataCollector->open(filename_stream.str().c_str(), fileCAttr); dataCollector->read(iteration, "deep/folder/data", size_read, data_read); dataCollector->close(); delete dataCollector; CPPUNIT_ASSERT(size_read == full_grid_size); CPPUNIT_ASSERT(testData(mpiSize, gridSize, data_read)); } MPI_CHECK(MPI_Barrier(mpiComm)); // test using full read per process memset(data_read, 0, sizeof (int) * full_grid_size.getScalarSize()); ParallelDataCollector *readCollector = new ParallelDataCollector(mpiComm, MPI_INFO_NULL, mpiSize, 1); readCollector->open(HDF5_FILE, fileCAttr); /* test entries listing */ { DataCollector::DCEntry *entries = NULL; size_t numEntries = 0; int32_t *ids = NULL; size_t numIDs = 0; readCollector->getEntryIDs(NULL, &numIDs); /* there might be old files, but we are at least at the current iteration */ CPPUNIT_ASSERT(numIDs >= iteration + 1); ids = new int32_t[numIDs]; readCollector->getEntryIDs(ids, NULL); readCollector->getEntriesForID(iteration, NULL, &numEntries); CPPUNIT_ASSERT(numEntries == 3); entries = new DataCollector::DCEntry[numEntries]; readCollector->getEntriesForID(iteration, entries, NULL); CPPUNIT_ASSERT(numEntries == datasetNames.size()); for (uint32_t i = 0; i < numEntries; ++i) { /* test that listed datasets match expected dataset names*/ CPPUNIT_ASSERT(datasetNames.find(entries[i].name) != datasetNames.end()); } delete[] entries; delete[] ids; } readCollector->read(iteration, "deep/folder/data", size_read, data_read); readCollector->close(); CPPUNIT_ASSERT(size_read == full_grid_size); CPPUNIT_ASSERT(testData(mpiSize, gridSize, data_read)); delete[] data_read; MPI_CHECK(MPI_Barrier(mpiComm)); // test using parallel read data_read = new int[gridSize.getScalarSize()]; memset(data_read, 0, sizeof (int) * gridSize.getScalarSize()); const Dimensions globalOffset = gridSize * mpiPos; readCollector->open(HDF5_FILE, fileCAttr); readCollector->read(iteration, gridSize, globalOffset, "deep/folder/data", size_read, data_read); readCollector->close(); delete readCollector; CPPUNIT_ASSERT(size_read == gridSize); for (size_t k = 0; k < gridSize[2]; ++k) { for (size_t j = 0; j < gridSize[1]; ++j) { for (size_t i = 0; i < gridSize[0]; ++i) { size_t index = k * gridSize[1] * gridSize[0] + j * gridSize[0] + i; if (data_read[index] != currentMpiRank + 1) { #if defined TESTS_DEBUG std::cout << index << ": " << data_read[index] << " != expected " << currentMpiRank + 1 << std::endl; #endif results_correct = false; break; } } if (!results_correct) break; } if (!results_correct) break; } delete[] data_read; MPI_CHECK(MPI_Barrier(mpiComm)); return results_correct; }
void FilenameTest::runTest(const char* filename, const char* fullFilename) { CPPUNIT_ASSERT(!fileExists(fullFilename)); DataCollector::FileCreationAttr attr; DataCollector::initFileCreationAttr(attr); attr.fileAccType = DataCollector::FAT_WRITE; // write first dataset to file (create file) dataCollector->open(filename, attr); int data1 = rand(); dataCollector->write(1, ctInt, 1, Selection(Dimensions(1, 1, 1)), "data", &data1); dataCollector->close(); // Now file must exist CPPUNIT_ASSERT(fileExists(fullFilename)); // write second dataset to file (write to existing file of same name dataCollector->open(filename, attr); int data2 = rand(); dataCollector->write(2, ctInt, 1, Selection(Dimensions(1, 1, 1)), "data", &data2); dataCollector->close(); // read data from file attr.fileAccType = DataCollector::FAT_READ; Dimensions data_size; int data = -1; dataCollector->open(filename, attr); CPPUNIT_ASSERT(dataCollector->getMaxID() == 2); dataCollector->read(1, "data", data_size, &data); CPPUNIT_ASSERT(data_size.getScalarSize() == 1); CPPUNIT_ASSERT(data == data1); dataCollector->read(2, "data", data_size, &data); CPPUNIT_ASSERT(data_size.getScalarSize() == 1); CPPUNIT_ASSERT(data == data2); dataCollector->close(); // erase file attr.fileAccType = DataCollector::FAT_CREATE; dataCollector->open(filename, attr); CPPUNIT_ASSERT_THROW(dataCollector->read(1, "data", data_size, &data), DCException); int data3 = rand(); dataCollector->write(2, ctInt, 1, Selection(Dimensions(1, 1, 1)), "data", &data3); dataCollector->close(); // Read from created file attr.fileAccType = DataCollector::FAT_READ; data = -1; dataCollector->open(filename, attr); CPPUNIT_ASSERT(dataCollector->getMaxID() == 2); dataCollector->read(2, "data", data_size, &data); CPPUNIT_ASSERT(data_size.getScalarSize() == 1); CPPUNIT_ASSERT(data == data3); dataCollector->close(); }