nvcomp (JavaCPP Presets for CUDA 12.9-9.10-1.5.12 API)

java.lang.Object
- org.bytedeco.cuda.presets.nvcomp
- - org.bytedeco.cuda.global.nvcomp

All Implemented Interfaces:

InfoMapper
```
public class nvcomp
extends nvcomp
```

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`ComputeAndNoVerify` enum nvcomp::ChecksumPolicy
`static int`	`ComputeAndVerify` enum nvcomp::ChecksumPolicy
`static int`	`ComputeAndVerifyIfPresent` enum nvcomp::ChecksumPolicy
`static int`	`float16` enum nvcompANSDataType_t
`static int`	`NoComputeAndVerifyIfPresent` enum nvcomp::ChecksumPolicy
`static int`	`NoComputeNoVerify` enum nvcomp::ChecksumPolicy
`static int`	`NVCOMP_NATIVE` enum class nvcomp::BitstreamKind
`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_FLOAT16` 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_UINT8` 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
`static int`	`RAW` enum class nvcomp::BitstreamKind
`static int`	`uint8` enum nvcompANSDataType_t
`static int`	`WITH_UNCOMPRESSED_SIZE` enum class nvcomp::BitstreamKind

Constructor Summary

Constructors
Constructor and Description

nvcomp()

Constructors
Constructor and Description
`nvcomp()`

Method Summary

All Methods Static Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static nvcompManagerBase`	`create_manager(byte[] comp_buffer)`
`static nvcompManagerBase`	`create_manager(byte[] comp_buffer, CUstream_st stream, int checksum_policy)`
`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 checksum_policy)`
`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 checksum_policy)` \brief Construct a ManagerBase from a buffer This synchronizes the stream
`static nvcompManagerBase`	`create_manager(BytePointer comp_buffer, CUstream_st stream, int device_id, int checksum_policy)` Deprecated. This signature is deprecated, in favour of the one that does not accept a device_id, and instead gets the device from the stream.
`static long`	`nvcompANSCompressionMaxAllowedChunkSize()`
`static long`	`nvcompANSRequiredAlignment()` The most restrictive of minimum alignment requirements for void-type CUDA memory buffers used for input, output, or temporary memory, passed to compression or decompression functions.
`static int`	`nvcompBatchedANSCompressAsync(PointerPointer device_uncompressed_chunk_ptrs, SizeTPointer device_uncompressed_chunk_bytes, long max_uncompressed_chunk_bytes, long num_chunks, Pointer device_temp_ptr, long temp_bytes, PointerPointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, nvcompBatchedANSOpts_t format_opts, CUstream_st stream)` \brief Perform batched asynchronous compression.
`static int`	`nvcompBatchedANSCompressAsync(Pointer device_uncompressed_chunk_ptrs, SizeTPointer device_uncompressed_chunk_bytes, long max_uncompressed_chunk_bytes, long num_chunks, Pointer device_temp_ptr, long temp_bytes, Pointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, nvcompBatchedANSOpts_t format_opts, CUstream_st stream)`
`static int`	`nvcompBatchedANSCompressGetMaxOutputChunkSize(long max_uncompressed_chunk_bytes, nvcompBatchedANSOpts_t format_opts, SizeTPointer max_compressed_chunk_bytes)` \brief Get the maximum size that a chunk of size at most max_uncompressed_chunk_bytes could compress to.
`static int`	`nvcompBatchedANSCompressGetRequiredAlignments(nvcompBatchedANSOpts_t format_opts, nvcompAlignmentRequirements_t alignment_requirements)` \brief Get the minimum buffer alignment requirements for compression.
`static int`	`nvcompBatchedANSCompressGetTempSize(long num_chunks, long max_uncompressed_chunk_bytes, nvcompBatchedANSOpts_t format_opts, SizeTPointer temp_bytes)` \brief Get the amount of temporary memory required on the GPU for compression.
`static int`	`nvcompBatchedANSCompressGetTempSizeEx(long num_chunks, long max_uncompressed_chunk_bytes, nvcompBatchedANSOpts_t format_opts, SizeTPointer temp_bytes, long max_total_uncompressed_bytes)` \brief Get the amount of temporary memory required on the GPU for compression with extra total bytes argument.
`static int`	`nvcompBatchedANSDecompressAsync(PointerPointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_buffer_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, Pointer device_temp_ptr, long temp_bytes, PointerPointer device_uncompressed_chunk_ptrs, IntPointer device_statuses, CUstream_st stream)` \brief Perform batched asynchronous decompression.
`static int`	`nvcompBatchedANSDecompressAsync(Pointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_buffer_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, Pointer device_temp_ptr, long temp_bytes, Pointer device_uncompressed_chunk_ptrs, int[] device_statuses, CUstream_st stream)`
`static int`	`nvcompBatchedANSDecompressAsync(Pointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_buffer_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, Pointer device_temp_ptr, long temp_bytes, Pointer device_uncompressed_chunk_ptrs, IntBuffer device_statuses, CUstream_st stream)`
`static int`	`nvcompBatchedANSDecompressAsync(Pointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_buffer_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, Pointer device_temp_ptr, long temp_bytes, Pointer device_uncompressed_chunk_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 temporary memory required on the GPU for decompression.
`static int`	`nvcompBatchedANSDecompressGetTempSizeEx(long num_chunks, long max_uncompressed_chunk_bytes, SizeTPointer temp_bytes, long max_total_uncompressed_bytes)` \brief Get the amount of temporary memory required on the GPU for decompression with extra total bytes argument.
`static nvcompAlignmentRequirements_t`	`nvcompBatchedANSDecompressRequiredAlignments()` Minimum buffer alignment requirements for decompression.
`static nvcompBatchedANSOpts_t`	`nvcompBatchedANSDefaultOpts()`
`static int`	`nvcompBatchedANSGetDecompressSizeAsync(PointerPointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, CUstream_st stream)` \brief Asynchronously compute the number of bytes of uncompressed data for each compressed chunk.
`static int`	`nvcompBatchedANSGetDecompressSizeAsync(Pointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, CUstream_st stream)`
`static int`	`nvcompBatchedBitcompCompressAsync(PointerPointer device_uncompressed_chunk_ptrs, SizeTPointer device_uncompressed_chunk_bytes, long max_uncompressed_chunk_bytes, long num_chunks, Pointer device_temp_ptr, long temp_bytes, PointerPointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, nvcompBatchedBitcompOpts_t format_opts, CUstream_st stream)` \brief Perform batched asynchronous compression.
`static int`	`nvcompBatchedBitcompCompressAsync(Pointer device_uncompressed_chunk_ptrs, SizeTPointer device_uncompressed_chunk_bytes, long max_uncompressed_chunk_bytes, long num_chunks, Pointer device_temp_ptr, long temp_bytes, Pointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, nvcompBatchedBitcompOpts_t format_opts, CUstream_st stream)`
`static int`	`nvcompBatchedBitcompCompressGetMaxOutputChunkSize(long max_uncompressed_chunk_bytes, nvcompBatchedBitcompOpts_t format_opts, SizeTPointer max_compressed_chunk_bytes)` \brief Get the maximum size that a chunk of size at most max_uncompressed_chunk_bytes could compress to.
`static int`	`nvcompBatchedBitcompCompressGetRequiredAlignments(nvcompBatchedBitcompOpts_t format_opts, nvcompAlignmentRequirements_t alignment_requirements)` \brief Get the minimum buffer alignment requirements for compression.
`static int`	`nvcompBatchedBitcompCompressGetTempSize(long num_chunks, long max_uncompressed_chunk_bytes, nvcompBatchedBitcompOpts_t format_opts, SizeTPointer temp_bytes)` \brief Get the amount of temporary memory required on the GPU for compression.
`static int`	`nvcompBatchedBitcompCompressGetTempSizeEx(long num_chunks, long max_uncompressed_chunk_bytes, nvcompBatchedBitcompOpts_t format_opts, SizeTPointer temp_bytes, long max_total_uncompressed_bytes)` \brief Get the amount of temporary memory required on the GPU for compression with extra total bytes argument.
`static int`	`nvcompBatchedBitcompDecompressAsync(PointerPointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_buffer_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, Pointer device_temp_ptr, long temp_bytes, PointerPointer device_uncompressed_chunk_ptrs, IntPointer device_statuses, CUstream_st stream)` \brief Perform batched asynchronous decompression.
`static int`	`nvcompBatchedBitcompDecompressAsync(Pointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_buffer_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, Pointer device_temp_ptr, long temp_bytes, Pointer device_uncompressed_chunk_ptrs, int[] device_statuses, CUstream_st stream)`
`static int`	`nvcompBatchedBitcompDecompressAsync(Pointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_buffer_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, Pointer device_temp_ptr, long temp_bytes, Pointer device_uncompressed_chunk_ptrs, IntBuffer device_statuses, CUstream_st stream)`
`static int`	`nvcompBatchedBitcompDecompressAsync(Pointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_buffer_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, Pointer device_temp_ptr, long temp_bytes, Pointer device_uncompressed_chunk_ptrs, IntPointer device_statuses, CUstream_st stream)`
`static int`	`nvcompBatchedBitcompDecompressGetTempSize(long num_chunks, long max_uncompressed_chunk_bytes, SizeTPointer temp_bytes)` \brief Get the amount of temporary memory required on the GPU for decompression.
`static int`	`nvcompBatchedBitcompDecompressGetTempSizeEx(long num_chunks, long max_uncompressed_chunk_bytes, SizeTPointer temp_bytes, long max_total_uncompressed_bytes)` \brief Get the amount of temporary memory required on the GPU for decompression with extra total bytes argument.
`static nvcompAlignmentRequirements_t`	`nvcompBatchedBitcompDecompressRequiredAlignments()` Minimum buffer alignment requirements for decompression.
`static nvcompBatchedBitcompOpts_t`	`nvcompBatchedBitcompDefaultOpts()` Legacy alias for \ref nvcompBatchedBitcompOpts_t.
`static int`	`nvcompBatchedBitcompGetDecompressSizeAsync(PointerPointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, CUstream_st stream)` \brief Asynchronously compute the number of bytes of uncompressed data for each compressed chunk.
`static int`	`nvcompBatchedBitcompGetDecompressSizeAsync(Pointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, CUstream_st stream)`
`static int`	`nvcompBatchedCascadedCompressAsync(PointerPointer device_uncompressed_chunk_ptrs, SizeTPointer device_uncompressed_chunk_bytes, long max_uncompressed_chunk_bytes, long num_chunks, Pointer device_temp_ptr, long temp_bytes, PointerPointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, nvcompBatchedCascadedOpts_t format_opts, CUstream_st stream)` \brief Perform batched asynchronous compression.
`static int`	`nvcompBatchedCascadedCompressAsync(Pointer device_uncompressed_chunk_ptrs, SizeTPointer device_uncompressed_chunk_bytes, long max_uncompressed_chunk_bytes, long num_chunks, Pointer device_temp_ptr, long temp_bytes, Pointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, nvcompBatchedCascadedOpts_t format_opts, CUstream_st stream)`
`static int`	`nvcompBatchedCascadedCompressGetMaxOutputChunkSize(long max_uncompressed_chunk_bytes, nvcompBatchedCascadedOpts_t format_opts, SizeTPointer max_compressed_chunk_bytes)` \brief Get the maximum size that a chunk of size at most max_uncompressed_chunk_bytes could compress to.
`static int`	`nvcompBatchedCascadedCompressGetRequiredAlignments(nvcompBatchedCascadedOpts_t format_opts, nvcompAlignmentRequirements_t alignment_requirements)` \brief Get the minimum buffer alignment requirements for compression.
`static int`	`nvcompBatchedCascadedCompressGetTempSize(long num_chunks, long max_uncompressed_chunk_bytes, nvcompBatchedCascadedOpts_t format_opts, SizeTPointer temp_bytes)` \brief Get the amount of temporary memory required on the GPU for compression.
`static int`	`nvcompBatchedCascadedCompressGetTempSizeEx(long num_chunks, long max_uncompressed_chunk_bytes, nvcompBatchedCascadedOpts_t format_opts, SizeTPointer temp_bytes, long max_total_uncompressed_bytes)` \brief Get the amount of temporary memory required on the GPU for compression with extra total bytes argument.
`static int`	`nvcompBatchedCascadedDecompressAsync(PointerPointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_buffer_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, Pointer device_temp_ptr, long temp_bytes, PointerPointer device_uncompressed_chunk_ptrs, IntPointer device_statuses, CUstream_st stream)` \brief Perform batched asynchronous decompression.
`static int`	`nvcompBatchedCascadedDecompressAsync(Pointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_buffer_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, Pointer device_temp_ptr, long temp_bytes, Pointer device_uncompressed_chunk_ptrs, int[] device_statuses, CUstream_st stream)`
`static int`	`nvcompBatchedCascadedDecompressAsync(Pointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_buffer_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, Pointer device_temp_ptr, long temp_bytes, Pointer device_uncompressed_chunk_ptrs, IntBuffer device_statuses, CUstream_st stream)`
`static int`	`nvcompBatchedCascadedDecompressAsync(Pointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_buffer_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, Pointer device_temp_ptr, long temp_bytes, Pointer device_uncompressed_chunk_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 temporary memory required on the GPU for decompression.
`static int`	`nvcompBatchedCascadedDecompressGetTempSizeEx(long num_chunks, long max_uncompressed_chunk_bytes, SizeTPointer temp_bytes, long max_total_uncompressed_bytes)` \brief Get the amount of temporary memory required on the GPU for decompression with extra total bytes argument.
`static nvcompAlignmentRequirements_t`	`nvcompBatchedCascadedDecompressRequiredAlignments()` Minimum buffer alignment requirements for decompression.
`static nvcompBatchedCascadedOpts_t`	`nvcompBatchedCascadedDefaultOpts()`
`static int`	`nvcompBatchedCascadedGetDecompressSizeAsync(PointerPointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, CUstream_st stream)` \brief Asynchronously compute the number of bytes of uncompressed data for each compressed chunk.
`static int`	`nvcompBatchedCascadedGetDecompressSizeAsync(Pointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, CUstream_st stream)`
`static int`	`nvcompBatchedCRC32Async(PointerPointer device_uncompressed_chunk_ptrs, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, IntPointer device_CRC32_ptr, CUstream_st stream)` \brief Perform CRC32 checksum calculation asynchronously.
`static int`	`nvcompBatchedCRC32Async(Pointer device_uncompressed_chunk_ptrs, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, int[] device_CRC32_ptr, CUstream_st stream)`
`static int`	`nvcompBatchedCRC32Async(Pointer device_uncompressed_chunk_ptrs, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, IntBuffer device_CRC32_ptr, CUstream_st stream)`
`static int`	`nvcompBatchedCRC32Async(Pointer device_uncompressed_chunk_ptrs, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, IntPointer device_CRC32_ptr, CUstream_st stream)`
`static int`	`nvcompBatchedDeflateCompressAsync(PointerPointer device_uncompressed_chunk_ptrs, SizeTPointer device_uncompressed_chunk_bytes, long max_uncompressed_chunk_bytes, long num_chunks, Pointer device_temp_ptr, long temp_bytes, PointerPointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, nvcompBatchedDeflateOpts_t format_opts, CUstream_st stream)` \brief Perform batched asynchronous compression.
`static int`	`nvcompBatchedDeflateCompressAsync(Pointer device_uncompressed_chunk_ptrs, SizeTPointer device_uncompressed_chunk_bytes, long max_uncompressed_chunk_bytes, long num_chunks, Pointer device_temp_ptr, long temp_bytes, Pointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, nvcompBatchedDeflateOpts_t format_opts, CUstream_st stream)`
`static int`	`nvcompBatchedDeflateCompressGetMaxOutputChunkSize(long max_uncompressed_chunk_bytes, nvcompBatchedDeflateOpts_t format_opts, SizeTPointer max_compressed_chunk_bytes)` \brief Get the maximum size that a chunk of size at most max_uncompressed_chunk_bytes could compress to.
`static int`	`nvcompBatchedDeflateCompressGetRequiredAlignments(nvcompBatchedDeflateOpts_t format_opts, nvcompAlignmentRequirements_t alignment_requirements)` \brief Get the minimum buffer alignment requirements for compression.
`static int`	`nvcompBatchedDeflateCompressGetTempSize(long num_chunks, long max_uncompressed_chunk_bytes, nvcompBatchedDeflateOpts_t format_opts, SizeTPointer temp_bytes)` \brief Get the amount of temporary memory required on the GPU for compression.
`static int`	`nvcompBatchedDeflateCompressGetTempSizeEx(long num_chunks, long max_uncompressed_chunk_bytes, nvcompBatchedDeflateOpts_t format_opts, SizeTPointer temp_bytes, long max_total_uncompressed_bytes)` \brief Get the amount of temporary memory required on the GPU for compression with extra total bytes argument.
`static int`	`nvcompBatchedDeflateDecompressAsync(PointerPointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_buffer_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, Pointer device_temp_ptr, long temp_bytes, PointerPointer device_uncompressed_chunk_ptrs, IntPointer device_statuses, CUstream_st stream)` \brief Perform batched asynchronous decompression.
`static int`	`nvcompBatchedDeflateDecompressAsync(Pointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_buffer_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, Pointer device_temp_ptr, long temp_bytes, Pointer device_uncompressed_chunk_ptrs, int[] device_statuses, CUstream_st stream)`
`static int`	`nvcompBatchedDeflateDecompressAsync(Pointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_buffer_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, Pointer device_temp_ptr, long temp_bytes, Pointer device_uncompressed_chunk_ptrs, IntBuffer device_statuses, CUstream_st stream)`
`static int`	`nvcompBatchedDeflateDecompressAsync(Pointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_buffer_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, Pointer device_temp_ptr, long temp_bytes, Pointer device_uncompressed_chunk_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 temporary memory required on the GPU for decompression.
`static int`	`nvcompBatchedDeflateDecompressGetTempSizeEx(long num_chunks, long max_uncompressed_chunk_bytes, SizeTPointer temp_bytes, long max_total_uncompressed_bytes)` \brief Get the amount of temporary memory required on the GPU for decompression with extra total bytes argument.
`static nvcompAlignmentRequirements_t`	`nvcompBatchedDeflateDecompressRequiredAlignments()` Minimum buffer alignment requirements for decompression.
`static nvcompBatchedDeflateOpts_t`	`nvcompBatchedDeflateDefaultOpts()`
`static int`	`nvcompBatchedDeflateGetDecompressSizeAsync(PointerPointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, CUstream_st stream)` \brief Asynchronously compute the number of bytes of uncompressed data for each compressed chunk.
`static int`	`nvcompBatchedDeflateGetDecompressSizeAsync(Pointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, CUstream_st stream)`
`static int`	`nvcompBatchedGdeflateCompressAsync(PointerPointer device_uncompressed_chunk_ptrs, SizeTPointer device_uncompressed_chunk_bytes, long max_uncompressed_chunk_bytes, long num_chunks, Pointer device_temp_ptr, long temp_bytes, PointerPointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, nvcompBatchedGdeflateOpts_t format_opts, CUstream_st stream)` \brief Perform batched asynchronous compression.
`static int`	`nvcompBatchedGdeflateCompressAsync(Pointer device_uncompressed_chunk_ptrs, SizeTPointer device_uncompressed_chunk_bytes, long max_uncompressed_chunk_bytes, long num_chunks, Pointer device_temp_ptr, long temp_bytes, Pointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, nvcompBatchedGdeflateOpts_t format_opts, CUstream_st stream)`
`static int`	`nvcompBatchedGdeflateCompressGetMaxOutputChunkSize(long max_uncompressed_chunk_bytes, nvcompBatchedGdeflateOpts_t format_opts, SizeTPointer max_compressed_chunk_bytes)` \brief Get the maximum size that a chunk of size at most max_uncompressed_chunk_bytes could compress to.
`static int`	`nvcompBatchedGdeflateCompressGetRequiredAlignments(nvcompBatchedGdeflateOpts_t format_opts, nvcompAlignmentRequirements_t alignment_requirements)` \brief Get the minimum buffer alignment requirements for compression.
`static int`	`nvcompBatchedGdeflateCompressGetTempSize(long num_chunks, long max_uncompressed_chunk_bytes, nvcompBatchedGdeflateOpts_t format_opts, SizeTPointer temp_bytes)` \brief Get the amount of temporary memory required on the GPU for compression.
`static int`	`nvcompBatchedGdeflateCompressGetTempSizeEx(long num_chunks, long max_uncompressed_chunk_bytes, nvcompBatchedGdeflateOpts_t format_opts, SizeTPointer temp_bytes, long max_total_uncompressed_bytes)` \brief Get the amount of temporary memory required on the GPU for compression with extra total bytes argument.
`static int`	`nvcompBatchedGdeflateDecompressAsync(PointerPointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_buffer_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, Pointer device_temp_ptr, long temp_bytes, PointerPointer device_uncompressed_chunk_ptrs, IntPointer device_statuses, CUstream_st stream)` \brief Perform batched asynchronous decompression.
`static int`	`nvcompBatchedGdeflateDecompressAsync(Pointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_buffer_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, Pointer device_temp_ptr, long temp_bytes, Pointer device_uncompressed_chunk_ptrs, int[] device_statuses, CUstream_st stream)`
`static int`	`nvcompBatchedGdeflateDecompressAsync(Pointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_buffer_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, Pointer device_temp_ptr, long temp_bytes, Pointer device_uncompressed_chunk_ptrs, IntBuffer device_statuses, CUstream_st stream)`
`static int`	`nvcompBatchedGdeflateDecompressAsync(Pointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_buffer_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, Pointer device_temp_ptr, long temp_bytes, Pointer device_uncompressed_chunk_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 temporary memory required on the GPU for decompression.
`static int`	`nvcompBatchedGdeflateDecompressGetTempSizeEx(long num_chunks, long max_uncompressed_chunk_bytes, SizeTPointer temp_bytes, long max_total_uncompressed_bytes)` \brief Get the amount of temporary memory required on the GPU for decompression with extra total bytes argument.
`static nvcompAlignmentRequirements_t`	`nvcompBatchedGdeflateDecompressRequiredAlignments()` Minimum buffer alignment requirements for decompression.
`static nvcompBatchedGdeflateOpts_t`	`nvcompBatchedGdeflateDefaultOpts()`
`static int`	`nvcompBatchedGdeflateGetDecompressSizeAsync(PointerPointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, CUstream_st stream)` \brief Asynchronously compute the number of bytes of uncompressed data for each compressed chunk.
`static int`	`nvcompBatchedGdeflateGetDecompressSizeAsync(Pointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, CUstream_st stream)`
`static int`	`nvcompBatchedGzipDecompressAsync(PointerPointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_buffer_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, Pointer device_temp_ptr, long temp_bytes, PointerPointer device_uncompressed_chunk_ptrs, IntPointer device_statuses, CUstream_st stream)` \brief Perform batched asynchronous decompression.
`static int`	`nvcompBatchedGzipDecompressAsync(Pointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_buffer_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, Pointer device_temp_ptr, long temp_bytes, Pointer device_uncompressed_chunk_ptrs, int[] device_statuses, CUstream_st stream)`
`static int`	`nvcompBatchedGzipDecompressAsync(Pointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_buffer_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, Pointer device_temp_ptr, long temp_bytes, Pointer device_uncompressed_chunk_ptrs, IntBuffer device_statuses, CUstream_st stream)`
`static int`	`nvcompBatchedGzipDecompressAsync(Pointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_buffer_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, Pointer device_temp_ptr, long temp_bytes, Pointer device_uncompressed_chunk_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 temporary memory required on the GPU for decompression.
`static int`	`nvcompBatchedGzipDecompressGetTempSizeEx(long num_chunks, long max_uncompressed_chunk_bytes, SizeTPointer temp_bytes, long max_total_uncompressed_bytes)` \brief Get the amount of temporary memory required on the GPU for decompression with extra total bytes argument.
`static nvcompAlignmentRequirements_t`	`nvcompBatchedGzipDecompressRequiredAlignments()` Minimum buffer alignment requirements for decompression.
`static nvcompBatchedGzipOpts_t`	`nvcompBatchedGzipDefaultOpts()`
`static int`	`nvcompBatchedGzipGetDecompressSizeAsync(PointerPointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, CUstream_st stream)` \brief Asynchronously compute the number of bytes of uncompressed data for each compressed chunk.
`static int`	`nvcompBatchedGzipGetDecompressSizeAsync(Pointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, CUstream_st stream)`
`static int`	`nvcompBatchedLZ4CompressAsync(PointerPointer device_uncompressed_chunk_ptrs, SizeTPointer device_uncompressed_chunk_bytes, long max_uncompressed_chunk_bytes, long num_chunks, Pointer device_temp_ptr, long temp_bytes, PointerPointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, nvcompBatchedLZ4Opts_t format_opts, CUstream_st stream)` \brief Perform batched asynchronous compression.
`static int`	`nvcompBatchedLZ4CompressAsync(Pointer device_uncompressed_chunk_ptrs, SizeTPointer device_uncompressed_chunk_bytes, long max_uncompressed_chunk_bytes, long num_chunks, Pointer device_temp_ptr, long temp_bytes, Pointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, nvcompBatchedLZ4Opts_t format_opts, CUstream_st stream)`
`static int`	`nvcompBatchedLZ4CompressGetMaxOutputChunkSize(long max_uncompressed_chunk_bytes, nvcompBatchedLZ4Opts_t format_opts, SizeTPointer max_compressed_chunk_bytes)` \brief Get the maximum size that a chunk of size at most max_uncompressed_chunk_bytes could compress to.
`static int`	`nvcompBatchedLZ4CompressGetRequiredAlignments(nvcompBatchedLZ4Opts_t format_opts, nvcompAlignmentRequirements_t alignment_requirements)` \brief Get the minimum buffer alignment requirements for compression.
`static int`	`nvcompBatchedLZ4CompressGetTempSize(long num_chunks, long max_uncompressed_chunk_bytes, nvcompBatchedLZ4Opts_t format_opts, SizeTPointer temp_bytes)` \brief Get the amount of temporary memory required on the GPU for compression.
`static int`	`nvcompBatchedLZ4CompressGetTempSizeEx(long num_chunks, long max_uncompressed_chunk_bytes, nvcompBatchedLZ4Opts_t format_opts, SizeTPointer temp_bytes, long max_total_uncompressed_bytes)` \brief Get the amount of temporary memory required on the GPU for compression with extra total bytes argument.
`static int`	`nvcompBatchedLZ4DecompressAsync(PointerPointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_buffer_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, Pointer device_temp_ptr, long temp_bytes, PointerPointer device_uncompressed_chunk_ptrs, IntPointer device_statuses, CUstream_st stream)` \brief Perform batched asynchronous decompression.
`static int`	`nvcompBatchedLZ4DecompressAsync(Pointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_buffer_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, Pointer device_temp_ptr, long temp_bytes, Pointer device_uncompressed_chunk_ptrs, int[] device_statuses, CUstream_st stream)`
`static int`	`nvcompBatchedLZ4DecompressAsync(Pointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_buffer_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, Pointer device_temp_ptr, long temp_bytes, Pointer device_uncompressed_chunk_ptrs, IntBuffer device_statuses, CUstream_st stream)`
`static int`	`nvcompBatchedLZ4DecompressAsync(Pointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_buffer_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, Pointer device_temp_ptr, long temp_bytes, Pointer device_uncompressed_chunk_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 temporary memory required on the GPU for decompression.
`static int`	`nvcompBatchedLZ4DecompressGetTempSizeEx(long num_chunks, long max_uncompressed_chunk_bytes, SizeTPointer temp_bytes, long max_total_uncompressed_bytes)` \brief Get the amount of temporary memory required on the GPU for decompression with extra total bytes argument.
`static nvcompAlignmentRequirements_t`	`nvcompBatchedLZ4DecompressRequiredAlignments()` Minimum buffer alignment requirements for decompression.
`static nvcompBatchedLZ4Opts_t`	`nvcompBatchedLZ4DefaultOpts()`
`static int`	`nvcompBatchedLZ4GetDecompressSizeAsync(PointerPointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, CUstream_st stream)` \brief Asynchronously compute the number of bytes of uncompressed data for each compressed chunk.
`static int`	`nvcompBatchedLZ4GetDecompressSizeAsync(Pointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, CUstream_st stream)`
`static int`	`nvcompBatchedSnappyCompressAsync(PointerPointer device_uncompressed_chunk_ptrs, SizeTPointer device_uncompressed_chunk_bytes, long max_uncompressed_chunk_bytes, long num_chunks, Pointer device_temp_ptr, long temp_bytes, PointerPointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, nvcompBatchedSnappyOpts_t format_opts, CUstream_st stream)` \brief Perform batched asynchronous compression.
`static int`	`nvcompBatchedSnappyCompressAsync(Pointer device_uncompressed_chunk_ptrs, SizeTPointer device_uncompressed_chunk_bytes, long max_uncompressed_chunk_bytes, long num_chunks, Pointer device_temp_ptr, long temp_bytes, Pointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, nvcompBatchedSnappyOpts_t format_opts, CUstream_st stream)`
`static int`	`nvcompBatchedSnappyCompressGetMaxOutputChunkSize(long max_uncompressed_chunk_bytes, nvcompBatchedSnappyOpts_t format_opts, SizeTPointer max_compressed_chunk_bytes)` \brief Get the maximum size that a chunk of size at most max_uncompressed_chunk_bytes could compress to.
`static int`	`nvcompBatchedSnappyCompressGetRequiredAlignments(nvcompBatchedSnappyOpts_t format_opts, nvcompAlignmentRequirements_t alignment_requirements)` \brief Get the minimum buffer alignment requirements for compression.
`static int`	`nvcompBatchedSnappyCompressGetTempSize(long num_chunks, long max_uncompressed_chunk_bytes, nvcompBatchedSnappyOpts_t format_opts, SizeTPointer temp_bytes)` \brief Get the amount of temporary memory required on the GPU for compression.
`static int`	`nvcompBatchedSnappyCompressGetTempSizeEx(long num_chunks, long max_uncompressed_chunk_bytes, nvcompBatchedSnappyOpts_t format_opts, SizeTPointer temp_bytes, long max_total_uncompressed_bytes)` \brief Get the amount of temporary memory required on the GPU for compression with extra total bytes argument.
`static int`	`nvcompBatchedSnappyDecompressAsync(PointerPointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_buffer_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, Pointer device_temp_ptr, long temp_bytes, PointerPointer device_uncompressed_chunk_ptrs, IntPointer device_statuses, CUstream_st stream)` \brief Perform batched asynchronous decompression.
`static int`	`nvcompBatchedSnappyDecompressAsync(Pointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_buffer_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, Pointer device_temp_ptr, long temp_bytes, Pointer device_uncompressed_chunk_ptrs, int[] device_statuses, CUstream_st stream)`
`static int`	`nvcompBatchedSnappyDecompressAsync(Pointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_buffer_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, Pointer device_temp_ptr, long temp_bytes, Pointer device_uncompressed_chunk_ptrs, IntBuffer device_statuses, CUstream_st stream)`
`static int`	`nvcompBatchedSnappyDecompressAsync(Pointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_buffer_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, Pointer device_temp_ptr, long temp_bytes, Pointer device_uncompressed_chunk_ptrs, IntPointer device_statuses, CUstream_st stream)`
`static int`	`nvcompBatchedSnappyDecompressGetTempSize(long num_chunks, long max_uncompressed_chunk_bytes, SizeTPointer temp_bytes)` \brief Get the amount of temporary memory required on the GPU for decompression.
`static int`	`nvcompBatchedSnappyDecompressGetTempSizeEx(long num_chunks, long max_uncompressed_chunk_bytes, SizeTPointer temp_bytes, long max_total_uncompressed_bytes)` \brief Get the amount of temporary memory required on the GPU for decompression with extra total bytes argument.
`static nvcompAlignmentRequirements_t`	`nvcompBatchedSnappyDecompressRequiredAlignments()` Minimum buffer alignment requirements for decompression.
`static nvcompBatchedSnappyOpts_t`	`nvcompBatchedSnappyDefaultOpts()`
`static int`	`nvcompBatchedSnappyGetDecompressSizeAsync(PointerPointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, CUstream_st stream)` \brief Asynchronously compute the number of bytes of uncompressed data for each compressed chunk.
`static int`	`nvcompBatchedSnappyGetDecompressSizeAsync(Pointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, CUstream_st stream)`
`static int`	`nvcompBatchedZstdCompressAsync(PointerPointer device_uncompressed_chunk_ptrs, SizeTPointer device_uncompressed_chunk_bytes, long max_uncompressed_chunk_bytes, long num_chunks, Pointer device_temp_ptr, long temp_bytes, PointerPointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, nvcompBatchedZstdOpts_t format_opts, CUstream_st stream)` \brief Perform batched asynchronous compression.
`static int`	`nvcompBatchedZstdCompressAsync(Pointer device_uncompressed_chunk_ptrs, SizeTPointer device_uncompressed_chunk_bytes, long max_uncompressed_chunk_bytes, long num_chunks, Pointer device_temp_ptr, long temp_bytes, Pointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, nvcompBatchedZstdOpts_t format_opts, CUstream_st stream)`
`static int`	`nvcompBatchedZstdCompressGetMaxOutputChunkSize(long max_uncompressed_chunk_bytes, nvcompBatchedZstdOpts_t format_opts, SizeTPointer max_compressed_chunk_bytes)` \brief Get the maximum size that a chunk of size at most max_uncompressed_chunk_bytes could compress to.
`static int`	`nvcompBatchedZstdCompressGetRequiredAlignments(nvcompBatchedZstdOpts_t format_opts, nvcompAlignmentRequirements_t alignment_requirements)` \brief Get the minimum buffer alignment requirements for compression.
`static int`	`nvcompBatchedZstdCompressGetTempSize(long num_chunks, long max_uncompressed_chunk_bytes, nvcompBatchedZstdOpts_t format_opts, SizeTPointer temp_bytes)` \brief Get the amount of temporary memory required on the GPU for compression.
`static int`	`nvcompBatchedZstdCompressGetTempSizeEx(long num_chunks, long max_uncompressed_chunk_bytes, nvcompBatchedZstdOpts_t format_opts, SizeTPointer temp_bytes, long max_total_uncompressed_bytes)` \brief Get the amount of temporary memory required on the GPU for compression with extra total bytes argument.
`static int`	`nvcompBatchedZstdDecompressAsync(PointerPointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_buffer_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, Pointer device_temp_ptr, long temp_bytes, PointerPointer device_uncompressed_chunk_ptrs, IntPointer device_statuses, CUstream_st stream)` \brief Perform batched asynchronous decompression.
`static int`	`nvcompBatchedZstdDecompressAsync(Pointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_buffer_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, Pointer device_temp_ptr, long temp_bytes, Pointer device_uncompressed_chunk_ptrs, int[] device_statuses, CUstream_st stream)`
`static int`	`nvcompBatchedZstdDecompressAsync(Pointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_buffer_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, Pointer device_temp_ptr, long temp_bytes, Pointer device_uncompressed_chunk_ptrs, IntBuffer device_statuses, CUstream_st stream)`
`static int`	`nvcompBatchedZstdDecompressAsync(Pointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_buffer_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, Pointer device_temp_ptr, long temp_bytes, Pointer device_uncompressed_chunk_ptrs, IntPointer device_statuses, CUstream_st stream)`
`static int`	`nvcompBatchedZstdDecompressGetTempSize(long num_chunks, long max_uncompressed_chunk_bytes, SizeTPointer temp_bytes)` \brief Get the amount of temporary memory required on the GPU for decompression.
`static int`	`nvcompBatchedZstdDecompressGetTempSizeEx(long num_chunks, long max_uncompressed_chunk_bytes, SizeTPointer temp_bytes, long max_total_uncompressed_bytes)` \brief Get the amount of temporary memory required on the GPU for decompression with extra total bytes argument.
`static nvcompAlignmentRequirements_t`	`nvcompBatchedZstdDecompressRequiredAlignments()` Minimum buffer alignment requirements for decompression.
`static nvcompBatchedZstdOpts_t`	`nvcompBatchedZstdDefaultOpts()`
`static int`	`nvcompBatchedZstdGetDecompressSizeAsync(PointerPointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, CUstream_st stream)` \brief Asynchronously compute the number of bytes of uncompressed data for each compressed chunk.
`static int`	`nvcompBatchedZstdGetDecompressSizeAsync(Pointer device_compressed_chunk_ptrs, SizeTPointer device_compressed_chunk_bytes, SizeTPointer device_uncompressed_chunk_bytes, long num_chunks, CUstream_st stream)`
`static long`	`nvcompBitcompCompressionMaxAllowedChunkSize()`
`static long`	`nvcompBitcompRequiredAlignment()` The most restrictive of minimum alignment requirements for void-type CUDA memory buffers used for input, output, or temporary memory, passed to compression or decompression functions.
`static long`	`nvcompCascadedCompressionMaxAllowedChunkSize()`
`static long`	`nvcompCascadedRequiredAlignment()` The most restrictive of minimum alignment requirements for void-type CUDA memory buffers used for input, output, or temporary memory, passed to compression or decompression functions.
`static long`	`nvcompDeflateCompressionMaxAllowedChunkSize()` Although chunk sizes up to 2GB are theoretically possible, compression with large chunks may be very slow or use large amounts of temporary memory, so caution is advised when using chunk sizes above 64KB.
`static long`	`nvcompDeflateRequiredAlignment()` The most restrictive of minimum alignment requirements for void-type CUDA memory buffers used for input, output, or temporary memory, passed to compression or decompression functions.
`static long`	`nvcompGdeflateCompressionMaxAllowedChunkSize()` Although chunk sizes up to 2GB are theoretically possible, compression with large chunks may be very slow or use large amounts of temporary memory, so caution is advised when using chunk sizes above 64KB.
`static long`	`nvcompGdeflateRequiredAlignment()` The most restrictive of minimum alignment requirements for void-type CUDA memory buffers used for input, output, or temporary memory, passed to compression or decompression functions.
`static int`	`nvcompGetProperties(nvcompProperties_t properties)` \brief Provides nvCOMP library properties.
`static long`	`nvcompLZ4CompressionMaxAllowedChunkSize()`
`static long`	`nvcompLZ4RequiredAlignment()` The most restrictive of minimum alignment requirements for void-type CUDA memory buffers used for input, output, or temporary memory, passed to compression or decompression functions.
`static long`	`nvcompSnappyCompressionMaxAllowedChunkSize()`
`static long`	`nvcompSnappyRequiredAlignment()` The most restrictive of minimum alignment requirements for void-type CUDA memory buffers used for input, output, or temporary memory, passed to compression or decompression functions.
`static long`	`nvcompZstdCompressionMaxAllowedChunkSize()`
`static long`	`nvcompZstdRequiredAlignment()` The most restrictive of minimum alignment requirements for void-type CUDA memory buffers used for input, output, or temporary memory, passed to compression or decompression functions.

Methods inherited from class org.bytedeco.cuda.presets.nvcomp
map

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail
- nvcompSuccess
```
public static final int nvcompSuccess
```
  enum nvcompStatus_t
  
  See Also:
  
  Constant Field Values
- nvcompErrorInvalidValue
```
public static final int nvcompErrorInvalidValue
```
  enum nvcompStatus_t
  
  See Also:
  
  Constant Field Values
- nvcompErrorNotSupported
```
public static final int nvcompErrorNotSupported
```
  enum nvcompStatus_t
  
  See Also:
  
  Constant Field Values
- nvcompErrorCannotDecompress
```
public static final int nvcompErrorCannotDecompress
```
  enum nvcompStatus_t
  
  See Also:
  
  Constant Field Values
- nvcompErrorBadChecksum
```
public static final int nvcompErrorBadChecksum
```
  enum nvcompStatus_t
  
  See Also:
  
  Constant Field Values
- nvcompErrorCannotVerifyChecksums
```
public static final int nvcompErrorCannotVerifyChecksums
```
  enum nvcompStatus_t
  
  See Also:
  
  Constant Field Values
- nvcompErrorOutputBufferTooSmall
```
public static final int nvcompErrorOutputBufferTooSmall
```
  enum nvcompStatus_t
  
  See Also:
  
  Constant Field Values
- nvcompErrorWrongHeaderLength
```
public static final int nvcompErrorWrongHeaderLength
```
  enum nvcompStatus_t
  
  See Also:
  
  Constant Field Values
- nvcompErrorAlignment
```
public static final int nvcompErrorAlignment
```
  enum nvcompStatus_t
  
  See Also:
  
  Constant Field Values
- nvcompErrorChunkSizeTooLarge
```
public static final int nvcompErrorChunkSizeTooLarge
```
  enum nvcompStatus_t
  
  See Also:
  
  Constant Field Values
- nvcompErrorCudaError
```
public static final int nvcompErrorCudaError
```
  enum nvcompStatus_t
  
  See Also:
  
  Constant Field Values
- nvcompErrorInternal
```
public static final int nvcompErrorInternal
```
  enum nvcompStatus_t
  
  See Also:
  
  Constant Field Values
- NVCOMP_TYPE_CHAR
```
public static final int NVCOMP_TYPE_CHAR
```
  enum nvcompType_t
  
  See Also:
  
  Constant Field Values
- NVCOMP_TYPE_UCHAR
```
public static final int NVCOMP_TYPE_UCHAR
```
  enum nvcompType_t
  
  See Also:
  
  Constant Field Values
- NVCOMP_TYPE_SHORT
```
public static final int NVCOMP_TYPE_SHORT
```
  enum nvcompType_t
  
  See Also:
  
  Constant Field Values
- NVCOMP_TYPE_USHORT
```
public static final int NVCOMP_TYPE_USHORT
```
  enum nvcompType_t
  
  See Also:
  
  Constant Field Values
- NVCOMP_TYPE_INT
```
public static final int NVCOMP_TYPE_INT
```
  enum nvcompType_t
  
  See Also:
  
  Constant Field Values
- NVCOMP_TYPE_UINT
```
public static final int NVCOMP_TYPE_UINT
```
  enum nvcompType_t
  
  See Also:
  
  Constant Field Values
- NVCOMP_TYPE_LONGLONG
```
public static final int NVCOMP_TYPE_LONGLONG
```
  enum nvcompType_t
  
  See Also:
  
  Constant Field Values
- NVCOMP_TYPE_ULONGLONG
```
public static final int NVCOMP_TYPE_ULONGLONG
```
  enum nvcompType_t
  
  See Also:
  
  Constant Field Values
- NVCOMP_TYPE_UINT8
```
public static final int NVCOMP_TYPE_UINT8
```
  enum nvcompType_t
  
  See Also:
  
  Constant Field Values
- NVCOMP_TYPE_FLOAT16
```
public static final int NVCOMP_TYPE_FLOAT16
```
  enum nvcompType_t
  
  See Also:
  
  Constant Field Values
- NVCOMP_TYPE_BITS
```
public static final int NVCOMP_TYPE_BITS
```
  enum nvcompType_t
  
  See Also:
  
  Constant Field Values
- NVCOMP_NATIVE
```
public static final int NVCOMP_NATIVE
```
  enum class nvcomp::BitstreamKind
  
  See Also:
  
  Constant Field Values
- RAW
```
public static final int RAW
```
  enum class nvcomp::BitstreamKind
  
  See Also:
  
  Constant Field Values
- WITH_UNCOMPRESSED_SIZE
```
public static final int WITH_UNCOMPRESSED_SIZE
```
  enum class nvcomp::BitstreamKind
  
  See Also:
  
  Constant Field Values
- NoComputeNoVerify
```
public static final int NoComputeNoVerify
```
  enum nvcomp::ChecksumPolicy
  
  See Also:
  
  Constant Field Values
- ComputeAndNoVerify
```
public static final int ComputeAndNoVerify
```
  enum nvcomp::ChecksumPolicy
  
  See Also:
  
  Constant Field Values
- NoComputeAndVerifyIfPresent
```
public static final int NoComputeAndVerifyIfPresent
```
  enum nvcomp::ChecksumPolicy
  
  See Also:
  
  Constant Field Values
- ComputeAndVerifyIfPresent
```
public static final int ComputeAndVerifyIfPresent
```
  enum nvcomp::ChecksumPolicy
  
  See Also:
  
  Constant Field Values
- ComputeAndVerify
```
public static final int ComputeAndVerify
```
  enum nvcomp::ChecksumPolicy
  
  See Also:
  
  Constant Field Values
- nvcomp_rANS
```
public static final int nvcomp_rANS
```
  enum nvcompANSType_t
  
  See Also:
  
  Constant Field Values
- uint8
```
public static final int uint8
```
  enum nvcompANSDataType_t
  
  See Also:
  
  Constant Field Values
- float16
```
public static final int float16
```
  enum nvcompANSDataType_t
  
  See Also:
  
  Constant Field Values

Constructor Detail
- nvcomp
```
public nvcomp()
```

Method Detail

nvcompGetProperties
```
@Cast(value="nvcompStatus_t")
public static int nvcompGetProperties(nvcompProperties_t properties)
```
\brief Provides nvCOMP library properties.

Parameters:

properties - [out] Set nvCOMP properties in nvcompProperties_t handle.

Returns:

nvcompErrorInvalidValue is properties is nullptr, nvcompSuccess otherwise

create_manager

@Namespace(value="nvcomp")
 @SharedPtr
public static nvcompManagerBase create_manager(@Cast(value="const uint8_t*")
                                                                                        BytePointer comp_buffer,
                                                                                        CUstream_st stream,
                                                                                        @Cast(value="nvcomp::ChecksumPolicy")
                                                                                        int checksum_policy)

\brief Construct a ManagerBase from a buffer This synchronizes the stream

create_manager

@Namespace(value="nvcomp")
 @SharedPtr
public static nvcompManagerBase create_manager(@Cast(value="const uint8_t*")
                                                                                        BytePointer comp_buffer)

create_manager

@Namespace(value="nvcomp")
 @SharedPtr
public static nvcompManagerBase create_manager(@Cast(value="const uint8_t*")
                                                                                        ByteBuffer comp_buffer,
                                                                                        CUstream_st stream,
                                                                                        @Cast(value="nvcomp::ChecksumPolicy")
                                                                                        int checksum_policy)

create_manager

@Namespace(value="nvcomp")
 @SharedPtr
public static nvcompManagerBase create_manager(@Cast(value="const uint8_t*")
                                                                                        ByteBuffer comp_buffer)

create_manager

@Namespace(value="nvcomp")
 @SharedPtr
public static nvcompManagerBase create_manager(@Cast(value="const uint8_t*")
                                                                                        byte[] comp_buffer,
                                                                                        CUstream_st stream,
                                                                                        @Cast(value="nvcomp::ChecksumPolicy")
                                                                                        int checksum_policy)

create_manager

@Namespace(value="nvcomp")
 @SharedPtr
public static nvcompManagerBase create_manager(@Cast(value="const uint8_t*")
                                                                                        byte[] comp_buffer)

create_manager

@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="nvcomp::ChecksumPolicy")
                                                                                        int checksum_policy)

Deprecated. This signature is deprecated, in favour of the one that does not accept a device_id, and instead gets the device from the stream.

\brief Construct a ManagerBase from a buffer

create_manager

@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="nvcomp::ChecksumPolicy")
                                                                                        int checksum_policy)

