Skip to content

Commit

Permalink
added test to reproduce SST BP compression bug
Browse files Browse the repository at this point in the history
  • Loading branch information
@JasonRuonanWang
JasonRuonanWang committed May 22, 2019
1 parent 02f246e commit b531104
Show file tree
Hide file tree
Showing 2 changed files with 364 additions and 0 deletions.
6 changes: 6 additions & 0 deletions testing/adios2/engine/sst/CMakeLists.txt
View file
Original file line number Diff line number Diff line change
Expand Up @@ -19,3 +19,9 @@ if(ADIOS2_HAVE_MPI)
target_link_libraries(TestSstParamFails MPI::MPI_C)
target_link_libraries(TestSstWriterFails MPI::MPI_C)
endif()

if(ADIOS2_HAVE_MPI)
add_executable(TestSstBpCompressionLarge TestSstBpCompressionLarge.cpp)
target_link_libraries(TestSstBpCompressionLarge adios2 gtest MPI::MPI_C)
add_test(NAME TestSstBpCompressionLarge COMMAND "mpirun" "-n" "8" $<TARGET_FILE:TestSstBpCompressionLarge>)
endif()
358 changes: 358 additions & 0 deletions testing/adios2/engine/sst/TestSstBpCompressionLarge.cpp
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,358 @@
/*
* Distributed under the OSI-approved Apache License, Version 2.0. See
* accompanying file Copyright.txt for details.
*/

#include <adios2.h>
#include <gtest/gtest.h>
#ifdef ADIOS2_HAVE_MPI
#include <mpi.h>
#endif
#include <numeric>
#include <thread>

using namespace adios2;
int mpiRank = 0;
int mpiSize = 1;
MPI_Comm mpiComm;
size_t print_lines = 0;

char runMode;

class SstEngineTest : public ::testing::Test
{
public:
SstEngineTest() = default;
};

template <class T>
void PrintData(const T *data, const size_t step, const Dims &start,
const Dims &count)
{
size_t size = std::accumulate(count.begin(), count.end(), 1,
std::multiplies<size_t>());
std::cout << "Rank: " << mpiRank << " Step: " << step << " Size:" << size
<< "\n";
size_t printsize = 128;

if (size < printsize)
{
printsize = size;
}
int s = 0;
for (size_t i = 0; i < printsize; ++i)
{
++s;
std::cout << data[i] << " ";
if (s == count[1])
{
std::cout << std::endl;
s = 0;
}
}

std::cout << "]" << std::endl;
}

template <class T>
void GenData(std::vector<T> &data, const size_t step, const Dims &start,
const Dims &count, const Dims &shape)
{
if (start.size() == 2)
{
for (size_t i = 0; i < count[0]; ++i)
{
for (size_t j = 0; j < count[1]; ++j)
{
data[i * count[1] + j] =
(i + start[1]) * shape[1] + j + start[0] + step;
}
}
}
}

template <class T>
void VerifyData(const std::complex<T> *data, size_t step, const Dims &start,
const Dims &count, const Dims &shape)
{
size_t size = std::accumulate(count.begin(), count.end(), 1,
std::multiplies<size_t>());
std::vector<std::complex<T>> tmpdata(size);
GenData(tmpdata, step, start, count, shape);
for (size_t i = 0; i < size; ++i)
{
ASSERT_EQ(data[i], tmpdata[i]);
}
if (print_lines < 100)
{
PrintData(data, step, start, count);
++print_lines;
}
}

template <class T>
void VerifyData(const T *data, size_t step, const Dims &start,
const Dims &count, const Dims &shape)
{
size_t size = std::accumulate(count.begin(), count.end(), 1,
std::multiplies<size_t>());
bool compressed = false;
std::vector<T> tmpdata(size);
if (print_lines < 100)
{
PrintData(data, step, start, count);
++print_lines;
}
GenData(tmpdata, step, start, count, shape);
for (size_t i = 0; i < size; ++i)
{
if (!compressed)
{
ASSERT_EQ(data[i], tmpdata[i]);
}
}
}

