merge updates from develop

.github/workflows/ubuntu.yml

@@ -159,15 +159,60 @@ jobs:
             -DENABLE_TEST_COVERAGE=ON \
             -DCMAKE_TOOLCHAIN_FILE="$TOOLCHAIN_FILE"
           cmake --build . --config Debug
-          ctest --output-on-failure || true
+
+          # Create empty coverage files to ensure they exist
+          find . -name "*.gcda" -exec rm {} \; 2>/dev/null || true
+          find . -name "*.gcno" -exec touch {} \; 2>/dev/null || true
+
+          # Run tests one by one to ensure proper execution and output
+          echo "Running tests individually..."
+          for test_file in $(find . -name "NovaLLMTests*" -type f -executable); do
+            echo "Running $test_file..."
+            $test_file --gtest_output=xml:test_results.xml --gtest_filter="*Concurrent*" || (
+              echo "Test $test_file completed with issues, checking for coverage data..."
+            )
+          done
+
+          # Explicitly run ctest
+          ctest --output-on-failure --verbose || echo "ctest failed, proceeding to coverage..."
       - name: Generate coverage report
         run: |
           cd build-coverage
-          # lcov --directory . --capture --output-file coverage.info
-          # Added --ignore-errors mismatch to handle GTest/GCC 13 issues
-          lcov --directory . --capture --output-file coverage.info --ignore-errors mismatch
-          lcov --remove coverage.info '/usr/*' '*/test/*' '*/conan/*' --output-file coverage.info
-          lcov --list coverage.info
+          echo "Checking for .gcda files..."
+          find . -name "*.gcda" -type f | head -10
+
+          # Capture coverage data with better error handling
+          echo "Capturing coverage data..."
+          lcov --directory . \
+               --capture \
+               --output-file coverage.info \
+               --ignore-errors mismatch,gcov,unused \
+               --no-external \
+               --base-directory $GITHUB_WORKSPACE || echo "lcov capture had issues, proceeding..."
+
+          # Check if coverage.info was created and has content
+          if [ -f coverage.info ]; then
+            echo "Coverage file created, size: $(du -h coverage.info)"
+            cat coverage.info | head -20
+
+            # Remove unwanted paths
+            echo "Removing unwanted paths..."
+            lcov --remove coverage.info \
+                 '/usr/*' \
+                 '*/test/*' \
+                 '*/conan/*' \
+                 '*/CMakeFiles/*' \
+                 '*/build*/*' \
+                 --output-file coverage_cleaned.info \
+                 --ignore-errors mismatch,gcov,unused
+
+            # Check final coverage
+            echo "Final coverage report:"
+            lcov --list coverage_cleaned.info
+            mv coverage_cleaned.info coverage.info
+          else
+            echo "Coverage file not created, skipping removal step"
+          fi
       - name: Upload coverage to Codecov
         uses: codecov/codecov-action@v4
         with:

include/NovaLLM/common/device.h

@@ -8,16 +8,16 @@ enum class DeviceType : uint32_t { UNKNOWN = 0, CPU = 0x01, CUDA = 0x02, METAL =
 
 struct DeviceTypeFlags {
  public:
-  [[nodiscard]] bool has(DeviceType type) const;
+   [[nodiscard]] NOVA_LLM_API bool has(DeviceType type) const;
 
-  void set(DeviceType type);
+  NOVA_LLM_API void set(DeviceType type);
 
-  void clear(DeviceType type);
+  NOVA_LLM_API void clear(DeviceType type);
 
-  [[nodiscard]] constexpr DeviceType get() const;
+  [[nodiscard]] NOVA_LLM_API constexpr DeviceType get() const;
 
  private:
   uint32_t flags_ = 0;
 };
 
-}  // namespace nova_llm
+}  // namespace nova_llm

include/NovaLLM/data/tensor.h

@@ -1,4 +1,11 @@
 #pragma once
+
+// Disable C4251 warning on Windows (DLL interface for STL containers)
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable: 4251)
+#endif
+
 #include <atomic>
 #include <cstdint>
 #include <functional>
@@ -152,4 +159,8 @@ class NOVA_LLM_API Tensor {
   Deleter m_deleter_ = DefaultDeletor();       ///< 自定义删除器
 };
 
-}  // namespace nova_llm
+}  // namespace nova_llm
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif

include/NovaLLM/memory/buffer_hub.h

@@ -1,4 +1,11 @@
 #pragma once
+
+// Disable C4251 warning on Windows (DLL interface for STL containers)
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable: 4251)
+#endif
+
 #include <cmath>
 #include <list>
 #include <memory>
