Implementation of mechanisms for synchronisation of memory access at the knowledge level

.gitignore

@@ -6,6 +6,7 @@ generated
 cmake-build-debug
 cmake-build-release
 cmake-build-debug-coverage
+cmake-build-*
 /CMakeUserPresets.json
 /ConanPresets.json
 
@@ -43,3 +44,14 @@ __pycache__
 *.log
 *.pdf
 *.run.xml
+
+CMakeCache.txt
+CMakeFiles/
+CPackConfig.cmake
+CPackSourceConfig.cmake
+CTestTestfile.cmake
+DartConfiguration.tcl
+Makefile
+cmake_install.cmake
+*.cmake
+*.tcl

sc-memory/sc-core/src/sc-store/sc-transaction/sc_element_version.c

@@ -0,0 +1,30 @@
+#include "sc_element_version.h"
+
+#include <sc-store/sc_element.h>
+#include <sc-core/sc-base/sc_allocator.h>
+
+sc_element_version * sc_element_create_new_version(sc_element * element, sc_uint64 version_id, sc_type modified_fields)
+{
+  if (element == NULL)
+    return NULL;
+
+  sc_element_version * new_version = sc_mem_new(sc_element_version, 1);
+  if (new_version == NULL)
+    return NULL;
+
+  new_version->data = element;
+  new_version->version_id = version_id;
+  new_version->prev_version = element->versions.tail;
+  new_version->next_version = NULL;
+  new_version->is_committed = SC_FALSE;
+  new_version->modified_fields = modified_fields;
+
+  if (element->versions.tail)
+    element->versions.tail->next_version = new_version;
+  else
+    element->versions.head = new_version;
+
+  element->versions.tail = new_version;
+
+  return new_version;
+}

sc-memory/sc-core/src/sc-store/sc-transaction/sc_element_version.h

@@ -0,0 +1,32 @@
+#ifndef SC_ELEMENT_VERSION_H
+#define SC_ELEMENT_VERSION_H
+
+#include <sc-core/sc_types.h>
+
+typedef struct sc_element_version
+{
+  sc_element* data;
+  sc_uint64 version_id;
+  struct sc_element_version * prev_version;
+  struct sc_element_version * next_version;
+  sc_bool is_committed;
+  sc_type modified_fields;
+} sc_element_version;
+
+typedef struct sc_version_chain
+{
+  sc_element_version * head;
+  sc_element_version * tail;
+} sc_version_chain;
+
+typedef enum
+{
+  SC_ELEMENT_FLAGS_MODIFIED = 1 << 0,
+  SC_ELEMENT_ARCS_MODIFIED = 1 << 1,
+  SC_ELEMENT_CONTENT_MODIFIED = 1 << 2,
+  SC_ELEMENT_LINKS_MODIFIED = 1 << 3
+} SC_ELEMENT_MODIFIED_FLAGS;
+
+sc_element_version * sc_element_create_new_version(sc_element * element, sc_uint64 version_id, sc_type modified_fields);
+
+#endif

sc-memory/sc-core/src/sc-store/sc-transaction/sc_transaction.c

@@ -0,0 +1,77 @@
+#include "sc_transaction.h"
+
+#include <sc-core/sc-base/sc_allocator.h>
+
+sc_transaction * sc_transaction_new(sc_uint64 const * txn_id)
+{
+  if (txn_id == NULL)
+    return NULL;
+
+  sc_transaction * txn = sc_mem_new(sc_transaction, 1);
+  if (txn == NULL)
+    return NULL;
+
+  txn->transaction_id = *txn_id;
+  txn->is_committed = SC_FALSE;
+
+  txn->elements = sc_mem_new(sc_list, 1);
+  if (txn->elements == NULL)
+  {
+    sc_mem_free(txn);
+    return NULL;
+  }
+
+  txn->transaction_buffer = sc_mem_new(sc_transaction_buffer, 1);
+  if (txn->transaction_buffer == NULL)
+  {
+    sc_mem_free(txn->elements);
+    sc_mem_free(txn);
+    return NULL;
+  }
+
+  sc_transaction_buffer_initialize(txn->transaction_buffer);
+  sc_list_init(&txn->elements);
+
+  return txn;
+}
+
+void sc_transaction_destroy(sc_transaction * txn)
+{
+  if (txn != NULL)
+  {
+    sc_list_clear(txn->elements);
+
+    sc_mem_free(txn);
+  }
+}
+
+void sc_transaction_add_element(sc_transaction * txn, sc_element * element) {}
+
+void sc_transaction_commit(sc_transaction * txn) {}
+
+void sc_transaction_rollback(sc_transaction * txn) {}
+
+sc_bool sc_transaction_validate(sc_transaction * txn)
+{
+  return SC_FALSE;
+}
+
+void sc_transaction_merge(sc_transaction * txn) {}
+
+void sc_transaction_apply(sc_transaction * txn) {}
+
+void sc_transaction_clear(sc_transaction * txn) {}
+
+sc_bool sc_transaction_element_new(sc_transaction * txn, sc_element * element) {}
+
+sc_bool sc_transaction_element_change(
+    sc_element * element,
+    sc_transaction * txn,
+    SC_ELEMENT_MODIFIED_FLAGS modified_flags,
+    sc_element const * new_data)
+{
+}
+
+sc_bool sc_transaction_element_remove(sc_transaction * txn, sc_addr addr) {}
+
+sc_bool sc_transaction_element_content_set(sc_transaction * txn, sc_addr addr, sc_stream * content) {}

