Upload Kmake

deps/zlib/contrib/qat/qatzpp/io_buffers.cpp

@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2024 Intel Corporation. All rights reserved.
+ * Authors:
+ *  Gustavo A Espinoza   <gustavo.adolfo.espinoza.quintero@intel.com>
+ *                       <gustavoaespinozaq@hotmail.com>
+ *
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+#include <fstream>
+#include <iostream>
+
+#include "io_buffers.h"
+#include "qat_instance.hpp"
+
+namespace qat
+{
+
+IOBuffers::IOBuffers()
+{
+}
+
+IOBuffers::IOBuffers(std::unique_ptr<BaseBufferList>&& src_list, std::unique_ptr<BaseBufferList>&& dst_list):
+    src_buffer_list_(std::move(src_list)), dst_buffer_list_(std::move(dst_list))
+{
+}
+
+IOBuffers::~IOBuffers()
+{
+}
+
+}

deps/zlib/contrib/qat/qatzpp/io_buffers.h

@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2024 Intel Corporation. All rights reserved.
+ * Authors:
+ *  Gustavo A Espinoza   <gustavo.adolfo.espinoza.quintero@intel.com>
+ *                       <gustavoaespinozaq@hotmail.com>
+ *
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+#ifndef QATZPP_IO_BUFFERS_H
+#define QATZPP_IO_BUFFERS_H
+
+#include <qat/cpa_dc.h>
+
+#include <cstring>
+#include <iostream>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "memory.hpp"
+#include "qat_instance.hpp"
+
+namespace qat
+{
+
+struct BaseBufferList
+{
+    virtual ~BaseBufferList() {}
+
+    CpaBufferList list;
+    std::vector<CpaFlatBuffer> flat_buffers;
+
+protected:
+    BaseBufferList() {}
+};
+
+class IOBuffers
+{
+public:
+    IOBuffers(
+        std::unique_ptr<BaseBufferList> &&src_list,
+        std::unique_ptr<BaseBufferList> &&dst_list
+    );
+    virtual ~IOBuffers();
+
+    BaseBufferList *GetSrc() const {
+        return src_buffer_list_.get();
+    }
+
+    BaseBufferList *GetDst() const {
+        return dst_buffer_list_.get();
+    }
+protected:
+    IOBuffers();
+
+    std::unique_ptr<BaseBufferList> src_buffer_list_;
+    std::unique_ptr<BaseBufferList> dst_buffer_list_;
+};
+
+}
+
+#endif

deps/zlib/contrib/qat/qatzpp/memory.cpp

@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2024 Intel Corporation. All rights reserved.
+ * Authors:
+ *  Gustavo A Espinoza   <gustavo.adolfo.espinoza.quintero@intel.com>
+ *                       <gustavoaespinozaq@hotmail.com>
+ *
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+#include <qat/qae_mem.h>
+
+#include <cstdlib>
+#include <iostream>
+
+#include "memory.hpp"
+#include "qat.hpp"
+
+namespace qat
+{
+
+void *Alloc(size_t size_bytes, uint32_t numa_node)
+{
+    return qaeMemAllocNUMA(size_bytes, numa_node, 1);
+}
+
+void Free(void *ptr)
+{
+    qaeMemFreeNUMA(&ptr);
+}
+
+}

deps/zlib/contrib/qat/qatzpp/memory.hpp

@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2024 Intel Corporation. All rights reserved.
+ * Authors:
+ *  Gustavo A Espinoza   <gustavo.adolfo.espinoza.quintero@intel.com>
+ *                       <gustavoaespinozaq@hotmail.com>
+ *
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+#ifndef QATZPP_MEMORY_HPP
+#define QATZPP_MEMORY_HPP
+
+#include <cstddef>
+#include <cstdint>
+
+namespace qat
+{
+
+void *Alloc(size_t sizeBytes, uint32_t numa_node);
+
+template <typename T>
+T *AllocBlock(int32_t numa_node)
+{
+    return static_cast<T*>(Alloc(sizeof(T), numa_node));
+}
+
+template <typename T>
+T *AllocBlockArray(size_t count, int32_t numa_node)
+{
+    if (count <= 0) {
+        return nullptr;
+    }
+
+    return static_cast<T*>(Alloc(sizeof(T) * count, numa_node));
+}
+
+void Free(void *ptr);
+
+}
+
+#endif