@@ -17,7 +24,7 @@ namespace nova_llm {
 // Forward declaration
 class BufferHub;
 
-struct Size {
+struct NOVA_LLM_API Size {
  private:
   uint64_t bytes_ = 0;
 
@@ -59,14 +66,14 @@ using BlockPtr = std::unique_ptr<Block>;
 // Raw non-owning pointer for temporary access
 using BlockRawPtr = Block*;
 
-class LevelAssignStrategy {
+class NOVA_LLM_API LevelAssignStrategy {
  public:
   virtual std::vector<Size> assignLevels();
 };
 
-class BufferHubConfig {
+class NOVA_LLM_API BufferHubConfig {
  public:
-  BufferHubConfig(DeviceType device_type, IAllocatorSharedPtr allocator, Size size_limit=Size(4UL*1024*1024*1024), LevelAssignStrategy strategy = LevelAssignStrategy(), float warning_level = 0.95)
+  BufferHubConfig(DeviceType device_type, IAllocatorSharedPtr allocator, Size size_limit=Size(4UL*1024*1024*1024), LevelAssignStrategy strategy = LevelAssignStrategy(), float warning_level = 0.95f)
       : device_type_(device_type),
         size_limit_(size_limit),
         warning_level_(warning_level),
@@ -103,11 +110,19 @@ class BufferHub;
  * @brief Buffers at the specified size level
  *
  */
-class BufferHubLevel {
+class NOVA_LLM_API BufferHubLevel {
  public:
   // Default constructor required for unordered_map
   BufferHubLevel() = default;
-
+
+  // Move constructor and assignment for unique_ptr compatibility
+  BufferHubLevel(BufferHubLevel&&) = default;
+  BufferHubLevel& operator=(BufferHubLevel&&) = default;
+
+  // Copy operations deleted to prevent unique_ptr copying
+  BufferHubLevel(const BufferHubLevel&) = delete;
+  BufferHubLevel& operator=(const BufferHubLevel&) = delete;
+
   void initialize(uint32_t index, const Size& block_size, BufferHub* hub);
 
   // Returns non-owning pointer since pool retains ownership
@@ -128,7 +143,7 @@ class BufferHubLevel {
  private:
   void refill(const Size& sz);
 
-  uint32_t index_ = -1;                        // level index in buffer hub
+  uint32_t index_ = static_cast<uint32_t>(-1); // level index in buffer hub
   Size block_size_ {static_cast<uint64_t>(0)}; // each block size at this level
   uint32_t expand_factor_ = 2;
 
@@ -201,18 +216,22 @@ class NOVA_LLM_API BufferHub {
   // Thread safety: protects all mutable state
   mutable std::mutex mutex_;
 
-  std::unordered_map<Size, BufferHubLevel, SizeHash, SizeEqual> buffers_;
+  std::unordered_map<Size, std::unique_ptr<BufferHubLevel>, SizeHash, SizeEqual> buffers_;
 
   DeviceType device_type_;
 
   std::vector<Size> size_levels_;  // ensure that levels are in ascending order
 
   Size size_limit_;  // Memory in buffer hub cannot exceed this limit
 
-  float warning_level_ = 0.95;  // Be cautious when memory in buffer hub exceeds size_limit*warning_level
+  float warning_level_ = 0.95f; // Be cautious when memory in buffer hub exceeds size_limit*warning_level
 
   IAllocatorSharedPtr allocator_;
 
 };
 
 }  // namespace nova_llm
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif

include/NovaLLM/memory/buffer_manager.h

@@ -8,6 +8,10 @@
 #include "NovaLLM/memory/allocator.h"
 #include "NovaLLM/memory/buffer_define.h"
 #include "NovaLLM/memory/buffer_hub.h"
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable: 4251)
+#endif
 
 namespace nova_llm {
 /*
@@ -77,3 +81,7 @@ class NOVA_LLM_API BufferManager {
 };
 
 }  // namespace nova_llm
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif

source/memory/buffer_hub.cpp

@@ -266,7 +266,7 @@ void BufferHub::addSizeLevel(uint32_t index, const Size& level_block_sz) {
   std::lock_guard<std::mutex> lock(mutex_);
 
   auto& level = buffers_[level_block_sz];
-  level.initialize(index, level_block_sz, this);
+  level->initialize(index, level_block_sz, this);
 }
 
 void BufferHub::eraseSizeLevel(const Size& level_sz) {
@@ -279,16 +279,16 @@ void BufferHub::eraseSizeLevel(const Size& level_sz) {
   }
 
   auto& level = it->second;
-  if (level.busyBlockCount() > 0) {
+  if (level->busyBlockCount() > 0) {
     LOG_ERROR("Level with size %llu has %zu busy blocks, cannot erase now", 
-              level_sz.totalBytes(), level.busyBlockCount());
+              level_sz.totalBytes(), level->busyBlockCount());
     return;
   }
 
   // Free all blocks in the block_list before erasing
   // The destructor will be called, but let's be explicit about cleanup
   LOG_INFO("Erasing level with size %llu, freeing %zu blocks", 
-           level_sz.totalBytes(), level.totalBlocks());
+           level_sz.totalBytes(), level->totalBlocks());
 
   // Erasing from the map will call BufferHubLevel destructor,
   // which properly frees all blocks via tearDownBlock
@@ -307,7 +307,7 @@ BlockRawPtr BufferHub::getBlock(const Size& sz) {
   BlockRawPtr ret_block {nullptr};
   if (buffers_.count(level_sz)) {
     auto& level = buffers_[level_sz];
-    auto block = level.fetchOneFreeBlock();
+    auto block = level->fetchOneFreeBlock();
     if (block && block->isValid()) {
       ret_block = block;
     }
@@ -329,7 +329,7 @@ void BufferHub::putBlock(BlockRawPtr block_ptr) {
   Size level_size(size);
   if (buffers_.count(level_size)) {
     auto& level = buffers_[level_size];
-    level.putOneBlock(block_ptr);
+    level->putOneBlock(block_ptr);
   } else {
     LOG_ERROR("Level size %d is not found in buffers!", level_size.totalBytes());
   }
@@ -346,7 +346,7 @@ void BufferHub::putBlockFromBuffer(Buffer& buffer) {
     auto& level = buffers_[level_sz];
     auto* data = static_cast<Block::DataPtr>(buffer.data);
 
-    if (!level.tryPutBlock(data)) {
+    if (!level->tryPutBlock(data)) {
        // Maybe log warning if data was expected to be there?
        // But original code just did nothing if not found in busy_map.
        // Actually original code: if (level.busy_map.count(data)) { ... }

source/memory/buffer_manager.cpp

@@ -4,6 +4,7 @@
 #include "NovaLLM/memory/buffer_hub.h"
 #include "NovaLLM/utils/log.h"
 #include "NovaLLM/utils/macros.h"
+// Disable C4251 warning on Windows (DLL interface for STL containers)
 
 namespace nova_llm {
 
@@ -68,4 +69,4 @@ void BufferManager::destroy() {
 }
 
 
-}  // namespace nova_llm
+}  // namespace nova_llm

test/CMakeLists.txt

@@ -33,8 +33,8 @@ target_include_directories(${PROJECT_NAME} PRIVATE
     ${CMAKE_BINARY_DIR}/conan/include
 )
 
-target_link_libraries(${PROJECT_NAME} 
-    PRIVATE 
+target_link_libraries(${PROJECT_NAME}
+    PRIVATE
     NovaLLM::NovaLLM
     GTest::gtest
     GTest::gtest_main
@@ -46,6 +46,11 @@ target_link_libraries(${PROJECT_NAME}
 
 set_target_properties(${PROJECT_NAME} PROPERTIES CXX_STANDARD 17)
 
+# Define import macro for Windows (tests consume the DLL, library exports)
+if(WIN32)
+  target_compile_definitions(${PROJECT_NAME} PRIVATE NOVA_LLM_IMPORTS)
+endif()
+
 # enable compiler warnings
 if(NOT TEST_INSTALLED_VERSION)
   if(CMAKE_CXX_COMPILER_ID MATCHES "Clang" OR CMAKE_CXX_COMPILER_ID MATCHES "GNU")

test/source/buffer_hub_test.cpp

@@ -82,14 +82,14 @@ TEST_F(CPUBufferHubTest, PutBlockFromBuffer) {
 
 // Concurrent access tests
 TEST_F(CPUBufferHubTest, ConcurrentAddSizeLevel) {
-  const int num_threads = 10;
-  const int num_levels_per_thread = 5;
+  constexpr int num_threads = 10;
+  constexpr int num_levels_per_thread = 5;
   std::vector<std::thread> threads;
   std::atomic<int> success_count {0};
 
   // Each thread adds multiple size levels
   for (int t = 0; t < num_threads; ++t) {
-    threads.emplace_back([this, t, &success_count,&num_levels_per_thread]() {
+    threads.emplace_back([this, t, &success_count, num_levels_per_thread=num_levels_per_thread]() {
       for (int i = 0; i < num_levels_per_thread; ++i) {
         // Create unique sizes for each thread to avoid conflicts
         uint64_t size_bytes = (1 << 20) * (t * num_levels_per_thread + i + 100);  // 100MB+
@@ -145,15 +145,15 @@ TEST_F(CPUBufferHubTest, ConcurrentEraseSizeLevel) {
 }
 
 TEST_F(CPUBufferHubTest, ConcurrentGetBlock) {
-  const int num_threads = 20;
-  const int blocks_per_thread = 5;
+  constexpr int num_threads = 20;
+  constexpr int blocks_per_thread = 5;
   std::vector<std::thread> threads;
   std::vector<std::vector<BlockRawPtr>> thread_blocks(num_threads);
   std::atomic<int> successful_gets {0};
 
   // Multiple threads requesting blocks of the same size concurrently
   for (int t = 0; t < num_threads; ++t) {
-    threads.emplace_back([this, t, &thread_blocks, &successful_gets,&blocks_per_thread]() {
+    threads.emplace_back([this, t, &thread_blocks, &successful_gets, blocks_per_thread=blocks_per_thread]() {
       for (int i = 0; i < blocks_per_thread; ++i) {
         auto* block = getBufferHub()->getBlock(Size(4096));  // 4KB blocks
         if (block != nullptr && block->data != nullptr) {