#include <stdio.h>
#include <sys/types.h>
#include <pthread.h>
#include <sys/time.h>
#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#define MAX_THREAD 1000
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
typedef struct {
	int id;
} parm;
#define failed() printf("Errr... That shouldn't happen! Exiting...\n"); exit(1);
static int x=0;
void thread_delay(int millisec){
int i;
for(i = 0; i < (millisec / 10);i++){
usleep(8200);  // Assume next thread will take alittle time
sched_yield();
}
}
void *runth(void *arg)
{       pthread_mutex_lock(&mutex);
        x++;
        pthread_mutex_unlock(&mutex);
        pthread_yield(0);
}

int main(int argc, char* argv[]) {
	int n,i;
	pthread_t *threads;
	pthread_attr_t pthread_custom_attr;
	parm *p;
        size_t stack;

	if (argc != 2)
	{
		printf ("Usage: %s n\n  where n is no. of threads\n",argv[0]);
		exit(1);
	}

	n=atoi(argv[1]);

	if ((n < 1) || (n > MAX_THREAD))
	{
		printf ("The no of thread should between 1 and %d.\n",MAX_THREAD);
		exit(1);
	}
        stack = 0xFFFF;
	threads=(pthread_t *)malloc(n*sizeof(*threads));
	if(threads == NULL){failed();}
	pthread_attr_init(&pthread_custom_attr);
        pthread_attr_setstacksize(&pthread_custom_attr, stack); 
	p=(parm *)malloc(sizeof(parm)*n);
	if(p == NULL){failed();}
	
	/* Start up thread */

	for (i=0; i<n; i++)
	{
		p[i].id=i;
		pthread_create(&threads[i], &pthread_custom_attr, runth, (void *)(p+i));
	}

	while(1){
        pthread_mutex_lock(&mutex);
        printf("%d	", x);
        pthread_mutex_unlock(&mutex);
        thread_delay(1500);
}
        /* - Never reached but OS should handle it - */
	free(p);
	return 0;
}

#define  _POSIX_C_SOURCE 199309L

#include <stdlib.h>
#include <pthread.h>
#include <stdio.h>

#define   MODE_WAIT   0L
#define   MODE_RUN    1L
#define   MODE_STOP   2L

long      mode    = 0L;
long      started = 0L;
long      running = 0L;
long      changes = 0L;
long      repeats = 0L;
long      current = 0L;

#ifdef LOCKLESS_ATOMICS

static inline long atomic_setl(long *const ptr, long const newvalue)
{
	long oldvalue;

	do {
		oldvalue = __sync_fetch_and_or(ptr, 0);
	} while (!__sync_bool_compare_and_swap(ptr, oldvalue, newvalue));

	return oldvalue;
}

static inline long atomic_getl(long *const ptr)
{
	return __sync_fetch_and_or(ptr, 0);
}

static inline long atomic_addl(long *const ptr, long const value)
{
	return __sync_fetch_and_add(ptr, value);
}

static inline long atomic_subl(long *const ptr, long const value)
{
	return __sync_fetch_and_sub(ptr, value);
}

#else

pthread_mutex_t atomic_lock = PTHREAD_MUTEX_INITIALIZER;

static inline long atomic_setl(long *const ptr, long const newvalue)
{
	long oldvalue;

	pthread_mutex_lock(&atomic_lock);
	oldvalue = *ptr;
	*ptr = newvalue;
	pthread_mutex_unlock(&atomic_lock);

	return oldvalue;
}

static inline long atomic_getl(long *const ptr)
{
	long oldvalue;

	pthread_mutex_lock(&atomic_lock);
	oldvalue = *ptr;
	pthread_mutex_unlock(&atomic_lock);

	return oldvalue;
}

static inline long atomic_addl(long *const ptr, long const value)
{
	long oldvalue;

	pthread_mutex_lock(&atomic_lock);
	oldvalue = *ptr;
	*ptr = oldvalue + value;
	pthread_mutex_unlock(&atomic_lock);

	return oldvalue;
}

static inline long atomic_subl(long *const ptr, long const value)
{
	long oldvalue;

	pthread_mutex_lock(&atomic_lock);
	oldvalue = *ptr;
	*ptr = oldvalue - value;
	pthread_mutex_unlock(&atomic_lock);

	return oldvalue;
}

#endif

void *worker(void *data)
{
	long const	id = (long)data;
	long		old;
	struct timespec t;

	t.tv_sec = 0;
	t.tv_nsec = 10000L; /* 10000 ns = 1/100th of a second */

	atomic_addl(&started, 1L);

	while (atomic_getl(&mode) == MODE_WAIT)
		nanosleep(&t, NULL);

	atomic_addl(&running, 1L);

	while (atomic_getl(&mode) == MODE_RUN) {

		old = atomic_setl(&current, id);
		if (old != id)
			atomic_addl(&changes, 1L);
		else
			atomic_addl(&repeats, 1L);

	};

	atomic_subl(&running, 1L);

	return NULL;
}

