C API#

通用#

枚举

enum nvcompType_t#

值

enumerator NVCOMP_TYPE_CHAR#
enumerator NVCOMP_TYPE_UCHAR#
enumerator NVCOMP_TYPE_SHORT#
enumerator NVCOMP_TYPE_USHORT#
enumerator NVCOMP_TYPE_INT#
enumerator NVCOMP_TYPE_UINT#
enumerator NVCOMP_TYPE_LONGLONG#
enumerator NVCOMP_TYPE_ULONGLONG#
enumerator NVCOMP_TYPE_UINT8#
enumerator NVCOMP_TYPE_FLOAT16#
enumerator NVCOMP_TYPE_BITS#

函数

nvcompStatus_t nvcompGetProperties(nvcompProperties_t *properties)#

提供 nvCOMP 库属性。

参数:

properties – [out] 在 nvcompProperties_t 句柄中设置 nvCOMP 属性。

返回值:

如果 properties 为 nullptr，则返回 nvcompErrorInvalidValue，否则返回 nvcompSuccess

nvcompStatus_t nvcompDecompressGetTempSize(
const void *metadata_ptr,
size_t *temp_bytes,
)#

计算执行解压缩所需的临时工作空间大小。

已弃用

此接口已弃用，将在未来版本中移除，请切换到 nvcomp/cascaded.h、nvcomp/lz4.h、nvcomp/snappy、nvcomp/bitcomp.h、nvcomp/gdeflate.h、nvcomp/zstd.h、nvcomp/deflate.h 和 nvcomp/ans.h 中的压缩方案特定接口。

参数:

  • metadata_ptr – 元数据。

  • temp_bytes – 所需临时工作空间的大小（以字节为单位）（输出）。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompDecompressGetOutputSize(
const void *metadata_ptr,
size_t *output_bytes,
)#

计算解压缩数据的字节大小。

已弃用

此接口已弃用，将在未来版本中移除，请切换到 nvcomp/cascaded.h、nvcomp/lz4.h、nvcomp/snappy、nvcomp/bitcomp.h、nvcomp/gdeflate.h、nvcomp/zstd.h、nvcomp/deflate.h 和 nvcomp/ans.h 中的压缩方案特定接口。

参数:

  • metadata_ptr – 元数据。

  • output_bytes – 解压缩数据的大小（输出）。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompDecompressGetType(
const void *metadata_ptr,
nvcompType_t *type,
)#

获取压缩数据的类型。

已弃用

此接口已弃用，将在未来版本中移除，请切换到 nvcomp/cascaded.h、nvcomp/lz4.h、nvcomp/snappy、nvcomp/bitcomp.h、nvcomp/gdeflate.h、nvcomp/zstd.h、nvcomp/deflate.h 和 nvcomp/ans.h 中的压缩方案特定接口。

参数:

  • metadata_ptr – 元数据。

  • type – 数据类型（输出）。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompDecompressAsync(
const void *in_ptr,
size_t in_bytes,
void *temp_ptr,
size_t temp_bytes,
void *metadata_ptr,
void *out_ptr,
size_t out_bytes,
cudaStream_t stream,
)#

执行异步解压缩。

已弃用

此接口已弃用，将在未来版本中移除，请切换到 nvcomp/cascaded.h、nvcomp/lz4.h、nvcomp/snappy、nvcomp/bitcomp.h、nvcomp/gdeflate.h、nvcomp/zstd.h、nvcomp/deflate.h 和 nvcomp/ans.h 中的压缩方案特定接口。

参数:

  • in_ptr – 设备上要解压缩的压缩数据。

  • in_bytes – 压缩数据的大小。

  • temp_ptr – 设备上的临时工作空间。

  • temp_bytes – 临时工作空间的大小。

  • metadata_ptr – 元数据。

  • out_ptr – 设备上的输出位置。

  • out_bytes – 输出位置的大小。

  • stream – 要操作的 cuda 流。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

struct nvcompProperties_t#
#include <nvcomp.h>

nvCOMP 属性。

公共成员

uint32_t version#

nvCOMP 库版本。

uint32_t cudart_version#

构建 nvCOMP 库时使用的 CUDA 运行时版本。

枚举

enum nvcompStatus_t#

值

enumerator nvcompSuccess#
enumerator nvcompErrorInvalidValue#
enumerator nvcompErrorNotSupported#
enumerator nvcompErrorCannotDecompress#
enumerator nvcompErrorBadChecksum#
enumerator nvcompErrorCannotVerifyChecksums#
enumerator nvcompErrorOutputBufferTooSmall#
enumerator nvcompErrorWrongHeaderLength#
enumerator nvcompErrorAlignment#
enumerator nvcompErrorChunkSizeTooLarge#
enumerator nvcompErrorCudaError#
enumerator nvcompErrorInternal#
struct nvcompAlignmentRequirements_t#
#include <shared_types.h>

每算法缓冲区对齐要求。

公共成员

size_t input#

每个输入缓冲区的最小对齐要求。

size_t output#

每个输出缓冲区的最小对齐要求。

size_t temp#

临时存储缓冲区的最小对齐要求（如果有）。对于不使用临时存储的算法，此字段始终等于 1。

注意

提供 nvcompBatched<compression_method>CompressGetTempSizeEx API 以允许用户提供 max_total_uncompressed_bytes，否则假定所有块的大小均为 max_uncompressed_chunk_bytes，这可能会导致临时内存需求被高估。

CRC32#

函数

nvcompStatus_t nvcompBatchedCRC32Async(
const void *const *device_uncompressed_chunk_ptrs,
const size_t *device_uncompressed_chunk_bytes,
size_t num_chunks,
uint32_t *device_CRC32_ptr,
cudaStream_t stream,
)#

异步执行 CRC32 校验和计算。所有指针都必须指向 GPU 可访问的位置。

参数:

  • device_uncompressed_chunk_ptrs – [in] 大小为 num_chunks 的指针数组，指向未压缩数据块。指针和未压缩数据都应驻留在设备可访问的内存中。

  • device_uncompressed_chunk_bytes – [in] 大小为 num_chunks 的大小数组，表示未压缩块的大小（以字节为单位）。大小应驻留在设备可访问的内存中。

  • num_chunks – [in] 要计算校验和的块数。

  • device_CRC32_ptr – [out] GPU 上大小为 num_chunks 的数组，用于填充每个块的 CRC32 校验和。

  • stream – [in] 要操作的 CUDA 流。

返回值:

如果成功启动，则返回 nvcompSuccess，否则返回错误代码。

LZ4#

函数

nvcompStatus_t nvcompBatchedLZ4CompressGetRequiredAlignments(
nvcompBatchedLZ4Opts_t format_opts,
nvcompAlignmentRequirements_t *alignment_requirements,
)#

获取压缩的最小缓冲区对齐要求。

参数:

  • format_opts – [in] 压缩选项。

  • alignment_requirements – [out] 压缩的最小缓冲区对齐要求。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedLZ4CompressGetTempSize(
size_t num_chunks,
size_t max_uncompressed_chunk_bytes,
nvcompBatchedLZ4Opts_t format_opts,
size_t *temp_bytes,
)#

获取 GPU 上压缩所需的临时内存量。

块大小不得超过 16777216 字节。为了获得最佳性能，建议块大小为 65536 字节。

参数:

  • num_chunks – [in] 批处理中内存块的数量。

  • max_uncompressed_chunk_bytes – [in] 批处理中块的最大大小。

  • format_opts – [in] 要使用的 LZ4 压缩选项。

  • temp_bytes – [out] 压缩期间临时需要的 GPU 内存量。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedLZ4CompressGetTempSizeEx(
size_t num_chunks,
size_t max_uncompressed_chunk_bytes,
nvcompBatchedLZ4Opts_t format_opts,
size_t *temp_bytes,
const size_t max_total_uncompressed_bytes,
)#

获取 GPU 上压缩所需的临时内存量，并带有额外的总字节参数。

块大小不得超过 16777216 字节。为了获得最佳性能，建议块大小为 65536 字节。

参数:

  • num_chunks – [in] 批处理中内存块的数量。

  • max_uncompressed_chunk_bytes – [in] 批处理中块的最大大小。

  • format_opts – [in] 要使用的 LZ4 压缩选项。

  • temp_bytes – [out] 压缩期间临时需要的 GPU 内存量。

  • max_total_uncompressed_bytes – [in] 所有块的总未压缩大小的上限

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedLZ4CompressGetMaxOutputChunkSize(
size_t max_uncompressed_chunk_bytes,
nvcompBatchedLZ4Opts_t format_opts,
size_t *max_compressed_chunk_bytes,
)#

获取大小最多为 max_uncompressed_chunk_bytes 的块可以压缩到的最大大小。也就是说，为每个块提供 nvcompBatchedLZ4CompressAsync() 所需的最小输出内存量。

块大小不得超过 16777216 字节。为了获得最佳性能，建议块大小为 65536 字节。

参数:

  • max_uncompressed_chunk_bytes – [in] 压缩前块的最大大小。

  • format_opts – [in] 要使用的 LZ4 压缩选项。

  • max_compressed_chunk_bytes – [out] 块的最大可能压缩大小。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedLZ4CompressAsync(
const void *const *device_uncompressed_chunk_ptrs,
const size_t *device_uncompressed_chunk_bytes,
size_t max_uncompressed_chunk_bytes,
size_t num_chunks,
void *device_temp_ptr,
size_t temp_bytes,
void *const *device_compressed_chunk_ptrs,
size_t *device_compressed_chunk_bytes,
nvcompBatchedLZ4Opts_t format_opts,
cudaStream_t stream,
)#

执行批量异步压缩。

注意

违反下面参数描述中列出的任何条件都可能导致未定义的行为。

参数:

  • device_uncompressed_chunk_ptrs – [in] 大小为 num_chunks 的指针数组，指向未压缩数据块。指针和未压缩数据都应驻留在设备可访问的内存中。每个块都必须与 nvcompAlignmentRequirements_t 对象的 `input` 成员中的值对齐，该对象由使用相同 format_opts 调用 `nvcompBatchedLZ4CompressGetRequiredAlignments` 输出。

  • device_uncompressed_chunk_bytes – [in] 大小为 num_chunks 的大小数组，表示未压缩块的大小（以字节为单位）。大小应驻留在设备可访问的内存中。每个块大小都必须是 format_opts.data_type 指定的数据类型大小的倍数。块大小不得超过 16777216 字节。为了获得最佳性能，建议块大小为 65536 字节。

  • max_uncompressed_chunk_bytes – [in] 最大未压缩块的大小。

  • num_chunks – [in] 要压缩的数据块的数量。

  • device_temp_ptr – [in] 临时 GPU 工作空间。必须与 nvcompAlignmentRequirements_t 对象的 `temp` 成员中的值对齐，该对象由使用相同 format_opts 调用 `nvcompBatchedLZ4CompressGetRequiredAlignments` 输出。

  • temp_bytes – [in] 由 `device_temp_ptr` 指向的临时 GPU 内存的大小。

  • device_compressed_chunk_ptrs – [out] 大小为 num_chunks 的指针数组，指向输出压缩缓冲区。指针和压缩缓冲区都应驻留在设备可访问的内存中。每个压缩缓冲区都应预先分配大小，该大小由 `nvcompBatchedLZ4CompressGetMaxOutputChunkSize` 给出。每个压缩缓冲区都必须与 nvcompAlignmentRequirements_t 对象的 `output` 成员中的值对齐，该对象由使用相同 format_opts 调用 `nvcompBatchedLZ4CompressGetRequiredAlignments` 输出。

  • device_compressed_chunk_bytes – [out] 大小为 num_chunks 的数组，用于填充每个块的压缩大小。缓冲区应在设备可访问的内存中预先分配。

  • format_opts – [in] 要使用的 LZ4 压缩选项。

  • stream – [in] 要操作的 CUDA 流。

返回值:

如果成功启动，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedLZ4DecompressGetTempSize(
size_t num_chunks,
size_t max_uncompressed_chunk_bytes,
size_t *temp_bytes,
)#

获取 GPU 上解压缩所需的临时内存量。

参数:

  • num_chunks – [in] 要解压缩的数据块的数量。

  • max_uncompressed_chunk_bytes – [in] 解压缩时最大块的大小（以字节为单位）。

  • temp_bytes – [out] 解压缩期间临时需要的 GPU 内存量。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedLZ4DecompressGetTempSizeEx(
size_t num_chunks,
size_t max_uncompressed_chunk_bytes,
size_t *temp_bytes,
size_t max_total_uncompressed_bytes,
)#

获取 GPU 上解压缩所需的临时内存量，并带有额外的总字节参数。

参数:

  • num_chunks – [in] 要解压缩的数据块的数量。

  • max_uncompressed_chunk_bytes – [in] 解压缩时最大块的大小（以字节为单位）。

  • temp_bytes – [out] 解压缩期间临时需要的 GPU 内存量。

  • max_total_uncompressed_bytes – [in] 所有块的总解压缩大小。在 LZ4 中未使用。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedLZ4GetDecompressSizeAsync(
const void *const *device_compressed_chunk_ptrs,
const size_t *device_compressed_chunk_bytes,
size_t *device_uncompressed_chunk_bytes,
size_t num_chunks,
cudaStream_t stream,
)#

异步计算每个压缩块的未压缩数据字节数。

当我们不知道预期的输出大小时，这是必需的。

注意

如果流已损坏，则计算出的大小将无效。

违反下面参数描述中列出的任何条件都可能导致未定义的行为。

