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

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

@@ -0,0 +1 @@
+#include "sc_element_version.h"

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

@@ -0,0 +1,14 @@
+#ifndef SC_ELEMENT_VERSION_H
+#define SC_ELEMENT_VERSION_H
+
+#include "sc-core/sc_types.h"
+
+typedef struct sc_element_version {
+  void* data;
+  sc_uint64 version_id;
+  struct sc_element_version* prev_version;
+  struct sc_element_version* next_version;
+  sc_bool is_committed;
+} sc_element_version;
+
+#endif

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

@@ -0,0 +1,24 @@
+#include "sc_transaction.h"
+
+#include <sc-core/sc-base/sc_allocator.h>
+
+sc_transaction* sc_transaction_create(const sc_uint64* txn_id) {
+  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->element_count = 0;
+  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);
+  }
+}

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

@@ -0,0 +1,34 @@
+#ifndef SC_TRANSACTION_H
+#define SC_TRANSACTION_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_uint32 element_count;
+} sc_transaction;
+
+sc_transaction* sc_transaction_create(const sc_uint64* txn_id);
+// create a new transaction
+void sc_transaction_destroy(sc_transaction* txn);
+// destroy the given transaction
+
+void sc_transaction_add_element(sc_transaction* txn, sc_element* element);
+// add element to track in transaction (based on "touched" elements, manager will try to commit or rollback transaction)
+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_manager.c

@@ -0,0 +1,58 @@
+#include "sc_transaction_manager.h"
+
+#include <sc-core/sc-base/sc_allocator.h>
+
+sc_transaction_manager * transaction_manager = null_ptr;
+
+sc_transaction_manager* sc_transaction_manager_initialize() {
+  if (sc_transaction_manager_is_initialized()) {
+    return transaction_manager;
+  }
+
+  transaction_manager = sc_mem_new(sc_transaction_manager, 1);
+  if (!sc_transaction_manager_is_initialized()) {
+    return null_ptr;
+  }
+
+  transaction_manager->current_sc_transaction = null_ptr;
+  sc_queue_init(transaction_manager->sc_transaction_queue);
+  sc_monitor_init(transaction_manager->sc_monitor);
+  transaction_manager->transaction_counter = 0;
+
+  return transaction_manager;
+}
+
+sc_bool sc_transaction_manager_is_initialized() {
+  return transaction_manager != null_ptr;
+}
+
+void sc_transaction_shutdown() {
+  if (transaction_manager != null_ptr) {
+    sc_transaction_manager_destroy();
+  }
+}
+
+void sc_transaction_manager_destroy() {
+  if (transaction_manager != null_ptr) {
+    sc_monitor_acquire_write(transaction_manager->sc_monitor);
+    sc_queue_destroy(transaction_manager->sc_transaction_queue);
+    sc_monitor_release_write(transaction_manager->sc_monitor);
+
+    sc_monitor_destroy(transaction_manager->sc_monitor);
+
+    sc_mem_free(transaction_manager);
+    transaction_manager = null_ptr;
+  }
+}
+
+sc_transaction* sc_transaction_manager_transaction_new() {
+  if (!sc_transaction_manager_is_initialized()) {
+    return null_ptr;
+  }
+
+  sc_monitor_acquire_write(transaction_manager->sc_monitor);
+  const sc_uint64 txn_id = transaction_manager->transaction_counter++;
+  sc_monitor_release_write(transaction_manager->sc_monitor);
+
+  return sc_transaction_create(&txn_id);
+}

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

@@ -0,0 +1,31 @@
+#ifndef SC_TRANSACTION_MANAGER_H
+#define SC_TRANSACTION_MANAGER_H
+
+#include "sc_transaction.h"
+#include "sc-store/sc-base/sc_monitor_private.h"
+
+typedef struct sc_transaction_manager {
+  sc_transaction*current_sc_transaction;
+  sc_queue* sc_transaction_queue;
+  sc_monitor* sc_monitor;
+  sc_uint64 transaction_counter;
+} sc_transaction_manager;
+
+sc_transaction_manager* sc_transaction_manager_initialize();
+// create and initialize the transaction manager
+sc_bool sc_transaction_manager_is_initialized();
+// check if the transaction manager is initialized
+void sc_transaction_shutdown();
+// shutdown the transaction manager
+
+sc_transaction* sc_transaction_manager_transaction_new();
+// create a new empty sc-transaction
+void sc_transaction_manager_transaction_add(sc_transaction* txn);
+// add transaction to the queue and start operations when the thread is ready
+void sc_transaction_manager_transaction_execute();
+// try to execute the transaction and wait till it's finished
+
+void sc_transaction_manager_destroy();
+// destroy the transaction manager
+
+#endif

