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

20
src/ArduinoJson/Data/ArrayFunctions.hpp
View File

@ -42,8 +42,7 @@ inline JsonVariantData* arrayGet(const JsonArrayData* arr, size_t index) {
return slot ? &slot->value : 0;
}
inline void arrayRemove(JsonArrayData* arr, VariantSlot* slot,
MemoryPool* pool) {
inline void arrayRemove(JsonArrayData* arr, VariantSlot* slot) {
if (!arr || !slot) return;
if (slot->prev)
@ -54,12 +53,10 @@ inline void arrayRemove(JsonArrayData* arr, VariantSlot* slot,
slot->next->prev = slot->prev;
else
arr->tail = slot->prev;
slotFree(slot, pool);
}
inline void arrayRemove(JsonArrayData* arr, size_t index, MemoryPool* pool) {
arrayRemove(arr, arrayGetSlot(arr, index), pool);
inline void arrayRemove(JsonArrayData* arr, size_t index) {
arrayRemove(arr, arrayGetSlot(arr, index));
}
inline void arrayClear(JsonArrayData* arr) {
@ -100,15 +97,4 @@ inline size_t arraySize(const JsonArrayData* arr) {
if (!arr) return 0;
return slotSize(arr->head);
}
inline void arrayFree(JsonArrayData* arr, MemoryPool* pool) {
ARDUINOJSON_ASSERT(arr);
VariantSlot* cur = arr->head;
while (cur) {
VariantSlot* next = cur->next;
slotFree(cur, pool);
cur = next;
}
}
} // namespace ARDUINOJSON_NAMESPACE

5
src/ArduinoJson/Data/ObjectFunctions.hpp
View File

@ -76,8 +76,7 @@ inline void objectClear(JsonObjectData* obj) {
obj->tail = 0;
}
inline void objectRemove(JsonObjectData* obj, VariantSlot* slot,
MemoryPool* pool) {
inline void objectRemove(JsonObjectData* obj, VariantSlot* slot) {
if (!obj) return;
if (!slot) return;
if (slot->prev)
@ -88,8 +87,6 @@ inline void objectRemove(JsonObjectData* obj, VariantSlot* slot,
slot->next->prev = slot->prev;
else
obj->tail = slot->prev;
slotFree(slot, pool);
}
inline size_t objectSize(const JsonObjectData* obj) {

13
src/ArduinoJson/Data/SlotFunctions.hpp
View File

@ -61,17 +61,4 @@ inline size_t slotSize(const VariantSlot* var) {
}
return n;
}
void variantFree(JsonVariantData* var, MemoryPool* pool);
inline void slotFree(VariantSlot* var, MemoryPool* pool) {
ARDUINOJSON_ASSERT(var != 0);
ARDUINOJSON_ASSERT(pool != 0);
variantFree(&var->value, pool);
if (var->value.keyIsOwned) pool->freeString(var->ownedKey);
pool->freeVariant(var);
}
} // namespace ARDUINOJSON_NAMESPACE

66
src/ArduinoJson/Data/VariantFunctions.hpp
View File

@ -12,25 +12,6 @@
#include "ObjectFunctions.hpp"
namespace ARDUINOJSON_NAMESPACE {
inline void variantFree(JsonVariantData* var, MemoryPool* pool) {
ARDUINOJSON_ASSERT(var != 0);
ARDUINOJSON_ASSERT(pool != 0);
switch (var->type) {
case JSON_ARRAY:
case JSON_OBJECT:
arrayFree(&var->content.asArray, pool);
break;
case JSON_OWNED_STRING:
case JSON_OWNED_RAW:
pool->freeString(var->content.asOwnedString);
break;
default:
break;
}
}
template <typename T>
inline T variantAsIntegral(const JsonVariantData* var) {
if (!var) return 0;
@ -116,30 +97,23 @@ inline const JsonObjectData* variantAsObject(const JsonVariantData* var) {
return 0;
}
inline bool variantSetBoolean(JsonVariantData* var, bool value,
MemoryPool* pool) {
inline bool variantSetBoolean(JsonVariantData* var, bool value) {
if (!var) return false;
variantFree(var, pool);
var->type = JSON_BOOLEAN;
var->content.asInteger = static_cast<JsonUInt>(value);
return true;
}
inline bool variantSetFloat(JsonVariantData* var, JsonFloat value,
MemoryPool* pool) {
inline bool variantSetFloat(JsonVariantData* var, JsonFloat value) {
if (!var) return false;
variantFree(var, pool);
var->type = JSON_FLOAT;
var->content.asFloat = value;
return true;
}
template <typename T>
inline bool variantSetSignedInteger(JsonVariantData* var, T value,
MemoryPool* pool) {
inline bool variantSetSignedInteger(JsonVariantData* var, T value) {
if (!var) return false;
variantFree(var, pool);
if (value >= 0) {
var->type = JSON_POSITIVE_INTEGER;
var->content.asInteger = static_cast<JsonUInt>(value);
@ -150,20 +124,16 @@ inline bool variantSetSignedInteger(JsonVariantData* var, T value,
return true;
}
inline bool variantSetUnsignedInteger(JsonVariantData* var, JsonUInt value,
MemoryPool* pool) {
inline bool variantSetUnsignedInteger(JsonVariantData* var, JsonUInt value) {
if (!var) return false;
variantFree(var, pool);
var->type = JSON_POSITIVE_INTEGER;
var->content.asInteger = static_cast<JsonUInt>(value);
return true;
}
inline bool variantSetLinkedRaw(JsonVariantData* var,
SerializedValue<const char*> value,
MemoryPool* pool) {
SerializedValue<const char*> value) {
if (!var) return false;
variantFree(var, pool);
var->type = JSON_LINKED_RAW;
var->content.asRaw.data = value.data();
var->content.asRaw.size = value.size();
@ -174,7 +144,6 @@ template <typename T>
inline bool variantSetOwnedRaw(JsonVariantData* var, SerializedValue<T> value,
MemoryPool* pool) {
if (!var) return false;
variantFree(var, pool);
StringSlot* slot = makeString(value.data(), value.size()).save(pool);
if (slot) {
var->type = JSON_OWNED_RAW;
@ -189,7 +158,6 @@ inline bool variantSetOwnedRaw(JsonVariantData* var, SerializedValue<T> value,
template <typename T>
inline bool variantSetString(JsonVariantData* var, T value, MemoryPool* pool) {
if (!var) return false;
variantFree(var, pool);
StringSlot* slot = value.save(pool);
if (slot) {
var->type = JSON_OWNED_STRING;
@ -201,42 +169,35 @@ inline bool variantSetString(JsonVariantData* var, T value, MemoryPool* pool) {
}
}
inline bool variantSetOwnedString(JsonVariantData* var, StringSlot* slot,
MemoryPool* pool) {
inline bool variantSetOwnedString(JsonVariantData* var, StringSlot* slot) {
if (!var) return false;
variantFree(var, pool);
var->type = JSON_OWNED_STRING;
var->content.asOwnedString = slot;
return true;
}
inline bool variantSetString(JsonVariantData* var, const char* value,
MemoryPool* pool) {
inline bool variantSetString(JsonVariantData* var, const char* value) {
if (!var) return false;
variantFree(var, pool);
var->type = JSON_LINKED_STRING;
var->content.asString = value;
return true;
}
inline void variantSetNull(JsonVariantData* var, MemoryPool* pool) {
inline void variantSetNull(JsonVariantData* var) {
if (!var) return;
variantFree(var, pool);
var->type = JSON_NULL;
}
inline JsonArrayData* variantToArray(JsonVariantData* var, MemoryPool* pool) {
inline JsonArrayData* variantToArray(JsonVariantData* var) {
if (!var) return 0;
variantFree(var, pool);
var->type = JSON_ARRAY;
var->content.asArray.head = 0;
var->content.asArray.tail = 0;
return &var->content.asArray;
}
inline JsonObjectData* variantToObject(JsonVariantData* var, MemoryPool* pool) {
inline JsonObjectData* variantToObject(JsonVariantData* var) {
if (!var) return 0;
variantFree(var, pool);
var->type = JSON_OBJECT;
var->content.asObject.head = 0;
var->content.asObject.tail = 0;
@ -247,16 +208,14 @@ inline bool variantCopy(JsonVariantData* dst, const JsonVariantData* src,
MemoryPool* pool) {
if (!dst) return false;
if (!src) {
variantFree(dst, pool);
dst->type = JSON_NULL;
return true;
}
switch (src->type) {
case JSON_ARRAY:
return arrayCopy(variantToArray(dst, pool), &src->content.asArray, pool);
return arrayCopy(variantToArray(dst), &src->content.asArray, pool);
case JSON_OBJECT:
return objectCopy(variantToObject(dst, pool), &src->content.asObject,
pool);
return objectCopy(variantToObject(dst), &src->content.asObject, pool);
case JSON_OWNED_STRING:
return variantSetString(
dst, makeString(src->content.asOwnedString->value), pool);
@ -266,7 +225,6 @@ inline bool variantCopy(JsonVariantData* dst, const JsonVariantData* src,
src->content.asOwnedRaw->size),
pool);
default:
variantFree(dst, pool);
// caution: don't override keyIsOwned
dst->type = src->type;
dst->content = src->content;

4
src/ArduinoJson/JsonArray.hpp
View File

@ -197,12 +197,12 @@ class JsonArray : public JsonArrayProxy<JsonArrayData>, public Visitable {
// Removes element at specified position.
FORCE_INLINE void remove(iterator it) const {
arrayRemove(_data, it.internal(), _memoryPool);
arrayRemove(_data, it.internal());
}
// Removes element at specified index.
FORCE_INLINE void remove(size_t index) const {
arrayRemove(_data, index, _memoryPool);
arrayRemove(_data, index);
}
template <typename Visitor>

4
src/ArduinoJson/JsonObject.hpp
View File

@ -227,7 +227,7 @@ class JsonObject : public JsonObjectProxy<JsonObjectData>, public Visitable {
}
FORCE_INLINE void remove(iterator it) const {
objectRemove(_data, it.internal(), _memoryPool);
objectRemove(_data, it.internal());
}
// Removes the specified key and the associated value.
@ -282,7 +282,7 @@ class JsonObject : public JsonObjectProxy<JsonObjectData>, public Visitable {
template <typename TStringRef>
FORCE_INLINE void remove_impl(TStringRef key) const {
objectRemove(_data, objectFindSlot(_data, key), _memoryPool);
objectRemove(_data, objectFindSlot(_data, key));
}
MemoryPool* _memoryPool;

17
src/ArduinoJson/JsonVariant.hpp
View File

@ -133,7 +133,7 @@ class JsonVariant : public JsonVariantProxy<JsonVariantData>,
// set(bool value)
FORCE_INLINE bool set(bool value) const {
return variantSetBoolean(_data, value, _memoryPool);
return variantSetBoolean(_data, value);
}
// set(double value);
@ -142,7 +142,7 @@ class JsonVariant : public JsonVariantProxy<JsonVariantData>,
FORCE_INLINE bool set(
T value,
typename enable_if<is_floating_point<T>::value>::type * = 0) const {
return variantSetFloat(_data, static_cast<JsonFloat>(value), _memoryPool);
return variantSetFloat(_data, static_cast<JsonFloat>(value));
}
// set(char)
@ -155,7 +155,7 @@ class JsonVariant : public JsonVariantProxy<JsonVariantData>,
T value,
typename enable_if<is_integral<T>::value && is_signed<T>::value>::type * =
0) const {
return variantSetSignedInteger(_data, value, _memoryPool);
return variantSetSignedInteger(_data, value);
}
// set(unsigned short)
@ -165,13 +165,12 @@ class JsonVariant : public JsonVariantProxy<JsonVariantData>,
FORCE_INLINE bool set(
T value, typename enable_if<is_integral<T>::value &&
is_unsigned<T>::value>::type * = 0) const {
return variantSetUnsignedInteger(_data, static_cast<JsonUInt>(value),
_memoryPool);
return variantSetUnsignedInteger(_data, static_cast<JsonUInt>(value));
}
// set(SerializedValue<const char *>)
FORCE_INLINE bool set(SerializedValue<const char *> value) const {
return variantSetLinkedRaw(_data, value, _memoryPool);
return variantSetLinkedRaw(_data, value);
}
// set(SerializedValue<std::string>)
@ -202,15 +201,15 @@ class JsonVariant : public JsonVariantProxy<JsonVariantData>,
// set(const char*);
FORCE_INLINE bool set(const char *value) const {
return variantSetString(_data, value, _memoryPool);
return variantSetString(_data, value);
}
// for internal use only
FORCE_INLINE bool set(StringInMemoryPool value) const {
return variantSetOwnedString(_data, value.slot(), _memoryPool);
return variantSetOwnedString(_data, value.slot());
}
FORCE_INLINE bool set(ZeroTerminatedRamStringConst value) const {
return variantSetString(_data, value.c_str(), _memoryPool);
return variantSetString(_data, value.c_str());
}
bool set(JsonVariantConst value) const;

6
src/ArduinoJson/JsonVariantImpl.hpp
View File

@ -53,19 +53,19 @@ JsonVariant::as() const {
template <typename T>
inline typename enable_if<is_same<T, JsonArray>::value, JsonArray>::type
JsonVariant::to() const {
return JsonArray(_memoryPool, variantToArray(_data, _memoryPool));
return JsonArray(_memoryPool, variantToArray(_data));
}
template <typename T>
typename enable_if<is_same<T, JsonObject>::value, JsonObject>::type
JsonVariant::to() const {
return JsonObject(_memoryPool, variantToObject(_data, _memoryPool));
return JsonObject(_memoryPool, variantToObject(_data));
}
template <typename T>
typename enable_if<is_same<T, JsonVariant>::value, JsonVariant>::type
JsonVariant::to() const {
variantSetNull(_data, _memoryPool);
variantSetNull(_data);
return *this;
}

66
src/ArduinoJson/Memory/MemoryPool.hpp
View File

@ -9,7 +9,6 @@
#include "../Strings/StringInMemoryPool.hpp"
#include "Alignment.hpp"
#include "MemoryPool.hpp"
#include "SlotList.hpp"
#include "StringSlot.hpp"
#include "VariantSlot.hpp"
@ -60,24 +59,11 @@ class MemoryPool {
}
size_t size() const {
return allocated_bytes() - _freeVariants.size() - _freeStrings.size();
return size_t(_left - _begin + _end - _right);
}
VariantSlot* allocVariant() {
VariantSlot* s = _freeVariants.pop();
if (s) return s;
return s ? s : allocRight<VariantSlot>();
}
void freeVariant(VariantSlot* slot) {
freeVariantSlot(slot);
compactRightSide();
}
void freeString(StringSlot* slot) {
freeStringSlot(slot);
compactLeftSide(slot->value, slot->size);
compactRightSide();
return allocRight<VariantSlot>();
}
StringSlot* allocFrozenString(size_t n) {
@ -88,7 +74,6 @@ class MemoryPool {
s->value = _left;
s->size = n;
_left += n;
_usedString.push(s);
checkInvariants();
return s;
@ -100,7 +85,6 @@ class MemoryPool {
s->value = _left;
s->size = size_t(_right - _left);
_usedString.push(s);
_left = _right;
checkInvariants();
@ -116,9 +100,6 @@ class MemoryPool {
void clear() {
_left = _begin;
_right = _end;
_freeVariants.clear();
_freeStrings.clear();
_usedString.clear();
}
bool canAlloc(size_t bytes) const {
@ -146,50 +127,10 @@ class MemoryPool {
}
private:
size_t allocated_bytes() const {
return size_t(_left - _begin + _end - _right);
}
StringSlot* allocStringSlot() {
StringSlot* s = _freeStrings.pop();
if (s) return s;
return allocRight<StringSlot>();
}
void freeVariantSlot(VariantSlot* slot) {
_freeVariants.push(slot);
}
void freeStringSlot(StringSlot* slot) {
_usedString.remove(slot);
_freeStrings.push(slot);
}
void compactLeftSide(char* holeAddress, size_t holeSize) {
ARDUINOJSON_ASSERT(holeAddress >= _begin);
ARDUINOJSON_ASSERT(holeAddress + holeSize <= _left);
char* holeEnd = holeAddress + holeSize;
memmove(holeAddress, // where the hole begun
holeEnd, // where the hole ended
size_t(_left - holeEnd)); // everything after the hole
_left -= holeSize;
_usedString.forEach(UpdateStringSlotAddress(holeAddress, holeSize));
checkInvariants();
}
void compactRightSide() {
loop:
if (_freeStrings.remove(_right)) {
_right += sizeof(StringSlot);
goto loop;
}
if (_freeVariants.remove(_right)) {
_right += sizeof(VariantSlot);
goto loop;
}
checkInvariants();
}
void checkInvariants() {
ARDUINOJSON_ASSERT(_begin <= _left);
ARDUINOJSON_ASSERT(_left <= _right);
@ -198,9 +139,6 @@ class MemoryPool {
}
char *_begin, *_left, *_right, *_end;
SlotList<VariantSlot> _freeVariants;
SlotList<StringSlot> _freeStrings;
SlotList<StringSlot> _usedString;
};
} // namespace ARDUINOJSON_NAMESPACE

67
src/ArduinoJson/Memory/SlotList.hpp
View File

@ -1,67 +0,0 @@
// ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2018
// MIT License
#pragma once
#include <stddef.h> // for size_t
namespace ARDUINOJSON_NAMESPACE {
template <typename TSlot>
class SlotList {
public:
SlotList() : _head(0) {}
TSlot *pop() {
TSlot *slot = _head;
if (slot) _head = slot->next;
return slot;
}
void push(TSlot *slot) {
slot->next = _head;
_head = slot;
}
bool remove(const TSlot *slot) {
if (_head == slot) {
_head = slot->next;
return true;
}
for (TSlot *s = _head; s; s = s->next) {
if (s->next == slot) {
s->next = slot->next;
return true;
}
}
return false;
}
bool remove(const void *slot) {
return remove(reinterpret_cast<const TSlot *>(slot));
}
template <typename Functor>
void forEach(const Functor &f) {
for (TSlot *s = _head; s; s = s->next) {
f(s);
}
}
size_t size() const {
size_t sum = 0;
for (TSlot *s = _head; s; s = s->next) sum += sizeof(TSlot);
return sum;
}
void clear() {
_head = 0;
}
private:
TSlot *_head;
};
} // namespace ARDUINOJSON_NAMESPACE