参数:

  • device_compressed_chunk_ptrs – [in] 大小为 num_chunks 的指针数组，指向设备可访问内存中的压缩缓冲区。每个缓冲区都必须与 `nvcompBatchedLZ4DecompressRequiredAlignments.input` 中的值对齐。

  • device_compressed_chunk_bytes – [in] 大小为 num_chunks 的大小数组，表示压缩缓冲区的大小（以字节为单位）。大小应驻留在设备可访问的内存中。

  • device_uncompressed_chunk_bytes – [out] 大小为 num_chunks 的数组，用于填充每个未压缩数据块的大小（以字节为单位）。此参数需要在设备可访问的内存中预先分配。

  • num_chunks – [in] 要计算大小的数据块的数量。

  • stream – [in] 要操作的 CUDA 流。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedLZ4DecompressAsync(
const void *const *device_compressed_chunk_ptrs,
const size_t *device_compressed_chunk_bytes,
const size_t *device_uncompressed_buffer_bytes,
size_t *device_uncompressed_chunk_bytes,
size_t num_chunks,
void *const device_temp_ptr,
size_t temp_bytes,
void *const *device_uncompressed_chunk_ptrs,
nvcompStatus_t *device_statuses,
cudaStream_t stream,
)#

执行批量异步解压缩。

注意

违反下面参数描述中列出的任何条件都可能导致未定义的行为。

如果压缩数据块不是有效的 LZ4 块，则无效块的大小将写入 0，并且该块将标记 nvcompStatusCannotDecompress。

参数:

  • device_compressed_chunk_ptrs – [输入] 大小为 num_chunks 的指针数组，指向设备可访问内存中设备可访问的压缩缓冲区。每个缓冲区必须与 nvcompBatchedLZ4DecompressRequiredAlignments.input 中的值对齐。

  • device_compressed_chunk_bytes – [in] 大小为 num_chunks 的大小数组，表示压缩缓冲区的大小（以字节为单位）。大小应驻留在设备可访问的内存中。

  • device_uncompressed_buffer_bytes – [输入] 大小为 num_chunks 的大小数组，以字节为单位，表示要填充每个块的解压缩数据的输出缓冲区的大小。这些大小应驻留在设备可访问的内存中。如果某个大小不足以容纳所有解压缩数据，则解压缩器会将 device_statuses 中与溢出块对应的状态设置为 nvcompErrorCannotDecompress。

  • device_uncompressed_chunk_bytes – [输出] 大小为 num_chunks 的数组，用于填充每个块的实际解压缩字节数。此参数需要预先分配，但如果需要，可以为 nullptr，在这种情况下，将不报告实际大小。

  • num_chunks – [输入] 要解压缩的数据块的数量。

  • device_temp_ptr – [输入] 临时 GPU 空间。必须与 nvcompBatchedLZ4DecompressRequiredAlignments.temp 中的值对齐。

  • temp_bytes – [输入] 临时 GPU 空间的大小。

  • device_uncompressed_chunk_ptrs – [输出] 大小为 num_chunks 的指针数组，指向设备可访问内存中的解压缩数据。每个解压缩缓冲区都需要在设备可访问内存中预先分配，其大小由 device_uncompressed_buffer_bytes 中的相应条目指定，并且必须与 nvcompBatchedLZ4DecompressRequiredAlignments.output 中的值对齐。

  • device_statuses – [输出] 大小为 num_chunks 的状态数组，位于设备可访问内存中。此参数需要预先分配。对于每个块，如果解压缩成功，则状态将设置为 nvcompSuccess。如果解压缩不成功，例如由于输入损坏或越界错误，则状态将设置为 nvcompErrorCannotDecompress。如果需要，可以为 nullptr，在这种情况下，将不报告错误状态。

  • stream – [in] 要操作的 CUDA 流。

返回值:

如果成功启动，则返回 nvcompSuccess，否则返回错误代码。

变量

static const nvcompBatchedLZ4Opts_t nvcompBatchedLZ4DefaultOpts = {NVCOMP_TYPE_CHAR}#
const size_t nvcompLZ4CompressionMaxAllowedChunkSize = 1 << 24#
const size_t nvcompLZ4RequiredAlignment = 4#

用于输入、输出或临时内存的 void 类型 CUDA 内存缓冲区的最严格的最小对齐要求，传递给压缩或解压缩函数。在所有情况下，类型化内存缓冲区仍必须与其类型的大小对齐，例如，int 为 4 字节。

const nvcompAlignmentRequirements_t nvcompBatchedLZ4DecompressRequiredAlignments{1, 1, 1}#

解压缩的最小缓冲区对齐要求。

struct nvcompBatchedLZ4Opts_t#
#include <lz4.h>

用于底层 API 的 LZ4 压缩选项

公共成员

nvcompType_t data_type#

Snappy#

函数

nvcompStatus_t nvcompBatchedSnappyCompressGetRequiredAlignments(
nvcompBatchedSnappyOpts_t format_opts,
nvcompAlignmentRequirements_t *alignment_requirements,
)#

获取压缩的最小缓冲区对齐要求。

参数:

  • format_opts – [in] 压缩选项。

  • alignment_requirements – [out] 压缩的最小缓冲区对齐要求。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedSnappyCompressGetTempSize(
size_t num_chunks,
size_t max_uncompressed_chunk_bytes,
nvcompBatchedSnappyOpts_t format_opts,
size_t *temp_bytes,
)#

获取 GPU 上压缩所需的临时内存量。

参数:

  • num_chunks – [in] 批处理中内存块的数量。

  • max_uncompressed_chunk_bytes – [输入] 批处理中块的最大大小。此参数当前未使用。将其设置为实际值或零。

  • format_opts – [输入] Snappy 压缩选项。

  • temp_bytes – [out] 压缩期间临时需要的 GPU 内存量。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedSnappyCompressGetTempSizeEx(
size_t num_chunks,
size_t max_uncompressed_chunk_bytes,
nvcompBatchedSnappyOpts_t format_opts,
size_t *temp_bytes,
const size_t max_total_uncompressed_bytes,
)#

获取 GPU 上压缩所需的临时内存量，并带有额外的总字节参数。

参数:

  • num_chunks – [in] 批处理中内存块的数量。

  • max_uncompressed_chunk_bytes – [输入] 批处理中块的最大大小。此参数当前未使用。将其设置为实际值或零。

  • format_opts – [输入] Snappy 压缩选项。

  • temp_bytes – [out] 压缩期间临时需要的 GPU 内存量。

  • max_total_uncompressed_bytes – [in] 所有块的总未压缩大小的上限

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedSnappyCompressGetMaxOutputChunkSize(
size_t max_uncompressed_chunk_bytes,
nvcompBatchedSnappyOpts_t format_opts,
size_t *max_compressed_chunk_bytes,
)#

获取大小至多为 max_uncompressed_chunk_bytes 的块可以压缩到的最大大小。也就是说，为每个块提供 nvcompBatchedSnappyCompressAsync() 所需的最小输出内存量。

参数:

  • max_uncompressed_chunk_bytes – [in] 压缩前块的最大大小。

  • format_opts – [输入] Snappy 压缩选项。

  • max_compressed_chunk_bytes – [out] 块的最大可能压缩大小。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedSnappyCompressAsync(
const void *const *device_uncompressed_chunk_ptrs,
const size_t *device_uncompressed_chunk_bytes,
size_t max_uncompressed_chunk_bytes,
size_t num_chunks,
void *device_temp_ptr,
size_t temp_bytes,
void *const *device_compressed_chunk_ptrs,
size_t *device_compressed_chunk_bytes,
nvcompBatchedSnappyOpts_t format_opts,
cudaStream_t stream,
)#

执行批量异步压缩。

注意

违反下面参数描述中列出的任何条件都可能导致未定义的行为。

参数:

  • device_uncompressed_chunk_ptrs – [输入] 大小为 num_chunks 的指针数组，指向解压缩数据块。指针和解压缩数据都应驻留在设备可访问的内存中。每个块都必须与 nvcompBatchedSnappyCompressGetRequiredAlignments 在使用相同的 format_opts 调用时输出的 nvcompAlignmentRequirements_t 对象的 input 成员中的值对齐。

  • device_uncompressed_chunk_bytes – [in] 大小为 num_chunks 的大小数组，表示未压缩块的大小（以字节为单位）。大小应驻留在设备可访问的内存中。

  • max_uncompressed_chunk_bytes – [输入] 最大解压缩块的大小。此参数当前未使用。将其设置为实际值或零。

  • num_chunks – [in] 要压缩的数据块的数量。

  • device_temp_ptr – [输入] 临时 GPU 工作区，如果不需要临时内存，则可以为 NULL。必须与 nvcompBatchedSnappyCompressGetRequiredAlignments 在使用相同的 format_opts 调用时输出的 nvcompAlignmentRequirements_t 对象的 temp 成员中的值对齐。

  • temp_bytes – [in] 由 `device_temp_ptr` 指向的临时 GPU 内存的大小。

  • device_compressed_chunk_ptrs – [输出] 大小为 num_chunks 的指针数组，指向输出压缩缓冲区。指针和压缩缓冲区都应驻留在设备可访问的内存中。每个压缩缓冲区都应使用 nvcompBatchedSnappyCompressGetMaxOutputChunkSize 给定的大小预先分配。每个压缩缓冲区都必须与 nvcompBatchedSnappyCompressGetRequiredAlignments 在使用相同的 format_opts 调用时输出的 nvcompAlignmentRequirements_t 对象的 output 成员中的值对齐。

  • device_compressed_chunk_bytes – [out] 大小为 num_chunks 的数组，用于填充每个块的压缩大小。缓冲区应在设备可访问的内存中预先分配。

  • format_opts – [输入] Snappy 压缩选项。

  • stream – [in] 要操作的 CUDA 流。

返回值:

如果成功启动，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedSnappyDecompressGetTempSize(
size_t num_chunks,
size_t max_uncompressed_chunk_bytes,
size_t *temp_bytes,
)#

获取 GPU 上解压缩所需的临时内存量。

参数:

  • num_chunks – [in] 要解压缩的数据块的数量。

  • max_uncompressed_chunk_bytes – [in] 解压缩时最大块的大小（以字节为单位）。

  • temp_bytes – [out] 解压缩期间临时需要的 GPU 内存量。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedSnappyDecompressGetTempSizeEx(
size_t num_chunks,
size_t max_uncompressed_chunk_bytes,
size_t *temp_bytes,
size_t max_total_uncompressed_bytes,
)#

获取 GPU 上解压缩所需的临时内存量，并带有额外的总字节参数。

参数:

  • num_chunks – [in] 要解压缩的数据块的数量。

  • max_uncompressed_chunk_bytes – [in] 解压缩时最大块的大小（以字节为单位）。

  • temp_bytes – [out] 解压缩期间临时需要的 GPU 内存量。

  • max_total_uncompressed_bytes – [输入] 所有块的总解压缩大小。在 Snappy 中未使用。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedSnappyGetDecompressSizeAsync(
const void *const *device_compressed_chunk_ptrs,
const size_t *device_compressed_chunk_bytes,
size_t *device_uncompressed_chunk_bytes,
size_t num_chunks,
cudaStream_t stream,
)#

异步计算每个压缩块的未压缩数据字节数。

注意

违反下面参数描述中列出的任何条件都可能导致未定义的行为。

参数:

  • device_compressed_chunk_ptrs – [输入] 大小为 num_chunks 的指针数组，指向设备可访问内存中的压缩缓冲区。每个缓冲区必须与 nvcompBatchedSnappyDecompressRequiredAlignments.input 中的值对齐。

  • device_compressed_chunk_bytes – [in] 大小为 num_chunks 的大小数组，表示压缩缓冲区的大小（以字节为单位）。大小应驻留在设备可访问的内存中。

  • device_uncompressed_chunk_bytes – [输出] 大小为 num_chunks 的数组，用于填充每个解压缩数据块的大小（以字节为单位）。如果在检索块大小的过程中出现错误，则该块的解压缩大小将设置为 0。此参数需要在设备可访问的内存中预先分配。

  • num_chunks – [in] 要计算大小的数据块的数量。

  • stream – [in] 要操作的 CUDA 流。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedSnappyDecompressAsync(
const void *const *device_compressed_chunk_ptrs,
const size_t *device_compressed_chunk_bytes,
const size_t *device_uncompressed_buffer_bytes,
size_t *device_uncompressed_chunk_bytes,
size_t num_chunks,
void *const device_temp_ptr,
size_t temp_bytes,
void *const *device_uncompressed_chunk_ptrs,
nvcompStatus_t *device_statuses,
cudaStream_t stream,
)#

执行批量异步解压缩。

注意

违反下面参数描述中列出的任何条件都可能导致未定义的行为。

参数:

  • device_compressed_chunk_ptrs – [输入] 大小为 num_chunks 的指针数组，指向设备可访问内存中设备可访问的压缩缓冲区。每个缓冲区必须与 nvcompBatchedSnappyDecompressRequiredAlignments.input 中的值对齐。

  • device_compressed_chunk_bytes – [in] 大小为 num_chunks 的大小数组，表示压缩缓冲区的大小（以字节为单位）。大小应驻留在设备可访问的内存中。

  • device_uncompressed_buffer_bytes – [输入] 大小为 num_chunks 的大小数组，以字节为单位，表示要填充每个块的解压缩数据的输出缓冲区的大小。这些大小应驻留在设备可访问的内存中。如果某个大小不足以容纳所有解压缩数据，则解压缩器会将 device_statuses 中与溢出块对应的状态设置为 nvcompErrorCannotDecompress。

  • device_uncompressed_chunk_bytes – [输出] 大小为 num_chunks 的数组，用于填充每个块的实际解压缩字节数。此参数需要预先分配，但如果需要，可以为 nullptr，在这种情况下，将不报告实际大小。

  • num_chunks – [输入] 要解压缩的数据块的数量。

  • device_temp_ptr – [输入] 临时 GPU 空间，如果不需要临时空间，则可以为 NULL。必须与 nvcompBatchedSnappyDecompressRequiredAlignments.temp 中的值对齐。

  • temp_bytes – [输入] 临时 GPU 空间的大小。

  • device_uncompressed_chunk_ptrs – [输出] 大小为 num_chunks 的指针数组，指向设备可访问内存中的解压缩数据。每个解压缩缓冲区都需要在设备可访问内存中预先分配，其大小由 device_uncompressed_buffer_bytes 中的相应条目指定，并且必须与 nvcompBatchedSnappyDecompressRequiredAlignments.output 中的值对齐。

  • device_statuses – [输出] 大小为 num_chunks 的状态数组，位于设备可访问内存中。此参数需要预先分配。对于每个块，如果解压缩成功，则状态将设置为 nvcompSuccess。如果解压缩不成功，例如由于输入损坏或越界错误，则状态将设置为 nvcompErrorCannotDecompress。如果需要，可以为 nullptr，在这种情况下，将不报告错误状态。

  • stream – [in] 要操作的 CUDA 流。

