Refact Project Structure And Add Wolf Header

Author: wingerted

CMakeLists.txt

@@ -3,16 +3,16 @@ cmake_minimum_required(VERSION 3.3)
 PROJECT (Wolf)
 
 ADD_COMPILE_OPTIONS(-std=c++11 -g -Wall)
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
+INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/src)
 INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/thirdparty/)
 
 SET (SRCS
         demo/cpp_demo.cpp
-        area/shm_area.cpp
-        container/comparator.h
-		container/shm_manager.cpp
-        container/random.h
-        container/lockfree_linklist.h
-        container/lockfree_skiplist.h)
+		src/core/area/shm_area.cpp
+		src/core/container/comparator.h
+		src/core/container/shm_manager.cpp
+		src/core/container/random.h
+		src/core/container/lockfree_linklist.h
+		src/core/container/lockfree_skiplist.h src/wolf.h)
 
 ADD_EXECUTABLE(demo ${SRCS})

demo/cpp_demo.cpp

@@ -10,17 +10,24 @@
 #include <chrono>
 #include <map>
 #include <set>
-#include "area/shm_area.h"
-
-#include "container/lockfree_skiplist.h"
-#include "container/lockfree_linklist.h"
-#include "container/shm_manager.h"
+//#include "core/area/shm_area.h"
+//
+//#include "core/container/lockfree_skiplist.h"
+//#include "core/container/lockfree_linklist.h"
+//#include "core/container/shm_manager.h"
 // #include <folly/ConcurrentSkipList.h>
 
 // using namespace folly;
 