create_manager

@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="nvcomp::ChecksumPolicy")
                                                                                        int checksum_policy)

nvcompBatchedANSDefaultOpts

@MemberGetter
 @Const
 @ByRef
public static nvcompBatchedANSOpts_t nvcompBatchedANSDefaultOpts()

nvcompANSCompressionMaxAllowedChunkSize

@MemberGetter
 @Cast(value="const size_t")
public static long nvcompANSCompressionMaxAllowedChunkSize()

nvcompANSRequiredAlignment
```
@MemberGetter
 @Cast(value="const size_t")
public static long nvcompANSRequiredAlignment()
```
The most restrictive of minimum alignment requirements for void-type CUDA memory buffers used for input, output, or temporary memory, passed to compression or decompression functions. In all cases, typed memory buffers must still be aligned to their type's size, e.g., 4 bytes for int.

nvcompBatchedANSCompressGetRequiredAlignments

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedANSCompressGetRequiredAlignments(@ByVal
                                                                                               nvcompBatchedANSOpts_t format_opts,
                                                                                               nvcompAlignmentRequirements_t alignment_requirements)

\brief Get the minimum buffer alignment requirements for compression.

Parameters:: format_opts - [in] Compression options.; alignment_requirements - [out] The minimum buffer alignment requirements for compression.
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedANSCompressGetTempSize

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedANSCompressGetTempSize(@Cast(value="size_t")
                                                                                     long num_chunks,
                                                                                     @Cast(value="size_t")
                                                                                     long max_uncompressed_chunk_bytes,
                                                                                     @ByVal
                                                                                     nvcompBatchedANSOpts_t format_opts,
                                                                                     @Cast(value="size_t*")
                                                                                     SizeTPointer temp_bytes)