返回值:

如果成功启动，则返回 nvcompSuccess，否则返回错误代码。

变量

static const nvcompBatchedSnappyOpts_t nvcompBatchedSnappyDefaultOpts = {0}#
const size_t nvcompSnappyCompressionMaxAllowedChunkSize = 1 << 24#
const size_t nvcompSnappyRequiredAlignment = 1#

用于输入、输出或临时内存的 void 类型 CUDA 内存缓冲区的最严格的最小对齐要求，传递给压缩或解压缩函数。在所有情况下，类型化内存缓冲区仍必须与其类型的大小对齐，例如，int 为 4 字节。

const nvcompAlignmentRequirements_t nvcompBatchedSnappyDecompressRequiredAlignments{1, 1, 1}#

解压缩的最小缓冲区对齐要求。

struct nvcompBatchedSnappyOpts_t#
#include <snappy.h>

用于底层 API 的 Snappy 压缩选项。

公共成员

int reserved#

Deflate#

函数

nvcompStatus_t nvcompBatchedDeflateCompressGetRequiredAlignments(
nvcompBatchedDeflateOpts_t format_opts,
nvcompAlignmentRequirements_t *alignment_requirements,
)#

获取压缩的最小缓冲区对齐要求。

参数:

  • format_opts – [in] 压缩选项。

  • alignment_requirements – [out] 压缩的最小缓冲区对齐要求。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedDeflateCompressGetTempSize(
size_t num_chunks,
size_t max_uncompressed_chunk_bytes,
nvcompBatchedDeflateOpts_t format_opts,
size_t *temp_bytes,
)#

获取 GPU 上压缩所需的临时内存量。

块大小不得超过 65536 字节。为了获得最佳性能，建议使用 65536 字节的块大小。

参数:

  • num_chunks – [in] 批处理中内存块的数量。

  • max_uncompressed_chunk_bytes – [in] 批处理中块的最大大小。

  • format_opts – [输入] 要使用的 Deflate 压缩选项。

  • temp_bytes – [out] 压缩期间临时需要的 GPU 内存量。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedDeflateCompressGetTempSizeEx(
size_t num_chunks,
size_t max_uncompressed_chunk_bytes,
nvcompBatchedDeflateOpts_t format_opts,
size_t *temp_bytes,
const size_t max_total_uncompressed_bytes,
)#

获取 GPU 上压缩所需的临时内存量，并带有额外的总字节参数。

块大小不得超过 65536 字节。为了获得最佳性能，建议使用 65536 字节的块大小。

参数:

  • num_chunks – [in] 批处理中内存块的数量。

  • max_uncompressed_chunk_bytes – [in] 批处理中块的最大大小。

  • format_opts – [输入] 要使用的 Deflate 压缩选项。

  • temp_bytes – [out] 压缩期间临时需要的 GPU 内存量。

  • max_total_uncompressed_bytes – [in] 所有块的总未压缩大小的上限

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedDeflateCompressGetMaxOutputChunkSize(
size_t max_uncompressed_chunk_bytes,
nvcompBatchedDeflateOpts_t format_opts,
size_t *max_compressed_chunk_bytes,
)#

获取大小至多为 max_uncompressed_chunk_bytes 的块可以压缩到的最大大小。也就是说，为每个块提供 nvcompBatchedDeflateCompressAsync() 所需的最小输出内存量。

块大小不得超过 65536 字节。为了获得最佳性能，建议使用 65536 字节的块大小。

参数:

  • max_uncompressed_chunk_bytes – [in] 压缩前块的最大大小。

  • format_opts – [输入] 要使用的 Deflate 压缩选项。

  • max_compressed_chunk_bytes – [out] 块的最大可能压缩大小。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedDeflateCompressAsync(
const void *const *device_uncompressed_chunk_ptrs,
const size_t *device_uncompressed_chunk_bytes,
size_t max_uncompressed_chunk_bytes,
size_t num_chunks,
void *device_temp_ptr,
size_t temp_bytes,
void *const *device_compressed_chunk_ptrs,
size_t *device_compressed_chunk_bytes,
nvcompBatchedDeflateOpts_t format_opts,
cudaStream_t stream,
)#

执行批量异步压缩。

注意

违反下面参数描述中列出的任何条件都可能导致未定义的行为。

参数:

  • device_uncompressed_chunk_ptrs – [输入] 大小为 num_chunks 的指针数组，指向解压缩数据块。指针和解压缩数据都应驻留在设备可访问的内存中。每个块都必须与 nvcompBatchedDeflateCompressGetRequiredAlignments 在使用相同的 format_opts 调用时输出的 nvcompAlignmentRequirements_t 对象的 input 成员中的值对齐。

  • device_uncompressed_chunk_bytes – [输入] 大小为 num_chunks 的数组，表示解压缩块的大小（以字节为单位）。这些大小应驻留在设备可访问的内存中。块大小不得超过 65536 字节。为了获得最佳性能，建议使用 65536 字节的块大小。

  • max_uncompressed_chunk_bytes – [in] 最大未压缩块的大小。

  • num_chunks – [in] 要压缩的数据块的数量。

  • device_temp_ptr – [输入] 临时 GPU 工作区。必须与 nvcompBatchedDeflateCompressGetRequiredAlignments 在使用相同的 format_opts 调用时输出的 nvcompAlignmentRequirements_t 对象的 temp 成员中的值对齐。

  • temp_bytes – [in] 由 `device_temp_ptr` 指向的临时 GPU 内存的大小。

  • device_compressed_chunk_ptrs – [输出] 大小为 num_chunks 的指针数组，指向输出压缩缓冲区。指针和压缩缓冲区都应驻留在设备可访问的内存中。每个压缩缓冲区都应使用 nvcompBatchedDeflateCompressGetMaxOutputChunkSize 给定的大小预先分配。每个压缩缓冲区都必须与 nvcompBatchedDeflateCompressGetRequiredAlignments 在使用相同的 format_opts 调用时输出的 nvcompAlignmentRequirements_t 对象的 output 成员中的值对齐。

  • device_compressed_chunk_bytes – [out] 大小为 num_chunks 的数组，用于填充每个块的压缩大小。缓冲区应在设备可访问的内存中预先分配。

  • format_opts – [输入] 要使用的 Deflate 压缩选项。

  • stream – [in] 要操作的 CUDA 流。

返回值:

如果成功启动，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedDeflateDecompressGetTempSize(
size_t num_chunks,
size_t max_uncompressed_chunk_bytes,
size_t *temp_bytes,
)#

获取 GPU 上解压缩所需的临时内存量。

参数:

  • num_chunks – [in] 要解压缩的数据块的数量。

  • max_uncompressed_chunk_bytes – [in] 解压缩时最大块的大小（以字节为单位）。

  • temp_bytes – [out] 解压缩期间临时需要的 GPU 内存量。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedDeflateDecompressGetTempSizeEx(
size_t num_chunks,
size_t max_uncompressed_chunk_bytes,
size_t *temp_bytes,
size_t max_total_uncompressed_bytes,
)#

获取 GPU 上解压缩所需的临时内存量，并带有额外的总字节参数。

参数:

  • num_chunks – [in] 要解压缩的数据块的数量。

  • max_uncompressed_chunk_bytes – [in] 解压缩时最大块的大小（以字节为单位）。

  • temp_bytes – [out] 解压缩期间临时需要的 GPU 内存量。

  • max_total_uncompressed_bytes – [输入] 所有块的总解压缩大小。在 Deflate 中未使用。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedDeflateGetDecompressSizeAsync(
const void *const *device_compressed_chunk_ptrs,
const size_t *device_compressed_chunk_bytes,
size_t *device_uncompressed_chunk_bytes,
size_t num_chunks,
cudaStream_t stream,
)#

异步计算每个压缩块的未压缩数据字节数。

当我们不知道预期的输出大小时，这是必需的。

注意

如果流已损坏，则计算出的大小将无效。

违反下面参数描述中列出的任何条件都可能导致未定义的行为。

参数:

  • device_compressed_chunk_ptrs – [输入] 大小为 num_chunks 的指针数组，指向设备可访问内存中的压缩缓冲区。每个缓冲区必须与 nvcompBatchedDeflateDecompressRequiredAlignments.input 中的值对齐。

  • device_compressed_chunk_bytes – [in] 大小为 num_chunks 的大小数组，表示压缩缓冲区的大小（以字节为单位）。大小应驻留在设备可访问的内存中。

  • device_uncompressed_chunk_bytes – [输出] 大小为 num_chunks 的数组，用于填充每个解压缩数据块的大小（以字节为单位）。

  • num_chunks – [in] 要计算大小的数据块的数量。

  • stream – [in] 要操作的 CUDA 流。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedDeflateDecompressAsync(
const void *const *device_compressed_chunk_ptrs,
const size_t *device_compressed_chunk_bytes,
const size_t *device_uncompressed_buffer_bytes,
size_t *device_uncompressed_chunk_bytes,
size_t num_chunks,
void *const device_temp_ptr,
size_t temp_bytes,
void *const *device_uncompressed_chunk_ptrs,
nvcompStatus_t *device_statuses,
cudaStream_t stream,
)#

执行批量异步解压缩。

注意

违反下面参数描述中列出的任何条件都可能导致未定义的行为。

如果压缩数据块不是有效的 Deflate 流，则无效块的大小将写入 0，并且该块将标记 nvcompStatusCannotDecompress。

参数:

  • device_compressed_chunk_ptrs – [输入] 大小为 num_chunks 的指针数组，指向设备可访问内存中设备可访问的压缩缓冲区。每个缓冲区必须与 nvcompBatchedDeflateDecompressRequiredAlignments.input 中的值对齐。

  • device_compressed_chunk_bytes – [in] 大小为 num_chunks 的大小数组，表示压缩缓冲区的大小（以字节为单位）。大小应驻留在设备可访问的内存中。

  • device_uncompressed_buffer_bytes – [输入] 大小为 num_chunks 的大小数组，以字节为单位，表示要填充每个块的解压缩数据的输出缓冲区的大小。这些大小应驻留在设备可访问的内存中。如果某个大小不足以容纳所有解压缩数据，则解压缩器会将 device_statuses 中与溢出块对应的状态设置为 nvcompErrorCannotDecompress。

  • device_uncompressed_chunk_bytes – [输出] 大小为 num_chunks 的数组，用于填充每个块的实际解压缩字节数。此参数需要预先分配，但如果需要，可以为 nullptr，在这种情况下，将不报告实际大小。

  • num_chunks – [输入] 要解压缩的数据块的数量。

  • device_temp_ptr – [输入] 临时 GPU 空间。必须与 nvcompBatchedDeflateDecompressRequiredAlignments.temp 中的值对齐。

  • temp_bytes – [输入] 临时 GPU 空间的大小。

  • device_uncompressed_chunk_ptrs – [输出] 大小为 num_chunks 的指针数组，指向设备可访问内存中的解压缩数据。每个解压缩缓冲区都需要在设备可访问内存中预先分配，其大小由 device_uncompressed_buffer_bytes 中的相应条目指定，并且必须与 nvcompBatchedDeflateDecompressRequiredAlignments.output 中的值对齐。

  • device_statuses – [输出] 大小为 num_chunks 的状态数组，位于设备可访问内存中。此参数需要预先分配。对于每个块，如果解压缩成功，则状态将设置为 nvcompSuccess。如果解压缩不成功，例如由于输入损坏或越界错误，则状态将设置为 nvcompErrorCannotDecompress。如果需要，可以为 nullptr，在这种情况下，将不报告错误状态。

  • stream – [in] 要操作的 CUDA 流。

返回值:

如果成功启动，则返回 nvcompSuccess，否则返回错误代码。

变量

static const nvcompBatchedDeflateOpts_t nvcompBatchedDeflateDefaultOpts = {1}#
const size_t nvcompDeflateCompressionMaxAllowedChunkSize = 1 << 16#
const size_t nvcompDeflateRequiredAlignment = 8#

用于输入、输出或临时内存的 void 类型 CUDA 内存缓冲区的最严格的最小对齐要求，传递给压缩或解压缩函数。在所有情况下，类型化内存缓冲区仍必须与其类型的大小对齐，例如，int 为 4 字节。

const nvcompAlignmentRequirements_t nvcompBatchedDeflateDecompressRequiredAlignments{4, 1, 1}#

解压缩的最小缓冲区对齐要求。

struct nvcompBatchedDeflateOpts_t#
#include <deflate.h>

用于底层 API 的 Deflate 压缩选项

公共成员

int algo#

要使用的压缩算法。允许的值为

  • 0：最高吞吐量、仅熵压缩（用于对称压缩/解压缩性能）

  • 1：高吞吐量、低压缩比（默认）

  • 2：中等吞吐量、中等压缩比，在压缩比上优于 Zlib 级别 1

  • 3：进一步压缩级别支持的占位符，此时将归入 MEDIUM_COMPRESSION

  • 4：较低吞吐量、较高压缩比，在压缩比上优于 Zlib 级别 6

  • 5：最低吞吐量、最高压缩比