void Writer(const Dims &shape, const Dims &start, const Dims &count,
const size_t steps, const adios2::Params &engineParams,
const std::string &name)
{
size_t datasize = std::accumulate(count.begin(), count.end(), 1,
std::multiplies<size_t>());
adios2::ADIOS adios(mpiComm, adios2::DebugON);
adios2::IO dataManIO = adios.DeclareIO("WAN");
dataManIO.SetEngine("sst");
dataManIO.SetParameters(engineParams);
std::vector<char> myChars(datasize);
std::vector<unsigned char> myUChars(datasize);
std::vector<short> myShorts(datasize);
std::vector<unsigned short> myUShorts(datasize);
std::vector<int> myInts(datasize);
std::vector<unsigned int> myUInts(datasize);
std::vector<float> myFloats(datasize);
std::vector<double> myDoubles(datasize);
std::vector<std::complex<float>> myComplexes(datasize);
std::vector<std::complex<double>> myDComplexes(datasize);
auto bpChars =
dataManIO.DefineVariable<char>("bpChars", shape, start, count);
auto bpUChars = dataManIO.DefineVariable<unsigned char>("bpUChars", shape,
start, count);
auto bpShorts =
dataManIO.DefineVariable<short>("bpShorts", shape, start, count);
auto bpUShorts = dataManIO.DefineVariable<unsigned short>(
"bpUShorts", shape, start, count);
auto bpInts = dataManIO.DefineVariable<int>("bpInts", shape, start, count);
auto bpUInts =
dataManIO.DefineVariable<unsigned int>("bpUInts", shape, start, count);
auto bpFloats =
dataManIO.DefineVariable<float>("bpFloats", shape, start, count);
auto bpDoubles =
dataManIO.DefineVariable<double>("bpDoubles", shape, start, count);
auto bpComplexes = dataManIO.DefineVariable<std::complex<float>>(
"bpComplexes", shape, start, count);
auto bpDComplexes = dataManIO.DefineVariable<std::complex<double>>(
"bpDComplexes", shape, start, count);

adios2::Operator ZfpOp = adios.DefineOperator("zfpCompressor", "zfp");
bpFloats.AddOperation(ZfpOp, {{"rate", "20"}});

dataManIO.DefineAttribute<int>("AttInt", 110);
adios2::Engine dataManWriter = dataManIO.Open(name, adios2::Mode::Write);
for (int i = 0; i < steps; ++i)
{
dataManWriter.BeginStep();
GenData(myChars, i, start, count, shape);
GenData(myUChars, i, start, count, shape);
GenData(myShorts, i, start, count, shape);
GenData(myUShorts, i, start, count, shape);
GenData(myInts, i, start, count, shape);
GenData(myUInts, i, start, count, shape);
GenData(myFloats, i, start, count, shape);
GenData(myDoubles, i, start, count, shape);
GenData(myComplexes, i, start, count, shape);
GenData(myDComplexes, i, start, count, shape);
dataManWriter.Put(bpChars, myChars.data(), adios2::Mode::Sync);
dataManWriter.Put(bpUChars, myUChars.data(), adios2::Mode::Sync);
dataManWriter.Put(bpShorts, myShorts.data(), adios2::Mode::Sync);
dataManWriter.Put(bpUShorts, myUShorts.data(), adios2::Mode::Sync);
dataManWriter.Put(bpInts, myInts.data(), adios2::Mode::Sync);
dataManWriter.Put(bpUInts, myUInts.data(), adios2::Mode::Sync);
dataManWriter.Put(bpFloats, myFloats.data(), adios2::Mode::Sync);
dataManWriter.Put(bpDoubles, myDoubles.data(), adios2::Mode::Sync);
dataManWriter.Put(bpComplexes, myComplexes.data(), adios2::Mode::Sync);
dataManWriter.Put(bpDComplexes, myDComplexes.data(),
adios2::Mode::Sync);
dataManWriter.EndStep();
}
dataManWriter.Close();
}