\brief Get the amount of temporary memory required on the GPU for compression.

Parameters:: num_chunks - [in] The number of chunks of memory in the batch.; max_uncompressed_chunk_bytes - [in] The maximum size of a chunk in the batch.; format_opts - [in] Compression options.; temp_bytes - [out] The amount of GPU memory that will be temporarily required during compression.
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedANSCompressGetTempSizeEx

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedANSCompressGetTempSizeEx(@Cast(value="size_t")
                                                                                       long num_chunks,
                                                                                       @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)

\brief Get the amount of temporary memory required on the GPU for compression with extra total bytes argument.

Parameters:: num_chunks - [in] The number of chunks of memory in the batch.; max_uncompressed_chunk_bytes - [in] The maximum size of a chunk in the batch.; format_opts - [in] Compression options.; temp_bytes - [out] The amount of GPU memory that will be temporarily required during compression.; max_total_uncompressed_bytes - [in] Upper bound on the total uncompressed size of all chunks
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedANSCompressGetMaxOutputChunkSize

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedANSCompressGetMaxOutputChunkSize(@Cast(value="size_t")
                                                                                               long max_uncompressed_chunk_bytes,
                                                                                               @ByVal
                                                                                               nvcompBatchedANSOpts_t format_opts,
                                                                                               @Cast(value="size_t*")
                                                                                               SizeTPointer max_compressed_chunk_bytes)

Parameters:: max_uncompressed_chunk_bytes - [in] The maximum size of a chunk before compression.; format_opts - [in] Compression options.; max_compressed_chunk_bytes - [out] The maximum possible compressed size of the chunk.
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedANSCompressAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedANSCompressAsync(@Cast(value="const void*const*")
                                                                               PointerPointer device_uncompressed_chunk_ptrs,
                                                                               @Cast(value="const size_t*")
                                                                               SizeTPointer device_uncompressed_chunk_bytes,
                                                                               @Cast(value="size_t")
                                                                               long max_uncompressed_chunk_bytes,
                                                                               @Cast(value="size_t")
                                                                               long num_chunks,
                                                                               Pointer device_temp_ptr,
                                                                               @Cast(value="size_t")
                                                                               long temp_bytes,
                                                                               @Cast(value="void*const*")
                                                                               PointerPointer device_compressed_chunk_ptrs,
                                                                               @Cast(value="size_t*")
                                                                               SizeTPointer device_compressed_chunk_bytes,
                                                                               @ByVal
                                                                               nvcompBatchedANSOpts_t format_opts,
                                                                               CUstream_st stream)

\brief Perform batched asynchronous compression. \note Violating any of the conditions listed in the parameter descriptions below may result in undefined behaviour.

Parameters:: device_uncompressed_chunk_ptrs - [in] Array with size \p num_chunks of pointers to the uncompressed data chunks. Both the pointers and the uncompressed data should reside in device-accessible memory. Each chunk must be aligned to the value in the input member of the \ref nvcompAlignmentRequirements_t object output by nvcompBatchedANSCompressGetRequiredAlignments when called with the same \p format_opts.; device_uncompressed_chunk_bytes - [in] Array with size \p num_chunks of sizes of the uncompressed chunks in bytes. The sizes should reside in device-accessible memory.; max_uncompressed_chunk_bytes - [in] The size of the largest uncompressed chunk.; num_chunks - [in] Number of chunks of data to compress.; device_temp_ptr - [in] The temporary GPU workspace, could be NULL in case temporary memory is not needed. Must be aligned to the value in the temp member of the \ref nvcompAlignmentRequirements_t object output by nvcompBatchedANSCompressGetRequiredAlignments when called with the same \p format_opts.; temp_bytes - [in] The size of the temporary GPU memory pointed to by device_temp_ptr.; device_compressed_chunk_ptrs - [out] Array with size \p num_chunks 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 the size given by nvcompBatchedANSCompressGetMaxOutputChunkSize. Each compressed buffer must be aligned to the value in the output member of the \ref nvcompAlignmentRequirements_t object output by nvcompBatchedANSCompressGetRequiredAlignments when called with the same \p format_opts.; device_compressed_chunk_bytes - [out] Array with size \p num_chunks, to be filled with the compressed sizes of each chunk. The buffer should be preallocated in device-accessible memory.; format_opts - [in] Compression options.; stream - [in] The CUDA stream to operate on.
Returns:: nvcompSuccess if successfully launched, and an error code otherwise.

nvcompBatchedANSCompressAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedANSCompressAsync(@Cast(value="const void*const*") @ByPtrPtr
                                                                               Pointer device_uncompressed_chunk_ptrs,
                                                                               @Cast(value="const size_t*")
                                                                               SizeTPointer device_uncompressed_chunk_bytes,
                                                                               @Cast(value="size_t")
                                                                               long max_uncompressed_chunk_bytes,
                                                                               @Cast(value="size_t")
                                                                               long num_chunks,
                                                                               Pointer device_temp_ptr,
                                                                               @Cast(value="size_t")
                                                                               long temp_bytes,
                                                                               @Cast(value="void*const*") @ByPtrPtr
                                                                               Pointer device_compressed_chunk_ptrs,
                                                                               @Cast(value="size_t*")
                                                                               SizeTPointer device_compressed_chunk_bytes,
                                                                               @ByVal
                                                                               nvcompBatchedANSOpts_t format_opts,
                                                                               CUstream_st stream)

nvcompBatchedANSDecompressRequiredAlignments

@MemberGetter
 @Const
 @ByRef
public static nvcompAlignmentRequirements_t nvcompBatchedANSDecompressRequiredAlignments()

Minimum buffer alignment requirements for decompression.

nvcompBatchedANSDecompressGetTempSize

@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)

\brief Get the amount of temporary memory required on the GPU for decompression.

Parameters:: num_chunks - [in] Number of chunks of data to be decompressed.; max_uncompressed_chunk_bytes - [in] The size of the largest chunk in bytes when uncompressed.; temp_bytes - [out] The amount of GPU memory that will be temporarily required during decompression.
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedANSDecompressGetTempSizeEx

@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_total_uncompressed_bytes)

\brief Get the amount of temporary memory required on the GPU for decompression with extra total bytes argument.

Parameters:: num_chunks - [in] Number of chunks of data to be decompressed.; max_uncompressed_chunk_bytes - [in] The size of the largest chunk in bytes when uncompressed.; temp_bytes - [out] The amount of GPU memory that will be temporarily required during decompression.; max_total_uncompressed_bytes - [in] The total decompressed size of all the chunks. Unused in ANS.
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedANSGetDecompressSizeAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedANSGetDecompressSizeAsync(@Cast(value="const void*const*")
                                                                                        PointerPointer device_compressed_chunk_ptrs,
                                                                                        @Cast(value="const size_t*")
                                                                                        SizeTPointer device_compressed_chunk_bytes,
                                                                                        @Cast(value="size_t*")
                                                                                        SizeTPointer device_uncompressed_chunk_bytes,
                                                                                        @Cast(value="size_t")
                                                                                        long num_chunks,
                                                                                        CUstream_st stream)

\brief Asynchronously compute the number of bytes of uncompressed data for each compressed chunk. \note Violating any of the conditions listed in the parameter descriptions below may result in undefined behaviour.

Parameters:: device_compressed_chunk_ptrs - [in] Array with size \p num_chunks of pointers in device-accessible memory to compressed buffers. Each buffer must be aligned to the value in nvcompBatchedANSDecompressRequiredAlignments.input.; device_compressed_chunk_bytes - [in] Array with size \p num_chunks of sizes of the compressed buffers in bytes. The sizes should reside in device-accessible memory.; device_uncompressed_chunk_bytes - [out] Array with size \p num_chunks to be filled with the sizes, in bytes, of each uncompressed data chunk. If there is an error when retrieving the size of a chunk, the uncompressed size of that chunk will be set to 0. This argument needs to be preallocated in device-accessible memory.; num_chunks - [in] Number of data chunks to compute sizes of.; stream - [in] The CUDA stream to operate on.
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedANSGetDecompressSizeAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedANSGetDecompressSizeAsync(@Cast(value="const void*const*") @ByPtrPtr
                                                                                        Pointer device_compressed_chunk_ptrs,
                                                                                        @Cast(value="const size_t*")
                                                                                        SizeTPointer device_compressed_chunk_bytes,
                                                                                        @Cast(value="size_t*")
                                                                                        SizeTPointer device_uncompressed_chunk_bytes,
                                                                                        @Cast(value="size_t")
                                                                                        long num_chunks,
                                                                                        CUstream_st stream)

nvcompBatchedANSDecompressAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedANSDecompressAsync(@Cast(value="const void*const*")
                                                                                 PointerPointer device_compressed_chunk_ptrs,
                                                                                 @Cast(value="const size_t*")
                                                                                 SizeTPointer device_compressed_chunk_bytes,
                                                                                 @Cast(value="const size_t*")
                                                                                 SizeTPointer device_uncompressed_buffer_bytes,
                                                                                 @Cast(value="size_t*")
                                                                                 SizeTPointer device_uncompressed_chunk_bytes,
                                                                                 @Cast(value="size_t")
                                                                                 long num_chunks,
                                                                                 Pointer device_temp_ptr,
                                                                                 @Cast(value="size_t")
                                                                                 long temp_bytes,
                                                                                 @Cast(value="void*const*")
                                                                                 PointerPointer device_uncompressed_chunk_ptrs,
                                                                                 @Cast(value="nvcompStatus_t*")
                                                                                 IntPointer device_statuses,
                                                                                 CUstream_st stream)

\brief Perform batched asynchronous decompression. This function is used to decompress compressed buffers produced by nvcompBatchedANSCompressAsync. \note Violating any of the conditions listed in the parameter descriptions below may result in undefined behaviour.

Parameters:: device_compressed_chunk_ptrs - [in] Array with size \p num_chunks of pointers in device-accessible memory to device-accessible compressed buffers. Each buffer must be aligned to the value in nvcompBatchedANSDecompressRequiredAlignments.input.; device_compressed_chunk_bytes - [in] Array with size \p num_chunks of sizes of the compressed buffers in bytes. The sizes should reside in device-accessible memory.; device_uncompressed_buffer_bytes - [in] Array with size \p num_chunks of sizes, in bytes, of the output buffers to be filled with uncompressed data for each chunk. The sizes should reside in device-accessible memory. If a size is not large enough to hold all decompressed data, the decompressor will set the status in \p device_statuses corresponding to the overflow chunk to nvcompErrorCannotDecompress.; device_uncompressed_chunk_bytes - [out] Array with size \p num_chunks to be filled with the actual number of bytes decompressed for every chunk. This argument needs to be preallocated.; num_chunks - [in] Number of chunks of data to decompress.; device_temp_ptr - [in] The temporary GPU space, could be NULL in case temporary space is not needed. Must be aligned to the value in nvcompBatchedANSDecompressRequiredAlignments.temp.; temp_bytes - [in] The size of the temporary GPU space.; device_uncompressed_chunk_ptrs - [out] Array with size \p num_chunks of pointers in device-accessible memory to decompressed data. Each uncompressed buffer needs to be preallocated in device-accessible memory, have the size specified by the corresponding entry in \p device_uncompressed_buffer_bytes, and be aligned to the value in nvcompBatchedANSDecompressRequiredAlignments.output.; device_statuses - [out] Array with size \p num_chunks of statuses in device-accessible memory. This argument needs to be preallocated. For each chunk, 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.
Returns:: nvcompSuccess if successfully launched, and an error code otherwise.

nvcompBatchedANSDecompressAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedANSDecompressAsync(@Cast(value="const void*const*") @ByPtrPtr
                                                                                 Pointer device_compressed_chunk_ptrs,
                                                                                 @Cast(value="const size_t*")
                                                                                 SizeTPointer device_compressed_chunk_bytes,
                                                                                 @Cast(value="const size_t*")
                                                                                 SizeTPointer device_uncompressed_buffer_bytes,
                                                                                 @Cast(value="size_t*")
                                                                                 SizeTPointer device_uncompressed_chunk_bytes,
                                                                                 @Cast(value="size_t")
                                                                                 long num_chunks,
                                                                                 Pointer device_temp_ptr,
                                                                                 @Cast(value="size_t")
                                                                                 long temp_bytes,
                                                                                 @Cast(value="void*const*") @ByPtrPtr
                                                                                 Pointer device_uncompressed_chunk_ptrs,
                                                                                 @Cast(value="nvcompStatus_t*")
                                                                                 IntPointer device_statuses,
                                                                                 CUstream_st stream)

nvcompBatchedANSDecompressAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedANSDecompressAsync(@Cast(value="const void*const*") @ByPtrPtr
                                                                                 Pointer device_compressed_chunk_ptrs,
                                                                                 @Cast(value="const size_t*")
                                                                                 SizeTPointer device_compressed_chunk_bytes,
                                                                                 @Cast(value="const size_t*")
                                                                                 SizeTPointer device_uncompressed_buffer_bytes,
                                                                                 @Cast(value="size_t*")
                                                                                 SizeTPointer device_uncompressed_chunk_bytes,
                                                                                 @Cast(value="size_t")
                                                                                 long num_chunks,
                                                                                 Pointer device_temp_ptr,
                                                                                 @Cast(value="size_t")
                                                                                 long temp_bytes,
                                                                                 @Cast(value="void*const*") @ByPtrPtr
                                                                                 Pointer device_uncompressed_chunk_ptrs,
                                                                                 @Cast(value="nvcompStatus_t*")
                                                                                 IntBuffer device_statuses,
                                                                                 CUstream_st stream)

nvcompBatchedANSDecompressAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedANSDecompressAsync(@Cast(value="const void*const*") @ByPtrPtr
                                                                                 Pointer device_compressed_chunk_ptrs,
                                                                                 @Cast(value="const size_t*")
                                                                                 SizeTPointer device_compressed_chunk_bytes,
                                                                                 @Cast(value="const size_t*")
                                                                                 SizeTPointer device_uncompressed_buffer_bytes,
                                                                                 @Cast(value="size_t*")
                                                                                 SizeTPointer device_uncompressed_chunk_bytes,
                                                                                 @Cast(value="size_t")
                                                                                 long num_chunks,
                                                                                 Pointer device_temp_ptr,
                                                                                 @Cast(value="size_t")
                                                                                 long temp_bytes,
                                                                                 @Cast(value="void*const*") @ByPtrPtr
                                                                                 Pointer device_uncompressed_chunk_ptrs,
                                                                                 @Cast(value="nvcompStatus_t*")
                                                                                 int[] device_statuses,
                                                                                 CUstream_st stream)

nvcompBatchedBitcompDefaultOpts

@MemberGetter
 @Const
 @ByRef
public static nvcompBatchedBitcompOpts_t nvcompBatchedBitcompDefaultOpts()

Legacy alias for \ref nvcompBatchedBitcompOpts_t.

nvcompBitcompCompressionMaxAllowedChunkSize

@MemberGetter
 @Cast(value="const size_t")
public static long nvcompBitcompCompressionMaxAllowedChunkSize()

nvcompBitcompRequiredAlignment
```
@MemberGetter
 @Cast(value="const size_t")
public static long nvcompBitcompRequiredAlignment()
```
The most restrictive of minimum alignment requirements for void-type CUDA memory buffers used for input, output, or temporary memory, passed to compression or decompression functions. In all cases, typed memory buffers must still be aligned to their type's size, e.g., 4 bytes for int.

nvcompBatchedBitcompCompressGetRequiredAlignments

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedBitcompCompressGetRequiredAlignments(@ByVal
                                                                                                   nvcompBatchedBitcompOpts_t format_opts,
                                                                                                   nvcompAlignmentRequirements_t alignment_requirements)

\brief Get the minimum buffer alignment requirements for compression.

Parameters:: format_opts - [in] Compression options.; alignment_requirements - [out] The minimum buffer alignment requirements for compression.
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedBitcompCompressGetTempSize

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedBitcompCompressGetTempSize(@Cast(value="size_t")
                                                                                         long num_chunks,
                                                                                         @Cast(value="size_t")
                                                                                         long max_uncompressed_chunk_bytes,
                                                                                         @ByVal
                                                                                         nvcompBatchedBitcompOpts_t format_opts,
                                                                                         @Cast(value="size_t*")
                                                                                         SizeTPointer temp_bytes)

\brief Get the amount of temporary memory required on the GPU for compression. NOTE: Bitcomp currently doesn't use any temp memory for Compression.

Parameters:: num_chunks - [in] The number of chunks of memory in the batch.; max_uncompressed_chunk_bytes - [in] The maximum size of a chunk in the batch. This parameter is currently unused. Set it to either the actual value or zero.; format_opts - [in] Compression options.; temp_bytes - [out] The amount of GPU memory that will be temporarily required during compression.
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedBitcompCompressGetTempSizeEx

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedBitcompCompressGetTempSizeEx(@Cast(value="size_t")
                                                                                           long num_chunks,
                                                                                           @Cast(value="size_t")
                                                                                           long max_uncompressed_chunk_bytes,
                                                                                           @ByVal
                                                                                           nvcompBatchedBitcompOpts_t format_opts,
                                                                                           @Cast(value="size_t*")
                                                                                           SizeTPointer temp_bytes,
                                                                                           @Cast(value="const size_t")
                                                                                           long max_total_uncompressed_bytes)

\brief Get the amount of temporary memory required on the GPU for compression with extra total bytes argument. NOTE: Bitcomp currently doesn't use any temp memory.

Parameters:: num_chunks - [in] The number of chunks of memory in the batch.; max_uncompressed_chunk_bytes - [in] The maximum size of a chunk in the batch. This parameter is currently unused. Set it to either the actual value or zero.; format_opts - [in] Compression options.; temp_bytes - [out] The amount of GPU memory that will be temporarily required during compression.; max_total_uncompressed_bytes - [in] Upper bound on the total uncompressed size of all chunks
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedBitcompCompressGetMaxOutputChunkSize

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedBitcompCompressGetMaxOutputChunkSize(@Cast(value="size_t")
                                                                                                   long max_uncompressed_chunk_bytes,
                                                                                                   @ByVal
                                                                                                   nvcompBatchedBitcompOpts_t format_opts,
                                                                                                   @Cast(value="size_t*")
                                                                                                   SizeTPointer max_compressed_chunk_bytes)

Parameters:: max_uncompressed_chunk_bytes - [in] The maximum size of a chunk before compression.; format_opts - [in] Compression options.; max_compressed_chunk_bytes - [out] The maximum possible compressed size of the chunk.
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedBitcompCompressAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedBitcompCompressAsync(@Cast(value="const void*const*")
                                                                                   PointerPointer device_uncompressed_chunk_ptrs,
                                                                                   @Cast(value="const size_t*")
                                                                                   SizeTPointer device_uncompressed_chunk_bytes,
                                                                                   @Cast(value="size_t")
                                                                                   long max_uncompressed_chunk_bytes,
                                                                                   @Cast(value="size_t")
                                                                                   long num_chunks,
                                                                                   Pointer device_temp_ptr,
                                                                                   @Cast(value="size_t")
                                                                                   long temp_bytes,
                                                                                   @Cast(value="void*const*")
                                                                                   PointerPointer device_compressed_chunk_ptrs,
                                                                                   @Cast(value="size_t*")
                                                                                   SizeTPointer device_compressed_chunk_bytes,
                                                                                   @ByVal
                                                                                   nvcompBatchedBitcompOpts_t format_opts,
                                                                                   CUstream_st stream)

\brief Perform batched asynchronous compression. \note Violating any of the conditions listed in the parameter descriptions below may result in undefined behaviour.

Parameters:: device_uncompressed_chunk_ptrs - [in] Array with size \p num_chunks of pointers to the uncompressed data chunks. Both the pointers and the uncompressed data should reside in device-accessible memory. Each chunk must be aligned to the value in the input member of the \ref nvcompAlignmentRequirements_t object output by nvcompBatchedBitcompCompressGetRequiredAlignments when called with the same \p format_opts.; device_uncompressed_chunk_bytes - [in] Array with size \p num_chunks of sizes of the uncompressed chunks 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.; max_uncompressed_chunk_bytes - [in] The maximum size of a chunk in the batch. This parameter is currently unused. Set it to either the actual value or zero.; num_chunks - [in] Number of chunks of data to compress.; device_temp_ptr - [in] This argument is not used.; temp_bytes - [in] This argument is not used.; device_compressed_chunk_ptrs - [out] Array with size \p num_chunks 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 the size given by nvcompBatchedBitcompCompressGetMaxOutputChunkSize. Each compressed buffer must be aligned to the value in the output member of the \ref nvcompAlignmentRequirements_t object output by nvcompBatchedBitcompCompressGetRequiredAlignments when called with the same \p format_opts.; device_compressed_chunk_bytes - [out] Array with size \p num_chunks, to be filled with the compressed sizes of each chunk. The buffer should be preallocated in device-accessible memory.; format_opts - [in] Compression options. They must be valid.; stream - [in] The CUDA stream to operate on.
Returns:: nvcompSuccess if successfully launched, and an error code otherwise.

nvcompBatchedBitcompCompressAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedBitcompCompressAsync(@Cast(value="const void*const*") @ByPtrPtr
                                                                                   Pointer device_uncompressed_chunk_ptrs,
                                                                                   @Cast(value="const size_t*")
                                                                                   SizeTPointer device_uncompressed_chunk_bytes,
                                                                                   @Cast(value="size_t")
                                                                                   long max_uncompressed_chunk_bytes,
                                                                                   @Cast(value="size_t")
                                                                                   long num_chunks,
                                                                                   Pointer device_temp_ptr,
                                                                                   @Cast(value="size_t")
                                                                                   long temp_bytes,
                                                                                   @Cast(value="void*const*") @ByPtrPtr
                                                                                   Pointer device_compressed_chunk_ptrs,
                                                                                   @Cast(value="size_t*")
                                                                                   SizeTPointer device_compressed_chunk_bytes,
                                                                                   @ByVal
                                                                                   nvcompBatchedBitcompOpts_t format_opts,
                                                                                   CUstream_st stream)

nvcompBatchedBitcompDecompressRequiredAlignments

@MemberGetter
 @Const
 @ByRef
public static nvcompAlignmentRequirements_t nvcompBatchedBitcompDecompressRequiredAlignments()

Minimum buffer alignment requirements for decompression.

nvcompBatchedBitcompDecompressGetTempSize

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedBitcompDecompressGetTempSize(@Cast(value="size_t")
                                                                                           long num_chunks,
                                                                                           @Cast(value="size_t")
                                                                                           long max_uncompressed_chunk_bytes,
                                                                                           @Cast(value="size_t*")
                                                                                           SizeTPointer temp_bytes)

\brief Get the amount of temporary memory required on the GPU for decompression. NOTE: Bitcomp currently doesn't use any temp memory.

Parameters:: num_chunks - [in] Number of chunks of data to be decompressed.; max_uncompressed_chunk_bytes - [in] The size of the largest chunk in bytes when uncompressed.; temp_bytes - [out] The amount of GPU memory that will be temporarily required during decompression.
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedBitcompDecompressGetTempSizeEx

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedBitcompDecompressGetTempSizeEx(@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_total_uncompressed_bytes)

\brief Get the amount of temporary memory required on the GPU for decompression with extra total bytes argument. NOTE: From 4.2, Bitcomp now uses temporary memory for Decompression, to prevent Device wide synchronizations that were occuring earlier.

Parameters:: num_chunks - [in] Number of chunks of data to be decompressed.; max_uncompressed_chunk_bytes - [in] The size of the largest chunk in bytes when uncompressed.; temp_bytes - [out] The amount of GPU memory that will be temporarily required during decompression. Unused in Bitcomp.; max_total_uncompressed_bytes - [in] The total decompressed size of all the chunks.

nvcompBatchedBitcompGetDecompressSizeAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedBitcompGetDecompressSizeAsync(@Cast(value="const void*const*")
                                                                                            PointerPointer device_compressed_chunk_ptrs,
                                                                                            @Cast(value="const size_t*")
                                                                                            SizeTPointer device_compressed_chunk_bytes,
                                                                                            @Cast(value="size_t*")
                                                                                            SizeTPointer device_uncompressed_chunk_bytes,
                                                                                            @Cast(value="size_t")
                                                                                            long num_chunks,
                                                                                            CUstream_st stream)