GDeflate#

函数

nvcompStatus_t nvcompBatchedGdeflateCompressGetRequiredAlignments(
nvcompBatchedGdeflateOpts_t format_opts,
nvcompAlignmentRequirements_t *alignment_requirements,
)#

获取压缩的最小缓冲区对齐要求。

参数:

  • format_opts – [in] 压缩选项。

  • alignment_requirements – [out] 压缩的最小缓冲区对齐要求。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedGdeflateCompressGetTempSize(
size_t num_chunks,
size_t max_uncompressed_chunk_bytes,
nvcompBatchedGdeflateOpts_t format_opts,
size_t *temp_bytes,
)#

获取 GPU 上压缩所需的临时内存量。

块大小不得超过 65536 字节。为了获得最佳性能，建议使用 65536 字节的块大小。

参数:

  • num_chunks – [in] 批处理中内存块的数量。

  • max_uncompressed_chunk_bytes – [in] 批处理中块的最大大小。

  • format_opts – [输入] 要使用的 GDeflate 压缩选项。

  • temp_bytes – [out] 压缩期间临时需要的 GPU 内存量。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedGdeflateCompressGetTempSizeEx(
size_t num_chunks,
size_t max_uncompressed_chunk_bytes,
nvcompBatchedGdeflateOpts_t format_opts,
size_t *temp_bytes,
const size_t max_total_uncompressed_bytes,
)#

获取 GPU 上压缩所需的临时内存量，并带有额外的总字节参数。

块大小不得超过 65536 字节。为了获得最佳性能，建议使用 65536 字节的块大小。

参数:

  • num_chunks – [in] 批处理中内存块的数量。

  • max_uncompressed_chunk_bytes – [in] 批处理中块的最大大小。

  • format_opts – [输入] 要使用的 GDeflate 压缩选项。

  • temp_bytes – [out] 压缩期间临时需要的 GPU 内存量。

  • max_total_uncompressed_bytes – [in] 所有块的总未压缩大小的上限

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedGdeflateCompressGetMaxOutputChunkSize(
size_t max_uncompressed_chunk_bytes,
nvcompBatchedGdeflateOpts_t format_opts,
size_t *max_compressed_chunk_bytes,
)#

获取大小至多为 max_uncompressed_chunk_bytes 的块可以压缩到的最大大小。也就是说，为每个块提供 nvcompBatchedGdeflateCompressAsync() 所需的最小输出内存量。

块大小不得超过 65536 字节。为了获得最佳性能，建议使用 65536 字节的块大小。

参数:

  • max_uncompressed_chunk_bytes – [in] 压缩前块的最大大小。

  • format_opts – [输入] 要使用的 GDeflate 压缩选项。

  • max_compressed_chunk_bytes – [out] 块的最大可能压缩大小。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedGdeflateCompressAsync(
const void *const *device_uncompressed_chunk_ptrs,
const size_t *device_uncompressed_chunk_bytes,
size_t max_uncompressed_chunk_bytes,
size_t num_chunks,
void *device_temp_ptr,
size_t temp_bytes,
void *const *device_compressed_chunk_ptrs,
size_t *device_compressed_chunk_bytes,
nvcompBatchedGdeflateOpts_t format_opts,
cudaStream_t stream,
)#

执行批量异步压缩。

注意

违反下面参数描述中列出的任何条件都可能导致未定义的行为。

参数:

  • device_uncompressed_chunk_ptrs – [输入] 大小为 num_chunks 的指针数组，指向解压缩数据块。指针和解压缩数据都应驻留在设备可访问的内存中。每个块都必须与 nvcompBatchedGdeflateCompressGetRequiredAlignments 在使用相同的 format_opts 调用时输出的 nvcompAlignmentRequirements_t 对象的 input 成员中的值对齐。

  • device_uncompressed_chunk_bytes – [输入] 大小为 num_chunks 的数组，表示解压缩块的大小（以字节为单位）。这些大小应驻留在设备可访问的内存中。块大小不得超过 65536 字节。为了获得最佳性能，建议使用 65536 字节的块大小。

  • max_uncompressed_chunk_bytes – [in] 最大未压缩块的大小。

  • num_chunks – [in] 要压缩的数据块的数量。

  • device_temp_ptr – [in] 临时 GPU 工作区。必须根据 nvcompAlignmentRequirements_t 对象的 `temp` 成员中的值对齐，该对象由 `nvcompBatchedGdeflateCompressGetRequiredAlignments` 在使用相同的 format_opts 调用时输出。

  • temp_bytes – [in] 由 `device_temp_ptr` 指向的临时 GPU 内存的大小。

  • device_compressed_chunk_ptrs – [out] 大小为 num_chunks 的指针数组，指向输出压缩缓冲区。指针和压缩缓冲区都应驻留在设备可访问的内存中。每个压缩缓冲区都应预先分配大小，该大小由 `nvcompBatchedGdeflateCompressGetMaxOutputChunkSize` 给出。每个压缩缓冲区都必须根据 nvcompAlignmentRequirements_t 对象的 `output` 成员中的值对齐，该对象由 `nvcompBatchedGdeflateCompressGetRequiredAlignments` 在使用相同的 format_opts 调用时输出。

  • device_compressed_chunk_bytes – [out] 大小为 num_chunks 的数组，用于填充每个块的压缩大小。缓冲区应在设备可访问的内存中预先分配。

  • format_opts – [输入] 要使用的 GDeflate 压缩选项。

  • stream – [in] 要操作的 CUDA 流。

返回值:

如果成功启动，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedGdeflateDecompressGetTempSize(
size_t num_chunks,
size_t max_uncompressed_chunk_bytes,
size_t *temp_bytes,
)#

获取 GPU 上解压缩所需的临时内存量。

参数:

  • num_chunks – [in] 要解压缩的数据块的数量。

  • max_uncompressed_chunk_bytes – [in] 解压缩时最大块的大小（以字节为单位）。

  • temp_bytes – [out] 解压缩期间临时需要的 GPU 内存量。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedGdeflateDecompressGetTempSizeEx(
size_t num_chunks,
size_t max_uncompressed_chunk_bytes,
size_t *temp_bytes,
size_t max_total_uncompressed_bytes,
)#

获取 GPU 上解压缩所需的临时内存量，并带有额外的总字节参数。

参数:

  • num_chunks – [in] 要解压缩的数据块的数量。

  • max_uncompressed_chunk_bytes – [in] 解压缩时最大块的大小（以字节为单位）。

  • temp_bytes – [out] 解压缩期间临时需要的 GPU 内存量。

  • max_total_uncompressed_bytes – [in] 所有块的总解压缩大小。在 GDeflate 中未使用。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedGdeflateGetDecompressSizeAsync(
const void *const *device_compressed_chunk_ptrs,
const size_t *device_compressed_chunk_bytes,
size_t *device_uncompressed_chunk_bytes,
size_t num_chunks,
cudaStream_t stream,
)#

异步计算每个压缩块的未压缩数据字节数。

当我们不知道预期的输出大小时，这是必需的。

注意

如果流已损坏，则计算出的大小将无效。

违反下面参数描述中列出的任何条件都可能导致未定义的行为。

参数:

  • device_compressed_chunk_ptrs – [in] 大小为 num_chunks 的指针数组，指向设备可访问内存中的压缩缓冲区。每个缓冲区都必须根据 `nvcompBatchedGdeflateDecompressRequiredAlignments.input` 中的值对齐。

  • device_compressed_chunk_bytes – [in] 大小为 num_chunks 的大小数组，表示压缩缓冲区的大小（以字节为单位）。大小应驻留在设备可访问的内存中。

  • device_uncompressed_chunk_bytes – [输出] 大小为 num_chunks 的数组，用于填充每个解压缩数据块的大小（以字节为单位）。

  • num_chunks – [in] 要计算大小的数据块的数量。

  • stream – [in] 要操作的 CUDA 流。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedGdeflateDecompressAsync(
const void *const *device_compressed_chunk_ptrs,
const size_t *device_compressed_chunk_bytes,
const size_t *device_uncompressed_buffer_bytes,
size_t *device_uncompressed_chunk_bytes,
size_t num_chunks,
void *const device_temp_ptr,
size_t temp_bytes,
void *const *device_uncompressed_chunk_ptrs,
nvcompStatus_t *device_statuses,
cudaStream_t stream,
)#

执行批量异步解压缩。

注意

违反下面参数描述中列出的任何条件都可能导致未定义的行为。

如果压缩数据块不是有效的 GDeflate 流，则无效块的大小将写入 0，并且该块将标记为 nvcompStatusCannotDecompress。

参数:

  • device_compressed_chunk_ptrs – [in] 大小为 num_chunks 的指针数组，指向设备可访问内存中的设备可访问压缩缓冲区。每个缓冲区都必须根据 `nvcompBatchedGdeflateDecompressRequiredAlignments.input` 中的值对齐。

  • device_compressed_chunk_bytes – [in] 大小为 num_chunks 的大小数组，表示压缩缓冲区的大小（以字节为单位）。大小应驻留在设备可访问的内存中。

  • device_uncompressed_buffer_bytes – [输入] 大小为 num_chunks 的大小数组，以字节为单位，表示要填充每个块的解压缩数据的输出缓冲区的大小。这些大小应驻留在设备可访问的内存中。如果某个大小不足以容纳所有解压缩数据，则解压缩器会将 device_statuses 中与溢出块对应的状态设置为 nvcompErrorCannotDecompress。

  • device_uncompressed_chunk_bytes – [输出] 大小为 num_chunks 的数组，用于填充每个块的实际解压缩字节数。此参数需要预先分配，但如果需要，可以为 nullptr，在这种情况下，将不报告实际大小。

  • num_chunks – [输入] 要解压缩的数据块的数量。

  • device_temp_ptr – [in] 临时 GPU 空间。必须根据 `nvcompBatchedGdeflateDecompressRequiredAlignments.temp` 中的值对齐。

  • temp_bytes – [输入] 临时 GPU 空间的大小。

  • device_uncompressed_chunk_ptrs – [out] 大小为 num_chunks 的指针数组，指向设备可访问内存中的解压缩数据。每个解压缩缓冲区都需要在设备可访问内存中预先分配，其大小由 device_uncompressed_buffer_bytes 中的相应条目指定，并且必须根据 `nvcompBatchedGdeflateDecompressRequiredAlignments.output` 中的值对齐。

  • device_statuses – [输出] 大小为 num_chunks 的状态数组，位于设备可访问内存中。此参数需要预先分配。对于每个块，如果解压缩成功，则状态将设置为 nvcompSuccess。如果解压缩不成功，例如由于输入损坏或越界错误，则状态将设置为 nvcompErrorCannotDecompress。如果需要，可以为 nullptr，在这种情况下，将不报告错误状态。

  • stream – [in] 要操作的 CUDA 流。

返回值:

如果成功启动，则返回 nvcompSuccess，否则返回错误代码。

变量

static const nvcompBatchedGdeflateOpts_t nvcompBatchedGdeflateDefaultOpts = {1}#
const size_t nvcompGdeflateCompressionMaxAllowedChunkSize = 1 << 16#
const size_t nvcompGdeflateRequiredAlignment = 8#

用于输入、输出或临时内存的 void 类型 CUDA 内存缓冲区的最严格的最小对齐要求，传递给压缩或解压缩函数。在所有情况下，类型化内存缓冲区仍必须与其类型的大小对齐，例如，int 为 4 字节。

const nvcompAlignmentRequirements_t nvcompBatchedGdeflateDecompressRequiredAlignments{4, 1, 1}#

解压缩的最小缓冲区对齐要求。

struct nvcompBatchedGdeflateOpts_t#
#include <gdeflate.h>

用于低级 API 的 GDeflate 压缩选项

公共成员

int algo#

要使用的压缩算法。允许的值为

  • 0：最高吞吐量、仅熵压缩（用于对称压缩/解压缩性能）

  • 1：高吞吐量、低压缩比（默认）

  • 2：中等吞吐量、中等压缩比，在压缩比上优于 Zlib 级别 1

  • 3：进一步压缩级别支持的占位符，此时将归入 MEDIUM_COMPRESSION

  • 4：较低吞吐量、较高压缩比，在压缩比上优于 Zlib 级别 6

  • 5：最低吞吐量、最高压缩比

ZSTD#

函数

nvcompStatus_t nvcompBatchedZstdCompressGetRequiredAlignments(
nvcompBatchedZstdOpts_t format_opts,
nvcompAlignmentRequirements_t *alignment_requirements,
)#

获取压缩的最小缓冲区对齐要求。

参数:

  • format_opts – [in] 压缩选项。

  • alignment_requirements – [out] 压缩的最小缓冲区对齐要求。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedZstdCompressGetTempSize(
size_t num_chunks,
size_t max_uncompressed_chunk_bytes,
nvcompBatchedZstdOpts_t format_opts,
size_t *temp_bytes,
)#

获取 GPU 上压缩所需的临时内存量。

块大小不得超过 16 MB。为了获得最佳性能，建议块大小为 64 KB。

参数:

  • num_chunks – [in] 批处理中内存块的数量。

  • max_uncompressed_chunk_bytes – [in] 批处理中块的最大大小。

  • format_opts – [in] 要使用的 ZSTD 压缩选项 – 当前为空

  • temp_bytes – [out] 压缩期间临时需要的 GPU 内存量。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedZstdCompressGetTempSizeEx(
size_t num_chunks,
size_t max_uncompressed_chunk_bytes,
nvcompBatchedZstdOpts_t format_opts,
size_t *temp_bytes,
const size_t max_total_uncompressed_bytes,
)#

获取 GPU 上压缩所需的临时内存量，并带有额外的总字节参数。

块大小不得超过 16 MB。为了获得最佳性能，建议块大小为 64 KB。

