/** Execute the algorithm.
*/
void NexusTester::exec()
{
std::string SaveFilename = getPropertyValue("SaveFilename");
std::string LoadFilename = getPropertyValue("LoadFilename");
std::string FakeDataType = getPropertyValue("FakeData");
int ChunkSizeKb = getProperty("ChunkSize");
int NumChunks = getProperty("NumChunks");
bool Compress = getProperty("Compress");
if (ChunkSizeKb <= 0) throw std::invalid_argument("ChunkSize must be > 0");
if (NumChunks <= 0) throw std::invalid_argument("NumChunks must be > 0");
// Size of the chunk in number of integers
size_t chunkSize = ChunkSizeKb*1024 / sizeof(uint32_t);
// ----------- Generate the fake data -----------------------------
uint32_t * fakeData = new uint32_t[chunkSize];
if (FakeDataType == "Zeros")
{
for (size_t i=0; i<chunkSize; i++)
fakeData[i] = 0;
} else if (FakeDataType == "Incrementing Numbers")
{
for (size_t i=0; i<chunkSize; i++)
fakeData[i] = uint32_t(i);
} else if (FakeDataType == "Random Numbers")
{
for (size_t i=0; i<chunkSize; i++)
fakeData[i] = rand();
}
std::vector<int64_t> dims;
dims.push_back(int64_t(chunkSize)*NumChunks);
std::vector<int64_t> chunkDims;
chunkDims.push_back(int64_t(chunkSize));
// Total size in BYTES
double dataSizeMB = double(chunkSize*NumChunks*sizeof(uint32_t)) / (1024.*1024.);
g_log.notice() << "Data size is " << dataSizeMB << " MB" << std::endl;
// ------------------------ Save a File ----------------------------
if (!SaveFilename.empty())
{
::NeXus::File file(SaveFilename, NXACC_CREATE5);
file.makeGroup("FakeDataGroup", "NXdata", true);
file.makeCompData("FakeData", ::NeXus::UINT32, dims, Compress ? ::NeXus::LZW : ::NeXus::NONE, chunkDims, true);
Progress prog(this, 0.0, 1.0, NumChunks);
CPUTimer tim;
for (int i=0; i<NumChunks; i++)
{
std::vector<int64_t> startDims;
startDims.push_back(i * int64_t(chunkSize));
file.putSlab(fakeData, startDims, chunkDims);
prog.report();
}
file.close();
double seconds = tim.elapsedWallClock(false);
double MBperSec = dataSizeMB / seconds;
g_log.notice() << tim << " to save the file = " << MBperSec << " MB/sec" << std::endl;
this->setProperty("SaveSpeed", MBperSec);
}
// Check the size of the file created/loaded
Poco::File info(SaveFilename.empty() ? LoadFilename : SaveFilename);
double fileSizeMB = double(info.getSize())/(1024.*1024.);
g_log.notice() << "File size is " << fileSizeMB << " MB" << std::endl;
double CompressionFactor = fileSizeMB / dataSizeMB;
this->setProperty("CompressionFactor", CompressionFactor);
bool ClearDiskCache = this->getProperty("ClearDiskCache");
if (ClearDiskCache)
{
g_log.information() << "Clearing disk cache." << std::endl;
if (system("sync ; echo 3 > /proc/sys/vm/drop_caches") != 0)
g_log.error("Error clearing disk cache");
Poco::Thread::sleep(100);
}
// ------------------------ Load a File ----------------------------
if (!LoadFilename.empty())
{
::NeXus::File file(LoadFilename, NXACC_READ);
int HDFCacheSize = getProperty("HDFCacheSize");
NXsetcache(HDFCacheSize);
file.openGroup("FakeDataGroup", "NXdata");
Progress prog(this, 0.0, 1.0, NumChunks);
CPUTimer tim;
for (int i=0; i<NumChunks; i++)
{
file.openData("FakeData");
std::vector<int64_t> startDims;
startDims.push_back(i * int64_t(chunkSize));
file.getSlab(fakeData, startDims, chunkDims);
prog.report();
file.closeData();
}
file.close();
double seconds = tim.elapsedWallClock(false);
double MBperSec = dataSizeMB / seconds;
this->setProperty("LoadSpeed", MBperSec);
g_log.notice() << tim << " to load the file = " << MBperSec << " MB/sec (data), " << MBperSec*CompressionFactor << " MB/sec (file)" << std::endl;
}
}