deps/zlib/contrib/qat/qatzpp/qat.cpp

@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 2024 Intel Corporation. All rights reserved.
+ * Authors:
+ *  Gustavo A Espinoza   <gustavo.adolfo.espinoza.quintero@intel.com>
+ *                       <gustavoaespinozaq@hotmail.com>
+ *
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+#include "qat.hpp"
+
+#include <qat/cpa.h>
+#include <qat/icp_sal_user.h>
+#include <qat/qae_mem.h>
+
+#include <iostream>
+#include <string>
+#include <memory>
+#include <mutex>
+
+namespace qat
+{
+
+static bool g_qat_not_available = false;
+static bool g_qat_initialized = false;
+static std::mutex g_qat_initialization_mutex;
+
+class QATContext
+{
+public:
+    explicit QATContext() {}
+
+    QATContext(const QATContext &) = delete;
+    QATContext &operator=(const QATContext &) = delete;
+
+    QATContext(QATContext &&) = delete;
+    QATContext &operator=(QATContext &&) = delete;
+
+    ~QATContext()
+    {
+        std::lock_guard<std::mutex> lock(g_qat_initialization_mutex);
+
+        if (g_qat_not_available) return;
+
+        if (g_qat_initialized) {
+            icp_sal_userStop();
+            g_qat_initialized = false;
+        }
+    }
+};
+
+static std::unique_ptr<QATContext> qat_context;
+
+int Initialize()
+{
+    std::lock_guard<std::mutex> lock(g_qat_initialization_mutex);
+    uint32_t cpa_state;
+    if (g_qat_not_available) {
+        return CPA_STATUS_FAIL;
+    }
+    if (g_qat_initialized) {
+        return CPA_STATUS_SUCCESS;
+    }
+
+    cpa_state = icp_sal_userStartMultiProcess("SSL", CPA_FALSE);
+
+    g_qat_not_available = (cpa_state != CPA_STATUS_SUCCESS);
+    g_qat_initialized = (cpa_state == CPA_STATUS_SUCCESS);
+
+    qat_context = std::make_unique<QATContext>();
+    return cpa_state;
+}
+
+}

deps/zlib/contrib/qat/qatzpp/qat.hpp

