d0a991d47b
These will allow us to (for instance) move pageslabs from a psset dedicated to not-yet-hugeified pages to one dedicated to hugeified ones.
522 lines
16 KiB
C
522 lines
16 KiB
C
#include "test/jemalloc_test.h"
|
|
|
|
#include "jemalloc/internal/psset.h"
|
|
|
|
#define PAGESLAB_PAGES 64
|
|
#define PAGESLAB_SIZE (PAGESLAB_PAGES << LG_PAGE)
|
|
#define PAGESLAB_SN 123
|
|
#define PAGESLAB_ADDR ((void *)(1234 << LG_PAGE))
|
|
|
|
#define ALLOC_ARENA_IND 111
|
|
#define ALLOC_ESN 222
|
|
|
|
static void
|
|
edata_init_test(edata_t *edata) {
|
|
memset(edata, 0, sizeof(*edata));
|
|
edata_arena_ind_set(edata, ALLOC_ARENA_IND);
|
|
edata_esn_set(edata, ALLOC_ESN);
|
|
}
|
|
|
|
static void
|
|
edata_expect(edata_t *edata, size_t page_offset, size_t page_cnt) {
|
|
/*
|
|
* Note that allocations should get the arena ind of their home
|
|
* arena, *not* the arena ind of the pageslab allocator.
|
|
*/
|
|
expect_u_eq(ALLOC_ARENA_IND, edata_arena_ind_get(edata),
|
|
"Arena ind changed");
|
|
expect_ptr_eq(
|
|
(void *)((uintptr_t)PAGESLAB_ADDR + (page_offset << LG_PAGE)),
|
|
edata_addr_get(edata), "Didn't allocate in order");
|
|
expect_zu_eq(page_cnt << LG_PAGE, edata_size_get(edata), "");
|
|
expect_false(edata_slab_get(edata), "");
|
|
expect_u_eq(SC_NSIZES, edata_szind_get_maybe_invalid(edata),
|
|
"");
|
|
expect_zu_eq(0, edata_sn_get(edata), "");
|
|
expect_d_eq(edata_state_get(edata), extent_state_active, "");
|
|
expect_false(edata_zeroed_get(edata), "");
|
|
expect_true(edata_committed_get(edata), "");
|
|
expect_d_eq(EXTENT_PAI_HPA, edata_pai_get(edata), "");
|
|
expect_false(edata_is_head_get(edata), "");
|
|
}
|
|
|
|
TEST_BEGIN(test_empty) {
|
|
bool err;
|
|
edata_t pageslab;
|
|
memset(&pageslab, 0, sizeof(pageslab));
|
|
edata_t alloc;
|
|
|
|
edata_init(&pageslab, /* arena_ind */ 0, PAGESLAB_ADDR, PAGESLAB_SIZE,
|
|
/* slab */ true, SC_NSIZES, PAGESLAB_SN, extent_state_active,
|
|
/* zeroed */ false, /* comitted */ true, EXTENT_PAI_HPA,
|
|
EXTENT_IS_HEAD);
|
|
edata_init_test(&alloc);
|
|
|
|
psset_t psset;
|
|
psset_init(&psset);
|
|
|
|
/* Empty psset should return fail allocations. */
|
|
err = psset_alloc_reuse(&psset, &alloc, PAGE);
|
|
expect_true(err, "Empty psset succeeded in an allocation.");
|
|
}
|
|
TEST_END
|
|
|
|
TEST_BEGIN(test_fill) {
|
|
bool err;
|
|
edata_t pageslab;
|
|
memset(&pageslab, 0, sizeof(pageslab));
|
|
edata_t alloc[PAGESLAB_PAGES];
|
|
|
|
edata_init(&pageslab, /* arena_ind */ 0, PAGESLAB_ADDR, PAGESLAB_SIZE,
|
|
/* slab */ true, SC_NSIZES, PAGESLAB_SN, extent_state_active,
|
|
/* zeroed */ false, /* comitted */ true, EXTENT_PAI_HPA,
|
|
EXTENT_IS_HEAD);
|
|
|
|
psset_t psset;
|
|
psset_init(&psset);
|
|
|
|
edata_init_test(&alloc[0]);
|
|
psset_alloc_new(&psset, &pageslab, &alloc[0], PAGE);
|
|
for (size_t i = 1; i < PAGESLAB_PAGES; i++) {
|
|
edata_init_test(&alloc[i]);
|
|
err = psset_alloc_reuse(&psset, &alloc[i], PAGE);
|
|
expect_false(err, "Nonempty psset failed page allocation.");
|
|
}
|
|
|
|
for (size_t i = 0; i < PAGESLAB_PAGES; i++) {
|
|
edata_t *edata = &alloc[i];
|
|
edata_expect(edata, i, 1);
|
|
}
|
|
|
|
/* The pageslab, and thus psset, should now have no allocations. */
|
|
edata_t extra_alloc;
|
|
edata_init_test(&extra_alloc);
|
|
err = psset_alloc_reuse(&psset, &extra_alloc, PAGE);
|
|
expect_true(err, "Alloc succeeded even though psset should be empty");
|
|
}
|
|
TEST_END
|
|
|
|
TEST_BEGIN(test_reuse) {
|
|
bool err;
|
|
edata_t *ps;
|
|
|
|
edata_t pageslab;
|
|
memset(&pageslab, 0, sizeof(pageslab));
|
|
edata_t alloc[PAGESLAB_PAGES];
|
|
|
|
edata_init(&pageslab, /* arena_ind */ 0, PAGESLAB_ADDR, PAGESLAB_SIZE,
|
|
/* slab */ true, SC_NSIZES, PAGESLAB_SN, extent_state_active,
|
|
/* zeroed */ false, /* comitted */ true, EXTENT_PAI_HPA,
|
|
EXTENT_IS_HEAD);
|
|
|
|
psset_t psset;
|
|
psset_init(&psset);
|
|
|
|
edata_init_test(&alloc[0]);
|
|
psset_alloc_new(&psset, &pageslab, &alloc[0], PAGE);
|
|
for (size_t i = 1; i < PAGESLAB_PAGES; i++) {
|
|
edata_init_test(&alloc[i]);
|
|
err = psset_alloc_reuse(&psset, &alloc[i], PAGE);
|
|
expect_false(err, "Nonempty psset failed page allocation.");
|
|
}
|
|
|
|
/* Free odd indices. */
|
|
for (size_t i = 0; i < PAGESLAB_PAGES; i ++) {
|
|
if (i % 2 == 0) {
|
|
continue;
|
|
}
|
|
ps = psset_dalloc(&psset, &alloc[i]);
|
|
expect_ptr_null(ps, "Nonempty pageslab evicted");
|
|
}
|
|
/* Realloc into them. */
|
|
for (size_t i = 0; i < PAGESLAB_PAGES; i++) {
|
|
if (i % 2 == 0) {
|
|
continue;
|
|
}
|
|
err = psset_alloc_reuse(&psset, &alloc[i], PAGE);
|
|
expect_false(err, "Nonempty psset failed page allocation.");
|
|
edata_expect(&alloc[i], i, 1);
|
|
}
|
|
/* Now, free the pages at indices 0 or 1 mod 2. */
|
|
for (size_t i = 0; i < PAGESLAB_PAGES; i++) {
|
|
if (i % 4 > 1) {
|
|
continue;
|
|
}
|
|
ps = psset_dalloc(&psset, &alloc[i]);
|
|
expect_ptr_null(ps, "Nonempty pageslab evicted");
|
|
}
|
|
/* And realloc 2-page allocations into them. */
|
|
for (size_t i = 0; i < PAGESLAB_PAGES; i++) {
|
|
if (i % 4 != 0) {
|
|
continue;
|
|
}
|
|
err = psset_alloc_reuse(&psset, &alloc[i], 2 * PAGE);
|
|
expect_false(err, "Nonempty psset failed page allocation.");
|
|
edata_expect(&alloc[i], i, 2);
|
|
}
|
|
/* Free all the 2-page allocations. */
|
|
for (size_t i = 0; i < PAGESLAB_PAGES; i++) {
|
|
if (i % 4 != 0) {
|
|
continue;
|
|
}
|
|
ps = psset_dalloc(&psset, &alloc[i]);
|
|
expect_ptr_null(ps, "Nonempty pageslab evicted");
|
|
}
|
|
/*
|
|
* Free up a 1-page hole next to a 2-page hole, but somewhere in the
|
|
* middle of the pageslab. Index 11 should be right before such a hole
|
|
* (since 12 % 4 == 0).
|
|
*/
|
|
size_t index_of_3 = 11;
|
|
ps = psset_dalloc(&psset, &alloc[index_of_3]);
|
|
expect_ptr_null(ps, "Nonempty pageslab evicted");
|
|
err = psset_alloc_reuse(&psset, &alloc[index_of_3], 3 * PAGE);
|
|
expect_false(err, "Should have been able to find alloc.");
|
|
edata_expect(&alloc[index_of_3], index_of_3, 3);
|
|
|
|
/* Free up a 4-page hole at the end. */
|
|
ps = psset_dalloc(&psset, &alloc[PAGESLAB_PAGES - 1]);
|
|
expect_ptr_null(ps, "Nonempty pageslab evicted");
|
|
ps = psset_dalloc(&psset, &alloc[PAGESLAB_PAGES - 2]);
|
|
expect_ptr_null(ps, "Nonempty pageslab evicted");
|
|
|
|
/* Make sure we can satisfy an allocation at the very end of a slab. */
|
|
size_t index_of_4 = PAGESLAB_PAGES - 4;
|
|
ps = psset_dalloc(&psset, &alloc[index_of_4]);
|
|
expect_ptr_null(ps, "Nonempty pageslab evicted");
|
|
err = psset_alloc_reuse(&psset, &alloc[index_of_4], 4 * PAGE);
|
|
expect_false(err, "Should have been able to find alloc.");
|
|
edata_expect(&alloc[index_of_4], index_of_4, 4);
|
|
}
|
|
TEST_END
|
|
|
|
TEST_BEGIN(test_evict) {
|
|
bool err;
|
|
edata_t *ps;
|
|
edata_t pageslab;
|
|
memset(&pageslab, 0, sizeof(pageslab));
|
|
edata_t alloc[PAGESLAB_PAGES];
|
|
|
|
edata_init(&pageslab, /* arena_ind */ 0, PAGESLAB_ADDR, PAGESLAB_SIZE,
|
|
/* slab */ true, SC_NSIZES, PAGESLAB_SN, extent_state_active,
|
|
/* zeroed */ false, /* comitted */ true, EXTENT_PAI_HPA,
|
|
EXTENT_IS_HEAD);
|
|
psset_t psset;
|
|
psset_init(&psset);
|
|
|
|
/* Alloc the whole slab. */
|
|
edata_init_test(&alloc[0]);
|
|
psset_alloc_new(&psset, &pageslab, &alloc[0], PAGE);
|
|
for (size_t i = 1; i < PAGESLAB_PAGES; i++) {
|
|
edata_init_test(&alloc[i]);
|
|
err = psset_alloc_reuse(&psset, &alloc[i], PAGE);
|
|
expect_false(err, "Unxpected allocation failure");
|
|
}
|
|
|
|
/* Dealloc the whole slab, going forwards. */
|
|
for (size_t i = 0; i < PAGESLAB_PAGES - 1; i++) {
|
|
ps = psset_dalloc(&psset, &alloc[i]);
|
|
expect_ptr_null(ps, "Nonempty pageslab evicted");
|
|
}
|
|
ps = psset_dalloc(&psset, &alloc[PAGESLAB_PAGES - 1]);
|
|
expect_ptr_eq(&pageslab, ps, "Empty pageslab not evicted.");
|
|
|
|
err = psset_alloc_reuse(&psset, &alloc[0], PAGE);
|
|
expect_true(err, "psset should be empty.");
|
|
}
|
|
TEST_END
|
|
|
|
TEST_BEGIN(test_multi_pageslab) {
|
|
bool err;
|
|
edata_t *ps;
|
|
edata_t pageslab[2];
|
|
memset(&pageslab, 0, sizeof(pageslab));
|
|
edata_t alloc[2][PAGESLAB_PAGES];
|
|
|
|
edata_init(&pageslab[0], /* arena_ind */ 0, PAGESLAB_ADDR, PAGESLAB_SIZE,
|
|
/* slab */ true, SC_NSIZES, PAGESLAB_SN, extent_state_active,
|
|
/* zeroed */ false, /* comitted */ true, EXTENT_PAI_HPA,
|
|
EXTENT_IS_HEAD);
|
|
edata_init(&pageslab[1], /* arena_ind */ 0,
|
|
(void *)((uintptr_t)PAGESLAB_ADDR + PAGESLAB_SIZE), PAGESLAB_SIZE,
|
|
/* slab */ true, SC_NSIZES, PAGESLAB_SN, extent_state_active,
|
|
/* zeroed */ false, /* comitted */ true, EXTENT_PAI_HPA,
|
|
EXTENT_IS_HEAD);
|
|
|
|
psset_t psset;
|
|
psset_init(&psset);
|
|
|
|
/* Insert both slabs. */
|
|
edata_init_test(&alloc[0][0]);
|
|
psset_alloc_new(&psset, &pageslab[0], &alloc[0][0], PAGE);
|
|
edata_init_test(&alloc[1][0]);
|
|
psset_alloc_new(&psset, &pageslab[1], &alloc[1][0], PAGE);
|
|
|
|
/* Fill them both up; make sure we do so in first-fit order. */
|
|
for (size_t i = 0; i < 2; i++) {
|
|
for (size_t j = 1; j < PAGESLAB_PAGES; j++) {
|
|
edata_init_test(&alloc[i][j]);
|
|
err = psset_alloc_reuse(&psset, &alloc[i][j], PAGE);
|
|
expect_false(err,
|
|
"Nonempty psset failed page allocation.");
|
|
assert_ptr_eq(&pageslab[i], edata_ps_get(&alloc[i][j]),
|
|
"Didn't pick pageslabs in first-fit");
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Free up a 2-page hole in the earlier slab, and a 1-page one in the
|
|
* later one. We should still pick the later one.
|
|
*/
|
|
ps = psset_dalloc(&psset, &alloc[0][0]);
|
|
expect_ptr_null(ps, "Unexpected eviction");
|
|
ps = psset_dalloc(&psset, &alloc[0][1]);
|
|
expect_ptr_null(ps, "Unexpected eviction");
|
|
ps = psset_dalloc(&psset, &alloc[1][0]);
|
|
expect_ptr_null(ps, "Unexpected eviction");
|
|
err = psset_alloc_reuse(&psset, &alloc[0][0], PAGE);
|
|
expect_ptr_eq(&pageslab[1], edata_ps_get(&alloc[0][0]),
|
|
"Should have picked the fuller pageslab");
|
|
|
|
/*
|
|
* Now both slabs have 1-page holes. Free up a second one in the later
|
|
* slab.
|
|
*/
|
|
ps = psset_dalloc(&psset, &alloc[1][1]);
|
|
expect_ptr_null(ps, "Unexpected eviction");
|
|
|
|
/*
|
|
* We should be able to allocate a 2-page object, even though an earlier
|
|
* size class is nonempty.
|
|
*/
|
|
err = psset_alloc_reuse(&psset, &alloc[1][0], 2 * PAGE);
|
|
expect_false(err, "Allocation should have succeeded");
|
|
}
|
|
TEST_END
|
|
|
|
static void
|
|
stats_expect_empty(psset_bin_stats_t *stats) {
|
|
assert_zu_eq(0, stats->npageslabs,
|
|
"Supposedly empty bin had positive npageslabs");
|
|
expect_zu_eq(0, stats->nactive, "Unexpected nonempty bin"
|
|
"Supposedly empty bin had positive nactive");
|
|
expect_zu_eq(0, stats->ninactive, "Unexpected nonempty bin"
|
|
"Supposedly empty bin had positive ninactive");
|
|
}
|
|
|
|
static void
|
|
stats_expect(psset_t *psset, size_t nactive) {
|
|
if (nactive == PAGESLAB_PAGES) {
|
|
expect_zu_eq(1, psset->full_slab_stats.npageslabs,
|
|
"Expected a full slab");
|
|
expect_zu_eq(PAGESLAB_PAGES, psset->full_slab_stats.nactive,
|
|
"Should have exactly filled the bin");
|
|
expect_zu_eq(0, psset->full_slab_stats.ninactive,
|
|
"Should never have inactive pages in a full slab");
|
|
} else {
|
|
stats_expect_empty(&psset->full_slab_stats);
|
|
}
|
|
size_t ninactive = PAGESLAB_PAGES - nactive;
|
|
pszind_t nonempty_pind = PSSET_NPSIZES;
|
|
if (ninactive != 0 && ninactive < PAGESLAB_PAGES) {
|
|
nonempty_pind = sz_psz2ind(sz_psz_quantize_floor(
|
|
ninactive << LG_PAGE));
|
|
}
|
|
for (pszind_t i = 0; i < PSSET_NPSIZES; i++) {
|
|
if (i == nonempty_pind) {
|
|
assert_zu_eq(1, psset->slab_stats[i].npageslabs,
|
|
"Should have found a slab");
|
|
expect_zu_eq(nactive, psset->slab_stats[i].nactive,
|
|
"Mismatch in active pages");
|
|
expect_zu_eq(ninactive, psset->slab_stats[i].ninactive,
|
|
"Mismatch in inactive pages");
|
|
} else {
|
|
stats_expect_empty(&psset->slab_stats[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
TEST_BEGIN(test_stats) {
|
|
bool err;
|
|
edata_t pageslab;
|
|
memset(&pageslab, 0, sizeof(pageslab));
|
|
edata_t alloc[PAGESLAB_PAGES];
|
|
|
|
edata_init(&pageslab, /* arena_ind */ 0, PAGESLAB_ADDR, PAGESLAB_SIZE,
|
|
/* slab */ true, SC_NSIZES, PAGESLAB_SN, extent_state_active,
|
|
/* zeroed */ false, /* comitted */ true, EXTENT_PAI_HPA,
|
|
EXTENT_IS_HEAD);
|
|
|
|
psset_t psset;
|
|
psset_init(&psset);
|
|
stats_expect(&psset, 0);
|
|
|
|
edata_init_test(&alloc[0]);
|
|
psset_alloc_new(&psset, &pageslab, &alloc[0], PAGE);
|
|
for (size_t i = 1; i < PAGESLAB_PAGES; i++) {
|
|
stats_expect(&psset, i);
|
|
edata_init_test(&alloc[i]);
|
|
err = psset_alloc_reuse(&psset, &alloc[i], PAGE);
|
|
expect_false(err, "Nonempty psset failed page allocation.");
|
|
}
|
|
stats_expect(&psset, PAGESLAB_PAGES);
|
|
edata_t *ps;
|
|
for (ssize_t i = PAGESLAB_PAGES - 1; i >= 0; i--) {
|
|
ps = psset_dalloc(&psset, &alloc[i]);
|
|
expect_true((ps == NULL) == (i != 0),
|
|
"psset_dalloc should only evict a slab on the last free");
|
|
stats_expect(&psset, i);
|
|
}
|
|
|
|
psset_alloc_new(&psset, &pageslab, &alloc[0], PAGE);
|
|
stats_expect(&psset, 1);
|
|
psset_remove(&psset, &pageslab);
|
|
stats_expect(&psset, 0);
|
|
psset_insert(&psset, &pageslab);
|
|
stats_expect(&psset, 1);
|
|
}
|
|
TEST_END
|
|
|
|
/*
|
|
* Fills in and inserts two pageslabs, with the first better than the second,
|
|
* and each fully allocated (into the allocations in allocs and worse_allocs,
|
|
* each of which should be PAGESLAB_PAGES long).
|
|
*
|
|
* (There's nothing magic about these numbers; it's just useful to share the
|
|
* setup between the oldest fit and the insert/remove test).
|
|
*/
|
|
static void
|
|
init_test_pageslabs(psset_t *psset, edata_t *pageslab, edata_t *worse_pageslab,
|
|
edata_t *alloc, edata_t *worse_alloc) {
|
|
bool err;
|
|
memset(pageslab, 0, sizeof(*pageslab));
|
|
edata_init(pageslab, /* arena_ind */ 0, (void *)(10 * PAGESLAB_SIZE),
|
|
PAGESLAB_SIZE, /* slab */ true, SC_NSIZES, PAGESLAB_SN + 1,
|
|
extent_state_active, /* zeroed */ false, /* comitted */ true,
|
|
EXTENT_PAI_HPA, EXTENT_IS_HEAD);
|
|
|
|
/*
|
|
* This pageslab is better from an edata_comp_snad POV, but will be
|
|
* added to the set after the previous one, and so should be less
|
|
* preferred for allocations.
|
|
*/
|
|
memset(worse_pageslab, 0, sizeof(*worse_pageslab));
|
|
edata_init(worse_pageslab, /* arena_ind */ 0,
|
|
(void *)(9 * PAGESLAB_SIZE), PAGESLAB_SIZE, /* slab */ true,
|
|
SC_NSIZES, PAGESLAB_SN - 1, extent_state_active, /* zeroed */ false,
|
|
/* comitted */ true, EXTENT_PAI_HPA, EXTENT_IS_HEAD);
|
|
|
|
psset_init(psset);
|
|
|
|
edata_init_test(&alloc[0]);
|
|
psset_alloc_new(psset, pageslab, &alloc[0], PAGE);
|
|
for (size_t i = 1; i < PAGESLAB_PAGES; i++) {
|
|
edata_init_test(&alloc[i]);
|
|
err = psset_alloc_reuse(psset, &alloc[i], PAGE);
|
|
expect_false(err, "Nonempty psset failed page allocation.");
|
|
expect_ptr_eq(pageslab, edata_ps_get(&alloc[i]),
|
|
"Allocated from the wrong pageslab");
|
|
}
|
|
|
|
edata_init_test(&worse_alloc[0]);
|
|
psset_alloc_new(psset, worse_pageslab, &worse_alloc[0], PAGE);
|
|
expect_ptr_eq(worse_pageslab, edata_ps_get(&worse_alloc[0]),
|
|
"Allocated from the wrong pageslab");
|
|
/*
|
|
* Make the two pssets otherwise indistinguishable; all full except for
|
|
* a single page.
|
|
*/
|
|
for (size_t i = 1; i < PAGESLAB_PAGES - 1; i++) {
|
|
edata_init_test(&worse_alloc[i]);
|
|
err = psset_alloc_reuse(psset, &alloc[i], PAGE);
|
|
expect_false(err, "Nonempty psset failed page allocation.");
|
|
expect_ptr_eq(worse_pageslab, edata_ps_get(&alloc[i]),
|
|
"Allocated from the wrong pageslab");
|
|
}
|
|
|
|
/* Deallocate the last page from the older pageslab. */
|
|
edata_t *evicted = psset_dalloc(psset, &alloc[PAGESLAB_PAGES - 1]);
|
|
expect_ptr_null(evicted, "Unexpected eviction");
|
|
}
|
|
|
|
TEST_BEGIN(test_oldest_fit) {
|
|
bool err;
|
|
edata_t alloc[PAGESLAB_PAGES];
|
|
edata_t worse_alloc[PAGESLAB_PAGES];
|
|
|
|
edata_t pageslab;
|
|
edata_t worse_pageslab;
|
|
|
|
psset_t psset;
|
|
|
|
init_test_pageslabs(&psset, &pageslab, &worse_pageslab, alloc,
|
|
worse_alloc);
|
|
|
|
/* The edata should come from the better pageslab. */
|
|
edata_t test_edata;
|
|
edata_init_test(&test_edata);
|
|
err = psset_alloc_reuse(&psset, &test_edata, PAGE);
|
|
expect_false(err, "Nonempty psset failed page allocation");
|
|
expect_ptr_eq(&pageslab, edata_ps_get(&test_edata),
|
|
"Allocated from the wrong pageslab");
|
|
}
|
|
TEST_END
|
|
|
|
TEST_BEGIN(test_insert_remove) {
|
|
bool err;
|
|
edata_t *ps;
|
|
edata_t alloc[PAGESLAB_PAGES];
|
|
edata_t worse_alloc[PAGESLAB_PAGES];
|
|
|
|
edata_t pageslab;
|
|
edata_t worse_pageslab;
|
|
|
|
psset_t psset;
|
|
|
|
init_test_pageslabs(&psset, &pageslab, &worse_pageslab, alloc,
|
|
worse_alloc);
|
|
|
|
/* Remove better; should still be able to alloc from worse. */
|
|
psset_remove(&psset, &pageslab);
|
|
err = psset_alloc_reuse(&psset, &worse_alloc[PAGESLAB_PAGES - 1], PAGE);
|
|
expect_false(err, "Removal should still leave an empty page");
|
|
expect_ptr_eq(&worse_pageslab,
|
|
edata_ps_get(&worse_alloc[PAGESLAB_PAGES - 1]),
|
|
"Allocated out of wrong ps");
|
|
|
|
/*
|
|
* After deallocating the previous alloc and reinserting better, it
|
|
* should be preferred for future allocations.
|
|
*/
|
|
ps = psset_dalloc(&psset, &worse_alloc[PAGESLAB_PAGES - 1]);
|
|
expect_ptr_null(ps, "Incorrect eviction of nonempty pageslab");
|
|
psset_insert(&psset, &pageslab);
|
|
err = psset_alloc_reuse(&psset, &alloc[PAGESLAB_PAGES - 1], PAGE);
|
|
expect_false(err, "psset should be nonempty");
|
|
expect_ptr_eq(&pageslab, edata_ps_get(&alloc[PAGESLAB_PAGES - 1]),
|
|
"Removal/reinsertion shouldn't change ordering");
|
|
/*
|
|
* After deallocating and removing both, allocations should fail.
|
|
*/
|
|
ps = psset_dalloc(&psset, &alloc[PAGESLAB_PAGES - 1]);
|
|
expect_ptr_null(ps, "Incorrect eviction");
|
|
psset_remove(&psset, &pageslab);
|
|
psset_remove(&psset, &worse_pageslab);
|
|
err = psset_alloc_reuse(&psset, &alloc[PAGESLAB_PAGES - 1], PAGE);
|
|
expect_true(err, "psset should be empty, but an alloc succeeded");
|
|
}
|
|
TEST_END
|
|
|
|
int
|
|
main(void) {
|
|
return test_no_reentrancy(
|
|
test_empty,
|
|
test_fill,
|
|
test_reuse,
|
|
test_evict,
|
|
test_multi_pageslab,
|
|
test_stats,
|
|
test_oldest_fit,
|
|
test_insert_remove);
|
|
}
|