public class nvcomp extends nvcomp
Modifier and Type | Field and Description |
---|---|
static int |
ComputeAndNoVerify
enum ChecksumPolicy
|
static int |
ComputeAndVerify
enum ChecksumPolicy
|
static int |
ComputeAndVerifyIfPresent
enum ChecksumPolicy
|
static int |
NoComputeAndVerifyIfPresent
enum ChecksumPolicy
|
static int |
NoComputeNoVerify
enum ChecksumPolicy
|
static int |
NVCOMP_MAJOR_VERSION
CONSTANTS ******************************************************************
|
static int |
NVCOMP_MINOR_VERSION |
static int |
NVCOMP_PATCH_VERSION |
static int |
nvcomp_rANS
enum nvcompANSType_t
|
static int |
NVCOMP_TYPE_BITS
enum nvcompType_t
|
static int |
NVCOMP_TYPE_CHAR
enum nvcompType_t
|
static int |
NVCOMP_TYPE_INT
enum nvcompType_t
|
static int |
NVCOMP_TYPE_LONGLONG
enum nvcompType_t
|
static int |
NVCOMP_TYPE_SHORT
enum nvcompType_t
|
static int |
NVCOMP_TYPE_UCHAR
enum nvcompType_t
|
static int |
NVCOMP_TYPE_UINT
enum nvcompType_t
|
static int |
NVCOMP_TYPE_ULONGLONG
enum nvcompType_t
|
static int |
NVCOMP_TYPE_USHORT
enum nvcompType_t
|
static int |
nvcompErrorAlignment
enum nvcompStatus_t
|
static int |
nvcompErrorBadChecksum
enum nvcompStatus_t
|
static int |
nvcompErrorCannotDecompress
enum nvcompStatus_t
|
static int |
nvcompErrorCannotVerifyChecksums
enum nvcompStatus_t
|
static int |
nvcompErrorChunkSizeTooLarge
enum nvcompStatus_t
|
static int |
nvcompErrorCudaError
enum nvcompStatus_t
|
static int |
nvcompErrorInternal
enum nvcompStatus_t
|
static int |
nvcompErrorInvalidValue
enum nvcompStatus_t
|
static int |
nvcompErrorNotSupported
enum nvcompStatus_t
|
static int |
nvcompErrorOutputBufferTooSmall
enum nvcompStatus_t
|
static int |
nvcompErrorWrongHeaderLength
enum nvcompStatus_t
|
static int |
nvcompSuccess
enum nvcompStatus_t
|
Constructor and Description |
---|
nvcomp() |
Modifier and Type | Method and Description |
---|---|
static nvcompManagerBase |
create_manager(byte[] comp_buffer) |
static nvcompManagerBase |
create_manager(byte[] comp_buffer,
CUstream_st stream,
int device_id,
int checksum_policy) |
static nvcompManagerBase |
create_manager(ByteBuffer comp_buffer) |
static nvcompManagerBase |
create_manager(ByteBuffer comp_buffer,
CUstream_st stream,
int device_id,
int checksum_policy) |
static nvcompManagerBase |
create_manager(BytePointer comp_buffer) |
static nvcompManagerBase |
create_manager(BytePointer comp_buffer,
CUstream_st stream,
int device_id,
int checksum_policy)
\brief Construct a ManagerBase from a buffer
This synchronizes the stream
|
static long |
nvcompANSCompressionMaxAllowedChunkSize() |
static long |
nvcompANSRequiredAlignment()
This is the minimum alignment required for void type CUDA memory buffers
passed to compression or decompression functions.
|
static int |
nvcompBatchedANSCompressAsync(PointerPointer device_uncompressed_ptrs,
SizeTPointer device_uncompressed_bytes,
long max_uncompressed_chunk_bytes,
long batch_size,
Pointer device_temp_ptr,
long temp_bytes,
PointerPointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
nvcompBatchedANSOpts_t format_opts,
CUstream_st stream)
\brief Perform compression.
|
static int |
nvcompBatchedANSCompressAsync(Pointer device_uncompressed_ptrs,
SizeTPointer device_uncompressed_bytes,
long max_uncompressed_chunk_bytes,
long batch_size,
Pointer device_temp_ptr,
long temp_bytes,
Pointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
nvcompBatchedANSOpts_t format_opts,
CUstream_st stream) |
static int |
nvcompBatchedANSCompressGetMaxOutputChunkSize(long max_chunk_size,
nvcompBatchedANSOpts_t format_opts,
SizeTPointer max_compressed_size)
\brief Get the maximum size any chunk could compress to in the batch.
|
static int |
nvcompBatchedANSCompressGetTempSize(long batch_size,
long max_uncompressed_chunk_bytes,
nvcompBatchedANSOpts_t format_opts,
SizeTPointer temp_bytes)
\brief Get temporary space required for compression.
|
static int |
nvcompBatchedANSCompressGetTempSizeEx(long batch_size,
long max_uncompressed_chunk_bytes,
nvcompBatchedANSOpts_t format_opts,
SizeTPointer temp_bytes,
long max_total_uncompressed_bytes)
\brief Get temporary space required for compression.
|
static int |
nvcompBatchedANSDecompressAsync(PointerPointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
SizeTPointer device_actual_uncompressed_bytes,
long batch_size,
Pointer device_temp_ptr,
long temp_bytes,
PointerPointer device_uncompressed_ptrs,
IntPointer device_statuses,
CUstream_st stream)
\brief Perform decompression.
|
static int |
nvcompBatchedANSDecompressAsync(Pointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
SizeTPointer device_actual_uncompressed_bytes,
long batch_size,
Pointer device_temp_ptr,
long temp_bytes,
Pointer device_uncompressed_ptrs,
int[] device_statuses,
CUstream_st stream) |
static int |
nvcompBatchedANSDecompressAsync(Pointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
SizeTPointer device_actual_uncompressed_bytes,
long batch_size,
Pointer device_temp_ptr,
long temp_bytes,
Pointer device_uncompressed_ptrs,
IntBuffer device_statuses,
CUstream_st stream) |
static int |
nvcompBatchedANSDecompressAsync(Pointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
SizeTPointer device_actual_uncompressed_bytes,
long batch_size,
Pointer device_temp_ptr,
long temp_bytes,
Pointer device_uncompressed_ptrs,
IntPointer device_statuses,
CUstream_st stream) |
static int |
nvcompBatchedANSDecompressGetTempSize(long num_chunks,
long max_uncompressed_chunk_bytes,
SizeTPointer temp_bytes)
\brief Get the amount of temp space required on the GPU for decompression.
|
static int |
nvcompBatchedANSDecompressGetTempSizeEx(long num_chunks,
long max_uncompressed_chunk_bytes,
SizeTPointer temp_bytes,
long max_uncompressed_total_size)
\brief Get the amount of temp space required on the GPU for decompression with extra total size argument.
|
static nvcompBatchedANSOpts_t |
nvcompBatchedANSDefaultOpts() |
static int |
nvcompBatchedANSGetDecompressSizeAsync(PointerPointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
long batch_size,
CUstream_st stream)
\brief Compute uncompressed sizes.
|
static int |
nvcompBatchedANSGetDecompressSizeAsync(Pointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
long batch_size,
CUstream_st stream) |
static int |
nvcompBatchedBitcompCompressAsync(PointerPointer device_uncompressed_ptrs,
SizeTPointer device_uncompressed_bytes,
long max_uncompressed_chunk_bytes,
long batch_size,
Pointer device_temp_ptr,
long temp_bytes,
PointerPointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
nvcompBatchedBitcompFormatOpts format_opts,
CUstream_st stream)
\brief Perform batched asynchronous compression.
|
static int |
nvcompBatchedBitcompCompressAsync(Pointer device_uncompressed_ptrs,
SizeTPointer device_uncompressed_bytes,
long max_uncompressed_chunk_bytes,
long batch_size,
Pointer device_temp_ptr,
long temp_bytes,
Pointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
nvcompBatchedBitcompFormatOpts format_opts,
CUstream_st stream) |
static int |
nvcompBatchedBitcompCompressGetMaxOutputChunkSize(long max_chunk_size,
nvcompBatchedBitcompFormatOpts format_opts,
SizeTPointer max_compressed_size)
\brief Get the maximum size any chunk could compress to in the batch.
|
static int |
nvcompBatchedBitcompCompressGetTempSize(long batch_size,
long max_uncompressed_chunk_bytes,
nvcompBatchedBitcompFormatOpts format_opts,
SizeTPointer temp_bytes)
\brief Return the temp size needed for Bitcomp compression.
|
static int |
nvcompBatchedBitcompCompressGetTempSizeEx(long batch_size,
long max_uncompressed_chunk_bytes,
nvcompBatchedBitcompFormatOpts format_opts,
SizeTPointer temp_bytes,
long max_total_uncompressed_bytes)
\brief Return the temp size needed for Bitcomp compression.
|
static int |
nvcompBatchedBitcompDecompressAsync(PointerPointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
SizeTPointer device_actual_uncompressed_bytes,
long batch_size,
Pointer device_temp_ptr,
long temp_bytes,
PointerPointer device_uncompressed_ptrs,
IntPointer device_statuses,
CUstream_st stream)
\brief Perform batched asynchronous decompression.
|
static int |
nvcompBatchedBitcompDecompressAsync(Pointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
SizeTPointer device_actual_uncompressed_bytes,
long batch_size,
Pointer device_temp_ptr,
long temp_bytes,
Pointer device_uncompressed_ptrs,
int[] device_statuses,
CUstream_st stream) |
static int |
nvcompBatchedBitcompDecompressAsync(Pointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
SizeTPointer device_actual_uncompressed_bytes,
long batch_size,
Pointer device_temp_ptr,
long temp_bytes,
Pointer device_uncompressed_ptrs,
IntBuffer device_statuses,
CUstream_st stream) |
static int |
nvcompBatchedBitcompDecompressAsync(Pointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
SizeTPointer device_actual_uncompressed_bytes,
long batch_size,
Pointer device_temp_ptr,
long temp_bytes,
Pointer device_uncompressed_ptrs,
IntPointer device_statuses,
CUstream_st stream) |
static int |
nvcompBatchedBitcompDecompressGetTempSize(long batch_size,
long max_chunk_bytes,
SizeTPointer temp_bytes)
\brief Return the temp size needed for Bitcomp decompression.
|
static int |
nvcompBatchedBitcompDecompressGetTempSizeEx(long batch_size,
long max_chunk_bytes,
SizeTPointer temp_bytes,
long max_uncompressed_total_size)
\brief Return the temp size needed for Bitcomp decompression.
|
static nvcompBatchedBitcompFormatOpts |
nvcompBatchedBitcompDefaultOpts()
\brief Checks if the compressed data was compressed with bitcomp.
|
static int |
nvcompBatchedBitcompGetDecompressSizeAsync(PointerPointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
long batch_size,
CUstream_st stream)
\brief Asynchronously get the number of bytes of the uncompressed data in
every partitions.
|
static int |
nvcompBatchedBitcompGetDecompressSizeAsync(Pointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
long batch_size,
CUstream_st stream) |
static int |
nvcompBatchedCascadedCompressAsync(PointerPointer device_uncompressed_ptrs,
SizeTPointer device_uncompressed_bytes,
long max_uncompressed_chunk_bytes,
long batch_size,
Pointer device_temp_ptr,
long temp_bytes,
PointerPointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
nvcompBatchedCascadedOpts_t format_opts,
CUstream_st stream)
\brief Perform batched asynchronous compression.
|
static int |
nvcompBatchedCascadedCompressAsync(Pointer device_uncompressed_ptrs,
SizeTPointer device_uncompressed_bytes,
long max_uncompressed_chunk_bytes,
long batch_size,
Pointer device_temp_ptr,
long temp_bytes,
Pointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
nvcompBatchedCascadedOpts_t format_opts,
CUstream_st stream) |
static int |
nvcompBatchedCascadedCompressGetMaxOutputChunkSize(long max_uncompressed_chunk_bytes,
nvcompBatchedCascadedOpts_t format_opts,
SizeTPointer max_compressed_bytes)
\brief Get the maximum size any chunk could compress to in the batch.
|
static int |
nvcompBatchedCascadedCompressGetTempSize(long batch_size,
long max_uncompressed_chunk_bytes,
nvcompBatchedCascadedOpts_t format_opts,
SizeTPointer temp_bytes)
\brief Get temporary space required for compression.
|
static int |
nvcompBatchedCascadedCompressGetTempSizeEx(long batch_size,
long max_uncompressed_chunk_bytes,
nvcompBatchedCascadedOpts_t format_opts,
SizeTPointer temp_bytes,
long max_total_uncompressed_bytes)
\brief Get temporary space required for compression.
|
static int |
nvcompBatchedCascadedDecompressAsync(PointerPointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
SizeTPointer device_actual_uncompressed_bytes,
long batch_size,
Pointer device_temp_ptr,
long temp_bytes,
PointerPointer device_uncompressed_ptrs,
IntPointer device_statuses,
CUstream_st stream)
\brief Perform batched asynchronous decompression.
|
static int |
nvcompBatchedCascadedDecompressAsync(Pointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
SizeTPointer device_actual_uncompressed_bytes,
long batch_size,
Pointer device_temp_ptr,
long temp_bytes,
Pointer device_uncompressed_ptrs,
int[] device_statuses,
CUstream_st stream) |
static int |
nvcompBatchedCascadedDecompressAsync(Pointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
SizeTPointer device_actual_uncompressed_bytes,
long batch_size,
Pointer device_temp_ptr,
long temp_bytes,
Pointer device_uncompressed_ptrs,
IntBuffer device_statuses,
CUstream_st stream) |
static int |
nvcompBatchedCascadedDecompressAsync(Pointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
SizeTPointer device_actual_uncompressed_bytes,
long batch_size,
Pointer device_temp_ptr,
long temp_bytes,
Pointer device_uncompressed_ptrs,
IntPointer device_statuses,
CUstream_st stream) |
static int |
nvcompBatchedCascadedDecompressGetTempSize(long num_chunks,
long max_uncompressed_chunk_bytes,
SizeTPointer temp_bytes)
\brief Get the amount of temp space required on the GPU for decompression.
|
static int |
nvcompBatchedCascadedDecompressGetTempSizeEx(long num_chunks,
long max_uncompressed_chunk_bytes,
SizeTPointer temp_bytes,
long max_uncompressed_total_size)
\brief Get the amount of temp space required on the GPU for decompression.
|
static nvcompBatchedCascadedOpts_t |
nvcompBatchedCascadedDefaultOpts() |
static int |
nvcompBatchedCascadedGetDecompressSizeAsync(PointerPointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
long batch_size,
CUstream_st stream)
\brief Asynchronously get the number of bytes of the uncompressed data in
every partitions.
|
static int |
nvcompBatchedCascadedGetDecompressSizeAsync(Pointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
long batch_size,
CUstream_st stream) |
static int |
nvcompBatchedCRC32Async(PointerPointer device_uncompressed_ptrs,
SizeTPointer device_uncompressed_bytes,
long batch_size,
IntPointer device_CRC32_ptrs,
CUstream_st stream)
\brief Perform CRC32 checksum calculation asynchronously.
|
static int |
nvcompBatchedCRC32Async(Pointer device_uncompressed_ptrs,
SizeTPointer device_uncompressed_bytes,
long batch_size,
int[] device_CRC32_ptrs,
CUstream_st stream) |
static int |
nvcompBatchedCRC32Async(Pointer device_uncompressed_ptrs,
SizeTPointer device_uncompressed_bytes,
long batch_size,
IntBuffer device_CRC32_ptrs,
CUstream_st stream) |
static int |
nvcompBatchedCRC32Async(Pointer device_uncompressed_ptrs,
SizeTPointer device_uncompressed_bytes,
long batch_size,
IntPointer device_CRC32_ptrs,
CUstream_st stream) |
static int |
nvcompBatchedDeflateCompressAsync(PointerPointer device_uncompressed_ptrs,
SizeTPointer device_uncompressed_bytes,
long max_uncompressed_chunk_bytes,
long batch_size,
Pointer device_temp_ptr,
long temp_bytes,
PointerPointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
nvcompBatchedDeflateOpts_t format_opts,
CUstream_st stream)
\brief Perform compression asynchronously.
|
static int |
nvcompBatchedDeflateCompressAsync(Pointer device_uncompressed_ptrs,
SizeTPointer device_uncompressed_bytes,
long max_uncompressed_chunk_bytes,
long batch_size,
Pointer device_temp_ptr,
long temp_bytes,
Pointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
nvcompBatchedDeflateOpts_t format_opts,
CUstream_st stream) |
static int |
nvcompBatchedDeflateCompressGetMaxOutputChunkSize(long max_uncompressed_chunk_bytes,
nvcompBatchedDeflateOpts_t format_opts,
SizeTPointer max_compressed_bytes)
\brief Get the maximum size any chunk could compress to in the batch.
|
static int |
nvcompBatchedDeflateCompressGetTempSize(long batch_size,
long max_uncompressed_chunk_bytes,
nvcompBatchedDeflateOpts_t format_opts,
SizeTPointer temp_bytes)
\brief Get temporary space required for compression.
|
static int |
nvcompBatchedDeflateCompressGetTempSizeEx(long batch_size,
long max_uncompressed_chunk_bytes,
nvcompBatchedDeflateOpts_t format_opts,
SizeTPointer temp_bytes,
long max_total_uncompressed_bytes)
\brief Get temporary space required for compression.
|
static int |
nvcompBatchedDeflateDecompressAsync(PointerPointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
SizeTPointer device_actual_uncompressed_bytes,
long batch_size,
Pointer device_temp_ptr,
long temp_bytes,
PointerPointer device_uncompressed_ptrs,
IntPointer device_statuses,
CUstream_st stream)
\brief Perform decompression asynchronously.
|
static int |
nvcompBatchedDeflateDecompressAsync(Pointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
SizeTPointer device_actual_uncompressed_bytes,
long batch_size,
Pointer device_temp_ptr,
long temp_bytes,
Pointer device_uncompressed_ptrs,
int[] device_statuses,
CUstream_st stream) |
static int |
nvcompBatchedDeflateDecompressAsync(Pointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
SizeTPointer device_actual_uncompressed_bytes,
long batch_size,
Pointer device_temp_ptr,
long temp_bytes,
Pointer device_uncompressed_ptrs,
IntBuffer device_statuses,
CUstream_st stream) |
static int |
nvcompBatchedDeflateDecompressAsync(Pointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
SizeTPointer device_actual_uncompressed_bytes,
long batch_size,
Pointer device_temp_ptr,
long temp_bytes,
Pointer device_uncompressed_ptrs,
IntPointer device_statuses,
CUstream_st stream) |
static int |
nvcompBatchedDeflateDecompressGetTempSize(long num_chunks,
long max_uncompressed_chunk_bytes,
SizeTPointer temp_bytes)
\brief Get the amount of temp space required on the GPU for decompression.
|
static int |
nvcompBatchedDeflateDecompressGetTempSizeEx(long num_chunks,
long max_uncompressed_chunk_bytes,
SizeTPointer temp_bytes,
long max_uncompressed_total_size)
\brief Get the amount of temp space required on the GPU for decompression.
|
static nvcompBatchedDeflateOpts_t |
nvcompBatchedDeflateDefaultOpts() |
static int |
nvcompBatchedDeflateGetDecompressSizeAsync(PointerPointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
long batch_size,
CUstream_st stream)
\brief Calculates the decompressed size of each chunk asynchronously.
|
static int |
nvcompBatchedDeflateGetDecompressSizeAsync(Pointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
long batch_size,
CUstream_st stream) |
static int |
nvcompBatchedGdeflateCompressAsync(PointerPointer device_uncompressed_ptrs,
SizeTPointer device_uncompressed_bytes,
long max_uncompressed_chunk_bytes,
long batch_size,
Pointer device_temp_ptr,
long temp_bytes,
PointerPointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
nvcompBatchedGdeflateOpts_t format_opts,
CUstream_st stream)
\brief Perform compression asynchronously.
|
static int |
nvcompBatchedGdeflateCompressAsync(Pointer device_uncompressed_ptrs,
SizeTPointer device_uncompressed_bytes,
long max_uncompressed_chunk_bytes,
long batch_size,
Pointer device_temp_ptr,
long temp_bytes,
Pointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
nvcompBatchedGdeflateOpts_t format_opts,
CUstream_st stream) |
static int |
nvcompBatchedGdeflateCompressGetMaxOutputChunkSize(long max_uncompressed_chunk_bytes,
nvcompBatchedGdeflateOpts_t format_opts,
SizeTPointer max_compressed_bytes)
\brief Get the maximum size any chunk could compress to in the batch.
|
static int |
nvcompBatchedGdeflateCompressGetTempSize(long batch_size,
long max_uncompressed_chunk_bytes,
nvcompBatchedGdeflateOpts_t format_opts,
SizeTPointer temp_bytes)
\brief Get temporary space required for compression.
|
static int |
nvcompBatchedGdeflateCompressGetTempSizeEx(long batch_size,
long max_uncompressed_chunk_bytes,
nvcompBatchedGdeflateOpts_t format_opts,
SizeTPointer temp_bytes,
long max_total_uncompressed_bytes)
\brief Get temporary space required for compression.
|
static int |
nvcompBatchedGdeflateDecompressAsync(PointerPointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
SizeTPointer device_actual_uncompressed_bytes,
long batch_size,
Pointer device_temp_ptr,
long temp_bytes,
PointerPointer device_uncompressed_ptrs,
IntPointer device_statuses,
CUstream_st stream)
\brief Perform decompression asynchronously.
|
static int |
nvcompBatchedGdeflateDecompressAsync(Pointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
SizeTPointer device_actual_uncompressed_bytes,
long batch_size,
Pointer device_temp_ptr,
long temp_bytes,
Pointer device_uncompressed_ptrs,
int[] device_statuses,
CUstream_st stream) |
static int |
nvcompBatchedGdeflateDecompressAsync(Pointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
SizeTPointer device_actual_uncompressed_bytes,
long batch_size,
Pointer device_temp_ptr,
long temp_bytes,
Pointer device_uncompressed_ptrs,
IntBuffer device_statuses,
CUstream_st stream) |
static int |
nvcompBatchedGdeflateDecompressAsync(Pointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
SizeTPointer device_actual_uncompressed_bytes,
long batch_size,
Pointer device_temp_ptr,
long temp_bytes,
Pointer device_uncompressed_ptrs,
IntPointer device_statuses,
CUstream_st stream) |
static int |
nvcompBatchedGdeflateDecompressGetTempSize(long num_chunks,
long max_uncompressed_chunk_bytes,
SizeTPointer temp_bytes)
\brief Get the amount of temp space required on the GPU for decompression.
|
static int |
nvcompBatchedGdeflateDecompressGetTempSizeEx(long num_chunks,
long max_uncompressed_chunk_bytes,
SizeTPointer temp_bytes,
long max_uncompressed_total_size)
\brief Get the amount of temp space required on the GPU for decompression.
|
static nvcompBatchedGdeflateOpts_t |
nvcompBatchedGdeflateDefaultOpts() |
static int |
nvcompBatchedGdeflateGetDecompressSizeAsync(PointerPointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
long batch_size,
CUstream_st stream)
\brief Calculates the decompressed size of each chunk asynchronously.
|
static int |
nvcompBatchedGdeflateGetDecompressSizeAsync(Pointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
long batch_size,
CUstream_st stream) |
static int |
nvcompBatchedGzipDecompressAsync(PointerPointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
SizeTPointer device_actual_uncompressed_bytes,
long batch_size,
Pointer device_temp_ptr,
long temp_bytes,
PointerPointer device_uncompressed_ptrs,
IntPointer device_statuses,
CUstream_st stream)
\brief Perform decompression asynchronously.
|
static int |
nvcompBatchedGzipDecompressAsync(Pointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
SizeTPointer device_actual_uncompressed_bytes,
long batch_size,
Pointer device_temp_ptr,
long temp_bytes,
Pointer device_uncompressed_ptrs,
int[] device_statuses,
CUstream_st stream) |
static int |
nvcompBatchedGzipDecompressAsync(Pointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
SizeTPointer device_actual_uncompressed_bytes,
long batch_size,
Pointer device_temp_ptr,
long temp_bytes,
Pointer device_uncompressed_ptrs,
IntBuffer device_statuses,
CUstream_st stream) |
static int |
nvcompBatchedGzipDecompressAsync(Pointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
SizeTPointer device_actual_uncompressed_bytes,
long batch_size,
Pointer device_temp_ptr,
long temp_bytes,
Pointer device_uncompressed_ptrs,
IntPointer device_statuses,
CUstream_st stream) |
static int |
nvcompBatchedGzipDecompressGetTempSize(long num_chunks,
long max_uncompressed_chunk_bytes,
SizeTPointer temp_bytes)
\brief Get the amount of temp space required on the GPU for decompression.
|
static int |
nvcompBatchedGzipDecompressGetTempSizeEx(long num_chunks,
long max_uncompressed_chunk_bytes,
SizeTPointer temp_bytes,
long max_uncompressed_total_size)
\brief Get the amount of temp space required on the GPU for decompression.
|
static int |
nvcompBatchedGzipGetDecompressSizeAsync(PointerPointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
long batch_size,
CUstream_st stream)
\brief Calculates the decompressed size of each chunk asynchronously.
|
static int |
nvcompBatchedGzipGetDecompressSizeAsync(Pointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
long batch_size,
CUstream_st stream) |
static int |
nvcompBatchedLZ4CompressAsync(PointerPointer device_uncompressed_ptrs,
SizeTPointer device_uncompressed_bytes,
long max_uncompressed_chunk_bytes,
long batch_size,
Pointer device_temp_ptr,
long temp_bytes,
PointerPointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
nvcompBatchedLZ4Opts_t format_opts,
CUstream_st stream)
\brief Perform compression asynchronously.
|
static int |
nvcompBatchedLZ4CompressAsync(Pointer device_uncompressed_ptrs,
SizeTPointer device_uncompressed_bytes,
long max_uncompressed_chunk_bytes,
long batch_size,
Pointer device_temp_ptr,
long temp_bytes,
Pointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
nvcompBatchedLZ4Opts_t format_opts,
CUstream_st stream) |
static int |
nvcompBatchedLZ4CompressGetMaxOutputChunkSize(long max_uncompressed_chunk_bytes,
nvcompBatchedLZ4Opts_t format_opts,
SizeTPointer max_compressed_bytes)
\brief Get the maximum size any chunk could compress to in the batch.
|
static int |
nvcompBatchedLZ4CompressGetTempSize(long batch_size,
long max_uncompressed_chunk_bytes,
nvcompBatchedLZ4Opts_t format_opts,
SizeTPointer temp_bytes)
\brief Get temporary space required for compression.
|
static int |
nvcompBatchedLZ4CompressGetTempSizeEx(long batch_size,
long max_uncompressed_chunk_bytes,
nvcompBatchedLZ4Opts_t format_opts,
SizeTPointer temp_bytes,
long max_total_uncompressed_bytes)
\brief Get temporary space required for compression.
|
static int |
nvcompBatchedLZ4DecompressAsync(PointerPointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
SizeTPointer device_actual_uncompressed_bytes,
long batch_size,
Pointer device_temp_ptr,
long temp_bytes,
PointerPointer device_uncompressed_ptrs,
IntPointer device_statuses,
CUstream_st stream)
\brief Perform decompression asynchronously.
|
static int |
nvcompBatchedLZ4DecompressAsync(Pointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
SizeTPointer device_actual_uncompressed_bytes,
long batch_size,
Pointer device_temp_ptr,
long temp_bytes,
Pointer device_uncompressed_ptrs,
int[] device_statuses,
CUstream_st stream) |
static int |
nvcompBatchedLZ4DecompressAsync(Pointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
SizeTPointer device_actual_uncompressed_bytes,
long batch_size,
Pointer device_temp_ptr,
long temp_bytes,
Pointer device_uncompressed_ptrs,
IntBuffer device_statuses,
CUstream_st stream) |
static int |
nvcompBatchedLZ4DecompressAsync(Pointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
SizeTPointer device_actual_uncompressed_bytes,
long batch_size,
Pointer device_temp_ptr,
long temp_bytes,
Pointer device_uncompressed_ptrs,
IntPointer device_statuses,
CUstream_st stream) |
static int |
nvcompBatchedLZ4DecompressGetTempSize(long num_chunks,
long max_uncompressed_chunk_bytes,
SizeTPointer temp_bytes)
\brief Get the amount of temp space required on the GPU for decompression.
|
static int |
nvcompBatchedLZ4DecompressGetTempSizeEx(long num_chunks,
long max_uncompressed_chunk_bytes,
SizeTPointer temp_bytes,
long max_uncompressed_total_size)
\brief Get the amount of temp space required on the GPU for decompression.
|
static nvcompBatchedLZ4Opts_t |
nvcompBatchedLZ4DefaultOpts() |
static int |
nvcompBatchedLZ4GetDecompressSizeAsync(PointerPointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
long batch_size,
CUstream_st stream)
\brief Calculates the decompressed size of each chunk asynchronously.
|
static int |
nvcompBatchedLZ4GetDecompressSizeAsync(Pointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
long batch_size,
CUstream_st stream) |
static int |
nvcompBatchedSnappyCompressAsync(PointerPointer device_uncompressed_ptrs,
SizeTPointer device_uncompressed_bytes,
long max_uncompressed_chunk_bytes,
long batch_size,
Pointer device_temp_ptr,
long temp_bytes,
PointerPointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
nvcompBatchedSnappyOpts_t format_ops,
CUstream_st stream)
\brief Perform compression.
|
static int |
nvcompBatchedSnappyCompressAsync(Pointer device_uncompressed_ptrs,
SizeTPointer device_uncompressed_bytes,
long max_uncompressed_chunk_bytes,
long batch_size,
Pointer device_temp_ptr,
long temp_bytes,
Pointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
nvcompBatchedSnappyOpts_t format_ops,
CUstream_st stream) |
static int |
nvcompBatchedSnappyCompressGetMaxOutputChunkSize(long max_chunk_size,
nvcompBatchedSnappyOpts_t format_opts,
SizeTPointer max_compressed_size)
\brief Get the maximum size any chunk could compress to in the batch.
|
static int |
nvcompBatchedSnappyCompressGetTempSize(long batch_size,
long max_uncompressed_chunk_bytes,
nvcompBatchedSnappyOpts_t format_ops,
SizeTPointer temp_bytes)
\brief Get temporary space required for compression.
|
static int |
nvcompBatchedSnappyCompressGetTempSizeEx(long batch_size,
long max_uncompressed_chunk_bytes,
nvcompBatchedSnappyOpts_t format_ops,
SizeTPointer temp_bytes,
long max_total_uncompressed_bytes)
\brief Get temporary space required for compression.
|
static int |
nvcompBatchedSnappyDecompressAsync(PointerPointer device_compresed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
SizeTPointer device_actual_uncompressed_bytes,
long batch_size,
Pointer device_temp_ptr,
long temp_bytes,
PointerPointer device_uncompressed_ptrs,
IntPointer device_statuses,
CUstream_st stream)
\brief Perform decompression.
|
static int |
nvcompBatchedSnappyDecompressAsync(Pointer device_compresed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
SizeTPointer device_actual_uncompressed_bytes,
long batch_size,
Pointer device_temp_ptr,
long temp_bytes,
Pointer device_uncompressed_ptrs,
int[] device_statuses,
CUstream_st stream) |
static int |
nvcompBatchedSnappyDecompressAsync(Pointer device_compresed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
SizeTPointer device_actual_uncompressed_bytes,
long batch_size,
Pointer device_temp_ptr,
long temp_bytes,
Pointer device_uncompressed_ptrs,
IntBuffer device_statuses,
CUstream_st stream) |
static int |
nvcompBatchedSnappyDecompressAsync(Pointer device_compresed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
SizeTPointer device_actual_uncompressed_bytes,
long batch_size,
Pointer device_temp_ptr,
long temp_bytes,
Pointer device_uncompressed_ptrs,
IntPointer device_statuses,
CUstream_st stream) |
static int |
nvcompBatchedSnappyDecompressGetTempSize(long num_chunks,
long max_uncompressed_chunk_size,
SizeTPointer temp_bytes)
\brief Get the amount of temp space required on the GPU for decompression.
|
static int |
nvcompBatchedSnappyDecompressGetTempSizeEx(long num_chunks,
long max_uncompressed_chunk_size,
SizeTPointer temp_bytes,
long max_uncompressed_total_size)
\brief Get the amount of temp space required on the GPU for decompression.
|
static nvcompBatchedSnappyOpts_t |
nvcompBatchedSnappyDefaultOpts() |
static int |
nvcompBatchedSnappyGetDecompressSizeAsync(PointerPointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
long batch_size,
CUstream_st stream)
\brief Compute uncompressed sizes.
|
static int |
nvcompBatchedSnappyGetDecompressSizeAsync(Pointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
long batch_size,
CUstream_st stream) |
static int |
nvcompBatchedZstdCompressAsync(PointerPointer device_uncompressed_ptrs,
SizeTPointer device_uncompressed_bytes,
long max_uncompressed_chunk_bytes,
long batch_size,
Pointer device_temp_ptr,
long temp_bytes,
PointerPointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
nvcompBatchedZstdOpts_t format_opts,
CUstream_st stream)
\brief Perform compression asynchronously.
|
static int |
nvcompBatchedZstdCompressAsync(Pointer device_uncompressed_ptrs,
SizeTPointer device_uncompressed_bytes,
long max_uncompressed_chunk_bytes,
long batch_size,
Pointer device_temp_ptr,
long temp_bytes,
Pointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
nvcompBatchedZstdOpts_t format_opts,
CUstream_st stream) |
static int |
nvcompBatchedZstdCompressGetMaxOutputChunkSize(long max_uncompressed_chunk_bytes,
nvcompBatchedZstdOpts_t arg1,
SizeTPointer max_compressed_size)
\brief Get the maximum size any chunk could compress to in the batch.
|
static int |
nvcompBatchedZstdCompressGetTempSize(long batch_size,
long max_uncompressed_chunk_bytes,
nvcompBatchedZstdOpts_t format_opts,
SizeTPointer temp_bytes)
\brief Get temporary space required for compression.
|
static int |
nvcompBatchedZstdCompressGetTempSizeEx(long batch_size,
long max_uncompressed_chunk_bytes,
nvcompBatchedZstdOpts_t format_opts,
SizeTPointer temp_bytes,
long max_total_uncompressed_bytes)
\brief Get temporary space required for compression.
|
static int |
nvcompBatchedZstdDecompressAsync(PointerPointer device_compresed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
SizeTPointer device_actual_uncompressed_bytes,
long batch_size,
Pointer device_temp_ptr,
long temp_bytes,
PointerPointer device_uncompressed_ptrs,
IntPointer device_statuses,
CUstream_st stream)
\brief Perform decompression.
|
static int |
nvcompBatchedZstdDecompressAsync(Pointer device_compresed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
SizeTPointer device_actual_uncompressed_bytes,
long batch_size,
Pointer device_temp_ptr,
long temp_bytes,
Pointer device_uncompressed_ptrs,
int[] device_statuses,
CUstream_st stream) |
static int |
nvcompBatchedZstdDecompressAsync(Pointer device_compresed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
SizeTPointer device_actual_uncompressed_bytes,
long batch_size,
Pointer device_temp_ptr,
long temp_bytes,
Pointer device_uncompressed_ptrs,
IntBuffer device_statuses,
CUstream_st stream) |
static int |
nvcompBatchedZstdDecompressAsync(Pointer device_compresed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
SizeTPointer device_actual_uncompressed_bytes,
long batch_size,
Pointer device_temp_ptr,
long temp_bytes,
Pointer device_uncompressed_ptrs,
IntPointer device_statuses,
CUstream_st stream) |
static int |
nvcompBatchedZstdDecompressGetTempSize(long num_chunks,
long max_uncompressed_chunk_size,
SizeTPointer temp_bytes)
\brief Get the amount of temp space required on the GPU for decompression.
|
static int |
nvcompBatchedZstdDecompressGetTempSizeEx(long num_chunks,
long max_uncompressed_chunk_size,
SizeTPointer temp_bytes,
long max_uncompressed_total_size)
\brief Get the amount of temp space required on the GPU for decompression.
|
static nvcompBatchedZstdOpts_t |
nvcompBatchedZstdDefaultOpts() |
static int |
nvcompBatchedZstdGetDecompressSizeAsync(PointerPointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
long batch_size,
CUstream_st stream)
\brief Compute uncompressed sizes.
|
static int |
nvcompBatchedZstdGetDecompressSizeAsync(Pointer device_compressed_ptrs,
SizeTPointer device_compressed_bytes,
SizeTPointer device_uncompressed_bytes,
long batch_size,
CUstream_st stream) |
static long |
nvcompBitcompCompressionMaxAllowedChunkSize()
\brief Structure for configuring Bitcomp compression.
|
static long |
nvcompBitcompRequiredAlignment()
This is the minimum alignment required for void type CUDA memory buffers
passed to compression or decompression functions.
|
static long |
nvcompCascadedCompressionMaxAllowedChunkSize() |
static long |
nvcompCascadedRequiredAlignment()
This is the minimum alignment required for void type CUDA memory buffers
passed to compression or decompression functions.
|
static long |
nvcompDeflateCompressionMaxAllowedChunkSize() |
static long |
nvcompDeflateRequiredAlignment()
This is the minimum alignment required for void type CUDA memory buffers
passed to compression or decompression functions.
|
static long |
nvcompGdeflateCompressionMaxAllowedChunkSize() |
static long |
nvcompGdeflateRequiredAlignment()
This is the minimum alignment required for void type CUDA memory buffers passed to
compression or decompression functions.
|
static long |
nvcompLZ4CompressionMaxAllowedChunkSize() |
static long |
nvcompLZ4RequiredAlignment()
This is the minimum alignment required for void type CUDA memory buffers
passed to compression or decompression functions.
|
static long |
nvcompSnappyCompressionMaxAllowedChunkSize() |
static long |
nvcompSnappyRequiredAlignment()
This is the minimum alignment required for void type CUDA memory buffers
passed to compression or decompression functions.
|
static long |
nvcompZstdCompressionMaxAllowedChunkSize() |
static long |
nvcompZstdRequiredAlignment()
This is the minimum alignment required for void type CUDA memory buffers
passed to compression or decompression functions.
|
public static final int NVCOMP_MAJOR_VERSION
public static final int NVCOMP_MINOR_VERSION
public static final int NVCOMP_PATCH_VERSION
public static final int NVCOMP_TYPE_CHAR
public static final int NVCOMP_TYPE_UCHAR
public static final int NVCOMP_TYPE_SHORT
public static final int NVCOMP_TYPE_USHORT
public static final int NVCOMP_TYPE_INT
public static final int NVCOMP_TYPE_UINT
public static final int NVCOMP_TYPE_LONGLONG
public static final int NVCOMP_TYPE_ULONGLONG
public static final int NVCOMP_TYPE_BITS
public static final int nvcompSuccess
public static final int nvcompErrorInvalidValue
public static final int nvcompErrorNotSupported
public static final int nvcompErrorCannotDecompress
public static final int nvcompErrorBadChecksum
public static final int nvcompErrorCannotVerifyChecksums
public static final int nvcompErrorOutputBufferTooSmall
public static final int nvcompErrorWrongHeaderLength
public static final int nvcompErrorAlignment
public static final int nvcompErrorChunkSizeTooLarge
public static final int nvcompErrorCudaError
public static final int nvcompErrorInternal
public static final int NoComputeNoVerify
public static final int ComputeAndNoVerify
public static final int NoComputeAndVerifyIfPresent
public static final int ComputeAndVerifyIfPresent
public static final int ComputeAndVerify
public static final int nvcomp_rANS
@Namespace(value="nvcomp") @SharedPtr public static nvcompManagerBase create_manager(@Cast(value="const uint8_t*") BytePointer comp_buffer, CUstream_st stream, int device_id, @Cast(value="ChecksumPolicy") int checksum_policy)
@Namespace(value="nvcomp") @SharedPtr public static nvcompManagerBase create_manager(@Cast(value="const uint8_t*") BytePointer comp_buffer)
@Namespace(value="nvcomp") @SharedPtr public static nvcompManagerBase create_manager(@Cast(value="const uint8_t*") ByteBuffer comp_buffer, CUstream_st stream, int device_id, @Cast(value="ChecksumPolicy") int checksum_policy)
@Namespace(value="nvcomp") @SharedPtr public static nvcompManagerBase create_manager(@Cast(value="const uint8_t*") ByteBuffer comp_buffer)
@Namespace(value="nvcomp") @SharedPtr public static nvcompManagerBase create_manager(@Cast(value="const uint8_t*") byte[] comp_buffer, CUstream_st stream, int device_id, @Cast(value="ChecksumPolicy") int checksum_policy)
@Namespace(value="nvcomp") @SharedPtr public static nvcompManagerBase create_manager(@Cast(value="const uint8_t*") byte[] comp_buffer)
@MemberGetter @Const @ByRef public static nvcompBatchedANSOpts_t nvcompBatchedANSDefaultOpts()
@MemberGetter @Cast(value="const size_t") public static long nvcompANSCompressionMaxAllowedChunkSize()
@MemberGetter @Cast(value="const size_t") public static long nvcompANSRequiredAlignment()
@Cast(value="nvcompStatus_t") public static int nvcompBatchedANSCompressGetTempSize(@Cast(value="size_t") long batch_size, @Cast(value="size_t") long max_uncompressed_chunk_bytes, @ByVal nvcompBatchedANSOpts_t format_opts, @Cast(value="size_t*") SizeTPointer temp_bytes)
batch_size
- The number of items in the batch.max_uncompressed_chunk_bytes
- The maximum size of a chunk in the batch.format_opts
- Compression options.temp_bytes
- The size of the required GPU workspace for compression
(output).@Cast(value="nvcompStatus_t") public static int nvcompBatchedANSCompressGetTempSizeEx(@Cast(value="size_t") long batch_size, @Cast(value="size_t") long max_uncompressed_chunk_bytes, @ByVal nvcompBatchedANSOpts_t format_opts, @Cast(value="size_t*") SizeTPointer temp_bytes, @Cast(value="const size_t") long max_total_uncompressed_bytes)
batch_size
- The number of items in the batch.max_uncompressed_chunk_bytes
- The maximum size of a chunk in the batch.format_opts
- Compression options.temp_bytes
- The size of the required GPU workspace for compression
(output).max_total_uncompressed_bytes
- Upper bound on the total uncompressed size of all
chunks@Cast(value="nvcompStatus_t") public static int nvcompBatchedANSCompressGetMaxOutputChunkSize(@Cast(value="size_t") long max_chunk_size, @ByVal nvcompBatchedANSOpts_t format_opts, @Cast(value="size_t*") SizeTPointer max_compressed_size)
max_chunk_size
- The maximum size of a chunk in the batch.format_opts
- Compression options.max_compressed_size
- The maximum compressed size of the largest chunk
(output).@Cast(value="nvcompStatus_t") public static int nvcompBatchedANSCompressAsync(@Cast(value="const void*const*") PointerPointer device_uncompressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t") long max_uncompressed_chunk_bytes, @Cast(value="size_t") long batch_size, Pointer device_temp_ptr, @Cast(value="size_t") long temp_bytes, @Cast(value="void*const*") PointerPointer device_compressed_ptrs, @Cast(value="size_t*") SizeTPointer device_compressed_bytes, @ByVal nvcompBatchedANSOpts_t format_opts, CUstream_st stream)
device_uncompressed_ptrs
- The pointers on the GPU, to uncompressed batched items.
Each pointer must be aligned to a 4-byte boundary.device_uncompressed_bytes
- The size of each uncompressed batch item on the GPU.max_uncompressed_chunk_bytes
- The size of the largest uncompressed chunk.batch_size
- The number of batch items.device_temp_ptr
- The temporary GPU workspace, could be NULL in case temprorary space is not needed.temp_bytes
- The size of the temporary GPU workspace.device_compressed_ptrs
- The pointers on the GPU, to the output location for each compressed batch item (output).
Each pointer must be aligned to an 8-byte boundary.device_compressed_bytes
- The compressed size of each chunk on the GPU (output).format_opts
- Compression options.stream
- The stream to operate on.@Cast(value="nvcompStatus_t") public static int nvcompBatchedANSCompressAsync(@Cast(value="const void*const*") @ByPtrPtr Pointer device_uncompressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t") long max_uncompressed_chunk_bytes, @Cast(value="size_t") long batch_size, Pointer device_temp_ptr, @Cast(value="size_t") long temp_bytes, @Cast(value="void*const*") @ByPtrPtr Pointer device_compressed_ptrs, @Cast(value="size_t*") SizeTPointer device_compressed_bytes, @ByVal nvcompBatchedANSOpts_t format_opts, CUstream_st stream)
@Cast(value="nvcompStatus_t") public static int nvcompBatchedANSDecompressGetTempSize(@Cast(value="size_t") long num_chunks, @Cast(value="size_t") long max_uncompressed_chunk_bytes, @Cast(value="size_t*") SizeTPointer temp_bytes)
num_chunks
- The number of items in the batch.max_uncompressed_chunk_bytes
- The size of the largest chunk in bytes
when uncompressed.temp_bytes
- The amount of temporary GPU space that will be required to
decompress.@Cast(value="nvcompStatus_t") public static int nvcompBatchedANSDecompressGetTempSizeEx(@Cast(value="size_t") long num_chunks, @Cast(value="size_t") long max_uncompressed_chunk_bytes, @Cast(value="size_t*") SizeTPointer temp_bytes, @Cast(value="size_t") long max_uncompressed_total_size)
max_uncompressed_total_size
- The total decompressed size of all the chunks. Unused in ANS.@Cast(value="nvcompStatus_t") public static int nvcompBatchedANSGetDecompressSizeAsync(@Cast(value="const void*const*") PointerPointer device_compressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t") long batch_size, CUstream_st stream)
device_compresed_ptrs
- The pointers on the GPU, to the compressed chunks.device_compressed_bytes
- The size of each compressed chunk on the GPU.device_uncompressed_bytes
- The actual size of each uncompressed chunk.batch_size
- The number of batch items.stream
- The stream to operate on.@Cast(value="nvcompStatus_t") public static int nvcompBatchedANSGetDecompressSizeAsync(@Cast(value="const void*const*") @ByPtrPtr Pointer device_compressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t") long batch_size, CUstream_st stream)
@Cast(value="nvcompStatus_t") public static int nvcompBatchedANSDecompressAsync(@Cast(value="const void*const*") PointerPointer device_compressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t*") SizeTPointer device_actual_uncompressed_bytes, @Cast(value="size_t") long batch_size, Pointer device_temp_ptr, @Cast(value="const size_t") long temp_bytes, @Cast(value="void*const*") PointerPointer device_uncompressed_ptrs, @Cast(value="nvcompStatus_t*") IntPointer device_statuses, CUstream_st stream)
device_compresed_ptrs
- The pointers on the GPU, to the compressed chunks.
Each pointer must be aligned to an 8-byte boundary.device_compressed_bytes
- The size of each compressed chunk on the GPU.device_uncompressed_bytes
- The size of each device_uncompressed_ptrs[i] buffer.device_actual_uncompressed_bytes
- The actual size of each uncompressed chunkbatch_size
- The number of batch items.device_temp_ptr
- The temporary GPU space, could be NULL in case temporary space is not needed.temp_bytes
- The size of the temporary GPU space.device_uncompressed_ptrs
- The pointers on the GPU, to where to uncompress each chunk (output).device_statuses
- The pointers on the GPU, to where to uncompress each chunk (output).stream
- The stream to operate on.@Cast(value="nvcompStatus_t") public static int nvcompBatchedANSDecompressAsync(@Cast(value="const void*const*") @ByPtrPtr Pointer device_compressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t*") SizeTPointer device_actual_uncompressed_bytes, @Cast(value="size_t") long batch_size, Pointer device_temp_ptr, @Cast(value="const size_t") long temp_bytes, @Cast(value="void*const*") @ByPtrPtr Pointer device_uncompressed_ptrs, @Cast(value="nvcompStatus_t*") IntPointer device_statuses, CUstream_st stream)
@Cast(value="nvcompStatus_t") public static int nvcompBatchedANSDecompressAsync(@Cast(value="const void*const*") @ByPtrPtr Pointer device_compressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t*") SizeTPointer device_actual_uncompressed_bytes, @Cast(value="size_t") long batch_size, Pointer device_temp_ptr, @Cast(value="const size_t") long temp_bytes, @Cast(value="void*const*") @ByPtrPtr Pointer device_uncompressed_ptrs, @Cast(value="nvcompStatus_t*") IntBuffer device_statuses, CUstream_st stream)
@Cast(value="nvcompStatus_t") public static int nvcompBatchedANSDecompressAsync(@Cast(value="const void*const*") @ByPtrPtr Pointer device_compressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t*") SizeTPointer device_actual_uncompressed_bytes, @Cast(value="size_t") long batch_size, Pointer device_temp_ptr, @Cast(value="const size_t") long temp_bytes, @Cast(value="void*const*") @ByPtrPtr Pointer device_uncompressed_ptrs, @Cast(value="nvcompStatus_t*") int[] device_statuses, CUstream_st stream)
@MemberGetter @Cast(value="const size_t") public static long nvcompBitcompCompressionMaxAllowedChunkSize()
@MemberGetter @Cast(value="const size_t") public static long nvcompBitcompRequiredAlignment()
@MemberGetter @Const @ByRef public static nvcompBatchedBitcompFormatOpts nvcompBatchedBitcompDefaultOpts()
in_ptr
- The compressed data.in_bytes
- The size of the compressed buffer.@Cast(value="nvcompStatus_t") public static int nvcompBatchedBitcompCompressGetMaxOutputChunkSize(@Cast(value="size_t") long max_chunk_size, @ByVal nvcompBatchedBitcompFormatOpts format_opts, @Cast(value="size_t*") SizeTPointer max_compressed_size)
max_chunk_size
- The maximum size of a chunk in the batch.format_ops
- Snappy compression options.max_compressed_size
- The maximum compressed size of the largest chunk
(output).@Cast(value="nvcompStatus_t") public static int nvcompBatchedBitcompCompressAsync(@Cast(value="const void*const*") PointerPointer device_uncompressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t") long max_uncompressed_chunk_bytes, @Cast(value="size_t") long batch_size, Pointer device_temp_ptr, @Cast(value="size_t") long temp_bytes, @Cast(value="void*const*") PointerPointer device_compressed_ptrs, @Cast(value="size_t*") SizeTPointer device_compressed_bytes, @Const @ByVal nvcompBatchedBitcompFormatOpts format_opts, CUstream_st stream)
nvcompBitcompCompressAsync
, a valid compression format must
be supplied to format_opts
.device_uncompressed_ptrs
- [in] Array with size \p batch_size of pointers
to the uncompressed partitions. Both the pointers and the uncompressed data
should reside in device-accessible memory. The uncompressed data must start
at locations with alignments of the data type.device_uncompressed_bytes
- [in] Sizes of the uncompressed partitions in
bytes. The sizes should reside in device-accessible memory.
Each chunk size MUST be a multiple of the size of the data type specified by
format_opts.data_type, else this may crash or produce invalid output.max_uncompressed_chunk_bytes
- [in] This argument is not used.batch_size
- [in] Number of partitions to compress.device_temp_ptr
- [in] This argument is not used.temp_bytes
- [in] This argument is not used.device_compressed_ptrs
- [out] Array with size \p batch_size of pointers
to the output compressed buffers. Both the pointers and the compressed
buffers should reside in device-accessible memory. Each compressed buffer
should be preallocated with size at least (8B + the uncompressed size). Each
compressed buffer should start at a location with 64-bit alignment.device_compressed_bytes
- [out] Compressed sizes in bytes for all
partitions. The buffer should be preallocated in device-accessible memory.format_opts
- [in] The bitcomp format options. The format must be valid.type
- [in] The data type of the uncompressed data.stream
- [in] The cuda stream to operate on.@Cast(value="nvcompStatus_t") public static int nvcompBatchedBitcompCompressAsync(@Cast(value="const void*const*") @ByPtrPtr Pointer device_uncompressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t") long max_uncompressed_chunk_bytes, @Cast(value="size_t") long batch_size, Pointer device_temp_ptr, @Cast(value="size_t") long temp_bytes, @Cast(value="void*const*") @ByPtrPtr Pointer device_compressed_ptrs, @Cast(value="size_t*") SizeTPointer device_compressed_bytes, @Const @ByVal nvcompBatchedBitcompFormatOpts format_opts, CUstream_st stream)
@Cast(value="nvcompStatus_t") public static int nvcompBatchedBitcompDecompressAsync(@Cast(value="const void*const*") PointerPointer device_compressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t*") SizeTPointer device_actual_uncompressed_bytes, @Cast(value="size_t") long batch_size, Pointer device_temp_ptr, @Cast(value="size_t") long temp_bytes, @Cast(value="void*const*") PointerPointer device_uncompressed_ptrs, @Cast(value="nvcompStatus_t*") IntPointer device_statuses, CUstream_st stream)
nvcompBatchedBitcompCompressAsync
. It can also decompress buffers
compressed with nvcompBitcompCompressAsync
or the standalone Bitcomp library.
NOTE: The function is not completely asynchronous, as it needs to look
at the compressed data in order to create the proper bitcomp handle.
The stream is synchronized, the data is examined, then the asynchronous
decompression is launched.device_compressed_ptrs
- [in] Array with size \p batch_size of pointers
in device-accessible memory to compressed buffers. Each compressed buffer
should reside in device-accessible memory and start at a location which is
64-bit aligned.device_compressed_bytes
- [in] This argument is not used.device_uncompressed_bytes
- [in] Sizes of the output uncompressed
buffers in bytes. The sizes should reside in device-accessible memory. If the
size is not large enough to hold all decompressed elements, the decompressor
will set the status specified in \p device_statuses corresponding to the
overflow partition to nvcompErrorCannotDecompress
.device_actual_uncompressed_bytes
- [out] Array with size \p batch_size of
the actual number of bytes decompressed for every partitions. This argument
needs to be preallocated.batch_size
- [in] Number of partitions to decompress.device_temp_ptr
- [in] This argument is not used.temp_bytes
- [in] This argument is not used.device_uncompressed_ptrs
- [out] This argument is not used.device_statuses
- [out] Array with size \p batch_size of statuses in
device-accessible memory. This argument needs to be preallocated. For each
partition, if the decompression is successful, the status will be set to
nvcompSuccess
. If the decompression is not successful, for example due to
the corrupted input or out-of-bound errors, the status will be set to
nvcompErrorCannotDecompress
.stream
- [in] The cuda stream to operate on.@Cast(value="nvcompStatus_t") public static int nvcompBatchedBitcompDecompressAsync(@Cast(value="const void*const*") @ByPtrPtr Pointer device_compressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t*") SizeTPointer device_actual_uncompressed_bytes, @Cast(value="size_t") long batch_size, Pointer device_temp_ptr, @Cast(value="size_t") long temp_bytes, @Cast(value="void*const*") @ByPtrPtr Pointer device_uncompressed_ptrs, @Cast(value="nvcompStatus_t*") IntPointer device_statuses, CUstream_st stream)
@Cast(value="nvcompStatus_t") public static int nvcompBatchedBitcompDecompressAsync(@Cast(value="const void*const*") @ByPtrPtr Pointer device_compressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t*") SizeTPointer device_actual_uncompressed_bytes, @Cast(value="size_t") long batch_size, Pointer device_temp_ptr, @Cast(value="size_t") long temp_bytes, @Cast(value="void*const*") @ByPtrPtr Pointer device_uncompressed_ptrs, @Cast(value="nvcompStatus_t*") IntBuffer device_statuses, CUstream_st stream)
@Cast(value="nvcompStatus_t") public static int nvcompBatchedBitcompDecompressAsync(@Cast(value="const void*const*") @ByPtrPtr Pointer device_compressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t*") SizeTPointer device_actual_uncompressed_bytes, @Cast(value="size_t") long batch_size, Pointer device_temp_ptr, @Cast(value="size_t") long temp_bytes, @Cast(value="void*const*") @ByPtrPtr Pointer device_uncompressed_ptrs, @Cast(value="nvcompStatus_t*") int[] device_statuses, CUstream_st stream)
@Cast(value="nvcompStatus_t") public static int nvcompBatchedBitcompGetDecompressSizeAsync(@Cast(value="const void*const*") PointerPointer device_compressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t") long batch_size, CUstream_st stream)
device_compressed_ptrs
- [in] Array with size \p batch_size of pointers
in device-accessible memory to compressed buffers.device_compressed_bytes
- [in] This argument is not used.device_uncompressed_bytes
- [out] Sizes of the uncompressed data in
bytes. If there is an error when retrieving the size of a partition, the
uncompressed size of that partition will be set to 0. This argument needs to
be prealloated in device-accessible memory.batch_size
- [in] Number of partitions to check sizes.stream
- [in] The cuda stream to operate on.@Cast(value="nvcompStatus_t") public static int nvcompBatchedBitcompGetDecompressSizeAsync(@Cast(value="const void*const*") @ByPtrPtr Pointer device_compressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t") long batch_size, CUstream_st stream)
@Cast(value="nvcompStatus_t") public static int nvcompBatchedBitcompCompressGetTempSize(@Cast(value="size_t") long batch_size, @Cast(value="size_t") long max_uncompressed_chunk_bytes, @ByVal nvcompBatchedBitcompFormatOpts format_opts, @Cast(value="size_t*") SizeTPointer temp_bytes)
batch_size
- [in] Number of chunksmax_uncompressed_chunk_bytes
- [in] Size in bytes of the largest chunkformat_opts
- [in] Bitcomp optionstemp_bytes
- [out] The temp size@Cast(value="nvcompStatus_t") public static int nvcompBatchedBitcompCompressGetTempSizeEx(@Cast(value="size_t") long batch_size, @Cast(value="size_t") long max_uncompressed_chunk_bytes, @ByVal nvcompBatchedBitcompFormatOpts format_opts, @Cast(value="size_t*") SizeTPointer temp_bytes, @Cast(value="const size_t") long max_total_uncompressed_bytes)
batch_size
- [in] Number of chunksmax_uncompressed_chunk_bytes
- [in] Size in bytes of the largest chunkformat_opts
- [in] Bitcomp optionstemp_bytes
- [out] The temp sizemax_total_uncompressed_bytes
- Upper bound on the total uncompressed size of all
chunks@Cast(value="nvcompStatus_t") public static int nvcompBatchedBitcompDecompressGetTempSize(@Cast(value="size_t") long batch_size, @Cast(value="size_t") long max_chunk_bytes, @Cast(value="size_t*") SizeTPointer temp_bytes)
batch_size
- [in] Number of chunksmax_chunk_bytes
- [in] Size in bytes of the largest chunkformat_opts
- [in] Bitcomp optionstemp_bytes
- [out] The temp size@Cast(value="nvcompStatus_t") public static int nvcompBatchedBitcompDecompressGetTempSizeEx(@Cast(value="size_t") long batch_size, @Cast(value="size_t") long max_chunk_bytes, @Cast(value="size_t*") SizeTPointer temp_bytes, @Cast(value="size_t") long max_uncompressed_total_size)
batch_size
- [in] Number of chunksmax_chunk_bytes
- [in] Size in bytes of the largest chunkformat_opts
- [in] Bitcomp optionsmax_uncompressed_total_size
- [in] The total decompressed size of all the chunks. Unused in bitcomp.temp_bytes
- [out] The temp size@MemberGetter @Const @ByRef public static nvcompBatchedCascadedOpts_t nvcompBatchedCascadedDefaultOpts()
@MemberGetter @Cast(value="const size_t") public static long nvcompCascadedCompressionMaxAllowedChunkSize()
@MemberGetter @Cast(value="const size_t") public static long nvcompCascadedRequiredAlignment()
@Cast(value="nvcompStatus_t") public static int nvcompBatchedCascadedCompressGetTempSize(@Cast(value="size_t") long batch_size, @Cast(value="size_t") long max_uncompressed_chunk_bytes, @ByVal nvcompBatchedCascadedOpts_t format_opts, @Cast(value="size_t*") SizeTPointer temp_bytes)
batch_size
- The number of items in the batch.max_uncompressed_chunk_bytes
- The maximum size of a chunk in the
batch.format_opts
- The Cascaded compression options and datatype to use.temp_bytes
- The size of the required GPU workspace for compression
(output).@Cast(value="nvcompStatus_t") public static int nvcompBatchedCascadedCompressGetTempSizeEx(@Cast(value="size_t") long batch_size, @Cast(value="size_t") long max_uncompressed_chunk_bytes, @ByVal nvcompBatchedCascadedOpts_t format_opts, @Cast(value="size_t*") SizeTPointer temp_bytes, @Cast(value="const size_t") long max_total_uncompressed_bytes)
batch_size
- The number of items in the batch.max_uncompressed_chunk_bytes
- The maximum size of a chunk in the
batch.format_opts
- The Cascaded compression options and datatype to use.temp_bytes
- The size of the required GPU workspace for compression
(output).max_total_uncompressed_bytes
- Upper bound on the total uncompressed size of all
chunks@Cast(value="nvcompStatus_t") public static int nvcompBatchedCascadedCompressGetMaxOutputChunkSize(@Cast(value="size_t") long max_uncompressed_chunk_bytes, @ByVal nvcompBatchedCascadedOpts_t format_opts, @Cast(value="size_t*") SizeTPointer max_compressed_bytes)
max_uncompressed_chunk_bytes
- The maximum size of a chunk in the batch.format_opts
- The Cascaded compression options to use.max_compressed_byes
- The maximum compressed size of the largest chunk
(output).@Cast(value="nvcompStatus_t") public static int nvcompBatchedCascadedCompressAsync(@Cast(value="const void*const*") PointerPointer device_uncompressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t") long max_uncompressed_chunk_bytes, @Cast(value="size_t") long batch_size, Pointer device_temp_ptr, @Cast(value="size_t") long temp_bytes, @Cast(value="void*const*") PointerPointer device_compressed_ptrs, @Cast(value="size_t*") SizeTPointer device_compressed_bytes, @Const @ByVal nvcompBatchedCascadedOpts_t format_opts, CUstream_st stream)
nvcompCascadedCompressAsync
, a valid compression format must
be supplied to format_opts
.
NOTE: The current implementation does not support uncompressed size larger
than 4,294,967,295 bytes (max uint32_t).device_uncompressed_ptrs
- [in] Array with size \p batch_size of pointers
to the uncompressed partitions. Both the pointers and the uncompressed data
should reside in device-accessible memory. The uncompressed data must start
at locations with alignments of the data type.device_uncompressed_bytes
- [in] Sizes of the uncompressed partitions in
bytes. The sizes should reside in device-accessible memory.
Each chunk size MUST be a multiple of the size of the data type specified by
format_opts.type, else this may crash or produce invalid output.max_uncompressed_chunk_bytes
- [in] This argument is not used.batch_size
- [in] Number of partitions to compress.device_temp_ptr
- [in] This argument is not used.temp_bytes
- [in] This argument is not used.device_compressed_ptrs
- [out] Array with size \p batch_size of pointers
to the output compressed buffers. Both the pointers and the compressed
buffers should reside in device-accessible memory. Each compressed buffer
should be preallocated with size at least (8B + the uncompressed size). Each
compressed buffer should start at a location with alignment of both 4B and
the data type.device_compressed_bytes
- [out] Number of bytes decompressed of all
partitions. The buffer should be preallocated in device-accessible memory.format_opts
- [in] The cascaded format options. The format must be valid.stream
- [in] The cuda stream to operate on.@Cast(value="nvcompStatus_t") public static int nvcompBatchedCascadedCompressAsync(@Cast(value="const void*const*") @ByPtrPtr Pointer device_uncompressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t") long max_uncompressed_chunk_bytes, @Cast(value="size_t") long batch_size, Pointer device_temp_ptr, @Cast(value="size_t") long temp_bytes, @Cast(value="void*const*") @ByPtrPtr Pointer device_compressed_ptrs, @Cast(value="size_t*") SizeTPointer device_compressed_bytes, @Const @ByVal nvcompBatchedCascadedOpts_t format_opts, CUstream_st stream)
@Cast(value="nvcompStatus_t") public static int nvcompBatchedCascadedDecompressGetTempSize(@Cast(value="size_t") long num_chunks, @Cast(value="size_t") long max_uncompressed_chunk_bytes, @Cast(value="size_t*") SizeTPointer temp_bytes)
num_chunks
- The number of items in the batch.max_uncompressed_chunk_bytes
- The size of the largest chunk in bytes
when uncompressed.temp_bytes
- The amount of temporary GPU space that will be required to
decompress.@Cast(value="nvcompStatus_t") public static int nvcompBatchedCascadedDecompressGetTempSizeEx(@Cast(value="size_t") long num_chunks, @Cast(value="size_t") long max_uncompressed_chunk_bytes, @Cast(value="size_t*") SizeTPointer temp_bytes, @Cast(value="size_t") long max_uncompressed_total_size)
num_chunks
- The number of items in the batch.max_uncompressed_chunk_bytes
- The size of the largest chunk in bytes
when uncompressed.temp_bytes
- The amount of temporary GPU space that will be required to
decompress.max_uncompressed_total_size
- The total decompressed size of all the chunks.
Unused in Cascaded.@Cast(value="nvcompStatus_t") public static int nvcompBatchedCascadedDecompressAsync(@Cast(value="const void*const*") PointerPointer device_compressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t*") SizeTPointer device_actual_uncompressed_bytes, @Cast(value="size_t") long batch_size, Pointer device_temp_ptr, @Cast(value="size_t") long temp_bytes, @Cast(value="void*const*") PointerPointer device_uncompressed_ptrs, @Cast(value="nvcompStatus_t*") IntPointer device_statuses, CUstream_st stream)
nvcompBatchedCascadedCompressAsync
. Currently it is not compatible with
compressed buffers produced by nvcompCascadedCompressAsync
.device_compressed_ptrs
- [in] Array with size \p batch_size of pointers
in device-accessible memory to compressed buffers. Each compressed buffer
should reside in device-accessible memory and start at a location with
alignment of both 4B and the data type.device_compressed_bytes
- [in] Sizes of the compressed buffers in bytes.
The sizes should reside in device-accessible memory.device_uncompressed_bytes
- [in] Sizes of the output uncompressed
buffers in bytes. The sizes should reside in device-accessible memory. If the
size is not large enough to hold all decompressed elements, the decompressor
will set the status specified in \p device_statuses corresponding to the
overflow partition to nvcompErrorCannotDecompress
.device_actual_uncompressed_bytes
- [out] Array with size \p batch_size of
the actual number of bytes decompressed for every partitions. This argument
needs to be preallocated.batch_size
- [in] Number of partitions to decompress.device_temp_ptr
- [in] This argument is not used.temp_bytes
- [in] This argument is not used.device_uncompressed_ptrs
- [out] Array with size \p batch_size of
pointers in device-accessible memory to decompressed data. Each uncompressed
buffer needs to be preallocated in device-accessible memory, and start at a
location with alignment of the data type.device_statuses
- [out] Array with size \p batch_size of statuses in
device-accessible memory. This argument needs to be preallocated. For each
partition, if the decompression is successful, the status will be set to
nvcompSuccess
. If the decompression is not successful, for example due to
the corrupted input or out-of-bound errors, the status will be set to
nvcompErrorCannotDecompress
.stream
- [in] The cuda stream to operate on.@Cast(value="nvcompStatus_t") public static int nvcompBatchedCascadedDecompressAsync(@Cast(value="const void*const*") @ByPtrPtr Pointer device_compressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t*") SizeTPointer device_actual_uncompressed_bytes, @Cast(value="size_t") long batch_size, Pointer device_temp_ptr, @Cast(value="size_t") long temp_bytes, @Cast(value="void*const*") @ByPtrPtr Pointer device_uncompressed_ptrs, @Cast(value="nvcompStatus_t*") IntPointer device_statuses, CUstream_st stream)
@Cast(value="nvcompStatus_t") public static int nvcompBatchedCascadedDecompressAsync(@Cast(value="const void*const*") @ByPtrPtr Pointer device_compressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t*") SizeTPointer device_actual_uncompressed_bytes, @Cast(value="size_t") long batch_size, Pointer device_temp_ptr, @Cast(value="size_t") long temp_bytes, @Cast(value="void*const*") @ByPtrPtr Pointer device_uncompressed_ptrs, @Cast(value="nvcompStatus_t*") IntBuffer device_statuses, CUstream_st stream)
@Cast(value="nvcompStatus_t") public static int nvcompBatchedCascadedDecompressAsync(@Cast(value="const void*const*") @ByPtrPtr Pointer device_compressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t*") SizeTPointer device_actual_uncompressed_bytes, @Cast(value="size_t") long batch_size, Pointer device_temp_ptr, @Cast(value="size_t") long temp_bytes, @Cast(value="void*const*") @ByPtrPtr Pointer device_uncompressed_ptrs, @Cast(value="nvcompStatus_t*") int[] device_statuses, CUstream_st stream)
@Cast(value="nvcompStatus_t") public static int nvcompBatchedCascadedGetDecompressSizeAsync(@Cast(value="const void*const*") PointerPointer device_compressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t") long batch_size, CUstream_st stream)
device_compressed_ptrs
- [in] Array with size \p batch_size of pointers
in device-accessible memory to compressed buffers.device_compressed_bytes
- [in] Sizes of the compressed buffers in bytes.
The sizes should reside in device-accessible memory.device_uncompressed_bytes
- [out] Sizes of the uncompressed data in
bytes. If there is an error when retrieving the size of a partition, the
uncompressed size of that partition will be set to 0. This argument needs to
be prealloated in device-accessible memory.batch_size
- [in] Number of partitions to check sizes.stream
- [in] The cuda stream to operate on.@Cast(value="nvcompStatus_t") public static int nvcompBatchedCascadedGetDecompressSizeAsync(@Cast(value="const void*const*") @ByPtrPtr Pointer device_compressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t") long batch_size, CUstream_st stream)
@Cast(value="nvcompStatus_t") public static int nvcompBatchedCRC32Async(@Cast(value="const void*const*") PointerPointer device_uncompressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t") long batch_size, @Cast(value="uint32_t*") IntPointer device_CRC32_ptrs, CUstream_st stream)
device_uncompressed_ptrs
- The pointers on the GPU, to uncompressed batched items.
This pointer must be GPU accessible.device_uncompressed_bytes
- The size of each uncompressed batch item on the GPU.batch_size
- The number of chunks to compress.device_compressed_ptrs
- The pointers on the GPU, to the output location for
each CRC32 checksum (output). This pointer must be GPU accessible.stream
- The CUDA stream to operate on.@Cast(value="nvcompStatus_t") public static int nvcompBatchedCRC32Async(@Cast(value="const void*const*") @ByPtrPtr Pointer device_uncompressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t") long batch_size, @Cast(value="uint32_t*") IntPointer device_CRC32_ptrs, CUstream_st stream)
@Cast(value="nvcompStatus_t") public static int nvcompBatchedCRC32Async(@Cast(value="const void*const*") @ByPtrPtr Pointer device_uncompressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t") long batch_size, @Cast(value="uint32_t*") IntBuffer device_CRC32_ptrs, CUstream_st stream)
@Cast(value="nvcompStatus_t") public static int nvcompBatchedCRC32Async(@Cast(value="const void*const*") @ByPtrPtr Pointer device_uncompressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t") long batch_size, @Cast(value="uint32_t*") int[] device_CRC32_ptrs, CUstream_st stream)
@MemberGetter @Const @ByRef public static nvcompBatchedDeflateOpts_t nvcompBatchedDeflateDefaultOpts()
@MemberGetter @Cast(value="const size_t") public static long nvcompDeflateCompressionMaxAllowedChunkSize()
@MemberGetter @Cast(value="const size_t") public static long nvcompDeflateRequiredAlignment()
@Cast(value="nvcompStatus_t") public static int nvcompBatchedDeflateCompressGetTempSize(@Cast(value="size_t") long batch_size, @Cast(value="size_t") long max_uncompressed_chunk_bytes, @ByVal nvcompBatchedDeflateOpts_t format_opts, @Cast(value="size_t*") SizeTPointer temp_bytes)
batch_size
- The number of items in the batch.max_uncompressed_chunk_bytes
- The maximum size of a chunk in the
batch.format_opts
- The Deflate compression options to use.temp_bytes
- The size of the required GPU workspace for compression
(output).@Cast(value="nvcompStatus_t") public static int nvcompBatchedDeflateCompressGetTempSizeEx(@Cast(value="size_t") long batch_size, @Cast(value="size_t") long max_uncompressed_chunk_bytes, @ByVal nvcompBatchedDeflateOpts_t format_opts, @Cast(value="size_t*") SizeTPointer temp_bytes, @Cast(value="const size_t") long max_total_uncompressed_bytes)
batch_size
- The number of items in the batch.max_uncompressed_chunk_bytes
- The maximum size of a chunk in the
batch.format_opts
- The Deflate compression options to use.temp_bytes
- The size of the required GPU workspace for compression
(output).max_total_uncompressed_bytes
- Upper bound on the total uncompressed size of all
chunks@Cast(value="nvcompStatus_t") public static int nvcompBatchedDeflateCompressGetMaxOutputChunkSize(@Cast(value="size_t") long max_uncompressed_chunk_bytes, @ByVal nvcompBatchedDeflateOpts_t format_opts, @Cast(value="size_t*") SizeTPointer max_compressed_bytes)
max_uncompressed_chunk_bytes
- The maximum size of a chunk in the batch.format_opts
- The Deflate compression options to use.max_compressed_byes
- The maximum compressed size of the largest chunk
(output).@Cast(value="nvcompStatus_t") public static int nvcompBatchedDeflateCompressAsync(@Cast(value="const void*const*") PointerPointer device_uncompressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t") long max_uncompressed_chunk_bytes, @Cast(value="size_t") long batch_size, Pointer device_temp_ptr, @Cast(value="size_t") long temp_bytes, @Cast(value="void*const*") PointerPointer device_compressed_ptrs, @Cast(value="size_t*") SizeTPointer device_compressed_bytes, @ByVal nvcompBatchedDeflateOpts_t format_opts, CUstream_st stream)
device_uncompressed_ptrs
- The pointers on the GPU, to uncompressed batched items.
This pointer must be GPU accessible.device_uncompressed_bytes
- The size of each uncompressed batch item on the GPU.max_uncompressed_chunk_bytes
- The maximum size in bytes of the largest
chunk in the batch.batch_size
- The number of chunks to compress.device_temp_ptr
- The temporary GPU workspace.temp_bytes
- The size of the temporary GPU workspace.device_compressed_ptrs
- The pointers on the GPU, to the output location for
each compressed batch item (output). This pointer must be GPU accessible.device_compressed_bytes
- The compressed size of each chunk on the GPU
(output). This pointer must be GPU accessible.format_opts
- The Deflate compression options to use.stream
- The CUDA stream to operate on.@Cast(value="nvcompStatus_t") public static int nvcompBatchedDeflateCompressAsync(@Cast(value="const void*const*") @ByPtrPtr Pointer device_uncompressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t") long max_uncompressed_chunk_bytes, @Cast(value="size_t") long batch_size, Pointer device_temp_ptr, @Cast(value="size_t") long temp_bytes, @Cast(value="void*const*") @ByPtrPtr Pointer device_compressed_ptrs, @Cast(value="size_t*") SizeTPointer device_compressed_bytes, @ByVal nvcompBatchedDeflateOpts_t format_opts, CUstream_st stream)
@Cast(value="nvcompStatus_t") public static int nvcompBatchedDeflateDecompressGetTempSize(@Cast(value="size_t") long num_chunks, @Cast(value="size_t") long max_uncompressed_chunk_bytes, @Cast(value="size_t*") SizeTPointer temp_bytes)
num_chunks
- The number of items in the batch.max_uncompressed_chunk_bytes
- The size of the largest chunk in bytes
when uncompressed.temp_bytes
- The amount of temporary GPU space that will be required to
decompress.@Cast(value="nvcompStatus_t") public static int nvcompBatchedDeflateDecompressGetTempSizeEx(@Cast(value="size_t") long num_chunks, @Cast(value="size_t") long max_uncompressed_chunk_bytes, @Cast(value="size_t*") SizeTPointer temp_bytes, @Cast(value="size_t") long max_uncompressed_total_size)
num_chunks
- The number of items in the batch.max_uncompressed_chunk_bytes
- The size of the largest chunk in bytes
when uncompressed.temp_bytes
- The amount of temporary GPU space that will be required to
decompress.max_uncompressed_total_size
- The total decompressed size of all the chunks.
Unused in deflate.@Cast(value="nvcompStatus_t") public static int nvcompBatchedDeflateDecompressAsync(@Cast(value="const void*const*") PointerPointer device_compressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t*") SizeTPointer device_actual_uncompressed_bytes, @Cast(value="size_t") long batch_size, Pointer device_temp_ptr, @Cast(value="size_t") long temp_bytes, @Cast(value="void*const*") PointerPointer device_uncompressed_ptrs, @Cast(value="nvcompStatus_t*") IntPointer device_statuses, CUstream_st stream)
device_compressed_ptrs
- The pointers on the GPU, to the compressed
chunks.device_compressed_bytes
- The size of each compressed chunk on the GPU.
This pointer must be GPU accessible.device_uncompressed_bytes
- The decompressed buffer size. This is needed
to prevent OOB accesses. This pointer must be GPU accessible.device_actual_uncompressed_bytes
- The actual calculated decompressed
size of each chunk. Can be nullptr if desired,
in which case the actual_uncompressed_bytes is not reported.batch_size
- The number of batch items.device_temp_ptr
- The temporary GPU space.temp_bytes
- The size of the temporary GPU space.device_uncompressed_ptrs
- The pointers on the GPU, to where to
uncompress each chunk (output).device_statuses
- The status for each chunk of whether it was
decompressed or not. Can be nullptr if desired,
in which case error status is not reported.stream
- The CUDA stream to operate on.@Cast(value="nvcompStatus_t") public static int nvcompBatchedDeflateDecompressAsync(@Cast(value="const void*const*") @ByPtrPtr Pointer device_compressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t*") SizeTPointer device_actual_uncompressed_bytes, @Cast(value="size_t") long batch_size, Pointer device_temp_ptr, @Cast(value="size_t") long temp_bytes, @Cast(value="void*const*") @ByPtrPtr Pointer device_uncompressed_ptrs, @Cast(value="nvcompStatus_t*") IntPointer device_statuses, CUstream_st stream)
@Cast(value="nvcompStatus_t") public static int nvcompBatchedDeflateDecompressAsync(@Cast(value="const void*const*") @ByPtrPtr Pointer device_compressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t*") SizeTPointer device_actual_uncompressed_bytes, @Cast(value="size_t") long batch_size, Pointer device_temp_ptr, @Cast(value="size_t") long temp_bytes, @Cast(value="void*const*") @ByPtrPtr Pointer device_uncompressed_ptrs, @Cast(value="nvcompStatus_t*") IntBuffer device_statuses, CUstream_st stream)
@Cast(value="nvcompStatus_t") public static int nvcompBatchedDeflateDecompressAsync(@Cast(value="const void*const*") @ByPtrPtr Pointer device_compressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t*") SizeTPointer device_actual_uncompressed_bytes, @Cast(value="size_t") long batch_size, Pointer device_temp_ptr, @Cast(value="size_t") long temp_bytes, @Cast(value="void*const*") @ByPtrPtr Pointer device_uncompressed_ptrs, @Cast(value="nvcompStatus_t*") int[] device_statuses, CUstream_st stream)
@Cast(value="nvcompStatus_t") public static int nvcompBatchedDeflateGetDecompressSizeAsync(@Cast(value="const void*const*") PointerPointer device_compressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t") long batch_size, CUstream_st stream)
device_compress_ptrs
- The compressed chunks of data. List of pointers
must be GPU accessible along with each chunk.device_compressed_bytes
- The size of each compressed chunk. Must be GPU
accessible.device_uncompressed_bytes
- The calculated decompressed size of each
chunk. Must be GPU accessible.batch_size
- The number of chunksstream
- The CUDA stream to operate on.@Cast(value="nvcompStatus_t") public static int nvcompBatchedDeflateGetDecompressSizeAsync(@Cast(value="const void*const*") @ByPtrPtr Pointer device_compressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t") long batch_size, CUstream_st stream)
@MemberGetter @Const @ByRef public static nvcompBatchedGdeflateOpts_t nvcompBatchedGdeflateDefaultOpts()
@MemberGetter @Cast(value="const size_t") public static long nvcompGdeflateCompressionMaxAllowedChunkSize()
@MemberGetter @Cast(value="const size_t") public static long nvcompGdeflateRequiredAlignment()
@Cast(value="nvcompStatus_t") public static int nvcompBatchedGdeflateCompressGetTempSize(@Cast(value="size_t") long batch_size, @Cast(value="size_t") long max_uncompressed_chunk_bytes, @ByVal nvcompBatchedGdeflateOpts_t format_opts, @Cast(value="size_t*") SizeTPointer temp_bytes)
batch_size
- The number of items in the batch.max_uncompressed_chunk_bytes
- The maximum size of a chunk in the
batch.format_opts
- The GDeflate compression options to use.temp_bytes
- The size of the required GPU workspace for compression
(output).@Cast(value="nvcompStatus_t") public static int nvcompBatchedGdeflateCompressGetTempSizeEx(@Cast(value="size_t") long batch_size, @Cast(value="size_t") long max_uncompressed_chunk_bytes, @ByVal nvcompBatchedGdeflateOpts_t format_opts, @Cast(value="size_t*") SizeTPointer temp_bytes, @Cast(value="const size_t") long max_total_uncompressed_bytes)
batch_size
- The number of items in the batch.max_uncompressed_chunk_bytes
- The maximum size of a chunk in the
batch.format_opts
- The GDeflate compression options to use.temp_bytes
- The size of the required GPU workspace for compression
(output).max_total_uncompressed_bytes
- Upper bound on the total uncompressed size of all
chunks@Cast(value="nvcompStatus_t") public static int nvcompBatchedGdeflateCompressGetMaxOutputChunkSize(@Cast(value="size_t") long max_uncompressed_chunk_bytes, @ByVal nvcompBatchedGdeflateOpts_t format_opts, @Cast(value="size_t*") SizeTPointer max_compressed_bytes)
max_uncompressed_chunk_bytes
- The maximum size of a chunk in the batch.format_opts
- The GDeflate compression options to use.max_compressed_byes
- The maximum compressed size of the largest chunk
(output).@Cast(value="nvcompStatus_t") public static int nvcompBatchedGdeflateCompressAsync(@Cast(value="const void*const*") PointerPointer device_uncompressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t") long max_uncompressed_chunk_bytes, @Cast(value="size_t") long batch_size, Pointer device_temp_ptr, @Cast(value="size_t") long temp_bytes, @Cast(value="void*const*") PointerPointer device_compressed_ptrs, @Cast(value="size_t*") SizeTPointer device_compressed_bytes, @ByVal nvcompBatchedGdeflateOpts_t format_opts, CUstream_st stream)
device_uncompressed_ptrs
- The pointers on the GPU, to uncompressed batched items.
This pointer must be GPU accessible.device_uncompressed_bytes
- The size of each uncompressed batch item on the GPU.max_uncompressed_chunk_bytes
- The maximum size in bytes of the largest
chunk in the batch.batch_size
- The number of chunks to compress.device_temp_ptr
- The temporary GPU workspace.temp_bytes
- The size of the temporary GPU workspace.device_compressed_ptrs
- The pointers on the GPU, to the output location for
each compressed batch item (output). This pointer must be GPU accessible.device_compressed_bytes
- The compressed size of each chunk on the GPU
(output). This pointer must be GPU accessible.format_opts
- The GDeflate compression options to use.stream
- The CUDA stream to operate on.@Cast(value="nvcompStatus_t") public static int nvcompBatchedGdeflateCompressAsync(@Cast(value="const void*const*") @ByPtrPtr Pointer device_uncompressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t") long max_uncompressed_chunk_bytes, @Cast(value="size_t") long batch_size, Pointer device_temp_ptr, @Cast(value="size_t") long temp_bytes, @Cast(value="void*const*") @ByPtrPtr Pointer device_compressed_ptrs, @Cast(value="size_t*") SizeTPointer device_compressed_bytes, @ByVal nvcompBatchedGdeflateOpts_t format_opts, CUstream_st stream)
@Cast(value="nvcompStatus_t") public static int nvcompBatchedGdeflateDecompressGetTempSize(@Cast(value="size_t") long num_chunks, @Cast(value="size_t") long max_uncompressed_chunk_bytes, @Cast(value="size_t*") SizeTPointer temp_bytes)
num_chunks
- The number of items in the batch.max_uncompressed_chunk_bytes
- The size of the largest chunk in bytes
when uncompressed.temp_bytes
- The amount of temporary GPU space that will be required to
decompress.@Cast(value="nvcompStatus_t") public static int nvcompBatchedGdeflateDecompressGetTempSizeEx(@Cast(value="size_t") long num_chunks, @Cast(value="size_t") long max_uncompressed_chunk_bytes, @Cast(value="size_t*") SizeTPointer temp_bytes, @Cast(value="size_t") long max_uncompressed_total_size)
num_chunks
- The number of items in the batch.max_uncompressed_chunk_bytes
- The size of the largest chunk in bytes
when uncompressed.temp_bytes
- The amount of temporary GPU space that will be required to
decompress.max_uncompressed_total_size
- The total decompressed size of all the chunks.
Unused in gdeflate.@Cast(value="nvcompStatus_t") public static int nvcompBatchedGdeflateDecompressAsync(@Cast(value="const void*const*") PointerPointer device_compressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t*") SizeTPointer device_actual_uncompressed_bytes, @Cast(value="size_t") long batch_size, Pointer device_temp_ptr, @Cast(value="size_t") long temp_bytes, @Cast(value="void*const*") PointerPointer device_uncompressed_ptrs, @Cast(value="nvcompStatus_t*") IntPointer device_statuses, CUstream_st stream)
device_compressed_ptrs
- The pointers on the GPU, to the compressed
chunks.device_compressed_bytes
- The size of each compressed chunk on the GPU.
This pointer must be GPU accessible.device_uncompressed_bytes
- The decompressed buffer size. This is needed
to prevent OOB accesses. This pointer must be GPU accessible.device_actual_uncompressed_bytes
- The actual calculated decompressed
size of each chunk. Can be nullptr if desired,
in which case the actual_uncompressed_bytes is not reported.batch_size
- The number of batch items.device_temp_ptr
- The temporary GPU space.temp_bytes
- The size of the temporary GPU space.device_uncompressed_ptrs
- The pointers on the GPU, to where to
uncompress each chunk (output).device_statuses
- The status for each chunk of whether it was
decompressed or not. Can be nullptr if desired,
in which case error status is not reported.stream
- The CUDA stream to operate on.@Cast(value="nvcompStatus_t") public static int nvcompBatchedGdeflateDecompressAsync(@Cast(value="const void*const*") @ByPtrPtr Pointer device_compressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t*") SizeTPointer device_actual_uncompressed_bytes, @Cast(value="size_t") long batch_size, Pointer device_temp_ptr, @Cast(value="size_t") long temp_bytes, @Cast(value="void*const*") @ByPtrPtr Pointer device_uncompressed_ptrs, @Cast(value="nvcompStatus_t*") IntPointer device_statuses, CUstream_st stream)
@Cast(value="nvcompStatus_t") public static int nvcompBatchedGdeflateDecompressAsync(@Cast(value="const void*const*") @ByPtrPtr Pointer device_compressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t*") SizeTPointer device_actual_uncompressed_bytes, @Cast(value="size_t") long batch_size, Pointer device_temp_ptr, @Cast(value="size_t") long temp_bytes, @Cast(value="void*const*") @ByPtrPtr Pointer device_uncompressed_ptrs, @Cast(value="nvcompStatus_t*") IntBuffer device_statuses, CUstream_st stream)
@Cast(value="nvcompStatus_t") public static int nvcompBatchedGdeflateDecompressAsync(@Cast(value="const void*const*") @ByPtrPtr Pointer device_compressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t*") SizeTPointer device_actual_uncompressed_bytes, @Cast(value="size_t") long batch_size, Pointer device_temp_ptr, @Cast(value="size_t") long temp_bytes, @Cast(value="void*const*") @ByPtrPtr Pointer device_uncompressed_ptrs, @Cast(value="nvcompStatus_t*") int[] device_statuses, CUstream_st stream)
@Cast(value="nvcompStatus_t") public static int nvcompBatchedGdeflateGetDecompressSizeAsync(@Cast(value="const void*const*") PointerPointer device_compressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t") long batch_size, CUstream_st stream)
device_compress_ptrs
- The compressed chunks of data. List of pointers
must be GPU accessible along with each chunk.device_compressed_bytes
- The size of each compressed chunk. Must be GPU
accessible.device_uncompressed_bytes
- The calculated decompressed size of each
chunk. Must be GPU accessible.batch_size
- The number of chunksstream
- The CUDA stream to operate on.@Cast(value="nvcompStatus_t") public static int nvcompBatchedGdeflateGetDecompressSizeAsync(@Cast(value="const void*const*") @ByPtrPtr Pointer device_compressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t") long batch_size, CUstream_st stream)
@Cast(value="nvcompStatus_t") public static int nvcompBatchedGzipDecompressGetTempSize(@Cast(value="size_t") long num_chunks, @Cast(value="size_t") long max_uncompressed_chunk_bytes, @Cast(value="size_t*") SizeTPointer temp_bytes)
num_chunks
- The number of items in the batch.max_uncompressed_chunk_bytes
- The size of the largest chunk in bytes
when uncompressed.temp_bytes
- The amount of temporary GPU space that will be required to
decompress.@Cast(value="nvcompStatus_t") public static int nvcompBatchedGzipDecompressGetTempSizeEx(@Cast(value="size_t") long num_chunks, @Cast(value="size_t") long max_uncompressed_chunk_bytes, @Cast(value="size_t*") SizeTPointer temp_bytes, @Cast(value="size_t") long max_uncompressed_total_size)
num_chunks
- The number of items in the batch.max_uncompressed_chunk_bytes
- The size of the largest chunk in bytes
when uncompressed.temp_bytes
- The amount of temporary GPU space that will be required to
decompress.max_uncompressed_total_size
- The total decompressed size of all the chunks.
Unused in gzip.@Cast(value="nvcompStatus_t") public static int nvcompBatchedGzipDecompressAsync(@Cast(value="const void*const*") PointerPointer device_compressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t*") SizeTPointer device_actual_uncompressed_bytes, @Cast(value="size_t") long batch_size, Pointer device_temp_ptr, @Cast(value="size_t") long temp_bytes, @Cast(value="void*const*") PointerPointer device_uncompressed_ptrs, @Cast(value="nvcompStatus_t*") IntPointer device_statuses, CUstream_st stream)
device_compressed_ptrs
- The pointers on the GPU, to the compressed
chunks.device_compressed_bytes
- The size of each compressed chunk on the GPU.
This pointer must be GPU accessible.device_uncompressed_bytes
- The decompressed buffer size. This is needed
to prevent OOB accesses. This pointer must be GPU accessible.device_actual_uncompressed_bytes
- The actual calculated decompressed
size of each chunk. Can be nullptr if desired,
in which case the actual_uncompressed_bytes is not reported.batch_size
- The number of batch items.device_temp_ptr
- The temporary GPU space.temp_bytes
- The size of the temporary GPU space.device_uncompressed_ptrs
- The pointers on the GPU, to where to
uncompress each chunk (output).device_statuses
- The status for each chunk of whether it was
decompressed or not. Can be nullptr if desired,
in which case error status is not reported.stream
- The CUDA stream to operate on.@Cast(value="nvcompStatus_t") public static int nvcompBatchedGzipDecompressAsync(@Cast(value="const void*const*") @ByPtrPtr Pointer device_compressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t*") SizeTPointer device_actual_uncompressed_bytes, @Cast(value="size_t") long batch_size, Pointer device_temp_ptr, @Cast(value="size_t") long temp_bytes, @Cast(value="void*const*") @ByPtrPtr Pointer device_uncompressed_ptrs, @Cast(value="nvcompStatus_t*") IntPointer device_statuses, CUstream_st stream)
@Cast(value="nvcompStatus_t") public static int nvcompBatchedGzipDecompressAsync(@Cast(value="const void*const*") @ByPtrPtr Pointer device_compressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t*") SizeTPointer device_actual_uncompressed_bytes, @Cast(value="size_t") long batch_size, Pointer device_temp_ptr, @Cast(value="size_t") long temp_bytes, @Cast(value="void*const*") @ByPtrPtr Pointer device_uncompressed_ptrs, @Cast(value="nvcompStatus_t*") IntBuffer device_statuses, CUstream_st stream)
@Cast(value="nvcompStatus_t") public static int nvcompBatchedGzipDecompressAsync(@Cast(value="const void*const*") @ByPtrPtr Pointer device_compressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t*") SizeTPointer device_actual_uncompressed_bytes, @Cast(value="size_t") long batch_size, Pointer device_temp_ptr, @Cast(value="size_t") long temp_bytes, @Cast(value="void*const*") @ByPtrPtr Pointer device_uncompressed_ptrs, @Cast(value="nvcompStatus_t*") int[] device_statuses, CUstream_st stream)
@Cast(value="nvcompStatus_t") public static int nvcompBatchedGzipGetDecompressSizeAsync(@Cast(value="const void*const*") PointerPointer device_compressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t") long batch_size, CUstream_st stream)
device_compress_ptrs
- The compressed chunks of data. List of pointers
must be GPU accessible along with each chunk.device_compressed_bytes
- The size of each compressed chunk. Must be GPU
accessible.device_uncompressed_bytes
- The calculated decompressed size of each
chunk. Must be GPU accessible.batch_size
- The number of chunksstream
- The CUDA stream to operate on.@Cast(value="nvcompStatus_t") public static int nvcompBatchedGzipGetDecompressSizeAsync(@Cast(value="const void*const*") @ByPtrPtr Pointer device_compressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t") long batch_size, CUstream_st stream)
@MemberGetter @Const @ByRef public static nvcompBatchedLZ4Opts_t nvcompBatchedLZ4DefaultOpts()
@MemberGetter @Cast(value="const size_t") public static long nvcompLZ4CompressionMaxAllowedChunkSize()
@MemberGetter @Cast(value="const size_t") public static long nvcompLZ4RequiredAlignment()
@Cast(value="nvcompStatus_t") public static int nvcompBatchedLZ4CompressGetTempSize(@Cast(value="size_t") long batch_size, @Cast(value="size_t") long max_uncompressed_chunk_bytes, @ByVal nvcompBatchedLZ4Opts_t format_opts, @Cast(value="size_t*") SizeTPointer temp_bytes)
batch_size
- The number of items in the batch.max_uncompressed_chunk_bytes
- The maximum size of a chunk in the
batch.format_opts
- The LZ4 compression options to use.temp_bytes
- The size of the required GPU workspace for compression
(output).@Cast(value="nvcompStatus_t") public static int nvcompBatchedLZ4CompressGetTempSizeEx(@Cast(value="size_t") long batch_size, @Cast(value="size_t") long max_uncompressed_chunk_bytes, @ByVal nvcompBatchedLZ4Opts_t format_opts, @Cast(value="size_t*") SizeTPointer temp_bytes, @Cast(value="const size_t") long max_total_uncompressed_bytes)
batch_size
- The number of items in the batch.max_uncompressed_chunk_bytes
- The maximum size of a chunk in the
batch.format_opts
- The LZ4 compression options to use.temp_bytes
- The size of the required GPU workspace for compression
(output).max_total_uncompressed_bytes
- Upper bound on the total uncompressed size of all
chunks@Cast(value="nvcompStatus_t") public static int nvcompBatchedLZ4CompressGetMaxOutputChunkSize(@Cast(value="size_t") long max_uncompressed_chunk_bytes, @ByVal nvcompBatchedLZ4Opts_t format_opts, @Cast(value="size_t*") SizeTPointer max_compressed_bytes)
max_uncompressed_chunk_bytes
- The maximum size of a chunk in the batch.format_opts
- The LZ4 compression options to use.max_compressed_byes
- The maximum compressed size of the largest chunk
(output).@Cast(value="nvcompStatus_t") public static int nvcompBatchedLZ4CompressAsync(@Cast(value="const void*const*") PointerPointer device_uncompressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t") long max_uncompressed_chunk_bytes, @Cast(value="size_t") long batch_size, Pointer device_temp_ptr, @Cast(value="size_t") long temp_bytes, @Cast(value="void*const*") PointerPointer device_compressed_ptrs, @Cast(value="size_t*") SizeTPointer device_compressed_bytes, @ByVal nvcompBatchedLZ4Opts_t format_opts, CUstream_st stream)
device_uncompressed_ptrs
- The pointers on the GPU, to uncompressed batched items.
This pointer must be GPU accessible.device_uncompressed_bytes
- The size of each uncompressed batch item on the GPU.
Each chunk size MUST be a multiple of the size of the data type specified by
format_opts.data_type, else this may crash or produce invalid output.max_uncompressed_chunk_bytes
- The maximum size in bytes of the largest
chunk in the batch. This parameter is currently unused, so if it is not set
with the maximum size, it should be set to zero. If a future version makes
use of it, it will return an error if it is set to zero.batch_size
- The number of chunks to compress.device_temp_ptr
- The temporary GPU workspace.temp_bytes
- The size of the temporary GPU workspace.device_compressed_ptrs
- The pointers on the GPU, to the output location for
each compressed batch item (output). This pointer must be GPU accessible.device_compressed_bytes
- The compressed size of each chunk on the GPU
(output). This pointer must be GPU accessible.format_opts
- The LZ4 compression options to use.stream
- The CUDA stream to operate on.@Cast(value="nvcompStatus_t") public static int nvcompBatchedLZ4CompressAsync(@Cast(value="const void*const*") @ByPtrPtr Pointer device_uncompressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t") long max_uncompressed_chunk_bytes, @Cast(value="size_t") long batch_size, Pointer device_temp_ptr, @Cast(value="size_t") long temp_bytes, @Cast(value="void*const*") @ByPtrPtr Pointer device_compressed_ptrs, @Cast(value="size_t*") SizeTPointer device_compressed_bytes, @ByVal nvcompBatchedLZ4Opts_t format_opts, CUstream_st stream)
@Cast(value="nvcompStatus_t") public static int nvcompBatchedLZ4DecompressGetTempSize(@Cast(value="size_t") long num_chunks, @Cast(value="size_t") long max_uncompressed_chunk_bytes, @Cast(value="size_t*") SizeTPointer temp_bytes)
num_chunks
- The number of items in the batch.max_uncompressed_chunk_bytes
- The size of the largest chunk in bytes
when uncompressed.temp_bytes
- The amount of temporary GPU space that will be required to
decompress.@Cast(value="nvcompStatus_t") public static int nvcompBatchedLZ4DecompressGetTempSizeEx(@Cast(value="size_t") long num_chunks, @Cast(value="size_t") long max_uncompressed_chunk_bytes, @Cast(value="size_t*") SizeTPointer temp_bytes, @Cast(value="size_t") long max_uncompressed_total_size)
num_chunks
- The number of items in the batch.max_uncompressed_chunk_bytes
- The size of the largest chunk in bytes
when uncompressed.temp_bytes
- The amount of temporary GPU space that will be required to
decompress.max_uncompressed_total_size
- The total decompressed size of all the chunks.
Unused in lz4.@Cast(value="nvcompStatus_t") public static int nvcompBatchedLZ4DecompressAsync(@Cast(value="const void*const*") PointerPointer device_compressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t*") SizeTPointer device_actual_uncompressed_bytes, @Cast(value="size_t") long batch_size, Pointer device_temp_ptr, @Cast(value="size_t") long temp_bytes, @Cast(value="void*const*") PointerPointer device_uncompressed_ptrs, @Cast(value="nvcompStatus_t*") IntPointer device_statuses, CUstream_st stream)
device_compressed_ptrs
- The pointers on the GPU, to the compressed
chunks.device_compressed_bytes
- The size of each compressed chunk on the GPU.device_uncompressed_bytes
- The decompressed buffer size. This is needed
to prevent OOB accesses.device_actual_uncompressed_bytes
- The actual calculated decompressed
size of each chunk. Can be nullptr if desired,
in which case the actual_uncompressed_bytes is not reported.batch_size
- The number of chunks to decompress.device_temp_ptr
- The temporary GPU space.temp_bytes
- The size of the temporary GPU space.device_uncompressed_ptrs
- The pointers on the GPU, to where to
uncompress each chunk (output).device_statuses
- The status for each chunk of whether it was
decompressed or not. Can be nullptr if desired,
in which case error status is not reported.stream
- The CUDA stream to operate on.@Cast(value="nvcompStatus_t") public static int nvcompBatchedLZ4DecompressAsync(@Cast(value="const void*const*") @ByPtrPtr Pointer device_compressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t*") SizeTPointer device_actual_uncompressed_bytes, @Cast(value="size_t") long batch_size, Pointer device_temp_ptr, @Cast(value="size_t") long temp_bytes, @Cast(value="void*const*") @ByPtrPtr Pointer device_uncompressed_ptrs, @Cast(value="nvcompStatus_t*") IntPointer device_statuses, CUstream_st stream)
@Cast(value="nvcompStatus_t") public static int nvcompBatchedLZ4DecompressAsync(@Cast(value="const void*const*") @ByPtrPtr Pointer device_compressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t*") SizeTPointer device_actual_uncompressed_bytes, @Cast(value="size_t") long batch_size, Pointer device_temp_ptr, @Cast(value="size_t") long temp_bytes, @Cast(value="void*const*") @ByPtrPtr Pointer device_uncompressed_ptrs, @Cast(value="nvcompStatus_t*") IntBuffer device_statuses, CUstream_st stream)
@Cast(value="nvcompStatus_t") public static int nvcompBatchedLZ4DecompressAsync(@Cast(value="const void*const*") @ByPtrPtr Pointer device_compressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t*") SizeTPointer device_actual_uncompressed_bytes, @Cast(value="size_t") long batch_size, Pointer device_temp_ptr, @Cast(value="size_t") long temp_bytes, @Cast(value="void*const*") @ByPtrPtr Pointer device_uncompressed_ptrs, @Cast(value="nvcompStatus_t*") int[] device_statuses, CUstream_st stream)
@Cast(value="nvcompStatus_t") public static int nvcompBatchedLZ4GetDecompressSizeAsync(@Cast(value="const void*const*") PointerPointer device_compressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t") long batch_size, CUstream_st stream)
device_compress_ptrs
- The compressed chunks of data. List of pointers
must be GPU accessible along with each chunk.device_compressed_bytes
- The size of each compressed chunk. Must be GPU
accessible.device_uncompressed_bytes
- The calculated decompressed size of each
chunk. Must be GPU accessible.batch_size
- The number of chunks.stream
- The CUDA stream to operate on.@Cast(value="nvcompStatus_t") public static int nvcompBatchedLZ4GetDecompressSizeAsync(@Cast(value="const void*const*") @ByPtrPtr Pointer device_compressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t") long batch_size, CUstream_st stream)
@MemberGetter @Const @ByRef public static nvcompBatchedSnappyOpts_t nvcompBatchedSnappyDefaultOpts()
@MemberGetter @Cast(value="const size_t") public static long nvcompSnappyCompressionMaxAllowedChunkSize()
@MemberGetter @Cast(value="const size_t") public static long nvcompSnappyRequiredAlignment()
@Cast(value="nvcompStatus_t") public static int nvcompBatchedSnappyDecompressGetTempSize(@Cast(value="size_t") long num_chunks, @Cast(value="size_t") long max_uncompressed_chunk_size, @Cast(value="size_t*") SizeTPointer temp_bytes)
num_chunks
- The number of items in the batch.max_uncompressed_chunk_size
- The size of the largest chunk when uncompressed.temp_bytes
- The amount of temporary GPU space that will be required to
decompress.@Cast(value="nvcompStatus_t") public static int nvcompBatchedSnappyDecompressGetTempSizeEx(@Cast(value="size_t") long num_chunks, @Cast(value="size_t") long max_uncompressed_chunk_size, @Cast(value="size_t*") SizeTPointer temp_bytes, @Cast(value="size_t") long max_uncompressed_total_size)
num_chunks
- The number of items in the batch.max_uncompressed_chunk_size
- The size of the largest chunk when uncompressed.temp_bytes
- The amount of temporary GPU space that will be required to
decompress.max_uncompressed_total_size
- The total decompressed size of all the chunks.
Unused in snappy.@Cast(value="nvcompStatus_t") public static int nvcompBatchedSnappyGetDecompressSizeAsync(@Cast(value="const void*const*") PointerPointer device_compressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t") long batch_size, CUstream_st stream)
device_compresed_ptrs
- The pointers on the GPU, to the compressed chunks.device_compressed_bytes
- The size of each compressed chunk on the GPU.device_uncompressed_bytes
- The actual size of each uncompressed chunk.batch_size
- The number of chunks in the batch.stream
- The CUDA stream to operate on.@Cast(value="nvcompStatus_t") public static int nvcompBatchedSnappyGetDecompressSizeAsync(@Cast(value="const void*const*") @ByPtrPtr Pointer device_compressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t") long batch_size, CUstream_st stream)
@Cast(value="nvcompStatus_t") public static int nvcompBatchedSnappyDecompressAsync(@Cast(value="const void*const*") PointerPointer device_compresed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t*") SizeTPointer device_actual_uncompressed_bytes, @Cast(value="size_t") long batch_size, Pointer device_temp_ptr, @Cast(value="const size_t") long temp_bytes, @Cast(value="void*const*") PointerPointer device_uncompressed_ptrs, @Cast(value="nvcompStatus_t*") IntPointer device_statuses, CUstream_st stream)
device_compresed_ptrs
- The pointers on the GPU, to the compressed chunks.device_compressed_bytes
- The size of each compressed chunk on the GPU.device_uncompressed_bytes
- The size of each device_uncompressed_ptr[i] buffer.device_actual_uncompressed_bytes
- The actual size of each uncompressed chunk
Can be nullptr if desired, in which case the actual_uncompressed_bytes is not reported.batch_size
- The number of chunks in the batch.device_temp_ptr
- The temporary GPU space, could be NULL in case temprorary space is not needed.temp_bytes
- The size of the temporary GPU space.device_uncompressed_ptrs
- The pointers on the GPU, to where to uncompress each chunk (output).device_statuses
- The pointers on the GPU, to where to uncompress each chunk (output).
Can be nullptr if desired, in which case error status is not reported.stream
- The CUDA stream to operate on.@Cast(value="nvcompStatus_t") public static int nvcompBatchedSnappyDecompressAsync(@Cast(value="const void*const*") @ByPtrPtr Pointer device_compresed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t*") SizeTPointer device_actual_uncompressed_bytes, @Cast(value="size_t") long batch_size, Pointer device_temp_ptr, @Cast(value="const size_t") long temp_bytes, @Cast(value="void*const*") @ByPtrPtr Pointer device_uncompressed_ptrs, @Cast(value="nvcompStatus_t*") IntPointer device_statuses, CUstream_st stream)
@Cast(value="nvcompStatus_t") public static int nvcompBatchedSnappyDecompressAsync(@Cast(value="const void*const*") @ByPtrPtr Pointer device_compresed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t*") SizeTPointer device_actual_uncompressed_bytes, @Cast(value="size_t") long batch_size, Pointer device_temp_ptr, @Cast(value="const size_t") long temp_bytes, @Cast(value="void*const*") @ByPtrPtr Pointer device_uncompressed_ptrs, @Cast(value="nvcompStatus_t*") IntBuffer device_statuses, CUstream_st stream)
@Cast(value="nvcompStatus_t") public static int nvcompBatchedSnappyDecompressAsync(@Cast(value="const void*const*") @ByPtrPtr Pointer device_compresed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t*") SizeTPointer device_actual_uncompressed_bytes, @Cast(value="size_t") long batch_size, Pointer device_temp_ptr, @Cast(value="const size_t") long temp_bytes, @Cast(value="void*const*") @ByPtrPtr Pointer device_uncompressed_ptrs, @Cast(value="nvcompStatus_t*") int[] device_statuses, CUstream_st stream)
@Cast(value="nvcompStatus_t") public static int nvcompBatchedSnappyCompressGetTempSize(@Cast(value="size_t") long batch_size, @Cast(value="size_t") long max_uncompressed_chunk_bytes, @ByVal nvcompBatchedSnappyOpts_t format_ops, @Cast(value="size_t*") SizeTPointer temp_bytes)
batch_size
- The number of items in the batch.max_uncompressed_chunk_bytes
- The maximum size of a chunk in the batch.format_ops
- Snappy compression options.temp_bytes
- The size of the required GPU workspace for compression
(output).@Cast(value="nvcompStatus_t") public static int nvcompBatchedSnappyCompressGetTempSizeEx(@Cast(value="size_t") long batch_size, @Cast(value="size_t") long max_uncompressed_chunk_bytes, @ByVal nvcompBatchedSnappyOpts_t format_ops, @Cast(value="size_t*") SizeTPointer temp_bytes, @Cast(value="const size_t") long max_total_uncompressed_bytes)
batch_size
- The number of items in the batch.max_uncompressed_chunk_bytes
- The maximum size of a chunk in the batch.format_ops
- Snappy compression options.temp_bytes
- The size of the required GPU workspace for compression
(output).max_total_uncompressed_bytes
- Upper bound on the total uncompressed size of all
chunks@Cast(value="nvcompStatus_t") public static int nvcompBatchedSnappyCompressGetMaxOutputChunkSize(@Cast(value="size_t") long max_chunk_size, @ByVal nvcompBatchedSnappyOpts_t format_opts, @Cast(value="size_t*") SizeTPointer max_compressed_size)
max_chunk_size
- The maximum size of a chunk in the batch.format_ops
- Snappy compression options.max_compressed_size
- The maximum compressed size of the largest chunk
(output).@Cast(value="nvcompStatus_t") public static int nvcompBatchedSnappyCompressAsync(@Cast(value="const void*const*") PointerPointer device_uncompressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t") long max_uncompressed_chunk_bytes, @Cast(value="size_t") long batch_size, Pointer device_temp_ptr, @Cast(value="size_t") long temp_bytes, @Cast(value="void*const*") PointerPointer device_compressed_ptrs, @Cast(value="size_t*") SizeTPointer device_compressed_bytes, @ByVal nvcompBatchedSnappyOpts_t format_ops, CUstream_st stream)
device_uncompressed_ptrs
- The pointers on the GPU, to uncompressed batched items.device_uncompressed_bytes
- The size of each uncompressed batch item on the GPU.max_uncompressed_chunk_bytes
- The size of the largest uncompressed chunk.batch_size
- The number of chunks in the batch.device_temp_ptr
- The temporary GPU workspace, could be NULL in case temprorary space is not needed.temp_bytes
- The size of the temporary GPU workspace.device_compressed_ptrs
- The pointers on the GPU, to the output location for each compressed batch item (output).device_compressed_bytes
- The compressed size of each chunk on the GPU (output).format_ops
- Snappy compression options.stream
- The CUDA stream to operate on.@Cast(value="nvcompStatus_t") public static int nvcompBatchedSnappyCompressAsync(@Cast(value="const void*const*") @ByPtrPtr Pointer device_uncompressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t") long max_uncompressed_chunk_bytes, @Cast(value="size_t") long batch_size, Pointer device_temp_ptr, @Cast(value="size_t") long temp_bytes, @Cast(value="void*const*") @ByPtrPtr Pointer device_compressed_ptrs, @Cast(value="size_t*") SizeTPointer device_compressed_bytes, @ByVal nvcompBatchedSnappyOpts_t format_ops, CUstream_st stream)
@MemberGetter @Const @ByRef public static nvcompBatchedZstdOpts_t nvcompBatchedZstdDefaultOpts()
@MemberGetter @Cast(value="const size_t") public static long nvcompZstdCompressionMaxAllowedChunkSize()
@MemberGetter @Cast(value="const size_t") public static long nvcompZstdRequiredAlignment()
@Cast(value="nvcompStatus_t") public static int nvcompBatchedZstdDecompressGetTempSize(@Cast(value="size_t") long num_chunks, @Cast(value="size_t") long max_uncompressed_chunk_size, @Cast(value="size_t*") SizeTPointer temp_bytes)
num_chunks
- The number of items in the batch.max_uncompressed_chunk_size
- The size of the largest chunk when uncompressed.temp_bytes
- The amount of temporary GPU space that will be required to
decompress.@Cast(value="nvcompStatus_t") public static int nvcompBatchedZstdDecompressGetTempSizeEx(@Cast(value="size_t") long num_chunks, @Cast(value="size_t") long max_uncompressed_chunk_size, @Cast(value="size_t*") SizeTPointer temp_bytes, @Cast(value="size_t") long max_uncompressed_total_size)
num_chunks
- The number of items in the batch.max_uncompressed_chunk_size
- The size of the largest chunk when uncompressed.temp_bytes
- The amount of temporary GPU space that will be required to
decompress.max_uncompressed_total_size
- The total decompressed size of all the chunks.@Cast(value="nvcompStatus_t") public static int nvcompBatchedZstdGetDecompressSizeAsync(@Cast(value="const void*const*") PointerPointer device_compressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t") long batch_size, CUstream_st stream)
device_compresed_ptrs
- The pointers on the GPU, to the compressed chunks.device_compressed_bytes
- The size of each compressed chunk on the GPU.device_uncompressed_bytes
- The actual size of each uncompressed chunk.batch_size
- The number of chunks in the batch.stream
- The CUDA stream to operate on.@Cast(value="nvcompStatus_t") public static int nvcompBatchedZstdGetDecompressSizeAsync(@Cast(value="const void*const*") @ByPtrPtr Pointer device_compressed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t") long batch_size, CUstream_st stream)
@Cast(value="nvcompStatus_t") public static int nvcompBatchedZstdDecompressAsync(@Cast(value="const void*const*") PointerPointer device_compresed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t*") SizeTPointer device_actual_uncompressed_bytes, @Cast(value="size_t") long batch_size, Pointer device_temp_ptr, @Cast(value="const size_t") long temp_bytes, @Cast(value="void*const*") PointerPointer device_uncompressed_ptrs, @Cast(value="nvcompStatus_t*") IntPointer device_statuses, CUstream_st stream)
device_compresed_ptrs
- The pointers on the GPU, to the compressed chunks.device_compressed_bytes
- The size of each compressed chunk on the GPU.device_uncompressed_bytes
- The size of each device_uncompressed_ptrs[i] buffer.device_actual_uncompressed_bytes
- The actual size of each uncompressed chunkbatch_size
- The number of chunks in the batch.device_temp_ptr
- The temporary GPU space, could be NULL in case temprorary space is not needed.temp_bytes
- The size of the temporary GPU space.device_uncompressed_ptrs
- The pointers on the GPU, to where to uncompress each chunk (output).device_statuses
- The pointers on the GPU, to where to uncompress each chunk (output).stream
- The CUDA stream to operate on.@Cast(value="nvcompStatus_t") public static int nvcompBatchedZstdDecompressAsync(@Cast(value="const void*const*") @ByPtrPtr Pointer device_compresed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t*") SizeTPointer device_actual_uncompressed_bytes, @Cast(value="size_t") long batch_size, Pointer device_temp_ptr, @Cast(value="const size_t") long temp_bytes, @Cast(value="void*const*") @ByPtrPtr Pointer device_uncompressed_ptrs, @Cast(value="nvcompStatus_t*") IntPointer device_statuses, CUstream_st stream)
@Cast(value="nvcompStatus_t") public static int nvcompBatchedZstdDecompressAsync(@Cast(value="const void*const*") @ByPtrPtr Pointer device_compresed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t*") SizeTPointer device_actual_uncompressed_bytes, @Cast(value="size_t") long batch_size, Pointer device_temp_ptr, @Cast(value="const size_t") long temp_bytes, @Cast(value="void*const*") @ByPtrPtr Pointer device_uncompressed_ptrs, @Cast(value="nvcompStatus_t*") IntBuffer device_statuses, CUstream_st stream)
@Cast(value="nvcompStatus_t") public static int nvcompBatchedZstdDecompressAsync(@Cast(value="const void*const*") @ByPtrPtr Pointer device_compresed_ptrs, @Cast(value="const size_t*") SizeTPointer device_compressed_bytes, @Cast(value="const size_t*") SizeTPointer device_uncompressed_bytes, @Cast(value="size_t*") SizeTPointer device_actual_uncompressed_bytes, @Cast(value="size_t") long batch_size, Pointer device_temp_ptr, @Cast(value="const size_t") long temp_bytes, @Cast(value="void*const*") @ByPtrPtr Pointer device_uncompressed_ptrs, @Cast(value="nvcompStatus_t*") int[] device_statuses, CUstream_st stream)
@Cast(value="nvcompStatus_t") public static int nvcompBatchedZstdCompressAsync(@Cast(value="const void*const*const") PointerPointer device_uncompressed_ptrs, @Cast(value="const size_t*const") SizeTPointer device_uncompressed_bytes, @Cast(value="const size_t") long max_uncompressed_chunk_bytes, @Cast(value="const size_t") long batch_size, Pointer device_temp_ptr, @Cast(value="const size_t") long temp_bytes, @Cast(value="void*const*const") PointerPointer device_compressed_ptrs, @Cast(value="size_t*const") SizeTPointer device_compressed_bytes, @Const @ByVal nvcompBatchedZstdOpts_t format_opts, CUstream_st stream)
device_uncompressed_ptrs
- The pointers on the GPU, to uncompressed batched items.
This pointer must be GPU accessible.device_uncompressed_bytes
- The size of each uncompressed batch item on the GPU.
Each chunk size MUST be a multiple of the size of the data type specified by
format_opts.data_type, else this may crash or produce invalid output.max_uncompressed_chunk_bytes
- The maximum size in bytes of the largest
chunk in the batch. This parameter is currently unused, so if it is not set
with the maximum size, it should be set to zero. If a future version makes
use of it, it will return an error if it is set to zero.batch_size
- The number of chunks to compress.device_temp_ptr
- The temporary GPU workspace.temp_bytes
- The size of the temporary GPU workspace.device_compressed_ptrs
- The pointers on the GPU, to the output location for
each compressed batch item (output). This pointer must be GPU accessible.device_compressed_bytes
- The compressed size of each chunk on the GPU
(output). This pointer must be GPU accessible.format_opts
- The Zstd compression options to use. Currently empty.stream
- The CUDA stream to operate on.@Cast(value="nvcompStatus_t") public static int nvcompBatchedZstdCompressAsync(@Cast(value="const void*const*const") @ByPtrPtr Pointer device_uncompressed_ptrs, @Cast(value="const size_t*const") SizeTPointer device_uncompressed_bytes, @Cast(value="const size_t") long max_uncompressed_chunk_bytes, @Cast(value="const size_t") long batch_size, Pointer device_temp_ptr, @Cast(value="const size_t") long temp_bytes, @Cast(value="void*const*const") @ByPtrPtr Pointer device_compressed_ptrs, @Cast(value="size_t*const") SizeTPointer device_compressed_bytes, @Const @ByVal nvcompBatchedZstdOpts_t format_opts, CUstream_st stream)
@Cast(value="nvcompStatus_t") public static int nvcompBatchedZstdCompressGetMaxOutputChunkSize(@Cast(value="const size_t") long max_uncompressed_chunk_bytes, @Const @ByVal nvcompBatchedZstdOpts_t arg1, @Cast(value="size_t*const") SizeTPointer max_compressed_size)
max_uncompressed_chunk_bytes
- The maximum size of a chunk in the batch.format_opts
- The Zstd compression options to use. Currently empty.max_compressed_byes
- The maximum compressed size of the largest chunk
(output).@Cast(value="nvcompStatus_t") public static int nvcompBatchedZstdCompressGetTempSize(@Cast(value="const size_t") long batch_size, @Cast(value="const size_t") long max_uncompressed_chunk_bytes, @Const @ByVal nvcompBatchedZstdOpts_t format_opts, @Cast(value="size_t*") SizeTPointer temp_bytes)
batch_size
- The number of items in the batch.max_uncompressed_chunk_bytes
- The maximum size of a chunk in the
batch.format_opts
- The ZSTD compression options to use -- currently emptytemp_bytes
- The size of the required GPU workspace for compression
(output).@Cast(value="nvcompStatus_t") public static int nvcompBatchedZstdCompressGetTempSizeEx(@Cast(value="const size_t") long batch_size, @Cast(value="const size_t") long max_uncompressed_chunk_bytes, @Const @ByVal nvcompBatchedZstdOpts_t format_opts, @Cast(value="size_t*") SizeTPointer temp_bytes, @Cast(value="const size_t") long max_total_uncompressed_bytes)
batch_size
- The number of items in the batch.max_uncompressed_chunk_bytes
- The maximum size of a chunk in the
batch.format_opts
- The ZSTD compression options to use -- currently emptytemp_bytes
- The size of the required GPU workspace for compression
(output).max_total_uncompressed_bytes
- Upper bound on the total uncompressed size of all
chunksCopyright © 2024. All rights reserved.