此扩展 API 适用于批处理中块大小不均匀的情况。即，在非扩展 API 中，如果除了 1 个块之外的所有块都是 64 KB，但 1 个块是 16 MB，则计算出的临时空间基于 16 MB * num_chunks。

参数:

  • num_chunks – [in] 批处理中内存块的数量。

  • max_uncompressed_chunk_bytes – [in] 批处理中块的最大大小。

  • format_opts – [in] 要使用的 ZSTD 压缩选项。当前为空。

  • temp_bytes – [out] 压缩期间临时需要的 GPU 内存量。

  • max_total_uncompressed_bytes – [in] 所有块的总未压缩大小的上限

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedZstdCompressGetMaxOutputChunkSize(
size_t max_uncompressed_chunk_bytes,
nvcompBatchedZstdOpts_t format_opts,
size_t *max_compressed_chunk_bytes,
)#

获取大小最大为 max_uncompressed_chunk_bytes 的块可以压缩到的最大大小。也就是说，为每个块提供 nvcompBatchedZstdCompressAsync() 所需的最小输出内存量。

块大小不得超过 16 MB。为了获得最佳性能，建议块大小为 64 KB。

参数:

  • max_uncompressed_chunk_bytes – [in] 压缩前块的最大大小。

  • format_opts – [in] 要使用的 Zstd 压缩选项。当前为空。

  • max_compressed_chunk_bytes – [out] 块的最大可能压缩大小。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedZstdCompressAsync(
const void *const *device_uncompressed_chunk_ptrs,
const size_t *device_uncompressed_chunk_bytes,
size_t max_uncompressed_chunk_bytes,
size_t num_chunks,
void *device_temp_ptr,
size_t temp_bytes,
void *const *device_compressed_chunk_ptrs,
size_t *device_compressed_chunk_bytes,
nvcompBatchedZstdOpts_t format_opts,
cudaStream_t stream,
)#

执行批量异步压缩。

注意

违反下面参数描述中列出的任何条件都可能导致未定义的行为。

参数:

  • device_uncompressed_chunk_ptrs – [in] 大小为 num_chunks 的指针数组，指向未压缩的数据块。指针和未压缩数据都应驻留在设备可访问的内存中。每个块都必须根据 nvcompAlignmentRequirements_t 对象的 `input` 成员中的值对齐，该对象由 `nvcompBatchedZstdCompressGetRequiredAlignments` 在使用相同的 format_opts 调用时输出。

  • device_uncompressed_chunk_bytes – [in] 大小为 num_chunks 的未压缩块大小（以字节为单位）的数组。大小应驻留在设备可访问的内存中。块大小不得超过 16 MB。为了获得最佳性能，建议块大小为 64 KB。

  • max_uncompressed_chunk_bytes – [in] 最大未压缩块的大小。

  • num_chunks – [in] 要压缩的数据块的数量。

  • device_temp_ptr – [in] 临时 GPU 工作区，如果不需要临时内存，则可以为 NULL。必须根据 nvcompAlignmentRequirements_t 对象的 `temp` 成员中的值对齐，该对象由 `nvcompBatchedZstdCompressGetRequiredAlignments` 在使用相同的 format_opts 调用时输出。

  • temp_bytes – [in] 由 `device_temp_ptr` 指向的临时 GPU 内存的大小。

  • device_compressed_chunk_ptrs – [out] 大小为 num_chunks 的指针数组，指向输出压缩缓冲区。指针和压缩缓冲区都应驻留在设备可访问的内存中。每个压缩缓冲区都应预先分配大小，该大小由 `nvcompBatchedZstdCompressGetMaxOutputChunkSize` 给出。每个压缩缓冲区都必须根据 nvcompAlignmentRequirements_t 对象的 `output` 成员中的值对齐，该对象由 `nvcompBatchedZstdCompressGetRequiredAlignments` 在使用相同的 format_opts 调用时输出。

  • device_compressed_chunk_bytes – [out] 大小为 num_chunks 的数组，用于填充每个块的压缩大小。缓冲区应在设备可访问的内存中预先分配。

  • format_opts – [in] 要使用的 Zstd 压缩选项。当前为空。

  • stream – [in] 要操作的 CUDA 流。

返回值:

如果成功启动，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedZstdDecompressGetTempSize(
size_t num_chunks,
size_t max_uncompressed_chunk_bytes,
size_t *temp_bytes,
)#

获取 GPU 上解压缩所需的临时内存量。

参数:

  • num_chunks – [in] 要解压缩的数据块的数量。

  • max_uncompressed_chunk_bytes – [in] 解压缩时最大块的大小（以字节为单位）。

  • temp_bytes – [out] 解压缩期间临时需要的 GPU 内存量。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedZstdDecompressGetTempSizeEx(
size_t num_chunks,
size_t max_uncompressed_chunk_bytes,
size_t *temp_bytes,
size_t max_total_uncompressed_bytes,
)#

获取 GPU 上解压缩所需的临时内存量，并带有额外的总字节参数。

参数:

  • num_chunks – [in] 要解压缩的数据块的数量。

  • max_uncompressed_chunk_bytes – [in] 解压缩时最大块的大小（以字节为单位）。

  • temp_bytes – [out] 解压缩期间临时需要的 GPU 内存量。

  • max_total_uncompressed_bytes – [in] 所有块的总解压缩大小。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedZstdGetDecompressSizeAsync(
const void *const *device_compressed_chunk_ptrs,
const size_t *device_compressed_chunk_bytes,
size_t *device_uncompressed_chunk_bytes,
size_t num_chunks,
cudaStream_t stream,
)#

异步计算每个压缩块的未压缩数据字节数。

注意

违反下面参数描述中列出的任何条件都可能导致未定义的行为。

参数:

  • device_compressed_chunk_ptrs – [in] 大小为 num_chunks 的指针数组，指向设备可访问内存中的压缩缓冲区。每个缓冲区都必须根据 `nvcompBatchedZstdDecompressRequiredAlignments.input` 中的值对齐。

  • device_compressed_chunk_bytes – [in] 大小为 num_chunks 的大小数组，表示压缩缓冲区的大小（以字节为单位）。大小应驻留在设备可访问的内存中。

  • device_uncompressed_chunk_bytes – [输出] 大小为 num_chunks 的数组，用于填充每个解压缩数据块的大小（以字节为单位）。如果在检索块大小的过程中出现错误，则该块的解压缩大小将设置为 0。此参数需要在设备可访问的内存中预先分配。

  • num_chunks – [in] 要计算大小的数据块的数量。

  • stream – [in] 要操作的 CUDA 流。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedZstdDecompressAsync(
const void *const *device_compressed_chunk_ptrs,
const size_t *device_compressed_chunk_bytes,
const size_t *device_uncompressed_buffer_bytes,
size_t *device_uncompressed_chunk_bytes,
size_t num_chunks,
void *const device_temp_ptr,
size_t temp_bytes,
void *const *device_uncompressed_chunk_ptrs,
nvcompStatus_t *device_statuses,
cudaStream_t stream,
)#

执行批量异步解压缩。

注意

违反下面参数描述中列出的任何条件都可能导致未定义的行为。

参数:

  • device_compressed_chunk_ptrs – [in] 大小为 num_chunks 的指针数组，指向设备可访问内存中的设备可访问压缩缓冲区。每个缓冲区都必须根据 `nvcompBatchedZstdDecompressRequiredAlignments.input` 中的值对齐。

  • device_compressed_chunk_bytes – [in] 大小为 num_chunks 的大小数组，表示压缩缓冲区的大小（以字节为单位）。大小应驻留在设备可访问的内存中。

  • device_uncompressed_buffer_bytes – [输入] 大小为 num_chunks 的大小数组，以字节为单位，表示要填充每个块的解压缩数据的输出缓冲区的大小。这些大小应驻留在设备可访问的内存中。如果某个大小不足以容纳所有解压缩数据，则解压缩器会将 device_statuses 中与溢出块对应的状态设置为 nvcompErrorCannotDecompress。

  • device_uncompressed_chunk_bytes – [out] 大小为 num_chunks 的数组，用于填充每个块的实际解压缩字节数。

  • num_chunks – [输入] 要解压缩的数据块的数量。

  • device_temp_ptr – [in] 临时 GPU 空间，如果不需要临时空间，则可以为 NULL。必须根据 `nvcompBatchedZstdDecompressRequiredAlignments.temp` 中的值对齐。

  • temp_bytes – [输入] 临时 GPU 空间的大小。

  • device_uncompressed_chunk_ptrs – [out] 大小为 num_chunks 的指针数组，指向设备可访问内存中的解压缩数据。每个解压缩缓冲区都需要在设备可访问内存中预先分配，其大小由 device_uncompressed_buffer_bytes 中的相应条目指定，并且必须根据 `nvcompBatchedZstdDecompressRequiredAlignments.output` 中的值对齐。

  • device_statuses – [out] 大小为 num_chunks 的状态数组，位于设备可访问内存中。此参数需要预先分配。对于每个块，如果解压缩成功，状态将设置为 `nvcompSuccess`。如果解压缩不成功，例如由于输入损坏或越界错误，状态将设置为 `nvcompErrorCannotDecompress`。

  • stream – [in] 要操作的 CUDA 流。

返回值:

如果成功启动，则返回 nvcompSuccess，否则返回错误代码。

变量

static const nvcompBatchedZstdOpts_t nvcompBatchedZstdDefaultOpts = {0}#
const size_t nvcompZstdCompressionMaxAllowedChunkSize = (1UL << 31) - 1#
const size_t nvcompZstdRequiredAlignment = 8#

用于输入、输出或临时内存的 void 类型 CUDA 内存缓冲区的最严格的最小对齐要求，传递给压缩或解压缩函数。在所有情况下，类型化内存缓冲区仍必须与其类型的大小对齐，例如，int 为 4 字节。

const nvcompAlignmentRequirements_t nvcompBatchedZstdDecompressRequiredAlignments{1, 1, 8}#

解压缩的最小缓冲区对齐要求。

struct nvcompBatchedZstdOpts_t#
#include <zstd.h>

用于低级 API 的 Zstd 压缩选项。

公共成员

int reserved#

GZIP#

函数

nvcompStatus_t nvcompBatchedGzipCompressGetTempSize(
size_t num_chunks,
size_t max_uncompressed_chunk_bytes,
nvcompBatchedGzipOpts_t format_opts,
size_t *temp_bytes,
)#

获取 GPU 上压缩所需的临时内存量。

块大小不得超过 65536 字节。为了获得最佳性能，建议使用 65536 字节的块大小。

参数:

  • num_chunks – [in] 批处理中内存块的数量。

  • max_uncompressed_chunk_bytes – [in] 批处理中块的最大大小。

  • format_opts – [in] 要使用的 Gzip 压缩选项。

  • temp_bytes – [out] 压缩期间临时需要的 GPU 内存量。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedGzipCompressGetTempSizeEx(
size_t num_chunks,
size_t max_uncompressed_chunk_bytes,
nvcompBatchedGzipOpts_t format_opts,
size_t *temp_bytes,
const size_t max_total_uncompressed_bytes,
)#

获取 GPU 上压缩所需的临时内存量，并带有额外的总字节参数。

块大小不得超过 65536 字节。为了获得最佳性能，建议使用 65536 字节的块大小。

参数:

  • num_chunks – [in] 批处理中内存块的数量。

  • max_uncompressed_chunk_bytes – [in] 批处理中块的最大大小。

  • format_opts – [in] 要使用的 Gzip 压缩选项。

  • temp_bytes – [out] 压缩期间临时需要的 GPU 内存量。

  • max_total_uncompressed_bytes – [in] 所有块的总未压缩大小的上限

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedGzipCompressGetMaxOutputChunkSize(
size_t max_uncompressed_chunk_bytes,
nvcompBatchedGzipOpts_t format_opts,
size_t *max_compressed_chunk_bytes,
)#

获取大小最大为 max_uncompressed_chunk_bytes 的块可以压缩到的最大大小。也就是说，为每个块提供 nvcompBatchedGzipCompressAsync() 所需的最小输出内存量。

块大小不得超过 65536 字节。为了获得最佳性能，建议使用 65536 字节的块大小。

参数:

  • max_uncompressed_chunk_bytes – [in] 压缩前块的最大大小。

  • format_opts – [in] 要使用的 Gzip 压缩选项。

  • max_compressed_chunk_bytes – [out] 块的最大可能压缩大小。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedGzipCompressAsync(
const void *const *device_uncompressed_chunk_ptrs,
const size_t *device_uncompressed_chunk_bytes,
size_t max_uncompressed_chunk_bytes,
size_t num_chunks,
void *device_temp_ptr,
size_t temp_bytes,
void *const *device_compressed_chunk_ptrs,
size_t *device_compressed_chunk_bytes,
nvcompBatchedGzipOpts_t format_opts,
cudaStream_t stream,
)#

执行批量异步压缩。

单个块大小不得超过 65536 字节。为了获得最佳性能，建议块大小为 65536 字节。输出缓冲区必须 8 字节对齐。

参数:

  • device_uncompressed_chunk_ptrs – [in] 大小为 num_chunks 的指针数组，指向未压缩数据块。指针和未压缩数据都应驻留在设备可访问的内存中。

  • device_uncompressed_chunk_bytes – [in] 大小为 num_chunks 的大小数组，表示未压缩块的大小（以字节为单位）。大小应驻留在设备可访问的内存中。

  • max_uncompressed_chunk_bytes – [in] 最大未压缩块的大小。

  • num_chunks – [in] 要压缩的数据块的数量。

  • device_temp_ptr – [in] 临时 GPU 工作区。

  • temp_bytes – [in] 由 `device_temp_ptr` 指向的临时 GPU 内存的大小。

  • device_compressed_chunk_ptrs – [out] 大小为 num_chunks 的指针数组，指向输出压缩缓冲区。指针和压缩缓冲区都应驻留在设备可访问的内存中。每个压缩缓冲区都应预先分配大小，该大小由 `nvcompBatchedGzipCompressGetMaxOutputChunkSize` 给出。

  • device_compressed_chunk_bytes – [out] 大小为 num_chunks 的数组，用于填充每个块的压缩大小。缓冲区应在设备可访问的内存中预先分配。

  • format_opts – [in] 要使用的 Gzip 压缩选项。

  • stream – [in] 要操作的 CUDA 流。

