Refactoring and add fine-grained with tests

Author: aartdem

work4/src/main/kotlin/Main.kt

@@ -1,13 +1,11 @@
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.newSingleThreadContext
 import kotlinx.coroutines.runBlocking
 import trees.CoarseGrainedBinaryTree
+import trees.FineGrainedBinaryTree
 
 
 fun main(): Unit = runBlocking {
-    val tree = CoarseGrainedBinaryTree<Int>()
-    tree.add(2)
-    tree.add(1)
-    tree.add(3)
-    tree.contains(1)
-    tree.remove(1)
-    tree.contains(1)
+    println("Hello world!")
 }

work4/src/main/kotlin/trees/BinarySearchTree.kt

@@ -0,0 +1,26 @@
+package trees
+
+import kotlinx.coroutines.sync.Mutex
+
+abstract class BinarySearchTree<T : Comparable<T>> {
+    protected var root: Node<T>? = null
+    protected val treeRootMutex = Mutex()
+
+    abstract suspend fun contains(x: T): Boolean
+    abstract suspend fun add(x: T)
+    abstract suspend fun remove(x: T)
+
+    suspend fun getValues(): List<T> {
+        val res = mutableListOf<T>()
+        fun getValuesRecursively(currentNode: Node<T>?) {
+            currentNode ?: return
+            getValuesRecursively(currentNode.left)
+            res.add(currentNode.key)
+            getValuesRecursively(currentNode.right)
+        }
+        treeRootMutex.lock()
+        getValuesRecursively(root)
+        treeRootMutex.unlock()
+        return res
+    }
+}

work4/src/main/kotlin/trees/CoarseGrainedBinaryTree.kt

@@ -2,11 +2,8 @@ package trees
 
 import kotlinx.coroutines.sync.Mutex
 