Parameters:: device_compressed_chunk_ptrs - [in] Array with size \p num_chunks of pointers in device-accessible memory to compressed buffers. Each buffer must be aligned to the value in nvcompBatchedBitcompDecompressRequiredAlignments.input.; device_compressed_chunk_bytes - [in] This argument is not used.; device_uncompressed_chunk_bytes - [out] Array with size \p num_chunks to be filled with the sizes, in bytes, of each uncompressed data chunk. If there is an error when retrieving the size of a chunk, the uncompressed size of that chunk will be set to 0. This argument needs to be preallocated in device-accessible memory.; num_chunks - [in] Number of data chunks to compute sizes of.; stream - [in] The CUDA stream to operate on.
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedBitcompGetDecompressSizeAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedBitcompGetDecompressSizeAsync(@Cast(value="const void*const*") @ByPtrPtr
                                                                                            Pointer device_compressed_chunk_ptrs,
                                                                                            @Cast(value="const size_t*")
                                                                                            SizeTPointer device_compressed_chunk_bytes,
                                                                                            @Cast(value="size_t*")
                                                                                            SizeTPointer device_uncompressed_chunk_bytes,
                                                                                            @Cast(value="size_t")
                                                                                            long num_chunks,
                                                                                            CUstream_st stream)

nvcompBatchedBitcompDecompressAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedBitcompDecompressAsync(@Cast(value="const void*const*")
                                                                                     PointerPointer device_compressed_chunk_ptrs,
                                                                                     @Cast(value="const size_t*")
                                                                                     SizeTPointer device_compressed_chunk_bytes,
                                                                                     @Cast(value="const size_t*")
                                                                                     SizeTPointer device_uncompressed_buffer_bytes,
                                                                                     @Cast(value="size_t*")
                                                                                     SizeTPointer device_uncompressed_chunk_bytes,
                                                                                     @Cast(value="size_t")
                                                                                     long num_chunks,
                                                                                     Pointer device_temp_ptr,
                                                                                     @Cast(value="size_t")
                                                                                     long temp_bytes,
                                                                                     @Cast(value="void*const*")
                                                                                     PointerPointer device_uncompressed_chunk_ptrs,
                                                                                     @Cast(value="nvcompStatus_t*")
                                                                                     IntPointer device_statuses,
                                                                                     CUstream_st stream)

\brief Perform batched asynchronous decompression. This function is used to decompress compressed buffers produced by nvcompBatchedBitcompCompressAsync. It can also decompress buffers compressed with the standalone Bitcomp library. \note Violating any of the conditions listed in the parameter descriptions below may result in undefined behaviour. \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. \note An asynchronous, faster version of batched Bitcomp asynchrnous decompression is available, and can be launched via the HLIF manager.

Parameters:: device_compressed_chunk_ptrs - [in] Array with size \p num_chunks of pointers in device-accessible memory to device-accessible compressed buffers. Each buffer must be aligned to the value in nvcompBatchedBitcompDecompressRequiredAlignments.input.; device_compressed_chunk_bytes - [in] This argument is not used.; device_uncompressed_buffer_bytes - [in] Array with size \p num_chunks of sizes, in bytes, of the output buffers to be filled with uncompressed data for each chunk. The sizes should reside in device-accessible memory. If a size is not large enough to hold all decompressed data, the decompressor will set the status in \p device_statuses corresponding to the overflow chunk to nvcompErrorCannotDecompress.; device_uncompressed_chunk_bytes - [out] Array with size \p num_chunks to be filled with the actual number of bytes decompressed for every chunk. This argument needs to be preallocated.; num_chunks - [in] Number of chunks of data to decompress.; device_temp_ptr - [in] Temporary scratch memory.; temp_bytes - [in] Size of temporary scratch memory.; device_uncompressed_chunk_ptrs - [out] Array with size \p num_chunks of pointers in device-accessible memory to decompressed data. Each uncompressed buffer needs to be preallocated in device-accessible memory, have the size specified by the corresponding entry in \p device_uncompressed_buffer_bytes, and be aligned to the value in nvcompBatchedBitcompDecompressRequiredAlignments.output.; device_statuses - [out] Array with size \p num_chunks of statuses in device-accessible memory. This argument needs to be preallocated. For each chunk, 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.
Returns:: nvcompSuccess if successfully launched, and an error code otherwise.

nvcompBatchedBitcompDecompressAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedBitcompDecompressAsync(@Cast(value="const void*const*") @ByPtrPtr
                                                                                     Pointer device_compressed_chunk_ptrs,
                                                                                     @Cast(value="const size_t*")
                                                                                     SizeTPointer device_compressed_chunk_bytes,
                                                                                     @Cast(value="const size_t*")
                                                                                     SizeTPointer device_uncompressed_buffer_bytes,
                                                                                     @Cast(value="size_t*")
                                                                                     SizeTPointer device_uncompressed_chunk_bytes,
                                                                                     @Cast(value="size_t")
                                                                                     long num_chunks,
                                                                                     Pointer device_temp_ptr,
                                                                                     @Cast(value="size_t")
                                                                                     long temp_bytes,
                                                                                     @Cast(value="void*const*") @ByPtrPtr
                                                                                     Pointer device_uncompressed_chunk_ptrs,
                                                                                     @Cast(value="nvcompStatus_t*")
                                                                                     IntPointer device_statuses,
                                                                                     CUstream_st stream)

nvcompBatchedBitcompDecompressAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedBitcompDecompressAsync(@Cast(value="const void*const*") @ByPtrPtr
                                                                                     Pointer device_compressed_chunk_ptrs,
                                                                                     @Cast(value="const size_t*")
                                                                                     SizeTPointer device_compressed_chunk_bytes,
                                                                                     @Cast(value="const size_t*")
                                                                                     SizeTPointer device_uncompressed_buffer_bytes,
                                                                                     @Cast(value="size_t*")
                                                                                     SizeTPointer device_uncompressed_chunk_bytes,
                                                                                     @Cast(value="size_t")
                                                                                     long num_chunks,
                                                                                     Pointer device_temp_ptr,
                                                                                     @Cast(value="size_t")
                                                                                     long temp_bytes,
                                                                                     @Cast(value="void*const*") @ByPtrPtr
                                                                                     Pointer device_uncompressed_chunk_ptrs,
                                                                                     @Cast(value="nvcompStatus_t*")
                                                                                     IntBuffer device_statuses,
                                                                                     CUstream_st stream)

nvcompBatchedBitcompDecompressAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedBitcompDecompressAsync(@Cast(value="const void*const*") @ByPtrPtr
                                                                                     Pointer device_compressed_chunk_ptrs,
                                                                                     @Cast(value="const size_t*")
                                                                                     SizeTPointer device_compressed_chunk_bytes,
                                                                                     @Cast(value="const size_t*")
                                                                                     SizeTPointer device_uncompressed_buffer_bytes,
                                                                                     @Cast(value="size_t*")
                                                                                     SizeTPointer device_uncompressed_chunk_bytes,
                                                                                     @Cast(value="size_t")
                                                                                     long num_chunks,
                                                                                     Pointer device_temp_ptr,
                                                                                     @Cast(value="size_t")
                                                                                     long temp_bytes,
                                                                                     @Cast(value="void*const*") @ByPtrPtr
                                                                                     Pointer device_uncompressed_chunk_ptrs,
                                                                                     @Cast(value="nvcompStatus_t*")
                                                                                     int[] device_statuses,
                                                                                     CUstream_st stream)

nvcompBatchedCascadedDefaultOpts

@MemberGetter
 @Const
 @ByRef
public static nvcompBatchedCascadedOpts_t nvcompBatchedCascadedDefaultOpts()

nvcompCascadedCompressionMaxAllowedChunkSize

@MemberGetter
 @Cast(value="const size_t")
public static long nvcompCascadedCompressionMaxAllowedChunkSize()

nvcompCascadedRequiredAlignment
```
@MemberGetter
 @Cast(value="const size_t")
public static long nvcompCascadedRequiredAlignment()
```
The most restrictive of minimum alignment requirements for void-type CUDA memory buffers used for input, output, or temporary memory, passed to compression or decompression functions. In all cases, typed memory buffers must still be aligned to their type's size, e.g., 4 bytes for int.

nvcompBatchedCascadedCompressGetRequiredAlignments

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedCascadedCompressGetRequiredAlignments(@ByVal
                                                                                                    nvcompBatchedCascadedOpts_t format_opts,
                                                                                                    nvcompAlignmentRequirements_t alignment_requirements)

\brief Get the minimum buffer alignment requirements for compression.

Parameters:: format_opts - [in] Compression options.; alignment_requirements - [out] The minimum buffer alignment requirements for compression.
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedCascadedCompressGetTempSize

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedCascadedCompressGetTempSize(@Cast(value="size_t")
                                                                                          long num_chunks,
                                                                                          @Cast(value="size_t")
                                                                                          long max_uncompressed_chunk_bytes,
                                                                                          @ByVal
                                                                                          nvcompBatchedCascadedOpts_t format_opts,
                                                                                          @Cast(value="size_t*")
                                                                                          SizeTPointer temp_bytes)

\brief Get the amount of temporary memory required on the GPU for compression. \note Batched Cascaded compression does not require temp space, so this will set *temp_bytes=0, unless an error is found with the format_opts.

Parameters:: num_chunks - [in] The number of chunks of memory in the batch.; max_uncompressed_chunk_bytes - [in] The maximum size of a chunk in the batch. This parameter is currently unused. Set it to either the actual value or zero.; format_opts - [in] The Cascaded compression options and datatype to use.; temp_bytes - [out] The amount of GPU memory that will be temporarily required during compression.
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedCascadedCompressGetTempSizeEx

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedCascadedCompressGetTempSizeEx(@Cast(value="size_t")
                                                                                            long num_chunks,
                                                                                            @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)

\brief Get the amount of temporary memory required on the GPU for compression with extra total bytes argument. \note Batched Cascaded compression does not require temp space, so this will set *temp_bytes=0, unless an error is found with the format_opts.

Parameters:: num_chunks - [in] The number of chunks of memory in the batch.; max_uncompressed_chunk_bytes - [in] The maximum size of a chunk in the batch. This parameter is currently unused. Set it to either the actual value or zero.; format_opts - [in] The Cascaded compression options and datatype to use.; temp_bytes - [out] The amount of GPU memory that will be temporarily required during compression.; max_total_uncompressed_bytes - [in] Upper bound on the total uncompressed size of all chunks
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedCascadedCompressGetMaxOutputChunkSize

@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_chunk_bytes)

Parameters:: max_uncompressed_chunk_bytes - [in] The maximum size of a chunk before compression.; format_opts - [in] The Cascaded compression options to use.; max_compressed_chunk_bytes - [out] The maximum possible compressed size of the chunk.
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedCascadedCompressAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedCascadedCompressAsync(@Cast(value="const void*const*")
                                                                                    PointerPointer device_uncompressed_chunk_ptrs,
                                                                                    @Cast(value="const size_t*")
                                                                                    SizeTPointer device_uncompressed_chunk_bytes,
                                                                                    @Cast(value="size_t")
                                                                                    long max_uncompressed_chunk_bytes,
                                                                                    @Cast(value="size_t")
                                                                                    long num_chunks,
                                                                                    Pointer device_temp_ptr,
                                                                                    @Cast(value="size_t")
                                                                                    long temp_bytes,
                                                                                    @Cast(value="void*const*")
                                                                                    PointerPointer device_compressed_chunk_ptrs,
                                                                                    @Cast(value="size_t*")
                                                                                    SizeTPointer device_compressed_chunk_bytes,
                                                                                    @ByVal
                                                                                    nvcompBatchedCascadedOpts_t format_opts,
                                                                                    CUstream_st stream)

\brief Perform batched asynchronous compression. \note The current implementation does not support uncompressed size larger than 4,294,967,295 bytes (max uint32_t). \note Violating any of the conditions listed in the parameter descriptions below may result in undefined behaviour.

Parameters:: device_uncompressed_chunk_ptrs - [in] Array with size \p num_chunks of pointers to the uncompressed data chunks. Both the pointers and the uncompressed data should reside in device-accessible memory. Each chunk must be aligned to the value in the input member of the \ref nvcompAlignmentRequirements_t object output by nvcompBatchedCascadedCompressGetRequiredAlignments when called with the same \p format_opts.; device_uncompressed_chunk_bytes - [in] Array with size \p num_chunks of sizes of the uncompressed chunks 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] The size of the largest uncompressed chunk. This parameter is currently unused. Set it to either the actual value or zero.; num_chunks - [in] Number of chunks of data to compress.; device_temp_ptr - [in] This argument is not used.; temp_bytes - [in] This argument is not used.; device_compressed_chunk_ptrs - [out] Array with size \p num_chunks 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 the size given by nvcompBatchedCascadedCompressGetMaxOutputChunkSize. Each compressed buffer must be aligned to the value in the output member of the \ref nvcompAlignmentRequirements_t object output by nvcompBatchedCascadedCompressGetRequiredAlignments when called with the same \p format_opts.; device_compressed_chunk_bytes - [out] Array with size \p num_chunks, to be filled with the compressed sizes of each chunk. 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.
Returns:: nvcompSuccess if successfully launched, and an error code otherwise.

nvcompBatchedCascadedCompressAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedCascadedCompressAsync(@Cast(value="const void*const*") @ByPtrPtr
                                                                                    Pointer device_uncompressed_chunk_ptrs,
                                                                                    @Cast(value="const size_t*")
                                                                                    SizeTPointer device_uncompressed_chunk_bytes,
                                                                                    @Cast(value="size_t")
                                                                                    long max_uncompressed_chunk_bytes,
                                                                                    @Cast(value="size_t")
                                                                                    long num_chunks,
                                                                                    Pointer device_temp_ptr,
                                                                                    @Cast(value="size_t")
                                                                                    long temp_bytes,
                                                                                    @Cast(value="void*const*") @ByPtrPtr
                                                                                    Pointer device_compressed_chunk_ptrs,
                                                                                    @Cast(value="size_t*")
                                                                                    SizeTPointer device_compressed_chunk_bytes,
                                                                                    @ByVal
                                                                                    nvcompBatchedCascadedOpts_t format_opts,
                                                                                    CUstream_st stream)

nvcompBatchedCascadedDecompressRequiredAlignments

@MemberGetter
 @Const
 @ByRef
public static nvcompAlignmentRequirements_t nvcompBatchedCascadedDecompressRequiredAlignments()

Minimum buffer alignment requirements for decompression.

nvcompBatchedCascadedDecompressGetTempSize

@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)

\brief Get the amount of temporary memory required on the GPU for decompression.

Parameters:: num_chunks - [in] Number of chunks of data to be decompressed.; max_uncompressed_chunk_bytes - [in] The size of the largest chunk in bytes when uncompressed.; temp_bytes - [out] The amount of GPU memory that will be temporarily required during decompression.
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedCascadedDecompressGetTempSizeEx

@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_total_uncompressed_bytes)

\brief Get the amount of temporary memory required on the GPU for decompression with extra total bytes argument.

Parameters:: num_chunks - [in] Number of chunks of data to be decompressed.; max_uncompressed_chunk_bytes - [in] The size of the largest chunk in bytes when uncompressed.; temp_bytes - [out] The amount of GPU memory that will be temporarily required during decompression.; max_total_uncompressed_bytes - [in] The total decompressed size of all the chunks. Unused in Cascaded.
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedCascadedGetDecompressSizeAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedCascadedGetDecompressSizeAsync(@Cast(value="const void*const*")
                                                                                             PointerPointer device_compressed_chunk_ptrs,
                                                                                             @Cast(value="const size_t*")
                                                                                             SizeTPointer device_compressed_chunk_bytes,
                                                                                             @Cast(value="size_t*")
                                                                                             SizeTPointer device_uncompressed_chunk_bytes,
                                                                                             @Cast(value="size_t")
                                                                                             long num_chunks,
                                                                                             CUstream_st stream)

Parameters:: device_compressed_chunk_ptrs - [in] Array with size \p num_chunks of pointers in device-accessible memory to compressed buffers. Each buffer must be aligned to the value in nvcompBatchedCascadedDecompressRequiredAlignments.input.; device_compressed_chunk_bytes - [in] Array with size \p num_chunks of sizes of the compressed buffers in bytes. The sizes should reside in device-accessible memory.; device_uncompressed_chunk_bytes - [out] Array with size \p num_chunks to be filled with the sizes, in bytes, of each uncompressed data chunk. If there is an error when retrieving the size of a chunk, the uncompressed size of that chunk will be set to 0. This argument needs to be preallocated in device-accessible memory.; num_chunks - [in] Number of data chunks to compute sizes of.; stream - [in] The CUDA stream to operate on.
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedCascadedGetDecompressSizeAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedCascadedGetDecompressSizeAsync(@Cast(value="const void*const*") @ByPtrPtr
                                                                                             Pointer device_compressed_chunk_ptrs,
                                                                                             @Cast(value="const size_t*")
                                                                                             SizeTPointer device_compressed_chunk_bytes,
                                                                                             @Cast(value="size_t*")
                                                                                             SizeTPointer device_uncompressed_chunk_bytes,
                                                                                             @Cast(value="size_t")
                                                                                             long num_chunks,
                                                                                             CUstream_st stream)

nvcompBatchedCascadedDecompressAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedCascadedDecompressAsync(@Cast(value="const void*const*")
                                                                                      PointerPointer device_compressed_chunk_ptrs,
                                                                                      @Cast(value="const size_t*")
                                                                                      SizeTPointer device_compressed_chunk_bytes,
                                                                                      @Cast(value="const size_t*")
                                                                                      SizeTPointer device_uncompressed_buffer_bytes,
                                                                                      @Cast(value="size_t*")
                                                                                      SizeTPointer device_uncompressed_chunk_bytes,
                                                                                      @Cast(value="size_t")
                                                                                      long num_chunks,
                                                                                      Pointer device_temp_ptr,
                                                                                      @Cast(value="size_t")
                                                                                      long temp_bytes,
                                                                                      @Cast(value="void*const*")
                                                                                      PointerPointer device_uncompressed_chunk_ptrs,
                                                                                      @Cast(value="nvcompStatus_t*")
                                                                                      IntPointer device_statuses,
                                                                                      CUstream_st stream)

\brief Perform batched asynchronous decompression. This function is used to decompress compressed buffers produced by nvcompBatchedCascadedCompressAsync. \note Violating any of the conditions listed in the parameter descriptions below may result in undefined behaviour.

Parameters:: device_compressed_chunk_ptrs - [in] Array with size \p num_chunks of pointers in device-accessible memory to device-accessible compressed buffers. Each buffer must be aligned to the value in nvcompBatchedCascadedDecompressRequiredAlignments.input.; device_compressed_chunk_bytes - [in] Array with size \p num_chunks of sizes of the compressed buffers in bytes. The sizes should reside in device-accessible memory.; device_uncompressed_buffer_bytes - [in] Array with size \p num_chunks of sizes, in bytes, of the output buffers to be filled with uncompressed data for each chunk. The sizes should reside in device-accessible memory. If a size is not large enough to hold all decompressed data, the decompressor will set the status in \p device_statuses corresponding to the overflow chunk to nvcompErrorCannotDecompress.; device_uncompressed_chunk_bytes - [out] Array with size \p num_chunks to be filled with the actual number of bytes decompressed for every chunk. This argument needs to be preallocated.; num_chunks - [in] Number of chunks of data to decompress.; device_temp_ptr - [in] This argument is not used.; temp_bytes - [in] This argument is not used.; device_uncompressed_chunk_ptrs - [out] Array with size \p num_chunks of pointers in device-accessible memory to decompressed data. Each uncompressed buffer needs to be preallocated in device-accessible memory, have the size specified by the corresponding entry in \p device_uncompressed_buffer_bytes, and be aligned to the value in nvcompBatchedCascadedDecompressRequiredAlignments.output.; device_statuses - [out] Array with size \p num_chunks of statuses in device-accessible memory. This argument needs to be preallocated. For each chunk, 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.
Returns:: nvcompSuccess if successfully launched, and an error code otherwise.

nvcompBatchedCascadedDecompressAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedCascadedDecompressAsync(@Cast(value="const void*const*") @ByPtrPtr
                                                                                      Pointer device_compressed_chunk_ptrs,
                                                                                      @Cast(value="const size_t*")
                                                                                      SizeTPointer device_compressed_chunk_bytes,
                                                                                      @Cast(value="const size_t*")
                                                                                      SizeTPointer device_uncompressed_buffer_bytes,
                                                                                      @Cast(value="size_t*")
                                                                                      SizeTPointer device_uncompressed_chunk_bytes,
                                                                                      @Cast(value="size_t")
                                                                                      long num_chunks,
                                                                                      Pointer device_temp_ptr,
                                                                                      @Cast(value="size_t")
                                                                                      long temp_bytes,
                                                                                      @Cast(value="void*const*") @ByPtrPtr
                                                                                      Pointer device_uncompressed_chunk_ptrs,
                                                                                      @Cast(value="nvcompStatus_t*")
                                                                                      IntPointer device_statuses,
                                                                                      CUstream_st stream)

nvcompBatchedCascadedDecompressAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedCascadedDecompressAsync(@Cast(value="const void*const*") @ByPtrPtr
                                                                                      Pointer device_compressed_chunk_ptrs,
                                                                                      @Cast(value="const size_t*")
                                                                                      SizeTPointer device_compressed_chunk_bytes,
                                                                                      @Cast(value="const size_t*")
                                                                                      SizeTPointer device_uncompressed_buffer_bytes,
                                                                                      @Cast(value="size_t*")
                                                                                      SizeTPointer device_uncompressed_chunk_bytes,
                                                                                      @Cast(value="size_t")
                                                                                      long num_chunks,
                                                                                      Pointer device_temp_ptr,
                                                                                      @Cast(value="size_t")
                                                                                      long temp_bytes,
                                                                                      @Cast(value="void*const*") @ByPtrPtr
                                                                                      Pointer device_uncompressed_chunk_ptrs,
                                                                                      @Cast(value="nvcompStatus_t*")
                                                                                      IntBuffer device_statuses,
                                                                                      CUstream_st stream)

nvcompBatchedCascadedDecompressAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedCascadedDecompressAsync(@Cast(value="const void*const*") @ByPtrPtr
                                                                                      Pointer device_compressed_chunk_ptrs,
                                                                                      @Cast(value="const size_t*")
                                                                                      SizeTPointer device_compressed_chunk_bytes,
                                                                                      @Cast(value="const size_t*")
                                                                                      SizeTPointer device_uncompressed_buffer_bytes,
                                                                                      @Cast(value="size_t*")
                                                                                      SizeTPointer device_uncompressed_chunk_bytes,
                                                                                      @Cast(value="size_t")
                                                                                      long num_chunks,
                                                                                      Pointer device_temp_ptr,
                                                                                      @Cast(value="size_t")
                                                                                      long temp_bytes,
                                                                                      @Cast(value="void*const*") @ByPtrPtr
                                                                                      Pointer device_uncompressed_chunk_ptrs,
                                                                                      @Cast(value="nvcompStatus_t*")
                                                                                      int[] device_statuses,
                                                                                      CUstream_st stream)

nvcompBatchedCRC32Async

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedCRC32Async(@Cast(value="const void*const*")
                                                                         PointerPointer device_uncompressed_chunk_ptrs,
                                                                         @Cast(value="const size_t*")
                                                                         SizeTPointer device_uncompressed_chunk_bytes,
                                                                         @Cast(value="size_t")
                                                                         long num_chunks,
                                                                         @Cast(value="uint32_t*")
                                                                         IntPointer device_CRC32_ptr,
                                                                         CUstream_st stream)

\brief Perform CRC32 checksum calculation asynchronously. All pointers must point to GPU accessible locations.

Parameters:: device_uncompressed_chunk_ptrs - [in] Array with size \p num_chunks of pointers to the uncompressed data chunks. Both the pointers and the uncompressed data should reside in device-accessible memory.; device_uncompressed_chunk_bytes - [in] Array with size \p num_chunks of sizes of the uncompressed chunks in bytes. The sizes should reside in device-accessible memory.; num_chunks - [in] The number of chunks to compute checksums of.; device_CRC - [out] 32_ptr Array with size \p num_chunks on the GPU to be filled with the CRC32 checksum of each chunk.; stream - [in] The CUDA stream to operate on.
Returns:: nvcompSuccess if successfully launched, and an error code otherwise.

nvcompBatchedCRC32Async

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedCRC32Async(@Cast(value="const void*const*") @ByPtrPtr
                                                                         Pointer device_uncompressed_chunk_ptrs,
                                                                         @Cast(value="const size_t*")
                                                                         SizeTPointer device_uncompressed_chunk_bytes,
                                                                         @Cast(value="size_t")
                                                                         long num_chunks,
                                                                         @Cast(value="uint32_t*")
                                                                         IntPointer device_CRC32_ptr,
                                                                         CUstream_st stream)

