static void TestEntries()
{
const int SZ = 4;
const int ALGN = 4;
size_t size[SZ] = {8, 8000, 9000, 100*1024};
size_t algn[ALGN] = {8, 64, 4*1024, 8*1024*1024};
rml::MemPoolPolicy pol(getGranMem, putGranMem);
currGranularity = 1; // not check granularity in the test
rml::MemoryPool *pool;
pool_create_v1(0, &pol, &pool);
for (int i=0; i<SZ; i++)
for (int j=0; j<ALGN; j++) {
char *p = (char*)pool_aligned_malloc(pool, size[i], algn[j]);
ASSERT(p && 0==((uintptr_t)p & (algn[j]-1)), NULL);
memset(p, j, size[i]);
size_t curr_algn = algn[rand() % ALGN];
size_t curr_sz = size[rand() % SZ];
char *p1 = (char*)pool_aligned_realloc(pool, p, curr_sz, curr_algn);
ASSERT(p1 && 0==((uintptr_t)p1 & (curr_algn-1)), NULL);
ASSERT(memEqual(p1, min(size[i], curr_sz), j), NULL);
memset(p1, j+1, curr_sz);
size_t curr_sz1 = size[rand() % SZ];
char *p2 = (char*)pool_realloc(pool, p1, curr_sz1);
ASSERT(p2, NULL);
ASSERT(memEqual(p2, min(curr_sz1, curr_sz), j+1), NULL);
pool_free(pool, p2);
}
pool_destroy(pool);
}
static int tbb_pool_posix_memalign(struct memkind *kind, void **memptr,
size_t alignment, size_t size)
{
//Check if alignment is "at least as large as sizeof(void *)".
if(!alignment && (0 != (alignment & (alignment-sizeof(void *))))) return EINVAL;
//Check if alignment is "a power of 2".
if(alignment & (alignment-1)) return EINVAL;
if(size_out_of_bounds(size)) {
*memptr = NULL;
return 0;
}
void *result = pool_aligned_malloc(kind->priv, size, alignment);
if (!result) {
return ENOMEM;
}
*memptr = result;
return 0;
}
