feedc0de/ArduinoJson
1
0
Fork 0
forked from bblanchon/ArduinoJson
Code Pull Requests Activity

Restored the monotonic allocator

Browse Source
This commit is contained in:
Benoit Blanchon
2018-11-30 14:27:33 +01:00
parent 637f7a5bfa
commit 45f4e5ac20
23 changed files with 35 additions and 609 deletions
Download Patch File Download Diff File Expand all files Collapse all files

66
test/MemoryPool/allocString.cpp
View File

@ -60,15 +60,6 @@ TEST_CASE("MemoryPool::allocFrozenString()") {
REQUIRE(a->value == b->value);
}
SECTION("Returns same address after freeString()") {
StringSlot *a = pool.allocFrozenString(1);
pool.freeString(a);
StringSlot *b = pool.allocFrozenString(1);
REQUIRE(a == b);
REQUIRE(a->value == b->value);
}
SECTION("Can use full capacity when fresh") {
StringSlot *a = pool.allocFrozenString(longestString);
@ -84,60 +75,3 @@ TEST_CASE("MemoryPool::allocFrozenString()") {
REQUIRE(a != 0);
}
}
TEST_CASE("MemoryPool::freeString()") {
const size_t poolCapacity = 512;
const size_t longestString = poolCapacity - sizeof(StringSlot);
char buffer[poolCapacity];
MemoryPool pool(buffer, poolCapacity);
static const size_t testStringSize =
(poolCapacity - sizeof(StringSlot) * 4 - sizeof(VariantSlot) * 4) / 4;
SECTION("Restores full capacity") {
StringSlot *strings[4];
VariantSlot *variants[4];
for (int i = 0; i < 4; i++) {
strings[i] = pool.allocFrozenString(testStringSize);
REQUIRE(strings[i] != 0);
variants[i] = pool.allocVariant();
REQUIRE(variants[i] != 0);
}
// In random order
pool.freeString(strings[2]);
pool.freeVariant(variants[3]);
pool.freeVariant(variants[0]);
pool.freeString(strings[0]);
pool.freeVariant(variants[1]);
pool.freeString(strings[1]);
pool.freeVariant(variants[2]);
pool.freeString(strings[3]);
StringSlot *b = pool.allocFrozenString(longestString);
REQUIRE(b != 0);
REQUIRE(b->size == longestString);
}
SECTION("Move strings") {
StringSlot *a = pool.allocFrozenString(6);
strcpy(a->value, "hello");
StringSlot *b = pool.allocFrozenString(7);
strcpy(b->value, "world!");
pool.freeString(a);
REQUIRE(b->size == 7);
REQUIRE(b->value == std::string("world!"));
REQUIRE(a->value == b->value);
}
SECTION("Accepts non-frozen string") {
StringSlot *a = pool.allocExpandableString();
pool.freeString(a);
REQUIRE(pool.size() == 0);
}
}

10
test/MemoryPool/allocVariant.cpp
View File

@ -21,16 +21,6 @@ TEST_CASE("MemoryPool::allocVariant()") {
REQUIRE(s1 != s2);
}
SECTION("Returns same pointer after freeSlot()") {
MemoryPool pool(buffer, sizeof(buffer));
VariantSlot* s1 = pool.allocVariant();
pool.freeVariant(s1);
VariantSlot* s2 = pool.allocVariant();
REQUIRE(s1 == s2);
}
SECTION("Returns aligned pointers") {
MemoryPool pool(buffer, sizeof(buffer));

52
test/MemoryPool/clear.cpp
View File

@ -28,56 +28,4 @@ TEST_CASE("MemoryPool::clear()") {
REQUIRE(memoryPool.size() == 0);
}
SECTION("Purges variant cache") {
VariantSlot* a = memoryPool.allocVariant();
REQUIRE(a != 0);
VariantSlot* b = memoryPool.allocVariant();
REQUIRE(b != 0);
// place slot a in the pool of free slots
memoryPool.freeVariant(a);
memoryPool.clear();
REQUIRE(memoryPool.size() == 0);
}
SECTION("Purges string cache") {
StringSlot* a = memoryPool.allocFrozenString(10);
REQUIRE(a != 0);
StringSlot* b = memoryPool.allocFrozenString(10);
REQUIRE(b != 0);
// place slot a in the pool of free slots
memoryPool.freeString(a);
memoryPool.clear();
REQUIRE(memoryPool.size() == 0);
}
SECTION("Purges list of string") {
StringSlot* a = memoryPool.allocFrozenString(6);
REQUIRE(a != 0);
strcpy(a->value, "hello");
StringSlot* b = memoryPool.allocFrozenString(6);
REQUIRE(b != 0);
strcpy(b->value, "world");
memoryPool.clear(); // ACT!
StringSlot* c = memoryPool.allocFrozenString(2);
REQUIRE(c != 0);
strcpy(c->value, "H");
StringSlot* d = memoryPool.allocFrozenString(2);
REQUIRE(d != 0);
strcpy(d->value, "W");
// if the memory pool keeps pointer to the old strings
// it will try to compact the strings
memoryPool.freeString(c);
REQUIRE(d->value == std::string("W"));
}
}

35
test/MemoryPool/size.cpp
View File

@ -45,41 +45,6 @@ TEST_CASE("MemoryPool::size()") {
REQUIRE(memoryPool.size() == 2 * JSON_STRING_SIZE(0));
}
SECTION("Decreases after freeVariant()") {
VariantSlot* a = memoryPool.allocVariant();
VariantSlot* b = memoryPool.allocVariant();
memoryPool.freeVariant(b);
REQUIRE(memoryPool.size() == sizeof(VariantSlot));
memoryPool.freeVariant(a);
REQUIRE(memoryPool.size() == 0);
}
SECTION("Decreases after calling freeString() in order") {
StringSlot* a = memoryPool.allocFrozenString(5);
REQUIRE(a != 0);
StringSlot* b = memoryPool.allocFrozenString(6);
REQUIRE(b != 0);
memoryPool.freeString(b);
REQUIRE(memoryPool.size() == JSON_STRING_SIZE(5));
memoryPool.freeString(a);
REQUIRE(memoryPool.size() == 0);
}
SECTION("Decreases after calling freeString() in reverse order") {
StringSlot* a = memoryPool.allocFrozenString(5);
REQUIRE(a != 0);
StringSlot* b = memoryPool.allocFrozenString(6);
REQUIRE(b != 0);
memoryPool.freeString(a);
REQUIRE(memoryPool.size() == JSON_STRING_SIZE(6));
memoryPool.freeString(b);
REQUIRE(memoryPool.size() == 0);
}
SECTION("Doesn't grow when memory pool is full") {
const size_t variantCount = sizeof(buffer) / sizeof(VariantSlot);