Fixed allocator initialization order error. Updated docs.

Author: vitalsong

README.md

@@ -50,18 +50,7 @@ arr_cmplx y6 = x1 * 2i;
 ### Slicing
 The behavior of slices is as close as possible to numpy. Except for cases with invalid indexes, in which case numpy does not throw an exception.
 ```cpp
-arr_real x = {0, 1, 2, 3, 4, 5, 6};
-x.slice(0, 2) ///{0, 1}
-x.slice(2, -1) ///{2, 3, 4, 5}
-x.slice(-1, 0, -1) ///{6, 5, 4, 3, 2, 1}
-x.slice(-1, 0) ///OUT_OF_RANGE, but numpy returns []
-x.slice(0, -1, -1) ///OUT_OF_RANGE, but numpy returns []
-x.slice(-8, 7) ///OUT_OF_RANGE, but numpy returns [0 1 2 3 4 5 6]
-```
-
-### Fast Fourier Transform:
-The FFT/IFFT calculation table is cached on first run. To eliminate this behavior, you can use the fft_plan object.
-```cpp
+using namespace dsplib;
 arr_real x = randn(512);
 arr_cmplx y = fft(x);
 ```
@@ -102,7 +91,7 @@ arr_real x2 = awgn(x1, 10);
 arr_real y = xcorr(x1, x2);
 ```
 
-### Spectrum Analyze (16-bit scale):
+Simple Spectrum Analyze (16-bit scale):
 ```cpp
 int nfft = 1024;
 arr_real x = randn(nfft) * 1000;