void Reader(const Dims &shape, const Dims &start, const Dims &count,
const size_t steps, const adios2::Params &engineParams,
const std::string &name)
{
adios2::ADIOS adios(mpiComm, adios2::DebugON);
adios2::IO dataManIO = adios.DeclareIO("Test");
dataManIO.SetEngine("sst");
dataManIO.SetParameters(engineParams);
adios2::Engine dataManReader = dataManIO.Open(name, adios2::Mode::Read);

size_t datasize = std::accumulate(count.begin(), count.end(), 1,
std::multiplies<size_t>());
std::vector<char> myChars(datasize);
std::vector<unsigned char> myUChars(datasize);
std::vector<short> myShorts(datasize);
std::vector<unsigned short> myUShorts(datasize);
std::vector<int> myInts(datasize);
std::vector<unsigned int> myUInts(datasize);
std::vector<float> myFloats(datasize);
std::vector<double> myDoubles(datasize);
std::vector<std::complex<float>> myComplexes(datasize);
std::vector<std::complex<double>> myDComplexes(datasize);

bool received_steps = false;
size_t i;
for (i = 0; i < steps; ++i)
{

adios2::StepStatus status =
dataManReader.BeginStep(StepMode::NextAvailable, 5);

if (status == adios2::StepStatus::OK)
{
received_steps = true;
const auto &vars = dataManIO.AvailableVariables();
if (print_lines == 0)
{
std::cout << "All available variables : ";
for (const auto &var : vars)
{
std::cout << var.first << ", ";
}
std::cout << std::endl;
}
ASSERT_EQ(vars.size(), 10);
size_t currentStep = dataManReader.CurrentStep();
// ASSERT_EQ(i, currentStep);
adios2::Variable<char> bpChars =
dataManIO.InquireVariable<char>("bpChars");
adios2::Variable<unsigned char> bpUChars =
dataManIO.InquireVariable<unsigned char>("bpUChars");
adios2::Variable<short> bpShorts =
dataManIO.InquireVariable<short>("bpShorts");
adios2::Variable<unsigned short> bpUShorts =
dataManIO.InquireVariable<unsigned short>("bpUShorts");
adios2::Variable<int> bpInts =
dataManIO.InquireVariable<int>("bpInts");
adios2::Variable<unsigned int> bpUInts =
dataManIO.InquireVariable<unsigned int>("bpUInts");
adios2::Variable<float> bpFloats =
dataManIO.InquireVariable<float>("bpFloats");
adios2::Variable<double> bpDoubles =
dataManIO.InquireVariable<double>("bpDoubles");
adios2::Variable<std::complex<float>> bpComplexes =
dataManIO.InquireVariable<std::complex<float>>("bpComplexes");
adios2::Variable<std::complex<double>> bpDComplexes =
dataManIO.InquireVariable<std::complex<double>>("bpDComplexes");
auto charsBlocksInfo = dataManReader.AllStepsBlocksInfo(bpChars);

bpChars.SetSelection({start, count});
bpUChars.SetSelection({start, count});
bpShorts.SetSelection({start, count});
bpUShorts.SetSelection({start, count});
bpInts.SetSelection({start, count});
bpUInts.SetSelection({start, count});
bpFloats.SetSelection({start, count});
bpDoubles.SetSelection({start, count});
bpComplexes.SetSelection({start, count});
bpDComplexes.SetSelection({start, count});

dataManReader.Get(bpChars, myChars.data(), adios2::Mode::Sync);
dataManReader.Get(bpUChars, myUChars.data(), adios2::Mode::Sync);
dataManReader.Get(bpShorts, myShorts.data(), adios2::Mode::Sync);
dataManReader.Get(bpUShorts, myUShorts.data(), adios2::Mode::Sync);
dataManReader.Get(bpInts, myInts.data(), adios2::Mode::Sync);
dataManReader.Get(bpUInts, myUInts.data(), adios2::Mode::Sync);
dataManReader.Get(bpFloats, myFloats.data(), adios2::Mode::Sync);
dataManReader.Get(bpDoubles, myDoubles.data(), adios2::Mode::Sync);
dataManReader.Get(bpComplexes, myComplexes.data(),
adios2::Mode::Sync);
dataManReader.Get(bpDComplexes, myDComplexes.data(),
adios2::Mode::Sync);
VerifyData(myChars.data(), currentStep, start, count, shape);
VerifyData(myUChars.data(), currentStep, start, count, shape);
VerifyData(myShorts.data(), currentStep, start, count, shape);
VerifyData(myUShorts.data(), currentStep, start, count, shape);
VerifyData(myInts.data(), currentStep, start, count, shape);
VerifyData(myUInts.data(), currentStep, start, count, shape);
VerifyData(myFloats.data(), currentStep, start, count, shape);
VerifyData(myDoubles.data(), currentStep, start, count, shape);
VerifyData(myComplexes.data(), currentStep, start, count, shape);
VerifyData(myDComplexes.data(), currentStep, start, count, shape);
dataManReader.EndStep();
}
else if (status == adios2::StepStatus::EndOfStream)
{
std::cout << "[Rank " + std::to_string(mpiRank) +
"] SstTest reader end of stream!"
<< std::endl;
break;
}
}
if (received_steps)
{
auto attInt = dataManIO.InquireAttribute<int>("AttInt");
std::cout << "[Rank " + std::to_string(mpiRank) +
"] Attribute received "
<< attInt.Data()[0] << ", expected 110" << std::endl;
ASSERT_EQ(110, attInt.Data()[0]);
ASSERT_NE(111, attInt.Data()[0]);
}
dataManReader.Close();
print_lines = 0;
}

TEST_F(SstEngineTest, SstBpCompressionLarge)
{
int worldRank, worldSize;
MPI_Comm_rank(MPI_COMM_WORLD, &worldRank);
MPI_Comm_size(MPI_COMM_WORLD, &worldSize);
int mpiGroup = worldRank / (worldSize / 2);
MPI_Comm_split(MPI_COMM_WORLD, mpiGroup, worldRank, &mpiComm);

MPI_Comm_rank(mpiComm, &mpiRank);
MPI_Comm_size(mpiComm, &mpiSize);

Dims shape = {100000, (size_t)mpiSize * 2};
Dims start = {0, (size_t)mpiRank * 2};
Dims count = {100000, 2};

std::string filename = "SstBpCompression";

if (mpiGroup == 0)
{
Writer(shape, start, count, 10, Params(), filename);
}

std::this_thread::sleep_for(std::chrono::milliseconds(100));

if (mpiGroup == 1)
{
Reader(shape, start, count, 10, Params(), filename);
}

MPI_Barrier(MPI_COMM_WORLD);
}

int main(int argc, char **argv)
{
MPI_Init(&argc, &argv);
int worldRank, worldSize;
MPI_Comm_rank(MPI_COMM_WORLD, &worldRank);
MPI_Comm_size(MPI_COMM_WORLD, &worldSize);
::testing::InitGoogleTest(&argc, argv);
int result = RUN_ALL_TESTS();

MPI_Finalize();
return result;
}

0 comments on commit b531104

Please sign in to comment.