返回值:

如果成功启动，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedGzipDecompressGetTempSize(
size_t num_chunks,
size_t max_uncompressed_chunk_bytes,
size_t *temp_bytes,
)#

获取 GPU 上解压缩所需的临时内存量。

参数:

  • num_chunks – [in] 要解压缩的数据块的数量。

  • max_uncompressed_chunk_bytes – [in] 解压缩时最大块的大小（以字节为单位）。

  • temp_bytes – [out] 解压缩期间临时需要的 GPU 内存量。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedGzipDecompressGetTempSizeEx(
size_t num_chunks,
size_t max_uncompressed_chunk_bytes,
size_t *temp_bytes,
size_t max_total_uncompressed_bytes,
)#

获取 GPU 上解压缩所需的临时内存量，并带有额外的总字节参数。

参数:

  • num_chunks – [in] 要解压缩的数据块的数量。

  • max_uncompressed_chunk_bytes – [in] 解压缩时最大块的大小（以字节为单位）。

  • temp_bytes – [out] 解压缩期间临时需要的 GPU 内存量。

  • max_total_uncompressed_bytes – [in] 所有块的总解压缩大小。在 gzip 中未使用。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedGzipGetDecompressSizeAsync(
const void *const *device_compressed_chunk_ptrs,
const size_t *device_compressed_chunk_bytes,
size_t *device_uncompressed_chunk_bytes,
size_t num_chunks,
cudaStream_t stream,
)#

异步计算每个压缩块的未压缩数据字节数。

当我们不知道预期的输出大小时，这是必需的。

注意

如果流已损坏，则计算出的大小将无效。

违反下面参数描述中列出的任何条件都可能导致未定义的行为。

参数:

  • device_compressed_chunk_ptrs – [in] 大小为 num_chunks 的指针数组，指向设备可访问内存中的压缩缓冲区。每个缓冲区都必须根据 `nvcompBatchedGzipDecompressRequiredAlignments.input` 中的值对齐。

  • device_compressed_chunk_bytes – [in] 大小为 num_chunks 的大小数组，表示压缩缓冲区的大小（以字节为单位）。大小应驻留在设备可访问的内存中。

  • device_uncompressed_chunk_bytes – [输出] 大小为 num_chunks 的数组，用于填充每个解压缩数据块的大小（以字节为单位）。

  • num_chunks – [in] 要计算大小的数据块的数量。

  • stream – [in] 要操作的 CUDA 流。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedGzipDecompressAsync(
const void *const *device_compressed_chunk_ptrs,
const size_t *device_compressed_chunk_bytes,
const size_t *device_uncompressed_buffer_bytes,
size_t *device_uncompressed_chunk_bytes,
size_t num_chunks,
void *const device_temp_ptr,
size_t temp_bytes,
void *const *device_uncompressed_chunk_ptrs,
nvcompStatus_t *device_statuses,
cudaStream_t stream,
)#

执行批量异步解压缩。

注意

违反下面参数描述中列出的任何条件都可能导致未定义的行为。

如果压缩数据块不是有效的 Deflate 流，则无效块的大小将写入 0，并且该块将标记 nvcompStatusCannotDecompress。

参数:

  • device_compressed_chunk_ptrs – [in] 大小为 num_chunks 的指针数组，指向设备可访问内存中的设备可访问压缩缓冲区。每个缓冲区都必须根据 `nvcompBatchedGzipDecompressRequiredAlignments.input` 中的值对齐。

  • device_compressed_chunk_bytes – [in] 大小为 num_chunks 的大小数组，表示压缩缓冲区的大小（以字节为单位）。大小应驻留在设备可访问的内存中。

  • device_uncompressed_buffer_bytes – [输入] 大小为 num_chunks 的大小数组，以字节为单位，表示要填充每个块的解压缩数据的输出缓冲区的大小。这些大小应驻留在设备可访问的内存中。如果某个大小不足以容纳所有解压缩数据，则解压缩器会将 device_statuses 中与溢出块对应的状态设置为 nvcompErrorCannotDecompress。

  • device_uncompressed_chunk_bytes – [输出] 大小为 num_chunks 的数组，用于填充每个块的实际解压缩字节数。此参数需要预先分配，但如果需要，可以为 nullptr，在这种情况下，将不报告实际大小。

  • num_chunks – [输入] 要解压缩的数据块的数量。

  • device_temp_ptr – [in] 临时 GPU 空间。必须根据 `nvcompBatchedGzipDecompressRequiredAlignments.temp` 中的值对齐。

  • temp_bytes – [输入] 临时 GPU 空间的大小。

  • device_uncompressed_chunk_ptrs – [out] 大小为 num_chunks 的指针数组，指向设备可访问内存中的解压缩数据。每个解压缩缓冲区都需要在设备可访问内存中预先分配，其大小由 device_uncompressed_buffer_bytes 中的相应条目指定，并且必须根据 `nvcompBatchedGzipDecompressRequiredAlignments.output` 中的值对齐。

  • device_statuses – [输出] 大小为 num_chunks 的状态数组，位于设备可访问内存中。此参数需要预先分配。对于每个块，如果解压缩成功，则状态将设置为 nvcompSuccess。如果解压缩不成功，例如由于输入损坏或越界错误，则状态将设置为 nvcompErrorCannotDecompress。如果需要，可以为 nullptr，在这种情况下，将不报告错误状态。

  • stream – [in] 要操作的 CUDA 流。

返回值:

如果成功启动，则返回 nvcompSuccess，否则返回错误代码。

变量

const nvcompAlignmentRequirements_t nvcompBatchedGzipDecompressRequiredAlignments{1, 1, 1}#

解压缩的最小缓冲区对齐要求。

static const nvcompBatchedGzipOpts_t nvcompBatchedGzipDefaultOpts = {0}#
struct nvcompBatchedGzipOpts_t#
#include <gzip.h>

用于低级 API 的 Gzip 压缩选项

公共成员

int reserved#

ANS#

枚举

enum nvcompANSType_t#

值

enumerator nvcomp_rANS#
enum nvcompANSDataType_t#

值

enumerator uint8#
enumerator float16#

函数

nvcompStatus_t nvcompBatchedANSCompressGetRequiredAlignments(
nvcompBatchedANSOpts_t format_opts,
nvcompAlignmentRequirements_t *alignment_requirements,
)#

获取压缩的最小缓冲区对齐要求。

参数:

  • format_opts – [in] 压缩选项。

  • alignment_requirements – [out] 压缩的最小缓冲区对齐要求。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedANSCompressGetTempSize(
size_t num_chunks,
size_t max_uncompressed_chunk_bytes,
nvcompBatchedANSOpts_t format_opts,
size_t *temp_bytes,
)#

获取 GPU 上压缩所需的临时内存量。

参数:

  • num_chunks – [in] 批处理中内存块的数量。

  • max_uncompressed_chunk_bytes – [in] 批处理中块的最大大小。

  • format_opts – [in] 压缩选项。

  • temp_bytes – [out] 压缩期间临时需要的 GPU 内存量。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedANSCompressGetTempSizeEx(
size_t num_chunks,
size_t max_uncompressed_chunk_bytes,
nvcompBatchedANSOpts_t format_opts,
size_t *temp_bytes,
const size_t max_total_uncompressed_bytes,
)#

获取 GPU 上压缩所需的临时内存量，并带有额外的总字节参数。

参数:

  • num_chunks – [in] 批处理中内存块的数量。

  • max_uncompressed_chunk_bytes – [in] 批处理中块的最大大小。

  • format_opts – [in] 压缩选项。

  • temp_bytes – [out] 压缩期间临时需要的 GPU 内存量。

  • max_total_uncompressed_bytes – [in] 所有块的总未压缩大小的上限

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedANSCompressGetMaxOutputChunkSize(
size_t max_uncompressed_chunk_bytes,
nvcompBatchedANSOpts_t format_opts,
size_t *max_compressed_chunk_bytes,
)#

获取大小最大为 max_uncompressed_chunk_bytes 的块可以压缩到的最大大小。也就是说，为每个块提供 nvcompBatchedANSCompressAsync() 所需的最小输出内存量。

参数:

  • max_uncompressed_chunk_bytes – [in] 压缩前块的最大大小。

  • format_opts – [in] 压缩选项。

  • max_compressed_chunk_bytes – [out] 块的最大可能压缩大小。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedANSCompressAsync(
const void *const *device_uncompressed_chunk_ptrs,
const size_t *device_uncompressed_chunk_bytes,
size_t max_uncompressed_chunk_bytes,
size_t num_chunks,
void *device_temp_ptr,
size_t temp_bytes,
void *const *device_compressed_chunk_ptrs,
size_t *device_compressed_chunk_bytes,
nvcompBatchedANSOpts_t format_opts,
cudaStream_t stream,
)#

执行批量异步压缩。

注意

违反下面参数描述中列出的任何条件都可能导致未定义的行为。

参数:

  • device_uncompressed_chunk_ptrs – [in] 大小为 num_chunks 的指针数组，指向未压缩的数据块。指针和未压缩数据都应驻留在设备可访问的内存中。每个块都必须根据 nvcompAlignmentRequirements_t 对象的 `input` 成员中的值对齐，该对象由 `nvcompBatchedANSCompressGetRequiredAlignments` 在使用相同的 format_opts 调用时输出。

  • device_uncompressed_chunk_bytes – [in] 大小为 num_chunks 的大小数组，表示未压缩块的大小（以字节为单位）。大小应驻留在设备可访问的内存中。

  • max_uncompressed_chunk_bytes – [in] 最大未压缩块的大小。

  • num_chunks – [in] 要压缩的数据块的数量。

  • device_temp_ptr – [in] 临时 GPU 工作区，如果不需要临时内存，则可以为 NULL。必须根据 nvcompAlignmentRequirements_t 对象的 `temp` 成员中的值对齐，该对象由 `nvcompBatchedANSCompressGetRequiredAlignments` 在使用相同的 format_opts 调用时输出。

  • temp_bytes – [in] 由 `device_temp_ptr` 指向的临时 GPU 内存的大小。

  • device_compressed_chunk_ptrs – [out] 大小为 num_chunks 的指针数组，指向输出压缩缓冲区。指针和压缩缓冲区都应驻留在设备可访问的内存中。每个压缩缓冲区都应预先分配大小，该大小由 `nvcompBatchedANSCompressGetMaxOutputChunkSize` 给出。每个压缩缓冲区都必须根据 nvcompAlignmentRequirements_t 对象的 `output` 成员中的值对齐，该对象由 `nvcompBatchedANSCompressGetRequiredAlignments` 在使用相同的 format_opts 调用时输出。

  • device_compressed_chunk_bytes – [out] 大小为 num_chunks 的数组，用于填充每个块的压缩大小。缓冲区应在设备可访问的内存中预先分配。

  • format_opts – [in] 压缩选项。

  • stream – [in] 要操作的 CUDA 流。

返回值:

如果成功启动，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedANSDecompressGetTempSize(
size_t num_chunks,
size_t max_uncompressed_chunk_bytes,
size_t *temp_bytes,
)#

获取 GPU 上解压缩所需的临时内存量。

参数:

  • num_chunks – [in] 要解压缩的数据块的数量。

  • max_uncompressed_chunk_bytes – [in] 解压缩时最大块的大小（以字节为单位）。

  • temp_bytes – [out] 解压缩期间临时需要的 GPU 内存量。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedANSDecompressGetTempSizeEx(
size_t num_chunks,
size_t max_uncompressed_chunk_bytes,
size_t *temp_bytes,
size_t max_total_uncompressed_bytes,
)#

获取 GPU 上解压缩所需的临时内存量，并带有额外的总字节参数。

参数:

  • num_chunks – [in] 要解压缩的数据块的数量。

  • max_uncompressed_chunk_bytes – [in] 解压缩时最大块的大小（以字节为单位）。

  • temp_bytes – [out] 解压缩期间临时需要的 GPU 内存量。

  • max_total_uncompressed_bytes – [in] 所有块的总解压缩大小。在 ANS 中未使用。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedANSGetDecompressSizeAsync(
const void *const *device_compressed_chunk_ptrs,
const size_t *device_compressed_chunk_bytes,
size_t *device_uncompressed_chunk_bytes,
size_t num_chunks,
cudaStream_t stream,
)#

异步计算每个压缩块的未压缩数据字节数。

注意

违反下面参数描述中列出的任何条件都可能导致未定义的行为。

参数:

  • device_compressed_chunk_ptrs – [in] 大小为 num_chunks 的指针数组，指向设备可访问内存中的压缩缓冲区。每个缓冲区都必须根据 `nvcompBatchedANSDecompressRequiredAlignments.input` 中的值对齐。

  • device_compressed_chunk_bytes – [in] 大小为 num_chunks 的大小数组，表示压缩缓冲区的大小（以字节为单位）。大小应驻留在设备可访问的内存中。

  • device_uncompressed_chunk_bytes – [输出] 大小为 num_chunks 的数组，用于填充每个解压缩数据块的大小（以字节为单位）。如果在检索块大小的过程中出现错误，则该块的解压缩大小将设置为 0。此参数需要在设备可访问的内存中预先分配。

  • num_chunks – [in] 要计算大小的数据块的数量。

  • stream – [in] 要操作的 CUDA 流。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedANSDecompressAsync(
const void *const *device_compressed_chunk_ptrs,
const size_t *device_compressed_chunk_bytes,
const size_t *device_uncompressed_buffer_bytes,
size_t *device_uncompressed_chunk_bytes,
size_t num_chunks,
void *const device_temp_ptr,
size_t temp_bytes,
void *const *device_uncompressed_chunk_ptrs,
nvcompStatus_t *device_statuses,
cudaStream_t stream,
)#