-class CoarseGrainedBinaryTree<T : Comparable<T>> {
-    private var root: Node<T>? = null
-    private val rootMutex = Mutex()
-
-    suspend fun contains(x: T): Boolean {
+class CoarseGrainedBinaryTree<T : Comparable<T>> : BinarySearchTree<T>() {
+    override suspend fun contains(x: T): Boolean {
         fun containsRecursively(currentNode: Node<T>?): Boolean {
             currentNode ?: return false
 
@@ -18,13 +15,13 @@ class CoarseGrainedBinaryTree<T : Comparable<T>> {
                 containsRecursively(currentNode.right)
             }
         }
-        rootMutex.lock()
+        treeRootMutex.lock()
         val result = containsRecursively(root)
-        rootMutex.unlock()
+        treeRootMutex.unlock()
         return result
     }
 
-    suspend fun add(x: T) {
+    override suspend fun add(x: T) {
         fun addRecursively(currentNode: Node<T>?): Node<T> {
             currentNode ?: return Node(x, null, null)
 
@@ -35,12 +32,12 @@ class CoarseGrainedBinaryTree<T : Comparable<T>> {
             }
             return currentNode
         }
-        rootMutex.lock()
+        treeRootMutex.lock()
         root = addRecursively(root)
-        rootMutex.unlock()
+        treeRootMutex.unlock()
     }
 
-    suspend fun remove(x: T) {
+    override suspend fun remove(x: T) {
         fun removeNode(node: Node<T>): Node<T>? {
             if (node.left != null && node.right != null) {
                 var curChild = node.left
@@ -68,20 +65,9 @@ class CoarseGrainedBinaryTree<T : Comparable<T>> {
             }
             return currentNode
         }
-        rootMutex.lock()
-        root = removeRecursively(root)
-        rootMutex.unlock()
-    }
 
-    fun getValues(): List<T> {
-        val res = mutableListOf<T>()
-        fun getValuesRecursively(currentNode: Node<T>?) {
-            currentNode ?: return
-            getValuesRecursively(currentNode.left)
-            res.add(currentNode.key)
-            getValuesRecursively(currentNode.right)
-        }
-        getValuesRecursively(root)
-        return res
+        treeRootMutex.lock()
+        root = removeRecursively(root)
+        treeRootMutex.unlock()
     }
 }

work4/src/main/kotlin/trees/FineGrainedBinaryTree.kt

@@ -0,0 +1,151 @@
+package trees
+
+class FineGrainedBinaryTree<T : Comparable<T>> : BinarySearchTree<T>() {
+    override suspend fun contains(x: T): Boolean {
+        suspend fun containsRecursively(currentNode: Node<T>): Boolean {
+            if (x == currentNode.key) {
+                currentNode.unlock()
+                return true
+            } else if (x < currentNode.key) {
+                if (currentNode.left == null) {
+                    currentNode.unlock()
+                    return false
+                } else {
+                    currentNode.left!!.lock()
+                    currentNode.unlock()
+                    return containsRecursively(currentNode.left!!)
+                }
+            } else {
+                if (currentNode.right == null) {
+                    currentNode.unlock()
+                    return false
+                } else {
+                    currentNode.right!!.lock()
+                    currentNode.unlock()
+                    return containsRecursively(currentNode.right!!)
+                }
+            }
+        }
+        treeRootMutex.lock()
+        if (root == null) {
+            treeRootMutex.unlock()
+            return false
+        } else {
+            root!!.lock()
+            treeRootMutex.unlock()
+            return containsRecursively(root!!)
+        }
+    }
+
+    override suspend fun add(x: T) {
+        suspend fun addRecursively(currentNode: Node<T>) {
+            if (x == currentNode.key) {
+                currentNode.unlock()
+            } else if (x < currentNode.key) {
+                if (currentNode.left == null) {
+                    currentNode.left = Node(x, null, null)
+                    currentNode.unlock()
+                } else {
+                    currentNode.left!!.lock()
+                    currentNode.unlock()
+                    addRecursively(currentNode.left!!)
+                }
+            } else {
+                if (currentNode.right == null) {
+                    currentNode.right = Node(x, null, null)
+                    currentNode.unlock()
+                } else {
+                    currentNode.right!!.lock()
+                    currentNode.unlock()
+                    addRecursively(currentNode.right!!)
+                }
+            }
+        }
+        treeRootMutex.lock()
+        if (root == null) {
+            root = Node(x, null, null)
+            treeRootMutex.unlock()
+        } else {
+            root!!.lock()
+            treeRootMutex.unlock()
+            addRecursively(root!!)
+        }
+    }
+
+    override suspend fun remove(x: T) {
+        suspend fun findRightSuccessor(node: Node<T>): Node<T> {
+            node.right?.lock()
+            if (node.right == null) {
+                return node
+            }
+            var currentNode = node.right!!
+            while (currentNode.right != null) {
+                currentNode.right!!.lock()
+                currentNode.unlock()
+                currentNode = currentNode.right!!
+            }
+            return currentNode
+        }
+
+        /**
+         * Return locked node
+         */
+        suspend fun removeNode(nodeToRemove: Node<T>): Node<T>? {
+            nodeToRemove.left?.lock()
+            nodeToRemove.right?.lock()
+            val newNode = if (nodeToRemove.left != null && nodeToRemove.right != null) {
+                val rightSuccessor = findRightSuccessor(nodeToRemove.left!!)
+                rightSuccessor.right = nodeToRemove.right
+                nodeToRemove.right?.unlock()
+                if (rightSuccessor != nodeToRemove.left) rightSuccessor.unlock()
+                nodeToRemove.left
+            } else if (nodeToRemove.left == null) {
+                nodeToRemove.right
+            } else {
+                nodeToRemove.left
+            }
+            return newNode
+        }
+
+        suspend fun removeRecursively(currentNode: Node<T>, parentNode: Node<T>?, left: Boolean) {
+            if (x == currentNode.key) {
+                val newNode = removeNode(currentNode)
+                if (parentNode == null) {
+                    root = newNode
+                } else if (left) {
+                    parentNode.left = newNode
+                } else {
+                    parentNode.right = newNode
+                }
+                currentNode.unlock()
+                newNode?.unlock()
+                parentNode?.unlock()
+            } else if (x < currentNode.key) {
+                currentNode.left?.lock()
+                parentNode?.unlock()
+                currentNode.left?.let {
+                    removeRecursively(it, currentNode, true)
+                } ?: run {
+                    currentNode.unlock()
+                }
+            } else {
+                currentNode.right?.lock()
+                parentNode?.unlock()
+                currentNode.right?.let {
+                    removeRecursively(it, currentNode, false)
+                } ?: run {
+                    currentNode.unlock()
+                }
+            }
+        }
+        treeRootMutex.lock()
+        if (root == null) {
+            treeRootMutex.unlock()
+        } else {
+            root!!.lock()
+            treeRootMutex.unlock()
+            removeRecursively(root!!, null, true)
+        }
+    }
+
+}

work4/src/main/kotlin/trees/Node.kt

@@ -1,7 +1,19 @@
 package trees
 
+import kotlinx.coroutines.sync.Mutex
+
 class Node<T : Comparable<T>>(
     var key: T,
     var left: Node<T>?,
     var right: Node<T>?
-)
+) {
+    private val mutex = Mutex()
+
+    suspend fun lock() {
+        mutex.lock()
+    }
+
+    fun unlock() {
+        if (mutex.isLocked) mutex.unlock()
+    }
+}

work4/src/test/kotlin/trees/BinarySearchTreeTests.kt

@@ -0,0 +1,81 @@
+package trees
+
+import kotlinx.coroutines.*
+import org.junit.jupiter.api.Assertions
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.Arguments
+import org.junit.jupiter.params.provider.MethodSource
+import kotlin.random.Random
+
+abstract class BinarySearchTreeTests {
+    protected lateinit var tree: BinarySearchTree<Int>
+    private val rnd = Random(0)
+
+    @BeforeEach
+    abstract fun setUp()
+
+    @OptIn(ExperimentalCoroutinesApi::class, DelicateCoroutinesApi::class)
+    @ParameterizedTest
+    @MethodSource("threadNumsProvider")
+    fun addingValuesTest(threadsNum: Int) {
+        val valuesToAddLists = List(threadsNum) { List(5000) { rnd.nextInt(5000) } }
+        runBlocking {
+            valuesToAddLists.forEachIndexed { id, list ->
+                launch(newSingleThreadContext("Thread$id")) {
+                    list.forEach { tree.add(it) }
+                }
+            }
+        }
+        runBlocking {
+            valuesToAddLists.forEachIndexed { id, list ->
+                launch(newSingleThreadContext("Thread$id")) {
+                    list.forEach { Assertions.assertTrue(tree.contains(it)) }
+                }
+            }
+        }
+    }
+
+    @OptIn(ExperimentalCoroutinesApi::class, DelicateCoroutinesApi::class)
+    @ParameterizedTest
+    @MethodSource("threadNumsProvider")
+    fun deletingValuesTest(threadsNum: Int) {
+        val valuesToRemoveLists = List(threadsNum) { List(5000 ) { rnd.nextInt(5000) } }
+        valuesToRemoveLists.forEach {
+            println(it)
+        }
+        val jobs = mutableListOf<Job>()
+        runBlocking {
+            valuesToRemoveLists.forEachIndexed { id, list ->
+                launch(newSingleThreadContext("Thread$id")) {
+                    list.forEach { tree.add(it) }
+                }.let {
+                    jobs.add(it)
+                }
+            }
+
+            jobs.forEach {
+                it.join()
+            }
+            valuesToRemoveLists.forEachIndexed { id, list ->
+                launch(newSingleThreadContext("Thread$id")) {
+                    list.forEach { tree.remove(it) }
+                }
+            }
+        }
+        println("ABOBUS")
+        runBlocking {
+            valuesToRemoveLists.forEachIndexed { id, list ->
+                launch(newSingleThreadContext("Thread$id")) {
+                    list.forEach { Assertions.assertFalse(tree.contains(it)) }
+                }
+            }
+        }
+    }
+
+    companion object {
+        @JvmStatic
+        fun threadNumsProvider(): List<Arguments> =
+            listOf(Arguments.of(1), Arguments.of(2), Arguments.of(4))
+    }
+}