Clean Project Structure And Change Name Of Area

Author: wingerted

CMakeLists.txt

@@ -0,0 +1,13 @@
+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}/thirdparty/)
+
+SET (SRCS
+	demo/cpp_demo.cpp
+)
+
+ADD_EXECUTABLE(demo ${SRCS})

WolfEvent.py

@@ -0,0 +1,129 @@
+//
+//  shm_allocator.h
+//  ShmArea
+//
+//  Created by Winger Cheng on 2018/1/14.
+//  Copyright © 2018年 Winger Cheng. All rights reserved.
+//
+
+#pragma once
+
+
+#include <fcntl.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <atomic>
+#include <exception>
+#include <string>
+#include <cassert>
+
+namespace area {
+class ShmAreaException : public std::exception {
+ public:
+  ShmAreaException(uint32_t need, uint32_t used, uint32_t max)
+      : need_(need), used_(used), max_(max) {}
+
+  virtual const char *what() const throw() {
+    return "No Enough Memory For Alloc Bytes";
+  }
+
+ private:
+  uint32_t need_;
+  uint32_t used_;
+  uint32_t max_;
+};
+
+struct SuperBlock {
+  std::atomic<uint32_t> memory_usage{0};
+  std::atomic<uint32_t> max_memory_size{0};
+};
+
+class ShmArea {
+ public:
+  ShmArea(const std::string &shm_path, uint32_t max_memory_size,
+          bool force_reset = false)
+      : begin_alloc_ptr_(nullptr), super_block_(nullptr) {
+    this->shm_fd_ = open(shm_path.c_str(), O_CREAT | O_RDWR, 0660);
+
+    fchmod(this->shm_fd_, S_IRWXU | S_IRWXG);
+
+    uint32_t memory_file_size = this->Init(max_memory_size, force_reset);
+    // 共享内存文件已经初始化完毕, 进行成员变量填充
+    char *shared_mem =
+        (char *)mmap(NULL, memory_file_size, PROT_READ | PROT_WRITE, MAP_SHARED,
+                     this->shm_fd_, 0);
+    this->super_block_ = (SuperBlock *)shared_mem;
+    this->begin_alloc_ptr_ = shared_mem + sizeof(SuperBlock);
+  };
+
+  char *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 ShmAreaException(bytes, current_memory_usage, max_memory_size);
+    }
+
+    // 对共享内存中存储的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 MemoryUsage() const {
+    return this->super_block_->memory_usage.load();
+  }
+
+  char *MemoryStart() const { return this->begin_alloc_ptr_; }
+
+ private:
+  // Init函数可以多进程/线程调用, 但是实际对SharedMemory的Init操作只会被执行一次
+  // force_reset很危险, 可以直接初始化SuperBlock中的参数,
+  // 无论这块共享内存是否初始化过
+  uint32_t Init(uint32_t max_memory_size, bool force_reset = false) {
+    assert(max_memory_size > 0);
+    // 对共享内存文件上锁, lockf基于POSIX是线程安全的上锁方式
+    ::lockf(this->shm_fd_, F_LOCK, 0);
+
+    // 为了获取当前文件的大小
+    struct stat file_stat;
+    if (::fstat(this->shm_fd_, &file_stat) == -1) {
+      /* TODO: check the value of errno */
+    }
+
+    uint32_t init_memory_file_size = (uint32_t)file_stat.st_size;
+
+    // 如果文件大小小于SuperBlock的大小, 则认为这块共享内存文件没有初始化过
+    if (force_reset || init_memory_file_size < sizeof(SuperBlock)) {
+      init_memory_file_size = sizeof(SuperBlock) + max_memory_size;
+      ::ftruncate(this->shm_fd_, init_memory_file_size);
+      this->super_block_ =
+          (SuperBlock *)mmap(NULL, sizeof(SuperBlock), PROT_READ | PROT_WRITE,
+                             MAP_SHARED, this->shm_fd_, 0);
+      this->super_block_->max_memory_size.store(max_memory_size);
+      this->super_block_->memory_usage.store(0);
+      munmap(this->super_block_, sizeof(SuperBlock));
+    }
+
+    // 成员变量的填充不需要对文件进行操作, 所以在这里就可以解锁
+    ::lockf(this->shm_fd_, F_ULOCK, 0);
+
+    return init_memory_file_size;
+  }
+
+ private:
+  uint32_t shm_fd_;
+  char *begin_alloc_ptr_;
+  SuperBlock *super_block_;
+};
+}  // namespace area

area/shm_area.h