执行批量异步解压缩。

此函数用于解压缩 `nvcompBatchedANSCompressAsync` 生成的压缩缓冲区。

注意

违反下面参数描述中列出的任何条件都可能导致未定义的行为。

参数:

  • device_compressed_chunk_ptrs – [in] 大小为 num_chunks 的指针数组，指向设备可访问内存中的设备可访问压缩缓冲区。每个缓冲区都必须根据 `nvcompBatchedANSDecompressRequiredAlignments.input` 中的值对齐。

  • device_compressed_chunk_bytes – [in] 大小为 num_chunks 的大小数组，表示压缩缓冲区的大小（以字节为单位）。大小应驻留在设备可访问的内存中。

  • device_uncompressed_buffer_bytes – [输入] 大小为 num_chunks 的大小数组，以字节为单位，表示要填充每个块的解压缩数据的输出缓冲区的大小。这些大小应驻留在设备可访问的内存中。如果某个大小不足以容纳所有解压缩数据，则解压缩器会将 device_statuses 中与溢出块对应的状态设置为 nvcompErrorCannotDecompress。

  • device_uncompressed_chunk_bytes – [out] 大小为 num_chunks 的数组，用于填充每个块的实际解压缩字节数。此参数需要预先分配。

  • num_chunks – [输入] 要解压缩的数据块的数量。

  • device_temp_ptr – [in] 临时 GPU 空间，如果不需要临时空间，则可以为 NULL。必须根据 `nvcompBatchedANSDecompressRequiredAlignments.temp` 中的值对齐。

  • temp_bytes – [输入] 临时 GPU 空间的大小。

  • device_uncompressed_chunk_ptrs – [out] 大小为 num_chunks 的指针数组，指向设备可访问内存中的解压缩数据。每个解压缩缓冲区都需要在设备可访问内存中预先分配，其大小由 device_uncompressed_buffer_bytes 中的相应条目指定，并且必须根据 `nvcompBatchedANSDecompressRequiredAlignments.output` 中的值对齐。

  • device_statuses – [out] 大小为 num_chunks 的状态数组，位于设备可访问内存中。此参数需要预先分配。对于每个块，如果解压缩成功，状态将设置为 `nvcompSuccess`。如果解压缩不成功，例如由于输入损坏或越界错误，状态将设置为 `nvcompErrorCannotDecompress`。

  • stream – [in] 要操作的 CUDA 流。

返回值:

如果成功启动，则返回 nvcompSuccess，否则返回错误代码。

变量

static const nvcompBatchedANSOpts_t nvcompBatchedANSDefaultOpts = {nvcomp_rANS, uint8}#
const size_t nvcompANSCompressionMaxAllowedChunkSize = 1 << 24#
const size_t nvcompANSRequiredAlignment = 8#

用于输入、输出或临时内存的 void 类型 CUDA 内存缓冲区的最严格的最小对齐要求，传递给压缩或解压缩函数。在所有情况下，类型化内存缓冲区仍必须与其类型的大小对齐，例如，int 为 4 字节。

const nvcompAlignmentRequirements_t nvcompBatchedANSDecompressRequiredAlignments{8, 1, 4}#

解压缩的最小缓冲区对齐要求。

struct nvcompBatchedANSOpts_t#
#include <ans.h>

ANS 低级 API 的压缩选项。

公共成员

nvcompANSType_t type#
nvcompANSDataType_t data_type#

Bitcomp#

类型定义

typedef nvcompBatchedBitcompOpts_t nvcompBatchedBitcompFormatOpts#

nvcompBatchedBitcompOpts_t 的旧别名。

函数

nvcompStatus_t nvcompBatchedBitcompCompressGetRequiredAlignments(
nvcompBatchedBitcompOpts_t format_opts,
nvcompAlignmentRequirements_t *alignment_requirements,
)#

获取压缩的最小缓冲区对齐要求。

参数:

  • format_opts – [in] 压缩选项。

  • alignment_requirements – [out] 压缩的最小缓冲区对齐要求。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedBitcompCompressGetTempSize(
size_t num_chunks,
size_t max_uncompressed_chunk_bytes,
nvcompBatchedBitcompOpts_t format_opts,
size_t *temp_bytes,
)#

获取 GPU 上压缩所需的临时内存量。

注意：Bitcomp 当前不使用任何临时内存。

参数:

  • num_chunks – [in] 批处理中内存块的数量。

  • max_uncompressed_chunk_bytes – [输入] 批处理中块的最大大小。此参数当前未使用。将其设置为实际值或零。

  • format_opts – [in] 压缩选项。

  • temp_bytes – [out] 压缩期间临时需要的 GPU 内存量。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedBitcompCompressGetTempSizeEx(
size_t num_chunks,
size_t max_uncompressed_chunk_bytes,
nvcompBatchedBitcompOpts_t format_opts,
size_t *temp_bytes,
const size_t max_total_uncompressed_bytes,
)#

获取 GPU 上压缩所需的临时内存量，并带有额外的总字节参数。

注意：Bitcomp 当前不使用任何临时内存。

参数:

  • num_chunks – [in] 批处理中内存块的数量。

  • max_uncompressed_chunk_bytes – [输入] 批处理中块的最大大小。此参数当前未使用。将其设置为实际值或零。

  • format_opts – [in] 压缩选项。

  • temp_bytes – [out] 压缩期间临时需要的 GPU 内存量。

  • max_total_uncompressed_bytes – [in] 所有块的总未压缩大小的上限

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedBitcompCompressGetMaxOutputChunkSize(
size_t max_uncompressed_chunk_bytes,
nvcompBatchedBitcompOpts_t format_opts,
size_t *max_compressed_chunk_bytes,
)#

获取大小至多为 max_uncompressed_chunk_bytes 的数据块压缩后的最大大小。 也就是说，为每个数据块提供给 nvcompBatchedBitcompCompressAsync() 的最小输出内存量。

参数:

  • max_uncompressed_chunk_bytes – [in] 压缩前块的最大大小。

  • format_opts – [in] 压缩选项。

  • max_compressed_chunk_bytes – [out] 块的最大可能压缩大小。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedBitcompCompressAsync(
const void *const *device_uncompressed_chunk_ptrs,
const size_t *device_uncompressed_chunk_bytes,
size_t max_uncompressed_chunk_bytes,
size_t num_chunks,
void *device_temp_ptr,
size_t temp_bytes,
void *const *device_compressed_chunk_ptrs,
size_t *device_compressed_chunk_bytes,
nvcompBatchedBitcompOpts_t format_opts,
cudaStream_t stream,
)#

执行批量异步压缩。

注意

违反下面参数描述中列出的任何条件都可能导致未定义的行为。

参数:

  • device_uncompressed_chunk_ptrs – [输入] 大小为 num_chunks 的指针数组，指向未压缩的数据块。 指针和未压缩数据都应驻留在设备可访问的内存中。 每个数据块都必须与 nvcompAlignmentRequirements_t 对象中 `input` 成员的值对齐，该对象由 `nvcompBatchedBitcompCompressGetRequiredAlignments` 在使用相同的 format_opts 调用时输出。

  • device_uncompressed_chunk_bytes – [输入] 大小为 num_chunks 的数组，包含未压缩块的大小（以字节为单位）。 大小应驻留在设备可访问的内存中。 每个块大小都必须是 format_opts.data_type 指定的数据类型大小的倍数。

  • max_uncompressed_chunk_bytes – [输入] 批处理中块的最大大小。此参数当前未使用。将其设置为实际值或零。

  • num_chunks – [in] 要压缩的数据块的数量。

  • device_temp_ptr – [输入] 此参数未使用。

  • temp_bytes – [输入] 此参数未使用。

  • device_compressed_chunk_ptrs – [输出] 大小为 num_chunks 的指针数组，指向输出压缩缓冲区。 指针和压缩缓冲区都应驻留在设备可访问的内存中。 每个压缩缓冲区都应预先分配大小，大小由 `nvcompBatchedBitcompCompressGetMaxOutputChunkSize` 给出。 每个压缩缓冲区都必须与 nvcompAlignmentRequirements_t 对象中 `output` 成员的值对齐，该对象由 `nvcompBatchedBitcompCompressGetRequiredAlignments` 在使用相同的 format_opts 调用时输出。

  • device_compressed_chunk_bytes – [out] 大小为 num_chunks 的数组，用于填充每个块的压缩大小。缓冲区应在设备可访问的内存中预先分配。

  • format_opts – [输入] 压缩选项。 它们必须有效。

  • stream – [in] 要操作的 CUDA 流。

返回值:

如果成功启动，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedBitcompDecompressGetTempSize(
size_t num_chunks,
size_t max_uncompressed_chunk_bytes,
size_t *temp_bytes,
)#

获取 GPU 上解压缩所需的临时内存量。

注意：Bitcomp 当前不使用任何临时内存。

参数:

  • num_chunks – [in] 要解压缩的数据块的数量。

  • max_uncompressed_chunk_bytes – [in] 解压缩时最大块的大小（以字节为单位）。

  • temp_bytes – [out] 解压缩期间临时需要的 GPU 内存量。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedBitcompDecompressGetTempSizeEx(
size_t num_chunks,
size_t max_uncompressed_chunk_bytes,
size_t *temp_bytes,
size_t max_total_uncompressed_bytes,
)#

获取 GPU 上解压缩所需的临时内存量，并带有额外的总字节参数。

注意：Bitcomp 当前不使用任何临时内存。

参数:

  • num_chunks – [in] 要解压缩的数据块的数量。

  • max_uncompressed_chunk_bytes – [in] 解压缩时最大块的大小（以字节为单位）。

  • temp_bytes – [输出] 解压缩期间临时需要的 GPU 内存量。 在 Bitcomp 中未使用。

  • max_total_uncompressed_bytes – [in] 所有块的总解压缩大小。

nvcompStatus_t nvcompBatchedBitcompGetDecompressSizeAsync(
const void *const *device_compressed_chunk_ptrs,
const size_t *device_compressed_chunk_bytes,
size_t *device_uncompressed_chunk_bytes,
size_t num_chunks,
cudaStream_t stream,
)#

异步计算每个压缩块的未压缩数据字节数。

注意

违反下面参数描述中列出的任何条件都可能导致未定义的行为。

参数:

  • device_compressed_chunk_ptrs – [输入] 大小为 num_chunks 的指针数组，指向设备可访问内存中的压缩缓冲区。 每个缓冲区都必须与 `nvcompBatchedBitcompDecompressRequiredAlignments.input` 中的值对齐。

  • device_compressed_chunk_bytes – [输入] 此参数未使用。

  • device_uncompressed_chunk_bytes – [输出] 大小为 num_chunks 的数组，用于填充每个解压缩数据块的大小（以字节为单位）。如果在检索块大小的过程中出现错误，则该块的解压缩大小将设置为 0。此参数需要在设备可访问的内存中预先分配。

  • num_chunks – [in] 要计算大小的数据块的数量。

  • stream – [in] 要操作的 CUDA 流。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedBitcompDecompressAsync(
const void *const *device_compressed_chunk_ptrs,
const size_t *device_compressed_chunk_bytes,
const size_t *device_uncompressed_buffer_bytes,
size_t *device_uncompressed_chunk_bytes,
size_t num_chunks,
void *const device_temp_ptr,
size_t temp_bytes,
void *const *device_uncompressed_chunk_ptrs,
nvcompStatus_t *device_statuses,
cudaStream_t stream,
)#

执行批量异步解压缩。

此函数用于解压缩 `nvcompBatchedBitcompCompressAsync` 生成的压缩缓冲区。 它还可以解压缩使用独立 Bitcomp 库压缩的缓冲区。

注意

违反下面参数描述中列出的任何条件都可能导致未定义的行为。

该函数并非完全异步，因为它需要查看压缩数据才能创建正确的 bitcomp 句柄。 流已同步，数据经过检查，然后启动异步解压缩。

异步、更快速版本的批量 Bitcomp 异步解压缩可用，并且可以通过 HLIF 管理器启动。

参数:

  • device_compressed_chunk_ptrs – [输入] 大小为 num_chunks 的指针数组，指向设备可访问内存中的设备可访问压缩缓冲区。 每个缓冲区都必须与 `nvcompBatchedBitcompDecompressRequiredAlignments.input` 中的值对齐。

  • device_compressed_chunk_bytes – [输入] 此参数未使用。

  • device_uncompressed_buffer_bytes – [输入] 大小为 num_chunks 的大小数组，以字节为单位，表示要填充每个块的解压缩数据的输出缓冲区的大小。这些大小应驻留在设备可访问的内存中。如果某个大小不足以容纳所有解压缩数据，则解压缩器会将 device_statuses 中与溢出块对应的状态设置为 nvcompErrorCannotDecompress。

  • device_uncompressed_chunk_bytes – [out] 大小为 num_chunks 的数组，用于填充每个块的实际解压缩字节数。此参数需要预先分配。

  • num_chunks – [输入] 要解压缩的数据块的数量。

  • device_temp_ptr – [输入] 此参数未使用。

  • temp_bytes – [输入] 此参数未使用。

  • device_uncompressed_chunk_ptrs – [输出] 大小为 num_chunks 的指针数组，指向设备可访问内存中的解压缩数据。 每个未压缩缓冲区都需要在设备可访问的内存中预先分配，其大小由 device_uncompressed_buffer_bytes 中的相应条目指定，并且与 `nvcompBatchedBitcompDecompressRequiredAlignments.output` 中的值对齐。

  • device_statuses – [out] 大小为 num_chunks 的状态数组，位于设备可访问内存中。此参数需要预先分配。对于每个块，如果解压缩成功，状态将设置为 `nvcompSuccess`。如果解压缩不成功，例如由于输入损坏或越界错误，状态将设置为 `nvcompErrorCannotDecompress`。

  • stream – [in] 要操作的 CUDA 流。