nvcompBatchedCRC32Async

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedCRC32Async(@Cast(value="const void*const*") @ByPtrPtr
                                                                         Pointer device_uncompressed_chunk_ptrs,
                                                                         @Cast(value="const size_t*")
                                                                         SizeTPointer device_uncompressed_chunk_bytes,
                                                                         @Cast(value="size_t")
                                                                         long num_chunks,
                                                                         @Cast(value="uint32_t*")
                                                                         IntBuffer device_CRC32_ptr,
                                                                         CUstream_st stream)

nvcompBatchedCRC32Async

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedCRC32Async(@Cast(value="const void*const*") @ByPtrPtr
                                                                         Pointer device_uncompressed_chunk_ptrs,
                                                                         @Cast(value="const size_t*")
                                                                         SizeTPointer device_uncompressed_chunk_bytes,
                                                                         @Cast(value="size_t")
                                                                         long num_chunks,
                                                                         @Cast(value="uint32_t*")
                                                                         int[] device_CRC32_ptr,
                                                                         CUstream_st stream)

nvcompBatchedDeflateDefaultOpts

@MemberGetter
 @Const
 @ByRef
public static nvcompBatchedDeflateOpts_t nvcompBatchedDeflateDefaultOpts()

nvcompDeflateCompressionMaxAllowedChunkSize
```
@MemberGetter
 @Cast(value="const size_t")
public static long nvcompDeflateCompressionMaxAllowedChunkSize()
```
Although chunk sizes up to 2GB are theoretically possible, compression with large chunks may be very slow or use large amounts of temporary memory, so caution is advised when using chunk sizes above 64KB.

nvcompDeflateRequiredAlignment
```
@MemberGetter
 @Cast(value="const size_t")
public static long nvcompDeflateRequiredAlignment()
```
The most restrictive of minimum alignment requirements for void-type CUDA memory buffers used for input, output, or temporary memory, passed to compression or decompression functions. In all cases, typed memory buffers must still be aligned to their type's size, e.g., 4 bytes for int.

nvcompBatchedDeflateCompressGetRequiredAlignments

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedDeflateCompressGetRequiredAlignments(@ByVal
                                                                                                   nvcompBatchedDeflateOpts_t format_opts,
                                                                                                   nvcompAlignmentRequirements_t alignment_requirements)

\brief Get the minimum buffer alignment requirements for compression.

Parameters:: format_opts - [in] Compression options.; alignment_requirements - [out] The minimum buffer alignment requirements for compression.
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedDeflateCompressGetTempSize

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedDeflateCompressGetTempSize(@Cast(value="size_t")
                                                                                         long num_chunks,
                                                                                         @Cast(value="size_t")
                                                                                         long max_uncompressed_chunk_bytes,
                                                                                         @ByVal
                                                                                         nvcompBatchedDeflateOpts_t format_opts,
                                                                                         @Cast(value="size_t*")
                                                                                         SizeTPointer temp_bytes)

\brief Get the amount of temporary memory required on the GPU for compression. Chunk size must not exceed 65536 bytes. For best performance, a chunk size of 65536 bytes is recommended.

Parameters:: num_chunks - [in] The number of chunks of memory in the batch.; max_uncompressed_chunk_bytes - [in] The maximum size of a chunk in the batch.; format_opts - [in] The Deflate compression options to use.; temp_bytes - [out] The amount of GPU memory that will be temporarily required during compression.
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedDeflateCompressGetTempSizeEx

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedDeflateCompressGetTempSizeEx(@Cast(value="size_t")
                                                                                           long num_chunks,
                                                                                           @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)

\brief Get the amount of temporary memory required on the GPU for compression with extra total bytes argument. Chunk size must not exceed 65536 bytes. For best performance, a chunk size of 65536 bytes is recommended.

Parameters:: num_chunks - [in] The number of chunks of memory in the batch.; max_uncompressed_chunk_bytes - [in] The maximum size of a chunk in the batch.; format_opts - [in] The Deflate compression options to use.; temp_bytes - [out] The amount of GPU memory that will be temporarily required during compression.; max_total_uncompressed_bytes - [in] Upper bound on the total uncompressed size of all chunks
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedDeflateCompressGetMaxOutputChunkSize

@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_chunk_bytes)

\brief Get the maximum size that a chunk of size at most max_uncompressed_chunk_bytes could compress to. That is, the minimum amount of output memory required to be given nvcompBatchedDeflateCompressAsync() for each chunk. Chunk size must not exceed 65536 bytes. For best performance, a chunk size of 65536 bytes is recommended.

Parameters:: max_uncompressed_chunk_bytes - [in] The maximum size of a chunk before compression.; format_opts - [in] The Deflate compression options to use.; max_compressed_chunk_bytes - [out] The maximum possible compressed size of the chunk.
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedDeflateCompressAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedDeflateCompressAsync(@Cast(value="const void*const*")
                                                                                   PointerPointer device_uncompressed_chunk_ptrs,
                                                                                   @Cast(value="const size_t*")
                                                                                   SizeTPointer device_uncompressed_chunk_bytes,
                                                                                   @Cast(value="size_t")
                                                                                   long max_uncompressed_chunk_bytes,
                                                                                   @Cast(value="size_t")
                                                                                   long num_chunks,
                                                                                   Pointer device_temp_ptr,
                                                                                   @Cast(value="size_t")
                                                                                   long temp_bytes,
                                                                                   @Cast(value="void*const*")
                                                                                   PointerPointer device_compressed_chunk_ptrs,
                                                                                   @Cast(value="size_t*")
                                                                                   SizeTPointer device_compressed_chunk_bytes,
                                                                                   @ByVal
                                                                                   nvcompBatchedDeflateOpts_t format_opts,
                                                                                   CUstream_st stream)

\brief Perform batched asynchronous compression. \note Violating any of the conditions listed in the parameter descriptions below may result in undefined behaviour.

Parameters:: device_uncompressed_chunk_ptrs - [in] Array with size \p num_chunks of pointers to the uncompressed data chunks. Both the pointers and the uncompressed data should reside in device-accessible memory. Each chunk must be aligned to the value in the input member of the \ref nvcompAlignmentRequirements_t object output by nvcompBatchedDeflateCompressGetRequiredAlignments when called with the same \p format_opts.; device_uncompressed_chunk_bytes - [in] Array with size \p num_chunks of sizes of the uncompressed chunks in bytes. The sizes should reside in device-accessible memory. Chunk sizes must not exceed 65536 bytes. For best performance, a chunk size of 65536 bytes is recommended.; max_uncompressed_chunk_bytes - [in] The size of the largest uncompressed chunk.; num_chunks - [in] Number of chunks of data to compress.; device_temp_ptr - [in] The temporary GPU workspace. Must be aligned to the value in the temp member of the \ref nvcompAlignmentRequirements_t object output by nvcompBatchedDeflateCompressGetRequiredAlignments when called with the same \p format_opts.; temp_bytes - [in] The size of the temporary GPU memory pointed to by device_temp_ptr.; device_compressed_chunk_ptrs - [out] Array with size \p num_chunks 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 the size given by nvcompBatchedDeflateCompressGetMaxOutputChunkSize. Each compressed buffer must be aligned to the value in the output member of the \ref nvcompAlignmentRequirements_t object output by nvcompBatchedDeflateCompressGetRequiredAlignments when called with the same \p format_opts.; device_compressed_chunk_bytes - [out] Array with size \p num_chunks, to be filled with the compressed sizes of each chunk. The buffer should be preallocated in device-accessible memory.; format_opts - [in] The Deflate compression options to use.; stream - [in] The CUDA stream to operate on.
Returns:: nvcompSuccess if successfully launched, and an error code otherwise.

nvcompBatchedDeflateCompressAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedDeflateCompressAsync(@Cast(value="const void*const*") @ByPtrPtr
                                                                                   Pointer device_uncompressed_chunk_ptrs,
                                                                                   @Cast(value="const size_t*")
                                                                                   SizeTPointer device_uncompressed_chunk_bytes,
                                                                                   @Cast(value="size_t")
                                                                                   long max_uncompressed_chunk_bytes,
                                                                                   @Cast(value="size_t")
                                                                                   long num_chunks,
                                                                                   Pointer device_temp_ptr,
                                                                                   @Cast(value="size_t")
                                                                                   long temp_bytes,
                                                                                   @Cast(value="void*const*") @ByPtrPtr
                                                                                   Pointer device_compressed_chunk_ptrs,
                                                                                   @Cast(value="size_t*")
                                                                                   SizeTPointer device_compressed_chunk_bytes,
                                                                                   @ByVal
                                                                                   nvcompBatchedDeflateOpts_t format_opts,
                                                                                   CUstream_st stream)

nvcompBatchedDeflateDecompressRequiredAlignments

@MemberGetter
 @Const
 @ByRef
public static nvcompAlignmentRequirements_t nvcompBatchedDeflateDecompressRequiredAlignments()

Minimum buffer alignment requirements for decompression.

nvcompBatchedDeflateDecompressGetTempSize

@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)

\brief Get the amount of temporary memory required on the GPU for decompression.

Parameters:: num_chunks - [in] Number of chunks of data to be decompressed.; max_uncompressed_chunk_bytes - [in] The size of the largest chunk in bytes when uncompressed.; temp_bytes - [out] The amount of GPU memory that will be temporarily required during decompression.
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedDeflateDecompressGetTempSizeEx

@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_total_uncompressed_bytes)

\brief Get the amount of temporary memory required on the GPU for decompression with extra total bytes argument.

Parameters:: num_chunks - [in] Number of chunks of data to be decompressed.; max_uncompressed_chunk_bytes - [in] The size of the largest chunk in bytes when uncompressed.; temp_bytes - [out] The amount of GPU memory that will be temporarily required during decompression.; max_total_uncompressed_bytes - [in] The total decompressed size of all the chunks. Unused in Deflate.
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedDeflateGetDecompressSizeAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedDeflateGetDecompressSizeAsync(@Cast(value="const void*const*")
                                                                                            PointerPointer device_compressed_chunk_ptrs,
                                                                                            @Cast(value="const size_t*")
                                                                                            SizeTPointer device_compressed_chunk_bytes,
                                                                                            @Cast(value="size_t*")
                                                                                            SizeTPointer device_uncompressed_chunk_bytes,
                                                                                            @Cast(value="size_t")
                                                                                            long num_chunks,
                                                                                            CUstream_st stream)

\brief Asynchronously compute the number of bytes of uncompressed data for each compressed chunk. This is needed when we do not know the expected output size. \note If the stream is corrupt, the calculated sizes will be invalid. \note Violating any of the conditions listed in the parameter descriptions below may result in undefined behaviour.

Parameters:: device_compressed_chunk_ptrs - [in] Array with size \p num_chunks of pointers in device-accessible memory to compressed buffers. Each buffer must be aligned to the value in nvcompBatchedDeflateDecompressRequiredAlignments.input.; device_compressed_chunk_bytes - [in] Array with size \p num_chunks of sizes of the compressed buffers in bytes. The sizes should reside in device-accessible memory.; device_uncompressed_chunk_bytes - [out] Array with size \p num_chunks to be filled with the sizes, in bytes, of each uncompressed data chunk.; num_chunks - [in] Number of data chunks to compute sizes of.; stream - [in] The CUDA stream to operate on.
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedDeflateGetDecompressSizeAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedDeflateGetDecompressSizeAsync(@Cast(value="const void*const*") @ByPtrPtr
                                                                                            Pointer device_compressed_chunk_ptrs,
                                                                                            @Cast(value="const size_t*")
                                                                                            SizeTPointer device_compressed_chunk_bytes,
                                                                                            @Cast(value="size_t*")
                                                                                            SizeTPointer device_uncompressed_chunk_bytes,
                                                                                            @Cast(value="size_t")
                                                                                            long num_chunks,
                                                                                            CUstream_st stream)

nvcompBatchedDeflateDecompressAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedDeflateDecompressAsync(@Cast(value="const void*const*")
                                                                                     PointerPointer device_compressed_chunk_ptrs,
                                                                                     @Cast(value="const size_t*")
                                                                                     SizeTPointer device_compressed_chunk_bytes,
                                                                                     @Cast(value="const size_t*")
                                                                                     SizeTPointer device_uncompressed_buffer_bytes,
                                                                                     @Cast(value="size_t*")
                                                                                     SizeTPointer device_uncompressed_chunk_bytes,
                                                                                     @Cast(value="size_t")
                                                                                     long num_chunks,
                                                                                     Pointer device_temp_ptr,
                                                                                     @Cast(value="size_t")
                                                                                     long temp_bytes,
                                                                                     @Cast(value="void*const*")
                                                                                     PointerPointer device_uncompressed_chunk_ptrs,
                                                                                     @Cast(value="nvcompStatus_t*")
                                                                                     IntPointer device_statuses,
                                                                                     CUstream_st stream)

\brief Perform batched asynchronous decompression. \note Violating any of the conditions listed in the parameter descriptions below may result in undefined behaviour. \note In the case where a chunk of compressed data is not a valid Deflate stream, 0 will be written for the size of the invalid chunk and nvcompStatusCannotDecompress will be flagged for that chunk.

Parameters:: device_compressed_chunk_ptrs - [in] Array with size \p num_chunks of pointers in device-accessible memory to device-accessible compressed buffers. Each buffer must be aligned to the value in nvcompBatchedDeflateDecompressRequiredAlignments.input.; device_compressed_chunk_bytes - [in] Array with size \p num_chunks of sizes of the compressed buffers in bytes. The sizes should reside in device-accessible memory.; device_uncompressed_buffer_bytes - [in] Array with size \p num_chunks of sizes, in bytes, of the output buffers to be filled with uncompressed data for each chunk. The sizes should reside in device-accessible memory. If a size is not large enough to hold all decompressed data, the decompressor will set the status in \p device_statuses corresponding to the overflow chunk to nvcompErrorCannotDecompress.; device_uncompressed_chunk_bytes - [out] Array with size \p num_chunks to be filled with the actual number of bytes decompressed for every chunk. This argument needs to be preallocated, but can be nullptr if desired, in which case the actual sizes are not reported.; num_chunks - [in] Number of chunks of data to decompress.; device_temp_ptr - [in] The temporary GPU space. Must be aligned to the value in nvcompBatchedDeflateDecompressRequiredAlignments.temp.; temp_bytes - [in] The size of the temporary GPU space.; device_uncompressed_chunk_ptrs - [out] Array with size \p num_chunks of pointers in device-accessible memory to decompressed data. Each uncompressed buffer needs to be preallocated in device-accessible memory, have the size specified by the corresponding entry in \p device_uncompressed_buffer_bytes, and be aligned to the value in nvcompBatchedDeflateDecompressRequiredAlignments.output.; device_statuses - [out] Array with size \p num_chunks of statuses in device-accessible memory. This argument needs to be preallocated. For each chunk, 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. Can be nullptr if desired, in which case error status is not reported.; stream - [in] The CUDA stream to operate on.
Returns:: nvcompSuccess if successfully launched, and an error code otherwise.

nvcompBatchedDeflateDecompressAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedDeflateDecompressAsync(@Cast(value="const void*const*") @ByPtrPtr
                                                                                     Pointer device_compressed_chunk_ptrs,
                                                                                     @Cast(value="const size_t*")
                                                                                     SizeTPointer device_compressed_chunk_bytes,
                                                                                     @Cast(value="const size_t*")
                                                                                     SizeTPointer device_uncompressed_buffer_bytes,
                                                                                     @Cast(value="size_t*")
                                                                                     SizeTPointer device_uncompressed_chunk_bytes,
                                                                                     @Cast(value="size_t")
                                                                                     long num_chunks,
                                                                                     Pointer device_temp_ptr,
                                                                                     @Cast(value="size_t")
                                                                                     long temp_bytes,
                                                                                     @Cast(value="void*const*") @ByPtrPtr
                                                                                     Pointer device_uncompressed_chunk_ptrs,
                                                                                     @Cast(value="nvcompStatus_t*")
                                                                                     IntPointer device_statuses,
                                                                                     CUstream_st stream)

nvcompBatchedDeflateDecompressAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedDeflateDecompressAsync(@Cast(value="const void*const*") @ByPtrPtr
                                                                                     Pointer device_compressed_chunk_ptrs,
                                                                                     @Cast(value="const size_t*")
                                                                                     SizeTPointer device_compressed_chunk_bytes,
                                                                                     @Cast(value="const size_t*")
                                                                                     SizeTPointer device_uncompressed_buffer_bytes,
                                                                                     @Cast(value="size_t*")
                                                                                     SizeTPointer device_uncompressed_chunk_bytes,
                                                                                     @Cast(value="size_t")
                                                                                     long num_chunks,
                                                                                     Pointer device_temp_ptr,
                                                                                     @Cast(value="size_t")
                                                                                     long temp_bytes,
                                                                                     @Cast(value="void*const*") @ByPtrPtr
                                                                                     Pointer device_uncompressed_chunk_ptrs,
                                                                                     @Cast(value="nvcompStatus_t*")
                                                                                     IntBuffer device_statuses,
                                                                                     CUstream_st stream)

nvcompBatchedDeflateDecompressAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedDeflateDecompressAsync(@Cast(value="const void*const*") @ByPtrPtr
                                                                                     Pointer device_compressed_chunk_ptrs,
                                                                                     @Cast(value="const size_t*")
                                                                                     SizeTPointer device_compressed_chunk_bytes,
                                                                                     @Cast(value="const size_t*")
                                                                                     SizeTPointer device_uncompressed_buffer_bytes,
                                                                                     @Cast(value="size_t*")
                                                                                     SizeTPointer device_uncompressed_chunk_bytes,
                                                                                     @Cast(value="size_t")
                                                                                     long num_chunks,
                                                                                     Pointer device_temp_ptr,
                                                                                     @Cast(value="size_t")
                                                                                     long temp_bytes,
                                                                                     @Cast(value="void*const*") @ByPtrPtr
                                                                                     Pointer device_uncompressed_chunk_ptrs,
                                                                                     @Cast(value="nvcompStatus_t*")
                                                                                     int[] device_statuses,
                                                                                     CUstream_st stream)

nvcompBatchedGdeflateDefaultOpts

@MemberGetter
 @Const
 @ByRef
public static nvcompBatchedGdeflateOpts_t nvcompBatchedGdeflateDefaultOpts()

nvcompGdeflateCompressionMaxAllowedChunkSize
```
@MemberGetter
 @Cast(value="const size_t")
public static long nvcompGdeflateCompressionMaxAllowedChunkSize()
```
Although chunk sizes up to 2GB are theoretically possible, compression with large chunks may be very slow or use large amounts of temporary memory, so caution is advised when using chunk sizes above 64KB.

nvcompGdeflateRequiredAlignment
```
@MemberGetter
 @Cast(value="const size_t")
public static long nvcompGdeflateRequiredAlignment()
```
The most restrictive of minimum alignment requirements for void-type CUDA memory buffers used for input, output, or temporary memory, passed to compression or decompression functions. In all cases, typed memory buffers must still be aligned to their type's size, e.g., 4 bytes for int.

nvcompBatchedGdeflateCompressGetRequiredAlignments

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedGdeflateCompressGetRequiredAlignments(@ByVal
                                                                                                    nvcompBatchedGdeflateOpts_t format_opts,
                                                                                                    nvcompAlignmentRequirements_t alignment_requirements)

\brief Get the minimum buffer alignment requirements for compression.

Parameters:: format_opts - [in] Compression options.; alignment_requirements - [out] The minimum buffer alignment requirements for compression.
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedGdeflateCompressGetTempSize

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedGdeflateCompressGetTempSize(@Cast(value="size_t")
                                                                                          long num_chunks,
                                                                                          @Cast(value="size_t")
                                                                                          long max_uncompressed_chunk_bytes,
                                                                                          @ByVal
                                                                                          nvcompBatchedGdeflateOpts_t format_opts,
                                                                                          @Cast(value="size_t*")
                                                                                          SizeTPointer temp_bytes)

\brief Get the amount of temporary memory required on the GPU for compression. Chunk size must not exceed 65536 bytes. For best performance, a chunk size of 65536 bytes is recommended.

Parameters:: num_chunks - [in] The number of chunks of memory in the batch.; max_uncompressed_chunk_bytes - [in] The maximum size of a chunk in the batch.; format_opts - [in] The GDeflate compression options to use.; temp_bytes - [out] The amount of GPU memory that will be temporarily required during compression.
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedGdeflateCompressGetTempSizeEx

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedGdeflateCompressGetTempSizeEx(@Cast(value="size_t")
                                                                                            long num_chunks,
                                                                                            @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)

Parameters:: num_chunks - [in] The number of chunks of memory in the batch.; max_uncompressed_chunk_bytes - [in] The maximum size of a chunk in the batch.; format_opts - [in] The GDeflate compression options to use.; temp_bytes - [out] The amount of GPU memory that will be temporarily required during compression.; max_total_uncompressed_bytes - [in] Upper bound on the total uncompressed size of all chunks
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedGdeflateCompressGetMaxOutputChunkSize

@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_chunk_bytes)

\brief Get the maximum size that a chunk of size at most max_uncompressed_chunk_bytes could compress to. That is, the minimum amount of output memory required to be given nvcompBatchedGdeflateCompressAsync() for each chunk. Chunk size must not exceed 65536 bytes. For best performance, a chunk size of 65536 bytes is recommended.

Parameters:: max_uncompressed_chunk_bytes - [in] The maximum size of a chunk before compression.; format_opts - [in] The GDeflate compression options to use.; max_compressed_chunk_bytes - [out] The maximum possible compressed size of the chunk.
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedGdeflateCompressAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedGdeflateCompressAsync(@Cast(value="const void*const*")
                                                                                    PointerPointer device_uncompressed_chunk_ptrs,
                                                                                    @Cast(value="const size_t*")
                                                                                    SizeTPointer device_uncompressed_chunk_bytes,
                                                                                    @Cast(value="size_t")
                                                                                    long max_uncompressed_chunk_bytes,
                                                                                    @Cast(value="size_t")
                                                                                    long num_chunks,
                                                                                    Pointer device_temp_ptr,
                                                                                    @Cast(value="size_t")
                                                                                    long temp_bytes,
                                                                                    @Cast(value="void*const*")
                                                                                    PointerPointer device_compressed_chunk_ptrs,
                                                                                    @Cast(value="size_t*")
                                                                                    SizeTPointer device_compressed_chunk_bytes,
                                                                                    @ByVal
                                                                                    nvcompBatchedGdeflateOpts_t format_opts,
                                                                                    CUstream_st stream)

\brief Perform batched asynchronous compression. \note Violating any of the conditions listed in the parameter descriptions below may result in undefined behaviour.

Parameters:: device_uncompressed_chunk_ptrs - [in] Array with size \p num_chunks of pointers to the uncompressed data chunks. Both the pointers and the uncompressed data should reside in device-accessible memory. Each chunk must be aligned to the value in the input member of the \ref nvcompAlignmentRequirements_t object output by nvcompBatchedGdeflateCompressGetRequiredAlignments when called with the same \p format_opts.; device_uncompressed_chunk_bytes - [in] Array with size \p num_chunks of sizes of the uncompressed chunks in bytes. The sizes should reside in device-accessible memory. Chunk sizes must not exceed 65536 bytes. For best performance, a chunk size of 65536 bytes is recommended.; max_uncompressed_chunk_bytes - [in] The size of the largest uncompressed chunk.; num_chunks - [in] Number of chunks of data to compress.; device_temp_ptr - [in] The temporary GPU workspace. Must be aligned to the value in the temp member of the \ref nvcompAlignmentRequirements_t object output by nvcompBatchedGdeflateCompressGetRequiredAlignments when called with the same \p format_opts.; temp_bytes - [in] The size of the temporary GPU memory pointed to by device_temp_ptr.; device_compressed_chunk_ptrs - [out] Array with size \p num_chunks 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 the size given by nvcompBatchedGdeflateCompressGetMaxOutputChunkSize. Each compressed buffer must be aligned to the value in the output member of the \ref nvcompAlignmentRequirements_t object output by nvcompBatchedGdeflateCompressGetRequiredAlignments when called with the same \p format_opts.; device_compressed_chunk_bytes - [out] Array with size \p num_chunks, to be filled with the compressed sizes of each chunk. The buffer should be preallocated in device-accessible memory.; format_opts - [in] The GDeflate compression options to use.; stream - [in] The CUDA stream to operate on.
Returns:: nvcompSuccess if successfully launched, and an error code otherwise.

nvcompBatchedGdeflateCompressAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedGdeflateCompressAsync(@Cast(value="const void*const*") @ByPtrPtr
                                                                                    Pointer device_uncompressed_chunk_ptrs,
                                                                                    @Cast(value="const size_t*")
                                                                                    SizeTPointer device_uncompressed_chunk_bytes,
                                                                                    @Cast(value="size_t")
                                                                                    long max_uncompressed_chunk_bytes,
                                                                                    @Cast(value="size_t")
                                                                                    long num_chunks,
                                                                                    Pointer device_temp_ptr,
                                                                                    @Cast(value="size_t")
                                                                                    long temp_bytes,
                                                                                    @Cast(value="void*const*") @ByPtrPtr
                                                                                    Pointer device_compressed_chunk_ptrs,
                                                                                    @Cast(value="size_t*")
                                                                                    SizeTPointer device_compressed_chunk_bytes,
                                                                                    @ByVal
                                                                                    nvcompBatchedGdeflateOpts_t format_opts,
                                                                                    CUstream_st stream)

nvcompBatchedGdeflateDecompressRequiredAlignments

@MemberGetter
 @Const
 @ByRef
public static nvcompAlignmentRequirements_t nvcompBatchedGdeflateDecompressRequiredAlignments()

Minimum buffer alignment requirements for decompression.

nvcompBatchedGdeflateDecompressGetTempSize

@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)

\brief Get the amount of temporary memory required on the GPU for decompression.

Parameters:: num_chunks - [in] Number of chunks of data to be decompressed.; max_uncompressed_chunk_bytes - [in] The size of the largest chunk in bytes when uncompressed.; temp_bytes - [out] The amount of GPU memory that will be temporarily required during decompression.
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedGdeflateDecompressGetTempSizeEx

@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_total_uncompressed_bytes)

\brief Get the amount of temporary memory required on the GPU for decompression with extra total bytes argument.

Parameters:: num_chunks - [in] Number of chunks of data to be decompressed.; max_uncompressed_chunk_bytes - [in] The size of the largest chunk in bytes when uncompressed.; temp_bytes - [out] The amount of GPU memory that will be temporarily required during decompression.; max_total_uncompressed_bytes - [in] The total decompressed size of all the chunks. Unused in GDeflate.
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedGdeflateGetDecompressSizeAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedGdeflateGetDecompressSizeAsync(@Cast(value="const void*const*")
                                                                                             PointerPointer device_compressed_chunk_ptrs,
                                                                                             @Cast(value="const size_t*")
                                                                                             SizeTPointer device_compressed_chunk_bytes,
                                                                                             @Cast(value="size_t*")
                                                                                             SizeTPointer device_uncompressed_chunk_bytes,
                                                                                             @Cast(value="size_t")
                                                                                             long num_chunks,
                                                                                             CUstream_st stream)

Parameters:: device_compressed_chunk_ptrs - [in] Array with size \p num_chunks of pointers in device-accessible memory to compressed buffers. Each buffer must be aligned to the value in nvcompBatchedGdeflateDecompressRequiredAlignments.input.; device_compressed_chunk_bytes - [in] Array with size \p num_chunks of sizes of the compressed buffers in bytes. The sizes should reside in device-accessible memory.; device_uncompressed_chunk_bytes - [out] Array with size \p num_chunks to be filled with the sizes, in bytes, of each uncompressed data chunk.; num_chunks - [in] Number of data chunks to compute sizes of.; stream - [in] The CUDA stream to operate on.
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedGdeflateGetDecompressSizeAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedGdeflateGetDecompressSizeAsync(@Cast(value="const void*const*") @ByPtrPtr
                                                                                             Pointer device_compressed_chunk_ptrs,
                                                                                             @Cast(value="const size_t*")
                                                                                             SizeTPointer device_compressed_chunk_bytes,
                                                                                             @Cast(value="size_t*")
                                                                                             SizeTPointer device_uncompressed_chunk_bytes,
                                                                                             @Cast(value="size_t")
                                                                                             long num_chunks,
                                                                                             CUstream_st stream)

nvcompBatchedGdeflateDecompressAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedGdeflateDecompressAsync(@Cast(value="const void*const*")
                                                                                      PointerPointer device_compressed_chunk_ptrs,
                                                                                      @Cast(value="const size_t*")
                                                                                      SizeTPointer device_compressed_chunk_bytes,
                                                                                      @Cast(value="const size_t*")
                                                                                      SizeTPointer device_uncompressed_buffer_bytes,
                                                                                      @Cast(value="size_t*")
                                                                                      SizeTPointer device_uncompressed_chunk_bytes,
                                                                                      @Cast(value="size_t")
                                                                                      long num_chunks,
                                                                                      Pointer device_temp_ptr,
                                                                                      @Cast(value="size_t")
                                                                                      long temp_bytes,
                                                                                      @Cast(value="void*const*")
                                                                                      PointerPointer device_uncompressed_chunk_ptrs,
                                                                                      @Cast(value="nvcompStatus_t*")
                                                                                      IntPointer device_statuses,
                                                                                      CUstream_st stream)

\brief Perform batched asynchronous decompression. \note Violating any of the conditions listed in the parameter descriptions below may result in undefined behaviour. \note In the case where a chunk of compressed data is not a valid GDeflate stream, 0 will be written for the size of the invalid chunk and nvcompStatusCannotDecompress will be flagged for that chunk.

Parameters:: device_compressed_chunk_ptrs - [in] Array with size \p num_chunks of pointers in device-accessible memory to device-accessible compressed buffers. Each buffer must be aligned to the value in nvcompBatchedGdeflateDecompressRequiredAlignments.input.; device_compressed_chunk_bytes - [in] Array with size \p num_chunks of sizes of the compressed buffers in bytes. The sizes should reside in device-accessible memory.; device_uncompressed_buffer_bytes - [in] Array with size \p num_chunks of sizes, in bytes, of the output buffers to be filled with uncompressed data for each chunk. The sizes should reside in device-accessible memory. If a size is not large enough to hold all decompressed data, the decompressor will set the status in \p device_statuses corresponding to the overflow chunk to nvcompErrorCannotDecompress.; device_uncompressed_chunk_bytes - [out] Array with size \p num_chunks to be filled with the actual number of bytes decompressed for every chunk. This argument needs to be preallocated, but can be nullptr if desired, in which case the actual sizes are not reported.; num_chunks - [in] Number of chunks of data to decompress.; device_temp_ptr - [in] The temporary GPU space. Must be aligned to the value in nvcompBatchedGdeflateDecompressRequiredAlignments.temp.; temp_bytes - [in] The size of the temporary GPU space.; device_uncompressed_chunk_ptrs - [out] Array with size \p num_chunks of pointers in device-accessible memory to decompressed data. Each uncompressed buffer needs to be preallocated in device-accessible memory, have the size specified by the corresponding entry in \p device_uncompressed_buffer_bytes, and be aligned to the value in nvcompBatchedGdeflateDecompressRequiredAlignments.output.; device_statuses - [out] Array with size \p num_chunks of statuses in device-accessible memory. This argument needs to be preallocated. For each chunk, 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. Can be nullptr if desired, in which case error status is not reported.; stream - [in] The CUDA stream to operate on.
Returns:: nvcompSuccess if successfully launched, and an error code otherwise.

nvcompBatchedGdeflateDecompressAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedGdeflateDecompressAsync(@Cast(value="const void*const*") @ByPtrPtr
                                                                                      Pointer device_compressed_chunk_ptrs,
                                                                                      @Cast(value="const size_t*")
                                                                                      SizeTPointer device_compressed_chunk_bytes,
                                                                                      @Cast(value="const size_t*")
                                                                                      SizeTPointer device_uncompressed_buffer_bytes,
                                                                                      @Cast(value="size_t*")
                                                                                      SizeTPointer device_uncompressed_chunk_bytes,
                                                                                      @Cast(value="size_t")
                                                                                      long num_chunks,
                                                                                      Pointer device_temp_ptr,
                                                                                      @Cast(value="size_t")
                                                                                      long temp_bytes,
                                                                                      @Cast(value="void*const*") @ByPtrPtr
                                                                                      Pointer device_uncompressed_chunk_ptrs,
                                                                                      @Cast(value="nvcompStatus_t*")
                                                                                      IntPointer device_statuses,
                                                                                      CUstream_st stream)

nvcompBatchedGdeflateDecompressAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedGdeflateDecompressAsync(@Cast(value="const void*const*") @ByPtrPtr
                                                                                      Pointer device_compressed_chunk_ptrs,
                                                                                      @Cast(value="const size_t*")
                                                                                      SizeTPointer device_compressed_chunk_bytes,
                                                                                      @Cast(value="const size_t*")
                                                                                      SizeTPointer device_uncompressed_buffer_bytes,
                                                                                      @Cast(value="size_t*")
                                                                                      SizeTPointer device_uncompressed_chunk_bytes,
                                                                                      @Cast(value="size_t")
                                                                                      long num_chunks,
                                                                                      Pointer device_temp_ptr,
                                                                                      @Cast(value="size_t")
                                                                                      long temp_bytes,
                                                                                      @Cast(value="void*const*") @ByPtrPtr
                                                                                      Pointer device_uncompressed_chunk_ptrs,
                                                                                      @Cast(value="nvcompStatus_t*")
                                                                                      IntBuffer device_statuses,
                                                                                      CUstream_st stream)

nvcompBatchedGdeflateDecompressAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedGdeflateDecompressAsync(@Cast(value="const void*const*") @ByPtrPtr
                                                                                      Pointer device_compressed_chunk_ptrs,
                                                                                      @Cast(value="const size_t*")
                                                                                      SizeTPointer device_compressed_chunk_bytes,
                                                                                      @Cast(value="const size_t*")
                                                                                      SizeTPointer device_uncompressed_buffer_bytes,
                                                                                      @Cast(value="size_t*")
                                                                                      SizeTPointer device_uncompressed_chunk_bytes,
                                                                                      @Cast(value="size_t")
                                                                                      long num_chunks,
                                                                                      Pointer device_temp_ptr,
                                                                                      @Cast(value="size_t")
                                                                                      long temp_bytes,
                                                                                      @Cast(value="void*const*") @ByPtrPtr
                                                                                      Pointer device_uncompressed_chunk_ptrs,
                                                                                      @Cast(value="nvcompStatus_t*")
                                                                                      int[] device_statuses,
                                                                                      CUstream_st stream)

nvcompBatchedGzipDecompressRequiredAlignments

@MemberGetter
 @Const
 @ByRef
public static nvcompAlignmentRequirements_t nvcompBatchedGzipDecompressRequiredAlignments()

Minimum buffer alignment requirements for decompression.

nvcompBatchedGzipDefaultOpts

@MemberGetter
 @Const
 @ByRef
public static nvcompBatchedGzipOpts_t nvcompBatchedGzipDefaultOpts()

nvcompBatchedGzipDecompressGetTempSize

@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)

\brief Get the amount of temporary memory required on the GPU for decompression.

Parameters:: num_chunks - [in] Number of chunks of data to be decompressed.; max_uncompressed_chunk_bytes - [in] The size of the largest chunk in bytes when uncompressed.; temp_bytes - [out] The amount of GPU memory that will be temporarily required during decompression.
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedGzipDecompressGetTempSizeEx

@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_total_uncompressed_bytes)

\brief Get the amount of temporary memory required on the GPU for decompression with extra total bytes argument.

Parameters:: num_chunks - [in] Number of chunks of data to be decompressed.; max_uncompressed_chunk_bytes - [in] The size of the largest chunk in bytes when uncompressed.; temp_bytes - [out] The amount of GPU memory that will be temporarily required during decompression.; max_total_uncompressed_bytes - [in] The total decompressed size of all the chunks. Unused in gzip.
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedGzipGetDecompressSizeAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedGzipGetDecompressSizeAsync(@Cast(value="const void*const*")
                                                                                         PointerPointer device_compressed_chunk_ptrs,
                                                                                         @Cast(value="const size_t*")
                                                                                         SizeTPointer device_compressed_chunk_bytes,
                                                                                         @Cast(value="size_t*")
                                                                                         SizeTPointer device_uncompressed_chunk_bytes,
                                                                                         @Cast(value="size_t")
                                                                                         long num_chunks,
                                                                                         CUstream_st stream)

Parameters:: device_compressed_chunk_ptrs - [in] Array with size \p num_chunks of pointers in device-accessible memory to compressed buffers. Each buffer must be aligned to the value in nvcompBatchedGzipDecompressRequiredAlignments.input.; device_compressed_chunk_bytes - [in] Array with size \p num_chunks of sizes of the compressed buffers in bytes. The sizes should reside in device-accessible memory.; device_uncompressed_chunk_bytes - [out] Array with size \p num_chunks to be filled with the sizes, in bytes, of each uncompressed data chunk.; num_chunks - [in] Number of data chunks to compute sizes of.; stream - [in] The CUDA stream to operate on.
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedGzipGetDecompressSizeAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedGzipGetDecompressSizeAsync(@Cast(value="const void*const*") @ByPtrPtr
                                                                                         Pointer device_compressed_chunk_ptrs,
                                                                                         @Cast(value="const size_t*")
                                                                                         SizeTPointer device_compressed_chunk_bytes,
                                                                                         @Cast(value="size_t*")
                                                                                         SizeTPointer device_uncompressed_chunk_bytes,
                                                                                         @Cast(value="size_t")
                                                                                         long num_chunks,
                                                                                         CUstream_st stream)

nvcompBatchedGzipDecompressAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedGzipDecompressAsync(@Cast(value="const void*const*")
                                                                                  PointerPointer device_compressed_chunk_ptrs,
                                                                                  @Cast(value="const size_t*")
                                                                                  SizeTPointer device_compressed_chunk_bytes,
                                                                                  @Cast(value="const size_t*")
                                                                                  SizeTPointer device_uncompressed_buffer_bytes,
                                                                                  @Cast(value="size_t*")
                                                                                  SizeTPointer device_uncompressed_chunk_bytes,
                                                                                  @Cast(value="size_t")
                                                                                  long num_chunks,
                                                                                  Pointer device_temp_ptr,
                                                                                  @Cast(value="size_t")
                                                                                  long temp_bytes,
                                                                                  @Cast(value="void*const*")
                                                                                  PointerPointer device_uncompressed_chunk_ptrs,
                                                                                  @Cast(value="nvcompStatus_t*")
                                                                                  IntPointer device_statuses,
                                                                                  CUstream_st stream)

Parameters:: device_compressed_chunk_ptrs - [in] Array with size \p num_chunks of pointers in device-accessible memory to device-accessible compressed buffers. Each buffer must be aligned to the value in nvcompBatchedGzipDecompressRequiredAlignments.input.; device_compressed_chunk_bytes - [in] Array with size \p num_chunks of sizes of the compressed buffers in bytes. The sizes should reside in device-accessible memory.; device_uncompressed_buffer_bytes - [in] Array with size \p num_chunks of sizes, in bytes, of the output buffers to be filled with uncompressed data for each chunk. The sizes should reside in device-accessible memory. If a size is not large enough to hold all decompressed data, the decompressor will set the status in \p device_statuses corresponding to the overflow chunk to nvcompErrorCannotDecompress.; device_uncompressed_chunk_bytes - [out] Array with size \p num_chunks to be filled with the actual number of bytes decompressed for every chunk. This argument needs to be preallocated, but can be nullptr if desired, in which case the actual sizes are not reported.; num_chunks - [in] Number of chunks of data to decompress.; device_temp_ptr - [in] The temporary GPU space. Must be aligned to the value in nvcompBatchedGzipDecompressRequiredAlignments.temp.; temp_bytes - [in] The size of the temporary GPU space.; device_uncompressed_chunk_ptrs - [out] Array with size \p num_chunks of pointers in device-accessible memory to decompressed data. Each uncompressed buffer needs to be preallocated in device-accessible memory, have the size specified by the corresponding entry in \p device_uncompressed_buffer_bytes, and be aligned to the value in nvcompBatchedGzipDecompressRequiredAlignments.output.; device_statuses - [out] Array with size \p num_chunks of statuses in device-accessible memory. This argument needs to be preallocated. For each chunk, 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. Can be nullptr if desired, in which case error status is not reported.; stream - [in] The CUDA stream to operate on.
Returns:: nvcompSuccess if successfully launched, and an error code otherwise.

nvcompBatchedGzipDecompressAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedGzipDecompressAsync(@Cast(value="const void*const*") @ByPtrPtr
                                                                                  Pointer device_compressed_chunk_ptrs,
                                                                                  @Cast(value="const size_t*")
                                                                                  SizeTPointer device_compressed_chunk_bytes,
                                                                                  @Cast(value="const size_t*")
                                                                                  SizeTPointer device_uncompressed_buffer_bytes,
                                                                                  @Cast(value="size_t*")
                                                                                  SizeTPointer device_uncompressed_chunk_bytes,
                                                                                  @Cast(value="size_t")
                                                                                  long num_chunks,
                                                                                  Pointer device_temp_ptr,
                                                                                  @Cast(value="size_t")
                                                                                  long temp_bytes,
                                                                                  @Cast(value="void*const*") @ByPtrPtr
                                                                                  Pointer device_uncompressed_chunk_ptrs,
                                                                                  @Cast(value="nvcompStatus_t*")
                                                                                  IntPointer device_statuses,
                                                                                  CUstream_st stream)

nvcompBatchedGzipDecompressAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedGzipDecompressAsync(@Cast(value="const void*const*") @ByPtrPtr
                                                                                  Pointer device_compressed_chunk_ptrs,
                                                                                  @Cast(value="const size_t*")
                                                                                  SizeTPointer device_compressed_chunk_bytes,
                                                                                  @Cast(value="const size_t*")
                                                                                  SizeTPointer device_uncompressed_buffer_bytes,
                                                                                  @Cast(value="size_t*")
                                                                                  SizeTPointer device_uncompressed_chunk_bytes,
                                                                                  @Cast(value="size_t")
                                                                                  long num_chunks,
                                                                                  Pointer device_temp_ptr,
                                                                                  @Cast(value="size_t")
                                                                                  long temp_bytes,
                                                                                  @Cast(value="void*const*") @ByPtrPtr
                                                                                  Pointer device_uncompressed_chunk_ptrs,
                                                                                  @Cast(value="nvcompStatus_t*")
                                                                                  IntBuffer device_statuses,
                                                                                  CUstream_st stream)

nvcompBatchedGzipDecompressAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedGzipDecompressAsync(@Cast(value="const void*const*") @ByPtrPtr
                                                                                  Pointer device_compressed_chunk_ptrs,
                                                                                  @Cast(value="const size_t*")
                                                                                  SizeTPointer device_compressed_chunk_bytes,
                                                                                  @Cast(value="const size_t*")
                                                                                  SizeTPointer device_uncompressed_buffer_bytes,
                                                                                  @Cast(value="size_t*")
                                                                                  SizeTPointer device_uncompressed_chunk_bytes,
                                                                                  @Cast(value="size_t")
                                                                                  long num_chunks,
                                                                                  Pointer device_temp_ptr,
                                                                                  @Cast(value="size_t")
                                                                                  long temp_bytes,
                                                                                  @Cast(value="void*const*") @ByPtrPtr
                                                                                  Pointer device_uncompressed_chunk_ptrs,
                                                                                  @Cast(value="nvcompStatus_t*")
                                                                                  int[] device_statuses,
                                                                                  CUstream_st stream)

nvcompBatchedLZ4DefaultOpts

@MemberGetter
 @Const
 @ByRef
public static nvcompBatchedLZ4Opts_t nvcompBatchedLZ4DefaultOpts()

nvcompLZ4CompressionMaxAllowedChunkSize

@MemberGetter
 @Cast(value="const size_t")
public static long nvcompLZ4CompressionMaxAllowedChunkSize()

nvcompLZ4RequiredAlignment
```
@MemberGetter
 @Cast(value="const size_t")
public static long nvcompLZ4RequiredAlignment()
```
The most restrictive of minimum alignment requirements for void-type CUDA memory buffers used for input, output, or temporary memory, passed to compression or decompression functions. In all cases, typed memory buffers must still be aligned to their type's size, e.g., 4 bytes for int.

nvcompBatchedLZ4CompressGetRequiredAlignments

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedLZ4CompressGetRequiredAlignments(@ByVal
                                                                                               nvcompBatchedLZ4Opts_t format_opts,
                                                                                               nvcompAlignmentRequirements_t alignment_requirements)

\brief Get the minimum buffer alignment requirements for compression.

Parameters:: format_opts - [in] Compression options.; alignment_requirements - [out] The minimum buffer alignment requirements for compression.
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedLZ4CompressGetTempSize

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedLZ4CompressGetTempSize(@Cast(value="size_t")
                                                                                     long num_chunks,
                                                                                     @Cast(value="size_t")
                                                                                     long max_uncompressed_chunk_bytes,
                                                                                     @ByVal
                                                                                     nvcompBatchedLZ4Opts_t format_opts,
                                                                                     @Cast(value="size_t*")
                                                                                     SizeTPointer temp_bytes)

\brief Get the amount of temporary memory required on the GPU for compression. Chunk size must not exceed 16777216 bytes. For best performance, a chunk size of 65536 bytes is recommended.

Parameters:: num_chunks - [in] The number of chunks of memory in the batch.; max_uncompressed_chunk_bytes - [in] The maximum size of a chunk in the batch.; format_opts - [in] The LZ4 compression options to use.; temp_bytes - [out] The amount of GPU memory that will be temporarily required during compression.
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedLZ4CompressGetTempSizeEx

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedLZ4CompressGetTempSizeEx(@Cast(value="size_t")
                                                                                       long num_chunks,
                                                                                       @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)

\brief Get the amount of temporary memory required on the GPU for compression with extra total bytes argument. Chunk size must not exceed 16777216 bytes. For best performance, a chunk size of 65536 bytes is recommended.

Parameters:: num_chunks - [in] The number of chunks of memory in the batch.; max_uncompressed_chunk_bytes - [in] The maximum size of a chunk in the batch.; format_opts - [in] The LZ4 compression options to use.; temp_bytes - [out] The amount of GPU memory that will be temporarily required during compression.; max_total_uncompressed_bytes - [in] Upper bound on the total uncompressed size of all chunks
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedLZ4CompressGetMaxOutputChunkSize

@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_chunk_bytes)

\brief Get the maximum size that a chunk of size at most max_uncompressed_chunk_bytes could compress to. That is, the minimum amount of output memory required to be given nvcompBatchedLZ4CompressAsync() for each chunk. Chunk size must not exceed 16777216 bytes. For best performance, a chunk size of 65536 bytes is recommended.

Parameters:: max_uncompressed_chunk_bytes - [in] The maximum size of a chunk before compression.; format_opts - [in] The LZ4 compression options to use.; max_compressed_chunk_bytes - [out] The maximum possible compressed size of the chunk.
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedLZ4CompressAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedLZ4CompressAsync(@Cast(value="const void*const*")
                                                                               PointerPointer device_uncompressed_chunk_ptrs,
                                                                               @Cast(value="const size_t*")
                                                                               SizeTPointer device_uncompressed_chunk_bytes,
                                                                               @Cast(value="size_t")
                                                                               long max_uncompressed_chunk_bytes,
                                                                               @Cast(value="size_t")
                                                                               long num_chunks,
                                                                               Pointer device_temp_ptr,
                                                                               @Cast(value="size_t")
                                                                               long temp_bytes,
                                                                               @Cast(value="void*const*")
                                                                               PointerPointer device_compressed_chunk_ptrs,
                                                                               @Cast(value="size_t*")
                                                                               SizeTPointer device_compressed_chunk_bytes,
                                                                               @ByVal
                                                                               nvcompBatchedLZ4Opts_t format_opts,
                                                                               CUstream_st stream)

\brief Perform batched asynchronous compression. \note Violating any of the conditions listed in the parameter descriptions below may result in undefined behaviour.

