diff --git a/KAESnappy/Makefile b/KAESnappy/Makefile index f498c5cd85fb9dee4cdee40e3860753533f0ea62..b982f4db744b70e54d2cd685b95d6e20224d5dad 100644 --- a/KAESnappy/Makefile +++ b/KAESnappy/Makefile @@ -17,10 +17,10 @@ ENGINE_INSTALL_PATH := /usr/local/kaesnappy CC=gcc -LIBNAME := libkaelz4.so +LIBNAME := libkaesnappy.so VERSION = 2.0.4 TARGET = ${LIBNAME}.${VERSION} -SOFTLINK = libkaelz4.so +SOFTLINK = libkaesnappy.so ifndef SILENCE SILENCE = @ @@ -67,7 +67,7 @@ OBJS = $(foreach x,$(SRCEXTS), \ .PHONY : all objs clean cleanall rebuild -all : $(TARGET) libkaelz4.a symlinks +all : $(TARGET) libkaesnappy.a symlinks symlinks : $(TARGET) @echo Creating symbolic links @@ -84,7 +84,7 @@ objs : $(OBJS) @echo compiling $(notdir $<) $(SILENCE) $(CC) -c $(CFLAGS) $(INCDIR) $(LDFLAGS) -o $@ $< -libkaelz4.a: $(OBJS) +libkaesnappy.a: $(OBJS) @echo compling static library @ar rcs $@ $^ @@ -104,7 +104,7 @@ clean : install : mkdir -p $(ENGINE_INSTALL_PATH)/include mkdir -p $(ENGINE_INSTALL_PATH)/lib - install -m 755 libkaelz4.a $(ENGINE_INSTALL_PATH)/lib + install -m 755 libkaesnappy.a $(ENGINE_INSTALL_PATH)/lib install -m 755 $(TARGET) $(ENGINE_INSTALL_PATH)/lib $(LN) $(ENGINE_INSTALL_PATH)/lib/$(TARGET) $(ENGINE_INSTALL_PATH)/lib/$(SOFTLINK) $(LN) $(ENGINE_INSTALL_PATH)/lib/$(TARGET) $(ENGINE_INSTALL_PATH)/lib/$(SOFTLINK).0 @@ -114,8 +114,8 @@ uninstall : $(RM) $(ENGINE_INSTALL_PATH)/lib/$(SOFTLINK) $(RM) $(ENGINE_INSTALL_PATH)/lib/$(SOFTLINK).0 $(RM) $(ENGINE_INSTALL_PATH)/lib/$(TARGET) - $(RM) $(ENGINE_INSTALL_PATH)/lib/libkaelz4.a + $(RM) $(ENGINE_INSTALL_PATH)/lib/libkaesnappy.a $(RM) $(ENGINE_INSTALL_PATH)/include/kaesnappy.h $(RM) $(ENGINE_INSTALL_PATH)/include/kaesnappy_log.h - $(RM) $(ENGINE_INSTALL_PATH)/include/lz4.h - $(RM) $(ENGINE_INSTALL_PATH)/include/lz4frame.h \ No newline at end of file + $(RM) $(ENGINE_INSTALL_PATH)/include/snappy.h + $(RM) $(ENGINE_INSTALL_PATH)/include/snappy-c.h \ No newline at end of file diff --git a/KAESnappy/build.sh b/KAESnappy/build.sh index f2b9b9731a72205df5ad07aa5e53c229a99d3d9d..ca0464a2b7fbd5bd64694981912e833c66878ce2 100644 --- a/KAESnappy/build.sh +++ b/KAESnappy/build.sh @@ -22,7 +22,7 @@ function Build_kaesnappy() cd "${SRC_PATH}" make clean && make make install - echo "install kaelz4" + echo "install kaesnappy" cd - rm -rf build @@ -34,13 +34,13 @@ function Build_kaesnappy() echo "build snappy success" } -function Dev_Build_kaelz4() +function Dev_Build_kaesnappy() { Target_snappy cd "${SRC_PATH}" make clean && make make install - echo "install kaelz4" + echo "install kaesnappy" cd - rm -rf build @@ -58,7 +58,7 @@ function Install_kaesnappy() cd "${SRC_PATH}" make clean && make make install - echo "install kaelz4" + echo "install kaesnappy" if [ -d "${SRC_PATH}"/open_source/snappy-1.1.10/ ]; then cd "${SRC_PATH}"/open_source/snappy-1.1.10/ @@ -88,7 +88,7 @@ function Uninstall_kaesnappy() fi fi - local kaesnappy_path=$(ls /usr/local/kaesnappy/lib | grep libkaelz4.so.${BUILDVERSION}) + local kaesnappy_path=$(ls /usr/local/kaesnappy/lib | grep libkaesnappy.so.${BUILDVERSION}) if [ -n "${kaesnappy_path}" ]; then if [ -d "${SRC_PATH}" ]; then cd "${SRC_PATH}" diff --git a/KAESnappy/open_source/kaesnappy_1_1_10.patch b/KAESnappy/open_source/kaesnappy_1_1_10.patch index 68b2d78971020b24f9d92f8f95ab11fef2398588..b1ed66d5e125844fb9686b277ed8de9bbaa3c655 100644 --- a/KAESnappy/open_source/kaesnappy_1_1_10.patch +++ b/KAESnappy/open_source/kaesnappy_1_1_10.patch @@ -1,9 +1,6 @@ -Binary files snappy-1.1.10/.vscode/.cache/clangd/wecode-cpp.db and snappy-1.1.10-KAE/.vscode/.cache/clangd/wecode-cpp.db differ -Binary files snappy-1.1.10/.vscode/tags-34.wecode-db and snappy-1.1.10-KAE/.vscode/tags-34.wecode-db differ -Binary files snappy-1.1.10/.vscode/tags-34.wecode-lock and snappy-1.1.10-KAE/.vscode/tags-34.wecode-lock differ diff -ruN snappy-1.1.10/CMakeLists.txt snappy-1.1.10-KAE/CMakeLists.txt --- snappy-1.1.10/CMakeLists.txt 2023-03-09 07:44:00.000000000 +0800 -+++ snappy-1.1.10-KAE/CMakeLists.txt 2025-09-01 22:42:04.359817000 +0800 ++++ snappy-1.1.10-KAE/CMakeLists.txt 2025-09-08 15:42:38.637547600 +0800 @@ -84,11 +84,11 @@ # BUILD_SHARED_LIBS is a standard CMake variable, but we declare it here to make @@ -40,7 +37,7 @@ diff -ruN snappy-1.1.10/CMakeLists.txt snappy-1.1.10-KAE/CMakeLists.txt +set_property(TARGET snappy + APPEND PROPERTY INSTALL_RPATH + /usr/local/kaesnappy/lib;/usr/local/lib) -+target_link_libraries(snappy PRIVATE :libkaelz4.so.2.0.4) ++target_link_libraries(snappy PRIVATE :libkaesnappy.so.2.0.4) + target_sources(snappy PRIVATE @@ -51,7 +48,7 @@ diff -ruN snappy-1.1.10/CMakeLists.txt snappy-1.1.10-KAE/CMakeLists.txt ) + + target_compile_definitions(snappy_unittest PRIVATE CONF_KAESNAPPY) -+ target_link_libraries(snappy_unittest snappy_test_support libkaelz4.so.2.0.4) ++ target_link_libraries(snappy_unittest snappy_test_support libkaesnappy.so.2.0.4) + target_include_directories(snappy_unittest PRIVATE + /usr/local/kaesnappy/include + ) @@ -72,7 +69,7 @@ diff -ruN snappy-1.1.10/CMakeLists.txt snappy-1.1.10-KAE/CMakeLists.txt - target_link_libraries(snappy_test_tool snappy_test_support) + + target_compile_definitions(snappy_test_tool PRIVATE CONF_KAESNAPPY) -+ target_link_libraries(snappy_test_tool snappy_test_support libkaelz4.so.2.0.4) ++ target_link_libraries(snappy_test_tool snappy_test_support libkaesnappy.so.2.0.4) + target_include_directories(snappy_test_tool PRIVATE + /usr/local/kaesnappy/include + ) @@ -90,7 +87,7 @@ diff -ruN snappy-1.1.10/CMakeLists.txt snappy-1.1.10-KAE/CMakeLists.txt target_link_libraries(snappy_benchmark snappy_test_support benchmark_main) + target_compile_definitions(snappy_benchmark PRIVATE CONF_KAESNAPPY) -+ target_link_libraries(snappy_benchmark snappy_test_support libkaelz4.so.2.0.4) ++ target_link_libraries(snappy_benchmark snappy_test_support libkaesnappy.so.2.0.4) + target_include_directories(snappy_benchmark PRIVATE + /usr/local/kaesnappy/include + ) @@ -104,152 +101,17 @@ diff -ruN snappy-1.1.10/CMakeLists.txt snappy-1.1.10-KAE/CMakeLists.txt # This project uses Google benchmark for benchmarking. set(BENCHMARK_ENABLE_TESTING OFF CACHE BOOL "" FORCE) set(BENCHMARK_ENABLE_EXCEPTIONS OFF CACHE BOOL "" FORCE) -diff -ruN snappy-1.1.10/lz4_accelerater.h snappy-1.1.10-KAE/lz4_accelerater.h ---- snappy-1.1.10/lz4_accelerater.h 1970-01-01 08:00:00.000000000 +0800 -+++ snappy-1.1.10-KAE/lz4_accelerater.h 2025-09-01 19:42:12.944666500 +0800 -@@ -0,0 +1,131 @@ -+/* * -+ * Copyright (c) Huawei Technologies Co., Ltd. 2023-2023. All rights reserved. -+ * Create: 2023-04 -+ */ -+ -+#ifndef LZ4_ACCELERATER_H -+#define LZ4_ACCELERATER_H -+ -+#include -+#include "stddef.h" -+#define NO_PREFETCH -+#define RAW_LZ4 -+ -+#define G_KZLPRIME5BYTES (889523592379ULL) -+#define G_KZLPRIME8BYTES (11400714785074694791ULL) -+ -+#ifndef KZL_FORCE_INLINE -+# ifdef _MSC_VER -+# define KZL_FORCE_INLINE static __forceinline -+# else -+# if defined (__cplusplus) || defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L /* C99 */ -+# ifdef __GNUC__ -+# define KZL_FORCE_INLINE static inline __attribute__((always_inline)) -+# else -+# define KZL_FORCE_INLINE static inline -+# endif -+# else -+# define KZL_FORCE_INLINE static -+# endif -+# endif -+#endif -+ -+#if defined(__GNUC__) && (__GNUC__ >= 4) -+# define KZL_MEMCPY_2(dst, src, size) __builtin_memcpy(dst, src, size) -+# define KZL_MEMCPY_4(dst, src, size) __builtin_memcpy(dst, src, size) -+# define KZL_MEMCPY_8(dst, src, size) vst1_u8((dst), vld1_u8(src)) -+# define KZL_MEMCPY_16(dst, src, size) vst1q_u8((dst), vld1q_u8(src)) -+# define KZL_MEMCPY_32(dst, src, size) vst1q_u8((dst), vld1q_u8(src)); vst1q_u8(((dst)+16), vld1q_u8(((src)+16))) -+# define KZL_MEMCPY_16X1(dst, src, size) vst1q_u64((dst), vld1q_u64(src)) -+# define KZL_MEMCPY_32X1(dst, src, size) vst1q_u64((dst), vld1q_u64(src)); \ -+ vst1q_u64(((dst)+16), vld1q_u64(((src)+16))) -+#endif -+ -+/* prefetch 321 -+ * can be disabled, by declaring NO_PREFETCH build macro */ -+#if defined(NO_PREFETCH) -+# define PREFETCH_L1(ptr) (void)(ptr) /* disabled */ -+# define PREFETCH_L2(ptr) (void)(ptr) /* disabled */ -+# define PREFETCH_L3(ptr) (void)(ptr) /* disabled */ -+#else -+# if defined(_MSC_VER) && (defined(_M_X64) || defined(_M_I86)) /* _mm_prefetch() is not defined outside of x86/x64 */ -+# include /* https://msdn.microsoft.com/fr-fr/library/84szxsww(v=vs.90).aspx */ -+# define PREFETCH_L1(ptr) _mm_prefetch((const char*)(ptr), _MM_HINT_T0) -+# define PREFETCH_L2(ptr) _mm_prefetch((const char*)(ptr), _MM_HINT_T1) -+# define PREFETCH_L2(ptr) _mm_prefetch((const char*)(ptr), _MM_HINT_T2) -+# elif defined(__GNUC__) && ((__GNUC__ >= 4) || ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 1))) -+# define PREFETCH_L1(ptr) __builtin_prefetch((ptr), 1 /* rw==write */, 3 /* locality */) -+# define PREFETCH_L2(ptr) __builtin_prefetch((ptr), 1 /* rw==write */, 2 /* locality */) -+# define PREFETCH_L3(ptr) __builtin_prefetch((ptr), 1 /* rw==write */, 1 /* locality */) -+# elif defined(__aarch64__) -+# define PREFETCH_L1(ptr) __asm__ __volatile__("prfm pldl1keep, %0" ::"Q"(*(ptr))) -+# define PREFETCH_L2(ptr) __asm__ __volatile__("prfm pldl2keep, %0" ::"Q"(*(ptr))) -+# define PREFETCH_L3(ptr) __asm__ __volatile__("prfm pldl3keep, %0" ::"Q"(*(ptr))) -+# else -+# define PREFETCH_L1(ptr) (void)(ptr) /* disabled */ -+# define PREFETCH_L2(ptr) (void)(ptr) /* disabled */ -+# define PREFETCH_L3(ptr) (void)(ptr) /* disabled */ -+# endif -+#endif /* NO_PREFETCH */ -+ -+#define L1_CACHELINE_SIZE 64 -+#define L2_CACHELINE_SIZE 64 -+#define L3_CACHELINE_SIZE 128 -+ -+#define PREFETCH_AREA_L1(p, s) { \ -+ const char* const ptr = (const char*)(p); \ -+ size_t const size = (size_t)(s); \ -+ size_t pos; \ -+ for (pos=0; pos> (HASH_SIZE - HashLogUsage)); -+} -+ -+KZL_FORCE_INLINE uint32_t KZL_BigEndianfastHash5(uint64_t sequence, uint8_t HashLogUsage) -+{ -+ // for data > 64KB -+ return (uint32_t)(((sequence >> SEQUENCE_MOVE) * G_KZLPRIME8BYTES) >> (HASH_SIZE - HashLogUsage)); -+} -+ -+void accerlerater(int srcSize, uint8_t *acceleration); -+void skipTrigger(int srcSize, uint8_t *skipStep); -+void PrefetchCpuCacheArea(const void* p, size_t s, CpuCacheType cacheType); -+ -+int PlatformIsSupport(void); -+ -+#endif diff -ruN snappy-1.1.10/snappy-internal.h snappy-1.1.10-KAE/snappy-internal.h --- snappy-1.1.10/snappy-internal.h 2023-03-09 07:44:00.000000000 +0800 -+++ snappy-1.1.10-KAE/snappy-internal.h 2025-09-01 19:42:12.945663100 +0800 ++++ snappy-1.1.10-KAE/snappy-internal.h 2025-09-04 15:10:21.196708100 +0800 @@ -40,6 +40,13 @@ #include #endif +#ifdef CONF_KAESNAPPY +extern "C" { -+ #include "kaelz4.h" -+ #include "kaelz4_log.h" ++ #include "kaesnappy.h" ++ #include "kaesnappy_log.h" +} +#endif + @@ -262,22 +124,22 @@ diff -ruN snappy-1.1.10/snappy-internal.h snappy-1.1.10-KAE/snappy-internal.h uint16_t* table, - const int table_size); + const int table_size, -+ LZ4_CCtx* cctx); ++ SNAPPY_CCtx* cctx); // Find the largest n such that // diff -ruN snappy-1.1.10/snappy.cc snappy-1.1.10-KAE/snappy.cc --- snappy-1.1.10/snappy.cc 2023-03-09 07:44:00.000000000 +0800 -+++ snappy-1.1.10-KAE/snappy.cc 2025-09-01 19:42:12.947656300 +0800 ++++ snappy-1.1.10-KAE/snappy.cc 2025-09-08 16:00:01.302849300 +0800 @@ -74,6 +74,14 @@ #define SNAPPY_PREFETCH(ptr) (void)(ptr) #endif +#ifdef CONF_KAESNAPPY +extern "C" { -+ #include "kaelz4.h" -+ #include "kaelz4_log.h" -+ #include "lz4_accelerater.h" ++ #include "kaesnappy.h" ++ #include "kaesnappy_log.h" ++ #include "snappy_accelerater.h" +} +#endif + @@ -313,11 +175,11 @@ diff -ruN snappy-1.1.10/snappy.cc snappy-1.1.10-KAE/snappy.cc namespace internal { char* CompressFragment(const char* input, size_t input_size, char* op, - uint16_t* table, const int table_size) { -+ uint16_t* table, const int table_size, LZ4_CCtx* cctx) { ++ uint16_t* table, const int table_size, SNAPPY_CCtx* cctx) { // "ip" is the input pointer, and "op" is the output pointer. const char* ip = input; assert(input_size <= kBlockSize); -@@ -787,6 +797,85 @@ +@@ -787,6 +797,86 @@ const char* base_ip = ip; const size_t kInputMarginBytes = 15; @@ -327,11 +189,11 @@ diff -ruN snappy-1.1.10/snappy.cc snappy-1.1.10-KAE/snappy.cc + goto _softVersion; + } + // 硬件压缩 -+ ++ + if (SNAPPY_PREDICT_TRUE(input_size >= kInputMarginBytes)) { + // 硬件压缩 -+ LZ4_CCtx& ctxBody = *cctx; -+ int result = kaelz4_compress(&ctxBody, input, input_size); ++ SNAPPY_CCtx& ctxBody = *cctx; ++ int result = kaesnappy_compress(&ctxBody, input, input_size); + if (result) { + printf("Snappy kaealz4_compress failed\n"); + return NULL; @@ -387,7 +249,7 @@ diff -ruN snappy-1.1.10/snappy.cc snappy-1.1.10-KAE/snappy.cc + //释放硬件资源 + // ctxBody.seqStore.lit = ctxBody.seqStore.litStart = NULL; + // ctxBody.seqStore.sequences = ctxBody.seqStore.sequencesStart = NULL; -+ // kaelz4_release(&ctxBody); ++ // kaesnappy_release(&ctxBody); + } + + //处理尾部数据 @@ -396,6 +258,7 @@ diff -ruN snappy-1.1.10/snappy.cc snappy-1.1.10-KAE/snappy.cc + // printf("last litLength:%d,last literal: %.*s \n", ip_end - ip, ip_end - ip, ip); + } + ++ + return op; + +_softVersion: @@ -403,7 +266,7 @@ diff -ruN snappy-1.1.10/snappy.cc snappy-1.1.10-KAE/snappy.cc if (SNAPPY_PREDICT_TRUE(input_size >= kInputMarginBytes)) { const char* ip_limit = input + input_size - kInputMarginBytes; -@@ -1616,7 +1705,45 @@ +@@ -1616,7 +1706,45 @@ writer->Append(ulength, p - ulength); written += (p - ulength); @@ -419,8 +282,8 @@ diff -ruN snappy-1.1.10/snappy.cc snappy-1.1.10-KAE/snappy.cc + internal::WorkingMemory wmem(N); +#ifdef CONF_KAESNAPPY -+ LZ4_CCtx ctxBody; -+ LZ4_CCtx* cctx = &ctxBody; ++ SNAPPY_CCtx ctxBody; ++ SNAPPY_CCtx* cctx = &ctxBody; + ctxBody.kaeInited = 0; + ctxBody.kaeFrameMode = 1; // 相当于每个都强刷 + ctxBody.kaeConfig = NULL; @@ -438,7 +301,7 @@ diff -ruN snappy-1.1.10/snappy.cc snappy-1.1.10-KAE/snappy.cc + ctxBody.seqnum = 0; + + int ret; -+ ret = kaelz4_init(&ctxBody); ++ ret = kaesnappy_init(&ctxBody); + if (ret == 0) { + ctxBody.kaeInited = 1; + } else { @@ -449,7 +312,7 @@ diff -ruN snappy-1.1.10/snappy.cc snappy-1.1.10-KAE/snappy.cc while (N > 0) { // Get next block to compress (without copying if possible) -@@ -1652,7 +1779,6 @@ +@@ -1652,7 +1780,6 @@ // Get encoding table for compression int table_size; uint16_t* table = wmem.GetHashTable(num_to_read, &table_size); @@ -457,7 +320,7 @@ diff -ruN snappy-1.1.10/snappy.cc snappy-1.1.10-KAE/snappy.cc // Compress input_fragment and append to dest const int max_output = MaxCompressedLength(num_to_read); -@@ -1664,14 +1790,18 @@ +@@ -1664,14 +1791,18 @@ // scratch_output[] region is big enough for this iteration. char* dest = writer->GetAppendBuffer(max_output, wmem.GetScratchOutput()); char* end = internal::CompressFragment(fragment, fragment_size, dest, table, @@ -473,14 +336,149 @@ diff -ruN snappy-1.1.10/snappy.cc snappy-1.1.10-KAE/snappy.cc +#ifdef CONF_KAESNAPPY + ctxBody.seqStore.lit = ctxBody.seqStore.litStart = NULL; + ctxBody.seqStore.sequences = ctxBody.seqStore.sequencesStart = NULL; -+ kaelz4_release(&ctxBody); ++ kaesnappy_release(&ctxBody); +#endif Report("snappy_compress", written, uncompressed_size); return written; +diff -ruN snappy-1.1.10/snappy_accelerater.h snappy-1.1.10-KAE/snappy_accelerater.h +--- snappy-1.1.10/snappy_accelerater.h 1970-01-01 08:00:00.000000000 +0800 ++++ snappy-1.1.10-KAE/snappy_accelerater.h 2025-09-08 16:02:45.017369300 +0800 +@@ -0,0 +1,131 @@ ++/* * ++ * Copyright (c) Huawei Technologies Co., Ltd. 2023-2023. All rights reserved. ++ * Create: 2023-04 ++ */ ++ ++#ifndef SNAPPY_ACCELERATER_H ++#define SNAPPY_ACCELERATER_H ++ ++#include ++#include "stddef.h" ++#define NO_PREFETCH ++#define RAW_SNAPPY ++ ++#define G_KZLPRIME5BYTES (889523592379ULL) ++#define G_KZLPRIME8BYTES (11400714785074694791ULL) ++ ++#ifndef KZL_FORCE_INLINE ++# ifdef _MSC_VER ++# define KZL_FORCE_INLINE static __forceinline ++# else ++# if defined (__cplusplus) || defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L /* C99 */ ++# ifdef __GNUC__ ++# define KZL_FORCE_INLINE static inline __attribute__((always_inline)) ++# else ++# define KZL_FORCE_INLINE static inline ++# endif ++# else ++# define KZL_FORCE_INLINE static ++# endif ++# endif ++#endif ++ ++#if defined(__GNUC__) && (__GNUC__ >= 4) ++# define KZL_MEMCPY_2(dst, src, size) __builtin_memcpy(dst, src, size) ++# define KZL_MEMCPY_4(dst, src, size) __builtin_memcpy(dst, src, size) ++# define KZL_MEMCPY_8(dst, src, size) vst1_u8((dst), vld1_u8(src)) ++# define KZL_MEMCPY_16(dst, src, size) vst1q_u8((dst), vld1q_u8(src)) ++# define KZL_MEMCPY_32(dst, src, size) vst1q_u8((dst), vld1q_u8(src)); vst1q_u8(((dst)+16), vld1q_u8(((src)+16))) ++# define KZL_MEMCPY_16X1(dst, src, size) vst1q_u64((dst), vld1q_u64(src)) ++# define KZL_MEMCPY_32X1(dst, src, size) vst1q_u64((dst), vld1q_u64(src)); \ ++ vst1q_u64(((dst)+16), vld1q_u64(((src)+16))) ++#endif ++ ++/* prefetch 321 ++ * can be disabled, by declaring NO_PREFETCH build macro */ ++#if defined(NO_PREFETCH) ++# define PREFETCH_L1(ptr) (void)(ptr) /* disabled */ ++# define PREFETCH_L2(ptr) (void)(ptr) /* disabled */ ++# define PREFETCH_L3(ptr) (void)(ptr) /* disabled */ ++#else ++# if defined(_MSC_VER) && (defined(_M_X64) || defined(_M_I86)) /* _mm_prefetch() is not defined outside of x86/x64 */ ++# include /* https://msdn.microsoft.com/fr-fr/library/84szxsww(v=vs.90).aspx */ ++# define PREFETCH_L1(ptr) _mm_prefetch((const char*)(ptr), _MM_HINT_T0) ++# define PREFETCH_L2(ptr) _mm_prefetch((const char*)(ptr), _MM_HINT_T1) ++# define PREFETCH_L2(ptr) _mm_prefetch((const char*)(ptr), _MM_HINT_T2) ++# elif defined(__GNUC__) && ((__GNUC__ >= 4) || ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 1))) ++# define PREFETCH_L1(ptr) __builtin_prefetch((ptr), 1 /* rw==write */, 3 /* locality */) ++# define PREFETCH_L2(ptr) __builtin_prefetch((ptr), 1 /* rw==write */, 2 /* locality */) ++# define PREFETCH_L3(ptr) __builtin_prefetch((ptr), 1 /* rw==write */, 1 /* locality */) ++# elif defined(__aarch64__) ++# define PREFETCH_L1(ptr) __asm__ __volatile__("prfm pldl1keep, %0" ::"Q"(*(ptr))) ++# define PREFETCH_L2(ptr) __asm__ __volatile__("prfm pldl2keep, %0" ::"Q"(*(ptr))) ++# define PREFETCH_L3(ptr) __asm__ __volatile__("prfm pldl3keep, %0" ::"Q"(*(ptr))) ++# else ++# define PREFETCH_L1(ptr) (void)(ptr) /* disabled */ ++# define PREFETCH_L2(ptr) (void)(ptr) /* disabled */ ++# define PREFETCH_L3(ptr) (void)(ptr) /* disabled */ ++# endif ++#endif /* NO_PREFETCH */ ++ ++#define L1_CACHELINE_SIZE 64 ++#define L2_CACHELINE_SIZE 64 ++#define L3_CACHELINE_SIZE 128 ++ ++#define PREFETCH_AREA_L1(p, s) { \ ++ const char* const ptr = (const char*)(p); \ ++ size_t const size = (size_t)(s); \ ++ size_t pos; \ ++ for (pos=0; pos> (HASH_SIZE - HashLogUsage)); ++} ++ ++KZL_FORCE_INLINE uint32_t KZL_BigEndianfastHash5(uint64_t sequence, uint8_t HashLogUsage) ++{ ++ // for data > 64KB ++ return (uint32_t)(((sequence >> SEQUENCE_MOVE) * G_KZLPRIME8BYTES) >> (HASH_SIZE - HashLogUsage)); ++} ++ ++void accerlerater(int srcSize, uint8_t *acceleration); ++void skipTrigger(int srcSize, uint8_t *skipStep); ++void PrefetchCpuCacheArea(const void* p, size_t s, CpuCacheType cacheType); ++ ++int PlatformIsSupport(void); ++ ++#endif diff -ruN snappy-1.1.10/snappy_unittest.cc snappy-1.1.10-KAE/snappy_unittest.cc --- snappy-1.1.10/snappy_unittest.cc 2023-03-09 07:44:00.000000000 +0800 -+++ snappy-1.1.10-KAE/snappy_unittest.cc 2025-09-01 19:42:12.949650100 +0800 ++++ snappy-1.1.10-KAE/snappy_unittest.cc 2025-09-03 15:55:26.864334600 +0800 @@ -225,7 +225,7 @@ compressed.resize(prefix.size()+snappy::MaxCompressedLength(input.size())); char* dest = string_as_array(&compressed) + prefix.size(); diff --git a/KAESnappy/src/kaesnappy_adapter.c b/KAESnappy/src/kaesnappy_adapter.c index 8b03ba841c0a415eee2b026808c2fab87e134fbb..994db18b747960d4e4b05148e75a8a4dc56f766d 100644 --- a/KAESnappy/src/kaesnappy_adapter.c +++ b/KAESnappy/src/kaesnappy_adapter.c @@ -15,7 +15,7 @@ #include "kaesnappy_log.h" #include "uadk/wd.h" -lz4_task_queues g_task_queues = {0}; +snappy_task_queues g_task_queues = {0}; pthread_mutex_t g_task_queue_init_mutex = PTHREAD_MUTEX_INITIALIZER; pthread_mutex_t g_task_queue_mutex[MAX_TASK_NUM] = { PTHREAD_MUTEX_INITIALIZER }; static struct timespec polling_timeout = { 1, 0 }; // 1秒超时 @@ -47,7 +47,7 @@ static void uadk_get_accel_platform(void) // hardware don't support, use zstd original interface g_platform = HW_NONE; end: - US_INFO("kaelz4 v%d inited!\n", g_platform); + US_INFO("kaesnappy v%d inited!\n", g_platform); } int kaesnappy_init(SNAPPY_CCtx* zc) @@ -60,10 +60,10 @@ int kaesnappy_init(SNAPPY_CCtx* zc) case HW_NONE: break; case HW_V1: - ret = kaelz4_init_v1(zc); + ret = kaesnappy_init_v1(zc); break; case HW_V2: - ret = kaelz4_init_v2(zc); + ret = kaesnappy_init_v2(zc); break; default: break; @@ -81,7 +81,7 @@ void kaesnappy_reset(SNAPPY_CCtx* zc) case HW_NONE: break; case HW_V1: - kaelz4_reset_v1(zc); + kaesnappy_reset_v1(zc); break; case HW_V2: break; @@ -100,15 +100,15 @@ void kaesnappy_release(SNAPPY_CCtx* zc) case HW_NONE: break; case HW_V1: - kaelz4_release_v1(zc); + kaesnappy_release_v1(zc); break; case HW_V2: - kaelz4_release_v2(zc); + kaesnappy_release_v2(zc); break; default: break; } - US_INFO("kaelz4_released"); + US_INFO("kaesnappy_released"); } void kaesnappy_setstatus(SNAPPY_CCtx* zc, unsigned int status) @@ -120,15 +120,15 @@ void kaesnappy_setstatus(SNAPPY_CCtx* zc, unsigned int status) case HW_NONE: break; case HW_V1: - kaelz4_setstatus_v1(zc, status); + kaesnappy_setstatus_v1(zc, status); break; case HW_V2: - kaelz4_setstatus_v2(zc, status); + kaesnappy_setstatus_v2(zc, status); break; default: break; } - US_INFO("kaelz4_set blk_type %d\n", status); + US_INFO("kaesnappy_set blk_type %d\n", status); } int kaesnappy_compress(SNAPPY_CCtx* zc, const void* src, size_t srcSize) @@ -141,10 +141,10 @@ int kaesnappy_compress(SNAPPY_CCtx* zc, const void* src, size_t srcSize) case HW_NONE: break; case HW_V1: - ret = kaelz4_compress_v1(zc, src, srcSize); + ret = kaesnappy_compress_v1(zc, src, srcSize); break; case HW_V2: - ret = kaelz4_compress_v2(zc, src, srcSize); + ret = kaesnappy_compress_v2(zc, src, srcSize); break; default: break; @@ -224,9 +224,9 @@ static void set_cpu_affinity_for_child(int i) } } -static void kaelz4_dequeue_process(lz4_task_queue *task_queue, int budget) +static void kaesnappy_dequeue_process(snappy_task_queue *task_queue, int budget) { - US_DEBUG("do kaelz4_dequeue_process. budget: %d", budget); + US_DEBUG("do kaesnappy_dequeue_process. budget: %d", budget); int cnt = 0; // 等待任务 while (task_queue->pi != task_queue->ci && cnt < budget) { @@ -235,19 +235,19 @@ static void kaelz4_dequeue_process(lz4_task_queue *task_queue, int budget) if (task_queue->stop) { break; } - if (kaelz4_async_is_thread_do_comp_full() == 1) { + if (kaesnappy_async_is_thread_do_comp_full() == 1) { break; } // 获取任务 size_t ci = task_queue->ci; - lz4_async_task_t task; + snappy_async_task_t task; task = task_queue->tasks[ci]; // 更新 ci，复用空闲位置 - task_queue->ci = (task_queue->ci + 1) % KAELZ4_TASK_QUEUE_DEPTH; + task_queue->ci = (task_queue->ci + 1) % KAEsnappy_TASK_QUEUE_DEPTH; // 执行压缩操作 - kaelz4_compress_async(task.src, task.dst, task.callback, task.result, + kaesnappy_compress_async(task.src, task.dst, task.callback, task.result, task.data_format, &task.preferences); cnt++; } @@ -256,14 +256,14 @@ static void kaelz4_dequeue_process(lz4_task_queue *task_queue, int budget) static void *compress_thread_func(void *arg) { - lz4_task_queue *task_queue = arg; + snappy_task_queue *task_queue = arg; struct timespec timeout; int ret = 0; int enter_idle = 0; set_cpu_affinity_for_child(task_queue->index); - kaelz4_async_init(&task_queue->stop, g_task_queues.sw_compress, g_task_queues.sw_compress_frame); + kaesnappy_async_init(&task_queue->stop, g_task_queues.sw_compress, g_task_queues.sw_compress_frame); while (1) { // 等待任务 @@ -278,7 +278,7 @@ static void *compress_thread_func(void *arg) } if (unlikely(check_time_out(&timeout))) { - kaelz4_ctx_clear(); + kaesnappy_ctx_clear(); sem_wait(&task_queue->sem); } } @@ -289,21 +289,21 @@ static void *compress_thread_func(void *arg) enter_idle = 0; - if (!kaelz4_async_is_thread_do_comp_full()) { - kaelz4_dequeue_process(task_queue, ASYNC_DEQUEUE_PROCESS_DEFAULT_BUDGET); + if (!kaesnappy_async_is_thread_do_comp_full()) { + kaesnappy_dequeue_process(task_queue, ASYNC_DEQUEUE_PROCESS_DEFAULT_BUDGET); } - ret = kaelz4_async_compress_polling(ASYNC_POLLING_DEFAULT_BUDGET); + ret = kaesnappy_async_compress_polling(ASYNC_POLLING_DEFAULT_BUDGET); } exit_thread: - kaelz4_async_deinit(); + kaesnappy_async_deinit(); return NULL; } static void init_env_config() { - char *task_queue_num = getenv("KAE_LZ4_ASYNC_THREAD_NUM"); + char *task_queue_num = getenv("KAE_SNAPPY_ASYNC_THREAD_NUM"); if (task_queue_num != NULL) { g_task_queues.num = atoi(task_queue_num); if (g_task_queues.num > MAX_TASK_NUM) { @@ -322,9 +322,9 @@ void async_thread_constructor(void) init_env_config(); } -static int kaelz4_task_queue_init(lz4_task_queue *task_queue, int index) +static int kaesnappy_task_queue_init(snappy_task_queue *task_queue, int index) { - task_queue->tasks = malloc(KAELZ4_TASK_QUEUE_DEPTH * sizeof(lz4_async_task_t)); + task_queue->tasks = malloc(KAEsnappy_TASK_QUEUE_DEPTH * sizeof(snappy_async_task_t)); if (task_queue->tasks == NULL) { return KAE_SNAPPY_ALLOC_FAIL; } @@ -343,7 +343,7 @@ static int kaelz4_task_queue_init(lz4_task_queue *task_queue, int index) return KAE_SNAPPY_SUCC; } -static void kaelz4_task_queue_free(lz4_task_queue *task_queue) +static void kaesnappy_task_queue_free(snappy_task_queue *task_queue) { pthread_mutex_lock(task_queue->mutex); task_queue->stop = 1; @@ -355,7 +355,7 @@ static void kaelz4_task_queue_free(lz4_task_queue *task_queue) pthread_mutex_unlock(task_queue->mutex); } -static int kaelz4_task_queues_init(int task_queue_num) +static int kaesnappy_task_queues_init(int task_queue_num) { int i; @@ -368,7 +368,7 @@ static int kaelz4_task_queues_init(int task_queue_num) } for (i = 0; i < g_task_queues.num; i++) { - if (kaelz4_task_queue_init(&g_task_queues.task_queue[i], i) != 0) + if (kaesnappy_task_queue_init(&g_task_queues.task_queue[i], i) != 0) goto task_queue_free; } @@ -376,7 +376,7 @@ static int kaelz4_task_queues_init(int task_queue_num) task_queue_free: while (i--) { - kaelz4_task_queue_free(&g_task_queues.task_queue[i]); + kaesnappy_task_queue_free(&g_task_queues.task_queue[i]); } return KAE_SNAPPY_INIT_FAIL; } @@ -388,7 +388,7 @@ int KAESNAPPY_async_compress_init(sw_compress_fn sw_compress, sw_compress_frame_ if (g_task_queues.init == 0) { g_task_queues.sw_compress = sw_compress; g_task_queues.sw_compress_frame = sw_compress_frame; - ret = kaelz4_task_queues_init(KAELZ4_TASK_THREAD_NUM); + ret = kaesnappy_task_queues_init(KAESNAPPY_TASK_THREAD_NUM); if (ret != 0) { g_task_queues.init = 0; pthread_mutex_unlock(&g_task_queue_init_mutex); @@ -410,18 +410,18 @@ void KAESNAPPY_teardown_async_compress(void) g_task_queues.init = 0; for (int i = 0; i < g_task_queues.num; i++) { - kaelz4_task_queue_free(&g_task_queues.task_queue[i]); + kaesnappy_task_queue_free(&g_task_queues.task_queue[i]); } pthread_mutex_unlock(&g_task_queue_init_mutex); return; } -static inline int kaelz4_enqueue(lz4_task_queue *task_queue, lz4_async_task_t *task) +static inline int kaesnappy_enqueue(snappy_task_queue *task_queue, snappy_async_task_t *task) { unsigned int cnt = 0; pthread_mutex_lock(task_queue->mutex); - while ((task_queue->pi + 1) % KAELZ4_TASK_QUEUE_DEPTH == task_queue->ci) { + while ((task_queue->pi + 1) % KAEsnappy_TASK_QUEUE_DEPTH == task_queue->ci) { pthread_mutex_unlock(task_queue->mutex); if (cnt > ENQUEUE_TIME_OUT_US) { return KAE_SNAPPY_ALLOC_FAIL; @@ -440,19 +440,19 @@ static inline int kaelz4_enqueue(lz4_task_queue *task_queue, lz4_async_task_t *t size_t task_index = task_queue->pi; task_queue->tasks[task_index] = *task; wmb(); - task_queue->pi = (task_queue->pi + 1) % KAELZ4_TASK_QUEUE_DEPTH; + task_queue->pi = (task_queue->pi + 1) % KAEsnappy_TASK_QUEUE_DEPTH; sem_post(&task_queue->sem); pthread_mutex_unlock(task_queue->mutex); return 0; } -static unsigned int kaelz4_get_queue_id(void) +static unsigned int kaesnappy_get_queue_id(void) { unsigned int index = 0; unsigned int min = 0xFFFFFFFF; for (int i = 0; i < g_task_queues.num; i++) { - unsigned int depth = (g_task_queues.task_queue[i].pi + KAELZ4_TASK_QUEUE_DEPTH - g_task_queues.task_queue[i].ci) % KAELZ4_TASK_QUEUE_DEPTH; + unsigned int depth = (g_task_queues.task_queue[i].pi + KAEsnappy_TASK_QUEUE_DEPTH - g_task_queues.task_queue[i].ci) % KAEsnappy_TASK_QUEUE_DEPTH; if (min > depth) { min = depth; index = i; @@ -463,7 +463,7 @@ static unsigned int kaelz4_get_queue_id(void) } return index; } -static int kaelz4_async_do_comp(const void *src, void *dst, +static int kaesnappy_async_do_comp(const void *src, void *dst, snappy_async_callback callback, struct kaesnappy_result *result, enum kae_snappy_async_data_format data_format, const int* preferences_ptr) { @@ -475,8 +475,8 @@ static int kaelz4_async_do_comp(const void *src, void *dst, } // 添加任务到队列 - unsigned int index = kaelz4_get_queue_id(); - lz4_async_task_t task = {0}; + unsigned int index = kaesnappy_get_queue_id(); + snappy_async_task_t task = {0}; task.src = src; task.dst = dst; task.callback = callback; @@ -486,7 +486,7 @@ static int kaelz4_async_do_comp(const void *src, void *dst, task.preferences = *preferences_ptr; } - return kaelz4_enqueue(&g_task_queues.task_queue[index], &task); + return kaesnappy_enqueue(&g_task_queues.task_queue[index], &task); } int KAESNAPPY_compress_async(const void *src, void *dst, snappy_async_callback callback, @@ -497,9 +497,9 @@ int KAESNAPPY_compress_async(const void *src, void *dst, snappy_async_callback c } if (result->src_size <= SMALL_BLOCK_SIZE) { - return kaelz4_async_do_comp(src, dst, callback, result, KAESNAPPY_ASYNC_SMALL_BLOCK, NULL); + return kaesnappy_async_do_comp(src, dst, callback, result, KAESNAPPY_ASYNC_SMALL_BLOCK, NULL); } - return kaelz4_async_do_comp(src, dst, callback, result, KAESNAPPY_ASYNC_BLOCK, NULL); + return kaesnappy_async_do_comp(src, dst, callback, result, KAESNAPPY_ASYNC_BLOCK, NULL); } diff --git a/KAESnappy/src/kaesnappy_adapter.h b/KAESnappy/src/kaesnappy_adapter.h index 1f8032d806b7f6e2fc78f6e4327575e94032d53e..74ae777114ad8e640cef9f1caae940c47d8bab5c 100644 --- a/KAESnappy/src/kaesnappy_adapter.h +++ b/KAESnappy/src/kaesnappy_adapter.h @@ -18,8 +18,8 @@ enum { }; #define MAX_TASK_NUM 32 -#define KAELZ4_TASK_THREAD_NUM 12 -#define KAELZ4_TASK_QUEUE_DEPTH 1024 +#define KAESNAPPY_TASK_THREAD_NUM 12 +#define KAEsnappy_TASK_QUEUE_DEPTH 1024 #define ENQUEUE_TIME_OUT_US 1000000 #define SMALL_BLOCK_SIZE (64 * 1024) #define ASYNC_DEQUEUE_PROCESS_DEFAULT_BUDGET 3 @@ -32,10 +32,10 @@ typedef struct { struct kaesnappy_result *result; enum kae_snappy_async_data_format data_format; int preferences; -} lz4_async_task_t; +} snappy_async_task_t; typedef struct { - lz4_async_task_t *tasks; + snappy_async_task_t *tasks; volatile size_t pi; // pi volatile size_t ci; // ci pthread_mutex_t *mutex; // 保护tasks资源的多线程互斥锁 @@ -44,34 +44,34 @@ typedef struct { pthread_t worker_thread; volatile int stop; // 用于停止线程的标志 int index; -} lz4_task_queue; +} snappy_task_queue; typedef struct { - lz4_task_queue task_queue[MAX_TASK_NUM]; + snappy_task_queue task_queue[MAX_TASK_NUM]; sw_compress_fn sw_compress; sw_compress_frame_fn sw_compress_frame; int num; volatile int init; -} lz4_task_queues; +} snappy_task_queues; -int kaelz4_init_v1(SNAPPY_CCtx* zc); -void kaelz4_reset_v1(SNAPPY_CCtx* zc); -void kaelz4_release_v1(SNAPPY_CCtx* zc); -void kaelz4_setstatus_v1(SNAPPY_CCtx* zc, unsigned int status); -int kaelz4_compress_v1(SNAPPY_CCtx* zc, const void* src, size_t srcSize); -void kaelz4_compress_async(const void *src, void *dst, +int kaesnappy_init_v1(SNAPPY_CCtx* zc); +void kaesnappy_reset_v1(SNAPPY_CCtx* zc); +void kaesnappy_release_v1(SNAPPY_CCtx* zc); +void kaesnappy_setstatus_v1(SNAPPY_CCtx* zc, unsigned int status); +int kaesnappy_compress_v1(SNAPPY_CCtx* zc, const void* src, size_t srcSize); +void kaesnappy_compress_async(const void *src, void *dst, snappy_async_callback callback, struct kaesnappy_result *result, enum kae_snappy_async_data_format data_format, const int *ptr); -int kaelz4_async_compress_polling(int budget); +int kaesnappy_async_compress_polling(int budget); -int kaelz4_init_v2(SNAPPY_CCtx* zc); -void kaelz4_release_v2(SNAPPY_CCtx* zc); -void kaelz4_setstatus_v2(SNAPPY_CCtx* zc, unsigned int status); -int kaelz4_compress_v2(SNAPPY_CCtx* zc, const void* src, size_t srcSize); +int kaesnappy_init_v2(SNAPPY_CCtx* zc); +void kaesnappy_release_v2(SNAPPY_CCtx* zc); +void kaesnappy_setstatus_v2(SNAPPY_CCtx* zc, unsigned int status); +int kaesnappy_compress_v2(SNAPPY_CCtx* zc, const void* src, size_t srcSize); int wd_get_available_dev_num(const char* alogrithm); -int kaelz4_async_is_thread_do_comp_full(); -void kaelz4_async_init(volatile int *stop, sw_compress_fn sw_compress, sw_compress_frame_fn sw_compress_frame); -void kaelz4_async_deinit(void); -void kaelz4_ctx_clear(void); +int kaesnappy_async_is_thread_do_comp_full(); +void kaesnappy_async_init(volatile int *stop, sw_compress_fn sw_compress, sw_compress_frame_fn sw_compress_frame); +void kaesnappy_async_deinit(void); +void kaesnappy_ctx_clear(void); #endif \ No newline at end of file diff --git a/KAESnappy/src/utils/kaesnappy_common.c b/KAESnappy/src/utils/kaesnappy_common.c index ba665763294aa6aa5d89121fa64727dd4ec7a469..18ace92a4e9d9233fd7f3621a89dc6363a32d1e2 100644 --- a/KAESnappy/src/utils/kaesnappy_common.c +++ b/KAESnappy/src/utils/kaesnappy_common.c @@ -67,8 +67,8 @@ HIDDEN_API void CONSTRUCTOR KaeSnappyInit(void) return; } - if (KaeSnappyDetect() != CPU_HISILICOM_V2) { - fprintf(stderr, "KAEsnappy only support in V2, please check CPU ID.\n"); + if (KaeSnappyDetect() == CPU_HISILICOM_V1 || KaeSnappyDetect() == CPU_UNKNOW) { + fprintf(stderr, "KAEsnappy only support in V2+, please check CPU ID.\n"); abort(); } g_kaesnappyInitialized = 1; diff --git a/KAESnappy/src/v1/kaesnappy_comp.c b/KAESnappy/src/v1/kaesnappy_comp.c index 94fc16ef9706523ed6eb8c9d2955980d195cae0a..6d026402769f15abfdc67f50d59117abe41dc385 100644 --- a/KAESnappy/src/v1/kaesnappy_comp.c +++ b/KAESnappy/src/v1/kaesnappy_comp.c @@ -5,76 +5,76 @@ * @Date: 2024-02-26 * @LastEditTime: 2024-03-28 */ -#include +#include #include "kaesnappy_ctx.h" #include "kaesnappy_comp.h" #include "kaesnappy_log.h" #include -__thread struct kaelz4_async_ctrl g_async_ctrl = {0}; +__thread struct kaesnappy_async_ctrl g_async_ctrl = {0}; -void kaelz4_setstatus_v1(SNAPPY_CCtx* zc, unsigned int status) +void kaesnappy_setstatus_v1(SNAPPY_CCtx* zc, unsigned int status) { - kaelz4_ctx_t* kaelz4_ctx = (kaelz4_ctx_t*)zc->kaeConfig; - if (kaelz4_ctx) { - kaelz4_ctx->lz4_data.blk_type = status; - US_DEBUG("kaelz4 set status %u", status); + kaesnappy_ctx_t* kaesnappy_ctx = (kaesnappy_ctx_t*)zc->kaeConfig; + if (kaesnappy_ctx) { + kaesnappy_ctx->snappy_data.blk_type = status; + US_DEBUG("kaesnappy set status %u", status); } } -static int kaelz4_data_parsing(SNAPPY_CCtx* zc, kaelz4_ctx_t* config) +static int kaesnappy_data_parsing(SNAPPY_CCtx* zc, kaesnappy_ctx_t* config) { - if (!config->lz4_data.literals_start || !config->lz4_data.sequences_start) { - US_ERR("lz4 literals or sequences start is NULL!\n"); + if (!config->snappy_data.literals_start || !config->snappy_data.sequences_start) { + US_ERR("snappy literals or sequences start is NULL!\n"); return KAE_SNAPPY_INVAL_PARA; } - zc->seqStore.litStart = config->lz4_data.literals_start; + zc->seqStore.litStart = config->snappy_data.literals_start; zc->seqStore.lit = zc->seqStore.litStart; - zc->seqStore.lit += config->lz4_data.lit_num; + zc->seqStore.lit += config->snappy_data.lit_num; - zc->seqStore.sequencesStart = config->lz4_data.sequences_start; + zc->seqStore.sequencesStart = config->snappy_data.sequences_start; zc->seqStore.sequences = zc->seqStore.sequencesStart; - zc->seqStore.sequences += config->lz4_data.seq_num; + zc->seqStore.sequences += config->snappy_data.seq_num; return KAE_SNAPPY_SUCC; } -int kaelz4_compress_v1(SNAPPY_CCtx* zc, const void* src, size_t srcSize) +int kaesnappy_compress_v1(SNAPPY_CCtx* zc, const void* src, size_t srcSize) { - kaelz4_ctx_t* kaelz4_ctx = (kaelz4_ctx_t*)zc->kaeConfig; - if (kaelz4_ctx == NULL || src == NULL || srcSize == 0) { + kaesnappy_ctx_t* kaesnappy_ctx = (kaesnappy_ctx_t*)zc->kaeConfig; + if (kaesnappy_ctx == NULL || src == NULL || srcSize == 0) { US_ERR("compress parameter invalid\n"); return KAE_SNAPPY_INVAL_PARA; } - US_INFO("kaelz4 compress srcSize : %lu", srcSize); - kaelz4_ctx->in = (void*)src; - kaelz4_ctx->in_len = srcSize; - kaelz4_ctx->out = NULL; - kaelz4_ctx->consumed = 0; - kaelz4_ctx->produced = 0; - kaelz4_ctx->avail_out = KAEZIP_STREAM_CHUNK_OUT; - kaelz4_ctx->flush = (zc->kaeFrameMode == 1) ? WCRYPTO_FINISH : + US_INFO("kaesnappy compress srcSize : %lu", srcSize); + kaesnappy_ctx->in = (void*)src; + kaesnappy_ctx->in_len = srcSize; + kaesnappy_ctx->out = NULL; + kaesnappy_ctx->consumed = 0; + kaesnappy_ctx->produced = 0; + kaesnappy_ctx->avail_out = KAEZIP_STREAM_CHUNK_OUT; + kaesnappy_ctx->flush = (zc->kaeFrameMode == 1) ? WCRYPTO_FINISH : (srcSize & 0x3) ? WCRYPTO_FINISH : WCRYPTO_SYNC_FLUSH; - kaelz4_ctx->do_comp_len = kaelz4_ctx->in_len; + kaesnappy_ctx->do_comp_len = kaesnappy_ctx->in_len; - kaelz4_set_input_data(kaelz4_ctx); - struct wcrypto_comp_op_data *op_data = &kaelz4_ctx->op_data; + kaesnappy_set_input_data(kaesnappy_ctx); + struct wcrypto_comp_op_data *op_data = &kaesnappy_ctx->op_data; - int ret = wcrypto_do_comp(kaelz4_ctx->wd_ctx, op_data, NULL); // sync + int ret = wcrypto_do_comp(kaesnappy_ctx->wd_ctx, op_data, NULL); // sync if (unlikely(ret < 0)) { - US_ERR("lz4 wcrypto_do_comp fail! ret = %d\n", ret); + US_ERR("snappy wcrypto_do_comp fail! ret = %d\n", ret); return ret; } else { - struct wcrypto_lz77_zstd_format* lz4_data = &kaelz4_ctx->lz4_data; - zc->seqnum = lz4_data->seq_num; // 获取硬件返回三元组数目，用于遍历解析 + struct wcrypto_lz77_zstd_format* snappy_data = &kaesnappy_ctx->snappy_data; + zc->seqnum = snappy_data->seq_num; // 获取硬件返回三元组数目，用于遍历解析 } if (op_data->stream_pos == WCRYPTO_COMP_STREAM_NEW) { op_data->stream_pos = WCRYPTO_COMP_STREAM_OLD; } - kaelz4_get_output_data(kaelz4_ctx); - ret = kaelz4_data_parsing(zc, kaelz4_ctx); + kaesnappy_get_output_data(kaesnappy_ctx); + ret = kaesnappy_data_parsing(zc, kaesnappy_ctx); return ret; } @@ -214,7 +214,7 @@ static inline void Slow_CRC32(uint64_t* l, uint8_t** p) } // CRC32 API接口函数 -static uint32_t KAELZ4CRC32(uint32_t crc, const char *data, uint64_t len) +static uint32_t KAESNAPPYCRC32(uint32_t crc, const char *data, uint64_t len) { if (data == NULL) { return crc; @@ -262,17 +262,17 @@ static uint32_t KAELZ4CRC32(uint32_t crc, const char *data, uint64_t len) return crcResult ^ 0xffffffffu; } -static void kaelz4_compress_async_callback(struct kaelz4_compress_ctx *compress_ctx, int status) +static void kaesnappy_compress_async_callback(struct kaesnappy_compress_ctx *compress_ctx, int status) { struct kaesnappy_result *result = compress_ctx->result; result->status = status; result->dst_len = compress_ctx->dst_len; if (result->ibuf_crc != NULL && status == KAE_SNAPPY_SUCC) { - *result->ibuf_crc = KAELZ4CRC32(*result->ibuf_crc, compress_ctx->src, compress_ctx->srcSize); + *result->ibuf_crc = KAESNAPPYCRC32(*result->ibuf_crc, compress_ctx->src, compress_ctx->srcSize); } if (result->obuf_crc != NULL && status == KAE_SNAPPY_SUCC) { - *result->obuf_crc = KAELZ4CRC32(*result->obuf_crc, compress_ctx->dst, compress_ctx->dst_len); + *result->obuf_crc = KAESNAPPYCRC32(*result->obuf_crc, compress_ctx->dst, compress_ctx->dst_len); } if (unlikely(status != KAE_SNAPPY_SUCC)) { @@ -283,15 +283,15 @@ static void kaelz4_compress_async_callback(struct kaelz4_compress_ctx *compress_ free(compress_ctx); } -static void LZ4_write16(void* memPtr, U16 value) { ((LZ4_unalign*)memPtr)->u16 = value; } +static void SNAPPY_write16(void* memPtr, U16 value) { ((SNAPPY_unalign*)memPtr)->u16 = value; } -static unsigned LZ4_isLittleEndian(void) +static unsigned SNAPPY_isLittleEndian(void) { const union { U32 u; BYTE c[4]; } one = { 1 }; /* don't use static : performance detrimental */ return one.c[0]; } -static inline void LZ4_wildCopy8(void* dstPtr, const void* srcPtr, void* dstEnd) +static inline void SNAPPY_wildCopy8(void* dstPtr, const void* srcPtr, void* dstEnd) { BYTE* d = (BYTE*)dstPtr; const BYTE* s = (const BYTE*)srcPtr; @@ -300,7 +300,7 @@ static inline void LZ4_wildCopy8(void* dstPtr, const void* srcPtr, void* dstEnd) do { KZL_MEMCPY_8(d,s,8); d+=8; s+=8; } while (d 65535)) { // 边界情况判断，硬件返回结果中，offBase不应该大于64KB US_ERR("Warning! offBase(%d) is larger than 64KB.\n", offBase); - return KAE_LZ4_REBUILD_FAIL; + return KAE_SNAPPY_REBUILD_FAIL; } matchCode = mlBase - 1; @@ -415,7 +415,7 @@ static int kaelz4_triples_rebuild(struct kaelz4_async_req *req, const void *sour } else { *token = (BYTE)(tempLiteralLength << ML_BITS); } - LZ4_memcpy(op, ip, tempLiteralLength); + SNAPPY_memcpy(op, ip, tempLiteralLength); op += tempLiteralLength; int result = (int)(((char*)op) - ((char*)dest)); @@ -427,7 +427,7 @@ static int kaelz4_triples_rebuild(struct kaelz4_async_req *req, const void *sour // 约束：分块原始数据内存连续 // 1、对于非last subblock：first new seq生成时继承prev subblock的last literal；cur subblock的尾部last literal信息更新至ctx中 // 2、对于last subblock：first new seq生成时继承prev subblock的last literal；cur subblock的尾部last literal生成last seq格式 -static int kaelz4_triples_rebuild_64Kblock(struct kaelz4_async_req *req, const void *source, void *dest) +static int kaesnappy_triples_rebuild_64Kblock(struct kaesnappy_async_req *req, const void *source, void *dest) { const BYTE* ip = (const BYTE*) source; BYTE* op = (BYTE*) dest; @@ -486,23 +486,23 @@ static int kaelz4_triples_rebuild_64Kblock(struct kaelz4_async_req *req, const v // 满足生成first new sequence条件，继承prev subblock的last literal if (req->compress_ctx->prev_last_lit_ptr != NULL) { - LZ4_wildCopy16(op, req->compress_ctx->prev_last_lit_ptr, op + req->compress_ctx->prev_last_lit_len); + SNAPPY_wildCopy16(op, req->compress_ctx->prev_last_lit_ptr, op + req->compress_ctx->prev_last_lit_len); op += req->compress_ctx->prev_last_lit_len; litLength -= req->compress_ctx->prev_last_lit_len; req->compress_ctx->prev_last_lit_ptr = NULL; req->compress_ctx->prev_last_lit_len = 0; } - LZ4_wildCopy16(op, ip, op + litLength); + SNAPPY_wildCopy16(op, ip, op + litLength); op += litLength; ip += litLength + mlBase + 3; tempLiteralLength = 0; - LZ4_writeLE16(op, (U16)(offBase)); + SNAPPY_writeLE16(op, (U16)(offBase)); op += 2; if (unlikely(offBase > 65535)) { // 边界情况判断，硬件返回结果中，offBase不应该大于64KB US_ERR("Warning! offBase(%d) is larger than 64KB.\n", offBase); - return KAE_LZ4_REBUILD_FAIL; + return KAE_SNAPPY_REBUILD_FAIL; } matchCode = mlBase - 1; @@ -549,16 +549,16 @@ static int kaelz4_triples_rebuild_64Kblock(struct kaelz4_async_req *req, const v *token = (BYTE)(litLength << ML_BITS); } - LZ4_wildCopy16(op, ip, op + litLength); + SNAPPY_wildCopy16(op, ip, op + litLength); op += litLength; ip += litLength + mlBase + 3; tempLiteralLength = 0; - LZ4_writeLE16(op, (U16)(offBase)); + SNAPPY_writeLE16(op, (U16)(offBase)); op += 2; if (unlikely(offBase > 65535)) { // 边界情况判断，硬件返回结果中，offBase不应该大于64KB US_ERR("Warning! offBase(%d) is larger than 64KB.\n", offBase); - return KAE_LZ4_REBUILD_FAIL; + return KAE_SNAPPY_REBUILD_FAIL; } matchCode = mlBase - 1; @@ -604,14 +604,14 @@ static int kaelz4_triples_rebuild_64Kblock(struct kaelz4_async_req *req, const v } if (req->compress_ctx->prev_last_lit_ptr != NULL) { - LZ4_wildCopy16(op, req->compress_ctx->prev_last_lit_ptr, op + req->compress_ctx->prev_last_lit_len); + SNAPPY_wildCopy16(op, req->compress_ctx->prev_last_lit_ptr, op + req->compress_ctx->prev_last_lit_len); op += req->compress_ctx->prev_last_lit_len; tempLiteralLength -= req->compress_ctx->prev_last_lit_len; req->compress_ctx->prev_last_lit_ptr = NULL; req->compress_ctx->prev_last_lit_len = 0; } - LZ4_memcpy(op, ip, tempLiteralLength); + SNAPPY_memcpy(op, ip, tempLiteralLength); op += tempLiteralLength; } @@ -620,31 +620,31 @@ static int kaelz4_triples_rebuild_64Kblock(struct kaelz4_async_req *req, const v return result; } -static void kaelz4_async_compress_cb(int status, void *param) +static void kaesnappy_async_compress_cb(int status, void *param) { - struct kaelz4_async_req* req = param; + struct kaesnappy_async_req* req = param; SNAPPY_CCtx* zc = &req->zc; - kaelz4_ctx_t* kaelz4_ctx = (kaelz4_ctx_t*)zc->kaeConfig; - struct wcrypto_comp_op_data *op_data = &kaelz4_ctx->op_data; + kaesnappy_ctx_t* kaesnappy_ctx = (kaesnappy_ctx_t*)zc->kaeConfig; + struct wcrypto_comp_op_data *op_data = &kaesnappy_ctx->op_data; if (status != 0) { - US_ERR("kaelz4_async_compress_cb status %d !\n", status); + US_ERR("kaesnappy_async_compress_cb status %d !\n", status); req->compress_ctx->status = KAE_SNAPPY_COMP_FAIL; req->done = 1; return; } - struct wcrypto_lz77_zstd_format* lz4_data = &kaelz4_ctx->lz4_data; - zc->seqnum = lz4_data->seq_num; // 获取硬件返回三元组数目，用于遍历解析 + struct wcrypto_lz77_zstd_format* snappy_data = &kaesnappy_ctx->snappy_data; + zc->seqnum = snappy_data->seq_num; // 获取硬件返回三元组数目，用于遍历解析 US_DEBUG("frameMode = %u, flush = %d, lit_num = %u, seq_num = %u, lit_length_overflow_cnt = %u, lit_length_overflow_pos = %u\n", - zc->kaeFrameMode, kaelz4_ctx->flush, - lz4_data->lit_num, lz4_data->seq_num, lz4_data->lit_length_overflow_cnt, lz4_data->lit_length_overflow_pos); + zc->kaeFrameMode, kaesnappy_ctx->flush, + snappy_data->lit_num, snappy_data->seq_num, snappy_data->lit_length_overflow_cnt, snappy_data->lit_length_overflow_pos); if (op_data->stream_pos == WCRYPTO_COMP_STREAM_NEW) { op_data->stream_pos = WCRYPTO_COMP_STREAM_OLD; } - kaelz4_get_output_data(kaelz4_ctx); - int ret = kaelz4_data_parsing(zc, kaelz4_ctx); + kaesnappy_get_output_data(kaesnappy_ctx); + int ret = kaesnappy_data_parsing(zc, kaesnappy_ctx); if (ret != KAE_SNAPPY_SUCC) { req->compress_ctx->status = KAE_SNAPPY_COMP_FAIL; @@ -654,75 +654,75 @@ static void kaelz4_async_compress_cb(int status, void *param) req->done = 1; } -static int kaelz4_compress_async_impl(SNAPPY_CCtx* zc, const void* src, size_t srcSize, void *usr_data) +static int kaesnappy_compress_async_impl(SNAPPY_CCtx* zc, const void* src, size_t srcSize, void *usr_data) { - kaelz4_ctx_t* kaelz4_ctx = (kaelz4_ctx_t*)zc->kaeConfig; - if (kaelz4_ctx == NULL || src == NULL || srcSize == 0) { + kaesnappy_ctx_t* kaesnappy_ctx = (kaesnappy_ctx_t*)zc->kaeConfig; + if (kaesnappy_ctx == NULL || src == NULL || srcSize == 0) { US_ERR("compress parameter invalid\n"); return KAE_SNAPPY_INVAL_PARA; } - US_INFO("kaelz4 compress srcSize : %lu", srcSize); - kaelz4_ctx->in = (void*)src; - kaelz4_ctx->in_len = srcSize; - kaelz4_ctx->out = NULL; - kaelz4_ctx->consumed = 0; - kaelz4_ctx->produced = 0; - kaelz4_ctx->avail_out = KAEZIP_STREAM_CHUNK_OUT; - kaelz4_ctx->flush = (zc->kaeFrameMode == 1) ? WCRYPTO_FINISH : + US_INFO("kaesnappy compress srcSize : %lu", srcSize); + kaesnappy_ctx->in = (void*)src; + kaesnappy_ctx->in_len = srcSize; + kaesnappy_ctx->out = NULL; + kaesnappy_ctx->consumed = 0; + kaesnappy_ctx->produced = 0; + kaesnappy_ctx->avail_out = KAEZIP_STREAM_CHUNK_OUT; + kaesnappy_ctx->flush = (zc->kaeFrameMode == 1) ? WCRYPTO_FINISH : (srcSize & 0x3) ? WCRYPTO_FINISH : WCRYPTO_SYNC_FLUSH; - kaelz4_ctx->do_comp_len = kaelz4_ctx->in_len; - kaelz4_ctx->callback = kaelz4_async_compress_cb; - kaelz4_ctx->param = usr_data; + kaesnappy_ctx->do_comp_len = kaesnappy_ctx->in_len; + kaesnappy_ctx->callback = kaesnappy_async_compress_cb; + kaesnappy_ctx->param = usr_data; - kaelz4_set_input_data(kaelz4_ctx); - struct wcrypto_comp_op_data *op_data = &kaelz4_ctx->op_data; + kaesnappy_set_input_data(kaesnappy_ctx); + struct wcrypto_comp_op_data *op_data = &kaesnappy_ctx->op_data; - return wcrypto_do_comp(kaelz4_ctx->wd_ctx, op_data, kaelz4_ctx); // async + return wcrypto_do_comp(kaesnappy_ctx->wd_ctx, op_data, kaesnappy_ctx); // async } -static void kaelz4_find_and_free_kz_ctx(kaelz4_ctx_t *kz_ctx) +static void kaesnappy_find_and_free_kz_ctx(kaesnappy_ctx_t *kz_ctx) { for (int i = 0; i < MAX_NUM_IN_COMP; i++) { if (g_async_ctrl.kz_ctx[i] == kz_ctx) { - kaelz4_free_ctx(g_async_ctrl.kz_ctx[i]); + kaesnappy_free_ctx(g_async_ctrl.kz_ctx[i]); g_async_ctrl.kz_ctx[i] = NULL; } } } -static void kaelz4_do_compress_polling(struct kaelz4_async_req *req) +static void kaesnappy_do_compress_polling(struct kaesnappy_async_req *req) { if (req->special_flag != 0) { return; } - kaelz4_ctx_t *kaelz4_ctx = (kaelz4_ctx_t *)req->zc.kaeConfig; - struct wd_queue *q = kaelz4_ctx->q_node->kae_wd_queue; + kaesnappy_ctx_t *kaesnappy_ctx = (kaesnappy_ctx_t *)req->zc.kaeConfig; + struct wd_queue *q = kaesnappy_ctx->q_node->kae_wd_queue; int ret = wcrypto_comp_poll(q, 1); if (unlikely(ret < 0)) { US_ERR("poll fail! ret = %d\n", ret); - kaelz4_find_and_free_kz_ctx(kaelz4_ctx); + kaesnappy_find_and_free_kz_ctx(kaesnappy_ctx); req->compress_ctx->status = KAE_SNAPPY_COMP_FAIL; req->done = 1; } return; } -int kaelz4_async_is_thread_do_comp_full(void) +int kaesnappy_async_is_thread_do_comp_full(void) { return g_async_ctrl.cur_num_in_comp < MAX_NUM_IN_COMP ? 0 : 1; } -void kaelz4_async_init(volatile int *stop, sw_compress_fn sw_compress, sw_compress_frame_fn sw_compress_frame) +void kaesnappy_async_init(volatile int *stop, sw_compress_fn sw_compress, sw_compress_frame_fn sw_compress_frame) { g_async_ctrl.stop_flag = stop; g_async_ctrl.sw_compress_frame = sw_compress_frame; } -static int kaelz4_async_sw_compress(struct kaelz4_compress_ctx *compress_ctx) +static int kaesnappy_async_sw_compress(struct kaesnappy_compress_ctx *compress_ctx) { int ret = -1; compress_ctx->status = KAE_SNAPPY_SUCC; @@ -733,22 +733,22 @@ static int kaelz4_async_sw_compress(struct kaelz4_compress_ctx *compress_ctx) ret = g_async_ctrl.sw_compress(compress_ctx->src, compress_ctx->dst, compress_ctx->srcSize, compress_ctx->dstCapacity); } - ret = (ret == 0) ? KAE_LZ4_SW_RETURN_0_FAIL : ret; + ret = (ret == 0) ? KAE_SNAPPY_SW_RETURN_0_FAIL : ret; return ret; } -int kaelz4_async_compress_polling(int budget) +int kaesnappy_async_compress_polling(int budget) { int cnt = 0; - struct kaelz4_compress_ctx *compress_ctx = g_async_ctrl.ctx_head; + struct kaesnappy_compress_ctx *compress_ctx = g_async_ctrl.ctx_head; if (compress_ctx == NULL) { return 0; } - struct kaelz4_async_req *req = compress_ctx->req_list; + struct kaesnappy_async_req *req = compress_ctx->req_list; US_DEBUG("do polling. budget = %d", budget); while (req && cnt < budget) { - kaelz4_do_compress_polling(req); + kaesnappy_do_compress_polling(req); if (!req->done) { return KAE_SNAPPY_PROCESS_HW_BUSY; } @@ -756,16 +756,16 @@ int kaelz4_async_compress_polling(int budget) int ret = -1; if (likely(compress_ctx->status == KAE_SNAPPY_SUCC)) { - ret = compress_ctx->kaelz4_post_process_handle(req, req->src, compress_ctx->dst + compress_ctx->dst_len); + ret = compress_ctx->kaesnappy_post_process_handle(req, req->src, compress_ctx->dst + compress_ctx->dst_len); if (ret < 0) { - US_ERR("kaelz4_post_process_handle err. ret=%d\n", ret); + US_ERR("kaesnappy_post_process_handle err. ret=%d\n", ret); } } if (unlikely(ret < 0 && req->idx == 0 && req->last != 0 && req->compress_ctx->status != KAE_SNAPPY_HW_TIMEOUT_FAIL)) { - US_WARN("KAELz4 async compress switch to soft"); + US_WARN("KAESnappy async compress switch to soft"); // 异常切软算处理 - ret = kaelz4_async_sw_compress(compress_ctx); + ret = kaesnappy_async_sw_compress(compress_ctx); } if (ret >= 0 && compress_ctx->status == KAE_SNAPPY_SUCC) { @@ -787,7 +787,7 @@ int kaelz4_async_compress_polling(int budget) if (req->last) { g_async_ctrl.ctx_head = compress_ctx->next; - kaelz4_compress_async_callback(compress_ctx, compress_ctx->status); + kaesnappy_compress_async_callback(compress_ctx, compress_ctx->status); compress_ctx = g_async_ctrl.ctx_head; } else { compress_ctx->req_list = compress_ctx->req_list->next; @@ -807,7 +807,7 @@ int kaelz4_async_compress_polling(int budget) static struct timespec polling_timeout_10us = { 0, 10000 }; // 10us超时 -static void kaelz4_ctx_body_init(SNAPPY_CCtx *ctx_body) +static void kaesnappy_ctx_body_init(SNAPPY_CCtx *ctx_body) { ctx_body->kaeInited = 0; ctx_body->kaeFrameMode = 1; // 相当于每个都强刷 @@ -826,11 +826,11 @@ static void kaelz4_ctx_body_init(SNAPPY_CCtx *ctx_body) ctx_body->seqnum = 0; } -static int kaelz4_async_init_ctx(SNAPPY_CCtx *ctx_body) +static int kaesnappy_async_init_ctx(SNAPPY_CCtx *ctx_body) { int enter_polling = 0; - kaelz4_ctx_body_init(ctx_body); + kaesnappy_ctx_body_init(ctx_body); if (unlikely(g_async_ctrl.kz_ctx[g_async_ctrl.ctx_index] == NULL)) { while (kaesnappy_init(ctx_body) != KAE_SNAPPY_SUCC) { // 本质来说，这个初始化函数就初始化了其中的kaeConfig，其他是没有的，所以在外面要赋值 @@ -845,18 +845,18 @@ static int kaelz4_async_init_ctx(SNAPPY_CCtx *ctx_body) return KAE_SNAPPY_INIT_FAIL; } - (void)kaelz4_async_compress_polling(1); + (void)kaesnappy_async_compress_polling(1); // 如果本线程已经idle，则使用之前已经申请到的kz_ctx if (g_async_ctrl.cur_num_in_comp == 0 && g_async_ctrl.kz_ctx[0] != NULL) { g_async_ctrl.ctx_index = 0; ctx_body->kaeConfig = (uintptr_t)g_async_ctrl.kz_ctx[g_async_ctrl.ctx_index]; } } - g_async_ctrl.kz_ctx[g_async_ctrl.ctx_index] = (kaelz4_ctx_t *)ctx_body->kaeConfig; + g_async_ctrl.kz_ctx[g_async_ctrl.ctx_index] = (kaesnappy_ctx_t *)ctx_body->kaeConfig; } else { - while (kaelz4_async_is_thread_do_comp_full()) { - (void)kaelz4_async_compress_polling(1); - // 此分支不需要超时判断，kaelz4_async_compress_polling本身具有超时机制，如果硬件超时，会主动释放资源 + while (kaesnappy_async_is_thread_do_comp_full()) { + (void)kaesnappy_async_compress_polling(1); + // 此分支不需要超时判断，kaesnappy_async_compress_polling本身具有超时机制，如果硬件超时，会主动释放资源 if (unlikely(*g_async_ctrl.stop_flag != 0)) { return KAE_SNAPPY_INIT_FAIL; } @@ -866,7 +866,7 @@ static int kaelz4_async_init_ctx(SNAPPY_CCtx *ctx_body) return KAE_SNAPPY_INIT_FAIL; } } - kaelz4_init_ctx(g_async_ctrl.kz_ctx[g_async_ctrl.ctx_index]); + kaesnappy_init_ctx(g_async_ctrl.kz_ctx[g_async_ctrl.ctx_index]); ctx_body->kaeConfig = (uintptr_t)g_async_ctrl.kz_ctx[g_async_ctrl.ctx_index]; } @@ -876,29 +876,29 @@ static int kaelz4_async_init_ctx(SNAPPY_CCtx *ctx_body) return KAE_SNAPPY_SUCC; } -void kaelz4_ctx_clear(void) +void kaesnappy_ctx_clear(void) { for (int i = 0; i < MAX_NUM_IN_COMP; i++) { if (g_async_ctrl.kz_ctx[i] != NULL) { - kaelz4_free_ctx(g_async_ctrl.kz_ctx[i]); + kaesnappy_free_ctx(g_async_ctrl.kz_ctx[i]); g_async_ctrl.kz_ctx[i] = NULL; } } } -static int kaelz4_send_async_compress(struct kaelz4_async_req *req) +static int kaesnappy_send_async_compress(struct kaesnappy_async_req *req) { int ret; // 1.kae上下文初始化函数调用 - ret = kaelz4_async_init_ctx(&req->zc); + ret = kaesnappy_async_init_ctx(&req->zc); if (unlikely(ret != KAE_SNAPPY_SUCC)) { US_ERR("Get kae hw ctx failed!\n"); return ret; } size_t compress_size = req->src_size - MFLIMIT; - ret = kaelz4_compress_async_impl(&req->zc, req->src, compress_size, (void *)req); + ret = kaesnappy_compress_async_impl(&req->zc, req->src, compress_size, (void *)req); if (unlikely(ret != KAE_SNAPPY_SUCC)) { - kaelz4_find_and_free_kz_ctx((kaelz4_ctx_t *)req->zc.kaeConfig); + kaesnappy_find_and_free_kz_ctx((kaesnappy_ctx_t *)req->zc.kaeConfig); g_async_ctrl.ctx_index = (g_async_ctrl.ctx_index + MAX_NUM_IN_COMP - 1) % MAX_NUM_IN_COMP; g_async_ctrl.cur_num_in_comp--; req->zc.kaeConfig = 0; @@ -908,10 +908,10 @@ static int kaelz4_send_async_compress(struct kaelz4_async_req *req) return ret; } -static int kaelz4_async_compress_process(void *arg) +static int kaesnappy_async_compress_process(void *arg) { - struct kaelz4_compress_ctx *compress_ctx = arg; - struct kaelz4_async_req *tail = NULL; + struct kaesnappy_compress_ctx *compress_ctx = arg; + struct kaesnappy_async_req *tail = NULL; // 转换衔接 size_t srcSize = compress_ctx->srcSize; @@ -920,15 +920,15 @@ static int kaelz4_async_compress_process(void *arg) size_t remainingLength = srcSize; // 该值用于保存剩余的待压缩数据长度 - // 针对ZSTD和LZ4的matchlength转换定义的数据结构 + // 针对ZSTD的Snappy的matchlength转换定义的数据结构 US_DEBUG("INPUTSIZE:%ld, dstCapacity:%ld, maxOutputSize:%ld.", compress_ctx->srcSize, dstCapacity, compress_ctx->dstCapacity); // 针对ZSTD 128K remaining会覆盖CTX的问题进行的拆分(具体按64K切分，对于末尾的literal，进行src前移，放到下一轮再压) int idx = 0; while (remainingLength) { US_DEBUG("remainingLength:%ld, hardware:%d\n", remainingLength, HARDWARE_BLOCK_SIZE); - struct kaelz4_async_req *req = (struct kaelz4_async_req *)kae_malloc(sizeof(struct kaelz4_async_req)); + struct kaesnappy_async_req *req = (struct kaesnappy_async_req *)kae_malloc(sizeof(struct kaesnappy_async_req)); if (unlikely(req == NULL)) { - US_ERR("Alloc kaelz4_async_req failed!\n"); + US_ERR("Alloc kaesnappy_async_req failed!\n"); compress_ctx->status = KAE_SNAPPY_ALLOC_FAIL; if (compress_ctx->req_list) { tail->last = 1; @@ -961,7 +961,7 @@ static int kaelz4_async_compress_process(void *arg) int ret = KAE_SNAPPY_SUCC; if (!req->special_flag) { - ret = kaelz4_send_async_compress(req); + ret = kaesnappy_send_async_compress(req); } else { // 小于12B处理，无需硬件压缩 req->done = 1; @@ -986,12 +986,12 @@ static int kaelz4_async_compress_process(void *arg) return KAE_SNAPPY_SUCC; } -static void kaelz4_flush_compress(void) +static void kaesnappy_flush_compress(void) { - struct kaelz4_compress_ctx *compress_ctx = g_async_ctrl.ctx_head; + struct kaesnappy_compress_ctx *compress_ctx = g_async_ctrl.ctx_head; while (compress_ctx != NULL) { - struct kaelz4_async_req *req = compress_ctx->req_list; + struct kaesnappy_async_req *req = compress_ctx->req_list; while (req != NULL) { compress_ctx->req_list = compress_ctx->req_list->next; free(req); @@ -1003,23 +1003,23 @@ static void kaelz4_flush_compress(void) } } -void kaelz4_async_deinit(void) +void kaesnappy_async_deinit(void) { - kaelz4_flush_compress(); - kaelz4_ctx_clear(); - kaelz4_free_all_qps(); + kaesnappy_flush_compress(); + kaesnappy_ctx_clear(); + kaesnappy_free_all_qps(); } -const kaelz4_post_process_handle_t g_post_process_handle[KAESNAPPY_ASYNC_BUTT] = { - [KAESNAPPY_ASYNC_SMALL_BLOCK] = kaelz4_triples_rebuild, - [KAESNAPPY_ASYNC_BLOCK] = kaelz4_triples_rebuild_64Kblock, +const kaesnappy_post_process_handle_t g_post_process_handle[KAESNAPPY_ASYNC_BUTT] = { + [KAESNAPPY_ASYNC_SMALL_BLOCK] = kaesnappy_triples_rebuild, + [KAESNAPPY_ASYNC_BLOCK] = kaesnappy_triples_rebuild_64Kblock, }; -void kaelz4_compress_async(const void *src, void *dst, +void kaesnappy_compress_async(const void *src, void *dst, snappy_async_callback callback, struct kaesnappy_result *result, enum kae_snappy_async_data_format data_format, const int *ptr) { - struct kaelz4_compress_ctx *compress_ctx = (struct kaelz4_compress_ctx *)kae_malloc(sizeof(struct kaelz4_compress_ctx)); + struct kaesnappy_compress_ctx *compress_ctx = (struct kaesnappy_compress_ctx *)kae_malloc(sizeof(struct kaesnappy_compress_ctx)); if (unlikely(compress_ctx == NULL)) { US_ERR("Alloc compress_ctx failed!\n"); goto err_callback; @@ -1034,7 +1034,7 @@ void kaelz4_compress_async(const void *src, void *dst, compress_ctx->result = result; compress_ctx->data_format = data_format; compress_ctx->preferences = *ptr; - compress_ctx->kaelz4_post_process_handle = g_post_process_handle[data_format]; + compress_ctx->kaesnappy_post_process_handle = g_post_process_handle[data_format]; compress_ctx->dst_len = 0; compress_ctx->next = NULL; compress_ctx->status = KAE_SNAPPY_SUCC; @@ -1049,7 +1049,7 @@ void kaelz4_compress_async(const void *src, void *dst, } g_async_ctrl.tail = compress_ctx; - if (unlikely(kaelz4_async_compress_process(compress_ctx) != KAE_SNAPPY_SUCC)) { + if (unlikely(kaesnappy_async_compress_process(compress_ctx) != KAE_SNAPPY_SUCC)) { goto free_compress_ctx; } diff --git a/KAESnappy/src/v1/kaesnappy_comp.h b/KAESnappy/src/v1/kaesnappy_comp.h index 819451057bd5c6dd3859c0b296cfa068d4f2f6ce..4166ea6e79f6df2cc07c12423652c837f480d0a0 100644 --- a/KAESnappy/src/v1/kaesnappy_comp.h +++ b/KAESnappy/src/v1/kaesnappy_comp.h @@ -20,17 +20,17 @@ #define ML_MASK ((1U<= 4) -# define LZ4_memcpy(dst, src, size) __builtin_memcpy(dst, src, size) +# define SNAPPY_memcpy(dst, src, size) __builtin_memcpy(dst, src, size) # else -# define LZ4_memcpy(dst, src, size) memcpy(dst, src, size) +# define SNAPPY_memcpy(dst, src, size) memcpy(dst, src, size) # endif #endif @@ -40,14 +40,14 @@ typedef size_t reg_t; /* 32-bits in x32 mode */ #endif -typedef union { U16 u16; U32 u32; reg_t uArch; } __attribute__((packed)) LZ4_unalign; +typedef union { U16 u16; U32 u32; reg_t uArch; } __attribute__((packed)) SNAPPY_unalign; -struct kaelz4_compress_ctx; -struct kaelz4_async_req; +struct kaesnappy_compress_ctx; +struct kaesnappy_async_req; -typedef int (*kaelz4_post_process_handle_t)(struct kaelz4_async_req *req, const void *source, void *dest); +typedef int (*kaesnappy_post_process_handle_t)(struct kaesnappy_async_req *req, const void *source, void *dest); -struct kaelz4_compress_ctx { +struct kaesnappy_compress_ctx { size_t srcSize; size_t dstCapacity; size_t dst_len; @@ -61,12 +61,12 @@ struct kaelz4_compress_ctx { struct kaesnappy_result *result; enum kae_snappy_async_data_format data_format; int preferences; - kaelz4_post_process_handle_t kaelz4_post_process_handle; - struct kaelz4_async_req *req_list; - struct kaelz4_compress_ctx *next; + kaesnappy_post_process_handle_t kaesnappy_post_process_handle; + struct kaesnappy_async_req *req_list; + struct kaesnappy_compress_ctx *next; }; -struct kaelz4_async_req { +struct kaesnappy_async_req { SNAPPY_CCtx zc; const void* src; size_t src_size; @@ -74,81 +74,81 @@ struct kaelz4_async_req { U32 special_flag; U32 last; U32 done; - struct kaelz4_compress_ctx *compress_ctx; - struct kaelz4_async_req *next; + struct kaesnappy_compress_ctx *compress_ctx; + struct kaesnappy_async_req *next; }; #define MAX_NUM_IN_COMP 2 // 每个线程最多允许同时进行的压缩任务数 -struct kaelz4_async_ctrl { - struct kaelz4_compress_ctx *ctx_head; - struct kaelz4_compress_ctx *tail; +struct kaesnappy_async_ctrl { + struct kaesnappy_compress_ctx *ctx_head; + struct kaesnappy_compress_ctx *tail; sw_compress_fn sw_compress; sw_compress_frame_fn sw_compress_frame; int cur_num_in_comp; // 当前正在压缩的任务数量 - kaelz4_ctx_t *kz_ctx[MAX_NUM_IN_COMP]; + kaesnappy_ctx_t *kz_ctx[MAX_NUM_IN_COMP]; int ctx_index; volatile int *stop_flag; }; -void kaelz4_setstatus_v1(SNAPPY_CCtx* zc, unsigned int status); -int kaelz4_compress_v1(SNAPPY_CCtx* zc, const void* src, size_t srcSize); +void kaesnappy_setstatus_v1(SNAPPY_CCtx* zc, unsigned int status); +int kaesnappy_compress_v1(SNAPPY_CCtx* zc, const void* src, size_t srcSize); // part1.frame模式的header & footer描述 -#define KAELZ4_MAGIC_NUMBER 0x184D2204U -#define KAELZ4_MAGIC_SKIPPABLE 0x184D2A50U - -#define KAELZ4_VERSION 0x1 // version必须为01 -#define KAELZ4_BLOCK_INDEPENDENCE_FLAG 0x1 // block间独立不依赖 -#define KAELZ4_BLOCK_CHECKSUM_FLAG (1 << 4) // 各block不带checksum -#define KAELZ4_CONTENT_SIZE_FLAG (1 << 3) // 携带原始数据长度 -#define KAELZ4_CONTENT_CHECKSUM_FLAG (1 << 2) // frame携带checksum -#define KAELZ4_DICTIONARY_ID_FLAG 0x0 // 不使用字典dict -#define KAELZ4_MAX_BLK_SIZE 0x4 // 各block大小64KB -#define KAELZ4_ENDMARK 0x0 // frame结束标志 - -#define KAELZ4_MAGIC_SIZE 4 // magic number长度 -#define KAELZ4_FRAMEDESCRIPTOR_SIZE 11 // frame descriptor长度 -#define KAELZ4_HEADER_SIZE (KAELZ4_MAGIC_SIZE + KAELZ4_FRAMEDESCRIPTOR_SIZE) // frame header长度 - -#define KAELZ4_BLOCK_HEADER_SIZE 4 // block header长度(4字节) -#define KAELZ4_STOREDBLOCK_FLAG 0x80000000U // 长度为0的未压缩块，是有效的 -#define KAELZ4_STORED_HEADER_SIZE 4 - -#define KAELZ4_CHECKSUM_SIZE 4 // checksum长度 -#define KAELZ4_ENDMARK_SIZE 4 // endmark长度 -#define KAELZ4_FOOTER_SIZE (KAELZ4_CHECKSUM_SIZE + KAELZ4_ENDMARK_SIZE) // frame footer长度 +#define KAESNAPPY_MAGIC_NUMBER 0x184D2204U +#define KAESNAPPY_MAGIC_SKIPPABLE 0x184D2A50U + +#define KAESNAPPY_VERSION 0x1 // version必须为01 +#define KAESNAPPY_BLOCK_INDEPENDENCE_FLAG 0x1 // block间独立不依赖 +#define KAESNAPPY_BLOCK_CHECKSUM_FLAG (1 << 4) // 各block不带checksum +#define KAESNAPPY_CONTENT_SIZE_FLAG (1 << 3) // 携带原始数据长度 +#define KAESNAPPY_CONTENT_CHECKSUM_FLAG (1 << 2) // frame携带checksum +#define KAESNAPPY_DICTIONARY_ID_FLAG 0x0 // 不使用字典dict +#define KAESNAPPY_MAX_BLK_SIZE 0x4 // 各block大小64KB +#define KAESNAPPY_ENDMARK 0x0 // frame结束标志 + +#define KAESNAPPY_MAGIC_SIZE 4 // magic number长度 +#define KAESNAPPY_FRAMEDESCRIPTOR_SIZE 11 // frame descriptor长度 +#define KAESNAPPY_HEADER_SIZE (KAESNAPPY_MAGIC_SIZE + KAESNAPPY_FRAMEDESCRIPTOR_SIZE) // frame header长度 + +#define KAESNAPPY_BLOCK_HEADER_SIZE 4 // block header长度(4字节) +#define KAESNAPPY_STOREDBLOCK_FLAG 0x80000000U // 长度为0的未压缩块，是有效的 +#define KAESNAPPY_STORED_HEADER_SIZE 4 + +#define KAESNAPPY_CHECKSUM_SIZE 4 // checksum长度 +#define KAESNAPPY_ENDMARK_SIZE 4 // endmark长度 +#define KAESNAPPY_FOOTER_SIZE (KAESNAPPY_CHECKSUM_SIZE + KAESNAPPY_ENDMARK_SIZE) // frame footer长度 // part2.首尾数据结构 // frame header -typedef struct KAELZ4H_S { +typedef struct KAESNAPPYH_S { uint32_t magic_number; uint8_t flag_descriptor; uint8_t block_descriptor; uint64_t content_size; uint8_t header_checksum; -} KAELZ4H_T; +} KAESNAPPYH_T; // frame footer -typedef struct KAELZ4F_S { +typedef struct KAESNAPPYF_S { uint32_t end_mark; uint32_t content_checksum; -} KAELZ4F_T; +} KAESNAPPYF_T; // part4.功能函数 -inline unsigned long KAELZ4HeaderSz(void) +inline unsigned long KAESNAPPYHeaderSz(void) { - return KAELZ4_HEADER_SIZE; + return KAESNAPPY_HEADER_SIZE; } -inline unsigned long KAELZ4FooterSz(void) +inline unsigned long KAESNAPPYFooterSz(void) { - return KAELZ4_FOOTER_SIZE; + return KAESNAPPY_FOOTER_SIZE; } -inline unsigned long KAELZ4BlockHeaderSz(void) +inline unsigned long KAESNAPPYBlockHeaderSz(void) { - return KAELZ4_BLOCK_HEADER_SIZE; + return KAESNAPPY_BLOCK_HEADER_SIZE; } -int kaelz4_async_is_thread_do_comp_full(); +int kaesnappy_async_is_thread_do_comp_full(); #endif diff --git a/KAESnappy/src/v1/kaesnappy_ctx.c b/KAESnappy/src/v1/kaesnappy_ctx.c index cb79fcbf39cb53d3cdd22f67568a67810b9a36f3..d389069aa517d489440bf86f4584ab65aaaf9a9d 100644 --- a/KAESnappy/src/v1/kaesnappy_ctx.c +++ b/KAESnappy/src/v1/kaesnappy_ctx.c @@ -9,67 +9,67 @@ #include "kaesnappy_utils.h" #include "kaesnappy_log.h" -static KAE_QUEUE_POOL_HEAD_S* g_kaelz4_deflate_qp = NULL; -static KAE_QUEUE_POOL_HEAD_S* g_kaelz4_inflate_qp = NULL; -static pthread_mutex_t g_kaelz4_deflate_pool_init_mutex = PTHREAD_MUTEX_INITIALIZER; -static pthread_mutex_t g_kaelz4_inflate_pool_init_mutex = PTHREAD_MUTEX_INITIALIZER; +static KAE_QUEUE_POOL_HEAD_S* g_kaesnappy_deflate_qp = NULL; +static KAE_QUEUE_POOL_HEAD_S* g_kaesnappy_inflate_qp = NULL; +static pthread_mutex_t g_kaesnappy_deflate_pool_init_mutex = PTHREAD_MUTEX_INITIALIZER; +static pthread_mutex_t g_kaesnappy_inflate_pool_init_mutex = PTHREAD_MUTEX_INITIALIZER; -static KAE_QUEUE_POOL_HEAD_S* kaelz4_get_qp(int algtype); -static kaelz4_ctx_t* kaelz4_new_ctx(KAE_QUEUE_DATA_NODE_S* q_node, int alg_comp_type, int comp_optype); -static int kaelz4_create_wd_ctx(kaelz4_ctx_t *kz_ctx, int alg_comp_type, int comp_optype); -static int kaelz4_driver_do_comp_impl(kaelz4_ctx_t *kz_ctx); +static KAE_QUEUE_POOL_HEAD_S* kaesnappy_get_qp(int algtype); +static kaesnappy_ctx_t* kaesnappy_new_ctx(KAE_QUEUE_DATA_NODE_S* q_node, int alg_comp_type, int comp_optype); +static int kaesnappy_create_wd_ctx(kaesnappy_ctx_t *kz_ctx, int alg_comp_type, int comp_optype); +static int kaesnappy_driver_do_comp_impl(kaesnappy_ctx_t *kz_ctx); -static void kaelz4_free_kz_ctx(void* kz_ctx) +static void kaesnappy_free_kz_ctx(void* kz_ctx) { - kaelz4_ctx_t* kaelz4_ctx = (kaelz4_ctx_t *)kz_ctx; - if (kaelz4_ctx == NULL) { + kaesnappy_ctx_t* kaesnappy_ctx = (kaesnappy_ctx_t *)kz_ctx; + if (kaesnappy_ctx == NULL) { return; } - if (kaelz4_ctx->op_data.in && kaelz4_ctx->setup.br.usr) { - kaelz4_ctx->setup.br.free(kaelz4_ctx->setup.br.usr, (void *)kaelz4_ctx->op_data.in); - kaelz4_ctx->op_data.in = NULL; + if (kaesnappy_ctx->op_data.in && kaesnappy_ctx->setup.br.usr) { + kaesnappy_ctx->setup.br.free(kaesnappy_ctx->setup.br.usr, (void *)kaesnappy_ctx->op_data.in); + kaesnappy_ctx->op_data.in = NULL; } - if (kaelz4_ctx->op_data.out && kaelz4_ctx->setup.br.usr) { - kaelz4_ctx->setup.br.free(kaelz4_ctx->setup.br.usr, (void *)kaelz4_ctx->op_data.out); - kaelz4_ctx->op_data.out = NULL; + if (kaesnappy_ctx->op_data.out && kaesnappy_ctx->setup.br.usr) { + kaesnappy_ctx->setup.br.free(kaesnappy_ctx->setup.br.usr, (void *)kaesnappy_ctx->op_data.out); + kaesnappy_ctx->op_data.out = NULL; } - if (kaelz4_ctx->wd_ctx != NULL) { - wcrypto_del_comp_ctx(kaelz4_ctx->wd_ctx); - kaelz4_ctx->wd_ctx = NULL; + if (kaesnappy_ctx->wd_ctx != NULL) { + wcrypto_del_comp_ctx(kaesnappy_ctx->wd_ctx); + kaesnappy_ctx->wd_ctx = NULL; } - kae_free(kaelz4_ctx); + kae_free(kaesnappy_ctx); return; } -static int kaelz4_get_comp_lv() +static int kaesnappy_get_comp_lv() { - char *lz4_str = getenv("KAE_LZ4_COMP_TYPE"); - if (lz4_str == NULL) { - US_DEBUG("KAE_LZ4_COMP_TYPE is NULL, use default lv 8\n"); + char *snappy_str = getenv("KAE_SNAPPY_COMP_TYPE"); + if (snappy_str == NULL) { + US_DEBUG("KAE_SNAPPY_COMP_TYPE is NULL, use default lv 8\n"); return 8; } - int lz4_val = atoi(lz4_str); - if (lz4_val != 8 && lz4_val != 9) { - US_DEBUG("KAE_LZ4_COMP_TYPE value out of range ：%d ,use default lv 8", lz4_val); + int snappy_val = atoi(snappy_str); + if (snappy_val != 8 && snappy_val != 9) { + US_DEBUG("KAE_SNAPPY_COMP_TYPE value out of range ：%d ,use default lv 8", snappy_val); return 8; } - US_DEBUG("KAE_LZ4_COMP_TYPE value is ：%d ", lz4_val); - return lz4_val; + US_DEBUG("KAE_SNAPPY_COMP_TYPE value is ：%d ", snappy_val); + return snappy_val; } -static int kaelz4_get_win_size() +static int kaesnappy_get_win_size() { - char *lz4_str = getenv("KAE_LZ4_WINTYPE"); - if (lz4_str == NULL) { - US_DEBUG("KAE_LZ4_WINTYPE is NULL, use default winsize 32\n"); + char *snappy_str = getenv("KAE_SNAPPY_WINTYPE"); + if (snappy_str == NULL) { + US_DEBUG("KAE_SNAPPY_WINTYPE is NULL, use default winsize 32\n"); return WCRYPTO_COMP_WS_16K; } - int winsize = atoi(lz4_str); + int winsize = atoi(snappy_str); int wintype = 0; @@ -91,18 +91,18 @@ static int kaelz4_get_win_size() break; default: wintype = WCRYPTO_COMP_WS_32K; - US_DEBUG("KAE_LZ4_WINTYPE value out of range ：%d ,use default winsize 32", winsize); + US_DEBUG("KAE_SNAPPY_WINTYPE value out of range ：%d ,use default winsize 32", winsize); break; } - US_DEBUG("KAE_LZ4_WINTYPE wintype is ：%d ", wintype); + US_DEBUG("KAE_SNAPPY_WINTYPE wintype is ：%d ", wintype); return wintype; } -static void kaelz4_ctx_callback(const void *msg, void *tag) +static void kaesnappy_ctx_callback(const void *msg, void *tag) { const struct wcrypto_comp_msg *respmsg = msg; - kaelz4_ctx_t *kz_ctx = (kaelz4_ctx_t *)tag; + kaesnappy_ctx_t *kz_ctx = (kaesnappy_ctx_t *)tag; if (kz_ctx->callback) kz_ctx->callback(respmsg->status, kz_ctx->param); @@ -110,24 +110,24 @@ static void kaelz4_ctx_callback(const void *msg, void *tag) return; } -static kaelz4_ctx_t* kaelz4_new_ctx(KAE_QUEUE_DATA_NODE_S* q_node, int alg_comp_type, int comp_optype) +static kaesnappy_ctx_t* kaesnappy_new_ctx(KAE_QUEUE_DATA_NODE_S* q_node, int alg_comp_type, int comp_optype) { - kaelz4_ctx_t *kz_ctx = NULL; - kz_ctx = (kaelz4_ctx_t *)kae_malloc(sizeof(kaelz4_ctx_t)); + kaesnappy_ctx_t *kz_ctx = NULL; + kz_ctx = (kaesnappy_ctx_t *)kae_malloc(sizeof(kaesnappy_ctx_t)); if (unlikely(kz_ctx == NULL)) { US_ERR("kaezip ctx malloc fail."); return NULL; } - memset(kz_ctx, 0, sizeof(kaelz4_ctx_t)); - - kz_ctx->setup.comp_lv = kaelz4_get_comp_lv(); - kz_ctx->setup.win_size = kaelz4_get_win_size(); - kz_ctx->setup.br.alloc = kaelz4_wd_alloc_blk; - kz_ctx->setup.br.free = kaelz4_wd_free_blk; - kz_ctx->setup.br.iova_map = kaelz4_dma_map; - kz_ctx->setup.br.iova_unmap = kaelz4_dma_unmap; + memset(kz_ctx, 0, sizeof(kaesnappy_ctx_t)); + + kz_ctx->setup.comp_lv = kaesnappy_get_comp_lv(); + kz_ctx->setup.win_size = kaesnappy_get_win_size(); + kz_ctx->setup.br.alloc = kaesnappy_wd_alloc_blk; + kz_ctx->setup.br.free = kaesnappy_wd_free_blk; + kz_ctx->setup.br.iova_map = kaesnappy_dma_map; + kz_ctx->setup.br.iova_unmap = kaesnappy_dma_unmap; kz_ctx->setup.br.usr = q_node->kae_queue_mem_pool; - kz_ctx->setup.cb = kaelz4_ctx_callback; + kz_ctx->setup.cb = kaesnappy_ctx_callback; kz_ctx->op_data.in = kz_ctx->setup.br.alloc(kz_ctx->setup.br.usr, COMP_BLOCK_SIZE); if (kz_ctx->op_data.in == NULL) { @@ -141,11 +141,11 @@ static kaelz4_ctx_t* kaelz4_new_ctx(KAE_QUEUE_DATA_NODE_S* q_node, int alg_comp_ goto err; } - kz_ctx->op_data.priv = &kz_ctx->lz4_data; + kz_ctx->op_data.priv = &kz_ctx->snappy_data; kz_ctx->q_node = q_node; q_node->priv_ctx = kz_ctx; - if (kaelz4_create_wd_ctx(kz_ctx, alg_comp_type, comp_optype) == KAEZIP_FAILED) { + if (kaesnappy_create_wd_ctx(kz_ctx, alg_comp_type, comp_optype) == KAEZIP_FAILED) { US_ERR("create wd ctx fail!"); goto err; } @@ -153,12 +153,12 @@ static kaelz4_ctx_t* kaelz4_new_ctx(KAE_QUEUE_DATA_NODE_S* q_node, int alg_comp_ return kz_ctx; err: - kaelz4_free_kz_ctx(kz_ctx); + kaesnappy_free_kz_ctx(kz_ctx); return NULL; } -static int kaelz4_create_wd_ctx(kaelz4_ctx_t *kz_ctx, int alg_comp_type, int comp_optype) +static int kaesnappy_create_wd_ctx(kaesnappy_ctx_t *kz_ctx, int alg_comp_type, int comp_optype) { if (kz_ctx->wd_ctx != NULL) { US_WARN("wd ctx is in used by other comp"); @@ -183,21 +183,21 @@ static int kaelz4_create_wd_ctx(kaelz4_ctx_t *kz_ctx, int alg_comp_type, int com return KAEZIP_SUCCESS; } -kaelz4_ctx_t* kaelz4_get_ctx(int alg_comp_type, int comp_optype) +kaesnappy_ctx_t* kaesnappy_get_ctx(int alg_comp_type, int comp_optype) { KAE_QUEUE_DATA_NODE_S *q_node = NULL; - kaelz4_ctx_t *kz_ctx = NULL; + kaesnappy_ctx_t *kz_ctx = NULL; - KAE_QUEUE_POOL_HEAD_S* qp = kaelz4_get_qp(comp_optype); + KAE_QUEUE_POOL_HEAD_S* qp = kaesnappy_get_qp(comp_optype); if(unlikely(!qp)) { US_ERR("failed to get hardware queue pool"); return NULL; } - q_node = kaelz4_get_node_from_pool(qp, alg_comp_type, comp_optype); + q_node = kaesnappy_get_node_from_pool(qp, alg_comp_type, comp_optype); if (q_node == NULL) { - kaelz4_queue_pool_check_and_release(qp, kaelz4_free_kz_ctx); - q_node = kaelz4_get_node_from_pool(qp, alg_comp_type, comp_optype); + kaesnappy_queue_pool_check_and_release(qp, kaesnappy_free_kz_ctx); + q_node = kaesnappy_get_node_from_pool(qp, alg_comp_type, comp_optype); if (q_node == NULL) { US_ERR("failed to get hardware queue"); @@ -205,23 +205,23 @@ kaelz4_ctx_t* kaelz4_get_ctx(int alg_comp_type, int comp_optype) } } - kz_ctx = (kaelz4_ctx_t *)q_node->priv_ctx; + kz_ctx = (kaesnappy_ctx_t *)q_node->priv_ctx; if (kz_ctx == NULL) { - kz_ctx = kaelz4_new_ctx(q_node, alg_comp_type, comp_optype); + kz_ctx = kaesnappy_new_ctx(q_node, alg_comp_type, comp_optype); if (kz_ctx == NULL) { US_ERR("kaezip new engine ctx fail!"); - (void)kaelz4_put_node_to_pool(qp, q_node, kaelz4_free_kz_ctx); + (void)kaesnappy_put_node_to_pool(qp, q_node, kaesnappy_free_kz_ctx); return NULL; } } kz_ctx->q_node = q_node; - kaelz4_init_ctx(kz_ctx); + kaesnappy_init_ctx(kz_ctx); return kz_ctx; } -void kaelz4_init_ctx(kaelz4_ctx_t* kz_ctx) +void kaesnappy_init_ctx(kaesnappy_ctx_t* kz_ctx) { if(unlikely(!kz_ctx)) { US_ERR("kae zip ctx NULL!"); @@ -238,14 +238,14 @@ void kaelz4_init_ctx(kaelz4_ctx_t* kz_ctx) kz_ctx->flush = 0; kz_ctx->status = KAEZIP_COMP_INIT; - kz_ctx->lz4_data.blk_type = 2; // lz4 compressed block + kz_ctx->snappy_data.blk_type = 2; // snappy compressed block kz_ctx->callback = NULL; kz_ctx->param = NULL; memset(&kz_ctx->end_block, 0, sizeof(struct wcrypto_end_block)); } -void kaelz4_put_ctx(kaelz4_ctx_t* kz_ctx) +void kaesnappy_put_ctx(kaesnappy_ctx_t* kz_ctx) { KAE_QUEUE_DATA_NODE_S* temp = NULL; if (unlikely(kz_ctx == NULL)) { @@ -256,7 +256,7 @@ void kaelz4_put_ctx(kaelz4_ctx_t* kz_ctx) if (kz_ctx->q_node != NULL) { temp = kz_ctx->q_node; kz_ctx->q_node = NULL; - (void)kaelz4_put_node_to_pool(kaelz4_get_qp(kz_ctx->comp_type), temp, kaelz4_free_kz_ctx); + (void)kaesnappy_put_node_to_pool(kaesnappy_get_qp(kz_ctx->comp_type), temp, kaesnappy_free_kz_ctx); } kz_ctx = NULL; @@ -264,17 +264,17 @@ void kaelz4_put_ctx(kaelz4_ctx_t* kz_ctx) return; } -void kaelz4_free_ctx(kaelz4_ctx_t* kz_ctx) +void kaesnappy_free_ctx(kaesnappy_ctx_t* kz_ctx) { if (unlikely(kz_ctx == NULL)) { US_ERR("kae zip ctx NULL!"); return; } - kaelz4_free_wd_queue_memory(kz_ctx->q_node, kaelz4_free_kz_ctx); + kaesnappy_free_wd_queue_memory(kz_ctx->q_node, kaesnappy_free_kz_ctx); } -static int kaelz4_driver_do_comp_impl(kaelz4_ctx_t* kz_ctx) +static int kaesnappy_driver_do_comp_impl(kaesnappy_ctx_t* kz_ctx) { KAEZIP_RETURN_FAIL_IF(kz_ctx == NULL, "kaezip ctx is NULL.", KAEZIP_FAILED); @@ -293,39 +293,39 @@ static int kaelz4_driver_do_comp_impl(kaelz4_ctx_t* kz_ctx) return KAEZIP_SUCCESS; } -int kaelz4_driver_do_comp(kaelz4_ctx_t *kaelz4_ctx) +int kaesnappy_driver_do_comp(kaesnappy_ctx_t *kaesnappy_ctx) { - KAEZIP_RETURN_FAIL_IF(kaelz4_ctx == NULL, "kaezip ctx is NULL.", KAEZIP_FAILED); + KAEZIP_RETURN_FAIL_IF(kaesnappy_ctx == NULL, "kaezip ctx is NULL.", KAEZIP_FAILED); - if (kaelz4_ctx->remain != 0) { - return kaelz4_get_remain_data(kaelz4_ctx); + if (kaesnappy_ctx->remain != 0) { + return kaesnappy_get_remain_data(kaesnappy_ctx); } - if (kaelz4_ctx->in_len == 0) { + if (kaesnappy_ctx->in_len == 0) { US_DEBUG("kaezip do comp impl success, for input len zero, comp type : %s", - kaelz4_ctx->comp_type == WCRYPTO_DEFLATE ? "deflate" : "inflate"); + kaesnappy_ctx->comp_type == WCRYPTO_DEFLATE ? "deflate" : "inflate"); return KAEZIP_SUCCESS; } - if (kaelz4_ctx->in_len >= KAEZIP_STREAM_CHUNK_IN) { - kaelz4_ctx->do_comp_len = KAEZIP_STREAM_CHUNK_IN; + if (kaesnappy_ctx->in_len >= KAEZIP_STREAM_CHUNK_IN) { + kaesnappy_ctx->do_comp_len = KAEZIP_STREAM_CHUNK_IN; } else { - kaelz4_ctx->do_comp_len = kaelz4_ctx->in_len; + kaesnappy_ctx->do_comp_len = kaesnappy_ctx->in_len; } - kaelz4_set_input_data(kaelz4_ctx); - int ret = kaelz4_driver_do_comp_impl(kaelz4_ctx); + kaesnappy_set_input_data(kaesnappy_ctx); + int ret = kaesnappy_driver_do_comp_impl(kaesnappy_ctx); if (ret != KAEZIP_SUCCESS) { US_DEBUG("kaezip do comp impl success, comp type : %s", - kaelz4_ctx->comp_type == WCRYPTO_DEFLATE ? "deflate" : "inflate"); + kaesnappy_ctx->comp_type == WCRYPTO_DEFLATE ? "deflate" : "inflate"); return ret; } - kaelz4_get_output_data(kaelz4_ctx); + kaesnappy_get_output_data(kaesnappy_ctx); return KAEZIP_SUCCESS; } -void kaelz4_set_input_data(kaelz4_ctx_t *kz_ctx) +void kaesnappy_set_input_data(kaesnappy_ctx_t *kz_ctx) { kz_ctx->op_data.in_len = 0; @@ -340,9 +340,9 @@ void kaelz4_set_input_data(kaelz4_ctx_t *kz_ctx) } } -static void kaelz4_set_comp_status(kaelz4_ctx_t *kz_ctx) +static void kaesnappy_set_comp_status(kaesnappy_ctx_t *kz_ctx) { - US_DEBUG("kaelz4 before comp status is %u, op_data.status is %u", kz_ctx->status, kz_ctx->op_data.status); + US_DEBUG("kaesnappy before comp status is %u, op_data.status is %u", kz_ctx->status, kz_ctx->op_data.status); if (kz_ctx->comp_type == WCRYPTO_INFLATE) { switch (kz_ctx->op_data.status) { case WCRYPTO_DECOMP_END: @@ -385,15 +385,15 @@ static void kaelz4_set_comp_status(kaelz4_ctx_t *kz_ctx) break; } } - US_DEBUG("kaelz4 after comp status is %u", kz_ctx->status); + US_DEBUG("kaesnappy after comp status is %u", kz_ctx->status); } -void kaelz4_get_output_data(kaelz4_ctx_t *kz_ctx) +void kaesnappy_get_output_data(kaesnappy_ctx_t *kz_ctx) { - kaelz4_set_comp_status(kz_ctx); + kaesnappy_set_comp_status(kz_ctx); } -int kaelz4_get_remain_data(kaelz4_ctx_t *kz_ctx) +int kaesnappy_get_remain_data(kaesnappy_ctx_t *kz_ctx) { KAEZIP_RETURN_FAIL_IF(kz_ctx->op_data.produced < kz_ctx->remain, "wrong remain data", KAEZIP_FAILED); int data_begin = kz_ctx->op_data.produced - kz_ctx->remain; @@ -410,7 +410,7 @@ int kaelz4_get_remain_data(kaelz4_ctx_t *kz_ctx) return KAEZIP_SUCCESS; } -static KAE_QUEUE_POOL_HEAD_S* kaelz4_get_qp(int algtype) +static KAE_QUEUE_POOL_HEAD_S* kaesnappy_get_qp(int algtype) { if ((algtype != WCRYPTO_DEFLATE) && (algtype != WCRYPTO_INFLATE) ) { US_ERR("kaezip get q pool failed, not a support algtye %d!", algtype); @@ -418,46 +418,46 @@ static KAE_QUEUE_POOL_HEAD_S* kaelz4_get_qp(int algtype) } if (algtype == WCRYPTO_DEFLATE) { - if (g_kaelz4_deflate_qp) { - return g_kaelz4_deflate_qp; + if (g_kaesnappy_deflate_qp) { + return g_kaesnappy_deflate_qp; } - pthread_mutex_lock(&g_kaelz4_deflate_pool_init_mutex); - if (g_kaelz4_deflate_qp != NULL) { - pthread_mutex_unlock(&g_kaelz4_deflate_pool_init_mutex); - return g_kaelz4_deflate_qp; + pthread_mutex_lock(&g_kaesnappy_deflate_pool_init_mutex); + if (g_kaesnappy_deflate_qp != NULL) { + pthread_mutex_unlock(&g_kaesnappy_deflate_pool_init_mutex); + return g_kaesnappy_deflate_qp; } - kaelz4_queue_pool_destroy(g_kaelz4_deflate_qp, kaelz4_free_kz_ctx); - g_kaelz4_deflate_qp = kaelz4_init_queue_pool(algtype); - pthread_mutex_unlock(&g_kaelz4_deflate_pool_init_mutex); + kaesnappy_queue_pool_destroy(g_kaesnappy_deflate_qp, kaesnappy_free_kz_ctx); + g_kaesnappy_deflate_qp = kaesnappy_init_queue_pool(algtype); + pthread_mutex_unlock(&g_kaesnappy_deflate_pool_init_mutex); - return g_kaelz4_deflate_qp == NULL ? NULL : g_kaelz4_deflate_qp; + return g_kaesnappy_deflate_qp == NULL ? NULL : g_kaesnappy_deflate_qp; } else { - if (g_kaelz4_inflate_qp) { - return g_kaelz4_inflate_qp; + if (g_kaesnappy_inflate_qp) { + return g_kaesnappy_inflate_qp; } - pthread_mutex_lock(&g_kaelz4_inflate_pool_init_mutex); - if (g_kaelz4_inflate_qp != NULL) { - pthread_mutex_unlock(&g_kaelz4_inflate_pool_init_mutex); - return g_kaelz4_inflate_qp; + pthread_mutex_lock(&g_kaesnappy_inflate_pool_init_mutex); + if (g_kaesnappy_inflate_qp != NULL) { + pthread_mutex_unlock(&g_kaesnappy_inflate_pool_init_mutex); + return g_kaesnappy_inflate_qp; } - kaelz4_queue_pool_destroy(g_kaelz4_inflate_qp, kaelz4_free_kz_ctx); - g_kaelz4_inflate_qp = kaelz4_init_queue_pool(algtype); - pthread_mutex_unlock(&g_kaelz4_inflate_pool_init_mutex); + kaesnappy_queue_pool_destroy(g_kaesnappy_inflate_qp, kaesnappy_free_kz_ctx); + g_kaesnappy_inflate_qp = kaesnappy_init_queue_pool(algtype); + pthread_mutex_unlock(&g_kaesnappy_inflate_pool_init_mutex); - return g_kaelz4_inflate_qp == NULL ? NULL : g_kaelz4_inflate_qp; + return g_kaesnappy_inflate_qp == NULL ? NULL : g_kaesnappy_inflate_qp; } return NULL; } -void kaelz4_free_all_qps(void) +void kaesnappy_free_all_qps(void) { - pthread_mutex_lock(&g_kaelz4_deflate_pool_init_mutex); - kaelz4_queue_pool_destroy(g_kaelz4_deflate_qp, kaelz4_free_kz_ctx); - g_kaelz4_deflate_qp = NULL; - pthread_mutex_unlock(&g_kaelz4_deflate_pool_init_mutex); - pthread_mutex_lock(&g_kaelz4_inflate_pool_init_mutex); - kaelz4_queue_pool_destroy(g_kaelz4_inflate_qp, kaelz4_free_kz_ctx); - g_kaelz4_inflate_qp = NULL; - pthread_mutex_unlock(&g_kaelz4_inflate_pool_init_mutex); + pthread_mutex_lock(&g_kaesnappy_deflate_pool_init_mutex); + kaesnappy_queue_pool_destroy(g_kaesnappy_deflate_qp, kaesnappy_free_kz_ctx); + g_kaesnappy_deflate_qp = NULL; + pthread_mutex_unlock(&g_kaesnappy_deflate_pool_init_mutex); + pthread_mutex_lock(&g_kaesnappy_inflate_pool_init_mutex); + kaesnappy_queue_pool_destroy(g_kaesnappy_inflate_qp, kaesnappy_free_kz_ctx); + g_kaesnappy_inflate_qp = NULL; + pthread_mutex_unlock(&g_kaesnappy_inflate_pool_init_mutex); } diff --git a/KAESnappy/src/v1/kaesnappy_ctx.h b/KAESnappy/src/v1/kaesnappy_ctx.h index e7e57cae7bab3b57194f104d302c5d1a3a23a831..4877f9a6c52221aa416be62fc8ae0b790529c8e7 100644 --- a/KAESnappy/src/v1/kaesnappy_ctx.h +++ b/KAESnappy/src/v1/kaesnappy_ctx.h @@ -1,5 +1,5 @@ /***************************************************************************** - * @file kaelz4_ctx.h + * @file kaesnappy_ctx.h * * This file provides kaezip ctx control and driver compress funtion; * @@ -11,7 +11,7 @@ #include "wd_queue_memory.h" #include "uadk/v1/wd_comp.h" -enum kaelz4_comp_status { +enum kaesnappy_comp_status { KAEZIP_COMP_INIT = 0, KAEZIP_COMP_DOING, KAEZIP_COMP_CRC_UNCHECK, @@ -20,7 +20,7 @@ enum kaelz4_comp_status { KAEZIP_COMP_VERIFY_ERR, }; -enum kaelz4_decomp_status { +enum kaesnappy_decomp_status { KAEZIP_DECOMP_INIT = 0, KAEZIP_DECOMP_DOING, KAEZIP_DECOMP_END_BUT_DATAREMAIN, @@ -35,7 +35,7 @@ struct wcrypto_end_block { unsigned int b_set; }; -struct kaelz4_ctx { +struct kaesnappy_ctx { void *in; unsigned int in_len; void *out; @@ -48,30 +48,30 @@ struct kaelz4_ctx { int comp_alg_type; // WCRYPTO_LZ77_ZSTD int comp_type; // WCRYPTO_DEFLATE / WCRYPTO_INFLATE unsigned int do_comp_len; // a compress proccess cost len - int status; // enum kaelz4_comp_status + int status; // enum kaesnappy_comp_status struct wcrypto_end_block end_block; KAE_QUEUE_DATA_NODE_S* q_node; struct wcrypto_comp_ctx_setup setup; struct wcrypto_comp_op_data op_data; - struct wcrypto_lz77_zstd_format lz4_data; + struct wcrypto_lz77_zstd_format snappy_data; void* wd_ctx; void (*callback)(int status, void *param); void* param; }; -typedef struct kaelz4_ctx kaelz4_ctx_t; +typedef struct kaesnappy_ctx kaesnappy_ctx_t; -kaelz4_ctx_t* kaelz4_get_ctx(int alg_comp_type, int comp_optype); -void kaelz4_put_ctx(kaelz4_ctx_t* kz_ctx); -void kaelz4_init_ctx(kaelz4_ctx_t* kz_ctx); -void kaelz4_free_ctx(kaelz4_ctx_t* kz_ctx); +kaesnappy_ctx_t* kaesnappy_get_ctx(int alg_comp_type, int comp_optype); +void kaesnappy_put_ctx(kaesnappy_ctx_t* kz_ctx); +void kaesnappy_init_ctx(kaesnappy_ctx_t* kz_ctx); +void kaesnappy_free_ctx(kaesnappy_ctx_t* kz_ctx); -void kaelz4_set_input_data(kaelz4_ctx_t *kz_ctx); -void kaelz4_get_output_data(kaelz4_ctx_t *kz_ctx); +void kaesnappy_set_input_data(kaesnappy_ctx_t *kz_ctx); +void kaesnappy_get_output_data(kaesnappy_ctx_t *kz_ctx); -int kaelz4_get_remain_data(kaelz4_ctx_t *kz_ctx); -int kaelz4_driver_do_comp(kaelz4_ctx_t *kaelz4_ctx); -void kaelz4_free_all_qps(void); +int kaesnappy_get_remain_data(kaesnappy_ctx_t *kz_ctx); +int kaesnappy_driver_do_comp(kaesnappy_ctx_t *kaesnappy_ctx); +void kaesnappy_free_all_qps(void); #endif diff --git a/KAESnappy/src/v1/kaesnappy_init.c b/KAESnappy/src/v1/kaesnappy_init.c index d0c1a11b2d8404e3a577e7803c19e7a8047960de..1aa0df94c9ba6dcbebcffc6370eef3f7be05299b 100644 --- a/KAESnappy/src/v1/kaesnappy_init.c +++ b/KAESnappy/src/v1/kaesnappy_init.c @@ -9,35 +9,35 @@ #include "kaesnappy_init.h" #include "kaesnappy_log.h" -int kaelz4_init_v1(SNAPPY_CCtx* zc) +int kaesnappy_init_v1(SNAPPY_CCtx* zc) { - kaelz4_ctx_t* kaelz4_ctx = kaelz4_get_ctx(WCRYPTO_LZ77_ONLY, WCRYPTO_DEFLATE); - if (!kaelz4_ctx) { - US_ERR("kaelz4 failed to get kaezip ctx!"); + kaesnappy_ctx_t* kaesnappy_ctx = kaesnappy_get_ctx(WCRYPTO_LZ77_ONLY, WCRYPTO_DEFLATE); + if (!kaesnappy_ctx) { + US_ERR("kaesnappy failed to get kaezip ctx!"); return KAE_SNAPPY_INIT_FAIL; } - zc->kaeConfig = (uintptr_t)kaelz4_ctx; + zc->kaeConfig = (uintptr_t)kaesnappy_ctx; - US_INFO("kaelz4 deflate init success, kaelz4_ctx %p!", kaelz4_ctx); + US_INFO("kaesnappy deflate init success, kaesnappy_ctx %p!", kaesnappy_ctx); return KAE_SNAPPY_SUCC; } -void kaelz4_reset_v1(SNAPPY_CCtx* zc) +void kaesnappy_reset_v1(SNAPPY_CCtx* zc) { - kaelz4_ctx_t* kaelz4_ctx = (kaelz4_ctx_t*)zc->kaeConfig; - if (kaelz4_ctx) { - kaelz4_ctx->status = KAEZIP_COMP_INIT; - kaelz4_ctx->lz4_data.blk_type = 2; // lz4 compressed block - US_DEBUG("kaelz4 reset v1"); + kaesnappy_ctx_t* kaesnappy_ctx = (kaesnappy_ctx_t*)zc->kaeConfig; + if (kaesnappy_ctx) { + kaesnappy_ctx->status = KAEZIP_COMP_INIT; + kaesnappy_ctx->snappy_data.blk_type = 2; // snappy compressed block + US_DEBUG("kaesnappy reset v1"); } } -void kaelz4_release_v1(SNAPPY_CCtx* zc) +void kaesnappy_release_v1(SNAPPY_CCtx* zc) { - kaelz4_ctx_t* kaelz4_ctx = (kaelz4_ctx_t*)zc->kaeConfig; - if (kaelz4_ctx) { - kaelz4_put_ctx(kaelz4_ctx); - US_INFO("kaelz4 release v1"); + kaesnappy_ctx_t* kaesnappy_ctx = (kaesnappy_ctx_t*)zc->kaeConfig; + if (kaesnappy_ctx) { + kaesnappy_put_ctx(kaesnappy_ctx); + US_INFO("kaesnappy release v1"); } zc->kaeConfig = 0; } diff --git a/KAESnappy/src/v1/kaesnappy_init.h b/KAESnappy/src/v1/kaesnappy_init.h index 66142b956ae0cac2f3388d2d3f061853c6a6f751..eeaf79805f0c2c7789041d91f3c18c6fb4afbd76 100644 --- a/KAESnappy/src/v1/kaesnappy_init.h +++ b/KAESnappy/src/v1/kaesnappy_init.h @@ -11,8 +11,8 @@ #include "kaesnappy_common.h" -int kaelz4_init_v1(SNAPPY_CCtx* zc); -void kaelz4_reset_v1(SNAPPY_CCtx* zc); -void kaelz4_release_v1(SNAPPY_CCtx* zc); +int kaesnappy_init_v1(SNAPPY_CCtx* zc); +void kaesnappy_reset_v1(SNAPPY_CCtx* zc); +void kaesnappy_release_v1(SNAPPY_CCtx* zc); #endif \ No newline at end of file diff --git a/KAESnappy/src/v1/wd_queue_memory.c b/KAESnappy/src/v1/wd_queue_memory.c index 32dce6d23e17744fc1e7bf7e35f0c2e1b04da545..1446d0a5a7c155763ae7991fd4b5e29cebf40280 100644 --- a/KAESnappy/src/v1/wd_queue_memory.c +++ b/KAESnappy/src/v1/wd_queue_memory.c @@ -12,10 +12,10 @@ #include "uadk/v1/wd_comp.h" #include "kaesnappy_ctx.h" -void kaelz4_wd_free_queue(struct wd_queue* queue); -struct wd_queue* kaelz4_wd_new_queue(int comp_alg_type, int comp_optype); +void kaesnappy_wd_free_queue(struct wd_queue* queue); +struct wd_queue* kaesnappy_wd_new_queue(int comp_alg_type, int comp_optype); -struct wd_queue* kaelz4_wd_new_queue(int comp_alg_type, int comp_optype) +struct wd_queue* kaesnappy_wd_new_queue(int comp_alg_type, int comp_optype) { struct wd_queue* queue = (struct wd_queue *)kae_malloc(sizeof(struct wd_queue)); if (queue == NULL) { @@ -55,7 +55,7 @@ struct wd_queue* kaelz4_wd_new_queue(int comp_alg_type, int comp_optype) return queue; } -void kaelz4_wd_free_queue(struct wd_queue* queue) +void kaesnappy_wd_free_queue(struct wd_queue* queue) { if (queue != NULL) { wd_release_queue(queue); @@ -64,7 +64,7 @@ void kaelz4_wd_free_queue(struct wd_queue* queue) } } -void* kaelz4_create_alg_wd_queue_mempool(struct wd_queue *q) +void* kaesnappy_create_alg_wd_queue_mempool(struct wd_queue *q) { unsigned int block_size = COMP_BLOCK_SIZE; unsigned int block_num = COMP_BLOCK_NUM; @@ -80,22 +80,22 @@ void* kaelz4_create_alg_wd_queue_mempool(struct wd_queue *q) return mempool; } -void kaelz4_wd_queue_mempool_destroy(void *pool) +void kaesnappy_wd_queue_mempool_destroy(void *pool) { return wd_blkpool_destroy(pool); } -void *kaelz4_dma_map(void *usr, void *va, size_t sz) +void *kaesnappy_dma_map(void *usr, void *va, size_t sz) { return wd_blk_iova_map(usr, va); } -void kaelz4_dma_unmap(void *usr, void *va, void *dma, size_t sz) +void kaesnappy_dma_unmap(void *usr, void *va, void *dma, size_t sz) { return wd_blk_iova_unmap(usr, dma, va); } -void *kaelz4_wd_alloc_blk(void *pool, size_t size) +void *kaesnappy_wd_alloc_blk(void *pool, size_t size) { if (pool == NULL) { US_ERR("mem pool empty!"); @@ -105,12 +105,12 @@ void *kaelz4_wd_alloc_blk(void *pool, size_t size) return wd_alloc_blk(pool); } -void kaelz4_wd_free_blk(void *pool, void *blk) +void kaesnappy_wd_free_blk(void *pool, void *blk) { return wd_free_blk(pool, blk); } -KAE_QUEUE_POOL_HEAD_S* kaelz4_init_queue_pool(int algtype) +KAE_QUEUE_POOL_HEAD_S* kaesnappy_init_queue_pool(int algtype) { KAE_QUEUE_POOL_HEAD_S *kae_pool = NULL; @@ -141,7 +141,7 @@ KAE_QUEUE_POOL_HEAD_S* kaelz4_init_queue_pool(int algtype) return kae_pool; } -static KAE_QUEUE_DATA_NODE_S* kaelz4_get_queue_data_from_list(KAE_QUEUE_POOL_HEAD_S* pool_head, int type) +static KAE_QUEUE_DATA_NODE_S* kaesnappy_get_queue_data_from_list(KAE_QUEUE_POOL_HEAD_S* pool_head, int type) { int i = 0; KAE_QUEUE_DATA_NODE_S *queue_data_node = NULL; @@ -183,7 +183,7 @@ static KAE_QUEUE_DATA_NODE_S* kaelz4_get_queue_data_from_list(KAE_QUEUE_POOL_HEA return queue_data_node; } -void kaelz4_free_wd_queue_memory(KAE_QUEUE_DATA_NODE_S *queue_node, kae_release_priv_ctx_cb release_fn) +void kaesnappy_free_wd_queue_memory(KAE_QUEUE_DATA_NODE_S *queue_node, kae_release_priv_ctx_cb release_fn) { if (queue_node != NULL) { if (release_fn != NULL && queue_node->priv_ctx != NULL) { @@ -192,11 +192,11 @@ void kaelz4_free_wd_queue_memory(KAE_QUEUE_DATA_NODE_S *queue_node, kae_release_ } if (queue_node->kae_queue_mem_pool != NULL) { - kaelz4_wd_queue_mempool_destroy(queue_node->kae_queue_mem_pool); + kaesnappy_wd_queue_mempool_destroy(queue_node->kae_queue_mem_pool); queue_node->kae_queue_mem_pool = NULL; } if (queue_node->kae_wd_queue != NULL) { - kaelz4_wd_free_queue(queue_node->kae_wd_queue); + kaesnappy_wd_free_queue(queue_node->kae_wd_queue); queue_node->kae_wd_queue = NULL; } @@ -207,7 +207,7 @@ void kaelz4_free_wd_queue_memory(KAE_QUEUE_DATA_NODE_S *queue_node, kae_release_ US_DEBUG("free wd queue success"); } -static KAE_QUEUE_DATA_NODE_S* kaelz4_new_wd_queue_memory(int comp_alg_type, int comp_type) +static KAE_QUEUE_DATA_NODE_S* kaesnappy_new_wd_queue_memory(int comp_alg_type, int comp_type) { KAE_QUEUE_DATA_NODE_S *queue_node = NULL; @@ -218,13 +218,13 @@ static KAE_QUEUE_DATA_NODE_S* kaelz4_new_wd_queue_memory(int comp_alg_type, int } memset(queue_node, 0, sizeof(KAE_QUEUE_DATA_NODE_S)); - queue_node->kae_wd_queue = kaelz4_wd_new_queue(comp_alg_type, comp_type); + queue_node->kae_wd_queue = kaesnappy_wd_new_queue(comp_alg_type, comp_type); if (queue_node->kae_wd_queue == NULL) { US_ERR("new wd queue fail"); goto err; } - queue_node->kae_queue_mem_pool = kaelz4_create_alg_wd_queue_mempool(queue_node->kae_wd_queue); + queue_node->kae_queue_mem_pool = kaesnappy_create_alg_wd_queue_mempool(queue_node->kae_wd_queue); if (queue_node->kae_queue_mem_pool == NULL) { US_ERR("request mempool fail!"); goto err; @@ -234,11 +234,11 @@ static KAE_QUEUE_DATA_NODE_S* kaelz4_new_wd_queue_memory(int comp_alg_type, int return queue_node; err: - kaelz4_free_wd_queue_memory(queue_node, NULL); + kaesnappy_free_wd_queue_memory(queue_node, NULL); return NULL; } -KAE_QUEUE_DATA_NODE_S* kaelz4_get_node_from_pool(KAE_QUEUE_POOL_HEAD_S* pool_head, int comp_alg_type, int comp_type) +KAE_QUEUE_DATA_NODE_S* kaesnappy_get_node_from_pool(KAE_QUEUE_POOL_HEAD_S* pool_head, int comp_alg_type, int comp_type) { KAE_QUEUE_DATA_NODE_S *queue_data_node = NULL; @@ -247,15 +247,15 @@ KAE_QUEUE_DATA_NODE_S* kaelz4_get_node_from_pool(KAE_QUEUE_POOL_HEAD_S* pool_hea return NULL; } - queue_data_node = kaelz4_get_queue_data_from_list(pool_head, comp_alg_type); + queue_data_node = kaesnappy_get_queue_data_from_list(pool_head, comp_alg_type); if (queue_data_node == NULL) { - queue_data_node = kaelz4_new_wd_queue_memory(comp_alg_type, comp_type); + queue_data_node = kaesnappy_new_wd_queue_memory(comp_alg_type, comp_type); } return queue_data_node; } -static void kaelz4_set_pool_use_num(KAE_QUEUE_POOL_HEAD_S *pool, int set_num) +static void kaesnappy_set_pool_use_num(KAE_QUEUE_POOL_HEAD_S *pool, int set_num) { pthread_mutex_lock(&pool->kae_queue_mutex); if (set_num > pool->pool_use_num) { @@ -264,7 +264,7 @@ static void kaelz4_set_pool_use_num(KAE_QUEUE_POOL_HEAD_S *pool, int set_num) (void)pthread_mutex_unlock(&pool->kae_queue_mutex); } -int kaelz4_put_node_to_pool(KAE_QUEUE_POOL_HEAD_S* pool_head, KAE_QUEUE_DATA_NODE_S* node_data, kae_release_priv_ctx_cb release_fn) +int kaesnappy_put_node_to_pool(KAE_QUEUE_POOL_HEAD_S* pool_head, KAE_QUEUE_DATA_NODE_S* node_data, kae_release_priv_ctx_cb release_fn) { int i = 0; KAE_QUEUE_POOL_HEAD_S *temp_pool = pool_head; @@ -289,7 +289,7 @@ int kaelz4_put_node_to_pool(KAE_QUEUE_POOL_HEAD_S* pool_head, KAE_QUEUE_DATA_NO temp_pool->kae_queue_pool[i].add_time = time((time_t *)NULL); KAE_SPIN_UNLOCK(temp_pool->kae_queue_pool[i].spinlock); if (i >= temp_pool->pool_use_num) { - kaelz4_set_pool_use_num(temp_pool, i + 1); + kaesnappy_set_pool_use_num(temp_pool, i + 1); } US_DEBUG("kaezip put queue node to pool, queue node id is %d.", i); @@ -303,7 +303,7 @@ int kaelz4_put_node_to_pool(KAE_QUEUE_POOL_HEAD_S* pool_head, KAE_QUEUE_DATA_NO if (temp_pool == NULL) { pthread_mutex_lock(&last_pool->destroy_mutex); if (last_pool->next == NULL) { - temp_pool = kaelz4_init_queue_pool(last_pool->algtype); + temp_pool = kaesnappy_init_queue_pool(last_pool->algtype); if (temp_pool == NULL) { (void)pthread_mutex_unlock(&last_pool->destroy_mutex); break; @@ -314,17 +314,17 @@ int kaelz4_put_node_to_pool(KAE_QUEUE_POOL_HEAD_S* pool_head, KAE_QUEUE_DATA_NO } } /* if not added,free it */ - kaelz4_free_wd_queue_memory(node_data, release_fn); + kaesnappy_free_wd_queue_memory(node_data, release_fn); return 0; } -void kaelz4_queue_pool_reset(KAE_QUEUE_POOL_HEAD_S* pool_head) +void kaesnappy_queue_pool_reset(KAE_QUEUE_POOL_HEAD_S* pool_head) { (void)pool_head; return; } -void kaelz4_queue_pool_destroy(KAE_QUEUE_POOL_HEAD_S* pool_head, kae_release_priv_ctx_cb release_fn) +void kaesnappy_queue_pool_destroy(KAE_QUEUE_POOL_HEAD_S* pool_head, kae_release_priv_ctx_cb release_fn) { int error = 0; int i = 0; @@ -347,7 +347,7 @@ void kaelz4_queue_pool_destroy(KAE_QUEUE_POOL_HEAD_S* pool_head, kae_release_pri for (i = 0; i < cur_pool->pool_use_num; i++) { queue_data_node = cur_pool->kae_queue_pool[i].node_data; if (queue_data_node != NULL) { - kaelz4_free_wd_queue_memory(queue_data_node, release_fn); + kaesnappy_free_wd_queue_memory(queue_data_node, release_fn); US_DEBUG("kae queue node destroy success. queue_node id =%d", i); cur_pool->kae_queue_pool[i].node_data = NULL; } @@ -372,7 +372,7 @@ void kaelz4_queue_pool_destroy(KAE_QUEUE_POOL_HEAD_S* pool_head, kae_release_pri return; } -void kaelz4_queue_pool_check_and_release(KAE_QUEUE_POOL_HEAD_S* pool_head, kae_release_priv_ctx_cb release_fn) +void kaesnappy_queue_pool_check_and_release(KAE_QUEUE_POOL_HEAD_S* pool_head, kae_release_priv_ctx_cb release_fn) { int i = 0; int error; @@ -414,7 +414,7 @@ void kaelz4_queue_pool_check_and_release(KAE_QUEUE_POOL_HEAD_S* pool_head, kae_r cur_pool->kae_queue_pool[i].node_data = (KAE_QUEUE_DATA_NODE_S *)NULL; KAE_SPIN_UNLOCK(cur_pool->kae_queue_pool[i].spinlock); - kaelz4_free_wd_queue_memory(queue_data_node, release_fn); + kaesnappy_free_wd_queue_memory(queue_data_node, release_fn); US_DEBUG("hpre queue list release success. queue node id =%d", i); } diff --git a/KAESnappy/src/v1/wd_queue_memory.h b/KAESnappy/src/v1/wd_queue_memory.h index 215a05fa64328c9adb2f518f22cec6c0b43243d4..3695b69b359661fd6e0cbc59459ddcbc28ce774c 100644 --- a/KAESnappy/src/v1/wd_queue_memory.h +++ b/KAESnappy/src/v1/wd_queue_memory.h @@ -61,18 +61,18 @@ typedef struct KAE_QUEUE_POOL_HEAD { KAE_QUEUE_POOL_NODE_S *kae_queue_pool; /* point to a attray */ } KAE_QUEUE_POOL_HEAD_S; -void kaelz4_wd_free_blk(void *pool, void *blk); -void *kaelz4_wd_alloc_blk(void *pool, size_t size); -void *kaelz4_dma_map(void *usr, void *va, size_t sz); -void kaelz4_dma_unmap(void *usr, void *va, void *dma, size_t sz); +void kaesnappy_wd_free_blk(void *pool, void *blk); +void *kaesnappy_wd_alloc_blk(void *pool, size_t size); +void *kaesnappy_dma_map(void *usr, void *va, size_t sz); +void kaesnappy_dma_unmap(void *usr, void *va, void *dma, size_t sz); -KAE_QUEUE_POOL_HEAD_S* kaelz4_init_queue_pool (int algtype); -KAE_QUEUE_DATA_NODE_S* kaelz4_get_node_from_pool(KAE_QUEUE_POOL_HEAD_S* pool_head, int alg_comp_type, int comp_optype); -int kaelz4_put_node_to_pool(KAE_QUEUE_POOL_HEAD_S* pool_head, KAE_QUEUE_DATA_NODE_S* node_data, kae_release_priv_ctx_cb release_fn); -void kaelz4_free_wd_queue_memory(KAE_QUEUE_DATA_NODE_S *queue_node, kae_release_priv_ctx_cb release_fn); -void kaelz4_queue_pool_reset(KAE_QUEUE_POOL_HEAD_S* pool_head); -void kaelz4_queue_pool_destroy(KAE_QUEUE_POOL_HEAD_S* pool_head, kae_release_priv_ctx_cb release_fn); -void kaelz4_queue_pool_check_and_release(KAE_QUEUE_POOL_HEAD_S* pool_head, kae_release_priv_ctx_cb release_ectx_fn); +KAE_QUEUE_POOL_HEAD_S* kaesnappy_init_queue_pool (int algtype); +KAE_QUEUE_DATA_NODE_S* kaesnappy_get_node_from_pool(KAE_QUEUE_POOL_HEAD_S* pool_head, int alg_comp_type, int comp_optype); +int kaesnappy_put_node_to_pool(KAE_QUEUE_POOL_HEAD_S* pool_head, KAE_QUEUE_DATA_NODE_S* node_data, kae_release_priv_ctx_cb release_fn); +void kaesnappy_free_wd_queue_memory(KAE_QUEUE_DATA_NODE_S *queue_node, kae_release_priv_ctx_cb release_fn); +void kaesnappy_queue_pool_reset(KAE_QUEUE_POOL_HEAD_S* pool_head); +void kaesnappy_queue_pool_destroy(KAE_QUEUE_POOL_HEAD_S* pool_head, kae_release_priv_ctx_cb release_fn); +void kaesnappy_queue_pool_check_and_release(KAE_QUEUE_POOL_HEAD_S* pool_head, kae_release_priv_ctx_cb release_ectx_fn); #endif diff --git a/KAESnappy/src/v2/kaesnappy_compress.c b/KAESnappy/src/v2/kaesnappy_compress.c index c7713e7e0d633bea197ca63431e3227a6e8b909a..03defb9d6388b8644b6c38170e788317a238b226 100644 --- a/KAESnappy/src/v2/kaesnappy_compress.c +++ b/KAESnappy/src/v2/kaesnappy_compress.c @@ -19,14 +19,14 @@ #include "kaesnappy_config.h" #include "kaesnappy_log.h" -void kaelz4_setstatus_v2(SNAPPY_CCtx* zc, unsigned int status) +void kaesnappy_setstatus_v2(SNAPPY_CCtx* zc, unsigned int status) { - KaeLz4Config *config; - config = kaelz4_get_config(zc); + KaeSnappyConfig *config; + config = kaesnappy_get_config(zc); config->tuple.bstatus = status; } -static int kaelz4_data_parsing(SNAPPY_CCtx* zc, KaeLz4Config* config) +static int kaesnappy_data_parsing(SNAPPY_CCtx* zc, KaeSnappyConfig* config) { if (config->tuple.litStart == NULL || config->tuple.sequencesStart == NULL) { US_ERR("config parameter invalid\n"); @@ -48,18 +48,18 @@ static int kaelz4_data_parsing(SNAPPY_CCtx* zc, KaeLz4Config* config) return 0; } -int kaelz4_compress_v2(SNAPPY_CCtx* zc, const void* src, size_t srcSize) +int kaesnappy_compress_v2(SNAPPY_CCtx* zc, const void* src, size_t srcSize) { - KaeLz4Config *config = NULL; + KaeSnappyConfig *config = NULL; int ret; - US_INFO("KAE lz4 compress, srcSize is %lu", srcSize); + US_INFO("KAE snappy compress, srcSize is %lu", srcSize); if (zc == NULL || src == NULL || srcSize == 0) { US_ERR("compress parameter invalid\n"); return KAE_SNAPPY_INVAL_PARA; } - config = kaelz4_get_config(zc); + config = kaesnappy_get_config(zc); config->req.src = (void*)src; config->req.src_len = srcSize; @@ -75,5 +75,5 @@ int kaelz4_compress_v2(SNAPPY_CCtx* zc, const void* src, size_t srcSize) config->tuple.litlen, config->tuple.seqnum, config->tuple.longLengthType, config->tuple.longLengthPos); } - return kaelz4_data_parsing(zc, config); + return kaesnappy_data_parsing(zc, config); } diff --git a/KAESnappy/src/v2/kaesnappy_config.c b/KAESnappy/src/v2/kaesnappy_config.c index 3faa9397151416ac0ae0319f96504ecfa96a8023..6bb0360fec3683e36bf581d892f08f8ae0b4739d 100644 --- a/KAESnappy/src/v2/kaesnappy_config.c +++ b/KAESnappy/src/v2/kaesnappy_config.c @@ -23,32 +23,32 @@ #define CTX_SET_SIZE 4 #define CTX_SET_NUM 1 -enum lz4_init_status { - KAE_LZ4_UNINIT, - KAE_LZ4_INIT, +enum snappy_init_status { + KAE_SNAPPY_UNINIT, + KAE_SNAPPY_INIT, }; -struct kz_lz4wrapper_config { +struct kz_snappywrapper_config { int count; int status; }; -static struct kz_lz4wrapper_config lz4_config = {0}; -static pthread_mutex_t kz_lz4_mutex = PTHREAD_MUTEX_INITIALIZER; +static struct kz_snappywrapper_config snappy_config = {0}; +static pthread_mutex_t kz_snappy_mutex = PTHREAD_MUTEX_INITIALIZER; -static inline int kaelz4_lock() +static inline int kaesnappy_lock() { - return pthread_mutex_lock(&kz_lz4_mutex); + return pthread_mutex_lock(&kz_snappy_mutex); } -static inline int kaelz4_unlock() +static inline int kaesnappy_unlock() { - return pthread_mutex_unlock(&kz_lz4_mutex); + return pthread_mutex_unlock(&kz_snappy_mutex); } -inline KaeLz4Config* kaelz4_get_config(SNAPPY_CCtx* zc) +inline KaeSnappyConfig* kaesnappy_get_config(SNAPPY_CCtx* zc) { - KaeLz4Config* config = (KaeLz4Config*)(zc->kaeConfig); + KaeSnappyConfig* config = (KaeSnappyConfig*)(zc->kaeConfig); if (config != NULL) { return config; @@ -57,17 +57,17 @@ inline KaeLz4Config* kaelz4_get_config(SNAPPY_CCtx* zc) } } -inline void kaelz4_set_config(SNAPPY_CCtx* zc, KaeLz4Config* config) +inline void kaesnappy_set_config(SNAPPY_CCtx* zc, KaeSnappyConfig* config) { if (zc != NULL) { zc->kaeConfig = (uintptr_t)config; } } -static inline void kaelz4_options_init(KaeLz4Config *config) +static inline void kaesnappy_options_init(KaeSnappyConfig *config) { - config->opts.ctx_num = KAELZ4_DEFAULT_CTX_NUM; - config->opts.thread_num = KAELZ4_DEFAULT_THREAD_NUM; + config->opts.ctx_num = KAESNAPPY_DEFAULT_CTX_NUM; + config->opts.thread_num = KAESNAPPY_DEFAULT_THREAD_NUM; } // level 8\9 win 0-4 @@ -116,31 +116,31 @@ static void Compression_level_conversion(int reqlevel, int* kae_lev, int* kae_wi } } -static int kaelz4_get_level_by_env() +static int kaesnappy_get_level_by_env() { - char *lz4_str = getenv("KAE_LZ4_LEVEL"); - if (lz4_str == NULL) { - US_DEBUG("KAE_LZ4_LEVEL is NULL\n"); + char *snappy_str = getenv("KAE_SNAPPY_LEVEL"); + if (snappy_str == NULL) { + US_DEBUG("KAE_SNAPPY_LEVEL is NULL\n"); return -1; } - int lz4_val = atoi(lz4_str); - if (lz4_val < 1 || lz4_val > 22) { - US_DEBUG("KAE_LZ4_LEVEL value out of range ：%d ", lz4_val); + int snappy_val = atoi(snappy_str); + if (snappy_val < 1 || snappy_val > 22) { + US_DEBUG("KAE_SNAPPY_LEVEL value out of range ：%d ", snappy_val); return -1; } - US_DEBUG("KAE_LZ4_LEVEL value is ：%d ", lz4_val); - return lz4_val; + US_DEBUG("KAE_SNAPPY_LEVEL value is ：%d ", snappy_val); + return snappy_val; } -static int kaelz4_create_session(KaeLz4Config *config, int lz4_level) +static int kaesnappy_create_session(KaeSnappyConfig *config, int snappy_level) { struct sched_params param = {0}; int kaeLev, kaeWin, reqlevel; - int env_level = kaelz4_get_level_by_env(); + int env_level = kaesnappy_get_level_by_env(); if (env_level > 0) { reqlevel = env_level; } else { - reqlevel = lz4_level; + reqlevel = snappy_level; } Compression_level_conversion(reqlevel, &kaeLev, &kaeWin); @@ -165,29 +165,29 @@ static int kaelz4_create_session(KaeLz4Config *config, int lz4_level) return 0; } -static inline void lz4_uadk_uninit(void) +static inline void snappy_uadk_uninit(void) { return wd_comp_uninit2(); } -# define KAELZ4_CTX_SET_NUM 1 -static int kaelz4_alg_init2(void) +# define KAESNAPPY_CTX_SET_NUM 1 +static int kaesnappy_alg_init2(void) { struct wd_ctx_nums *ctx_set_num; struct wd_ctx_params cparams = {0}; int ret, i; - if (lz4_config.status == 1) { + if (snappy_config.status == 1) { // 进程已经初始化过，直接返回 return 0; } - ctx_set_num = calloc(KAELZ4_CTX_SET_NUM, sizeof(*ctx_set_num)); + ctx_set_num = calloc(KAESNAPPY_CTX_SET_NUM, sizeof(*ctx_set_num)); if (!ctx_set_num) { WD_ERR("failed to alloc ctx_set_size!\n"); return KAE_SNAPPY_ALLOC_FAIL; } - cparams.op_type_num = KAELZ4_CTX_SET_NUM; + cparams.op_type_num = KAESNAPPY_CTX_SET_NUM; cparams.ctx_set_num = ctx_set_num; cparams.bmp = numa_allocate_nodemask(); if (!cparams.bmp) { @@ -208,7 +208,7 @@ static int kaelz4_alg_init2(void) US_DEBUG("cpu is %d, numa_niode_of_cpu is %d, dev-numaid is %d\n", cpu, node, dev->numa_id); for (i = 0; i < 1; i++) - ctx_set_num[i].sync_ctx_num = KAELZ4_CTX_SET_NUM; + ctx_set_num[i].sync_ctx_num = KAESNAPPY_CTX_SET_NUM; ret = wd_comp_init2_("lz77_zstd", 0, 1, &cparams); if (ret && ret != -WD_EEXIST) { @@ -216,8 +216,8 @@ static int kaelz4_alg_init2(void) ret = KAE_SNAPPY_INIT_FAIL; goto out_freedev; } - atexit(lz4_uadk_uninit); // 注册退出处理函数 - lz4_config.status = 1; + atexit(snappy_uadk_uninit); // 注册退出处理函数 + snappy_config.status = 1; out_freedev: free(dev); @@ -229,53 +229,53 @@ out_freectx: return ret; } -int kaelz4_init_v2(SNAPPY_CCtx* zc) +int kaesnappy_init_v2(SNAPPY_CCtx* zc) { int ret; - KaeLz4Config *config = NULL; + KaeSnappyConfig *config = NULL; - US_DEBUG("Begin init KAE-v2 lz4."); - config = (KaeLz4Config*)malloc(sizeof(KaeLz4Config)); + US_DEBUG("Begin init KAE-v2 snappy."); + config = (KaeSnappyConfig*)malloc(sizeof(KaeSnappyConfig)); if (config == NULL) { US_ERR("failed to alloc config!\n"); return KAE_SNAPPY_INIT_FAIL; } - memset(config, 0, sizeof(KaeLz4Config)); - kaelz4_options_init(config); + memset(config, 0, sizeof(KaeSnappyConfig)); + kaesnappy_options_init(config); - kaelz4_lock(); - ret = kaelz4_alg_init2(); + kaesnappy_lock(); + ret = kaesnappy_alg_init2(); if (ret) { - US_ERR("failed to kaelz4_alg_init2!\n"); + US_ERR("failed to kaesnappy_alg_init2!\n"); goto free_config; } - ret = kaelz4_create_session(config, zc->kaeLevel); + ret = kaesnappy_create_session(config, zc->kaeLevel); if (ret) { US_ERR("failed to init session!\n"); goto free_config; } - kaelz4_unlock(); + kaesnappy_unlock(); - kaelz4_set_config(zc, config); + kaesnappy_set_config(zc, config); - __atomic_fetch_add(&lz4_config.count, 1, __ATOMIC_SEQ_CST); + __atomic_fetch_add(&snappy_config.count, 1, __ATOMIC_SEQ_CST); return ret; free_config: free(config); - kaelz4_unlock(); + kaesnappy_unlock(); return KAE_SNAPPY_INIT_FAIL; } -void kaelz4_release_v2(SNAPPY_CCtx* zc) +void kaesnappy_release_v2(SNAPPY_CCtx* zc) { - KaeLz4Config *config = NULL; + KaeSnappyConfig *config = NULL; if (zc == NULL) { return; } - config = kaelz4_get_config(zc); + config = kaesnappy_get_config(zc); wd_comp_free_sess(config->sess); free(config->req.dst); free(config); diff --git a/KAESnappy/src/v2/kaesnappy_config.h b/KAESnappy/src/v2/kaesnappy_config.h index d90d503a9c38525fa0ccf34fd7cbcc615d614069..d168e9065ee2658bf0b930f9d747c7cd37b49fab 100644 --- a/KAESnappy/src/v2/kaesnappy_config.h +++ b/KAESnappy/src/v2/kaesnappy_config.h @@ -46,7 +46,7 @@ typedef struct Info_S { struct wd_ctx_config ctx_config; } Info; -typedef struct KaeLz4Config_S { +typedef struct KaeSnappyConfig_S { Info info; Options opts; @@ -55,16 +55,16 @@ typedef struct KaeLz4Config_S { struct wd_comp_req req; Comp4Tuple tuple; -} KaeLz4Config; +} KaeSnappyConfig; -#define KAELZ4_DEFAULT_CTX_NUM 1 -#define KAELZ4_DEFAULT_THREAD_NUM 1 +#define KAESNAPPY_DEFAULT_CTX_NUM 1 +#define KAESNAPPY_DEFAULT_THREAD_NUM 1 #define REQ_SRCBUFF_LEN (128 * 1024) #define REQ_DSTBUFF_LEN (128 * 1024 * 10) #define REQ_WINDOW_SIZE 2 #define REQ_COMPRESS_LEVEL 8 -KaeLz4Config* kaelz4_get_config(SNAPPY_CCtx* zc); -void kaelz4_set_config(SNAPPY_CCtx* zc, KaeLz4Config* config); +KaeSnappyConfig* kaesnappy_get_config(SNAPPY_CCtx* zc); +void kaesnappy_set_config(SNAPPY_CCtx* zc, KaeSnappyConfig* config); #endif