返回值:

如果成功启动，则返回 nvcompSuccess，否则返回错误代码。

变量

static const nvcompBatchedBitcompOpts_t nvcompBatchedBitcompDefaultOpts = {0, NVCOMP_TYPE_UCHAR}#
const size_t nvcompBitcompCompressionMaxAllowedChunkSize = 1 << 24#
const size_t nvcompBitcompRequiredAlignment = 8#

用于输入、输出或临时内存的 void 类型 CUDA 内存缓冲区的最严格的最小对齐要求，传递给压缩或解压缩函数。在所有情况下，类型化内存缓冲区仍必须与其类型的大小对齐，例如，int 为 4 字节。

const nvcompAlignmentRequirements_t nvcompBatchedBitcompDecompressRequiredAlignments{4, 8, 1}#

解压缩的最小缓冲区对齐要求。

struct nvcompBatchedBitcompOpts_t#
#include <bitcomp.h>

用于配置 Bitcomp 压缩的结构体。

公共成员

int algorithm_type#

Bitcomp 算法选项。

  • 0 : 默认算法，通常提供最佳压缩率

  • 1 : “稀疏”算法，在稀疏数据（包含大量零）上表现良好，并且通常比默认算法更快。

nvcompType_t data_type#

nvcomp 的可能数据类型之一。

Cascaded#

函数

nvcompStatus_t nvcompBatchedCascadedCompressGetRequiredAlignments(
nvcompBatchedCascadedOpts_t format_opts,
nvcompAlignmentRequirements_t *alignment_requirements,
)#

获取压缩的最小缓冲区对齐要求。

参数:

  • format_opts – [in] 压缩选项。

  • alignment_requirements – [out] 压缩的最小缓冲区对齐要求。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedCascadedCompressGetTempSize(
size_t num_chunks,
size_t max_uncompressed_chunk_bytes,
nvcompBatchedCascadedOpts_t format_opts,
size_t *temp_bytes,
)#

获取 GPU 上压缩所需的临时内存量。

注意

批量 Cascaded 压缩不需要临时空间，因此除非 format_opts 出现错误，否则这将设置 *temp_bytes=0。

参数:

  • num_chunks – [in] 批处理中内存块的数量。

  • max_uncompressed_chunk_bytes – [输入] 批处理中块的最大大小。此参数当前未使用。将其设置为实际值或零。

  • format_opts – [输入] 要使用的 Cascaded 压缩选项和数据类型。

  • temp_bytes – [out] 压缩期间临时需要的 GPU 内存量。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedCascadedCompressGetTempSizeEx(
size_t num_chunks,
size_t max_uncompressed_chunk_bytes,
nvcompBatchedCascadedOpts_t format_opts,
size_t *temp_bytes,
const size_t max_total_uncompressed_bytes,
)#

获取 GPU 上压缩所需的临时内存量，并带有额外的总字节参数。

注意

批量 Cascaded 压缩不需要临时空间，因此除非 format_opts 出现错误，否则这将设置 *temp_bytes=0。

参数:

  • num_chunks – [in] 批处理中内存块的数量。

  • max_uncompressed_chunk_bytes – [输入] 批处理中块的最大大小。此参数当前未使用。将其设置为实际值或零。

  • format_opts – [输入] 要使用的 Cascaded 压缩选项和数据类型。

  • temp_bytes – [out] 压缩期间临时需要的 GPU 内存量。

  • max_total_uncompressed_bytes – [in] 所有块的总未压缩大小的上限

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedCascadedCompressGetMaxOutputChunkSize(
size_t max_uncompressed_chunk_bytes,
nvcompBatchedCascadedOpts_t format_opts,
size_t *max_compressed_chunk_bytes,
)#

获取大小至多为 max_uncompressed_chunk_bytes 的数据块压缩后的最大大小。 也就是说，为每个数据块提供给 nvcompBatchedCascadedCompressAsync() 的最小输出内存量。

参数:

  • max_uncompressed_chunk_bytes – [in] 压缩前块的最大大小。

  • format_opts – [输入] 要使用的 Cascaded 压缩选项。

  • max_compressed_chunk_bytes – [out] 块的最大可能压缩大小。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedCascadedCompressAsync(
const void *const *device_uncompressed_chunk_ptrs,
const size_t *device_uncompressed_chunk_bytes,
size_t max_uncompressed_chunk_bytes,
size_t num_chunks,
void *device_temp_ptr,
size_t temp_bytes,
void *const *device_compressed_chunk_ptrs,
size_t *device_compressed_chunk_bytes,
nvcompBatchedCascadedOpts_t format_opts,
cudaStream_t stream,
)#

执行批量异步压缩。

注意

当前实现不支持大于 4,294,967,295 字节（最大 uint32_t）的未压缩大小。

违反下面参数描述中列出的任何条件都可能导致未定义的行为。

参数:

  • device_uncompressed_chunk_ptrs – [输入] 大小为 num_chunks 的指针数组，指向未压缩的数据块。 指针和未压缩数据都应驻留在设备可访问的内存中。 每个数据块都必须与 nvcompAlignmentRequirements_t 对象中 `input` 成员的值对齐，该对象由 `nvcompBatchedCascadedCompressGetRequiredAlignments` 在使用相同的 format_opts 调用时输出。

  • device_uncompressed_chunk_bytes – [输入] 大小为 num_chunks 的数组，包含未压缩块的大小（以字节为单位）。 大小应驻留在设备可访问的内存中。 每个块大小都必须是 format_opts.type 指定的数据类型大小的倍数，否则可能会崩溃或产生无效输出。

  • max_uncompressed_chunk_bytes – [输入] 最大解压缩块的大小。此参数当前未使用。将其设置为实际值或零。

  • num_chunks – [in] 要压缩的数据块的数量。

  • device_temp_ptr – [输入] 此参数未使用。

  • temp_bytes – [输入] 此参数未使用。

  • device_compressed_chunk_ptrs – [输出] 大小为 num_chunks 的指针数组，指向输出压缩缓冲区。 指针和压缩缓冲区都应驻留在设备可访问的内存中。 每个压缩缓冲区都应预先分配大小，大小由 `nvcompBatchedCascadedCompressGetMaxOutputChunkSize` 给出。 每个压缩缓冲区都必须与 nvcompAlignmentRequirements_t 对象中 `output` 成员的值对齐，该对象由 `nvcompBatchedCascadedCompressGetRequiredAlignments` 在使用相同的 format_opts 调用时输出。

  • device_compressed_chunk_bytes – [out] 大小为 num_chunks 的数组，用于填充每个块的压缩大小。缓冲区应在设备可访问的内存中预先分配。

  • format_opts – [输入] cascaded 格式选项。 格式必须有效。

  • stream – [in] 要操作的 CUDA 流。

返回值:

如果成功启动，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedCascadedDecompressGetTempSize(
size_t num_chunks,
size_t max_uncompressed_chunk_bytes,
size_t *temp_bytes,
)#

获取 GPU 上解压缩所需的临时内存量。

参数:

  • num_chunks – [in] 要解压缩的数据块的数量。

  • max_uncompressed_chunk_bytes – [in] 解压缩时最大块的大小（以字节为单位）。

  • temp_bytes – [out] 解压缩期间临时需要的 GPU 内存量。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedCascadedDecompressGetTempSizeEx(
size_t num_chunks,
size_t max_uncompressed_chunk_bytes,
size_t *temp_bytes,
size_t max_total_uncompressed_bytes,
)#

获取 GPU 上解压缩所需的临时内存量，并带有额外的总字节参数。

参数:

  • num_chunks – [in] 要解压缩的数据块的数量。

  • max_uncompressed_chunk_bytes – [in] 解压缩时最大块的大小（以字节为单位）。

  • temp_bytes – [out] 解压缩期间临时需要的 GPU 内存量。

  • max_total_uncompressed_bytes – [输入] 所有数据块的总解压缩大小。 在 Cascaded 中未使用。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedCascadedGetDecompressSizeAsync(
const void *const *device_compressed_chunk_ptrs,
const size_t *device_compressed_chunk_bytes,
size_t *device_uncompressed_chunk_bytes,
size_t num_chunks,
cudaStream_t stream,
)#

异步计算每个压缩块的未压缩数据字节数。

注意

违反下面参数描述中列出的任何条件都可能导致未定义的行为。

参数:

  • device_compressed_chunk_ptrs – [输入] 大小为 num_chunks 的指针数组，指向设备可访问内存中的压缩缓冲区。 每个缓冲区都必须与 `nvcompBatchedCascadedDecompressRequiredAlignments.input` 中的值对齐。

  • device_compressed_chunk_bytes – [in] 大小为 num_chunks 的大小数组，表示压缩缓冲区的大小（以字节为单位）。大小应驻留在设备可访问的内存中。

  • device_uncompressed_chunk_bytes – [输出] 大小为 num_chunks 的数组，用于填充每个解压缩数据块的大小（以字节为单位）。如果在检索块大小的过程中出现错误，则该块的解压缩大小将设置为 0。此参数需要在设备可访问的内存中预先分配。

  • num_chunks – [in] 要计算大小的数据块的数量。

  • stream – [in] 要操作的 CUDA 流。

返回值:

如果成功，则返回 nvcompSuccess，否则返回错误代码。

nvcompStatus_t nvcompBatchedCascadedDecompressAsync(
const void *const *device_compressed_chunk_ptrs,
const size_t *device_compressed_chunk_bytes,
const size_t *device_uncompressed_buffer_bytes,
size_t *device_uncompressed_chunk_bytes,
size_t num_chunks,
void *const device_temp_ptr,
size_t temp_bytes,
void *const *device_uncompressed_chunk_ptrs,
nvcompStatus_t *device_statuses,
cudaStream_t stream,
)#

执行批量异步解压缩。

此函数用于解压缩 `nvcompBatchedCascadedCompressAsync` 生成的压缩缓冲区。

注意

违反下面参数描述中列出的任何条件都可能导致未定义的行为。

参数:

  • device_compressed_chunk_ptrs – [输入] 大小为 num_chunks 的指针数组，指向设备可访问内存中的设备可访问压缩缓冲区。 每个缓冲区都必须与 `nvcompBatchedCascadedDecompressRequiredAlignments.input` 中的值对齐。

  • device_compressed_chunk_bytes – [in] 大小为 num_chunks 的大小数组，表示压缩缓冲区的大小（以字节为单位）。大小应驻留在设备可访问的内存中。

  • device_uncompressed_buffer_bytes – [输入] 大小为 num_chunks 的大小数组，以字节为单位，表示要填充每个块的解压缩数据的输出缓冲区的大小。这些大小应驻留在设备可访问的内存中。如果某个大小不足以容纳所有解压缩数据，则解压缩器会将 device_statuses 中与溢出块对应的状态设置为 nvcompErrorCannotDecompress。

  • device_uncompressed_chunk_bytes – [out] 大小为 num_chunks 的数组，用于填充每个块的实际解压缩字节数。此参数需要预先分配。

  • num_chunks – [输入] 要解压缩的数据块的数量。

  • device_temp_ptr – [输入] 此参数未使用。

  • temp_bytes – [输入] 此参数未使用。

  • device_uncompressed_chunk_ptrs – [输出] 大小为 num_chunks 的指针数组，指向设备可访问内存中的解压缩数据。 每个未压缩缓冲区都需要在设备可访问的内存中预先分配，其大小由 device_uncompressed_buffer_bytes 中的相应条目指定，并且与 `nvcompBatchedCascadedDecompressRequiredAlignments.output` 中的值对齐。

  • device_statuses – [out] 大小为 num_chunks 的状态数组，位于设备可访问内存中。此参数需要预先分配。对于每个块，如果解压缩成功，状态将设置为 `nvcompSuccess`。如果解压缩不成功，例如由于输入损坏或越界错误，状态将设置为 `nvcompErrorCannotDecompress`。

  • stream – [in] 要操作的 CUDA 流。

返回值:

如果成功启动，则返回 nvcompSuccess，否则返回错误代码。

变量

static const nvcompBatchedCascadedOpts_t nvcompBatchedCascadedDefaultOpts = {4096, NVCOMP_TYPE_INT, 2, 1, 1}#
const size_t nvcompCascadedCompressionMaxAllowedChunkSize = 1 << 24#
const size_t nvcompCascadedRequiredAlignment = 8#

用于输入、输出或临时内存的 void 类型 CUDA 内存缓冲区的最严格的最小对齐要求，传递给压缩或解压缩函数。在所有情况下，类型化内存缓冲区仍必须与其类型的大小对齐，例如，int 为 4 字节。

const nvcompAlignmentRequirements_t nvcompBatchedCascadedDecompressRequiredAlignments{4, 8, 1}#

解压缩的最小缓冲区对齐要求。

struct nvcompBatchedCascadedOpts_t#
#include <cascaded.h>

存储压缩配置的结构体。

公共成员

size_t internal_chunk_bytes#

使用 Cascaded 压缩独立解压缩的每个内部数据块的大小。

Cascaded 压缩。 该值应在 [512, 16384] 范围内，具体取决于输入的数据类型和所用 GPU 的共享内存大小。 这不是传递到 API 中的块的大小。 建议大小为 4096。

注意

当前未使用，仅使用默认值 4096。

nvcompType_t type#

用于定义压缩位宽的数据类型。

int num_RLEs#

要执行的行程长度编码 (RLE) 的数量。

int num_deltas#

要执行的 Delta 编码的数量。

int use_bp#

是否对最终层进行位打包。

本页内容