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

227 lines
6.8 KiB
C
Raw Normal View History

Edata cache: add a unit test.
2020-02-19 08:09:10 +08:00
#include "test/jemalloc_test.h"
#include "jemalloc/internal/edata_cache.h"
static void
test_edata_cache_init(edata_cache_t *edata_cache) {
base_t *base = base_new(TSDN_NULL, /* ind */ 1,
&ehooks_default_extent_hooks);
assert_ptr_not_null(base, "");
bool err = edata_cache_init(edata_cache, base);
assert_false(err, "");
}
static void
test_edata_cache_destroy(edata_cache_t *edata_cache) {
base_delete(TSDN_NULL, edata_cache->base);
}
TEST_BEGIN(test_edata_cache) {
Edata cache: add edata_cache_small_t. This can be used to amortize the synchronization costs of edata_cache accesses.
2020-02-19 09:21:40 +08:00
edata_cache_t ec;
test_edata_cache_init(&ec);
Edata cache: add a unit test.
2020-02-19 08:09:10 +08:00
/* Get one */
Edata cache: add edata_cache_small_t. This can be used to amortize the synchronization costs of edata_cache accesses.
2020-02-19 09:21:40 +08:00
edata_t *ed1 = edata_cache_get(TSDN_NULL, &ec);
Edata cache: add a unit test.
2020-02-19 08:09:10 +08:00
assert_ptr_not_null(ed1, "");
/* Cache should be empty */
Edata cache: add edata_cache_small_t. This can be used to amortize the synchronization costs of edata_cache accesses.
2020-02-19 09:21:40 +08:00
assert_zu_eq(atomic_load_zu(&ec.count, ATOMIC_RELAXED), 0, "");
Edata cache: add a unit test.
2020-02-19 08:09:10 +08:00
/* Get another */
Edata cache: add edata_cache_small_t. This can be used to amortize the synchronization costs of edata_cache accesses.
2020-02-19 09:21:40 +08:00
edata_t *ed2 = edata_cache_get(TSDN_NULL, &ec);
Edata cache: add a unit test.
2020-02-19 08:09:10 +08:00
assert_ptr_not_null(ed2, "");
/* Still empty */
Edata cache: add edata_cache_small_t. This can be used to amortize the synchronization costs of edata_cache accesses.
2020-02-19 09:21:40 +08:00
assert_zu_eq(atomic_load_zu(&ec.count, ATOMIC_RELAXED), 0, "");
Edata cache: add a unit test.
2020-02-19 08:09:10 +08:00
/* Put one back, and the cache should now have one item */
Edata cache: add edata_cache_small_t. This can be used to amortize the synchronization costs of edata_cache accesses.
2020-02-19 09:21:40 +08:00
edata_cache_put(TSDN_NULL, &ec, ed1);
assert_zu_eq(atomic_load_zu(&ec.count, ATOMIC_RELAXED), 1, "");
Edata cache: add a unit test.
2020-02-19 08:09:10 +08:00
/* Reallocating should reuse the item, and leave an empty cache. */
Edata cache: add edata_cache_small_t. This can be used to amortize the synchronization costs of edata_cache accesses.
2020-02-19 09:21:40 +08:00
edata_t *ed1_again = edata_cache_get(TSDN_NULL, &ec);
Edata cache: add a unit test.
2020-02-19 08:09:10 +08:00
assert_ptr_eq(ed1, ed1_again, "");
Edata cache: add edata_cache_small_t. This can be used to amortize the synchronization costs of edata_cache accesses.
2020-02-19 09:21:40 +08:00
assert_zu_eq(atomic_load_zu(&ec.count, ATOMIC_RELAXED), 0, "");
Edata cache: add a unit test.
2020-02-19 08:09:10 +08:00
Edata cache: add edata_cache_small_t. This can be used to amortize the synchronization costs of edata_cache accesses.
2020-02-19 09:21:40 +08:00
test_edata_cache_destroy(&ec);
}
TEST_END
edata_cache: Allow unbounded fast caching. The edata_cache_small had a fill/flush heuristic. In retrospect, this was a premature optimization; more testing indicates that an unbounded cache is effectively fine here, and moreover we spend a nontrivial amount of time doing unnecessary filling/flushing. As the HPA takes on a larger and larger fraction of all allocations, any theoretical differences in allocation patterns should shrink. The HPA is more efficient with its metadata in general, so it still comes out ahead on metadata usage anyways.
2021-07-24 06:29:43 +08:00
static size_t
ecf_count(edata_cache_fast_t *ecf) {
size_t count = 0;
edata_t *cur;
ql_foreach(cur, &ecf->list.head, ql_link_inactive) {
count++;
}
return count;
}
TEST_BEGIN(test_edata_cache_fast_simple) {
Edata cache: add edata_cache_small_t. This can be used to amortize the synchronization costs of edata_cache accesses.
2020-02-19 09:21:40 +08:00
edata_cache_t ec;
edata_cache: Allow unbounded fast caching. The edata_cache_small had a fill/flush heuristic. In retrospect, this was a premature optimization; more testing indicates that an unbounded cache is effectively fine here, and moreover we spend a nontrivial amount of time doing unnecessary filling/flushing. As the HPA takes on a larger and larger fraction of all allocations, any theoretical differences in allocation patterns should shrink. The HPA is more efficient with its metadata in general, so it still comes out ahead on metadata usage anyways.
2021-07-24 06:29:43 +08:00
edata_cache_fast_t ecf;
Edata cache: add edata_cache_small_t. This can be used to amortize the synchronization costs of edata_cache accesses.
2020-02-19 09:21:40 +08:00
test_edata_cache_init(&ec);
edata_cache: Allow unbounded fast caching. The edata_cache_small had a fill/flush heuristic. In retrospect, this was a premature optimization; more testing indicates that an unbounded cache is effectively fine here, and moreover we spend a nontrivial amount of time doing unnecessary filling/flushing. As the HPA takes on a larger and larger fraction of all allocations, any theoretical differences in allocation patterns should shrink. The HPA is more efficient with its metadata in general, so it still comes out ahead on metadata usage anyways.
2021-07-24 06:29:43 +08:00
edata_cache_fast_init(&ecf, &ec);
Edata cache: add edata_cache_small_t. This can be used to amortize the synchronization costs of edata_cache accesses.
2020-02-19 09:21:40 +08:00
edata_cache: Allow unbounded fast caching. The edata_cache_small had a fill/flush heuristic. In retrospect, this was a premature optimization; more testing indicates that an unbounded cache is effectively fine here, and moreover we spend a nontrivial amount of time doing unnecessary filling/flushing. As the HPA takes on a larger and larger fraction of all allocations, any theoretical differences in allocation patterns should shrink. The HPA is more efficient with its metadata in general, so it still comes out ahead on metadata usage anyways.
2021-07-24 06:29:43 +08:00
edata_t *ed1 = edata_cache_fast_get(TSDN_NULL, &ecf);
Edata cache small: rewrite. In previous designs, this was intended to be a sort of cache that couldn't fail. In the current design, we want to use it just as a contention reduction mechanism. Rewrite it with those goals in mind.
2020-10-29 20:11:16 +08:00
expect_ptr_not_null(ed1, "");
edata_cache: Allow unbounded fast caching. The edata_cache_small had a fill/flush heuristic. In retrospect, this was a premature optimization; more testing indicates that an unbounded cache is effectively fine here, and moreover we spend a nontrivial amount of time doing unnecessary filling/flushing. As the HPA takes on a larger and larger fraction of all allocations, any theoretical differences in allocation patterns should shrink. The HPA is more efficient with its metadata in general, so it still comes out ahead on metadata usage anyways.
2021-07-24 06:29:43 +08:00
expect_zu_eq(ecf_count(&ecf), 0, "");
Edata cache small: rewrite. In previous designs, this was intended to be a sort of cache that couldn't fail. In the current design, we want to use it just as a contention reduction mechanism. Rewrite it with those goals in mind.
2020-10-29 20:11:16 +08:00
expect_zu_eq(atomic_load_zu(&ec.count, ATOMIC_RELAXED), 0, "");
Edata cache: add edata_cache_small_t. This can be used to amortize the synchronization costs of edata_cache accesses.
2020-02-19 09:21:40 +08:00
edata_cache: Allow unbounded fast caching. The edata_cache_small had a fill/flush heuristic. In retrospect, this was a premature optimization; more testing indicates that an unbounded cache is effectively fine here, and moreover we spend a nontrivial amount of time doing unnecessary filling/flushing. As the HPA takes on a larger and larger fraction of all allocations, any theoretical differences in allocation patterns should shrink. The HPA is more efficient with its metadata in general, so it still comes out ahead on metadata usage anyways.
2021-07-24 06:29:43 +08:00
edata_t *ed2 = edata_cache_fast_get(TSDN_NULL, &ecf);
Edata cache small: rewrite. In previous designs, this was intended to be a sort of cache that couldn't fail. In the current design, we want to use it just as a contention reduction mechanism. Rewrite it with those goals in mind.
2020-10-29 20:11:16 +08:00
expect_ptr_not_null(ed2, "");
edata_cache: Allow unbounded fast caching. The edata_cache_small had a fill/flush heuristic. In retrospect, this was a premature optimization; more testing indicates that an unbounded cache is effectively fine here, and moreover we spend a nontrivial amount of time doing unnecessary filling/flushing. As the HPA takes on a larger and larger fraction of all allocations, any theoretical differences in allocation patterns should shrink. The HPA is more efficient with its metadata in general, so it still comes out ahead on metadata usage anyways.
2021-07-24 06:29:43 +08:00
expect_zu_eq(ecf_count(&ecf), 0, "");
Edata cache small: rewrite. In previous designs, this was intended to be a sort of cache that couldn't fail. In the current design, we want to use it just as a contention reduction mechanism. Rewrite it with those goals in mind.
2020-10-29 20:11:16 +08:00
expect_zu_eq(atomic_load_zu(&ec.count, ATOMIC_RELAXED), 0, "");
Edata cache: add edata_cache_small_t. This can be used to amortize the synchronization costs of edata_cache accesses.
2020-02-19 09:21:40 +08:00
edata_cache: Allow unbounded fast caching. The edata_cache_small had a fill/flush heuristic. In retrospect, this was a premature optimization; more testing indicates that an unbounded cache is effectively fine here, and moreover we spend a nontrivial amount of time doing unnecessary filling/flushing. As the HPA takes on a larger and larger fraction of all allocations, any theoretical differences in allocation patterns should shrink. The HPA is more efficient with its metadata in general, so it still comes out ahead on metadata usage anyways.
2021-07-24 06:29:43 +08:00
edata_cache_fast_put(TSDN_NULL, &ecf, ed1);
expect_zu_eq(ecf_count(&ecf), 1, "");
Edata cache small: rewrite. In previous designs, this was intended to be a sort of cache that couldn't fail. In the current design, we want to use it just as a contention reduction mechanism. Rewrite it with those goals in mind.
2020-10-29 20:11:16 +08:00
expect_zu_eq(atomic_load_zu(&ec.count, ATOMIC_RELAXED), 0, "");
Edata cache: add edata_cache_small_t. This can be used to amortize the synchronization costs of edata_cache accesses.
2020-02-19 09:21:40 +08:00
edata_cache: Allow unbounded fast caching. The edata_cache_small had a fill/flush heuristic. In retrospect, this was a premature optimization; more testing indicates that an unbounded cache is effectively fine here, and moreover we spend a nontrivial amount of time doing unnecessary filling/flushing. As the HPA takes on a larger and larger fraction of all allocations, any theoretical differences in allocation patterns should shrink. The HPA is more efficient with its metadata in general, so it still comes out ahead on metadata usage anyways.
2021-07-24 06:29:43 +08:00
edata_cache_fast_put(TSDN_NULL, &ecf, ed2);
expect_zu_eq(ecf_count(&ecf), 2, "");
Edata cache small: rewrite. In previous designs, this was intended to be a sort of cache that couldn't fail. In the current design, we want to use it just as a contention reduction mechanism. Rewrite it with those goals in mind.
2020-10-29 20:11:16 +08:00
expect_zu_eq(atomic_load_zu(&ec.count, ATOMIC_RELAXED), 0, "");
Edata cache: add edata_cache_small_t. This can be used to amortize the synchronization costs of edata_cache accesses.
2020-02-19 09:21:40 +08:00
Edata cache small: rewrite. In previous designs, this was intended to be a sort of cache that couldn't fail. In the current design, we want to use it just as a contention reduction mechanism. Rewrite it with those goals in mind.
2020-10-29 20:11:16 +08:00
/* LIFO ordering. */
edata_cache: Allow unbounded fast caching. The edata_cache_small had a fill/flush heuristic. In retrospect, this was a premature optimization; more testing indicates that an unbounded cache is effectively fine here, and moreover we spend a nontrivial amount of time doing unnecessary filling/flushing. As the HPA takes on a larger and larger fraction of all allocations, any theoretical differences in allocation patterns should shrink. The HPA is more efficient with its metadata in general, so it still comes out ahead on metadata usage anyways.
2021-07-24 06:29:43 +08:00
expect_ptr_eq(ed2, edata_cache_fast_get(TSDN_NULL, &ecf), "");
expect_zu_eq(ecf_count(&ecf), 1, "");
Edata cache small: rewrite. In previous designs, this was intended to be a sort of cache that couldn't fail. In the current design, we want to use it just as a contention reduction mechanism. Rewrite it with those goals in mind.
2020-10-29 20:11:16 +08:00
expect_zu_eq(atomic_load_zu(&ec.count, ATOMIC_RELAXED), 0, "");
Edata cache: add edata_cache_small_t. This can be used to amortize the synchronization costs of edata_cache accesses.
2020-02-19 09:21:40 +08:00
edata_cache: Allow unbounded fast caching. The edata_cache_small had a fill/flush heuristic. In retrospect, this was a premature optimization; more testing indicates that an unbounded cache is effectively fine here, and moreover we spend a nontrivial amount of time doing unnecessary filling/flushing. As the HPA takes on a larger and larger fraction of all allocations, any theoretical differences in allocation patterns should shrink. The HPA is more efficient with its metadata in general, so it still comes out ahead on metadata usage anyways.
2021-07-24 06:29:43 +08:00
expect_ptr_eq(ed1, edata_cache_fast_get(TSDN_NULL, &ecf), "");
expect_zu_eq(ecf_count(&ecf), 0, "");
Edata cache small: rewrite. In previous designs, this was intended to be a sort of cache that couldn't fail. In the current design, we want to use it just as a contention reduction mechanism. Rewrite it with those goals in mind.
2020-10-29 20:11:16 +08:00
expect_zu_eq(atomic_load_zu(&ec.count, ATOMIC_RELAXED), 0, "");
test_edata_cache_destroy(&ec);
}
TEST_END
TEST_BEGIN(test_edata_cache_fill) {
edata_cache_t ec;
edata_cache: Allow unbounded fast caching. The edata_cache_small had a fill/flush heuristic. In retrospect, this was a premature optimization; more testing indicates that an unbounded cache is effectively fine here, and moreover we spend a nontrivial amount of time doing unnecessary filling/flushing. As the HPA takes on a larger and larger fraction of all allocations, any theoretical differences in allocation patterns should shrink. The HPA is more efficient with its metadata in general, so it still comes out ahead on metadata usage anyways.
2021-07-24 06:29:43 +08:00
edata_cache_fast_t ecf;
Edata cache small: rewrite. In previous designs, this was intended to be a sort of cache that couldn't fail. In the current design, we want to use it just as a contention reduction mechanism. Rewrite it with those goals in mind.
2020-10-29 20:11:16 +08:00
test_edata_cache_init(&ec);
edata_cache: Allow unbounded fast caching. The edata_cache_small had a fill/flush heuristic. In retrospect, this was a premature optimization; more testing indicates that an unbounded cache is effectively fine here, and moreover we spend a nontrivial amount of time doing unnecessary filling/flushing. As the HPA takes on a larger and larger fraction of all allocations, any theoretical differences in allocation patterns should shrink. The HPA is more efficient with its metadata in general, so it still comes out ahead on metadata usage anyways.
2021-07-24 06:29:43 +08:00
edata_cache_fast_init(&ecf, &ec);
Edata cache small: rewrite. In previous designs, this was intended to be a sort of cache that couldn't fail. In the current design, we want to use it just as a contention reduction mechanism. Rewrite it with those goals in mind.
2020-10-29 20:11:16 +08:00
edata_cache: Allow unbounded fast caching. The edata_cache_small had a fill/flush heuristic. In retrospect, this was a premature optimization; more testing indicates that an unbounded cache is effectively fine here, and moreover we spend a nontrivial amount of time doing unnecessary filling/flushing. As the HPA takes on a larger and larger fraction of all allocations, any theoretical differences in allocation patterns should shrink. The HPA is more efficient with its metadata in general, so it still comes out ahead on metadata usage anyways.
2021-07-24 06:29:43 +08:00
edata_t *allocs[EDATA_CACHE_FAST_FILL * 2];
Edata cache small: rewrite. In previous designs, this was intended to be a sort of cache that couldn't fail. In the current design, we want to use it just as a contention reduction mechanism. Rewrite it with those goals in mind.
2020-10-29 20:11:16 +08:00
/*
* If the fallback cache can't satisfy the request, we shouldn't do
* extra allocations until compelled to. Put half the fill goal in the
* fallback.
*/
edata_cache: Allow unbounded fast caching. The edata_cache_small had a fill/flush heuristic. In retrospect, this was a premature optimization; more testing indicates that an unbounded cache is effectively fine here, and moreover we spend a nontrivial amount of time doing unnecessary filling/flushing. As the HPA takes on a larger and larger fraction of all allocations, any theoretical differences in allocation patterns should shrink. The HPA is more efficient with its metadata in general, so it still comes out ahead on metadata usage anyways.
2021-07-24 06:29:43 +08:00
for (int i = 0; i < EDATA_CACHE_FAST_FILL / 2; i++) {
Edata cache small: rewrite. In previous designs, this was intended to be a sort of cache that couldn't fail. In the current design, we want to use it just as a contention reduction mechanism. Rewrite it with those goals in mind.
2020-10-29 20:11:16 +08:00
allocs[i] = edata_cache_get(TSDN_NULL, &ec);
}
edata_cache: Allow unbounded fast caching. The edata_cache_small had a fill/flush heuristic. In retrospect, this was a premature optimization; more testing indicates that an unbounded cache is effectively fine here, and moreover we spend a nontrivial amount of time doing unnecessary filling/flushing. As the HPA takes on a larger and larger fraction of all allocations, any theoretical differences in allocation patterns should shrink. The HPA is more efficient with its metadata in general, so it still comes out ahead on metadata usage anyways.
2021-07-24 06:29:43 +08:00
for (int i = 0; i < EDATA_CACHE_FAST_FILL / 2; i++) {
Edata cache small: rewrite. In previous designs, this was intended to be a sort of cache that couldn't fail. In the current design, we want to use it just as a contention reduction mechanism. Rewrite it with those goals in mind.
2020-10-29 20:11:16 +08:00
edata_cache_put(TSDN_NULL, &ec, allocs[i]);
}
edata_cache: Allow unbounded fast caching. The edata_cache_small had a fill/flush heuristic. In retrospect, this was a premature optimization; more testing indicates that an unbounded cache is effectively fine here, and moreover we spend a nontrivial amount of time doing unnecessary filling/flushing. As the HPA takes on a larger and larger fraction of all allocations, any theoretical differences in allocation patterns should shrink. The HPA is more efficient with its metadata in general, so it still comes out ahead on metadata usage anyways.
2021-07-24 06:29:43 +08:00
expect_zu_eq(EDATA_CACHE_FAST_FILL / 2,
Edata cache small: rewrite. In previous designs, this was intended to be a sort of cache that couldn't fail. In the current design, we want to use it just as a contention reduction mechanism. Rewrite it with those goals in mind.
2020-10-29 20:11:16 +08:00
atomic_load_zu(&ec.count, ATOMIC_RELAXED), "");
edata_cache: Allow unbounded fast caching. The edata_cache_small had a fill/flush heuristic. In retrospect, this was a premature optimization; more testing indicates that an unbounded cache is effectively fine here, and moreover we spend a nontrivial amount of time doing unnecessary filling/flushing. As the HPA takes on a larger and larger fraction of all allocations, any theoretical differences in allocation patterns should shrink. The HPA is more efficient with its metadata in general, so it still comes out ahead on metadata usage anyways.
2021-07-24 06:29:43 +08:00
allocs[0] = edata_cache_fast_get(TSDN_NULL, &ecf);
expect_zu_eq(EDATA_CACHE_FAST_FILL / 2 - 1, ecf_count(&ecf),
Edata cache small: rewrite. In previous designs, this was intended to be a sort of cache that couldn't fail. In the current design, we want to use it just as a contention reduction mechanism. Rewrite it with those goals in mind.
2020-10-29 20:11:16 +08:00
"Should have grabbed all edatas available but no more.");
edata_cache: Allow unbounded fast caching. The edata_cache_small had a fill/flush heuristic. In retrospect, this was a premature optimization; more testing indicates that an unbounded cache is effectively fine here, and moreover we spend a nontrivial amount of time doing unnecessary filling/flushing. As the HPA takes on a larger and larger fraction of all allocations, any theoretical differences in allocation patterns should shrink. The HPA is more efficient with its metadata in general, so it still comes out ahead on metadata usage anyways.
2021-07-24 06:29:43 +08:00
for (int i = 1; i < EDATA_CACHE_FAST_FILL / 2; i++) {
allocs[i] = edata_cache_fast_get(TSDN_NULL, &ecf);
Edata cache small: rewrite. In previous designs, this was intended to be a sort of cache that couldn't fail. In the current design, we want to use it just as a contention reduction mechanism. Rewrite it with those goals in mind.
2020-10-29 20:11:16 +08:00
expect_ptr_not_null(allocs[i], "");
}
edata_cache: Allow unbounded fast caching. The edata_cache_small had a fill/flush heuristic. In retrospect, this was a premature optimization; more testing indicates that an unbounded cache is effectively fine here, and moreover we spend a nontrivial amount of time doing unnecessary filling/flushing. As the HPA takes on a larger and larger fraction of all allocations, any theoretical differences in allocation patterns should shrink. The HPA is more efficient with its metadata in general, so it still comes out ahead on metadata usage anyways.
2021-07-24 06:29:43 +08:00
expect_zu_eq(0, ecf_count(&ecf), "");
Edata cache small: rewrite. In previous designs, this was intended to be a sort of cache that couldn't fail. In the current design, we want to use it just as a contention reduction mechanism. Rewrite it with those goals in mind.
2020-10-29 20:11:16 +08:00
/* When forced, we should alloc from the base. */
edata_cache: Allow unbounded fast caching. The edata_cache_small had a fill/flush heuristic. In retrospect, this was a premature optimization; more testing indicates that an unbounded cache is effectively fine here, and moreover we spend a nontrivial amount of time doing unnecessary filling/flushing. As the HPA takes on a larger and larger fraction of all allocations, any theoretical differences in allocation patterns should shrink. The HPA is more efficient with its metadata in general, so it still comes out ahead on metadata usage anyways.
2021-07-24 06:29:43 +08:00
edata_t *edata = edata_cache_fast_get(TSDN_NULL, &ecf);
Edata cache small: rewrite. In previous designs, this was intended to be a sort of cache that couldn't fail. In the current design, we want to use it just as a contention reduction mechanism. Rewrite it with those goals in mind.
2020-10-29 20:11:16 +08:00
expect_ptr_not_null(edata, "");
edata_cache: Allow unbounded fast caching. The edata_cache_small had a fill/flush heuristic. In retrospect, this was a premature optimization; more testing indicates that an unbounded cache is effectively fine here, and moreover we spend a nontrivial amount of time doing unnecessary filling/flushing. As the HPA takes on a larger and larger fraction of all allocations, any theoretical differences in allocation patterns should shrink. The HPA is more efficient with its metadata in general, so it still comes out ahead on metadata usage anyways.
2021-07-24 06:29:43 +08:00
expect_zu_eq(0, ecf_count(&ecf), "Allocated more than necessary");
Edata cache small: rewrite. In previous designs, this was intended to be a sort of cache that couldn't fail. In the current design, we want to use it just as a contention reduction mechanism. Rewrite it with those goals in mind.
2020-10-29 20:11:16 +08:00
expect_zu_eq(0, atomic_load_zu(&ec.count, ATOMIC_RELAXED),
"Allocated more than necessary");
/*
* We should correctly fill in the common case where the fallback isn't
* exhausted, too.
*/
edata_cache: Allow unbounded fast caching. The edata_cache_small had a fill/flush heuristic. In retrospect, this was a premature optimization; more testing indicates that an unbounded cache is effectively fine here, and moreover we spend a nontrivial amount of time doing unnecessary filling/flushing. As the HPA takes on a larger and larger fraction of all allocations, any theoretical differences in allocation patterns should shrink. The HPA is more efficient with its metadata in general, so it still comes out ahead on metadata usage anyways.
2021-07-24 06:29:43 +08:00
for (int i = 0; i < EDATA_CACHE_FAST_FILL * 2; i++) {
Edata cache small: rewrite. In previous designs, this was intended to be a sort of cache that couldn't fail. In the current design, we want to use it just as a contention reduction mechanism. Rewrite it with those goals in mind.
2020-10-29 20:11:16 +08:00
allocs[i] = edata_cache_get(TSDN_NULL, &ec);
expect_ptr_not_null(allocs[i], "");
}
edata_cache: Allow unbounded fast caching. The edata_cache_small had a fill/flush heuristic. In retrospect, this was a premature optimization; more testing indicates that an unbounded cache is effectively fine here, and moreover we spend a nontrivial amount of time doing unnecessary filling/flushing. As the HPA takes on a larger and larger fraction of all allocations, any theoretical differences in allocation patterns should shrink. The HPA is more efficient with its metadata in general, so it still comes out ahead on metadata usage anyways.
2021-07-24 06:29:43 +08:00
for (int i = 0; i < EDATA_CACHE_FAST_FILL * 2; i++) {
Edata cache small: rewrite. In previous designs, this was intended to be a sort of cache that couldn't fail. In the current design, we want to use it just as a contention reduction mechanism. Rewrite it with those goals in mind.
2020-10-29 20:11:16 +08:00
edata_cache_put(TSDN_NULL, &ec, allocs[i]);
}
edata_cache: Allow unbounded fast caching. The edata_cache_small had a fill/flush heuristic. In retrospect, this was a premature optimization; more testing indicates that an unbounded cache is effectively fine here, and moreover we spend a nontrivial amount of time doing unnecessary filling/flushing. As the HPA takes on a larger and larger fraction of all allocations, any theoretical differences in allocation patterns should shrink. The HPA is more efficient with its metadata in general, so it still comes out ahead on metadata usage anyways.
2021-07-24 06:29:43 +08:00
allocs[0] = edata_cache_fast_get(TSDN_NULL, &ecf);
expect_zu_eq(EDATA_CACHE_FAST_FILL - 1, ecf_count(&ecf), "");
expect_zu_eq(EDATA_CACHE_FAST_FILL,
Edata cache small: rewrite. In previous designs, this was intended to be a sort of cache that couldn't fail. In the current design, we want to use it just as a contention reduction mechanism. Rewrite it with those goals in mind.
2020-10-29 20:11:16 +08:00
atomic_load_zu(&ec.count, ATOMIC_RELAXED), "");
edata_cache: Allow unbounded fast caching. The edata_cache_small had a fill/flush heuristic. In retrospect, this was a premature optimization; more testing indicates that an unbounded cache is effectively fine here, and moreover we spend a nontrivial amount of time doing unnecessary filling/flushing. As the HPA takes on a larger and larger fraction of all allocations, any theoretical differences in allocation patterns should shrink. The HPA is more efficient with its metadata in general, so it still comes out ahead on metadata usage anyways.
2021-07-24 06:29:43 +08:00
for (int i = 1; i < EDATA_CACHE_FAST_FILL; i++) {
expect_zu_eq(EDATA_CACHE_FAST_FILL - i, ecf_count(&ecf), "");
expect_zu_eq(EDATA_CACHE_FAST_FILL,
Edata cache small: rewrite. In previous designs, this was intended to be a sort of cache that couldn't fail. In the current design, we want to use it just as a contention reduction mechanism. Rewrite it with those goals in mind.
2020-10-29 20:11:16 +08:00
atomic_load_zu(&ec.count, ATOMIC_RELAXED), "");
edata_cache: Allow unbounded fast caching. The edata_cache_small had a fill/flush heuristic. In retrospect, this was a premature optimization; more testing indicates that an unbounded cache is effectively fine here, and moreover we spend a nontrivial amount of time doing unnecessary filling/flushing. As the HPA takes on a larger and larger fraction of all allocations, any theoretical differences in allocation patterns should shrink. The HPA is more efficient with its metadata in general, so it still comes out ahead on metadata usage anyways.
2021-07-24 06:29:43 +08:00
allocs[i] = edata_cache_fast_get(TSDN_NULL, &ecf);
Edata cache small: rewrite. In previous designs, this was intended to be a sort of cache that couldn't fail. In the current design, we want to use it just as a contention reduction mechanism. Rewrite it with those goals in mind.
2020-10-29 20:11:16 +08:00
expect_ptr_not_null(allocs[i], "");
}
edata_cache: Allow unbounded fast caching. The edata_cache_small had a fill/flush heuristic. In retrospect, this was a premature optimization; more testing indicates that an unbounded cache is effectively fine here, and moreover we spend a nontrivial amount of time doing unnecessary filling/flushing. As the HPA takes on a larger and larger fraction of all allocations, any theoretical differences in allocation patterns should shrink. The HPA is more efficient with its metadata in general, so it still comes out ahead on metadata usage anyways.
2021-07-24 06:29:43 +08:00
expect_zu_eq(0, ecf_count(&ecf), "");
expect_zu_eq(EDATA_CACHE_FAST_FILL,
Edata cache small: rewrite. In previous designs, this was intended to be a sort of cache that couldn't fail. In the current design, we want to use it just as a contention reduction mechanism. Rewrite it with those goals in mind.
2020-10-29 20:11:16 +08:00
atomic_load_zu(&ec.count, ATOMIC_RELAXED), "");
edata_cache: Allow unbounded fast caching. The edata_cache_small had a fill/flush heuristic. In retrospect, this was a premature optimization; more testing indicates that an unbounded cache is effectively fine here, and moreover we spend a nontrivial amount of time doing unnecessary filling/flushing. As the HPA takes on a larger and larger fraction of all allocations, any theoretical differences in allocation patterns should shrink. The HPA is more efficient with its metadata in general, so it still comes out ahead on metadata usage anyways.
2021-07-24 06:29:43 +08:00
allocs[0] = edata_cache_fast_get(TSDN_NULL, &ecf);
expect_zu_eq(EDATA_CACHE_FAST_FILL - 1, ecf_count(&ecf), "");
Edata cache small: rewrite. In previous designs, this was intended to be a sort of cache that couldn't fail. In the current design, we want to use it just as a contention reduction mechanism. Rewrite it with those goals in mind.
2020-10-29 20:11:16 +08:00
expect_zu_eq(0, atomic_load_zu(&ec.count, ATOMIC_RELAXED), "");
edata_cache: Allow unbounded fast caching. The edata_cache_small had a fill/flush heuristic. In retrospect, this was a premature optimization; more testing indicates that an unbounded cache is effectively fine here, and moreover we spend a nontrivial amount of time doing unnecessary filling/flushing. As the HPA takes on a larger and larger fraction of all allocations, any theoretical differences in allocation patterns should shrink. The HPA is more efficient with its metadata in general, so it still comes out ahead on metadata usage anyways.
2021-07-24 06:29:43 +08:00
for (int i = 1; i < EDATA_CACHE_FAST_FILL; i++) {
expect_zu_eq(EDATA_CACHE_FAST_FILL - i, ecf_count(&ecf), "");
Edata cache small: rewrite. In previous designs, this was intended to be a sort of cache that couldn't fail. In the current design, we want to use it just as a contention reduction mechanism. Rewrite it with those goals in mind.
2020-10-29 20:11:16 +08:00
expect_zu_eq(0, atomic_load_zu(&ec.count, ATOMIC_RELAXED), "");
edata_cache: Allow unbounded fast caching. The edata_cache_small had a fill/flush heuristic. In retrospect, this was a premature optimization; more testing indicates that an unbounded cache is effectively fine here, and moreover we spend a nontrivial amount of time doing unnecessary filling/flushing. As the HPA takes on a larger and larger fraction of all allocations, any theoretical differences in allocation patterns should shrink. The HPA is more efficient with its metadata in general, so it still comes out ahead on metadata usage anyways.
2021-07-24 06:29:43 +08:00
allocs[i] = edata_cache_fast_get(TSDN_NULL, &ecf);
Edata cache small: rewrite. In previous designs, this was intended to be a sort of cache that couldn't fail. In the current design, we want to use it just as a contention reduction mechanism. Rewrite it with those goals in mind.
2020-10-29 20:11:16 +08:00
expect_ptr_not_null(allocs[i], "");
}
edata_cache: Allow unbounded fast caching. The edata_cache_small had a fill/flush heuristic. In retrospect, this was a premature optimization; more testing indicates that an unbounded cache is effectively fine here, and moreover we spend a nontrivial amount of time doing unnecessary filling/flushing. As the HPA takes on a larger and larger fraction of all allocations, any theoretical differences in allocation patterns should shrink. The HPA is more efficient with its metadata in general, so it still comes out ahead on metadata usage anyways.
2021-07-24 06:29:43 +08:00
expect_zu_eq(0, ecf_count(&ecf), "");
Edata cache small: rewrite. In previous designs, this was intended to be a sort of cache that couldn't fail. In the current design, we want to use it just as a contention reduction mechanism. Rewrite it with those goals in mind.
2020-10-29 20:11:16 +08:00
expect_zu_eq(0, atomic_load_zu(&ec.count, ATOMIC_RELAXED), "");
test_edata_cache_destroy(&ec);
}
TEST_END
TEST_BEGIN(test_edata_cache_disable) {
edata_cache_t ec;
edata_cache: Allow unbounded fast caching. The edata_cache_small had a fill/flush heuristic. In retrospect, this was a premature optimization; more testing indicates that an unbounded cache is effectively fine here, and moreover we spend a nontrivial amount of time doing unnecessary filling/flushing. As the HPA takes on a larger and larger fraction of all allocations, any theoretical differences in allocation patterns should shrink. The HPA is more efficient with its metadata in general, so it still comes out ahead on metadata usage anyways.
2021-07-24 06:29:43 +08:00
edata_cache_fast_t ecf;
Edata cache small: rewrite. In previous designs, this was intended to be a sort of cache that couldn't fail. In the current design, we want to use it just as a contention reduction mechanism. Rewrite it with those goals in mind.
2020-10-29 20:11:16 +08:00
test_edata_cache_init(&ec);
edata_cache: Allow unbounded fast caching. The edata_cache_small had a fill/flush heuristic. In retrospect, this was a premature optimization; more testing indicates that an unbounded cache is effectively fine here, and moreover we spend a nontrivial amount of time doing unnecessary filling/flushing. As the HPA takes on a larger and larger fraction of all allocations, any theoretical differences in allocation patterns should shrink. The HPA is more efficient with its metadata in general, so it still comes out ahead on metadata usage anyways.
2021-07-24 06:29:43 +08:00
edata_cache_fast_init(&ecf, &ec);
Edata cache small: rewrite. In previous designs, this was intended to be a sort of cache that couldn't fail. In the current design, we want to use it just as a contention reduction mechanism. Rewrite it with those goals in mind.
2020-10-29 20:11:16 +08:00
edata_cache: Allow unbounded fast caching. The edata_cache_small had a fill/flush heuristic. In retrospect, this was a premature optimization; more testing indicates that an unbounded cache is effectively fine here, and moreover we spend a nontrivial amount of time doing unnecessary filling/flushing. As the HPA takes on a larger and larger fraction of all allocations, any theoretical differences in allocation patterns should shrink. The HPA is more efficient with its metadata in general, so it still comes out ahead on metadata usage anyways.
2021-07-24 06:29:43 +08:00
for (int i = 0; i < EDATA_CACHE_FAST_FILL; i++) {
Edata cache small: rewrite. In previous designs, this was intended to be a sort of cache that couldn't fail. In the current design, we want to use it just as a contention reduction mechanism. Rewrite it with those goals in mind.
2020-10-29 20:11:16 +08:00
edata_t *edata = edata_cache_get(TSDN_NULL, &ec);
expect_ptr_not_null(edata, "");
edata_cache: Allow unbounded fast caching. The edata_cache_small had a fill/flush heuristic. In retrospect, this was a premature optimization; more testing indicates that an unbounded cache is effectively fine here, and moreover we spend a nontrivial amount of time doing unnecessary filling/flushing. As the HPA takes on a larger and larger fraction of all allocations, any theoretical differences in allocation patterns should shrink. The HPA is more efficient with its metadata in general, so it still comes out ahead on metadata usage anyways.
2021-07-24 06:29:43 +08:00
edata_cache_fast_put(TSDN_NULL, &ecf, edata);
Edata cache small: rewrite. In previous designs, this was intended to be a sort of cache that couldn't fail. In the current design, we want to use it just as a contention reduction mechanism. Rewrite it with those goals in mind.
2020-10-29 20:11:16 +08:00
}
edata_cache: Allow unbounded fast caching. The edata_cache_small had a fill/flush heuristic. In retrospect, this was a premature optimization; more testing indicates that an unbounded cache is effectively fine here, and moreover we spend a nontrivial amount of time doing unnecessary filling/flushing. As the HPA takes on a larger and larger fraction of all allocations, any theoretical differences in allocation patterns should shrink. The HPA is more efficient with its metadata in general, so it still comes out ahead on metadata usage anyways.
2021-07-24 06:29:43 +08:00
expect_zu_eq(EDATA_CACHE_FAST_FILL, ecf_count(&ecf), "");
Edata cache small: rewrite. In previous designs, this was intended to be a sort of cache that couldn't fail. In the current design, we want to use it just as a contention reduction mechanism. Rewrite it with those goals in mind.
2020-10-29 20:11:16 +08:00
expect_zu_eq(0, atomic_load_zu(&ec.count, ATOMIC_RELAXED), "");
edata_cache: Allow unbounded fast caching. The edata_cache_small had a fill/flush heuristic. In retrospect, this was a premature optimization; more testing indicates that an unbounded cache is effectively fine here, and moreover we spend a nontrivial amount of time doing unnecessary filling/flushing. As the HPA takes on a larger and larger fraction of all allocations, any theoretical differences in allocation patterns should shrink. The HPA is more efficient with its metadata in general, so it still comes out ahead on metadata usage anyways.
2021-07-24 06:29:43 +08:00
edata_cache_fast_disable(TSDN_NULL, &ecf);
Edata cache small: rewrite. In previous designs, this was intended to be a sort of cache that couldn't fail. In the current design, we want to use it just as a contention reduction mechanism. Rewrite it with those goals in mind.
2020-10-29 20:11:16 +08:00
edata_cache: Allow unbounded fast caching. The edata_cache_small had a fill/flush heuristic. In retrospect, this was a premature optimization; more testing indicates that an unbounded cache is effectively fine here, and moreover we spend a nontrivial amount of time doing unnecessary filling/flushing. As the HPA takes on a larger and larger fraction of all allocations, any theoretical differences in allocation patterns should shrink. The HPA is more efficient with its metadata in general, so it still comes out ahead on metadata usage anyways.
2021-07-24 06:29:43 +08:00
expect_zu_eq(0, ecf_count(&ecf), "");
expect_zu_eq(EDATA_CACHE_FAST_FILL,
Edata cache small: rewrite. In previous designs, this was intended to be a sort of cache that couldn't fail. In the current design, we want to use it just as a contention reduction mechanism. Rewrite it with those goals in mind.
2020-10-29 20:11:16 +08:00
atomic_load_zu(&ec.count, ATOMIC_RELAXED), "Disabling should flush");
edata_cache: Allow unbounded fast caching. The edata_cache_small had a fill/flush heuristic. In retrospect, this was a premature optimization; more testing indicates that an unbounded cache is effectively fine here, and moreover we spend a nontrivial amount of time doing unnecessary filling/flushing. As the HPA takes on a larger and larger fraction of all allocations, any theoretical differences in allocation patterns should shrink. The HPA is more efficient with its metadata in general, so it still comes out ahead on metadata usage anyways.
2021-07-24 06:29:43 +08:00
edata_t *edata = edata_cache_fast_get(TSDN_NULL, &ecf);
expect_zu_eq(0, ecf_count(&ecf), "");
expect_zu_eq(EDATA_CACHE_FAST_FILL - 1,
Edata cache small: rewrite. In previous designs, this was intended to be a sort of cache that couldn't fail. In the current design, we want to use it just as a contention reduction mechanism. Rewrite it with those goals in mind.
2020-10-29 20:11:16 +08:00
atomic_load_zu(&ec.count, ATOMIC_RELAXED),
edata_cache: Allow unbounded fast caching. The edata_cache_small had a fill/flush heuristic. In retrospect, this was a premature optimization; more testing indicates that an unbounded cache is effectively fine here, and moreover we spend a nontrivial amount of time doing unnecessary filling/flushing. As the HPA takes on a larger and larger fraction of all allocations, any theoretical differences in allocation patterns should shrink. The HPA is more efficient with its metadata in general, so it still comes out ahead on metadata usage anyways.
2021-07-24 06:29:43 +08:00
"Disabled ecf should forward on get");
Edata cache small: rewrite. In previous designs, this was intended to be a sort of cache that couldn't fail. In the current design, we want to use it just as a contention reduction mechanism. Rewrite it with those goals in mind.
2020-10-29 20:11:16 +08:00
edata_cache: Allow unbounded fast caching. The edata_cache_small had a fill/flush heuristic. In retrospect, this was a premature optimization; more testing indicates that an unbounded cache is effectively fine here, and moreover we spend a nontrivial amount of time doing unnecessary filling/flushing. As the HPA takes on a larger and larger fraction of all allocations, any theoretical differences in allocation patterns should shrink. The HPA is more efficient with its metadata in general, so it still comes out ahead on metadata usage anyways.
2021-07-24 06:29:43 +08:00
edata_cache_fast_put(TSDN_NULL, &ecf, edata);
expect_zu_eq(0, ecf_count(&ecf), "");
expect_zu_eq(EDATA_CACHE_FAST_FILL,
Edata cache small: rewrite. In previous designs, this was intended to be a sort of cache that couldn't fail. In the current design, we want to use it just as a contention reduction mechanism. Rewrite it with those goals in mind.
2020-10-29 20:11:16 +08:00
atomic_load_zu(&ec.count, ATOMIC_RELAXED),
edata_cache: Allow unbounded fast caching. The edata_cache_small had a fill/flush heuristic. In retrospect, this was a premature optimization; more testing indicates that an unbounded cache is effectively fine here, and moreover we spend a nontrivial amount of time doing unnecessary filling/flushing. As the HPA takes on a larger and larger fraction of all allocations, any theoretical differences in allocation patterns should shrink. The HPA is more efficient with its metadata in general, so it still comes out ahead on metadata usage anyways.
2021-07-24 06:29:43 +08:00
"Disabled ecf should forward on put");
Edata cache: add edata_cache_small_t. This can be used to amortize the synchronization costs of edata_cache accesses.
2020-02-19 09:21:40 +08:00
test_edata_cache_destroy(&ec);
Edata cache: add a unit test.
2020-02-19 08:09:10 +08:00
}
TEST_END
int
main(void) {
return test(
Edata cache: add edata_cache_small_t. This can be used to amortize the synchronization costs of edata_cache accesses.
2020-02-19 09:21:40 +08:00
test_edata_cache,
edata_cache: Allow unbounded fast caching. The edata_cache_small had a fill/flush heuristic. In retrospect, this was a premature optimization; more testing indicates that an unbounded cache is effectively fine here, and moreover we spend a nontrivial amount of time doing unnecessary filling/flushing. As the HPA takes on a larger and larger fraction of all allocations, any theoretical differences in allocation patterns should shrink. The HPA is more efficient with its metadata in general, so it still comes out ahead on metadata usage anyways.
2021-07-24 06:29:43 +08:00
test_edata_cache_fast_simple,
Edata cache small: rewrite. In previous designs, this was intended to be a sort of cache that couldn't fail. In the current design, we want to use it just as a contention reduction mechanism. Rewrite it with those goals in mind.
2020-10-29 20:11:16 +08:00
test_edata_cache_fill,
test_edata_cache_disable);
Edata cache: add a unit test.
2020-02-19 08:09:10 +08:00
}
Reference in New Issue Copy Permalink