feat: add time serise pool

Author: cc004

src/base/time_serise_pool.h

@@ -0,0 +1,113 @@
+/*
+ * Copyright 2021 4Paradigm
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SRC_BASE_TIME_SERISE_POOL_H_
+#define SRC_BASE_TIME_SERISE_POOL_H_
+
+#include <malloc.h>
+#include <memory>
+#include <map>
+
+namespace openmldb {
+namespace base {
+
+
+class TimeBucket {
+  public:
+    TimeBucket(uint32_t block_size) : block_size_(block_size), current_offset_(block_size + 1), object_num_(0) {
+        head_ = (Block*)malloc(sizeof(Block*)); //empty block at end
+        head_->next = NULL;
+    }
+    void Clear()
+    {
+        auto p = head_;
+        while (p)
+        {
+            auto q = p->next;
+            free(p);
+            p = q;
+        }
+    }
+    void* Alloc(uint32_t size) {
+        object_num_++;
+        if (current_offset_ + size <= block_size_ - sizeof(Block)) {
+            void* addr = head_->data + current_offset_;
+            current_offset_ += size;
+            return addr;
+        } else {
+            auto block = (Block*)malloc(block_size_);
+            current_offset_ = size;
+            block->next = head_->next;
+            head_ = block;
+            return head_->data;
+        }
+    }
+    bool Free() // ret if fully freed
+    {
+        if (!--object_num_)
+        {
+          Clear();
+          return true;
+        }
+        else return false;
+    }
+  private:
+    uint32_t block_size_;
+    uint32_t current_offset_;
+    uint32_t object_num_;
+    struct Block {
+        Block* next;
+        char data[];
+    } *head_;
+};
+
+class TimeSerisePool {
+  public:
+    explicit TimeSerisePool(uint32_t block_size) : block_size_(block_size) {
+
+    }
+    void* Alloc(uint32_t size, uint64_t time) {
+      auto pair = pool_.find(keyof(time));
+      if (pair == pool_.end()){
+        auto bucket = new TimeBucket(block_size_);
+        pool_.insert(std::pair<uint32_t, std::unique_ptr<TimeBucket>>(keyof(time), std::unique_ptr<TimeBucket>(bucket)));
+        return bucket->Alloc(size);
+      }
+
+      return pair->second->Alloc(size);
+    }
+    void Free(uint64_t time) {
+      auto pair = pool_.find(keyof(time));
+      if (pair->second->Free()) {
+        pool_.erase(pair);
+      }
+    }
+    bool Empty(){
+      return pool_.empty();
+    }
+  private:
+    // key is the time / (60 * 60 * 1000)
+    uint32_t block_size_;
+    std::map<uint32_t, std::unique_ptr<TimeBucket>> pool_;
+    inline static uint32_t keyof(uint64_t time) {
+      return time / (60 * 60 * 1000);
+    }
+};
+
+}
+}
+
+#endif // SRC_BASE_TIME_SERISE_POOL_H_

src/base/time_serise_pool_test.cc

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2021 4Paradigm
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+#include "base/time_serise_pool.h"
+
+#include "gtest/gtest.h"
+
+#include <vector>
+
+namespace openmldb {
+namespace base {
+
+class TimeSerisePoolTest : public ::testing::Test {
+ public:
+    TimeSerisePoolTest() {}
+    ~TimeSerisePoolTest() {}
+};
+
+TEST_F(TimeSerisePoolTest, FreeToEmpty) {
+    TimeSerisePool pool(1024);
+    std::vector<uint64_t> times;
+    const int datasize = 1024/2;
+    char data[datasize];
+    for (int i = 0; i < datasize; ++i) data[i] = i * i * i;
+    for (int i = 0; i < 1000; ++i){
+        auto time = (i * i % 7) * (60 * 60 * 1000);
+        auto ptr = pool.Alloc(datasize, time);
+        memcpy(ptr, data, datasize);
+        times.push_back(time);
+    }
+
+    for (auto time : times) pool.Free(time);
+
+    ASSERT_TRUE(pool.Empty());
+}
+
+}  // namespace base
+}  // namespace openmldb
+
+int main(int argc, char** argv) {
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}