Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-09-19 18:45:43 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity

fixed error with integer types

Browse Source
This commit is contained in:
mclarsen 2018-11-26 14:30:30 -08:00 committed by Mark Kim
parent 584b36d64e
commit 0c788b92a2
6 changed files with 163 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
vtkm/worklet/ZFPCompressor.h
View File

@ -103,7 +103,8 @@ void DataDump(vtkm::cont::ArrayHandle<T> handle, std::string fileName)
class ZFPCompressor
{
public:
void Compress(const vtkm::cont::ArrayHandle<vtkm::Float64>& data,
template <typename Scalar>
void Compress(const vtkm::cont::ArrayHandle<Scalar>& data,
const vtkm::Float64 requestedRate,
const vtkm::Id3 dims)
{

29
vtkm/worklet/testing/UnitTestZFPCompressor.cxx
View File

@ -27,12 +27,13 @@
using Handle64 = vtkm::cont::ArrayHandle<vtkm::Float64>;
void Test3D()
template <typename Scalar>
void Test3D(int rate)
{
std::cout << "Testing ZFP 3d:" << std::endl;
//vtkm::Id3 dims(4,4,4);
vtkm::Id3 dims(4, 4, 7);
//vtkm::Id3 dims(4,4,8);
//vtkm::Id3 dims(4,4,7);
vtkm::Id3 dims(8, 8, 8);
//vtkm::Id3 dims(256,256,256);
//vtkm::Id3 dims(128,128,128);
vtkm::cont::testing::MakeTestDataSet testDataSet;
@ -42,23 +43,29 @@ void Test3D()
vtkm::worklet::ZFPCompressor compressor;
vtkm::Float64 rate = 4;
if (dynField.IsSameType(Handle64()))
{
Handle64 array = dynField.Cast<Handle64>();
//std::cout<<"\n";
for (int i = 0; i < 64; ++i)
Handle64 field = dynField.Cast<Handle64>();
vtkm::cont::ArrayHandle<Scalar> handle;
const vtkm::Id size = field.GetNumberOfValues();
handle.Allocate(size);
auto fPortal = field.GetPortalControl();
auto hPortal = handle.GetPortalControl();
for (vtkm::Id i = 0; i < size; ++i)
{
std::cout << array.GetPortalControl().Get(i) << " ";
hPortal.Set(i, static_cast<Scalar>(fPortal.Get(i)));
}
std::cout << "\n";
compressor.Compress(array, rate, dims);
compressor.Compress(handle, rate, dims);
}
}
void TestZFP()
{
Test3D();
//Test3D<vtkm::Float64>(4);
Test3D<vtkm::Float32>(4);
//Test3D<vtkm::Int64>(4);
//Test3D<vtkm::Int32>(4);
}
int UnitTestZFPCompressor(int, char* [])

6
vtkm/worklet/zfp/ZFPBlockWriter.h
View File

@ -54,6 +54,7 @@ struct BlockWriter
{
m_word_index = (block_idx * maxbits) / (sizeof(Word) * 8);
// debug_index = m_word_index;
//std::cout<<"** Block "<<block_idx<<" start "<<m_word_index<<"\n";
m_start_bit = vtkm::Int32((block_idx * maxbits) % (sizeof(Word) * 8));
}
@ -88,6 +89,7 @@ struct BlockWriter
{
UIntInt newval;
UIntInt old;
(void)old;
newval.uintpart = value;
Portal.Add(index, newval.intpart);
//old.uintpart = 0;
@ -102,7 +104,7 @@ struct BlockWriter
inline VTKM_EXEC
//void write_bits(const unsigned int &bits, const uint &n_bits, const uint &bit_offset)
vtkm::Int32
vtkm::UInt64
write_bits(const vtkm::UInt64& bits, const uint& n_bits)
{
//std::cout<<"write nbits "<<n_bits<<" "<<m_current_bit<<"\n";
@ -148,7 +150,7 @@ struct BlockWriter
//debug_index = write_index +1;
}
m_current_bit += n_bits;
return vtkm::Int32(bits >> (Word)n_bits);
return bits >> (Word)n_bits;
}
// TODO: optimize

46
vtkm/worklet/zfp/ZFPEncode3.h
View File

@ -101,8 +101,6 @@ public:
const InputScalarPortal& scalars,
BitstreamPortal& stream) const
{
std::cout << "****************************************\n";
(void)stream;
using Scalar = typename InputScalarPortal::ValueType;
constexpr vtkm::Int32 BlockSize = 64;
Scalar fblock[BlockSize];
@ -128,45 +126,33 @@ public:
partial = true;
if (logicalStart[2] + 4 > Dims[2])
partial = true;
std::cout << "Dims " << Dims << "\n";
//std::cout<<"Dims "<<Dims<<"\n";
if (partial)
{
const vtkm::Int32 nx = logicalStart[0] + 4 > Dims[0] ? Dims[0] - logicalStart[0] : 4;
const vtkm::Int32 ny = logicalStart[1] + 4 > Dims[1] ? Dims[1] - logicalStart[1] : 4;
const vtkm::Int32 nz = logicalStart[2] + 4 > Dims[2] ? Dims[2] - logicalStart[2] : 4;
std::cout << "Partial block " << logicalStart << " offset " << offset << "\n";
std::cout << "Nx " << nx << " " << ny << " " << nz << "\n";
const vtkm::Int32 nx =
logicalStart[0] + 4 > Dims[0] ? Dims[0] - logicalStart[0] : vtkm::Int32(4);
const vtkm::Int32 ny =
logicalStart[1] + 4 > Dims[1] ? Dims[1] - logicalStart[1] : vtkm::Int32(4);
const vtkm::Int32 nz =
logicalStart[2] + 4 > Dims[2] ? Dims[2] - logicalStart[2] : vtkm::Int32(4);
//std::cout<<"Partial block "<<logicalStart<<" offset "<<offset<<"\n";
//std::cout<<"Nx "<<nx<<" "<<ny<<" "<<nz<<"\n";
GatherPartial3(fblock, scalars, Dims, offset, nx, ny, nz);
}
else
{
std::cout << "FULL block " << zfpBlock << "\n";
//std::cout<<"FULL block "<<zfpBlock<<"\n";
Gather3(fblock, scalars, Dims, offset);
}
//for(int i = 0; i < 64; ++i) std::cout<< fblock[i]<<" ";
//for(int i = 0; i < 64; ++i)
//{
// std::cout<<" "<<fblock[i];
//}
//std::cout<<"\n";
// encode block
vtkm::Int32 emax = zfp::MaxExponent<BlockSize, Scalar>(fblock);
vtkm::Int32 maxprec =
zfp::precision(emax, zfp::get_precision<Scalar>(), zfp::get_min_exp<Scalar>());
vtkm::UInt32 e = maxprec ? emax + zfp::get_ebias<Scalar>() : 0;
zfp::ZFPBlockEncoder<BlockSize, Scalar, BitstreamPortal> encoder;
zfp::BlockWriter<BlockSize, BitstreamPortal> blockWriter(stream, MaxBits, blockIdx);
//blockWriter.print();
const vtkm::UInt32 ebits = zfp::get_ebits<Scalar>() + 1;
blockWriter.write_bits(2 * e + 1, ebits);
//std::cout<<"EBITS "<<ebits<<"\n";
//std::cout<<"Max exponent "<<2*e+1<<" emax "<<emax<<" maxprec "<<maxprec<<" e "<<e<<"\n";
//zfp::print_bits(2*e+1);
//blockWriter.print();
using Int = typename zfp::zfp_traits<Scalar>::Int;
Int iblock[BlockSize];
zfp::fwd_cast<Int, Scalar, BlockSize>(iblock, fblock, emax);
zfp::encode_block<BitstreamPortal, Scalar, Int, BlockSize>(
blockWriter, iblock, maxprec, MaxBits - ebits);
encoder.encode(fblock, MaxBits, blockIdx, stream);
//blockWriter.print(0);
//blockWriter.print(1);
}

119
vtkm/worklet/zfp/ZFPFunctions.h
View File

@ -86,11 +86,11 @@ template <typename Int, typename Scalar, vtkm::Int32 BlockSize>
inline VTKM_EXEC void fwd_cast(Int* iblock, const Scalar* fblock, vtkm::Int32 emax)
{
Scalar s = quantize<Scalar>(1, emax);
//std::cout<<"EMAX "<<emax<<" q "<<s<<"\n";
std::cout << "EMAX " << emax << " q " << s << "\n";
for (vtkm::Int32 i = 0; i < BlockSize; ++i)
{
iblock[i] = static_cast<Int>(s * fblock[i]);
//std::cout<<i<<" f = "<<fblock[i]<<" i = "<<(vtkm::UInt64)iblock[i]<<"\n";
std::cout << i << " f = " << fblock[i] << " i = " << (vtkm::UInt64)iblock[i] << "\n";
}
}
@ -219,30 +219,23 @@ void print_bits(T bits)
printf("\n");
}
template <typename PortalType, typename Scalar, typename Int, vtkm::Int32 BlockSize>
inline VTKM_EXEC void encode_block(BlockWriter<BlockSize, PortalType>& stream,
Int* iblock,
vtkm::Int32 maxprec,
vtkm::Int32 maxbits)
template <vtkm::Int32 BlockSize, typename PortalType, typename Int>
VTKM_EXEC void encode_block(BlockWriter<BlockSize, PortalType>& stream,
vtkm::Int32 maxbits,
vtkm::Int32 maxprec,
Int* iblock)
{
//std::cout<<"Incoming stream \n";
//stream.print();
using UInt = typename zfp::zfp_traits<Scalar>::UInt;
using UInt = typename zfp_traits<Int>::UInt;
fwd_xform<Int, BlockSize>(iblock);
UInt ublock[BlockSize];
fwd_order<UInt, Int, BlockSize>(ublock, iblock);
//for(int i = 0; i < 64; ++i)
//for(int i = 0; i < BlockSize; ++i)
//{
// std::cout<<"iblock "<<i<<" "<<(vtkm::UInt64)iblock[i]<<"\n";
//}
//for(int i = 0; i < 64; ++i)
//{
// std::cout<<"ublock "<<i<<" "<<ublock[i]<<"\n";
// std::cout<<"tid "<<i<<" --> nb "<<ublock[i]<<"\n";
//}
//bitstream s = *stream;
vtkm::UInt32 intprec = CHAR_BIT * (vtkm::UInt32)sizeof(UInt);
vtkm::UInt32 kmin = intprec > (vtkm::UInt32)maxprec ? intprec - maxprec : 0;
vtkm::UInt32 bits = maxbits;
@ -266,6 +259,8 @@ inline VTKM_EXEC void encode_block(BlockWriter<BlockSize, PortalType>& stream,
//std::cout<<"Bits left "<<bits<<" m "<<m<<"\n";
x = stream.write_bits(x, m);
//std::cout<<"Wrote m "<<m<<" bits\n";
//vtkm::UInt32 temp = bits;
//std::cout<<"rem bitplane "<<x<<"\n";
/* step 3: unary run-length encode remainder of bit plane */
for (; n < BlockSize && bits && (bits--, stream.write_bit(!!x)); x >>= 1, n++)
{
@ -275,14 +270,98 @@ inline VTKM_EXEC void encode_block(BlockWriter<BlockSize, PortalType>& stream,
//std::cout<<"n "<<n<<" bits "<<bits<<"\n";
}
}
//temp = temp - bits;
//std::cout<<"rem bits "<<bits<<" intprec "<<intprec<<" k "<<k<<" encoded_bits "<<temp<<"\n";
//stream.print();
}
//*stream = s;
//return maxbits - bits;
}
template <vtkm::Int32 BlockSize, typename Scalar, typename PortalType>
inline VTKM_EXEC void zfp_encodef(Scalar* fblock,
vtkm::Int32 maxbits,
vtkm::UInt32 blockIdx,
PortalType& stream)
{
using Int = typename zfp::zfp_traits<Scalar>::Int;
zfp::BlockWriter<BlockSize, PortalType> blockWriter(stream, maxbits, blockIdx);
vtkm::Int32 emax = zfp::MaxExponent<BlockSize, Scalar>(fblock);
vtkm::Int32 maxprec =
zfp::precision(emax, zfp::get_precision<Scalar>(), zfp::get_min_exp<Scalar>());
vtkm::UInt32 e = maxprec ? emax + zfp::get_ebias<Scalar>() : 0;
/* encode block only if biased exponent is nonzero */
if (e)
{
const vtkm::UInt32 ebits = zfp::get_ebits<Scalar>() + 1;
blockWriter.write_bits(2 * e + 1, ebits);
Int iblock[BlockSize];
zfp::fwd_cast<Int, Scalar, BlockSize>(iblock, fblock, emax);
encode_block<BlockSize>(blockWriter, maxbits - ebits, maxprec, iblock);
}
}
// helpers so we can do partial template instantiation since
// the portal type could be on any backend
template <vtkm::Int32 BlockSize, typename Scalar, typename PortalType>
struct ZFPBlockEncoder
{
};
template <vtkm::Int32 BlockSize, typename PortalType>
struct ZFPBlockEncoder<BlockSize, vtkm::Float32, PortalType>
{
VTKM_EXEC void encode(vtkm::Float32* fblock,
vtkm::Int32 maxbits,
vtkm::UInt32 blockIdx,
PortalType& stream)
{
zfp_encodef<BlockSize>(fblock, maxbits, blockIdx, stream);
}
};
template <vtkm::Int32 BlockSize, typename PortalType>
struct ZFPBlockEncoder<BlockSize, vtkm::Float64, PortalType>
{
VTKM_EXEC void encode(vtkm::Float64* fblock,
vtkm::Int32 maxbits,
vtkm::UInt32 blockIdx,
PortalType& stream)
{
zfp_encodef<BlockSize>(fblock, maxbits, blockIdx, stream);
}
};
template <vtkm::Int32 BlockSize, typename PortalType>
struct ZFPBlockEncoder<BlockSize, vtkm::Int32, PortalType>
{
VTKM_EXEC void encode(vtkm::Int32* fblock,
vtkm::Int32 maxbits,
vtkm::UInt32 blockIdx,
PortalType& stream)
{
using Int = typename zfp::zfp_traits<vtkm::Int32>::Int;
zfp::BlockWriter<BlockSize, PortalType> blockWriter(stream, maxbits, blockIdx);
encode_block<BlockSize>(blockWriter, maxbits, get_precision<vtkm::Int32>(), (Int*)fblock);
}
};
template <vtkm::Int32 BlockSize, typename PortalType>
struct ZFPBlockEncoder<BlockSize, vtkm::Int64, PortalType>
{
VTKM_EXEC void encode(vtkm::Int64* fblock,
vtkm::Int32 maxbits,
vtkm::UInt32 blockIdx,
PortalType& stream)
{
using Int = typename zfp::zfp_traits<vtkm::Int64>::Int;
zfp::BlockWriter<BlockSize, PortalType> blockWriter(stream, maxbits, blockIdx);
encode_block<BlockSize>(blockWriter, maxbits, get_precision<vtkm::Int64>(), (Int*)fblock);
}
};
} // namespace zfp
} // namespace worklet

24
vtkm/worklet/zfp/ZFPTypeInfo.h
View File

@ -144,6 +144,30 @@ inline VTKM_EXEC int scalar_sizeof<int>()
return 4;
}
template <typename T>
inline VTKM_EXEC bool is_float();
template <>
inline VTKM_EXEC bool is_float<double>()
{
return true;
}
template <>
inline VTKM_EXEC bool is_float<long long int>()
{
return true;
}
template <>
inline VTKM_EXEC bool is_float<float>()
{
return false;
}
template <>
inline VTKM_EXEC bool is_float<int>()
{
return false;
}
template <typename T>
struct zfp_traits;