GitHub/gf-core
1
0
Fork 1
mirror of https://github.com/GrammaticalFramework/gf-core.git synced 2026-05-03 16:22:52 -06:00
Code Issues Packages Projects Releases Wiki Activity

first draft of the new allocator with transactions support

Browse Source
This commit is contained in:
Krasimir Angelov
2022-05-20 13:55:45 +02:00
parent 546dc01b5d
commit 5594679a83
24 changed files with 1582 additions and 2372 deletions
Download Patch File Download Diff File Expand all files Collapse all files

504
src/runtime/c/pgf/namespace.h
View File

@@ -5,15 +5,8 @@
// #define DEBUG_NAMESPACE
/* Namespace<V> expects that the class V contains:
*
* - A member 'size_t ref_count' which keeps track of the number of
* references to the particular object.
* - A member 'PgfText name' which contains the name of the object.
* - A method:
* static void release(ref<V> object)
* which is executed when ref_count becomes zero. After that the memory
* for the object is released as well.
/* Namespace<V> expects that the class V contains,
* a member 'PgfText name' which contains the name of the object.
*/
template <class V>
@@ -26,7 +19,7 @@ template <class V>
class PGF_INTERNAL_DECL Node
{
public:
size_t ref_count;
txn_t txn_id;
size_t sz;
V value;
@@ -36,12 +29,12 @@ public:
static
ref<Node> new_node(V value)
{
ref<Node> node = current_db->malloc<Node>();
node->ref_count = 1;
node->sz = 1;
node->value = value;
node->left = 0;
node->right = 0;
ref<Node> node = PgfDB::malloc<Node>();
node->txn_id = PgfDB::get_txn_id();
node->sz = 1;
node->value = value;
node->left = 0;
node->right = 0;
#ifdef DEBUG_NAMESPACE
printf("new node %6ld %s\n", node.as_object(), node->value->name.text);
@@ -50,310 +43,200 @@ public:
}
static
ref<Node> new_node(V value, ref<Node> left, ref<Node> right)
ref<Node> upd_node(ref<Node> node, ref<Node> left, ref<Node> right)
{
ref<Node> node = current_db->malloc<Node>();
node->ref_count = 1;
node->sz = 1+Node::size(left)+Node::size(right);
node->value = value;
node->left = left;
node->right = right;
if (node->txn_id != PgfDB::get_txn_id()) {
ref<Node> new_node = PgfDB::malloc<Node>();
new_node->txn_id = PgfDB::get_txn_id();
new_node->value = node->value;
release(node);
node = new_node;
#ifdef DEBUG_NAMESPACE
printf("new node %6ld %s(%ld,%ld)\n", node.as_object(), node->value->name.text, left.as_object(), right.as_object());
printf("new node %6ld %s(%ld,%ld)\n", node.as_object(), node->value->name.text, left.as_object(), right.as_object());
#endif
}
node->sz = 1+Node::size(left)+Node::size(right);
node->left = left;
node->right = right;
return node;
}
static
void add_node_ref(ref<Node> node)
ref<Node> balanceL(ref<Node> node)
{
node->ref_count++;
#ifdef DEBUG_NAMESPACE
printf("add_ref node %6ld %s (ref_count=%ld)\n", node.as_object(), node->value->name.text, node->ref_count);
#endif
}
template <class A> static
void add_value_ref(A &value)
{
value.add_ref();
#ifdef DEBUG_NAMESPACE
printf("add_ref value %5ld %s (ref_count=%ld)\n", value.as_object(), value->name.text, value->ref_count);
#endif
}
template <class A> static
void add_value_ref(ref<A> value)
{
value->ref_count++;
#ifdef DEBUG_NAMESPACE
printf("add_ref value %5ld %s (ref_count=%ld)\n", value.as_object(), value->name.text, value->ref_count);
#endif
}
template <class A> static
void release_value_ref(A &value)
{
#ifdef DEBUG_NAMESPACE
printf("release value %5ld %s (ref_count=%ld)\n", value.as_object(), value->name.text, value->ref_count-1);
#endif
value.release_ref();
}
template <class A> static
void release_value_ref(ref<A> value)
{
#ifdef DEBUG_NAMESPACE
printf("release value %5ld %s (ref_count=%ld)\n", value.as_object(), value->name.text, value->ref_count-1);
#endif
if (!(--value->ref_count)) {
A::release(value);
}
}
static
ref<Node> balanceL(V value, ref<Node> left, ref<Node> right)
{
if (right == 0) {
if (left == 0) {
add_value_ref(value);
return new_node(value);
if (node->right == 0) {
if (node->left == 0) {
return node;
} else {
if (left->left == 0) {
if (left->right == 0) {
add_value_ref(value);
add_node_ref(left);
return new_node(value,left,0);
if (node->left->left == 0) {
if (node->left->right == 0) {
return node;
} else {
add_value_ref(value);
add_value_ref(left->value);
add_value_ref(left->right->value);
ref<Node<V>> new_left = new_node(left->value);
ref<Node<V>> new_right = new_node(value);
return new_node(left->right->value,
new_left,
new_right);
ref<Node<V>> left_right = node->left->right;
ref<Node<V>> left = upd_node(node->left,0,0);
ref<Node<V>> right = upd_node(node,0,0);
return upd_node(left_right,
left,
right);
}
} else {
if (left->right == 0) {
add_value_ref(value);
ref<Node<V>> new_right = new_node(value);
add_value_ref(left->value);
add_node_ref(left->left);
return new_node(left->value,
if (node->left->right == 0) {
ref<Node<V>> left = node->left;
ref<Node<V>> right = upd_node(node,0,0);
return upd_node(left,
left->left,
new_right);
right);
} else {
if (left->right->sz < 2 * left->left->sz) {
add_value_ref(value);
add_value_ref(left->value);
add_node_ref(left->left);
add_node_ref(left->right);
ref<Node<V>> new_right =
new_node(value,
if (node->left->right->sz < 2 * node->left->left->sz) {
ref<Node<V>> left = node->left;
ref<Node<V>> right =
upd_node(node,
left->right,
0);
return new_node(left->value,
return upd_node(left,
left->left,
new_right);
right);
} else {
add_value_ref(value);
add_value_ref(left->value);
add_value_ref(left->right->value);
add_node_ref(left->left);
if (left->right->left != 0)
add_node_ref(left->right->left);
if (left->right->right != 0)
add_node_ref(left->right->right);
ref<Node<V>> new_left =
new_node(left->value,
left->left,
left->right->left);
ref<Node<V>> new_right =
new_node(value,
left->right->right,
ref<Node<V>> left_right = node->left->right;
ref<Node<V>> left =
upd_node(node->left,
node->left->left,
left_right->left);
ref<Node<V>> right =
upd_node(node,
left_right->right,
0);
return new_node(left->right->value,
new_left,
new_right);
return upd_node(left_right,
left,
right);
}
}
}
}
} else {
if (left == 0) {
add_value_ref(value);
add_node_ref(right);
return new_node(value,0,right);
if (node->left == 0) {
return node;
} else {
if (left->sz > 3*right->sz) {
if (left->right->sz < 2*left->left->sz) {
add_value_ref(value);
add_value_ref(left->value);
add_node_ref(left->left);
add_node_ref(left->right);
add_node_ref(right);
ref<Node<V>> new_right =
new_node(value,
if (node->left->sz > 3*node->right->sz) {
if (node->left->right->sz < 2*node->left->left->sz) {
ref<Node<V>> left = node->left;
ref<Node<V>> right =
upd_node(node,
left->right,
right);
return new_node(left->value,
node->right);
return upd_node(left,
left->left,
new_right);
right);
} else {
add_value_ref(value);
add_value_ref(left->value);
add_value_ref(left->right->value);
add_node_ref(left->left);
if (left->right->left != 0)
add_node_ref(left->right->left);
if (left->right->right != 0)
add_node_ref(left->right->right);
add_node_ref(right);
ref<Node<V>> new_left =
new_node(left->value,
left->left,
left->right->left);
ref<Node<V>> new_right =
new_node(value,
left->right->right,
right);
return new_node(left->right->value,
new_left,
new_right);
ref<Node<V>> left_right = node->left->right;
ref<Node<V>> left =
upd_node(node->left,
node->left->left,
left_right->left);
ref<Node<V>> right =
upd_node(node,
left_right->right,
node->right);
return upd_node(left_right,
left,
right);
}
} else {
add_value_ref(value);
add_node_ref(left);
add_node_ref(right);
return new_node(value,left,right);
return node;
}
}
}
}
static
ref<Node> balanceR(V value, ref<Node> left, ref<Node> right)
ref<Node> balanceR(ref<Node> node)
{
if (left == 0) {
if (right == 0) {
add_value_ref(value);
return new_node(value);
if (node->left == 0) {
if (node->right == 0) {
return node;
} else {
if (right->left == 0) {
if (right->right == 0) {
add_value_ref(value);
add_node_ref(right);
return new_node(value,0,right);
if (node->right->left == 0) {
if (node->right->right == 0) {
return node;
} else {
add_value_ref(value);
add_value_ref(right->value);
add_node_ref(right->right);
ref<Node<V>> new_left =
new_node(value);
return new_node(right->value,
new_left,
ref<Node<V>> right = node->right;
ref<Node<V>> left =
upd_node(node,
0,
0);
return upd_node(right,
left,
right->right);
}
} else {
if (right->right == 0) {
add_value_ref(value);
add_value_ref(right->value);
add_value_ref(right->left->value);
ref<Node<V>> new_left =
new_node(value);
ref<Node<V>> new_right =
new_node(right->value);
return new_node(right->left->value,
new_left,
new_right);
if (node->right->right == 0) {
ref<Node<V>> right_left = node->right->left;
ref<Node<V>> right =
upd_node(node->right,0,0);
ref<Node<V>> left =
upd_node(node,0,0);
return upd_node(right_left,
left,
right);
} else {
if (right->left->sz < 2 * right->right->sz) {
add_value_ref(value);
add_value_ref(right->value);
add_node_ref(right->left);
add_node_ref(right->right);
ref<Node<V>> new_left =
new_node(value,
if (node->right->left->sz < 2 * node->right->right->sz) {
ref<Node<V>> right = node->right;
ref<Node<V>> left =
upd_node(node,
0,
right->left);
return new_node(right->value,
new_left,
return upd_node(right,
left,
right->right);
} else {
add_value_ref(value);
add_value_ref(right->value);
add_value_ref(right->left->value);
if (right->left->left != 0)
add_node_ref(right->left->left);
if (right->left->right != 0)
add_node_ref(right->left->right);
add_node_ref(right->right);
ref<Node<V>> new_left =
new_node(value,
ref<Node<V>> right_left = node->right->left;
ref<Node<V>> right =
upd_node(node->right,
right_left->right,
node->right->right);
ref<Node<V>> left =
upd_node(node,
0,
right->left->left);
ref<Node<V>> new_right =
new_node(right->value,
right->left->right,
right->right);
return new_node(right->left->value,
new_left,
new_right);
right_left->left);
return upd_node(right_left,
left,
right);
}
}
}
}
} else {
if (right == 0) {
add_value_ref(value);
add_node_ref(left);
return new_node(value,left,0);
if (node->right == 0) {
return node;
} else {
if (right->sz > 3*left->sz) {
if (right->left->sz < 2*right->right->sz) {
add_value_ref(value);
add_value_ref(right->value);
add_node_ref(left);
add_node_ref(right->left);
add_node_ref(right->right);
ref<Node<V>> new_left =
new_node(value,
left,
if (node->right->sz > 3*node->left->sz) {
if (node->right->left->sz < 2*node->right->right->sz) {
ref<Node<V>> right = node->right;
ref<Node<V>> left =
upd_node(node,
node->left,
right->left);
return new_node(right->value,
new_left,
return upd_node(right,
left,
right->right);
} else {
add_value_ref(value);
add_value_ref(right->value);
add_value_ref(right->left->value);
add_node_ref(left);
if (right->left->left != 0)
add_node_ref(right->left->left);
if (right->left->right != 0)
add_node_ref(right->left->right);
add_node_ref(right->right);
ref<Node<V>> new_left =
new_node(value,
left,
right->left->left);
ref<Node<V>> new_right =
new_node(right->value,
right->left->right,
right->right);
return new_node(right->left->value,
new_left,
new_right);
ref<Node<V>> right_left = node->right->left;
ref<Node<V>> right =
upd_node(node->right,
right_left->right,
node->right->right);
ref<Node<V>> left =
upd_node(node,
node->left,
right_left->left);
return upd_node(right_left,
left,
right);
}
} else {
add_value_ref(value);
add_node_ref(left);
add_node_ref(right);
return new_node(value,left,right);
return node;
}
}
}
@@ -368,57 +251,42 @@ public:
}
static
ref<Node> pop_first(ref<Node> node, V *res)
ref<Node> pop_first(ref<Node> node, ref<Node> *res)
{
if (node == 0) {
return 0;
} else if (node->left == 0) {
*res = node->value;
if (node->right != 0)
node->right->ref_count++;
*res = node;
return node->right;
} else {
ref<Node> new_left = pop_first(node->left, res);
ref<Node> new_node = balanceR(node->value, new_left, node->right);
release(new_left);
return new_node;
ref<Node> left = pop_first(node->left, res);
ref<Node> node = upd_node(node, left, node->right);
return balanceR(node);
}
}
static
ref<Node> pop_last(ref<Node> node, V *res)
ref<Node> pop_last(ref<Node> node, ref<Node> *res)
{
if (node == 0) {
return 0;
} else if (node->right == 0) {
*res = node->value;
if (node->left != 0)
node->left->ref_count++;
*res = node;
return node->left;
} else {
ref<Node> new_right = pop_last(node->right, res);
ref<Node> new_node = balanceR(node->value, node->left, new_right);
release(new_right);
return new_node;
ref<Node> right = pop_last(node->right, res);
ref<Node> node = upd_node(node, node->left, right);
return balanceL(node);
}
}
static
void release(ref<Node> node)
{
if (node == 0)
return;
#ifdef DEBUG_NAMESPACE
printf("release node %6ld %s (ref_count=%ld)\n", node.as_object(), node->value->name.text, node->ref_count-1);
#endif
if (!(--node->ref_count)) {
release(node->left);
release(node->right);
release_value_ref(node->value);
PgfDB::free(node);
}
PgfDB::free(node);
}
};
@@ -443,26 +311,22 @@ Namespace<V> namespace_insert(Namespace<V> map, ref<V> value)
int cmp = textcmp(&value->name,&map->value->name);
if (cmp < 0) {
Namespace<V> left = namespace_insert(map->left, value);
Namespace<V> node = Node<ref<V>>::balanceL(map->value,left,map->right);
namespace_release(left);
return node;
map = Node<ref<V>>::upd_node(map,left,map->right);
return Node<ref<V>>::balanceL(map);
} else if (cmp > 0) {
Namespace<V> right = namespace_insert(map->right, value);
Namespace<V> node = Node<ref<V>>::balanceR(map->value, map->left, right);
namespace_release(right);
return node;
map = Node<ref<V>>::upd_node(map,map->left,right);
return Node<ref<V>>::balanceR(map);
} else {
if (map->left != 0)
map->left->ref_count++;
if (map->right != 0)
map->right->ref_count++;
return Node<ref<V>>::new_node(value,map->left,map->right);
map = Node<ref<V>>::upd_node(map,map->left,map->right);
map->value = value;
return map;
}
}
template <class V>
Namespace<V> namespace_delete(Namespace<V> map, PgfText* name,
ref<V> *pvalue = NULL)
ref<V> *pvalue)
{
if (map == 0) {
if (pvalue != NULL) *pvalue = 0;
@@ -472,41 +336,33 @@ Namespace<V> namespace_delete(Namespace<V> map, PgfText* name,
int cmp = textcmp(name,&map->value->name);
if (cmp < 0) {
Namespace<V> left = namespace_delete(map->left, name, pvalue);
if (left == map->left)
return map;
Namespace<V> node = Node<ref<V>>::balanceR(map->value,left,map->right);
namespace_release(left);
return node;
map = Node<ref<V>>::upd_node(map,left,map->right);
return Node<ref<V>>::balanceR(map);
} else if (cmp > 0) {
Namespace<V> right = namespace_delete(map->right, name, pvalue);
if (right == map->right)
return map;
Namespace<V> node = Node<ref<V>>::balanceL(map->value,map->left,right);
namespace_release(right);
return node;
map = Node<ref<V>>::upd_node(map,map->left,right);
return Node<ref<V>>::balanceL(map);
} else {
if (pvalue != NULL) *pvalue = map->value;
if (map->left == 0) {
if (map->right != 0)
map->right->ref_count++;
Node<ref<V>>::release(map);
return map->right;
} else if (map->right == 0) {
if (map->left != 0)
map->left->ref_count++;
Node<ref<V>>::release(map);
return map->left;
} else if (map->left->sz > map->right->sz) {
ref<V> value;
Namespace<V> new_left = Node<ref<V>>::pop_last(map->left, &value);
Namespace<V> node = Node<ref<V>>::balanceR(value, new_left, map->right);
namespace_release(new_left);
return node;
Namespace<V> node;
Namespace<V> left = Node<ref<V>>::pop_last(map->left, &node);
node = Node<ref<V>>::upd_node(node, left, map->right);
Node<ref<V>>::release(map);
return Node<ref<V>>::balanceR(node);
} else {
ref<V> value;
Namespace<V> new_right = Node<ref<V>>::pop_first(map->right, &value);
Namespace<V> node = Node<ref<V>>::balanceL(value, map->left, new_right);
namespace_release(new_right);
return node;
Namespace<V> node;
Namespace<V> right = Node<ref<V>>::pop_first(map->right, &node);
node = Node<ref<V>>::upd_node(node, map->left, right);
Node<ref<V>>::release(map);
return Node<ref<V>>::balanceL(node);
}
}
}
@@ -554,6 +410,10 @@ void namespace_iter(Namespace<V> map, PgfItor* itor, PgfExn *err)
template <class V>
void namespace_release(Namespace<V> node)
{
if (node == 0)
return;
namespace_release(node->left);
namespace_release(node->right);
Node<ref<V>>::release(node);
}