@@ -112,3 +101,7 @@ arr_cmplx y = fft(x) / (nfft / 2);
 arr_real z = abs(y);
 z = log10(z / 0x7FFF) * 20;
 ```
+
+## Allocation
+
+On some platforms (for example, Android) there may be performance issues due to slow memory allocation for the vector. In this case, try enabling a custom allocator via the DSPLIB_POOL_ALLOCATOR option and estimate its peak consumption using the dsplib::pool_state function.

include/dsplib/allocator.h

@@ -2,27 +2,38 @@
 
 #include <vector>
 #include <memory>
+#include <cassert>
 
 namespace dsplib {
 
+// Implementation of an allocator as a pool of memory blocks.
+// Used to allocate memory for a vector on platforms where frequent malloc() calls are critical.
+// For each memory request, a free block is checked.
+// If there are no free blocks, then memory is allocated using malloc(), the pointer is placed in the pool
+// and returned as a temporary object.
+// When the memory allocation limit is exceeded, the allocation will be performed in the standard way.
+// Block sizes are multiples of 512 bytes, i.e. 512, 1024, 1536 ... MAX_POOLED_SIZE
+// There is also a separate pool of 64 bytes for small objects.
+// Alignment of the real_t/cmplx_t pointer is guaranteed by the malloc implementation.
+
 template<class T>
 inline void unused(T&&) {
 }
 
-//init pool table
+// Init pool table
+// Prepare a pool of objects if the block sizes are known in advance.
+// For evaluation, you can use function pool_info() after running your algorithm.
 void pool_init(std::vector<int> map);
 
-//release all free memory blocks
+// Release all free memory blocks
 void pool_reset();
 
-//allocate memory block from pool
+// Allocate memory block from pool
 void* pool_alloc(size_t size);
 
-//free (return) memory block to pool
+// Free (return) memory block to pool
 void pool_free(void* ptr);
 
-//current pool state
-//TODO: allocated/free
 struct pool_info_t
 {
     pool_info_t(bool used, int size)
@@ -33,6 +44,7 @@ struct pool_info_t
     int size{0};
 };
 
+// Current pool state
 std::vector<pool_info_t> pool_info();
 
 template<typename T>
@@ -49,7 +61,10 @@ class pool_allocator : public std::allocator<T>
 
     pointer allocate(size_type n, const void* hint = 0) {
         unused(hint);
-        return reinterpret_cast<pointer>(pool_alloc(n * sizeof(T)));
+        auto ptr = pool_alloc(n * sizeof(T));
+        auto r_ptr = reinterpret_cast<pointer>(ptr);
+        assert(uintptr_t(ptr) == uintptr_t(r_ptr));
+        return r_ptr;
     }
 
     void deallocate(pointer p, size_type n) {

lib/allocator.cpp

@@ -2,20 +2,11 @@
 
 #include <memory>
 #include <vector>
-#include <cassert>
 #include <unordered_map>
 #include <stdexcept>
 
 namespace dsplib {
 
-//----------------------------------------------------------------------------------------
-constexpr int MAX_POOLED_SIZE = (1L << 15);
-constexpr int SMALL_BLOCK_SIZE = 64;
-constexpr int BLOCK_SIZE = 512;
-constexpr int STORAGE_COUNT = MAX_POOLED_SIZE / BLOCK_SIZE + 1;
-constexpr size_t MEMORY_ALLOCATION_LIMIT = 1024 * 1024;   //1 MB (TODO: set from options)
-constexpr int NOT_POOLED_KEY = -1;
-
 //----------------------------------------------------------------------------------------
 class storage_t
 {
@@ -39,10 +30,31 @@ class storage_t
 };
 
 //----------------------------------------------------------------------------------------
-static thread_local std::vector<storage_t> _storage(STORAGE_COUNT);
-static thread_local size_t _bytes_allocated{0};
-static thread_local std::unordered_map<void*, int> _alocate_map;
+//TODO: Move constants MAX_POOLED_SIZE, SMALL_BLOCK_SIZE, BLOCK_SIZE, MEMORY_ALLOCATION_LIMIT to config
+constexpr int MAX_POOLED_SIZE = (1L << 15);
+constexpr int SMALL_BLOCK_SIZE = 64;
+constexpr int BLOCK_SIZE = 512;
+constexpr int STORAGE_COUNT = MAX_POOLED_SIZE / BLOCK_SIZE + 1;
+constexpr size_t MEMORY_ALLOCATION_LIMIT = 1024 * 1024;   //1 MB (TODO: set from options)
+constexpr int NOT_POOLED_KEY = -1;
+
+//----------------------------------------------------------------------------------------
+static std::vector<storage_t>& get_storage() {
+    static std::vector<storage_t> _storage(STORAGE_COUNT);
+    return _storage;
+}
 
+static std::unordered_map<void*, int>& get_allocmap() {
+    static std::unordered_map<void*, int> _alocate_map{};
+    return _alocate_map;
+}
+
+static size_t& allocated() {
+    static size_t _bytes_allocated{0};
+    return _bytes_allocated;
+}
+
+//----------------------------------------------------------------------------------------
 static int key_by_size(int size) {
     assert(size <= MAX_POOLED_SIZE);
     if (size <= SMALL_BLOCK_SIZE) {
@@ -67,7 +79,7 @@ void pool_init(std::vector<int> map) {
         bytes_needed += pool_size;
     }
 
-    if ((bytes_needed + _bytes_allocated) > MEMORY_ALLOCATION_LIMIT) {
+    if ((bytes_needed + allocated()) > MEMORY_ALLOCATION_LIMIT) {
         throw std::runtime_error("Limit is exceeded. Memory has not been allocated.");
     }
 
@@ -80,66 +92,77 @@ void pool_init(std::vector<int> map) {
 
 //----------------------------------------------------------------------------------------
 void pool_reset() {
-    for (int key = 0; key < _storage.size(); ++key) {
-        auto& pool = _storage[key];
+    auto& storage = get_storage();
+    for (int key = 0; key < storage.size(); ++key) {
+        auto& pool = storage[key];
         while (pool.size() > 0) {
             auto ptr = pool.pop();
             free(ptr);
-            _bytes_allocated -= size_by_key(key);
+            allocated() -= size_by_key(key);
         }
     }
 }
 
 //----------------------------------------------------------------------------------------
 void* pool_alloc(size_t size) {
+    auto& storage = get_storage();
+    auto& allocmap = get_allocmap();
+
     if (size > MAX_POOLED_SIZE) {
         auto ptr = malloc(size);
-        _alocate_map[ptr] = NOT_POOLED_KEY;
+        allocmap[ptr] = NOT_POOLED_KEY;
         return ptr;
     }
 
     const int key = key_by_size(size);
-    auto& pool = _storage[key];
+    auto& pool = storage[key];
     const int cap = size_by_key(key);
 
     //TODO: get first free object from pool (not equal size)
-    if ((pool.size() == 0) && (_bytes_allocated > MEMORY_ALLOCATION_LIMIT)) {
+    if ((pool.size() == 0) && (allocated() > MEMORY_ALLOCATION_LIMIT)) {
         auto ptr = malloc(size);
-        _alocate_map[ptr] = NOT_POOLED_KEY;
+        allocmap[ptr] = NOT_POOLED_KEY;
         return ptr;
     }
 
     //add block to pool
     if (pool.size() == 0) {
         auto ptr = malloc(cap);
         pool.push(ptr);
-        _bytes_allocated += cap;
+        allocated() += cap;
     }
 
     auto ptr = pool.pop();
-    _alocate_map[ptr] = key;
+    allocmap[ptr] = key;
     return ptr;
 }
 
 //----------------------------------------------------------------------------------------
 void pool_free(void* ptr) {
-    assert(_alocate_map.count(ptr) == 1);
-    auto key = _alocate_map.at(ptr);
-    _alocate_map.erase(ptr);
+    auto& storage = get_storage();
+    auto& allocmap = get_allocmap();
+
+    assert(allocmap.count(ptr) == 1);
+
+    auto key = allocmap.at(ptr);
+    allocmap.erase(ptr);
     if (key == NOT_POOLED_KEY) {
         free(ptr);
     } else {
-        auto& pool = _storage[key];
+        auto& pool = storage[key];
         pool.push(ptr);
     }
 }
 
 std::vector<pool_info_t> pool_info() {
+    auto& storage = get_storage();
+    auto& allocmap = get_allocmap();
+
     std::vector<pool_info_t> out;
 
     //free blocks
-    for (int k = 0; k < _storage.size(); ++k) {
-        auto& pool = _storage[k];
+    for (int k = 0; k < storage.size(); ++k) {
+        auto& pool = storage[k];
         for (int i = 0; i < pool.size(); ++i) {
             auto pool_size = size_by_key(k);
             pool_info_t info = {false, pool_size};
@@ -148,7 +171,7 @@ std::vector<pool_info_t> pool_info() {
     }
 
     //used blocks
-    for (auto it : _alocate_map) {
+    for (auto it : allocmap) {
         auto key = it.second;
         auto pool_size = size_by_key(key);
         pool_info_t info = {true, pool_size};