QAT support

cpp/src/arrow/ipc/metadata_internal.cc

@@ -924,6 +924,8 @@ static Status GetBodyCompression(FBB& fbb, const IpcWriteOptions& options,
       codec = flatbuf::CompressionType::ZSTD;
     } else if (options.codec->compression_type() == Compression::FASTPFOR) {
       codec = flatbuf::CompressionType::FASTPFOR;
+    } else if (options.codec->compression_type() == Compression::GZIP) {
+      codec = flatbuf::CompressionType::GZIP;
     } else {
       return Status::Invalid("Unsupported IPC compression codec: ",
                              options.codec->name());

cpp/src/arrow/ipc/options.cc

@@ -29,8 +29,8 @@ IpcReadOptions IpcReadOptions::Defaults() { return IpcReadOptions(); }
 namespace internal {
 
 Status CheckCompressionSupported(Compression::type codec) {
-  if (!(codec == Compression::LZ4_FRAME || codec == Compression::ZSTD || codec == Compression::FASTPFOR)) {
-    return Status::Invalid("Only LZ4_FRAME and ZSTD compression allowed");
+  if (!(codec == Compression::LZ4_FRAME || codec == Compression::ZSTD || codec == Compression::FASTPFOR || codec == Compression::GZIP)) {
+    return Status::Invalid("Only LZ4_FRAME and ZSTD compression allowed GZIP");
   }
   return Status::OK();
 }

cpp/src/arrow/ipc/reader.cc

@@ -640,6 +640,8 @@ Status GetCompression(const flatbuf::RecordBatch* batch, Compression::type* out)
       *out = Compression::ZSTD;
     } else if (compression->codec() == flatbuf::CompressionType::FASTPFOR) {
       *out = Compression::FASTPFOR;
+    } else if (compression->codec() == flatbuf::CompressionType::GZIP) {
+      *out = Compression::GZIP;
     } else {
       return Status::Invalid("Unsupported codec in RecordBatch::compression metadata");
     }

cpp/src/arrow/util/compression_zlib.cc

@@ -22,6 +22,7 @@
 #include <cstring>
 #include <limits>
 #include <memory>
+#include <iostream>
 
 #include <zconf.h>
 #include <zlib.h>
@@ -568,6 +569,7 @@ std::unique_ptr<Codec> MakeGZipCodec(int compression_level, GZipFormat::type for
   if (s == "QAT") {
 #ifdef ARROW_WITH_QAT
     using arrow::util::internal::QatCodec;
+    std::cout << "QAT is used as codec" << std::endl;
     return std::unique_ptr<Codec>(new QatCodec());
 #else
     ARROW_LOG(WARNING) << "Support for codec QAT not built";
@@ -576,6 +578,7 @@ std::unique_ptr<Codec> MakeGZipCodec(int compression_level, GZipFormat::type for
     ARROW_LOG(WARNING) << "Invalid backend for ARROW_GZIP_BACKEND: " << s
                        << ", only support QAT now";
   }
+  std::cout << "ZLIB is used as codec" << std::endl;
   return std::unique_ptr<Codec>(new GZipCodec(compression_level, format));
 }
 

cpp/src/generated/Message_generated.h

@@ -33,31 +33,34 @@ enum class CompressionType : int8_t {
   LZ4_FRAME = 0,
   ZSTD = 1,
   FASTPFOR = 2,
+  GZIP = 3,
   MIN = LZ4_FRAME,
-  MAX = ZSTD
+  MAX = GZIP
 };
 
-inline const CompressionType (&EnumValuesCompressionType())[3] {
+inline const CompressionType (&EnumValuesCompressionType())[4] {
   static const CompressionType values[] = {
     CompressionType::LZ4_FRAME,
     CompressionType::ZSTD,
-    CompressionType::FASTPFOR
+    CompressionType::FASTPFOR,
+    CompressionType::GZIP
   };
   return values;
 }
 
 inline const char * const *EnumNamesCompressionType() {
-  static const char * const names[4] = {
+  static const char * const names[5] = {
     "LZ4_FRAME",
     "ZSTD",
     "FASTPFOR",
+    "GZIP",
     nullptr
   };
   return names;
 }
 
 inline const char *EnumNameCompressionType(CompressionType e) {
-  if (flatbuffers::IsOutRange(e, CompressionType::LZ4_FRAME, CompressionType::ZSTD)) return "";
+  if (flatbuffers::IsOutRange(e, CompressionType::LZ4_FRAME, CompressionType::GZIP)) return "";
   const size_t index = static_cast<size_t>(e);
   return EnumNamesCompressionType()[index];
 }

format/Message.fbs

@@ -50,7 +50,8 @@ enum CompressionType:byte {
 
   // Zstandard
   ZSTD,
-  FASTPFOR
+  FASTPFOR,
+  GZIP
 }
 
 /// Provided for forward compatibility in case we need to support different