How to detect where data is lost when multithreading is used - c

Question

I have a program that enables multiple threads to insert entries into a hashtable and retrieve them. The hashtable itself is a very simple implementation with a struct defining each bucket entry and a table (array) to hold each bucket. I'm very to new to concurrency and multithreading, but I think that in order to avoid data from being lost in the table during insert and read operations, some kind of synchronization (in the form of something like mutex locking) needs to be added to avoid preemption on one process's data operation by another's.
In practice though, I'm not really sure how to tell where a process could be preempted in either a data read or write operation on the hashtable and where exactly locks should be placed to avoid such problems as well as dead locks. As per this website, for the hashtable insert method, I added a mutex lock before each key gets inserted into the table and unlock it at the end of the function. I essentially do something similar in the function where I'm reading data from the hash table and when I run the code, it seems that the keys are successfully being inserted initially, but the program hangs when the keys are supposed to be retrieved. Here is how I implemented the locking for each function:
// Inserts a key-value pair into the table
void insert(int key, int val) {
pthread_mutex_lock(&lock);
int i = key % NUM_BUCKETS;
bucket_entry *e = (bucket_entry *) malloc(sizeof(bucket_entry));
if (!e) panic("No memory to allocate bucket!");
e->next = table[i];
e->key = key;
e->val = val;
table[i] = e;
pthread_mutex_unlock(&lock);
pthread_exit(NULL);
}
// Retrieves an entry from the hash table by key
// Returns NULL if the key isn't found in the table
bucket_entry * retrieve(int key) {
pthread_mutex_lock(&lock);
bucket_entry *b;
for (b = table[key % NUM_BUCKETS]; b != NULL; b = b->next) {
if (b->key == key) return b;
}
pthread_mutex_unlock(&lock);
pthread_exit(NULL);
return NULL;
}
So the main problems here are:
How to tell where data is being lost between each thread operation
What could cause the program to hang when the keys are being retrieved from the hashtable?

Answer 1

First, you should read more about pthreads. Read also pthreads(7). Notice in particular that every locking call like pthread_mutex_lock should always be later followed by a call to pthread_mutex_unlock on the same mutex (and conventionally you should adopt the discipline that each lock and unlock happens in the same block). Hence your return in the for loop of your retrieve is wrong, you should code:
bucket_entry *
retrieve(int key) {
bucket_entry *res = NULL;
pthread_mutex_lock(&lock);
for (bucket_entry *b = table[key % NUM_BUCKETS];
b != NULL; b = b->next) {
if (b->key == key)
{ res = b; break; };
}
pthread_mutex_unlock(&lock);
return res;
}
Then you could use valgrind and use a recent GCC compiler (e.g. 5.2 in November 2015). Compile with all warnings & debug info (gcc -Wall -Wextra -g -pthread). Read about the sanitizer debugging options, in particular consider using -fsanitize=thread
There are few reasons to call pthread_exit (likewise, you rarely call exit in a program). When you do, the entire current thread will be terminated.