Binary semaphore to maintain concurrency

I'll get to the code in a bit that proves you had a race condition. I'll add a couple of different ways to trigger it so you can see how this works. I'm doing this on Linux and passing -std=gnu99 as a param to gcc ie

gcc -Wall -pedantic -lpthread -std=gnu99 semaphore.c -o semtex

Note. In your original example (assuming Linux) one fatal mistake you had was not removing the semaphore. If you run the following command you might see some of these sitting around on your machine

ls -la /dev/shm/sem.*

You need to make sure that there are no old semaphore sitting on the filesystem before running your program or you end up picking up the last settings from the old semaphore. You need to use sem_unlink to clean up.

To run it please use the following.

rm /dev/shm/sem.semtex;./semtex

I'm deliberately making sure that the semaphore is not there before running because if you have a DEADLOCK it can be left around and that causes all sorts of problems when testing.

Now, when I opened the sempahore, I made the count 3. I was expecting that this wouldn't work, and I would get race condition, because each thread is now capable of decrementing the count.

You had a race condition but sometimes C is so damned fast things can appear to work because your program can get everything it needs done in the time the OS has allocated to the thread ie the OS didn't preempt it at an important point.

This is one of those cases, the race condition is there you just need to squint a little bit to see it. In the following code you can tweak some parameters to see the a deadlock, correct usage and Undefined Behavior.

#define INITIAL_SEMAPHORE_VALUE CORRECT

The value INITIAL_SEMAPHORE_VALUE can take three values...

#define DEADLOCK  0
#define CORRECT   1
#define INCORRECT 2

I hope they're self explanatory. You can also use two methods to cause the race condition to blow up the program.

#define METHOD sleep

Set the METHOD to spin and you can play with the SPIN_COUNT and find out how many times the loop can run before you actually see a problem, this is C, it can get a lot done before it gets preempted. The code has most of the rest of the information you need in it.

#include <assert.h>
#include <errno.h>
#include <fcntl.h>
#include <pthread.h>
#include <semaphore.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h> 
#include <unistd.h>
#define DEADLOCK  0 // DEADLOCK
#define CORRECT   1 // CORRECT
#define INCORRECT 2 // INCORRECT
/*
 * Change the following values to observe what happen.
 */
#define INITIAL_SEMAPHORE_VALUE CORRECT
//The next value provides to two different ways to trigger the problem, one
//using a tight loop and the other using a system call.
#define METHOD sleep

#if (METHOD == spin)
/* You need to increase the SPIN_COUNT to a value that's big enough that the
 * kernel preempts the thread to see it fail. The value set here worked for me 
 * in a VM but might not work for you, tweak it. */
#define SPIN_COUNT 1000000
#else 
/* The reason we can use such a small time for USLEEP is because we're making
 * the kernel preempt the thread by using a system call.*/
#define USLEEP_TIME 1
#endif
#define TOT_THREADS 10

static int g = 0;
static int ret = 1729;
sem_t *semaphore;

void *myThreadFun(void *vargp) {
  int myid = (int)vargp;
  int w = 0;
  static int s = 0;
  if((w = sem_wait(semaphore)) != 0) {
    fprintf(stderr, "Error: %s\n", strerror(errno));
    abort();
  };
/* This is the interesting part... Between updating `s` and `g` we add
 * a delay using one of two methods. */
  s++;
#if ( METHOD == spin )
  int spin = 0;
  while(spin < SPIN_COUNT) {
    spin++;
  }
#else
  usleep(USLEEP_TIME);
#endif
g++;
  if(s != g) {
    fprintf(stderr, "Fatal Error: s != g in thread: %d, s: %d, g: %d\n", myid, s, g);
    abort();
  } 
  printf("Thread ID: %d, Static: %d, Global: %d\n", myid, s, g);
  // It's a false sense of security if you think the assert will fail on a race
  // condition when you get the params to sem_open wrong It might not be
  // detected.
  assert(s == g);
  if((w = sem_post(semaphore)) != 0) {
    fprintf(stderr, "Error: %s\n", strerror(errno));
    abort();
  };
  return &ret;
} 

int main(void){
  int i;
  void *status;
  const char *semaphore_name = "semtex";
  pthread_t tids[TOT_THREADS];
  if((semaphore = sem_open(semaphore_name, O_CREAT, 0644, INITIAL_SEMAPHORE_VALUE)) == SEM_FAILED) {
    fprintf(stderr, "Fatal Error: %s\n", strerror(errno));
    abort();
  }
  for (i = 0; i < TOT_THREADS; i++) {
    pthread_create(&tids[i], NULL, myThreadFun, (void *) (intptr_t) i);
  }
  for (i = 0; i < TOT_THREADS; i++) {
    pthread_join(tids[i], &status);
    assert(*(int*)status == 1729);
  }
  /*The following line was missing from your original code*/
  sem_unlink(semaphore_name);
  pthread_exit(0);
}