sc-memory/sc-core/src/sc-store/sc_element.h

@@ -8,6 +8,7 @@
 #define _sc_element_h_
 
 #include "sc-core/sc_types.h"
+#include "sc-transaction/sc_element_version.h"
 
 struct _sc_arc_info
 {
@@ -65,6 +66,8 @@ struct _sc_element
 
   sc_uint32 incoming_arcs_count;
   sc_uint32 outgoing_arcs_count;
+
+  sc_element_version* current_version;
 };
 
 #endif

sc-memory/sc-core/tests/units/common/test_sc_transaction_core.cpp

@@ -0,0 +1,95 @@
+#include <gtest/gtest.h>
+#include <pthread.h>
+#include <sc-memory/test/sc_test.hpp>
+
+extern "C" {
+#include <sc-store/sc-transaction/sc_transaction_manager.h>
+}
+
+struct TransactionThreadData {
+    transaction_manager* manager;
+    int thread_id;
+};
+
+void* transaction_thread(void* arg) {
+    auto* data = static_cast<TransactionThreadData*>(arg);
+    transaction_manager* manager = data->manager;
+
+    sc_element_version version = {};
+    log_version_change(manager, &version);
+
+    if (data->thread_id % 2 == 0) {
+        commit_transaction(manager);
+    } else {
+        rollback_transaction(manager);
+    }
+
+    return nullptr;
+}
+
+TEST_F(ScMemoryTest, MultiThreadedTransactionTest) {
+    transaction_manager manager;
+    initialize_transaction_manager(&manager);
+
+    const int NUM_THREADS = 10;
+    pthread_t threads[NUM_THREADS];
+    TransactionThreadData thread_data[NUM_THREADS];
+
+    for (int i = 0; i < NUM_THREADS; ++i) {
+        thread_data[i].manager = &manager;
+        thread_data[i].thread_id = i;
+        pthread_create(&threads[i], nullptr, transaction_thread, &thread_data[i]);
+    }
+
+    for (int i = 0; i < NUM_THREADS; ++i) {
+        pthread_join(threads[i], nullptr);
+    }
+
+    EXPECT_EQ(manager.current_transaction, nullptr);
+
+    EXPECT_NE(manager.log_head, nullptr);
+}
+
+TEST_F(ScMemoryTest, MultiThreadedTransactionLogTest) {
+    transaction_manager manager;
+    initialize_transaction_manager(&manager);
+
+    const int NUM_THREADS = 5;
+    pthread_t threads[NUM_THREADS];
+    TransactionThreadData thread_data[NUM_THREADS];
+
+    for (int i = 0; i < NUM_THREADS; ++i) {
+        thread_data[i].manager = &manager;
+        thread_data[i].thread_id = i;
+        pthread_create(&threads[i], nullptr, transaction_thread, &thread_data[i]);
+    }
+
+    for (int i = 0; i < NUM_THREADS; ++i) {
+        pthread_join(threads[i], nullptr);
+    }
+
+    EXPECT_NE(manager.log_head, nullptr);
+}
+
+TEST_F(ScMemoryTest, TransactionManagerTests) {
+    transaction_manager manager;
+    initialize_transaction_manager(&manager);
+
+    const int NUM_THREADS = 20;
+    pthread_t threads[NUM_THREADS];
+    TransactionThreadData thread_data[NUM_THREADS];
+
+    for (int i = 0; i < NUM_THREADS; ++i) {
+        thread_data[i].manager = &manager;
+        thread_data[i].thread_id = i;
+        pthread_create(&threads[i], nullptr, transaction_thread, &thread_data[i]);
+    }
+
+    for (int i = 0; i < NUM_THREADS; ++i) {
+        pthread_join(threads[i], nullptr);
+    }
+
+    EXPECT_EQ(manager.current_transaction, nullptr);
+
+    EXPECT_NE(manager.log_head, nullptr);
+}