int main(int argc, char *argv[])
{
	pthread_t       *thread;
	struct timespec  ts;
	long	         threads, t;
	long		 curr, prev, count;
	char	         dummy;

	if (argc != 2) {
		fprintf(stderr, "Usage: %s number-of-threads\n", argv[0]);
		return 1;
	}

	if (sscanf(argv[1], "%ld %c", &threads, &dummy) != 1) {
		fprintf(stderr, "%s: Invalid number of threads.\n", argv[1]);
		return 1;
	}
	if (threads < 2L) {
		fprintf(stderr, "%s: Number of threads is too small.\n", argv[1]);
		return 1;
	}

	thread = malloc(sizeof(pthread_t) * (size_t)threads);
	if (!thread) {
		fprintf(stderr, "Not enough memory for %ld threads.\n", threads);
		return 1;
	}

	for (t = 0L; t < threads; t++)
		if (pthread_create(&thread[t], NULL, worker, (void *)t)) {
			fprintf(stderr, "Cannot create thread %ld of %ld. Aborted.\n", t+1L, threads);
			return 1;
		}

	ts.tv_sec  = 0;
	ts.tv_nsec = 10000L; /* 10000 ns = 1/100th of a second */

	printf("Waiting for all threads to start .. ");
	fflush(stdout);

	while (atomic_getl(&started) < threads)
		nanosleep(&ts, NULL);

	printf("okay.\nRacing:\n");
	fflush(stdout);

	atomic_setl(&mode, MODE_RUN);

	curr = -1L;
	do {
		prev = curr;
		curr = atomic_getl(&current) + 1L;
		count = atomic_getl(&changes);
		if (curr != prev && count > 0L) {
			printf("%9ld. %ld\n", count, curr);
			fflush(stdout);
		}
	} while (count < 1000L && count < 2L * threads);

	atomic_setl(&mode, MODE_STOP);

	printf("Waiting for all threads to exit.. ");
	fflush(stdout);

	for (t = 0L; t < threads; t++)
		pthread_join(thread[t], NULL);

	printf("Done.\n\nThread statistics:\n");
	printf("%9ld threads started\n", started);
	printf("%9ld owner changes\n", changes);
	printf("%9ld owner repeats\n\n", repeats);

	free(thread);
	return 0;
}

#define MAX_THREAD 1000
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
typedef struct {
	int id;
} parm;
#define failed() printf("Errr... That shouldn't happen! Exiting...\n"); exit(1);
static int x=0;
void thread_delay(int millisec){
int i;
for(i = 0; i < (millisec / 10);i++){
usleep(7500); 
//sched_yield();
}
}
void *runth(void *arg)
{       pthread_mutex_lock(&mutex);
        x++;
        pthread_mutex_unlock(&mutex);
        //pthread_yield(0);
	thread_delay(5);
}

int main(int argc, char* argv[]) {
	int n,i;
	pthread_t *threads;
	pthread_attr_t pthread_custom_attr;
	parm *p;
        size_t stack;

	if (argc != 2)
	{
		printf ("Usage: %s n\n  where n is no. of threads\n",argv[0]);
		exit(1);
	}

	n=atoi(argv[1]);

	if ((n < 1) || (n > MAX_THREAD))
	{
		printf ("The no of thread should between 1 and %d.\n",MAX_THREAD);
		exit(1);
	}
        stack = 0xFFFF;
	threads=(pthread_t *)malloc(n*sizeof(*threads));
	if(threads == NULL){failed();}
	pthread_attr_init(&pthread_custom_attr);
        pthread_attr_setstacksize(&pthread_custom_attr, stack); 
	p=(parm *)malloc(sizeof(parm)*n);
	if(p == NULL){failed();}
	
	/* Start up thread */

	for (i=0; i<n; i++)
	{
		p[i].id=i;
		pthread_create(&threads[i], &pthread_custom_attr, runth, (void *)(p+i));
	}

	while(1){
        pthread_mutex_lock(&mutex);
        printf("%d	", x);
	fflush(stdout);
        pthread_mutex_unlock(&mutex);
        thread_delay(1500);
}
        /* - Never reached but OS should handle it - */
	free(p);
	return 0;
}

void *runth(void *arg)
{
        int i;

        for (i = 0; i < 100; i++) {
                pthread_mutex_lock(&mutex);
                x++;
                pthread_mutex_unlock(&mutex);
                thread_delay(5);
        }
}

#include <stdint.h>

/* ANSI C has no "static inline", so use "static" instead. */
#ifdef  __STRICT_ANSI__
#define   STATIC_INLINE  static
#else
#define   STATIC_INLINE  static inline
#endif

struct word64 {
    union {
        double    d;
        uint64_t  u;
        int64_t   i;
    }             type;
};

STATIC_INLINE double atomic_addd(double *const variable, double const value)
{
    struct word64 *const ptr = (struct word64 *)variable;
    struct word64        old, tmp;

    do {
        old.type.i = __sync_fetch_and_or(&(ptr->type.i), (int64_t)0);
        tmp.type.d = old.type.d + value;
    } while (!__sync_bool_compare_and_swap(&(ptr->type.i), &(old.type.i), &(tmp.type.i)));

    return tmp.type.d;
}