sc-memory/sc-core/src/sc-store/sc-transaction/sc_transaction.h

@@ -0,0 +1,46 @@
+#ifndef SC_TRANSACTION_H
+#define SC_TRANSACTION_H
+
+#include <sc-store/sc-transaction/sc_element_version.h>
+#include <sc-store/sc-transaction/sc_transaction_buffer.h>
+
+#include <sc-core/sc_stream.h>
+#include <sc-core/sc-container/sc_list.h>
+
+typedef struct sc_transaction
+{
+  sc_uint64 transaction_id;
+  sc_bool is_committed;
+  sc_list * elements;
+  sc_transaction_buffer * transaction_buffer;
+} sc_transaction;
+
+sc_transaction * sc_transaction_new(sc_uint64 const * txn_id);
+// create a new transaction
+void sc_transaction_destroy(sc_transaction * txn);
+// destroy the given transaction
+
+sc_bool sc_transaction_element_new(sc_transaction * txn, sc_element * element);
+sc_bool sc_transaction_element_change(
+    sc_element * element,
+    sc_transaction * txn,
+    SC_ELEMENT_MODIFIED_FLAGS modified_flags,
+    sc_element const * new_data);
+sc_bool sc_transaction_element_remove(sc_transaction * txn, sc_addr addr);
+sc_bool sc_transaction_element_content_set(sc_transaction * txn, sc_addr addr, sc_stream * content);
+
+void sc_transaction_commit(sc_transaction * txn);
+// apply all operations of the transaction on sc-memory
+void sc_transaction_rollback(sc_transaction * txn);
+// rollback the transaction operations
+
+sc_bool sc_transaction_validate(sc_transaction * txn);
+// check if the transaction can be applied based on element versions and free segments
+void sc_transaction_merge(sc_transaction * txn);
+// check versions of all elements in the transaction and try to merge them
+void sc_transaction_apply(sc_transaction * txn);
+// apply all operations (merged versions, allocated spaces) to sc-memory
+void sc_transaction_clear(sc_transaction * txn);
+// deletes all transaction items and clears them without performing a commit
+
+#endif

sc-memory/sc-core/src/sc-store/sc-transaction/sc_transaction_buffer.c

