Stream read is now consist with BP3. (fc6d0a64) · Commits · Podhorszki, Norbert / ADIOS2

source/adios2/engine/hdf5/HDF5ReaderP.cpp

+6 −4

Original line number	Diff line number	Diff line
		@@ -68,10 +68,12 @@ void HDF5ReaderP::Init()
		m_H5File.ReadAttrToIO(m_IO);
		if (!m_InStreamMode)
		{
		//m_H5File.ReadVariables(0, m_IO);
		m_H5File.ReadAllVariables(m_IO);
		}
		else
		{
		//m_H5File.ReadVariables(0, m_IO);
		m_H5File.ReadAllVariables(m_IO);
		}
		}
		@@ -260,12 +262,12 @@ StepStatus HDF5ReaderP::BeginStep(StepMode mode, const float timeoutSeconds)

		if (m_StreamAt >= ts)
		{
		m_IO.m_ReadStreaming = false;
		return StepStatus::EndOfStream;
		}

		m_IO.RemoveAllVariables();
		m_IO.RemoveAllAttributes();
		m_H5File.ReadVariables(m_StreamAt, m_IO);
		m_IO.m_ReadStreaming = true;
		m_IO.m_EngineStep = m_StreamAt;

		return StepStatus::OK;
		}

source/adios2/engine/hdf5/HDF5WriterP.cpp

+2 −0

Original line number	Diff line number	Diff line
		@@ -24,6 +24,7 @@ HDF5WriterP::HDF5WriterP(IO &io, const std::string &name, const Mode mode,
		MPI_Comm mpiComm)
		: Engine("HDF5Writer", io, name, mode, mpiComm), m_H5File(io.m_DebugMode)
		{
		m_IO.m_ReadStreaming = false;
		m_EndMessage = ", in call to IO HDF5Writer Open " + m_Name + "\n";
		Init();
		}
		@@ -32,6 +33,7 @@ HDF5WriterP::~HDF5WriterP() { DoClose(); }

		StepStatus HDF5WriterP::BeginStep(StepMode mode, const float timeoutSeconds)
		{
		m_IO.m_ReadStreaming = false;
		return StepStatus::OK;
		}

source/adios2/toolkit/interop/hdf5/HDF5Common.cpp

+32 −27