Parameters:: device_uncompressed_chunk_ptrs - [in] Array with size \p num_chunks of pointers to the uncompressed data chunks. Both the pointers and the uncompressed data should reside in device-accessible memory. Each chunk must be aligned to the value in the input member of the \ref nvcompAlignmentRequirements_t object output by nvcompBatchedLZ4CompressGetRequiredAlignments when called with the same \p format_opts.; device_uncompressed_chunk_bytes - [in] Array with size \p num_chunks of sizes of the uncompressed chunks 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. Chunk sizes must not exceed 16777216 bytes. For best performance, a chunk size of 65536 bytes is recommended.; max_uncompressed_chunk_bytes - [in] The size of the largest uncompressed chunk.; num_chunks - [in] Number of chunks of data to compress.; device_temp_ptr - [in] The temporary GPU workspace. Must be aligned to the value in the temp member of the \ref nvcompAlignmentRequirements_t object output by nvcompBatchedLZ4CompressGetRequiredAlignments when called with the same \p format_opts.; temp_bytes - [in] The size of the temporary GPU memory pointed to by device_temp_ptr.; device_compressed_chunk_ptrs - [out] Array with size \p num_chunks 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 the size given by nvcompBatchedLZ4CompressGetMaxOutputChunkSize. Each compressed buffer must be aligned to the value in the output member of the \ref nvcompAlignmentRequirements_t object output by nvcompBatchedLZ4CompressGetRequiredAlignments when called with the same \p format_opts.; device_compressed_chunk_bytes - [out] Array with size \p num_chunks, to be filled with the compressed sizes of each chunk. The buffer should be preallocated in device-accessible memory.; format_opts - [in] The LZ4 compression options to use.; stream - [in] The CUDA stream to operate on.
Returns:: nvcompSuccess if successfully launched, and an error code otherwise.

nvcompBatchedLZ4CompressAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedLZ4CompressAsync(@Cast(value="const void*const*") @ByPtrPtr
                                                                               Pointer device_uncompressed_chunk_ptrs,
                                                                               @Cast(value="const size_t*")
                                                                               SizeTPointer device_uncompressed_chunk_bytes,
                                                                               @Cast(value="size_t")
                                                                               long max_uncompressed_chunk_bytes,
                                                                               @Cast(value="size_t")
                                                                               long num_chunks,
                                                                               Pointer device_temp_ptr,
                                                                               @Cast(value="size_t")
                                                                               long temp_bytes,
                                                                               @Cast(value="void*const*") @ByPtrPtr
                                                                               Pointer device_compressed_chunk_ptrs,
                                                                               @Cast(value="size_t*")
                                                                               SizeTPointer device_compressed_chunk_bytes,
                                                                               @ByVal
                                                                               nvcompBatchedLZ4Opts_t format_opts,
                                                                               CUstream_st stream)

nvcompBatchedLZ4DecompressRequiredAlignments

@MemberGetter
 @Const
 @ByRef
public static nvcompAlignmentRequirements_t nvcompBatchedLZ4DecompressRequiredAlignments()

Minimum buffer alignment requirements for decompression.

nvcompBatchedLZ4DecompressGetTempSize

@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)

\brief Get the amount of temporary memory required on the GPU for decompression.

Parameters:: num_chunks - [in] Number of chunks of data to be decompressed.; max_uncompressed_chunk_bytes - [in] The size of the largest chunk in bytes when uncompressed.; temp_bytes - [out] The amount of GPU memory that will be temporarily required during decompression.
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedLZ4DecompressGetTempSizeEx

@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_total_uncompressed_bytes)

\brief Get the amount of temporary memory required on the GPU for decompression with extra total bytes argument.

Parameters:: num_chunks - [in] Number of chunks of data to be decompressed.; max_uncompressed_chunk_bytes - [in] The size of the largest chunk in bytes when uncompressed.; temp_bytes - [out] The amount of GPU memory that will be temporarily required during decompression.; max_total_uncompressed_bytes - [in] The total decompressed size of all the chunks. Unused in LZ4.
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedLZ4GetDecompressSizeAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedLZ4GetDecompressSizeAsync(@Cast(value="const void*const*")
                                                                                        PointerPointer device_compressed_chunk_ptrs,
                                                                                        @Cast(value="const size_t*")
                                                                                        SizeTPointer device_compressed_chunk_bytes,
                                                                                        @Cast(value="size_t*")
                                                                                        SizeTPointer device_uncompressed_chunk_bytes,
                                                                                        @Cast(value="size_t")
                                                                                        long num_chunks,
                                                                                        CUstream_st stream)

Parameters:: device_compressed_chunk_ptrs - [in] Array with size \p num_chunks of pointers in device-accessible memory to compressed buffers. Each buffer must be aligned to the value in nvcompBatchedLZ4DecompressRequiredAlignments.input.; device_compressed_chunk_bytes - [in] Array with size \p num_chunks of sizes of the compressed buffers in bytes. The sizes should reside in device-accessible memory.; device_uncompressed_chunk_bytes - [out] Array with size \p num_chunks to be filled with the sizes, in bytes, of each uncompressed data chunk. This argument needs to be preallocated in device-accessible memory.; num_chunks - [in] Number of data chunks to compute sizes of.; stream - [in] The CUDA stream to operate on.
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedLZ4GetDecompressSizeAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedLZ4GetDecompressSizeAsync(@Cast(value="const void*const*") @ByPtrPtr
                                                                                        Pointer device_compressed_chunk_ptrs,
                                                                                        @Cast(value="const size_t*")
                                                                                        SizeTPointer device_compressed_chunk_bytes,
                                                                                        @Cast(value="size_t*")
                                                                                        SizeTPointer device_uncompressed_chunk_bytes,
                                                                                        @Cast(value="size_t")
                                                                                        long num_chunks,
                                                                                        CUstream_st stream)

nvcompBatchedLZ4DecompressAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedLZ4DecompressAsync(@Cast(value="const void*const*")
                                                                                 PointerPointer device_compressed_chunk_ptrs,
                                                                                 @Cast(value="const size_t*")
                                                                                 SizeTPointer device_compressed_chunk_bytes,
                                                                                 @Cast(value="const size_t*")
                                                                                 SizeTPointer device_uncompressed_buffer_bytes,
                                                                                 @Cast(value="size_t*")
                                                                                 SizeTPointer device_uncompressed_chunk_bytes,
                                                                                 @Cast(value="size_t")
                                                                                 long num_chunks,
                                                                                 Pointer device_temp_ptr,
                                                                                 @Cast(value="size_t")
                                                                                 long temp_bytes,
                                                                                 @Cast(value="void*const*")
                                                                                 PointerPointer device_uncompressed_chunk_ptrs,
                                                                                 @Cast(value="nvcompStatus_t*")
                                                                                 IntPointer device_statuses,
                                                                                 CUstream_st stream)

\brief Perform batched asynchronous decompression. \note Violating any of the conditions listed in the parameter descriptions below may result in undefined behaviour. \note In the case where a chunk of compressed data is not a valid LZ4 block, 0 will be written for the size of the invalid chunk and nvcompStatusCannotDecompress will be flagged for that chunk.

Parameters:: device_compressed_chunk_ptrs - [in] Array with size \p num_chunks of pointers in device-accessible memory to device-accessible compressed buffers. Each buffer must be aligned to the value in nvcompBatchedLZ4DecompressRequiredAlignments.input.; device_compressed_chunk_bytes - [in] Array with size \p num_chunks of sizes of the compressed buffers in bytes. The sizes should reside in device-accessible memory.; device_uncompressed_buffer_bytes - [in] Array with size \p num_chunks of sizes, in bytes, of the output buffers to be filled with uncompressed data for each chunk. The sizes should reside in device-accessible memory. If a size is not large enough to hold all decompressed data, the decompressor will set the status in \p device_statuses corresponding to the overflow chunk to nvcompErrorCannotDecompress.; device_uncompressed_chunk_bytes - [out] Array with size \p num_chunks to be filled with the actual number of bytes decompressed for every chunk. This argument needs to be preallocated, but can be nullptr if desired, in which case the actual sizes are not reported.; num_chunks - [in] Number of chunks of data to decompress.; device_temp_ptr - [in] The temporary GPU space. Must be aligned to the value in nvcompBatchedLZ4DecompressRequiredAlignments.temp.; temp_bytes - [in] The size of the temporary GPU space.; device_uncompressed_chunk_ptrs - [out] Array with size \p num_chunks of pointers in device-accessible memory to decompressed data. Each uncompressed buffer needs to be preallocated in device-accessible memory, have the size specified by the corresponding entry in \p device_uncompressed_buffer_bytes, and be aligned to the value in nvcompBatchedLZ4DecompressRequiredAlignments.output.; device_statuses - [out] Array with size \p num_chunks of statuses in device-accessible memory. This argument needs to be preallocated. For each chunk, 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. Can be nullptr if desired, in which case error status is not reported.; stream - [in] The CUDA stream to operate on.
Returns:: nvcompSuccess if successfully launched, and an error code otherwise.

nvcompBatchedLZ4DecompressAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedLZ4DecompressAsync(@Cast(value="const void*const*") @ByPtrPtr
                                                                                 Pointer device_compressed_chunk_ptrs,
                                                                                 @Cast(value="const size_t*")
                                                                                 SizeTPointer device_compressed_chunk_bytes,
                                                                                 @Cast(value="const size_t*")
                                                                                 SizeTPointer device_uncompressed_buffer_bytes,
                                                                                 @Cast(value="size_t*")
                                                                                 SizeTPointer device_uncompressed_chunk_bytes,
                                                                                 @Cast(value="size_t")
                                                                                 long num_chunks,
                                                                                 Pointer device_temp_ptr,
                                                                                 @Cast(value="size_t")
                                                                                 long temp_bytes,
                                                                                 @Cast(value="void*const*") @ByPtrPtr
                                                                                 Pointer device_uncompressed_chunk_ptrs,
                                                                                 @Cast(value="nvcompStatus_t*")
                                                                                 IntPointer device_statuses,
                                                                                 CUstream_st stream)

nvcompBatchedLZ4DecompressAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedLZ4DecompressAsync(@Cast(value="const void*const*") @ByPtrPtr
                                                                                 Pointer device_compressed_chunk_ptrs,
                                                                                 @Cast(value="const size_t*")
                                                                                 SizeTPointer device_compressed_chunk_bytes,
                                                                                 @Cast(value="const size_t*")
                                                                                 SizeTPointer device_uncompressed_buffer_bytes,
                                                                                 @Cast(value="size_t*")
                                                                                 SizeTPointer device_uncompressed_chunk_bytes,
                                                                                 @Cast(value="size_t")
                                                                                 long num_chunks,
                                                                                 Pointer device_temp_ptr,
                                                                                 @Cast(value="size_t")
                                                                                 long temp_bytes,
                                                                                 @Cast(value="void*const*") @ByPtrPtr
                                                                                 Pointer device_uncompressed_chunk_ptrs,
                                                                                 @Cast(value="nvcompStatus_t*")
                                                                                 IntBuffer device_statuses,
                                                                                 CUstream_st stream)

nvcompBatchedLZ4DecompressAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedLZ4DecompressAsync(@Cast(value="const void*const*") @ByPtrPtr
                                                                                 Pointer device_compressed_chunk_ptrs,
                                                                                 @Cast(value="const size_t*")
                                                                                 SizeTPointer device_compressed_chunk_bytes,
                                                                                 @Cast(value="const size_t*")
                                                                                 SizeTPointer device_uncompressed_buffer_bytes,
                                                                                 @Cast(value="size_t*")
                                                                                 SizeTPointer device_uncompressed_chunk_bytes,
                                                                                 @Cast(value="size_t")
                                                                                 long num_chunks,
                                                                                 Pointer device_temp_ptr,
                                                                                 @Cast(value="size_t")
                                                                                 long temp_bytes,
                                                                                 @Cast(value="void*const*") @ByPtrPtr
                                                                                 Pointer device_uncompressed_chunk_ptrs,
                                                                                 @Cast(value="nvcompStatus_t*")
                                                                                 int[] device_statuses,
                                                                                 CUstream_st stream)

nvcompBatchedSnappyDefaultOpts

@MemberGetter
 @Const
 @ByRef
public static nvcompBatchedSnappyOpts_t nvcompBatchedSnappyDefaultOpts()

nvcompSnappyCompressionMaxAllowedChunkSize

@MemberGetter
 @Cast(value="const size_t")
public static long nvcompSnappyCompressionMaxAllowedChunkSize()

nvcompSnappyRequiredAlignment
```
@MemberGetter
 @Cast(value="const size_t")
public static long nvcompSnappyRequiredAlignment()
```
The most restrictive of minimum alignment requirements for void-type CUDA memory buffers used for input, output, or temporary memory, passed to compression or decompression functions. In all cases, typed memory buffers must still be aligned to their type's size, e.g., 4 bytes for int.

nvcompBatchedSnappyCompressGetRequiredAlignments

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedSnappyCompressGetRequiredAlignments(@ByVal
                                                                                                  nvcompBatchedSnappyOpts_t format_opts,
                                                                                                  nvcompAlignmentRequirements_t alignment_requirements)

\brief Get the minimum buffer alignment requirements for compression.

Parameters:: format_opts - [in] Compression options.; alignment_requirements - [out] The minimum buffer alignment requirements for compression.
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedSnappyCompressGetTempSize

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedSnappyCompressGetTempSize(@Cast(value="size_t")
                                                                                        long num_chunks,
                                                                                        @Cast(value="size_t")
                                                                                        long max_uncompressed_chunk_bytes,
                                                                                        @ByVal
                                                                                        nvcompBatchedSnappyOpts_t format_opts,
                                                                                        @Cast(value="size_t*")
                                                                                        SizeTPointer temp_bytes)

\brief Get the amount of temporary memory required on the GPU for compression.

Parameters:: num_chunks - [in] The number of chunks of memory in the batch.; max_uncompressed_chunk_bytes - [in] The maximum size of a chunk in the batch. This parameter is currently unused. Set it to either the actual value or zero.; format_opts - [in] Snappy compression options.; temp_bytes - [out] The amount of GPU memory that will be temporarily required during compression.
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedSnappyCompressGetTempSizeEx

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedSnappyCompressGetTempSizeEx(@Cast(value="size_t")
                                                                                          long num_chunks,
                                                                                          @Cast(value="size_t")
                                                                                          long max_uncompressed_chunk_bytes,
                                                                                          @ByVal
                                                                                          nvcompBatchedSnappyOpts_t format_opts,
                                                                                          @Cast(value="size_t*")
                                                                                          SizeTPointer temp_bytes,
                                                                                          @Cast(value="const size_t")
                                                                                          long max_total_uncompressed_bytes)

\brief Get the amount of temporary memory required on the GPU for compression with extra total bytes argument.

Parameters:: num_chunks - [in] The number of chunks of memory in the batch.; max_uncompressed_chunk_bytes - [in] The maximum size of a chunk in the batch. This parameter is currently unused. Set it to either the actual value or zero.; format_opts - [in] Snappy compression options.; temp_bytes - [out] The amount of GPU memory that will be temporarily required during compression.; max_total_uncompressed_bytes - [in] Upper bound on the total uncompressed size of all chunks
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedSnappyCompressGetMaxOutputChunkSize

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedSnappyCompressGetMaxOutputChunkSize(@Cast(value="size_t")
                                                                                                  long max_uncompressed_chunk_bytes,
                                                                                                  @ByVal
                                                                                                  nvcompBatchedSnappyOpts_t format_opts,
                                                                                                  @Cast(value="size_t*")
                                                                                                  SizeTPointer max_compressed_chunk_bytes)

Parameters:: max_uncompressed_chunk_bytes - [in] The maximum size of a chunk before compression.; format_opts - [in] Snappy compression options.; max_compressed_chunk_bytes - [out] The maximum possible compressed size of the chunk.
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedSnappyCompressAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedSnappyCompressAsync(@Cast(value="const void*const*")
                                                                                  PointerPointer device_uncompressed_chunk_ptrs,
                                                                                  @Cast(value="const size_t*")
                                                                                  SizeTPointer device_uncompressed_chunk_bytes,
                                                                                  @Cast(value="size_t")
                                                                                  long max_uncompressed_chunk_bytes,
                                                                                  @Cast(value="size_t")
                                                                                  long num_chunks,
                                                                                  Pointer device_temp_ptr,
                                                                                  @Cast(value="size_t")
                                                                                  long temp_bytes,
                                                                                  @Cast(value="void*const*")
                                                                                  PointerPointer device_compressed_chunk_ptrs,
                                                                                  @Cast(value="size_t*")
                                                                                  SizeTPointer device_compressed_chunk_bytes,
                                                                                  @ByVal
                                                                                  nvcompBatchedSnappyOpts_t format_opts,
                                                                                  CUstream_st stream)

\brief Perform batched asynchronous compression. \note Violating any of the conditions listed in the parameter descriptions below may result in undefined behaviour.

Parameters:: device_uncompressed_chunk_ptrs - [in] Array with size \p num_chunks of pointers to the uncompressed data chunks. Both the pointers and the uncompressed data should reside in device-accessible memory. Each chunk must be aligned to the value in the input member of the \ref nvcompAlignmentRequirements_t object output by nvcompBatchedSnappyCompressGetRequiredAlignments when called with the same \p format_opts.; device_uncompressed_chunk_bytes - [in] Array with size \p num_chunks of sizes of the uncompressed chunks in bytes. The sizes should reside in device-accessible memory.; max_uncompressed_chunk_bytes - [in] The size of the largest uncompressed chunk. This parameter is currently unused. Set it to either the actual value or zero.; num_chunks - [in] Number of chunks of data to compress.; device_temp_ptr - [in] The temporary GPU workspace, could be NULL in case temporary memory is not needed. Must be aligned to the value in the temp member of the \ref nvcompAlignmentRequirements_t object output by nvcompBatchedSnappyCompressGetRequiredAlignments when called with the same \p format_opts.; temp_bytes - [in] The size of the temporary GPU memory pointed to by device_temp_ptr.; device_compressed_chunk_ptrs - [out] Array with size \p num_chunks 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 the size given by nvcompBatchedSnappyCompressGetMaxOutputChunkSize. Each compressed buffer must be aligned to the value in the output member of the \ref nvcompAlignmentRequirements_t object output by nvcompBatchedSnappyCompressGetRequiredAlignments when called with the same \p format_opts.; device_compressed_chunk_bytes - [out] Array with size \p num_chunks, to be filled with the compressed sizes of each chunk. The buffer should be preallocated in device-accessible memory.; format_opts - [in] Snappy compression options.; stream - [in] The CUDA stream to operate on.
Returns:: nvcompSuccess if successfully launched, and an error code otherwise.

nvcompBatchedSnappyCompressAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedSnappyCompressAsync(@Cast(value="const void*const*") @ByPtrPtr
                                                                                  Pointer device_uncompressed_chunk_ptrs,
                                                                                  @Cast(value="const size_t*")
                                                                                  SizeTPointer device_uncompressed_chunk_bytes,
                                                                                  @Cast(value="size_t")
                                                                                  long max_uncompressed_chunk_bytes,
                                                                                  @Cast(value="size_t")
                                                                                  long num_chunks,
                                                                                  Pointer device_temp_ptr,
                                                                                  @Cast(value="size_t")
                                                                                  long temp_bytes,
                                                                                  @Cast(value="void*const*") @ByPtrPtr
                                                                                  Pointer device_compressed_chunk_ptrs,
                                                                                  @Cast(value="size_t*")
                                                                                  SizeTPointer device_compressed_chunk_bytes,
                                                                                  @ByVal
                                                                                  nvcompBatchedSnappyOpts_t format_opts,
                                                                                  CUstream_st stream)

nvcompBatchedSnappyDecompressRequiredAlignments

@MemberGetter
 @Const
 @ByRef
public static nvcompAlignmentRequirements_t nvcompBatchedSnappyDecompressRequiredAlignments()

Minimum buffer alignment requirements for decompression.

nvcompBatchedSnappyDecompressGetTempSize

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedSnappyDecompressGetTempSize(@Cast(value="size_t")
                                                                                          long num_chunks,
                                                                                          @Cast(value="size_t")
                                                                                          long max_uncompressed_chunk_bytes,
                                                                                          @Cast(value="size_t*")
                                                                                          SizeTPointer temp_bytes)

\brief Get the amount of temporary memory required on the GPU for decompression.

Parameters:: num_chunks - [in] Number of chunks of data to be decompressed.; max_uncompressed_chunk_bytes - [in] The size of the largest chunk in bytes when uncompressed.; temp_bytes - [out] The amount of GPU memory that will be temporarily required during decompression.
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedSnappyDecompressGetTempSizeEx

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedSnappyDecompressGetTempSizeEx(@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_total_uncompressed_bytes)

\brief Get the amount of temporary memory required on the GPU for decompression with extra total bytes argument.

Parameters:: num_chunks - [in] Number of chunks of data to be decompressed.; max_uncompressed_chunk_bytes - [in] The size of the largest chunk in bytes when uncompressed.; temp_bytes - [out] The amount of GPU memory that will be temporarily required during decompression.; max_total_uncompressed_bytes - [in] The total decompressed size of all the chunks. Unused in Snappy.
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedSnappyGetDecompressSizeAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedSnappyGetDecompressSizeAsync(@Cast(value="const void*const*")
                                                                                           PointerPointer device_compressed_chunk_ptrs,
                                                                                           @Cast(value="const size_t*")
                                                                                           SizeTPointer device_compressed_chunk_bytes,
                                                                                           @Cast(value="size_t*")
                                                                                           SizeTPointer device_uncompressed_chunk_bytes,
                                                                                           @Cast(value="size_t")
                                                                                           long num_chunks,
                                                                                           CUstream_st stream)

Parameters:: device_compressed_chunk_ptrs - [in] Array with size \p num_chunks of pointers in device-accessible memory to compressed buffers. Each buffer must be aligned to the value in nvcompBatchedSnappyDecompressRequiredAlignments.input.; device_compressed_chunk_bytes - [in] Array with size \p num_chunks of sizes of the compressed buffers in bytes. The sizes should reside in device-accessible memory.; device_uncompressed_chunk_bytes - [out] Array with size \p num_chunks to be filled with the sizes, in bytes, of each uncompressed data chunk. If there is an error when retrieving the size of a chunk, the uncompressed size of that chunk will be set to 0. This argument needs to be preallocated in device-accessible memory.; num_chunks - [in] Number of data chunks to compute sizes of.; stream - [in] The CUDA stream to operate on.
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedSnappyGetDecompressSizeAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedSnappyGetDecompressSizeAsync(@Cast(value="const void*const*") @ByPtrPtr
                                                                                           Pointer device_compressed_chunk_ptrs,
                                                                                           @Cast(value="const size_t*")
                                                                                           SizeTPointer device_compressed_chunk_bytes,
                                                                                           @Cast(value="size_t*")
                                                                                           SizeTPointer device_uncompressed_chunk_bytes,
                                                                                           @Cast(value="size_t")
                                                                                           long num_chunks,
                                                                                           CUstream_st stream)

nvcompBatchedSnappyDecompressAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedSnappyDecompressAsync(@Cast(value="const void*const*")
                                                                                    PointerPointer device_compressed_chunk_ptrs,
                                                                                    @Cast(value="const size_t*")
                                                                                    SizeTPointer device_compressed_chunk_bytes,
                                                                                    @Cast(value="const size_t*")
                                                                                    SizeTPointer device_uncompressed_buffer_bytes,
                                                                                    @Cast(value="size_t*")
                                                                                    SizeTPointer device_uncompressed_chunk_bytes,
                                                                                    @Cast(value="size_t")
                                                                                    long num_chunks,
                                                                                    Pointer device_temp_ptr,
                                                                                    @Cast(value="size_t")
                                                                                    long temp_bytes,
                                                                                    @Cast(value="void*const*")
                                                                                    PointerPointer device_uncompressed_chunk_ptrs,
                                                                                    @Cast(value="nvcompStatus_t*")
                                                                                    IntPointer device_statuses,
                                                                                    CUstream_st stream)

\brief Perform batched asynchronous decompression. \note Violating any of the conditions listed in the parameter descriptions below may result in undefined behaviour.

Parameters:: device_compressed_chunk_ptrs - [in] Array with size \p num_chunks of pointers in device-accessible memory to device-accessible compressed buffers. Each buffer must be aligned to the value in nvcompBatchedSnappyDecompressRequiredAlignments.input.; device_compressed_chunk_bytes - [in] Array with size \p num_chunks of sizes of the compressed buffers in bytes. The sizes should reside in device-accessible memory.; device_uncompressed_buffer_bytes - [in] Array with size \p num_chunks of sizes, in bytes, of the output buffers to be filled with uncompressed data for each chunk. The sizes should reside in device-accessible memory. If a size is not large enough to hold all decompressed data, the decompressor will set the status in \p device_statuses corresponding to the overflow chunk to nvcompErrorCannotDecompress.; device_uncompressed_chunk_bytes - [out] Array with size \p num_chunks to be filled with the actual number of bytes decompressed for every chunk. This argument needs to be preallocated, but can be nullptr if desired, in which case the actual sizes are not reported.; num_chunks - [in] Number of chunks of data to decompress.; device_temp_ptr - [in] The temporary GPU space, could be NULL in case temporary space is not needed. Must be aligned to the value in nvcompBatchedSnappyDecompressRequiredAlignments.temp.; temp_bytes - [in] The size of the temporary GPU space.; device_uncompressed_chunk_ptrs - [out] Array with size \p num_chunks of pointers in device-accessible memory to decompressed data. Each uncompressed buffer needs to be preallocated in device-accessible memory, have the size specified by the corresponding entry in \p device_uncompressed_buffer_bytes, and be aligned to the value in nvcompBatchedSnappyDecompressRequiredAlignments.output.; device_statuses - [out] Array with size \p num_chunks of statuses in device-accessible memory. This argument needs to be preallocated. For each chunk, 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. Can be nullptr if desired, in which case error status is not reported.; stream - [in] The CUDA stream to operate on.
Returns:: nvcompSuccess if successfully launched, and an error code otherwise.

nvcompBatchedSnappyDecompressAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedSnappyDecompressAsync(@Cast(value="const void*const*") @ByPtrPtr
                                                                                    Pointer device_compressed_chunk_ptrs,
                                                                                    @Cast(value="const size_t*")
                                                                                    SizeTPointer device_compressed_chunk_bytes,
                                                                                    @Cast(value="const size_t*")
                                                                                    SizeTPointer device_uncompressed_buffer_bytes,
                                                                                    @Cast(value="size_t*")
                                                                                    SizeTPointer device_uncompressed_chunk_bytes,
                                                                                    @Cast(value="size_t")
                                                                                    long num_chunks,
                                                                                    Pointer device_temp_ptr,
                                                                                    @Cast(value="size_t")
                                                                                    long temp_bytes,
                                                                                    @Cast(value="void*const*") @ByPtrPtr
                                                                                    Pointer device_uncompressed_chunk_ptrs,
                                                                                    @Cast(value="nvcompStatus_t*")
                                                                                    IntPointer device_statuses,
                                                                                    CUstream_st stream)

nvcompBatchedSnappyDecompressAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedSnappyDecompressAsync(@Cast(value="const void*const*") @ByPtrPtr
                                                                                    Pointer device_compressed_chunk_ptrs,
                                                                                    @Cast(value="const size_t*")
                                                                                    SizeTPointer device_compressed_chunk_bytes,
                                                                                    @Cast(value="const size_t*")
                                                                                    SizeTPointer device_uncompressed_buffer_bytes,
                                                                                    @Cast(value="size_t*")
                                                                                    SizeTPointer device_uncompressed_chunk_bytes,
                                                                                    @Cast(value="size_t")
                                                                                    long num_chunks,
                                                                                    Pointer device_temp_ptr,
                                                                                    @Cast(value="size_t")
                                                                                    long temp_bytes,
                                                                                    @Cast(value="void*const*") @ByPtrPtr
                                                                                    Pointer device_uncompressed_chunk_ptrs,
                                                                                    @Cast(value="nvcompStatus_t*")
                                                                                    IntBuffer device_statuses,
                                                                                    CUstream_st stream)

nvcompBatchedSnappyDecompressAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedSnappyDecompressAsync(@Cast(value="const void*const*") @ByPtrPtr
                                                                                    Pointer device_compressed_chunk_ptrs,
                                                                                    @Cast(value="const size_t*")
                                                                                    SizeTPointer device_compressed_chunk_bytes,
                                                                                    @Cast(value="const size_t*")
                                                                                    SizeTPointer device_uncompressed_buffer_bytes,
                                                                                    @Cast(value="size_t*")
                                                                                    SizeTPointer device_uncompressed_chunk_bytes,
                                                                                    @Cast(value="size_t")
                                                                                    long num_chunks,
                                                                                    Pointer device_temp_ptr,
                                                                                    @Cast(value="size_t")
                                                                                    long temp_bytes,
                                                                                    @Cast(value="void*const*") @ByPtrPtr
                                                                                    Pointer device_uncompressed_chunk_ptrs,
                                                                                    @Cast(value="nvcompStatus_t*")
                                                                                    int[] device_statuses,
                                                                                    CUstream_st stream)

nvcompBatchedZstdDefaultOpts

@MemberGetter
 @Const
 @ByRef
public static nvcompBatchedZstdOpts_t nvcompBatchedZstdDefaultOpts()

nvcompZstdCompressionMaxAllowedChunkSize

@MemberGetter
 @Cast(value="const size_t")
public static long nvcompZstdCompressionMaxAllowedChunkSize()

nvcompZstdRequiredAlignment
```
@MemberGetter
 @Cast(value="const size_t")
public static long nvcompZstdRequiredAlignment()
```
The most restrictive of minimum alignment requirements for void-type CUDA memory buffers used for input, output, or temporary memory, passed to compression or decompression functions. In all cases, typed memory buffers must still be aligned to their type's size, e.g., 4 bytes for int.

nvcompBatchedZstdCompressGetRequiredAlignments

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedZstdCompressGetRequiredAlignments(@ByVal
                                                                                                nvcompBatchedZstdOpts_t format_opts,
                                                                                                nvcompAlignmentRequirements_t alignment_requirements)

\brief Get the minimum buffer alignment requirements for compression.

Parameters:: format_opts - [in] Compression options.; alignment_requirements - [out] The minimum buffer alignment requirements for compression.
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedZstdCompressGetTempSize

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedZstdCompressGetTempSize(@Cast(value="size_t")
                                                                                      long num_chunks,
                                                                                      @Cast(value="size_t")
                                                                                      long max_uncompressed_chunk_bytes,
                                                                                      @ByVal
                                                                                      nvcompBatchedZstdOpts_t format_opts,
                                                                                      @Cast(value="size_t*")
                                                                                      SizeTPointer temp_bytes)

\brief Get the amount of temporary memory required on the GPU for compression. Chunk size must not exceed 16 MB. For best performance, a chunk size of 64 KB is recommended.

Parameters:: num_chunks - [in] The number of chunks of memory in the batch.; max_uncompressed_chunk_bytes - [in] The maximum size of a chunk in the batch.; format_opts - [in] The ZSTD compression options to use -- currently empty; temp_bytes - [out] The amount of GPU memory that will be temporarily required during compression.
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedZstdCompressGetTempSizeEx

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedZstdCompressGetTempSizeEx(@Cast(value="size_t")
                                                                                        long num_chunks,
                                                                                        @Cast(value="size_t")
                                                                                        long max_uncompressed_chunk_bytes,
                                                                                        @ByVal
                                                                                        nvcompBatchedZstdOpts_t format_opts,
                                                                                        @Cast(value="size_t*")
                                                                                        SizeTPointer temp_bytes,
                                                                                        @Cast(value="const size_t")
                                                                                        long max_total_uncompressed_bytes)

\brief Get the amount of temporary memory required on the GPU for compression with extra total bytes argument. Chunk size must not exceed 16 MB. For best performance, a chunk size of 64 KB is recommended. This extended API is useful for cases where chunk sizes aren't uniform in the batch I.e. in the non-extended API, if all but 1 chunk is 64 KB, but 1 chunk is 16 MB, the temporary space computed is based on 16 MB * num_chunks.

Parameters:: num_chunks - [in] The number of chunks of memory in the batch.; max_uncompressed_chunk_bytes - [in] The maximum size of a chunk in the batch.; format_opts - [in] The ZSTD compression options to use. Currently empty.; temp_bytes - [out] The amount of GPU memory that will be temporarily required during compression.; max_total_uncompressed_bytes - [in] Upper bound on the total uncompressed size of all chunks
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedZstdCompressGetMaxOutputChunkSize

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedZstdCompressGetMaxOutputChunkSize(@Cast(value="size_t")
                                                                                                long max_uncompressed_chunk_bytes,
                                                                                                @ByVal
                                                                                                nvcompBatchedZstdOpts_t format_opts,
                                                                                                @Cast(value="size_t*")
                                                                                                SizeTPointer max_compressed_chunk_bytes)

\brief Get the maximum size that a chunk of size at most max_uncompressed_chunk_bytes could compress to. That is, the minimum amount of output memory required to be given nvcompBatchedZstdCompressAsync() for each chunk. Chunk size must not exceed 16 MB. For best performance, a chunk size of 64 KB is recommended.

Parameters:: max_uncompressed_chunk_bytes - [in] The maximum size of a chunk before compression.; format_opts - [in] The Zstd compression options to use. Currently empty.; max_compressed_chunk_bytes - [out] The maximum possible compressed size of the chunk.
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedZstdCompressAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedZstdCompressAsync(@Cast(value="const void*const*")
                                                                                PointerPointer device_uncompressed_chunk_ptrs,
                                                                                @Cast(value="const size_t*")
                                                                                SizeTPointer device_uncompressed_chunk_bytes,
                                                                                @Cast(value="size_t")
                                                                                long max_uncompressed_chunk_bytes,
                                                                                @Cast(value="size_t")
                                                                                long num_chunks,
                                                                                Pointer device_temp_ptr,
                                                                                @Cast(value="size_t")
                                                                                long temp_bytes,
                                                                                @Cast(value="void*const*")
                                                                                PointerPointer device_compressed_chunk_ptrs,
                                                                                @Cast(value="size_t*")
                                                                                SizeTPointer device_compressed_chunk_bytes,
                                                                                @ByVal
                                                                                nvcompBatchedZstdOpts_t format_opts,
                                                                                CUstream_st stream)

\brief Perform batched asynchronous compression. \note Violating any of the conditions listed in the parameter descriptions below may result in undefined behaviour.

Parameters:: device_uncompressed_chunk_ptrs - [in] Array with size \p num_chunks of pointers to the uncompressed data chunks. Both the pointers and the uncompressed data should reside in device-accessible memory. Each chunk must be aligned to the value in the input member of the \ref nvcompAlignmentRequirements_t object output by nvcompBatchedZstdCompressGetRequiredAlignments when called with the same \p format_opts.; device_uncompressed_chunk_bytes - [in] Array with size \p num_chunks of sizes of the uncompressed chunks in bytes. The sizes should reside in device-accessible memory. Chunk sizes must not exceed 16 MB. For best performance, a chunk size of 64 KB is recommended.; max_uncompressed_chunk_bytes - [in] The size of the largest uncompressed chunk.; num_chunks - [in] Number of chunks of data to compress.; device_temp_ptr - [in] The temporary GPU workspace, could be NULL in case temporary memory is not needed. Must be aligned to the value in the temp member of the \ref nvcompAlignmentRequirements_t object output by nvcompBatchedZstdCompressGetRequiredAlignments when called with the same \p format_opts.; temp_bytes - [in] The size of the temporary GPU memory pointed to by device_temp_ptr.; device_compressed_chunk_ptrs - [out] Array with size \p num_chunks 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 the size given by nvcompBatchedZstdCompressGetMaxOutputChunkSize. Each compressed buffer must be aligned to the value in the output member of the \ref nvcompAlignmentRequirements_t object output by nvcompBatchedZstdCompressGetRequiredAlignments when called with the same \p format_opts.; device_compressed_chunk_bytes - [out] Array with size \p num_chunks, to be filled with the compressed sizes of each chunk. The buffer should be preallocated in device-accessible memory.; format_opts - [in] The Zstd compression options to use. Currently empty.; stream - [in] The CUDA stream to operate on.
Returns:: nvcompSuccess if successfully launched, and an error code otherwise.

nvcompBatchedZstdCompressAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedZstdCompressAsync(@Cast(value="const void*const*") @ByPtrPtr
                                                                                Pointer device_uncompressed_chunk_ptrs,
                                                                                @Cast(value="const size_t*")
                                                                                SizeTPointer device_uncompressed_chunk_bytes,
                                                                                @Cast(value="size_t")
                                                                                long max_uncompressed_chunk_bytes,
                                                                                @Cast(value="size_t")
                                                                                long num_chunks,
                                                                                Pointer device_temp_ptr,
                                                                                @Cast(value="size_t")
                                                                                long temp_bytes,
                                                                                @Cast(value="void*const*") @ByPtrPtr
                                                                                Pointer device_compressed_chunk_ptrs,
                                                                                @Cast(value="size_t*")
                                                                                SizeTPointer device_compressed_chunk_bytes,
                                                                                @ByVal
                                                                                nvcompBatchedZstdOpts_t format_opts,
                                                                                CUstream_st stream)

nvcompBatchedZstdDecompressRequiredAlignments

@MemberGetter
 @Const
 @ByRef
public static nvcompAlignmentRequirements_t nvcompBatchedZstdDecompressRequiredAlignments()

Minimum buffer alignment requirements for decompression.

nvcompBatchedZstdDecompressGetTempSize

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedZstdDecompressGetTempSize(@Cast(value="size_t")
                                                                                        long num_chunks,
                                                                                        @Cast(value="size_t")
                                                                                        long max_uncompressed_chunk_bytes,
                                                                                        @Cast(value="size_t*")
                                                                                        SizeTPointer temp_bytes)

\brief Get the amount of temporary memory required on the GPU for decompression.

Parameters:: num_chunks - [in] Number of chunks of data to be decompressed.; max_uncompressed_chunk_bytes - [in] The size of the largest chunk in bytes when uncompressed.; temp_bytes - [out] The amount of GPU memory that will be temporarily required during decompression.
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedZstdDecompressGetTempSizeEx

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedZstdDecompressGetTempSizeEx(@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_total_uncompressed_bytes)

\brief Get the amount of temporary memory required on the GPU for decompression with extra total bytes argument.

Parameters:: num_chunks - [in] Number of chunks of data to be decompressed.; max_uncompressed_chunk_bytes - [in] The size of the largest chunk in bytes when uncompressed.; temp_bytes - [out] The amount of GPU memory that will be temporarily required during decompression.; max_total_uncompressed_bytes - [in] The total decompressed size of all the chunks.
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedZstdGetDecompressSizeAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedZstdGetDecompressSizeAsync(@Cast(value="const void*const*")
                                                                                         PointerPointer device_compressed_chunk_ptrs,
                                                                                         @Cast(value="const size_t*")
                                                                                         SizeTPointer device_compressed_chunk_bytes,
                                                                                         @Cast(value="size_t*")
                                                                                         SizeTPointer device_uncompressed_chunk_bytes,
                                                                                         @Cast(value="size_t")
                                                                                         long num_chunks,
                                                                                         CUstream_st stream)

Parameters:: device_compressed_chunk_ptrs - [in] Array with size \p num_chunks of pointers in device-accessible memory to compressed buffers. Each buffer must be aligned to the value in nvcompBatchedZstdDecompressRequiredAlignments.input.; device_compressed_chunk_bytes - [in] Array with size \p num_chunks of sizes of the compressed buffers in bytes. The sizes should reside in device-accessible memory.; device_uncompressed_chunk_bytes - [out] Array with size \p num_chunks to be filled with the sizes, in bytes, of each uncompressed data chunk. If there is an error when retrieving the size of a chunk, the uncompressed size of that chunk will be set to 0. This argument needs to be preallocated in device-accessible memory.; num_chunks - [in] Number of data chunks to compute sizes of.; stream - [in] The CUDA stream to operate on.
Returns:: nvcompSuccess if successful, and an error code otherwise.

nvcompBatchedZstdGetDecompressSizeAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedZstdGetDecompressSizeAsync(@Cast(value="const void*const*") @ByPtrPtr
                                                                                         Pointer device_compressed_chunk_ptrs,
                                                                                         @Cast(value="const size_t*")
                                                                                         SizeTPointer device_compressed_chunk_bytes,
                                                                                         @Cast(value="size_t*")
                                                                                         SizeTPointer device_uncompressed_chunk_bytes,
                                                                                         @Cast(value="size_t")
                                                                                         long num_chunks,
                                                                                         CUstream_st stream)

nvcompBatchedZstdDecompressAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedZstdDecompressAsync(@Cast(value="const void*const*")
                                                                                  PointerPointer device_compressed_chunk_ptrs,
                                                                                  @Cast(value="const size_t*")
                                                                                  SizeTPointer device_compressed_chunk_bytes,
                                                                                  @Cast(value="const size_t*")
                                                                                  SizeTPointer device_uncompressed_buffer_bytes,
                                                                                  @Cast(value="size_t*")
                                                                                  SizeTPointer device_uncompressed_chunk_bytes,
                                                                                  @Cast(value="size_t")
                                                                                  long num_chunks,
                                                                                  Pointer device_temp_ptr,
                                                                                  @Cast(value="size_t")
                                                                                  long temp_bytes,
                                                                                  @Cast(value="void*const*")
                                                                                  PointerPointer device_uncompressed_chunk_ptrs,
                                                                                  @Cast(value="nvcompStatus_t*")
                                                                                  IntPointer device_statuses,
                                                                                  CUstream_st stream)

\brief Perform batched asynchronous decompression. \note Violating any of the conditions listed in the parameter descriptions below may result in undefined behaviour.

Parameters:: device_compressed_chunk_ptrs - [in] Array with size \p num_chunks of pointers in device-accessible memory to device-accessible compressed buffers. Each buffer must be aligned to the value in nvcompBatchedZstdDecompressRequiredAlignments.input.; device_compressed_chunk_bytes - [in] Array with size \p num_chunks of sizes of the compressed buffers in bytes. The sizes should reside in device-accessible memory.; device_uncompressed_buffer_bytes - [in] Array with size \p num_chunks of sizes, in bytes, of the output buffers to be filled with uncompressed data for each chunk. The sizes should reside in device-accessible memory. If a size is not large enough to hold all decompressed data, the decompressor will set the status in \p device_statuses corresponding to the overflow chunk to nvcompErrorCannotDecompress.; device_uncompressed_chunk_bytes - [out] Array with size \p num_chunks to be filled with the actual number of bytes decompressed for every chunk.; num_chunks - [in] Number of chunks of data to decompress.; device_temp_ptr - [in] The temporary GPU space, could be NULL in case temporary space is not needed. Must be aligned to the value in nvcompBatchedZstdDecompressRequiredAlignments.temp.; temp_bytes - [in] The size of the temporary GPU space.; device_uncompressed_chunk_ptrs - [out] Array with size \p num_chunks of pointers in device-accessible memory to decompressed data. Each uncompressed buffer needs to be preallocated in device-accessible memory, have the size specified by the corresponding entry in \p device_uncompressed_buffer_bytes, and be aligned to the value in nvcompBatchedZstdDecompressRequiredAlignments.output.; device_statuses - [out] Array with size \p num_chunks of statuses in device-accessible memory. This argument needs to be preallocated. For each chunk, 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.
Returns:: nvcompSuccess if successfully launched, and an error code otherwise.

nvcompBatchedZstdDecompressAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedZstdDecompressAsync(@Cast(value="const void*const*") @ByPtrPtr
                                                                                  Pointer device_compressed_chunk_ptrs,
                                                                                  @Cast(value="const size_t*")
                                                                                  SizeTPointer device_compressed_chunk_bytes,
                                                                                  @Cast(value="const size_t*")
                                                                                  SizeTPointer device_uncompressed_buffer_bytes,
                                                                                  @Cast(value="size_t*")
                                                                                  SizeTPointer device_uncompressed_chunk_bytes,
                                                                                  @Cast(value="size_t")
                                                                                  long num_chunks,
                                                                                  Pointer device_temp_ptr,
                                                                                  @Cast(value="size_t")
                                                                                  long temp_bytes,
                                                                                  @Cast(value="void*const*") @ByPtrPtr
                                                                                  Pointer device_uncompressed_chunk_ptrs,
                                                                                  @Cast(value="nvcompStatus_t*")
                                                                                  IntPointer device_statuses,
                                                                                  CUstream_st stream)

nvcompBatchedZstdDecompressAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedZstdDecompressAsync(@Cast(value="const void*const*") @ByPtrPtr
                                                                                  Pointer device_compressed_chunk_ptrs,
                                                                                  @Cast(value="const size_t*")
                                                                                  SizeTPointer device_compressed_chunk_bytes,
                                                                                  @Cast(value="const size_t*")
                                                                                  SizeTPointer device_uncompressed_buffer_bytes,
                                                                                  @Cast(value="size_t*")
                                                                                  SizeTPointer device_uncompressed_chunk_bytes,
                                                                                  @Cast(value="size_t")
                                                                                  long num_chunks,
                                                                                  Pointer device_temp_ptr,
                                                                                  @Cast(value="size_t")
                                                                                  long temp_bytes,
                                                                                  @Cast(value="void*const*") @ByPtrPtr
                                                                                  Pointer device_uncompressed_chunk_ptrs,
                                                                                  @Cast(value="nvcompStatus_t*")
                                                                                  IntBuffer device_statuses,
                                                                                  CUstream_st stream)

nvcompBatchedZstdDecompressAsync

@Cast(value="nvcompStatus_t")
public static int nvcompBatchedZstdDecompressAsync(@Cast(value="const void*const*") @ByPtrPtr
                                                                                  Pointer device_compressed_chunk_ptrs,
                                                                                  @Cast(value="const size_t*")
                                                                                  SizeTPointer device_compressed_chunk_bytes,
                                                                                  @Cast(value="const size_t*")
                                                                                  SizeTPointer device_uncompressed_buffer_bytes,
                                                                                  @Cast(value="size_t*")
                                                                                  SizeTPointer device_uncompressed_chunk_bytes,
                                                                                  @Cast(value="size_t")
                                                                                  long num_chunks,
                                                                                  Pointer device_temp_ptr,
                                                                                  @Cast(value="size_t")
                                                                                  long temp_bytes,
                                                                                  @Cast(value="void*const*") @ByPtrPtr
                                                                                  Pointer device_uncompressed_chunk_ptrs,
                                                                                  @Cast(value="nvcompStatus_t*")
                                                                                  int[] device_statuses,
                                                                                  CUstream_st stream)

Class nvcomp

Field Summary

Constructor Summary

Method Summary

Methods inherited from class org.bytedeco.cuda.presets.nvcomp

Methods inherited from class java.lang.Object

Field Detail

nvcompSuccess

nvcompErrorInvalidValue

nvcompErrorNotSupported

nvcompErrorCannotDecompress

nvcompErrorBadChecksum

nvcompErrorCannotVerifyChecksums

nvcompErrorOutputBufferTooSmall

nvcompErrorWrongHeaderLength

nvcompErrorAlignment

nvcompErrorChunkSizeTooLarge

nvcompErrorCudaError

nvcompErrorInternal

NVCOMP_TYPE_CHAR

NVCOMP_TYPE_UCHAR

NVCOMP_TYPE_SHORT

NVCOMP_TYPE_USHORT

NVCOMP_TYPE_INT

NVCOMP_TYPE_UINT

NVCOMP_TYPE_LONGLONG

NVCOMP_TYPE_ULONGLONG

NVCOMP_TYPE_UINT8

NVCOMP_TYPE_FLOAT16

NVCOMP_TYPE_BITS

NVCOMP_NATIVE

RAW

WITH_UNCOMPRESSED_SIZE

NoComputeNoVerify

ComputeAndNoVerify

NoComputeAndVerifyIfPresent

ComputeAndVerifyIfPresent

ComputeAndVerify

nvcomp_rANS

uint8

float16

Constructor Detail

nvcomp

Method Detail

nvcompGetProperties

create_manager

create_manager

create_manager

create_manager

create_manager

create_manager

create_manager

create_manager

create_manager

nvcompBatchedANSDefaultOpts

nvcompANSCompressionMaxAllowedChunkSize

nvcompANSRequiredAlignment

nvcompBatchedANSCompressGetRequiredAlignments

nvcompBatchedANSCompressGetTempSize

nvcompBatchedANSCompressGetTempSizeEx

nvcompBatchedANSCompressGetMaxOutputChunkSize

nvcompBatchedANSCompressAsync

nvcompBatchedANSCompressAsync

nvcompBatchedANSDecompressRequiredAlignments

nvcompBatchedANSDecompressGetTempSize

nvcompBatchedANSDecompressGetTempSizeEx

nvcompBatchedANSGetDecompressSizeAsync

nvcompBatchedANSGetDecompressSizeAsync

nvcompBatchedANSDecompressAsync

nvcompBatchedANSDecompressAsync

nvcompBatchedANSDecompressAsync

nvcompBatchedANSDecompressAsync

nvcompBatchedBitcompDefaultOpts

nvcompBitcompCompressionMaxAllowedChunkSize

nvcompBitcompRequiredAlignment

nvcompBatchedBitcompCompressGetRequiredAlignments

nvcompBatchedBitcompCompressGetTempSize

nvcompBatchedBitcompCompressGetTempSizeEx

nvcompBatchedBitcompCompressGetMaxOutputChunkSize

nvcompBatchedBitcompCompressAsync