@@ -0,0 +1,19 @@
+/*
+ * Copyright (C) 2024 Intel Corporation. All rights reserved.
+ * Authors:
+ *  Gustavo A Espinoza   <gustavo.adolfo.espinoza.quintero@intel.com>
+ *                       <gustavoaespinozaq@hotmail.com>
+ *
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+#ifndef QATZPP_QAT_HPP
+#define QATZPP_QAT_HPP
+
+namespace qat
+{
+
+int Initialize();
+
+}
+
+#endif

deps/zlib/contrib/qat/qatzpp/qat_buffer_list.cpp

@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2024 Intel Corporation. All rights reserved.
+ * Authors:
+ *  Gustavo A Espinoza   <gustavo.adolfo.espinoza.quintero@intel.com>
+ *                       <gustavoaespinozaq@hotmail.com>
+ *
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+#include "qat_buffer_list.hpp"
+
+namespace qat
+{
+
+BufferListUser::BufferListUser(
+    uint8_t *data,
+    size_t size,
+    size_t metadata_size)
+{
+    flat_buffers = std::vector<CpaFlatBuffer>(1);
+    flat_buffers[0].pData = data;
+    flat_buffers[0].dataLenInBytes = size;
+    list.pPrivateMetaData = AllocBlockArray<uint8_t>(metadata_size, 0);
+    list.numBuffers = 1;
+    list.pBuffers = flat_buffers.data();
+}
+
+BufferListUser::~BufferListUser()
+{
+    if (list.pPrivateMetaData) {
+        Free(list.pPrivateMetaData);
+    }
+}
+
+}

deps/zlib/contrib/qat/qatzpp/qat_buffer_list.hpp

@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2024 Intel Corporation. All rights reserved.
+ * Authors:
+ *  Gustavo A Espinoza   <gustavo.adolfo.espinoza.quintero@intel.com>
+ *                       <gustavoaespinozaq@hotmail.com>
+ *
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+#ifndef QATZPP_QAT_BUFFER_LIST_HPP
+#define QATZPP_QAT_BUFFER_LIST_HPP
+
+#include <qat/cpa.h>
+
+#include "io_buffers.h"
+
+namespace qat
+{
+
+struct BufferListUser final : public BaseBufferList
+{
+    BufferListUser(
+        uint8_t *data,
+        size_t size,
+        size_t metadata_size
+    );
+
+    ~BufferListUser() override;
+};
+
+}
+
+#endif

deps/zlib/contrib/qat/qatzpp/qat_instance.cpp

@@ -0,0 +1,135 @@
+/*
+ * Copyright (C) 2024 Intel Corporation. All rights reserved.
+ * Authors:
+ *  Gustavo A Espinoza   <gustavo.adolfo.espinoza.quintero@intel.com>
+ *                       <gustavoaespinozaq@hotmail.com>
+ *
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+#include <qat/qae_mem.h>
+
+#include <iostream>
+#include <vector>
+
+#include "memory.hpp"
+#include "qat_instance.hpp"
+#include "session.hpp"
+
+#define MAX_SAMPLE_BUFFER_SIZE  (4*1024*1024)
+
+namespace qat
+{
+
+static std::mutex g_instance_mutex;
+static std::vector<std::shared_ptr<Instance>> instances;
+
+static CpaPhysicalAddr virt2Phys(void *virt_addr)
+{
+    return (CpaPhysicalAddr)qaeVirtToPhysNUMA(virt_addr);
+}
+
+Instance::Instance(CpaInstanceHandle instance):
+    instance_(instance),
+    num_intermediate_buffer_lists_(0),
+    intermediate_buffer_array_(nullptr),
+    started_(false)
+{
+    CpaDcInstanceCapabilities caps{};
+    cpaDcQueryCapabilities(instance_, &caps);
+
+    if (!caps.statelessDeflateCompression || !caps.statelessDeflateDecompression ||
+        !caps.checksumAdler32 || !caps.dynamicHuffman)
+    {
+        return;
+    }
+
+    if (caps.dynamicHuffmanBufferReq) {
+        uint32_t buffer_metadata_size;
+        cpaDcBufferListGetMetaSize(instance_, 1, &buffer_metadata_size);
+        cpaDcGetNumIntermediateBuffers(instance_, &num_intermediate_buffer_lists_);
+
+        if(num_intermediate_buffer_lists_) {
+            intermediate_buffer_array_ = AllocBlockArray<CpaBufferList*>(num_intermediate_buffer_lists_, 0);
+        }
+        for (int i = 0; i < num_intermediate_buffer_lists_; ++i) {
+            intermediate_buffer_array_[i] = AllocBlock<CpaBufferList>(0);
+            intermediate_buffer_array_[i]->pPrivateMetaData =
+                                                    AllocBlockArray<uint8_t>(buffer_metadata_size, 0);
+            intermediate_buffer_array_[i]->pBuffers = AllocBlock<CpaFlatBuffer>(0);
+            intermediate_buffer_array_[i]->pBuffers->pData =
+                                                    AllocBlockArray<uint8_t>(MAX_SAMPLE_BUFFER_SIZE, 0);
+            intermediate_buffer_array_[i]->pBuffers->dataLenInBytes = MAX_SAMPLE_BUFFER_SIZE;
+        }
+    }
+
+    cpaDcSetAddressTranslation(instance_, virt2Phys);
+}
+
+Instance::~Instance()
+{
+}
+
+CpaDcInstanceCapabilities Instance::GetCapabilities()
+{
+    CpaDcInstanceCapabilities caps{};
+    cpaDcQueryCapabilities(instance_, &caps);
+
+    return caps;
+}
+
+CpaInstanceInfo2 Instance::GetInfo()
+{
+    CpaInstanceInfo2 info{};
+    cpaDcInstanceGetInfo2(instance_, &info);
+
+    return info;
+}
+
+int Instance::Start()
+{
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (started_) {
+        return 0;
+    }
+
+    int ret = cpaDcStartInstance
+    (
+        instance_,
+        num_intermediate_buffer_lists_,
+        intermediate_buffer_array_
+    );
+    if (ret) {
+        return -1;
+    }
+    started_ = true;
+    return 0;
+}
+
+std::vector<std::shared_ptr<Instance>> Instance::Create()
+{
+    std::lock_guard<std::mutex> lock(g_instance_mutex);
+    uint16_t num_instances = 0;
+
+    if (!instances.empty()) {
+        return instances;
+    }
+
+    cpaDcGetNumInstances(&num_instances);
+
+    if (!num_instances) {
+        std::cerr << "No instances found\n";
+        return {};
+    }
+
+    std::vector<CpaInstanceHandle> handles(num_instances);
+    cpaDcGetInstances(num_instances, handles.data());
+
+    for(auto& handle: handles) {
+        instances.emplace_back(std::make_shared<Instance>(handle));
+    }
+
+    return instances;
+}
+
+}

deps/zlib/contrib/qat/qatzpp/qat_instance.hpp

@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2024 Intel Corporation. All rights reserved.
+ * Authors:
+ *  Gustavo A Espinoza   <gustavo.adolfo.espinoza.quintero@intel.com>
+ *                       <gustavoaespinozaq@hotmail.com>
+ *
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+#ifndef QATZPP_QAT_INSTANCE_HPP
+#define QATZPP_QAT_INSTANCE_HPP
+
+#include <qat/cpa_dc.h>
+
+#include <memory>
+#include <mutex>
+#include <vector>
+
+namespace qat
+{
+
+class Instance
+{
+public:
+    Instance(CpaInstanceHandle);
+    ~Instance();
+
+    CpaInstanceHandle GetHandle() { return instance_; }
+    CpaDcInstanceCapabilities GetCapabilities();
+    CpaInstanceInfo2 GetInfo();
+
+    int Start(void);
+    static std::vector<std::shared_ptr<Instance>> Create();
+private:
+
+    CpaInstanceHandle instance_;
+    uint16_t num_intermediate_buffer_lists_;
+    CpaBufferList **intermediate_buffer_array_;
+    bool started_;
+
+    std::mutex mutex_;
+};
+
+}
+
+#endif

deps/zlib/contrib/qat/qatzpp/qat_task.cpp

@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2024 Intel Corporation. All rights reserved.
+ * Authors:
+ *  Gustavo A Espinoza   <gustavo.adolfo.espinoza.quintero@intel.com>
+ *                       <gustavoaespinozaq@hotmail.com>
+ *
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+#include <qat/cpa.h>
+#include <qat/icp_sal_poll.h>
+
+#include "qat_task.hpp"
+
+namespace qat
+{
+
+QATTask::QATTask(std::shared_ptr<Instance> &qat_instance,
+    std::unique_ptr<IOBuffers> &&buffers,
+    std::unique_ptr<CpaDcRqResults> &&dc_results):
+    qat_instance_(qat_instance),
+    io_buffers_(std::move(buffers)),
+    dc_results_(std::move(dc_results)),
+    completed_(false)
+{
+}
+
+void QATTask::WaitCompletion()
+{
+    if (completed_) {
+        return;
+    }
+
+    while (!completed_) {
+        icp_sal_DcPollInstance(qat_instance_->GetHandle(), 0);
+    }
+}
+
+IOBuffers *QATTask::GetBuffers()
+{
+    return io_buffers_.get();
+}
+
+CpaDcRqResults *QATTask::GetResults()
+{
+    return dc_results_.get();
+}
+
+void dc_callback(void *callback_tag, CpaStatus status)
+{
+    if (!callback_tag) {
+        return;
+    }
+    // Ugly and dangerous
+    QATTask* task = static_cast<QATTask*>(callback_tag);
+    task->completed_ = true;
+}
+
+}

deps/zlib/contrib/qat/qatzpp/qat_task.hpp

@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2024 Intel Corporation. All rights reserved.
+ * Authors:
+ *  Gustavo A Espinoza   <gustavo.adolfo.espinoza.quintero@intel.com>
+ *                       <gustavoaespinozaq@hotmail.com>
+ *
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+#ifndef QATZPP_WORK_HPP
+#define QATZPP_WORK_HPP
+
+#include <qat/cpa.h>
+
+#include <memory>
+
+#include "io_buffers.h"
+
+namespace qat
+{
+
+class QATTask
+{
+public:
+    explicit QATTask(std::shared_ptr<Instance> &qat_instance,
+                std::unique_ptr<IOBuffers> &&,
+                std::unique_ptr<CpaDcRqResults> &&dc_results);
+
+    QATTask(QATTask &&) = delete;
+    QATTask& operator=(QATTask &&) = delete;
+
+    QATTask(const QATTask &) = delete;
+    QATTask &operator=(const QATTask &) = delete;
+
+    void WaitCompletion();
+
+    IOBuffers *GetBuffers();
+    CpaDcRqResults *GetResults();
+
+private:
+    bool completed_;
+
+    std::shared_ptr<Instance> qat_instance_;
+
+    std::unique_ptr<CpaDcRqResults> dc_results_;
+    std::unique_ptr<IOBuffers> io_buffers_;
+
+    friend void dc_callback(void *, CpaStatus);
+};
+
+void dc_callback(void*, CpaStatus);
+
+}
+
+#endif

deps/zlib/contrib/qat/qatzpp/session.cpp

@@ -0,0 +1,129 @@
+/*
+ * Copyright (C) 2024 Intel Corporation. All rights reserved.
+ * Authors:
+ *  Gustavo A Espinoza   <gustavo.adolfo.espinoza.quintero@intel.com>
+ *                       <gustavoaespinozaq@hotmail.com>
+ *
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+#include <iostream>
+#include <semaphore.h>
+
+#include "memory.hpp"
+#include "session.hpp"
+
+namespace qat
+{
+
+constexpr CpaDcHuffType kHuffType = CPA_DC_HT_FULL_DYNAMIC;
+
+DeflateSession::DeflateSession(
+    std::shared_ptr<Instance> &qat_instance,
+    CpaDcCompLvl comp_level, CpaDcChecksum checksum,
+    uint32_t numa_node):
+    qat_instance_(qat_instance)
+{
+    uint32_t session_size = 0;
+    uint32_t ctx_size = 0;
+
+    CpaDcSessionSetupData sd{};
+    sd.compLevel = comp_level;
+    sd.compType = CPA_DC_DEFLATE;
+    sd.huffType = kHuffType;
+    sd.autoSelectBestHuffmanTree = CPA_DC_ASB_UNCOMP_STATIC_DYNAMIC_WITH_STORED_HDRS;
+    sd.sessDirection = CPA_DC_DIR_COMBINED;
+    sd.sessState = CPA_DC_STATELESS;
+    sd.checksum = checksum;
+
+    cpaDcGetSessionSize(qat_instance_->GetHandle(), &sd, &session_size, &ctx_size);
+    session_ = AllocBlockArray<uint8_t>(session_size, numa_node);
+
+    cpaDcInitSession(
+        qat_instance_->GetHandle(),
+        session_,
+        &sd,
+        nullptr, // No context for stateless operations
+        &dc_callback
+    );
+
+}
+
+DeflateSession::~DeflateSession()
+{
+    if (session_) {
+        cpaDcRemoveSession(qat_instance_->GetHandle(), session_);
+        Free(session_);
+    }
+
+    session_ = nullptr;
+}
+
+std::unique_ptr<QATTask> DeflateSession::Deflate(
+    std::unique_ptr<IOBuffers> &&buffers,
+    bool flush_final)
+{
+    CpaDcOpData op_data{};
+    op_data.flushFlag = (flush_final) ?
+        CPA_DC_FLUSH_FINAL : CPA_DC_FLUSH_FULL;
+    op_data.compressAndVerify = CPA_TRUE;
+    op_data.inputSkipData.skipMode = CPA_DC_SKIP_DISABLED;
+    op_data.outputSkipData.skipMode = CPA_DC_SKIP_DISABLED;
+
+    auto task = std::make_unique<QATTask>(
+        qat_instance_, std::move(buffers),
+        std::make_unique<CpaDcRqResults>()
+    );
+
+    cpaDcCompressData2(
+        qat_instance_->GetHandle(),
+        session_,
+        &task->GetBuffers()->GetSrc()->list,
+        &task->GetBuffers()->GetDst()->list,
+        &op_data,
+        task->GetResults(),
+        static_cast<void*>(task.get())
+    );
+
+    return std::move(task);
+}
+
+std::unique_ptr<QATTask> DeflateSession::Inflate(std::unique_ptr<IOBuffers> &&buffers)
+{
+    CpaDcOpData op_data = {};
+    op_data.flushFlag = CPA_DC_FLUSH_FINAL;
+    op_data.compressAndVerify = CPA_TRUE;
+    op_data.inputSkipData.skipMode = CPA_DC_SKIP_DISABLED;
+    op_data.outputSkipData.skipMode = CPA_DC_SKIP_DISABLED;
+
+    auto task = std::make_unique<QATTask>(
+        qat_instance_, std::move(buffers),
+        std::make_unique<CpaDcRqResults>()
+    );
+
+    cpaDcDecompressData2(
+        qat_instance_->GetHandle(),
+        session_,
+        &task->GetBuffers()->GetSrc()->list,
+        &task->GetBuffers()->GetDst()->list,
+        &op_data,
+        task->GetResults(),
+        static_cast<void*>(task.get())
+    );
+
+    return std::move(task);
+}
+
+uint32_t DeflateSession::GetDeflateBound(uint32_t input_size)
+{
+    uint32_t output_size = 0;
+
+    cpaDcDeflateCompressBound(
+        qat_instance_->GetHandle(),
+        kHuffType,
+        input_size, &output_size
+    );
+
+    return output_size;
+}
+
+}

deps/zlib/contrib/qat/qatzpp/session.hpp

@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2024 Intel Corporation. All rights reserved.
+ * Authors:
+ *  Gustavo A Espinoza   <gustavo.adolfo.espinoza.quintero@intel.com>
+ *                       <gustavoaespinozaq@hotmail.com>
+ *
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+#ifndef QATZPP_SESSION_HPP
+#define QATZPP_SESSION_HPP
+
+#include <qat/cpa.h>
+#include <qat/cpa_dc.h>
+
+#include <memory>
+
+#include "io_buffers.h"
+#include "qat_task.hpp"
+
+namespace qat
+{
+
+class DeflateSession
+{
+public:
+    DeflateSession(
+        std::shared_ptr<Instance> &, CpaDcCompLvl,
+        CpaDcChecksum, uint32_t numa_node);
+    ~DeflateSession();
+
+    std::unique_ptr<QATTask> Deflate(std::unique_ptr<IOBuffers> &&buffers, bool flush_final);
+    std::unique_ptr<QATTask> Inflate(std::unique_ptr<IOBuffers> &&buffers);
+
+    uint32_t GetDeflateBound(uint32_t input_size);
+
+    std::shared_ptr<Instance> getInstance() { return qat_instance_; }
+
+private:
+    std::shared_ptr<Instance> qat_instance_;
+    CpaDcSessionHandle session_;
+};
+
+}
+
+#endif