@@ -0,0 +1,175 @@
+#include "sc_transaction_buffer.h"
+
+#include <sc-store/sc-transaction/sc_element_version.h>
+#include <sc-core/sc-base/sc_allocator.h>
+#include <sc-core/sc-container/sc_list.h>
+#include <sc-core/sc_stream.h>
+
+typedef struct sc_modified_element {
+    sc_addr addr;
+    sc_element_version * version;
+    sc_stream * content;
+    SC_ELEMENT_MODIFIED_FLAGS flags;
+} sc_modified_element;
+
+sc_bool sc_transaction_buffer_initialize(sc_transaction_buffer * buffer)
+{
+  if (buffer == null_ptr)
+    return SC_FALSE;
+
+  buffer->new_elements = sc_mem_new(sc_list, 1);
+  if (buffer->new_elements == null_ptr)
+    return SC_FALSE;
+  sc_list_init(&buffer->new_elements);
+
+  buffer->modified_elements = sc_mem_new(sc_list, 1);
+  if (buffer->modified_elements == null_ptr)
+  {
+    sc_mem_free(buffer->new_elements);
+    return SC_FALSE;
+  }
+  sc_list_init(&buffer->modified_elements);
+
+  buffer->deleted_elements = sc_mem_new(sc_list, 1);
+  if (buffer->deleted_elements == null_ptr)
+  {
+    sc_mem_free(buffer->new_elements);
+    sc_mem_free(buffer->modified_elements);
+    return SC_FALSE;
+  }
+  sc_list_init(&buffer->deleted_elements);
+
+  return SC_TRUE;
+}
+
+sc_bool sc_transaction_buffer_created_add(sc_transaction_buffer * buffer, sc_addr addr)
+{
+  if (buffer == null_ptr || buffer->new_elements == null_ptr)
+    return SC_FALSE;
+
+  if (SC_ADDR_IS_EMPTY(addr))
+    return SC_FALSE;
+
+  if (transaction_buffer_contains_created(buffer, addr))
+    return SC_TRUE;
+
+  sc_addr * addr_copy = sc_mem_new(sc_addr, 1);
+  if (addr_copy == null_ptr)
+    return SC_FALSE;
+
+  *addr_copy = addr;
+
+  if (sc_list_push_back(buffer->new_elements, addr_copy) == null_ptr)
+  {
+    sc_mem_free(addr_copy);
+    return SC_FALSE;
+  }
+
+  return SC_TRUE;
+}
+
+sc_bool sc_transaction_buffer_modified_add(
+    sc_transaction_buffer * buffer,
+    sc_addr addr,
+    sc_element * element,
+    sc_stream * content,
+    SC_ELEMENT_MODIFIED_FLAGS flags)
+{
+  if (buffer == null_ptr || buffer->modified_elements == null_ptr)
+    return SC_FALSE;
+
+  if (SC_ADDR_IS_EMPTY(addr))
+    return SC_FALSE;
+
+  sc_element_version * new_version = sc_element_create_new_version(element, /* version_id */ 0, flags); // Add generation for id
+  if (new_version == NULL)
+    return SC_FALSE;
+
+  sc_iterator * it = sc_list_iterator(buffer->modified_elements);
+  while (sc_iterator_next(it))
+  {
+    sc_modified_element * mod = (sc_modified_element *) sc_iterator_get(it);
+    if (SC_ADDR_IS_EQUAL(mod->addr, addr))
+    {
+      mod->version = new_version;
+      mod->content = content;
+      mod->flags = flags;
+      sc_iterator_destroy(it);
+      return SC_TRUE;
+    }
+  }
+  sc_iterator_destroy(it);
+
+  sc_modified_element * new_mod = sc_mem_new(sc_modified_element, 1);
+  if (new_mod == null_ptr)
+    return SC_FALSE;
+
+  new_mod->addr = addr;
+  new_mod->version = new_version;
+  new_mod->content = content;
+  new_mod->flags = flags;
+
+  if (sc_list_push_back(buffer->modified_elements, new_mod) == null_ptr)
+  {
+    sc_mem_free(new_version);
+    sc_mem_free(new_mod);
+    return SC_FALSE;
+  }
+
+  return SC_TRUE;
+}
+
+sc_bool sc_transaction_buffer_removed_add(sc_transaction_buffer * buffer, sc_addr addr)
+{
+  if (buffer == null_ptr || buffer->deleted_elements == null_ptr)
+    return SC_FALSE;
+
+  if (SC_ADDR_IS_EMPTY(addr))
+    return SC_FALSE;
+
+  sc_iterator * it = sc_list_iterator(buffer->deleted_elements);
+  while (sc_iterator_next(it))
+  {
+    sc_addr * stored_addr = (sc_addr *) sc_iterator_get(it);
+    if (SC_ADDR_IS_EQUAL(*stored_addr, addr))
+    {
+      sc_iterator_destroy(it);
+      return SC_TRUE;
+    }
+  }
+  sc_iterator_destroy(it);
+
+  sc_addr * addr_copy = sc_mem_new(sc_addr, 1);
+  if (addr_copy == null_ptr)
+    return SC_FALSE;
+
+  *addr_copy = addr;
+  if (sc_list_push_back(buffer->deleted_elements, addr_copy) == null_ptr)
+  {
+    sc_mem_free(addr_copy);
+    return SC_FALSE;
+  }
+
+  return SC_TRUE;
+}
+
+sc_bool transaction_buffer_contains_created(sc_transaction_buffer const * buffer, sc_addr addr)
+{
+  if (buffer == null_ptr || buffer->new_elements == null_ptr)
+    return SC_FALSE;
+
+  sc_iterator * it = sc_list_iterator(buffer->new_elements);
+  while (sc_iterator_next(it))
+  {
+    sc_addr * stored_addr = (sc_addr *) sc_iterator_get(it);
+    if (SC_ADDR_IS_EQUAL(*stored_addr, addr))
+    {
+      sc_iterator_destroy(it);
+      return SC_TRUE;
+    }
+  }
+  sc_iterator_destroy(it);
+
+  return SC_FALSE;
+}
+