@@ -0,0 +1,25 @@
+//
+//  comparator.cpp
+//  Wolf
+//
+//  Created by Winger Cheng on 2018/2/17.
+//  Copyright © 2018年 Winger Cheng. All rights reserved.
+//
+
+#pragma once
+namespace container{
+    
+template<typename Key>
+struct DefaultComparator {
+    int operator()(const Key& left, const Key& right) const {
+        if (left < right) {
+            return -1;
+        } else if (left > right) {
+            return 1;
+        } else {
+            return 0;
+        }
+    }
+};
+
+}

container/comparator.h

@@ -6,35 +6,23 @@
 //  Copyright © 2018年 Winger Cheng. All rights reserved.
 //
 // Key必须是POD类型
-
+#pragma once
 
 #include <string>
 #include <atomic>
 #include <random>
 #include <chrono>
 
+#include "comparator.h"
 #include "shm_manager.h"
 #include "random.h"
 
-namespace skiplist{
-    
-template<typename Key>
-struct DefaultComparator {
-    int operator()(const Key& a, const Key& b) const {
-        if (a < b) {
-            return -1;
-        } else if (a > b) {
-            return +1;
-        } else {
-            return 0;
-        }
-    }
-};
+namespace container{
 
 template<typename Key, class Comparator = DefaultComparator<Key>>
 class LockFreeSkipList {
 public:
-    const static int kMaxHeight {24};
+    const static int kMaxHeight {12};
 private:
     // 这部分Node需要放在共享内存中, 所以需要是POD类型
     // TODO:: 共享内存中最大的Node数量受限于Node的size和next中存储的索引值的上限,即如果next使用long则无法做无锁mark
@@ -86,9 +74,9 @@ struct LockFreeSkipList<Key, Comparator>::Ref {
 
 template<typename Key, class Comparator>
 struct LockFreeSkipList<Key, Comparator>::Node {
-    Node(int in_key, uint32_t in_offset, int in_height): key(in_key),
-                                                        self_offset(in_offset),
-                                                        height(in_height) {
+    Node(int in_key, uint32_t in_offset, int in_height): height(in_height),
+                                                         key(in_key),
+                                                         self_offset(in_offset) {
         for (int i=0; i<kMaxHeight; ++i) {
             this->ref[i] = {0, false};
         }
@@ -112,10 +100,10 @@ template<typename Key, class Comparator>
 LockFreeSkipList<Key, Comparator>::LockFreeSkipList(ShmManager* shm_manager,
                                                     bool reset,
                                                     Comparator cmp):
-    shm_manager_(shm_manager),
     //rnd_(static_cast<unsigned int>(std::chrono::system_clock::to_time_t(std::chrono::system_clock::now()))),
     rnd_(0xdeadbeef),
-    compare_(cmp) {
+    compare_(cmp),
+    shm_manager_(shm_manager) {
 
     if (reset) {
         this->head_ = this->NewNode(0, kMaxHeight);
@@ -263,7 +251,12 @@ bool LockFreeSkipList<Key, Comparator>::Add(Key key) {
     Node* second_nodes[kMaxHeight];
 
     while (true) {
+//        auto first = std::chrono::system_clock::now();
         bool found = this->FindWindow(key, first_nodes, second_nodes);
+//        auto second = std::chrono::system_clock::now();
+//        std::cout
+//        << " Time: " << std::chrono::duration_cast<std::chrono::nanoseconds>(second - first).count() << " us"
+//        << std::endl;
         if (found) {
             // 不支持重复的Key
             return false;

lockfree_linklist.h renamed to container/lockfree_linklist.h

@@ -6,23 +6,23 @@
 //  Copyright © 2018年 Winger Cheng. All rights reserved.
 //
 
-#ifndef shm_manager_h
-#define shm_manager_h
+#pragma once
 
 #include <utility>
-#include "shm_allocator.h"
+#include "area/shm_area.h"
 
+namespace container {
 
 class ShmManager {
 public:
-    ShmManager(ShmAllocator* allocator);
+    ShmManager(area::ShmArea* allocator);
     std::pair<uint32_t, char*> Allocate(int bytes);
     char* GetBufferByIndex(uint32_t index);
 private:
-    ShmAllocator* allocator_;
+    area::ShmArea* allocator_;
 };
 
-ShmManager::ShmManager(ShmAllocator* allocator): allocator_(allocator) {}
+ShmManager::ShmManager(area::ShmArea* allocator): allocator_(allocator) {}
 
 std::pair<uint32_t, char*> ShmManager::Allocate(int bytes) {
     char* buffer = this->allocator_->Allocate(bytes);
@@ -34,5 +34,4 @@ char* ShmManager::GetBufferByIndex(uint32_t index) {
     return this->allocator_->MemoryStart() + index;
 }
 
-
-#endif /* shm_manager_h */
+}