Which is Faster, Fine-grained or Coarse-grained? - locking

Question

I'm the sophomore studying the subject of operating system now.
I would like to compare the fine-grained and coarse-grained by implementing binary search tree and using mutex.
The lock and unlock were used for node insert and delete function, and the execution time was printed.
I thought Fine Grained would be faster. However, even if I change the number, the coarse grained is faster.
Is there anyone who can explain about this? Did I make the wrong code?
Result Page
Result Page 2
int lab2_node_insert_fg(lab2_tree *tree, lab2_node *new_node){
if (tree->root == NULL) {
tree->root = new_node;
return LAB2_ERROR;
}
if (search_key(tree,new_node->key)) {
return LAB2_ERROR;
}
lab2_node* cur = tree->root;
while (1) {
if (cur->key < new_node->key) {
if (cur->right == NULL) {
pthread_mutex_lock(&lock); // LOCK
cur->right = new_node;
pthread_mutex_unlock(&lock); // UNLOCK
return LAB2_SUCCESS;
}
cur = cur->right;
}
else {
if (cur->left == NULL) {
pthread_mutex_lock(&lock); // LOCK
cur->left = new_node;
pthread_mutex_unlock(&lock); // UNLOCK
return LAB2_SUCCESS;
}
cur = cur->left;
}
}
}
int lab2_node_insert_cg(lab2_tree *tree, lab2_node *new_node){
pthread_mutex_lock(&lock); // LOCK
if (tree->root == NULL) {
tree->root = new_node;
pthread_mutex_unlock(&lock); // UNLOCK
return LAB2_ERROR;
}
if (search_key(tree,new_node->key)) {
pthread_mutex_unlock(&lock); // UNLOCK
return LAB2_ERROR;
}
lab2_node* cur = tree->root;
while (1) {
if (cur->key < new_node->key) {
if (cur->right == NULL) {
cur->right = new_node;
pthread_mutex_unlock(&lock); // UNLOCK
return LAB2_SUCCESS;
}
cur = cur->right;
}
else {
if (cur->left == NULL) {
cur->left = new_node;
pthread_mutex_unlock(&lock); // UNLOCK
return LAB2_SUCCESS;
}
cur = cur->left;
}
}
}

Answer 1

I assume that the first snippet is supposed to represent the fine-grained version, the other the coarse-grained version.
The "fine-grained" version is missing a lock for creating the root node. Also, you hold the lock for assigning the new node, you don't do so for the condition. While you iterate the tree, locking a node at a time is insufficient in the presence of concurrent deletes. All of which are concurrency issues.
Usually, the difference between fine-grained and coarse-grained locking is not the "size" of your lock sections (the amount of code you cover with a lock), it refers to the lock granularity in relation to the data structure itself.
So, one approach is to have a single lock for the whole tree - coarse-grained locking. The other approach is to introduce locks at lower levels (e.g. per node) to eliminate lock contention if two operations running in parallel are operating on different tree nodes. This is similar to the difference between table locks and row-level locks in the database space.
One approach for the fine-grained version is to have a per-node lock and use so-called hand-over-hand locking. For the insert operation, you'd have to lock the current node until you identified and locked the next node as you descend.
Do additional research, change your implementation accordingly and retest.
Generally speaking, fine-grained locking can lead to a more scalable implementation if the access pattern tends to hit different locks. If that's not the case most of the time, then a coarse-grained version might perform as good or slightly better because a single lock can be held throughout the operation rather than having to acquire different locks with most of them leading to lock contention again. As always, it depends on the actual usage pattern.