我需要一个简单的非阻塞静态块大小的内存池。我没有在网上找到这样的东西。所以每个人都需要这样的解决方案。这个是免费的......只适用于Win32。
致以最诚挚的问候，
弗里德里希
#ifndef MEMPOOL_HPP_INCLUDED
#define MEMPOOL_HPP_INCLUDED
#include "atomic.hpp"
#include "static_assert.hpp"
#pragma warning( push )
#pragma warning( disable : 4311 ) // warning C4311: 'Typumwandlung'
/// @brief Block-free memory-pool implemenation
/// @tparam T Object-type to be saved within the memory-pool.
/// @tparam S Capacy of the memory-pool.
template <typename T, int S>
class MemoryPool
{
private:
STATIC_ASSERT(sizeof(int) == sizeof(void*), "Well, ...");
public:
/// @brief Object-type saved within the pool.
typedef T TYPE;
enum
{
/// @brief Capacy of the memory-pool.
SIZE = S
};
private:
/// @brief Chunks, that holds the memory
struct Chunk
{
/// @brief Single-linked list.
Chunk* Next;
/// @brief The value
/// We do not call the default constructor this way.
char Value[sizeof(TYPE)];
};
/// @brief The root object.
Chunk* Root;
/// @brief The pool
Chunk Pool[SIZE];
private:
// do not allow copying
MemoryPool(const MemoryPool&);
MemoryPool& operator=(const MemoryPool&);
void free(Chunk* c)
{
c->Next = Root;
while(!CompareAndSwap((int*)&Root, (int)c->Next, (int)c))
{
c->Next = Root;
}
}
public:
/// Default constructor
/// Creates an empty memory-pool.
/// Invalidates all the memory.
MemoryPool()
: Root(0)
{
for(int i = 0; i < SIZE; i++)
{
MemoryPool::free(&Pool[i]);
}
}
/// @brief Frees a chunk of memory, that was allocated by MemoryPool::malloc
/// @param _Chunk A chunk of memory, that was allocated by MemoryPool::malloc
/// This function will not call the destructor.
/// Thread-safe, non-blocking
void free(T* _Chunk)
{
if(!_Chunk)
return;
Chunk* c = (Chunk*)((int)(_Chunk) - sizeof(Chunk*));
if(c < &Pool[0] || c > &Pool[SIZE - 1])
return;
MemoryPool::free(c);
}
/// @brief Returns a pointer to a chunk of memory
/// @return 0 on a memory shortage
/// @return A pointer to a chunk of memory
/// This function will not call the constructor.
/// Thread-safe, non-blocking
T* malloc()
{
Chunk* r = Root;
if(!r)
return 0;
while(!CompareAndSwap((int*)&Root, (int)r, (int)r->Next))
{
r = Root;
if(!r)
return 0;
}
return &(r->Value);
}
};
#pragma warning( pop )
#endif // MEMPOOL_HPP_INCLUDED
和CompareAndSwap
/// @brief Atomic compare and set
/// Atomically compare the value stored at *p with cmpval and if the
/// two values are equal, update the value of *p with newval. Returns
/// zero if the compare failed, nonzero otherwise.
/// @param p Pointer to the target
/// @param cmpval Value as we excpect it
/// @param newval New value
static inline int CompareAndSwap(volatile int *_ptr, int _old, int _new)
{
__asm {
mov eax, [_old] // place the value of _old to EAX
mov ecx, [_new] // place the value of _new to ECX
mov edx, [_ptr] // place the pointer of _ptr to EDX
lock cmpxchg [edx], ecx // cmpxchg old (EAX) and *ptr ([EDX])
}
return 1;
}
答案 0 :(得分：9)
这种方法的问题在于malloc：
while(!CompareAndSwap((int*)&Root, (int)r, (int)r->Next))
考虑以下操作顺序：
Root = A, A->next = B, ... r = Root所以r = A和（在寄存器中）读取ecx = r->Next = B malloc和free，以便A暂时使用并最后释放。Root = A, A->next = ZZZ, ... cmpxchg成功，因为Root == r == A因此设置了Root = ecx = B 如果您有双字cmpxchg，例如cmpxchg8b，则可以解决此问题。您只需在列表头旁边添加一个序列号，这样如果您在上面的（3）中被中断，则比较失败。只要每个free交换指针并且增加序列号，malloc方就可以使用窄版本。
答案 1 :(得分：3)
感谢您的任何评论。这个可能与WinXP和更新版本一起使用。前面提到的实现仍然可以与PowerPC体系结构一起使用（如果您有适当的CompareAndSwap实现，请参阅“http://publib.boulder.ibm.com/infocenter/aix/v6r1/topic/com.ibm.aix”。 aixassem / DOC / alangref / stwcx.htm“）。
致以最诚挚的问候，
弗里德里希
/// @brief Lock-free memory-pool implementation
/// @tparam T Type stored within the memory-pool
/// @tparam S Number of elements stored in the memory-pool.
template <typename T, int S>
class MemoryPool
{
public:
/// @brief Type stored within the memory-pool.
typedef T TYPE;
enum
{
/// @brief Number of enrties in the memory-pool.
SIZE = S
};
private:
// we need to align the memory-pool-chunks.
#pragma pack(push, MEMORY_ALLOCATION_ALIGNMENT)
/// @brief The memory-chunk used by the memory-pool.
template <typename TYPE>
struct MemoryChunk
{
/// @brief Next entry in the single-linked list.
SLIST_ENTRY Next;
/// @brief The value stored within the memory-pool.
/// Do not call the constructor
char Value[sizeof(TYPE)];
};
typedef MemoryChunk<TYPE> CHUNK_TYPE;
#pragma pack(pop, MEMORY_ALLOCATION_ALIGNMENT)
/// @brief Head of the single-linked list.
SLIST_HEADER Head;
/// @brief The pool itself
CHUNK_TYPE Pool[SIZE];
// no copying is supported
MemoryPool& operator=(const MemoryPool&);
MemoryPool(const MemoryPool&);
public:
/// @brief Constructs the memory-pool.
MemoryPool()
{
InitializeSListHead(&Head);
for(int i = 0; i < SIZE; i++)
{
InterlockedPushEntrySList(&Head, &Pool[i].Next);
}
}
/// @brief Free the memory-pool.
~MemoryPool()
{
InterlockedFlushSList(&Head);
}
/// @brief Allocates a memory chunk
/// @return 0 if none is free
/// @return Pointer to a free memory chunk (the constructor is not called!)
TYPE* Allocate()
{
CHUNK_TYPE* c = reinterpret_cast<CHUNK_TYPE*>(InterlockedPopEntrySList(&Head));
if(c)
return reinterpret_cast<TYPE*>(&c->Value[0]);
else
return 0;
}
/// @brief Deallocates a memory chunk (the destructor is not called)
/// @param c Point to the memory-chunk allocated by us.
void Deallocate(void* c)
{
if(c < static_cast<void*>(&Pool[0]) || c > static_cast<void*>(&Pool[SIZE]))
return; // was not allocated by us
char* p = static_cast<char*>(c);
p -= sizeof(SLIST_ENTRY);
CHUNK_TYPE* t = reinterpret_cast<CHUNK_TYPE*>(p);
InterlockedPushEntrySList(&Head, &t->Next);
}
};