implement graph

build.rs

@@ -1,8 +1,14 @@
+/*
+ * Copyright FalkorDB Ltd. 2023 - present
+ * Licensed under the Server Side Public License v1 (SSPLv1).
+ */
+
 use std::env;
 
 fn main() {
     println!("cargo:rerun-if-changed=build.rs");
     println!("cargo:rerun-if-env-changed=BINROOT");
+    println!("cargo:rerun-if-env-changed=CLANG");
 
     let bin_root = env::var("BINROOT");
     if let Ok(bin_root) = bin_root {

src/binding/cmutex.rs

@@ -0,0 +1,44 @@
+/*
+ * Copyright FalkorDB Ltd. 2023 - present
+ * Licensed under the Server Side Public License v1 (SSPLv1).
+ */
+
+use std::{cell::UnsafeCell, mem::MaybeUninit, ptr::null_mut};
+
+use libc::pthread_mutex_t;
+
+/// Wrap C mutex as we can't use Rust Mutex.
+/// Used to lock the matrix only when we apply pending changes.
+pub struct CMutex {
+    mutex: UnsafeCell<pthread_mutex_t>,
+}
+
+impl CMutex {
+    pub fn new() -> Self {
+        unsafe {
+            let mut mutex = MaybeUninit::uninit();
+            libc::pthread_mutex_init(mutex.as_mut_ptr(), null_mut());
+            Self {
+                mutex: UnsafeCell::new(mutex.assume_init()),
+            }
+        }
+    }
+
+    pub fn lock(&self) {
+        unsafe {
+            libc::pthread_mutex_lock(self.mutex.get());
+        }
+    }
+
+    pub fn unlock(&self) {
+        unsafe {
+            libc::pthread_mutex_unlock(self.mutex.get());
+        }
+    }
+}
+
+impl Drop for CMutex {
+    fn drop(&mut self) {
+        unsafe { libc::pthread_mutex_destroy(self.mutex.get()) };
+    }
+}

src/binding/crwlock.rs

@@ -0,0 +1,53 @@
+/*
+ * Copyright FalkorDB Ltd. 2023 - present
+ * Licensed under the Server Side Public License v1 (SSPLv1).
+ */
+
+use std::ptr::null_mut;
+
+use libc::{pthread_rwlock_t, PTHREAD_RWLOCK_INITIALIZER};
+
+/// Wrap C rwlock as we can't use Rust RWLock.
+/// Used to lock the graph.
+pub struct CRWLock {
+    rwlock: Box<pthread_rwlock_t>,
+}
+
+impl CRWLock {
+    pub fn new() -> Self {
+        let mut res = CRWLock {
+            rwlock: Box::new(PTHREAD_RWLOCK_INITIALIZER),
+        };
+        unsafe {
+            libc::pthread_rwlock_init(res.rwlock.as_mut(), null_mut());
+        }
+        res
+    }
+
+    pub fn acquire_read(&mut self) {
+        unsafe {
+            let res = libc::pthread_rwlock_rdlock(self.rwlock.as_mut());
+            debug_assert!(res == 0, "pthread_rwlock_rdlock failed");
+        }
+    }
+
+    pub fn acquire_write(&mut self) {
+        unsafe {
+            let res = libc::pthread_rwlock_wrlock(self.rwlock.as_mut());
+            debug_assert!(res == 0, "pthread_rwlock_wrlock failed");
+        }
+    }
+
+    pub fn release(&mut self) {
+        unsafe {
+            let res = libc::pthread_rwlock_unlock(self.rwlock.as_mut());
+            debug_assert!(res == 0, "pthread_rwlock_unlock failed");
+        }
+    }
+}
+
+impl Drop for CRWLock {
+    fn drop(&mut self) {
+        unsafe { libc::pthread_rwlock_destroy(self.rwlock.as_mut()) };
+    }
+}