Original line number	Diff line number	Diff line
		@@ -174,7 +174,7 @@ void HDF5Common::ReadAllVariables(core::IO &io)
		{
		if (!m_IsGeneratedByAdios)
		{
		FindVarsFromH5(io, m_FileId, "/", "");
		FindVarsFromH5(io, m_FileId, "/", "", 0);
		return;
		}

		@@ -188,7 +188,7 @@ void HDF5Common::ReadAllVariables(core::IO &io)
		}

		void HDF5Common::FindVarsFromH5(core::IO &io, hid_t top_id, const char *gname,
		const char *heritage)
		const char *heritage, unsigned int ts)
		{
		// int i = 0;
		// std::string stepStr;
		@@ -229,7 +229,7 @@ void HDF5Common::FindVarsFromH5(core::IO &io, hid_t top_id, const char *gname,
		}
		// CreateVar(io, datasetId, name);
		ReadNativeAttrToIO(io, datasetId, longName);
		CreateVar(io, datasetId, longName);
		CreateVar(io, datasetId, longName, ts);
		}
		else if (currType == H5G_GROUP)
		{
		@@ -239,7 +239,7 @@ void HDF5Common::FindVarsFromH5(core::IO &io, hid_t top_id, const char *gname,
		heritageNext += "/";
		heritageNext += gname;
		}
		FindVarsFromH5(io, gid, name, heritageNext.c_str());
		FindVarsFromH5(io, gid, name, heritageNext.c_str(), ts);
		}
		}
		}
		@@ -303,7 +303,7 @@ void HDF5Common::ReadVariables(unsigned int ts, core::IO &io)
		int currType = H5Gget_objtype_by_idx(gid, k);
		if (currType == H5G_GROUP)
		{
		FindVarsFromH5(io, gid, name, "");
		FindVarsFromH5(io, gid, name, "", ts);
		}
		else if ((currType == H5G_DATASET) \|\| (currType == H5G_TYPE))
		{
		@@ -311,7 +311,7 @@ void HDF5Common::ReadVariables(unsigned int ts, core::IO &io)

		HDF5TypeGuard d(datasetId, E_H5_DATASET);
		ReadNativeAttrToIO(io, datasetId, name);
		CreateVar(io, datasetId, name);
		CreateVar(io, datasetId, name, ts);
		}
		}
		}
		@@ -321,7 +321,7 @@ void HDF5Common::ReadVariables(unsigned int ts, core::IO &io)
		}

		template <class T>
		void HDF5Common::AddVar(core::IO &io, std::string const &name, hid_t datasetId)
		void HDF5Common::AddVar(core::IO &io, std::string const &name, hid_t datasetId, unsigned int ts)
		{
		core::Variable<T> *v = io.InquireVariable<T>(name);
		if (NULL == v)
		@@ -356,8 +356,12 @@ void HDF5Common::AddVar(core::IO &io, std::string const &name, hid_t datasetId)
		{
		auto &foo = io.DefineVariable<T>(name, shape, zeros, shape);

		// 0 is a dummy holder. Just to make sure the ts entry is in there
		foo.m_AvailableStepBlockIndexOffsets[ts+1] = std::vector<size_t>({0});
		foo.m_AvailableStepsStart = ts;
		// default was set to 0 while m_AvailabelStepsStart is 1.
		// correcting

		if (0 == foo.m_AvailableStepsCount)
		{
		foo.m_AvailableStepsCount++;
		@@ -378,11 +382,12 @@ void HDF5Common::AddVar(core::IO &io, std::string const &name, hid_t datasetId)
		}
		*/
		v->m_AvailableStepsCount++;
		v->m_AvailableStepBlockIndexOffsets[ts+1] = std::vector<size_t>({0});
		}
		}

		void HDF5Common::CreateVar(core::IO &io, hid_t datasetId,
		std::string const &nameSuggested)
		std::string const &nameSuggested, unsigned int ts)
		{
		std::string name;
		ReadADIOSName(datasetId, name);
		@@ -402,83 +407,83 @@ void HDF5Common::CreateVar(core::IO &io, hid_t datasetId,
		if (H5Tget_class(h5Type) == H5T_STRING)
		// if (H5Tequal(H5T_STRING, h5Type))
		{
		AddVar<std::string>(io, name, datasetId);
		AddVar<std::string>(io, name, datasetId, ts);
		return;
		}

		if (H5Tequal(H5T_NATIVE_SCHAR, h5Type))
		{
		AddVar<signed char>(io, name, datasetId);
		AddVar<signed char>(io, name, datasetId, ts);
		}
		else if (H5Tequal(H5T_NATIVE_CHAR, h5Type))
		{
		AddVar<char>(io, name, datasetId);
		AddVar<char>(io, name, datasetId, ts);
		}
		else if (H5Tequal(H5T_NATIVE_UCHAR, h5Type))
		{
		AddVar<unsigned char>(io, name, datasetId);
		AddVar<unsigned char>(io, name, datasetId, ts);
		}
		else if (H5Tequal(H5T_NATIVE_SHORT, h5Type))
		{
		AddVar<short>(io, name, datasetId);
		AddVar<short>(io, name, datasetId, ts);
		}
		else if (H5Tequal(H5T_NATIVE_USHORT, h5Type))
		{
		AddVar<unsigned short>(io, name, datasetId);
		AddVar<unsigned short>(io, name, datasetId, ts);
		}
		else if (H5Tequal(H5T_NATIVE_INT, h5Type))
		{
		AddVar<int>(io, name, datasetId);
		AddVar<int>(io, name, datasetId, ts);
		}
		else if (H5Tequal(H5T_NATIVE_UINT, h5Type))
		{
		AddVar<unsigned int>(io, name, datasetId);
		AddVar<unsigned int>(io, name, datasetId, ts);
		}
		else if (H5Tequal(H5T_STD_I64LE, h5Type))
		{
		/*
		*/
		AddVar<int64_t>(io, name, datasetId);
		AddVar<int64_t>(io, name, datasetId, ts);
		}
		else if (H5Tequal(H5T_STD_U64LE, h5Type))
		{
		AddVar<uint64_t>(io, name, datasetId);
		AddVar<uint64_t>(io, name, datasetId, ts);
		}
		else if (H5Tequal(H5T_NATIVE_LONG, h5Type))
		{
		AddVar<long>(io, name, datasetId);
		AddVar<long>(io, name, datasetId, ts);
		}
		else if (H5Tequal(H5T_NATIVE_ULONG, h5Type))
		{
		AddVar<unsigned long>(io, name, datasetId);
		AddVar<unsigned long>(io, name, datasetId, ts);
		}
		else if (H5Tequal(H5T_NATIVE_LLONG, h5Type))
		{
		AddVar<long long>(io, name, datasetId);
		AddVar<long long>(io, name, datasetId, ts);
		}
		else if (H5Tequal(H5T_NATIVE_ULLONG, h5Type))
		{
		AddVar<unsigned long long>(io, name, datasetId);
		AddVar<unsigned long long>(io, name, datasetId, ts);
		}
		else if (H5Tequal(H5T_NATIVE_FLOAT, h5Type))
		{
		AddVar<float>(io, name, datasetId);
		AddVar<float>(io, name, datasetId, ts);
		}
		else if (H5Tequal(H5T_NATIVE_DOUBLE, h5Type))
		{
		AddVar<double>(io, name, datasetId);
		AddVar<double>(io, name, datasetId, ts);
		}
		else if (H5Tequal(H5T_NATIVE_LDOUBLE, h5Type))
		{
		AddVar<long double>(io, name, datasetId);
		AddVar<long double>(io, name, datasetId, ts);
		}
		else if (H5Tequal(m_DefH5TypeComplexFloat, h5Type))
		{
		AddVar<std::complex<float>>(io, name, datasetId);
		AddVar<std::complex<float>>(io, name, datasetId, ts);
		}
		else if (H5Tequal(m_DefH5TypeComplexDouble, h5Type))
		{
		AddVar<std::complex<double>>(io, name, datasetId);
		AddVar<std::complex<double>>(io, name, datasetId, ts);
		}

		// H5Tclose(h5Type);

source/adios2/toolkit/interop/hdf5/HDF5Common.h

+3 −3

Original line number	Diff line number	Diff line
		@@ -145,15 +145,15 @@ public:

		void ReadVariables(unsigned int ts, core::IO &io);
		void FindVarsFromH5(core::IO &io, hid_t gid, const char *name,
		const char *heritage);
		const char *heritage, unsigned int ts);
		void ReadAllVariables(core::IO &io);

		void ReadStringScalarDataset(hid_t dataSetId, std::string &result);
		hid_t GetTypeStringScalar(const std::string &input);
		void CreateVar(core::IO &io, hid_t h5Type, std::string const &name);
		void CreateVar(core::IO &io, hid_t h5Type, std::string const &name, unsigned int ts);

		template <class T>
		void AddVar(core::IO &io, std::string const &name, hid_t datasetId);
		void AddVar(core::IO &io, std::string const &name, hid_t datasetId, unsigned int ts);

		template <class T>
		void AddNonStringAttribute(core::IO &io, std::string const &attrName,

testing/adios2/engine/hdf5/TestHDF5WriteReadAsStream.cpp

+37 −35

Original line number	Diff line number	Diff line
		@@ -215,21 +215,21 @@ TEST_F(HDF5WriteReadAsStreamTestADIOS2, ADIOS2HDF5WriteRead1D8)
		EXPECT_FALSE(var_u64);

		ASSERT_EQ(var_i8.ShapeID(), adios2::ShapeID::GlobalArray);
		ASSERT_EQ(var_i8.Steps(), 1);
		ASSERT_EQ(var_i8.Steps(), NSteps / 2 + NSteps % 2);
		ASSERT_EQ(var_i8.Shape()[0], static_cast<size_t>(mpiSize * Nx));

		ASSERT_EQ(var_i16.ShapeID(), adios2::ShapeID::GlobalArray);
		ASSERT_EQ(var_i16.Steps(), 1);
		ASSERT_EQ(var_i16.Steps(), NSteps / 2 + NSteps % 2);
		ASSERT_EQ(var_i16.Shape()[0],
		static_cast<size_t>(mpiSize * Nx));

		ASSERT_EQ(var_i32.ShapeID(), adios2::ShapeID::GlobalArray);
		ASSERT_EQ(var_i32.Steps(), 1);
		ASSERT_EQ(var_i32.Steps(), NSteps / 2 + NSteps % 2);
		ASSERT_EQ(var_i32.Shape()[0],
		static_cast<size_t>(mpiSize * Nx));

		ASSERT_EQ(var_i64.ShapeID(), adios2::ShapeID::GlobalArray);
		ASSERT_EQ(var_i64.Steps(), 1);
		ASSERT_EQ(var_i64.Steps(), NSteps / 2 + NSteps % 2);
		ASSERT_EQ(var_i64.Shape()[0],
		static_cast<size_t>(mpiSize * Nx));

		@@ -256,19 +256,19 @@ TEST_F(HDF5WriteReadAsStreamTestADIOS2, ADIOS2HDF5WriteRead1D8)
		EXPECT_TRUE(var_u64);

		ASSERT_EQ(var_u8.ShapeID(), adios2::ShapeID::GlobalArray);
		ASSERT_EQ(var_u8.Steps(), 1);
		ASSERT_EQ(var_u8.Steps(), NSteps / 2);
		ASSERT_EQ(var_u8.Shape()[0], mpiSize * Nx);

		ASSERT_EQ(var_u16.ShapeID(), adios2::ShapeID::GlobalArray);
		ASSERT_EQ(var_u16.Steps(), 1);
		ASSERT_EQ(var_u16.Steps(), NSteps / 2);
		ASSERT_EQ(var_u16.Shape()[0], mpiSize * Nx);

		ASSERT_EQ(var_u32.ShapeID(), adios2::ShapeID::GlobalArray);
		ASSERT_EQ(var_u32.Steps(), 1);
		ASSERT_EQ(var_u32.Steps(), NSteps / 2);
		ASSERT_EQ(var_u32.Shape()[0], mpiSize * Nx);

		ASSERT_EQ(var_u64.ShapeID(), adios2::ShapeID::GlobalArray);
		ASSERT_EQ(var_u64.Steps(), 1);
		ASSERT_EQ(var_u64.Steps(), NSteps / 2);
		ASSERT_EQ(var_u64.Shape()[0], mpiSize * Nx);

		var_u8.SetSelection(sel);
		@@ -293,11 +293,11 @@ TEST_F(HDF5WriteReadAsStreamTestADIOS2, ADIOS2HDF5WriteRead1D8)
		EXPECT_TRUE(var_r64);

		ASSERT_EQ(var_r32.ShapeID(), adios2::ShapeID::GlobalArray);
		ASSERT_EQ(var_r32.Steps(), 1);
		ASSERT_EQ(var_r32.Steps(), NSteps - 1);
		ASSERT_EQ(var_r32.Shape()[0], mpiSize * Nx);

		ASSERT_EQ(var_r64.ShapeID(), adios2::ShapeID::GlobalArray);
		ASSERT_EQ(var_r64.Steps(), 1);
		ASSERT_EQ(var_r64.Steps(), NSteps - 1);
		ASSERT_EQ(var_r64.Shape()[0], mpiSize * Nx);

		var_r32.SetSelection(sel);
		@@ -311,11 +311,11 @@ TEST_F(HDF5WriteReadAsStreamTestADIOS2, ADIOS2HDF5WriteRead1D8)
		EXPECT_TRUE(var_cr64);

		ASSERT_EQ(var_cr32.ShapeID(), adios2::ShapeID::GlobalArray);
		ASSERT_EQ(var_cr32.Steps(), 1);
		ASSERT_EQ(var_cr32.Steps(), NSteps);
		ASSERT_EQ(var_cr32.Shape()[0], mpiSize * Nx);

		ASSERT_EQ(var_cr64.ShapeID(), adios2::ShapeID::GlobalArray);
		ASSERT_EQ(var_cr64.Steps(), 1);
		ASSERT_EQ(var_cr64.Steps(), NSteps);
		ASSERT_EQ(var_cr64.Shape()[0], mpiSize * Nx);

		var_cr32.SetSelection(sel);
		@@ -474,70 +474,70 @@ TEST_F(HDF5WriteReadAsStreamTestADIOS2, ADIOS2HDF5WriteRead2D2x4)
		auto var_i8 = io.InquireVariable<int8_t>("i8");
		EXPECT_TRUE(var_i8);
		ASSERT_EQ(var_i8.ShapeID(), adios2::ShapeID::GlobalArray);
		ASSERT_EQ(var_i8.Steps(), 1);
		ASSERT_EQ(var_i8.Steps(), NSteps);
		ASSERT_EQ(var_i8.Shape()[0], Ny);
		ASSERT_EQ(var_i8.Shape()[1], static_cast<size_t>(mpiSize * Nx));

		auto var_i16 = io.InquireVariable<int16_t>("i16");
		EXPECT_TRUE(var_i16);
		ASSERT_EQ(var_i16.ShapeID(), adios2::ShapeID::GlobalArray);
		ASSERT_EQ(var_i16.Steps(), 1);
		ASSERT_EQ(var_i16.Steps(), NSteps);
		ASSERT_EQ(var_i16.Shape()[0], Ny);
		ASSERT_EQ(var_i16.Shape()[1], static_cast<size_t>(mpiSize * Nx));

		auto var_i32 = io.InquireVariable<int32_t>("i32");
		EXPECT_TRUE(var_i32);
		ASSERT_EQ(var_i32.ShapeID(), adios2::ShapeID::GlobalArray);
		ASSERT_EQ(var_i32.Steps(), 1);
		ASSERT_EQ(var_i32.Steps(), NSteps);
		ASSERT_EQ(var_i32.Shape()[0], Ny);
		ASSERT_EQ(var_i32.Shape()[1], static_cast<size_t>(mpiSize * Nx));

		auto var_i64 = io.InquireVariable<int64_t>("i64");
		EXPECT_TRUE(var_i64);
		ASSERT_EQ(var_i64.ShapeID(), adios2::ShapeID::GlobalArray);
		ASSERT_EQ(var_i64.Steps(), 1);
		ASSERT_EQ(var_i64.Steps(), NSteps);
		ASSERT_EQ(var_i64.Shape()[0], Ny);
		ASSERT_EQ(var_i64.Shape()[1], static_cast<size_t>(mpiSize * Nx));

		auto var_u8 = io.InquireVariable<uint8_t>("u8");
		EXPECT_TRUE(var_u8);
		ASSERT_EQ(var_u8.ShapeID(), adios2::ShapeID::GlobalArray);
		ASSERT_EQ(var_u8.Steps(), 1);
		ASSERT_EQ(var_u8.Steps(), NSteps);
		ASSERT_EQ(var_u8.Shape()[0], Ny);
		ASSERT_EQ(var_u8.Shape()[1], static_cast<size_t>(mpiSize * Nx));

		auto var_u16 = io.InquireVariable<uint16_t>("u16");
		EXPECT_TRUE(var_u16);
		ASSERT_EQ(var_u16.ShapeID(), adios2::ShapeID::GlobalArray);
		ASSERT_EQ(var_u16.Steps(), 1);
		ASSERT_EQ(var_u16.Steps(), NSteps);
		ASSERT_EQ(var_u16.Shape()[0], Ny);
		ASSERT_EQ(var_u16.Shape()[1], static_cast<size_t>(mpiSize * Nx));

		auto var_u32 = io.InquireVariable<uint32_t>("u32");
		EXPECT_TRUE(var_u32);
		ASSERT_EQ(var_u32.ShapeID(), adios2::ShapeID::GlobalArray);
		ASSERT_EQ(var_u32.Steps(), 1);
		ASSERT_EQ(var_u32.Steps(), NSteps);
		ASSERT_EQ(var_u32.Shape()[0], Ny);
		ASSERT_EQ(var_u32.Shape()[1], static_cast<size_t>(mpiSize * Nx));

		auto var_u64 = io.InquireVariable<uint64_t>("u64");
		EXPECT_TRUE(var_u64);
		ASSERT_EQ(var_u64.ShapeID(), adios2::ShapeID::GlobalArray);
		ASSERT_EQ(var_u64.Steps(), 1);
		ASSERT_EQ(var_u64.Steps(), NSteps);
		ASSERT_EQ(var_u64.Shape()[0], Ny);
		ASSERT_EQ(var_u64.Shape()[1], static_cast<size_t>(mpiSize * Nx));

		auto var_r32 = io.InquireVariable<float>("r32");
		EXPECT_TRUE(var_r32);
		ASSERT_EQ(var_r32.ShapeID(), adios2::ShapeID::GlobalArray);
		ASSERT_EQ(var_r32.Steps(), 1);
		ASSERT_EQ(var_r32.Steps(), NSteps);
		ASSERT_EQ(var_r32.Shape()[0], Ny);
		ASSERT_EQ(var_r32.Shape()[1], static_cast<size_t>(mpiSize * Nx));

		auto var_r64 = io.InquireVariable<double>("r64");
		EXPECT_TRUE(var_r64);
		ASSERT_EQ(var_r64.ShapeID(), adios2::ShapeID::GlobalArray);
		ASSERT_EQ(var_r64.Steps(), 1);
		ASSERT_EQ(var_r64.Steps(), NSteps);
		ASSERT_EQ(var_r64.Shape()[0], Ny);
		ASSERT_EQ(var_r64.Shape()[1], static_cast<size_t>(mpiSize * Nx));

		@@ -724,70 +724,70 @@ TEST_F(HDF5WriteReadAsStreamTestADIOS2, ADIOS2HDF5WriteRead2D4x2)
		auto var_i8 = io.InquireVariable<int8_t>("i8");
		EXPECT_TRUE(var_i8);
		ASSERT_EQ(var_i8.ShapeID(), adios2::ShapeID::GlobalArray);
		ASSERT_EQ(var_i8.Steps(), 1);
		ASSERT_EQ(var_i8.Steps(), NSteps);
		ASSERT_EQ(var_i8.Shape()[0], Ny);
		ASSERT_EQ(var_i8.Shape()[1], static_cast<size_t>(mpiSize * Nx));

		auto var_i16 = io.InquireVariable<int16_t>("i16");
		EXPECT_TRUE(var_i16);
		ASSERT_EQ(var_i16.ShapeID(), adios2::ShapeID::GlobalArray);
		ASSERT_EQ(var_i16.Steps(), 1);
		ASSERT_EQ(var_i16.Steps(), NSteps);
		ASSERT_EQ(var_i16.Shape()[0], Ny);
		ASSERT_EQ(var_i16.Shape()[1], static_cast<size_t>(mpiSize * Nx));

		auto var_i32 = io.InquireVariable<int32_t>("i32");
		EXPECT_TRUE(var_i32);
		ASSERT_EQ(var_i32.ShapeID(), adios2::ShapeID::GlobalArray);
		ASSERT_EQ(var_i32.Steps(), 1);
		ASSERT_EQ(var_i32.Steps(), NSteps);
		ASSERT_EQ(var_i32.Shape()[0], Ny);
		ASSERT_EQ(var_i32.Shape()[1], static_cast<size_t>(mpiSize * Nx));

		auto var_i64 = io.InquireVariable<int64_t>("i64");
		EXPECT_TRUE(var_i64);
		ASSERT_EQ(var_i64.ShapeID(), adios2::ShapeID::GlobalArray);
		ASSERT_EQ(var_i64.Steps(), 1);
		ASSERT_EQ(var_i64.Steps(), NSteps);
		ASSERT_EQ(var_i64.Shape()[0], Ny);
		ASSERT_EQ(var_i64.Shape()[1], static_cast<size_t>(mpiSize * Nx));

		auto var_u8 = io.InquireVariable<uint8_t>("u8");
		EXPECT_TRUE(var_u8);
		ASSERT_EQ(var_u8.ShapeID(), adios2::ShapeID::GlobalArray);
		ASSERT_EQ(var_u8.Steps(), 1);
		ASSERT_EQ(var_u8.Steps(), NSteps);
		ASSERT_EQ(var_u8.Shape()[0], Ny);
		ASSERT_EQ(var_u8.Shape()[1], static_cast<size_t>(mpiSize * Nx));

		auto var_u16 = io.InquireVariable<uint16_t>("u16");
		EXPECT_TRUE(var_u16);
		ASSERT_EQ(var_u16.ShapeID(), adios2::ShapeID::GlobalArray);
		ASSERT_EQ(var_u16.Steps(), 1);
		ASSERT_EQ(var_u16.Steps(), NSteps);
		ASSERT_EQ(var_u16.Shape()[0], Ny);
		ASSERT_EQ(var_u16.Shape()[1], static_cast<size_t>(mpiSize * Nx));

		auto var_u32 = io.InquireVariable<uint32_t>("u32");
		EXPECT_TRUE(var_u32);
		ASSERT_EQ(var_u32.ShapeID(), adios2::ShapeID::GlobalArray);
		ASSERT_EQ(var_u32.Steps(), 1);
		ASSERT_EQ(var_u32.Steps(), NSteps);
		ASSERT_EQ(var_u32.Shape()[0], Ny);
		ASSERT_EQ(var_u32.Shape()[1], static_cast<size_t>(mpiSize * Nx));

		auto var_u64 = io.InquireVariable<uint64_t>("u64");
		EXPECT_TRUE(var_u64);
		ASSERT_EQ(var_u64.ShapeID(), adios2::ShapeID::GlobalArray);
		ASSERT_EQ(var_u64.Steps(), 1);
		ASSERT_EQ(var_u64.Steps(), NSteps);
		ASSERT_EQ(var_u64.Shape()[0], Ny);
		ASSERT_EQ(var_u64.Shape()[1], static_cast<size_t>(mpiSize * Nx));

		auto var_r32 = io.InquireVariable<float>("r32");
		EXPECT_TRUE(var_r32);
		ASSERT_EQ(var_r32.ShapeID(), adios2::ShapeID::GlobalArray);
		ASSERT_EQ(var_r32.Steps(), 1);
		ASSERT_EQ(var_r32.Steps(), NSteps);
		ASSERT_EQ(var_r32.Shape()[0], Ny);
		ASSERT_EQ(var_r32.Shape()[1], static_cast<size_t>(mpiSize * Nx));

		auto var_r64 = io.InquireVariable<double>("r64");
		EXPECT_TRUE(var_r64);
		ASSERT_EQ(var_r64.ShapeID(), adios2::ShapeID::GlobalArray);
		ASSERT_EQ(var_r64.Steps(), 1);
		ASSERT_EQ(var_r64.Steps(), NSteps);
		ASSERT_EQ(var_r64.Shape()[0], Ny);
		ASSERT_EQ(var_r64.Shape()[1], static_cast<size_t>(mpiSize * Nx));

		@@ -937,9 +937,11 @@ TEST_F(HDF5WriteReadAsStreamTestADIOS2, ReaderWriterDefineVariable)
		EXPECT_TRUE(varR32);
		reader.EndStep();

		if (step == 0) {
		adios2::Variable<double> varR64 = io.DefineVariable<double>(
		"r64", shape, start, count, adios2::ConstantDims);
		EXPECT_TRUE(varR64);
		}
		SmallTestData currentTestData = generateNewSmallTestData(
		m_TestData, static_cast<int>(step), mpiRank, mpiSize);
		writer.BeginStep();