+#include "wolf.h"
+
 
 int main(int argc, const char * argv[]) {
+
+    Wolf<int> wolf_home("/Users/wingerted/test_shared_memory_dat", 10000000, true);
+    wolf_home.Add(1);
+
+
 //    // insert code here...
 //    flatbuffers::FlatBufferBuilder builder(1024);
 //    auto key = builder.CreateString("Winger");

area/shm_area.cpp renamed to src/core/area/shm_area.cpp

@@ -26,42 +26,12 @@ namespace area {
         this->begin_alloc_ptr_ = shared_mem + sizeof(SuperBlock);
     };
 
-    char* ShmArea::Allocate(uint32_t bytes) {
-        assert(bytes > 0);
-        uint32_t current_memory_usage = this->super_block_->memory_usage.load();
-        uint32_t max_memory_size = this->super_block_->max_memory_size.load();
-
-        if (bytes > max_memory_size - current_memory_usage) {
-            throw std::bad_alloc();
-        }
-
-        // 对共享内存中存储的memory_usage进行CAS操作,
-        // 如果之前获取的current_memory_usage与当前共享内存中的值不一致
-        // 则共享内存在此期间已经对外分配过, 需要重新load current_memory_usage的值,
-        // 再次进行CAS操作, 以保证获取到bytes字节不会被别的线程/进程使用
-        while (!this->super_block_->memory_usage.compare_exchange_strong(
-                current_memory_usage, current_memory_usage + bytes)) {
-            current_memory_usage = this->super_block_->memory_usage.load();
-        }
-
-        // 对于同一块共享内存来说begin_alloc_ptr永远不变, 所以current_memory_usage +
-        // begin_alloc_ptr可以确定一块内存的分配点
-        return this->begin_alloc_ptr_ + current_memory_usage;
-    }
-
-    uint32_t ShmArea::MemoryUsage() const {
-        return this->super_block_->memory_usage.load();
-    }
-
-    char* ShmArea::MemoryStart() const {
-        return this->begin_alloc_ptr_;
-    }
-
     // Init函数可以多进程/线程调用, 但是实际对SharedMemory的Init操作只会被执行一次
     // force_reset很危险, 可以直接初始化SuperBlock中的参数,
     // 无论这块共享内存是否初始化过
     uint32_t ShmArea::Init(uint32_t max_memory_size, bool force_reset) {
-        assert(max_memory_size > 0);
+        assert(max_memory_size > 0 || !force_reset);
+
         // 对共享内存文件上锁, lockf基于POSIX是线程安全的上锁方式
         ::lockf(this->shm_fd_, F_LOCK, 0);
 
@@ -93,4 +63,39 @@ namespace area {
 
         return init_memory_file_size;
     }
+
+    char* ShmArea::Allocate(uint32_t bytes) {
+        assert(bytes > 0);
+        uint32_t current_memory_usage = this->super_block_->memory_usage.load();
+        uint32_t max_memory_size = this->super_block_->max_memory_size.load();
+
+        if (bytes > max_memory_size - current_memory_usage) {
+            throw std::bad_alloc();
+        }
+
+        // 对共享内存中存储的memory_usage进行CAS操作,
+        // 如果之前获取的current_memory_usage与当前共享内存中的值不一致
+        // 则共享内存在此期间已经对外分配过, 需要重新load current_memory_usage的值,
+        // 再次进行CAS操作, 以保证获取到bytes字节不会被别的线程/进程使用
+        while (!this->super_block_->memory_usage.compare_exchange_strong(
+                current_memory_usage, current_memory_usage + bytes)) {
+            current_memory_usage = this->super_block_->memory_usage.load();
+        }
+
+        // 对于同一块共享内存来说begin_alloc_ptr永远不变, 所以current_memory_usage +
+        // begin_alloc_ptr可以确定一块内存的分配点
+        return this->begin_alloc_ptr_ + current_memory_usage;
+    }
+
+    uint32_t ShmArea::MemoryUsage() const {
+        return this->super_block_->memory_usage.load();
+    }
+
+    char* ShmArea::MemoryStart() const {
+        return this->begin_alloc_ptr_;
+    }
+
+    char *ShmArea::GetMemoryBuffer(uint32_t offset) {
+        return this->begin_alloc_ptr_ + offset;
+    }
 }

area/shm_area.h renamed to src/core/area/shm_area.h

@@ -32,6 +32,7 @@ class ShmArea {
   char *Allocate(uint32_t bytes);
   uint32_t MemoryUsage() const;
   char *MemoryStart() const;
+  char *GetMemoryBuffer(uint32_t offset);
 
  private:
   uint32_t Init(uint32_t max_memory_size, bool force_reset = false);

container/comparator.h renamed to src/core/container/comparator.h

@@ -9,7 +9,7 @@
 #pragma once
 
 #include <utility>
-#include "area/shm_area.h"
+#include "core/area/shm_area.h"
 
 namespace container {
 

container/lockfree_linklist.h renamed to src/core/container/lockfree_linklist.h

@@ -0,0 +1,65 @@
+//
+// Created by Winger Cheng on 2018/2/26.
+//
+
+#pragma once
+
+#include <string>
+#include "core/area/shm_area.h"
+
+#include "core/container/lockfree_skiplist.h"
+#include "core/container/lockfree_linklist.h"
+#include "core/container/shm_manager.h"
+
+template <typename Data>
+class Wolf{
+public:
+    Wolf(const std::string& index_path,
+         uint32_t index_max_size = 0,
+         bool index_reset_flag = false,
+         const std::string& data_path = "",
+         uint32_t data_max_size = 0,
+         bool data_reset_flag = false): index_path_(index_path),
+                                        index_max_size_(index_max_size),
+                                        index_reset_flag_(index_reset_flag),
+                                        data_path_(data_path),
+                                        data_max_size_(data_max_size),
+                                        data_reset_flag_(data_reset_flag) {
+        auto* allocator = new area::ShmArea(index_path, index_max_size, index_reset_flag);
+        auto* shm_manager = new container::ShmManager(allocator);
+
+        if (data_path.empty()) {
+            this->inner_data_ = new container::LockFreeSkipList<Data>(shm_manager, index_reset_flag);
+        } else {
+            this->index_ = new container::LockFreeSkipList<uint32_t>(shm_manager, index_reset_flag);
+            this->data_area_ = new area::ShmArea(data_path, data_max_size, data_reset_flag);
+        }
+    }
+
+    void Add(const Data& data) {
+        if (this->inner_data_ != nullptr) {
+            this->inner_data_->Add(data);
+        } else {
+//            auto* buffer = this->data_area_->Allocate(sizeof(Data));
+//            memcpy(buffer, &data, sizeof(Data));
+//
+//            auto offset = (uint32_t)(buffer - this->data_area_->MemoryStart());
+            //this->index_->Add(offset);
+        }
+    }
+
+//    void Find(const Data& data) {
+//        this->inner_data_->FindLessThan(data);
+//    }
+
+private:
+    const std::string index_path_;
+    uint32_t index_max_size_;
+    bool index_reset_flag_;
+    const std::string data_path_;
+    uint32_t data_max_size_;
+    bool data_reset_flag_;
+    container::LockFreeSkipList<Data>* inner_data_ = nullptr;
+    container::LockFreeSkipList<uint32_t>* index_ = nullptr;
+    area::ShmArea* data_area_ = nullptr;
+};