project-base/server-skynet-source-3rd-jemalloc
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
5228d869ee
server-skynet-source-3rd-je.../test/unit/psset.c

494 lines
15 KiB
C
Raw Normal View History

Add psset: a set of pageslabs. This introduces a new sort of edata_t; a pageslab, and a set to manage them. This is part of a series of a commits to implement a hugepage allocator; the pageset will be per-arena, and track small page allocations requests within a larger extent allocated from a centralized hugepage allocator.
2020-07-11 08:40:13 +08:00
#include "test/jemalloc_test.h"
#include "jemalloc/internal/psset.h"
Introduce hpdata_t. Using an edata_t both for hugepages and the allocations within those hugepages was convenient at first, but has outlived its usefulness. Representing hugepages explicitly, with their own data structure, will make future development easier.
2020-11-18 08:32:45 +08:00
#define PAGESLAB_ADDR ((void *)(1234 * HUGEPAGE))
#define PAGESLAB_AGE 5678
Add psset: a set of pageslabs. This introduces a new sort of edata_t; a pageslab, and a set to manage them. This is part of a series of a commits to implement a hugepage allocator; the pageset will be per-arena, and track small page allocations requests within a larger extent allocated from a centralized hugepage allocator.
2020-07-11 08:40:13 +08:00
#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;
Introduce hpdata_t. Using an edata_t both for hugepages and the allocations within those hugepages was convenient at first, but has outlived its usefulness. Representing hugepages explicitly, with their own data structure, will make future development easier.
2020-11-18 08:32:45 +08:00
hpdata_t pageslab;
hpdata_init(&pageslab, PAGESLAB_ADDR, PAGESLAB_AGE);
Add psset: a set of pageslabs. This introduces a new sort of edata_t; a pageslab, and a set to manage them. This is part of a series of a commits to implement a hugepage allocator; the pageset will be per-arena, and track small page allocations requests within a larger extent allocated from a centralized hugepage allocator.
2020-07-11 08:40:13 +08:00
Introduce hpdata_t. Using an edata_t both for hugepages and the allocations within those hugepages was convenient at first, but has outlived its usefulness. Representing hugepages explicitly, with their own data structure, will make future development easier.
2020-11-18 08:32:45 +08:00
edata_t alloc;
Add psset: a set of pageslabs. This introduces a new sort of edata_t; a pageslab, and a set to manage them. This is part of a series of a commits to implement a hugepage allocator; the pageset will be per-arena, and track small page allocations requests within a larger extent allocated from a centralized hugepage allocator.
2020-07-11 08:40:13 +08:00
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;
Introduce hpdata_t. Using an edata_t both for hugepages and the allocations within those hugepages was convenient at first, but has outlived its usefulness. Representing hugepages explicitly, with their own data structure, will make future development easier.
2020-11-18 08:32:45 +08:00
hpdata_t pageslab;
hpdata_init(&pageslab, PAGESLAB_ADDR, PAGESLAB_AGE);
edata_t alloc[HUGEPAGE_PAGES];
Add psset: a set of pageslabs. This introduces a new sort of edata_t; a pageslab, and a set to manage them. This is part of a series of a commits to implement a hugepage allocator; the pageset will be per-arena, and track small page allocations requests within a larger extent allocated from a centralized hugepage allocator.
2020-07-11 08:40:13 +08:00
psset_t psset;
psset_init(&psset);
edata_init_test(&alloc[0]);
psset_alloc_new(&psset, &pageslab, &alloc[0], PAGE);
Introduce hpdata_t. Using an edata_t both for hugepages and the allocations within those hugepages was convenient at first, but has outlived its usefulness. Representing hugepages explicitly, with their own data structure, will make future development easier.
2020-11-18 08:32:45 +08:00
for (size_t i = 1; i < HUGEPAGE_PAGES; i++) {
Add psset: a set of pageslabs. This introduces a new sort of edata_t; a pageslab, and a set to manage them. This is part of a series of a commits to implement a hugepage allocator; the pageset will be per-arena, and track small page allocations requests within a larger extent allocated from a centralized hugepage allocator.
2020-07-11 08:40:13 +08:00
edata_init_test(&alloc[i]);
err = psset_alloc_reuse(&psset, &alloc[i], PAGE);
expect_false(err, "Nonempty psset failed page allocation.");
}
Introduce hpdata_t. Using an edata_t both for hugepages and the allocations within those hugepages was convenient at first, but has outlived its usefulness. Representing hugepages explicitly, with their own data structure, will make future development easier.
2020-11-18 08:32:45 +08:00
for (size_t i = 0; i < HUGEPAGE_PAGES; i++) {
Add psset: a set of pageslabs. This introduces a new sort of edata_t; a pageslab, and a set to manage them. This is part of a series of a commits to implement a hugepage allocator; the pageset will be per-arena, and track small page allocations requests within a larger extent allocated from a centralized hugepage allocator.
2020-07-11 08:40:13 +08:00
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;
Introduce hpdata_t. Using an edata_t both for hugepages and the allocations within those hugepages was convenient at first, but has outlived its usefulness. Representing hugepages explicitly, with their own data structure, will make future development easier.
2020-11-18 08:32:45 +08:00
hpdata_t *ps;
Add psset: a set of pageslabs. This introduces a new sort of edata_t; a pageslab, and a set to manage them. This is part of a series of a commits to implement a hugepage allocator; the pageset will be per-arena, and track small page allocations requests within a larger extent allocated from a centralized hugepage allocator.
2020-07-11 08:40:13 +08:00
Introduce hpdata_t. Using an edata_t both for hugepages and the allocations within those hugepages was convenient at first, but has outlived its usefulness. Representing hugepages explicitly, with their own data structure, will make future development easier.
2020-11-18 08:32:45 +08:00
hpdata_t pageslab;
hpdata_init(&pageslab, PAGESLAB_ADDR, PAGESLAB_AGE);
Add psset: a set of pageslabs. This introduces a new sort of edata_t; a pageslab, and a set to manage them. This is part of a series of a commits to implement a hugepage allocator; the pageset will be per-arena, and track small page allocations requests within a larger extent allocated from a centralized hugepage allocator.
2020-07-11 08:40:13 +08:00
Introduce hpdata_t. Using an edata_t both for hugepages and the allocations within those hugepages was convenient at first, but has outlived its usefulness. Representing hugepages explicitly, with their own data structure, will make future development easier.
2020-11-18 08:32:45 +08:00
edata_t alloc[HUGEPAGE_PAGES];
Add psset: a set of pageslabs. This introduces a new sort of edata_t; a pageslab, and a set to manage them. This is part of a series of a commits to implement a hugepage allocator; the pageset will be per-arena, and track small page allocations requests within a larger extent allocated from a centralized hugepage allocator.
2020-07-11 08:40:13 +08:00
psset_t psset;
psset_init(&psset);
edata_init_test(&alloc[0]);
psset_alloc_new(&psset, &pageslab, &alloc[0], PAGE);
Introduce hpdata_t. Using an edata_t both for hugepages and the allocations within those hugepages was convenient at first, but has outlived its usefulness. Representing hugepages explicitly, with their own data structure, will make future development easier.
2020-11-18 08:32:45 +08:00
for (size_t i = 1; i < HUGEPAGE_PAGES; i++) {
Add psset: a set of pageslabs. This introduces a new sort of edata_t; a pageslab, and a set to manage them. This is part of a series of a commits to implement a hugepage allocator; the pageset will be per-arena, and track small page allocations requests within a larger extent allocated from a centralized hugepage allocator.
2020-07-11 08:40:13 +08:00
edata_init_test(&alloc[i]);
err = psset_alloc_reuse(&psset, &alloc[i], PAGE);
expect_false(err, "Nonempty psset failed page allocation.");
}
/* Free odd indices. */
Introduce hpdata_t. Using an edata_t both for hugepages and the allocations within those hugepages was convenient at first, but has outlived its usefulness. Representing hugepages explicitly, with their own data structure, will make future development easier.
2020-11-18 08:32:45 +08:00
for (size_t i = 0; i < HUGEPAGE_PAGES; i ++) {
Add psset: a set of pageslabs. This introduces a new sort of edata_t; a pageslab, and a set to manage them. This is part of a series of a commits to implement a hugepage allocator; the pageset will be per-arena, and track small page allocations requests within a larger extent allocated from a centralized hugepage allocator.
2020-07-11 08:40:13 +08:00
if (i % 2 == 0) {
continue;
}
ps = psset_dalloc(&psset, &alloc[i]);
expect_ptr_null(ps, "Nonempty pageslab evicted");
}
/* Realloc into them. */
Introduce hpdata_t. Using an edata_t both for hugepages and the allocations within those hugepages was convenient at first, but has outlived its usefulness. Representing hugepages explicitly, with their own data structure, will make future development easier.
2020-11-18 08:32:45 +08:00
for (size_t i = 0; i < HUGEPAGE_PAGES; i++) {
Add psset: a set of pageslabs. This introduces a new sort of edata_t; a pageslab, and a set to manage them. This is part of a series of a commits to implement a hugepage allocator; the pageset will be per-arena, and track small page allocations requests within a larger extent allocated from a centralized hugepage allocator.
2020-07-11 08:40:13 +08:00
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. */
Introduce hpdata_t. Using an edata_t both for hugepages and the allocations within those hugepages was convenient at first, but has outlived its usefulness. Representing hugepages explicitly, with their own data structure, will make future development easier.
2020-11-18 08:32:45 +08:00
for (size_t i = 0; i < HUGEPAGE_PAGES; i++) {
Add psset: a set of pageslabs. This introduces a new sort of edata_t; a pageslab, and a set to manage them. This is part of a series of a commits to implement a hugepage allocator; the pageset will be per-arena, and track small page allocations requests within a larger extent allocated from a centralized hugepage allocator.
2020-07-11 08:40:13 +08:00
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. */
Introduce hpdata_t. Using an edata_t both for hugepages and the allocations within those hugepages was convenient at first, but has outlived its usefulness. Representing hugepages explicitly, with their own data structure, will make future development easier.
2020-11-18 08:32:45 +08:00
for (size_t i = 0; i < HUGEPAGE_PAGES; i++) {
Add psset: a set of pageslabs. This introduces a new sort of edata_t; a pageslab, and a set to manage them. This is part of a series of a commits to implement a hugepage allocator; the pageset will be per-arena, and track small page allocations requests within a larger extent allocated from a centralized hugepage allocator.
2020-07-11 08:40:13 +08:00
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. */
Introduce hpdata_t. Using an edata_t both for hugepages and the allocations within those hugepages was convenient at first, but has outlived its usefulness. Representing hugepages explicitly, with their own data structure, will make future development easier.
2020-11-18 08:32:45 +08:00
for (size_t i = 0; i < HUGEPAGE_PAGES; i++) {
Add psset: a set of pageslabs. This introduces a new sort of edata_t; a pageslab, and a set to manage them. This is part of a series of a commits to implement a hugepage allocator; the pageset will be per-arena, and track small page allocations requests within a larger extent allocated from a centralized hugepage allocator.
2020-07-11 08:40:13 +08:00
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. */
Introduce hpdata_t. Using an edata_t both for hugepages and the allocations within those hugepages was convenient at first, but has outlived its usefulness. Representing hugepages explicitly, with their own data structure, will make future development easier.
2020-11-18 08:32:45 +08:00
ps = psset_dalloc(&psset, &alloc[HUGEPAGE_PAGES - 1]);
Add psset: a set of pageslabs. This introduces a new sort of edata_t; a pageslab, and a set to manage them. This is part of a series of a commits to implement a hugepage allocator; the pageset will be per-arena, and track small page allocations requests within a larger extent allocated from a centralized hugepage allocator.
2020-07-11 08:40:13 +08:00
expect_ptr_null(ps, "Nonempty pageslab evicted");
Introduce hpdata_t. Using an edata_t both for hugepages and the allocations within those hugepages was convenient at first, but has outlived its usefulness. Representing hugepages explicitly, with their own data structure, will make future development easier.
2020-11-18 08:32:45 +08:00
ps = psset_dalloc(&psset, &alloc[HUGEPAGE_PAGES - 2]);
Add psset: a set of pageslabs. This introduces a new sort of edata_t; a pageslab, and a set to manage them. This is part of a series of a commits to implement a hugepage allocator; the pageset will be per-arena, and track small page allocations requests within a larger extent allocated from a centralized hugepage allocator.
2020-07-11 08:40:13 +08:00
expect_ptr_null(ps, "Nonempty pageslab evicted");
/* Make sure we can satisfy an allocation at the very end of a slab. */
Introduce hpdata_t. Using an edata_t both for hugepages and the allocations within those hugepages was convenient at first, but has outlived its usefulness. Representing hugepages explicitly, with their own data structure, will make future development easier.
2020-11-18 08:32:45 +08:00
size_t index_of_4 = HUGEPAGE_PAGES - 4;
Add psset: a set of pageslabs. This introduces a new sort of edata_t; a pageslab, and a set to manage them. This is part of a series of a commits to implement a hugepage allocator; the pageset will be per-arena, and track small page allocations requests within a larger extent allocated from a centralized hugepage allocator.
2020-07-11 08:40:13 +08:00
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;
Introduce hpdata_t. Using an edata_t both for hugepages and the allocations within those hugepages was convenient at first, but has outlived its usefulness. Representing hugepages explicitly, with their own data structure, will make future development easier.
2020-11-18 08:32:45 +08:00
hpdata_t *ps;
hpdata_t pageslab;
hpdata_init(&pageslab, PAGESLAB_ADDR, PAGESLAB_AGE);
edata_t alloc[HUGEPAGE_PAGES];
Add psset: a set of pageslabs. This introduces a new sort of edata_t; a pageslab, and a set to manage them. This is part of a series of a commits to implement a hugepage allocator; the pageset will be per-arena, and track small page allocations requests within a larger extent allocated from a centralized hugepage allocator.
2020-07-11 08:40:13 +08:00
psset_t psset;
psset_init(&psset);
/* Alloc the whole slab. */
edata_init_test(&alloc[0]);
psset_alloc_new(&psset, &pageslab, &alloc[0], PAGE);
Introduce hpdata_t. Using an edata_t both for hugepages and the allocations within those hugepages was convenient at first, but has outlived its usefulness. Representing hugepages explicitly, with their own data structure, will make future development easier.
2020-11-18 08:32:45 +08:00
for (size_t i = 1; i < HUGEPAGE_PAGES; i++) {
Add psset: a set of pageslabs. This introduces a new sort of edata_t; a pageslab, and a set to manage them. This is part of a series of a commits to implement a hugepage allocator; the pageset will be per-arena, and track small page allocations requests within a larger extent allocated from a centralized hugepage allocator.
2020-07-11 08:40:13 +08:00
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. */
Introduce hpdata_t. Using an edata_t both for hugepages and the allocations within those hugepages was convenient at first, but has outlived its usefulness. Representing hugepages explicitly, with their own data structure, will make future development easier.
2020-11-18 08:32:45 +08:00
for (size_t i = 0; i < HUGEPAGE_PAGES - 1; i++) {
Add psset: a set of pageslabs. This introduces a new sort of edata_t; a pageslab, and a set to manage them. This is part of a series of a commits to implement a hugepage allocator; the pageset will be per-arena, and track small page allocations requests within a larger extent allocated from a centralized hugepage allocator.
2020-07-11 08:40:13 +08:00
ps = psset_dalloc(&psset, &alloc[i]);
expect_ptr_null(ps, "Nonempty pageslab evicted");
}
Introduce hpdata_t. Using an edata_t both for hugepages and the allocations within those hugepages was convenient at first, but has outlived its usefulness. Representing hugepages explicitly, with their own data structure, will make future development easier.
2020-11-18 08:32:45 +08:00
ps = psset_dalloc(&psset, &alloc[HUGEPAGE_PAGES - 1]);
Add psset: a set of pageslabs. This introduces a new sort of edata_t; a pageslab, and a set to manage them. This is part of a series of a commits to implement a hugepage allocator; the pageset will be per-arena, and track small page allocations requests within a larger extent allocated from a centralized hugepage allocator.
2020-07-11 08:40:13 +08:00
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;
Introduce hpdata_t. Using an edata_t both for hugepages and the allocations within those hugepages was convenient at first, but has outlived its usefulness. Representing hugepages explicitly, with their own data structure, will make future development easier.
2020-11-18 08:32:45 +08:00
hpdata_t *ps;
hpdata_t pageslab[2];
hpdata_init(&pageslab[0], PAGESLAB_ADDR, PAGESLAB_AGE);
hpdata_init(&pageslab[1],
(void *)((uintptr_t)PAGESLAB_ADDR + HUGEPAGE),
PAGESLAB_AGE + 1);
edata_t alloc[2][HUGEPAGE_PAGES];
Add psset: a set of pageslabs. This introduces a new sort of edata_t; a pageslab, and a set to manage them. This is part of a series of a commits to implement a hugepage allocator; the pageset will be per-arena, and track small page allocations requests within a larger extent allocated from a centralized hugepage allocator.
2020-07-11 08:40:13 +08:00
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++) {
Introduce hpdata_t. Using an edata_t both for hugepages and the allocations within those hugepages was convenient at first, but has outlived its usefulness. Representing hugepages explicitly, with their own data structure, will make future development easier.
2020-11-18 08:32:45 +08:00
for (size_t j = 1; j < HUGEPAGE_PAGES; j++) {
Add psset: a set of pageslabs. This introduces a new sort of edata_t; a pageslab, and a set to manage them. This is part of a series of a commits to implement a hugepage allocator; the pageset will be per-arena, and track small page allocations requests within a larger extent allocated from a centralized hugepage allocator.
2020-07-11 08:40:13 +08:00
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
psset: Do first-fit based on slab age. This functions more like the serial number strategy of the ecache and hpa_central_t. Longer-lived slabs are more likely to continue to live for longer in the future.
2020-09-19 07:36:40 +08:00
* later one. We should still pick the later one.
Add psset: a set of pageslabs. This introduces a new sort of edata_t; a pageslab, and a set to manage them. This is part of a series of a commits to implement a hugepage allocator; the pageset will be per-arena, and track small page allocations requests within a larger extent allocated from a centralized hugepage allocator.
2020-07-11 08:40:13 +08:00
*/
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);
psset: Do first-fit based on slab age. This functions more like the serial number strategy of the ecache and hpa_central_t. Longer-lived slabs are more likely to continue to live for longer in the future.
2020-09-19 07:36:40 +08:00
expect_ptr_eq(&pageslab[1], edata_ps_get(&alloc[0][0]),
"Should have picked the fuller pageslab");
Add psset: a set of pageslabs. This introduces a new sort of edata_t; a pageslab, and a set to manage them. This is part of a series of a commits to implement a hugepage allocator; the pageset will be per-arena, and track small page allocations requests within a larger extent allocated from a centralized hugepage allocator.
2020-07-11 08:40:13 +08:00
/*
* 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
psset: Add stats
2020-09-03 03:59:10 +08:00
static void
stats_expect_empty(psset_bin_stats_t *stats) {
HPA: Manage whole hugepages at a time. This redesigns the HPA implementation to allow us to manage hugepages all at once, locally, without relying on a global fallback.
2020-11-10 05:49:30 +08:00
assert_zu_eq(0, stats->npageslabs_nonhuge,
psset: Add stats
2020-09-03 03:59:10 +08:00
"Supposedly empty bin had positive npageslabs");
HPA: Manage whole hugepages at a time. This redesigns the HPA implementation to allow us to manage hugepages all at once, locally, without relying on a global fallback.
2020-11-10 05:49:30 +08:00
expect_zu_eq(0, stats->nactive_nonhuge, "Unexpected nonempty bin"
psset: Add stats
2020-09-03 03:59:10 +08:00
"Supposedly empty bin had positive nactive");
HPA: Manage whole hugepages at a time. This redesigns the HPA implementation to allow us to manage hugepages all at once, locally, without relying on a global fallback.
2020-11-10 05:49:30 +08:00
expect_zu_eq(0, stats->ninactive_nonhuge, "Unexpected nonempty bin"
psset: Add stats
2020-09-03 03:59:10 +08:00
"Supposedly empty bin had positive ninactive");
}
static void
stats_expect(psset_t *psset, size_t nactive) {
Introduce hpdata_t. Using an edata_t both for hugepages and the allocations within those hugepages was convenient at first, but has outlived its usefulness. Representing hugepages explicitly, with their own data structure, will make future development easier.
2020-11-18 08:32:45 +08:00
if (nactive == HUGEPAGE_PAGES) {
HPA: Manage whole hugepages at a time. This redesigns the HPA implementation to allow us to manage hugepages all at once, locally, without relying on a global fallback.
2020-11-10 05:49:30 +08:00
expect_zu_eq(1, psset->stats.full_slabs.npageslabs_nonhuge,
psset: Add stats
2020-09-03 03:59:10 +08:00
"Expected a full slab");
Introduce hpdata_t. Using an edata_t both for hugepages and the allocations within those hugepages was convenient at first, but has outlived its usefulness. Representing hugepages explicitly, with their own data structure, will make future development easier.
2020-11-18 08:32:45 +08:00
expect_zu_eq(HUGEPAGE_PAGES,
HPA: Manage whole hugepages at a time. This redesigns the HPA implementation to allow us to manage hugepages all at once, locally, without relying on a global fallback.
2020-11-10 05:49:30 +08:00
psset->stats.full_slabs.nactive_nonhuge,
psset: Add stats
2020-09-03 03:59:10 +08:00
"Should have exactly filled the bin");
HPA: Manage whole hugepages at a time. This redesigns the HPA implementation to allow us to manage hugepages all at once, locally, without relying on a global fallback.
2020-11-10 05:49:30 +08:00
expect_zu_eq(0, psset->stats.full_slabs.ninactive_nonhuge,
psset: Add stats
2020-09-03 03:59:10 +08:00
"Should never have inactive pages in a full slab");
} else {
psset: Move in stats. A later change will benefit from having these functions pulled into a psset-module set of functions.
2020-11-11 08:23:03 +08:00
stats_expect_empty(&psset->stats.full_slabs);
psset: Add stats
2020-09-03 03:59:10 +08:00
}
Introduce hpdata_t. Using an edata_t both for hugepages and the allocations within those hugepages was convenient at first, but has outlived its usefulness. Representing hugepages explicitly, with their own data structure, will make future development easier.
2020-11-18 08:32:45 +08:00
size_t ninactive = HUGEPAGE_PAGES - nactive;
psset: Add stats
2020-09-03 03:59:10 +08:00
pszind_t nonempty_pind = PSSET_NPSIZES;
Introduce hpdata_t. Using an edata_t both for hugepages and the allocations within those hugepages was convenient at first, but has outlived its usefulness. Representing hugepages explicitly, with their own data structure, will make future development easier.
2020-11-18 08:32:45 +08:00
if (ninactive != 0 && ninactive < HUGEPAGE_PAGES) {
psset: Add stats
2020-09-03 03:59:10 +08:00
nonempty_pind = sz_psz2ind(sz_psz_quantize_floor(
ninactive << LG_PAGE));
}
for (pszind_t i = 0; i < PSSET_NPSIZES; i++) {
if (i == nonempty_pind) {
psset: Move in stats. A later change will benefit from having these functions pulled into a psset-module set of functions.
2020-11-11 08:23:03 +08:00
assert_zu_eq(1,
HPA: Manage whole hugepages at a time. This redesigns the HPA implementation to allow us to manage hugepages all at once, locally, without relying on a global fallback.
2020-11-10 05:49:30 +08:00
psset->stats.nonfull_slabs[i].npageslabs_nonhuge,
psset: Add stats
2020-09-03 03:59:10 +08:00
"Should have found a slab");
psset: Move in stats. A later change will benefit from having these functions pulled into a psset-module set of functions.
2020-11-11 08:23:03 +08:00
expect_zu_eq(nactive,
HPA: Manage whole hugepages at a time. This redesigns the HPA implementation to allow us to manage hugepages all at once, locally, without relying on a global fallback.
2020-11-10 05:49:30 +08:00
psset->stats.nonfull_slabs[i].nactive_nonhuge,
psset: Add stats
2020-09-03 03:59:10 +08:00
"Mismatch in active pages");
psset: Move in stats. A later change will benefit from having these functions pulled into a psset-module set of functions.
2020-11-11 08:23:03 +08:00
expect_zu_eq(ninactive,
HPA: Manage whole hugepages at a time. This redesigns the HPA implementation to allow us to manage hugepages all at once, locally, without relying on a global fallback.
2020-11-10 05:49:30 +08:00
psset->stats.nonfull_slabs[i].ninactive_nonhuge,
psset: Add stats
2020-09-03 03:59:10 +08:00
"Mismatch in inactive pages");
} else {
psset: Move in stats. A later change will benefit from having these functions pulled into a psset-module set of functions.
2020-11-11 08:23:03 +08:00
stats_expect_empty(&psset->stats.nonfull_slabs[i]);
psset: Add stats
2020-09-03 03:59:10 +08:00
}
}
}
TEST_BEGIN(test_stats) {
bool err;
Introduce hpdata_t. Using an edata_t both for hugepages and the allocations within those hugepages was convenient at first, but has outlived its usefulness. Representing hugepages explicitly, with their own data structure, will make future development easier.
2020-11-18 08:32:45 +08:00
hpdata_t pageslab;
hpdata_init(&pageslab, PAGESLAB_ADDR, PAGESLAB_AGE);
edata_t alloc[HUGEPAGE_PAGES];
psset: Add stats
2020-09-03 03:59:10 +08:00
psset_t psset;
psset_init(&psset);
stats_expect(&psset, 0);
edata_init_test(&alloc[0]);
psset_alloc_new(&psset, &pageslab, &alloc[0], PAGE);
Introduce hpdata_t. Using an edata_t both for hugepages and the allocations within those hugepages was convenient at first, but has outlived its usefulness. Representing hugepages explicitly, with their own data structure, will make future development easier.
2020-11-18 08:32:45 +08:00
for (size_t i = 1; i < HUGEPAGE_PAGES; i++) {
psset: Add stats
2020-09-03 03:59:10 +08:00
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.");
}
Introduce hpdata_t. Using an edata_t both for hugepages and the allocations within those hugepages was convenient at first, but has outlived its usefulness. Representing hugepages explicitly, with their own data structure, will make future development easier.
2020-11-18 08:32:45 +08:00
stats_expect(&psset, HUGEPAGE_PAGES);
hpdata_t *ps;
for (ssize_t i = HUGEPAGE_PAGES - 1; i >= 0; i--) {
psset: Add insert/remove functions. These will allow us to (for instance) move pageslabs from a psset dedicated to not-yet-hugeified pages to one dedicated to hugeified ones.
2020-11-10 09:24:31 +08:00
ps = psset_dalloc(&psset, &alloc[i]);
psset: Add stats
2020-09-03 03:59:10 +08:00
expect_true((ps == NULL) == (i != 0),
"psset_dalloc should only evict a slab on the last free");
stats_expect(&psset, i);
}
psset: Add insert/remove functions. These will allow us to (for instance) move pageslabs from a psset dedicated to not-yet-hugeified pages to one dedicated to hugeified ones.
2020-11-10 09:24:31 +08:00
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);
psset: Add stats
2020-09-03 03:59:10 +08:00
}
TEST_END
psset: Add insert/remove functions. These will allow us to (for instance) move pageslabs from a psset dedicated to not-yet-hugeified pages to one dedicated to hugeified ones.
2020-11-10 09:24:31 +08:00
/*
* 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,
Introduce hpdata_t. Using an edata_t both for hugepages and the allocations within those hugepages was convenient at first, but has outlived its usefulness. Representing hugepages explicitly, with their own data structure, will make future development easier.
2020-11-18 08:32:45 +08:00
* each of which should be HUGEPAGE_PAGES long).
psset: Add insert/remove functions. These will allow us to (for instance) move pageslabs from a psset dedicated to not-yet-hugeified pages to one dedicated to hugeified ones.
2020-11-10 09:24:31 +08:00
*
* (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
Introduce hpdata_t. Using an edata_t both for hugepages and the allocations within those hugepages was convenient at first, but has outlived its usefulness. Representing hugepages explicitly, with their own data structure, will make future development easier.
2020-11-18 08:32:45 +08:00
init_test_pageslabs(psset_t *psset, hpdata_t *pageslab,
hpdata_t *worse_pageslab, edata_t *alloc, edata_t *worse_alloc) {
psset: Do first-fit based on slab age. This functions more like the serial number strategy of the ecache and hpa_central_t. Longer-lived slabs are more likely to continue to live for longer in the future.
2020-09-19 07:36:40 +08:00
bool err;
Introduce hpdata_t. Using an edata_t both for hugepages and the allocations within those hugepages was convenient at first, but has outlived its usefulness. Representing hugepages explicitly, with their own data structure, will make future development easier.
2020-11-18 08:32:45 +08:00
hpdata_init(pageslab, (void *)(10 * HUGEPAGE), PAGESLAB_AGE);
psset: Do first-fit based on slab age. This functions more like the serial number strategy of the ecache and hpa_central_t. Longer-lived slabs are more likely to continue to live for longer in the future.
2020-09-19 07:36:40 +08:00
/*
Introduce hpdata_t. Using an edata_t both for hugepages and the allocations within those hugepages was convenient at first, but has outlived its usefulness. Representing hugepages explicitly, with their own data structure, will make future development easier.
2020-11-18 08:32:45 +08:00
* This pageslab would be better from an address-first-fit POV, but
* better from an age POV.
psset: Do first-fit based on slab age. This functions more like the serial number strategy of the ecache and hpa_central_t. Longer-lived slabs are more likely to continue to live for longer in the future.
2020-09-19 07:36:40 +08:00
*/
Introduce hpdata_t. Using an edata_t both for hugepages and the allocations within those hugepages was convenient at first, but has outlived its usefulness. Representing hugepages explicitly, with their own data structure, will make future development easier.
2020-11-18 08:32:45 +08:00
hpdata_init(worse_pageslab, (void *)(9 * HUGEPAGE), PAGESLAB_AGE + 1);
psset: Do first-fit based on slab age. This functions more like the serial number strategy of the ecache and hpa_central_t. Longer-lived slabs are more likely to continue to live for longer in the future.
2020-09-19 07:36:40 +08:00
psset: Add insert/remove functions. These will allow us to (for instance) move pageslabs from a psset dedicated to not-yet-hugeified pages to one dedicated to hugeified ones.
2020-11-10 09:24:31 +08:00
psset_init(psset);
psset: Do first-fit based on slab age. This functions more like the serial number strategy of the ecache and hpa_central_t. Longer-lived slabs are more likely to continue to live for longer in the future.
2020-09-19 07:36:40 +08:00
edata_init_test(&alloc[0]);
psset: Add insert/remove functions. These will allow us to (for instance) move pageslabs from a psset dedicated to not-yet-hugeified pages to one dedicated to hugeified ones.
2020-11-10 09:24:31 +08:00
psset_alloc_new(psset, pageslab, &alloc[0], PAGE);
Introduce hpdata_t. Using an edata_t both for hugepages and the allocations within those hugepages was convenient at first, but has outlived its usefulness. Representing hugepages explicitly, with their own data structure, will make future development easier.
2020-11-18 08:32:45 +08:00
for (size_t i = 1; i < HUGEPAGE_PAGES; i++) {
psset: Do first-fit based on slab age. This functions more like the serial number strategy of the ecache and hpa_central_t. Longer-lived slabs are more likely to continue to live for longer in the future.
2020-09-19 07:36:40 +08:00
edata_init_test(&alloc[i]);
psset: Add insert/remove functions. These will allow us to (for instance) move pageslabs from a psset dedicated to not-yet-hugeified pages to one dedicated to hugeified ones.
2020-11-10 09:24:31 +08:00
err = psset_alloc_reuse(psset, &alloc[i], PAGE);
psset: Do first-fit based on slab age. This functions more like the serial number strategy of the ecache and hpa_central_t. Longer-lived slabs are more likely to continue to live for longer in the future.
2020-09-19 07:36:40 +08:00
expect_false(err, "Nonempty psset failed page allocation.");
psset: Add insert/remove functions. These will allow us to (for instance) move pageslabs from a psset dedicated to not-yet-hugeified pages to one dedicated to hugeified ones.
2020-11-10 09:24:31 +08:00
expect_ptr_eq(pageslab, edata_ps_get(&alloc[i]),
psset: Do first-fit based on slab age. This functions more like the serial number strategy of the ecache and hpa_central_t. Longer-lived slabs are more likely to continue to live for longer in the future.
2020-09-19 07:36:40 +08:00
"Allocated from the wrong pageslab");
}
edata_init_test(&worse_alloc[0]);
psset: Add insert/remove functions. These will allow us to (for instance) move pageslabs from a psset dedicated to not-yet-hugeified pages to one dedicated to hugeified ones.
2020-11-10 09:24:31 +08:00
psset_alloc_new(psset, worse_pageslab, &worse_alloc[0], PAGE);
expect_ptr_eq(worse_pageslab, edata_ps_get(&worse_alloc[0]),
psset: Do first-fit based on slab age. This functions more like the serial number strategy of the ecache and hpa_central_t. Longer-lived slabs are more likely to continue to live for longer in the future.
2020-09-19 07:36:40 +08:00
"Allocated from the wrong pageslab");
/*
* Make the two pssets otherwise indistinguishable; all full except for
* a single page.
*/
Introduce hpdata_t. Using an edata_t both for hugepages and the allocations within those hugepages was convenient at first, but has outlived its usefulness. Representing hugepages explicitly, with their own data structure, will make future development easier.
2020-11-18 08:32:45 +08:00
for (size_t i = 1; i < HUGEPAGE_PAGES - 1; i++) {
psset: Do first-fit based on slab age. This functions more like the serial number strategy of the ecache and hpa_central_t. Longer-lived slabs are more likely to continue to live for longer in the future.
2020-09-19 07:36:40 +08:00
edata_init_test(&worse_alloc[i]);
psset: Add insert/remove functions. These will allow us to (for instance) move pageslabs from a psset dedicated to not-yet-hugeified pages to one dedicated to hugeified ones.
2020-11-10 09:24:31 +08:00
err = psset_alloc_reuse(psset, &alloc[i], PAGE);
psset: Do first-fit based on slab age. This functions more like the serial number strategy of the ecache and hpa_central_t. Longer-lived slabs are more likely to continue to live for longer in the future.
2020-09-19 07:36:40 +08:00
expect_false(err, "Nonempty psset failed page allocation.");
psset: Add insert/remove functions. These will allow us to (for instance) move pageslabs from a psset dedicated to not-yet-hugeified pages to one dedicated to hugeified ones.
2020-11-10 09:24:31 +08:00
expect_ptr_eq(worse_pageslab, edata_ps_get(&alloc[i]),
psset: Do first-fit based on slab age. This functions more like the serial number strategy of the ecache and hpa_central_t. Longer-lived slabs are more likely to continue to live for longer in the future.
2020-09-19 07:36:40 +08:00
"Allocated from the wrong pageslab");
}
/* Deallocate the last page from the older pageslab. */
Introduce hpdata_t. Using an edata_t both for hugepages and the allocations within those hugepages was convenient at first, but has outlived its usefulness. Representing hugepages explicitly, with their own data structure, will make future development easier.
2020-11-18 08:32:45 +08:00
hpdata_t *evicted = psset_dalloc(psset, &alloc[HUGEPAGE_PAGES - 1]);
psset: Do first-fit based on slab age. This functions more like the serial number strategy of the ecache and hpa_central_t. Longer-lived slabs are more likely to continue to live for longer in the future.
2020-09-19 07:36:40 +08:00
expect_ptr_null(evicted, "Unexpected eviction");
psset: Add insert/remove functions. These will allow us to (for instance) move pageslabs from a psset dedicated to not-yet-hugeified pages to one dedicated to hugeified ones.
2020-11-10 09:24:31 +08:00
}
psset: Do first-fit based on slab age. This functions more like the serial number strategy of the ecache and hpa_central_t. Longer-lived slabs are more likely to continue to live for longer in the future.
2020-09-19 07:36:40 +08:00
psset: Add insert/remove functions. These will allow us to (for instance) move pageslabs from a psset dedicated to not-yet-hugeified pages to one dedicated to hugeified ones.
2020-11-10 09:24:31 +08:00
TEST_BEGIN(test_oldest_fit) {
bool err;
Introduce hpdata_t. Using an edata_t both for hugepages and the allocations within those hugepages was convenient at first, but has outlived its usefulness. Representing hugepages explicitly, with their own data structure, will make future development easier.
2020-11-18 08:32:45 +08:00
edata_t alloc[HUGEPAGE_PAGES];
edata_t worse_alloc[HUGEPAGE_PAGES];
psset: Add insert/remove functions. These will allow us to (for instance) move pageslabs from a psset dedicated to not-yet-hugeified pages to one dedicated to hugeified ones.
2020-11-10 09:24:31 +08:00
Introduce hpdata_t. Using an edata_t both for hugepages and the allocations within those hugepages was convenient at first, but has outlived its usefulness. Representing hugepages explicitly, with their own data structure, will make future development easier.
2020-11-18 08:32:45 +08:00
hpdata_t pageslab;
hpdata_t worse_pageslab;
psset: Add insert/remove functions. These will allow us to (for instance) move pageslabs from a psset dedicated to not-yet-hugeified pages to one dedicated to hugeified ones.
2020-11-10 09:24:31 +08:00
psset_t psset;
init_test_pageslabs(&psset, &pageslab, &worse_pageslab, alloc,
worse_alloc);
/* The edata should come from the better pageslab. */
psset: Do first-fit based on slab age. This functions more like the serial number strategy of the ecache and hpa_central_t. Longer-lived slabs are more likely to continue to live for longer in the future.
2020-09-19 07:36:40 +08:00
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
psset: Add insert/remove functions. These will allow us to (for instance) move pageslabs from a psset dedicated to not-yet-hugeified pages to one dedicated to hugeified ones.
2020-11-10 09:24:31 +08:00
TEST_BEGIN(test_insert_remove) {
bool err;
Introduce hpdata_t. Using an edata_t both for hugepages and the allocations within those hugepages was convenient at first, but has outlived its usefulness. Representing hugepages explicitly, with their own data structure, will make future development easier.
2020-11-18 08:32:45 +08:00
hpdata_t *ps;
edata_t alloc[HUGEPAGE_PAGES];
edata_t worse_alloc[HUGEPAGE_PAGES];
psset: Add insert/remove functions. These will allow us to (for instance) move pageslabs from a psset dedicated to not-yet-hugeified pages to one dedicated to hugeified ones.
2020-11-10 09:24:31 +08:00
Introduce hpdata_t. Using an edata_t both for hugepages and the allocations within those hugepages was convenient at first, but has outlived its usefulness. Representing hugepages explicitly, with their own data structure, will make future development easier.
2020-11-18 08:32:45 +08:00
hpdata_t pageslab;
hpdata_t worse_pageslab;
psset: Add insert/remove functions. These will allow us to (for instance) move pageslabs from a psset dedicated to not-yet-hugeified pages to one dedicated to hugeified ones.
2020-11-10 09:24:31 +08:00
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);
Introduce hpdata_t. Using an edata_t both for hugepages and the allocations within those hugepages was convenient at first, but has outlived its usefulness. Representing hugepages explicitly, with their own data structure, will make future development easier.
2020-11-18 08:32:45 +08:00
err = psset_alloc_reuse(&psset, &worse_alloc[HUGEPAGE_PAGES - 1], PAGE);
psset: Add insert/remove functions. These will allow us to (for instance) move pageslabs from a psset dedicated to not-yet-hugeified pages to one dedicated to hugeified ones.
2020-11-10 09:24:31 +08:00
expect_false(err, "Removal should still leave an empty page");
expect_ptr_eq(&worse_pageslab,
Introduce hpdata_t. Using an edata_t both for hugepages and the allocations within those hugepages was convenient at first, but has outlived its usefulness. Representing hugepages explicitly, with their own data structure, will make future development easier.
2020-11-18 08:32:45 +08:00
edata_ps_get(&worse_alloc[HUGEPAGE_PAGES - 1]),
psset: Add insert/remove functions. These will allow us to (for instance) move pageslabs from a psset dedicated to not-yet-hugeified pages to one dedicated to hugeified ones.
2020-11-10 09:24:31 +08:00
"Allocated out of wrong ps");
/*
* After deallocating the previous alloc and reinserting better, it
* should be preferred for future allocations.
*/
Introduce hpdata_t. Using an edata_t both for hugepages and the allocations within those hugepages was convenient at first, but has outlived its usefulness. Representing hugepages explicitly, with their own data structure, will make future development easier.
2020-11-18 08:32:45 +08:00
ps = psset_dalloc(&psset, &worse_alloc[HUGEPAGE_PAGES - 1]);
psset: Add insert/remove functions. These will allow us to (for instance) move pageslabs from a psset dedicated to not-yet-hugeified pages to one dedicated to hugeified ones.
2020-11-10 09:24:31 +08:00
expect_ptr_null(ps, "Incorrect eviction of nonempty pageslab");
psset_insert(&psset, &pageslab);
Introduce hpdata_t. Using an edata_t both for hugepages and the allocations within those hugepages was convenient at first, but has outlived its usefulness. Representing hugepages explicitly, with their own data structure, will make future development easier.
2020-11-18 08:32:45 +08:00
err = psset_alloc_reuse(&psset, &alloc[HUGEPAGE_PAGES - 1], PAGE);
psset: Add insert/remove functions. These will allow us to (for instance) move pageslabs from a psset dedicated to not-yet-hugeified pages to one dedicated to hugeified ones.
2020-11-10 09:24:31 +08:00
expect_false(err, "psset should be nonempty");
Introduce hpdata_t. Using an edata_t both for hugepages and the allocations within those hugepages was convenient at first, but has outlived its usefulness. Representing hugepages explicitly, with their own data structure, will make future development easier.
2020-11-18 08:32:45 +08:00
expect_ptr_eq(&pageslab, edata_ps_get(&alloc[HUGEPAGE_PAGES - 1]),
psset: Add insert/remove functions. These will allow us to (for instance) move pageslabs from a psset dedicated to not-yet-hugeified pages to one dedicated to hugeified ones.
2020-11-10 09:24:31 +08:00
"Removal/reinsertion shouldn't change ordering");
/*
* After deallocating and removing both, allocations should fail.
*/
Introduce hpdata_t. Using an edata_t both for hugepages and the allocations within those hugepages was convenient at first, but has outlived its usefulness. Representing hugepages explicitly, with their own data structure, will make future development easier.
2020-11-18 08:32:45 +08:00
ps = psset_dalloc(&psset, &alloc[HUGEPAGE_PAGES - 1]);
psset: Add insert/remove functions. These will allow us to (for instance) move pageslabs from a psset dedicated to not-yet-hugeified pages to one dedicated to hugeified ones.
2020-11-10 09:24:31 +08:00
expect_ptr_null(ps, "Incorrect eviction");
psset_remove(&psset, &pageslab);
psset_remove(&psset, &worse_pageslab);
Introduce hpdata_t. Using an edata_t both for hugepages and the allocations within those hugepages was convenient at first, but has outlived its usefulness. Representing hugepages explicitly, with their own data structure, will make future development easier.
2020-11-18 08:32:45 +08:00
err = psset_alloc_reuse(&psset, &alloc[HUGEPAGE_PAGES - 1], PAGE);
psset: Add insert/remove functions. These will allow us to (for instance) move pageslabs from a psset dedicated to not-yet-hugeified pages to one dedicated to hugeified ones.
2020-11-10 09:24:31 +08:00
expect_true(err, "psset should be empty, but an alloc succeeded");
}
TEST_END
Add psset: a set of pageslabs. This introduces a new sort of edata_t; a pageslab, and a set to manage them. This is part of a series of a commits to implement a hugepage allocator; the pageset will be per-arena, and track small page allocations requests within a larger extent allocated from a centralized hugepage allocator.
2020-07-11 08:40:13 +08:00
int
main(void) {
return test_no_reentrancy(
test_empty,
test_fill,
test_reuse,
test_evict,
psset: Add stats
2020-09-03 03:59:10 +08:00
test_multi_pageslab,
psset: Do first-fit based on slab age. This functions more like the serial number strategy of the ecache and hpa_central_t. Longer-lived slabs are more likely to continue to live for longer in the future.
2020-09-19 07:36:40 +08:00
test_stats,
psset: Add insert/remove functions. These will allow us to (for instance) move pageslabs from a psset dedicated to not-yet-hugeified pages to one dedicated to hugeified ones.
2020-11-10 09:24:31 +08:00
test_oldest_fit,
test_insert_remove);
Add psset: a set of pageslabs. This introduces a new sort of edata_t; a pageslab, and a set to manage them. This is part of a series of a commits to implement a hugepage allocator; the pageset will be per-arena, and track small page allocations requests within a larger extent allocated from a centralized hugepage allocator.
2020-07-11 08:40:13 +08:00
}
Reference in New Issue Copy Permalink