Refactor host decompression in ORC reader

cpp/include/cudf/io/types.hpp

@@ -60,7 +60,11 @@ enum class compression_type {
   BZIP2,   ///< BZIP2 format, using Burrows-Wheeler transform
   BROTLI,  ///< BROTLI format, using LZ77 + Huffman + 2nd order context modeling
   ZIP,     ///< ZIP format, using DEFLATE algorithm
-  XZ       ///< XZ format, using LZMA(2) algorithm
+  XZ,      ///< XZ format, using LZMA(2) algorithm
+  ZLIB,    ///< ZLIB format, using DEFLATE algorithm
+  LZ4,     ///< LZ4 format, using LZ77
+  LZO,     ///< Lempel–Ziv–Oberhumer format
+  ZSTD     ///< Zstandard format
 };
 
 /**

cpp/src/io/comp/io_uncomp.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018-2021, NVIDIA CORPORATION.
+ * Copyright (c) 2018-2022, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -27,35 +27,20 @@ using cudf::host_span;
 
 namespace cudf {
 namespace io {
-enum {
-  IO_UNCOMP_STREAM_TYPE_INFER   = 0,
-  IO_UNCOMP_STREAM_TYPE_GZIP    = 1,
-  IO_UNCOMP_STREAM_TYPE_ZIP     = 2,
-  IO_UNCOMP_STREAM_TYPE_BZIP2   = 3,
-  IO_UNCOMP_STREAM_TYPE_XZ      = 4,
-  IO_UNCOMP_STREAM_TYPE_INFLATE = 5,
-  IO_UNCOMP_STREAM_TYPE_SNAPPY  = 6,
-  IO_UNCOMP_STREAM_TYPE_BROTLI  = 7,
-  IO_UNCOMP_STREAM_TYPE_LZ4     = 8,
-  IO_UNCOMP_STREAM_TYPE_LZO     = 9,
-  IO_UNCOMP_STREAM_TYPE_ZSTD    = 10,
-};
 
-std::vector<char> io_uncompress_single_h2d(void const* src, size_t src_size, int stream_type);
-
-std::vector<char> get_uncompressed_data(host_span<char const> data, compression_type compression);
-
-class HostDecompressor {
- public:
-  virtual size_t Decompress(uint8_t* dstBytes,
-                            size_t dstLen,
-                            uint8_t const* srcBytes,
-                            size_t srcLen) = 0;
-  virtual ~HostDecompressor() {}
+/**
+ * @brief Decompresses a system memory buffer.
+ *
+ * @param compression Type of compression of the input data
+ * @param src Compressed host buffer
+ *
+ * @return Vector containing the Decompressed output
+ */
+std::vector<uint8_t> decompress(compression_type compression, host_span<uint8_t const> src);
 
- public:
-  static std::unique_ptr<HostDecompressor> Create(int stream_type);
-};
+size_t decompress(compression_type compression,
+                  host_span<uint8_t const> src,
+                  host_span<uint8_t> dst);
 
 /**
  * @brief GZIP header flags

cpp/src/io/comp/nvcomp_adapter.cpp

@@ -23,37 +23,37 @@
 namespace cudf::io::nvcomp {
 
 template <typename... Args>
-auto batched_decompress_get_temp_size(compression_type type, Args&&... args)
+auto batched_decompress_get_temp_size(compression_type compression, Args&&... args)
 {
-  switch (type) {
+  switch (compression) {
     case compression_type::SNAPPY:
       return nvcompBatchedSnappyDecompressGetTempSize(std::forward<Args>(args)...);
     default: CUDF_FAIL("Unsupported compression type");
   }
 };
 
 template <typename... Args>
-auto batched_decompress_async(compression_type type, Args&&... args)
+auto batched_decompress_async(compression_type compression, Args&&... args)
 {
-  switch (type) {
+  switch (compression) {
     case compression_type::SNAPPY:
       return nvcompBatchedSnappyDecompressAsync(std::forward<Args>(args)...);
     default: CUDF_FAIL("Unsupported compression type");
   }
 };
 
-size_t get_temp_size(compression_type type, size_t num_chunks, size_t max_uncomp_chunk_size)
+size_t get_temp_size(compression_type compression, size_t num_chunks, size_t max_uncomp_chunk_size)
 {
   size_t temp_size = 0;
   nvcompStatus_t nvcomp_status =
-    batched_decompress_get_temp_size(type, num_chunks, max_uncomp_chunk_size, &temp_size);
+    batched_decompress_get_temp_size(compression, num_chunks, max_uncomp_chunk_size, &temp_size);
   CUDF_EXPECTS(nvcomp_status == nvcompStatus_t::nvcompSuccess,
                "Unable to get scratch size for decompression");
 
   return temp_size;
 }
 
-void batched_decompress(compression_type type,
+void batched_decompress(compression_type compression,
                         device_span<device_span<uint8_t const> const> inputs,
                         device_span<device_span<uint8_t> const> outputs,
                         device_span<decompress_status> statuses,
@@ -67,8 +67,8 @@ void batched_decompress(compression_type type,
   rmm::device_uvector<size_t> actual_uncompressed_data_sizes(num_chunks, stream);
   rmm::device_uvector<nvcompStatus_t> nvcomp_statuses(num_chunks, stream);
   // Temporary space required for decompression
-  rmm::device_buffer scratch(get_temp_size(type, num_chunks, max_uncomp_chunk_size), stream);
-  auto const nvcomp_status = batched_decompress_async(type,
+  rmm::device_buffer scratch(get_temp_size(compression, num_chunks, max_uncomp_chunk_size), stream);
+  auto const nvcomp_status = batched_decompress_async(compression,
                                                       nvcomp_args.compressed_data_ptrs.data(),
                                                       nvcomp_args.compressed_data_sizes.data(),
                                                       nvcomp_args.uncompressed_data_sizes.data(),

cpp/src/io/comp/nvcomp_adapter.hpp

@@ -36,7 +36,7 @@ enum class compression_type { SNAPPY };
  * @param[in] max_uncomp_page_size maximum size of uncompressed block
  * @param[in] stream CUDA stream to use
  */
-void batched_decompress(compression_type type,
+void batched_decompress(compression_type compression,
                         device_span<device_span<uint8_t const> const> inputs,
                         device_span<device_span<uint8_t> const> outputs,
                         device_span<decompress_status> statuses,