Archive

Posts Tagged ‘pthreads’

Learning Pthreads

February 17th, 2009 Comments off

I am beginning to enjoy the Prepare Future program on Linux internal and   driver development. Today’s class was about pthreads. I had some prior experience on pthreads library while at CUSAT.   It was refreshed today.

Pthreads is a user space library for  manipulating threads.

Here is what we did today.  First we wrote a small program which created a thread.

It is here.

#include<stdio.h>
#include <sys/types.h>
#include <pthread.h>

void * thread_function ( void *arg)
{
printf(“In Thread\n”);
pthread_exit(“Success”);
}

int main()
{
pthread_t tid;
void * ret_status;
pthread_create( &tid,NULL, &thread_function,NULL);

printf(“In Main\n”);

pthread_join(tid ,&ret_status);

return (0);

}

For compiling this I used.

$gcc -D_REENTRANT -o pt1 pt1.c -l pthread

Then  i tried out   semaphore and mutex in pthread library.

The important semaphore operations are

sem_init  –   int sem_init(sem_t *sem, int pshared, unsigned int value);

sem_ wait    int sem_wait(sem_t *sem);

sem_post         int sem_post(sem_t *sem);

sem_destroy   int sem_destroy(sem_t *sem);

I was forced to RTFM the manual. 😀

I wrote this then.

#include<stdio.h>
#include <sys/types.h>
#include <pthread.h>
#include <semaphore.h>

int y=0;
sem_t sigsem;

void * thread1 ( void *arg)
{
int x;
sem_wait(&sigsem);

x=y+3;

printf(“In Thread1\n”);
printf(” x is %d\n”,x);

pthread_exit(“Success thread1 “);
}

void * thread2 ( void *arg)
{
y=45;
sem_post(&sigsem);
printf(“In Thread2\n”);
printf(” y is %d\n”,y);
pthread_exit(“Success thread2”);
}

int main()
{
pthread_t tid1,tid2;
void * ret_status;

sem_init( &sigsem,0,0);

pthread_create( &tid1,NULL, &thread1,NULL);
pthread_create( &tid2,NULL, &thread2,NULL);
printf(“In Main\n”);

pthread_join(tid1 ,&ret_status);
pthread_join(tid2 ,&ret_status);

sem_destroy(&sigsem);

return (0);

}
This was followed by producer consumer problem as below.

#include<stdio.h>
#include <sys/types.h>
#include <pthread.h>

//sem_t sigsem;
int buffer[10];

void * producer ( void *arg)
{
int i,index;
index=0;

for (i =0;i<40 ;++i)
{

printf(“Producer  trying to produce an item……….\n”);

buffer[index] =i;

printf (“producer put  %d  at buffer [%d]\n”, i,index);

index++;
if (index==10)
index=0;
}

pthread_exit(“Producer ends”);
}

void * consumer ( void *arg)
{
int i,index=0;
for (i=0;i<40;++i)
{
printf(” Consumer  trying to consume  an item ……….\n”);
printf ( ” Consumer ate  %d from buffer[%d]\n”, buffer [index] ,index);

index++;
if (index==10)
index=0;
}

pthread_exit(“Consumer ends”);
}

int main()
{
pthread_t tid1,tid2;
void * ret_status;
pthread_create( &tid1,NULL, &producer,NULL);
pthread_create( &tid2,NULL, &consumer,NULL);

pthread_join(tid1 ,&ret_status);
pthread_join(tid2 ,&ret_status);

return (0);

}
The mutex in it  was then rewritten with pthread_mutex functions. Again lot of RTFM.

Then as an assignment we did the readers and writers problem.

#include<stdio.h>
#include <sys/types.h>
#include <pthread.h>
#include <semaphore.h>

sem_t  mutex,rcmutex;
int reader_count=0;
int buffer=10;

void reader_action(int r )
{

printf ( “\nReader %d  buffer is %d “,r, buffer);
}

void  write_action (int i)
{
int j;
buffer+=10;
for (j=0;j<10;++j) ; //Waste some time

printf ( “\n Writing for %d time buffer is %d “,i, buffer);

}

void * reader1 ( void *arg)
{

sem_wait(&rcmutex);
reader_count++;
if(reader_count==1)
sem_wait(&mutex);
sem_post(&rcmutex);

reader_action(1);

sem_wait(&rcmutex);

reader_count–;
if ( reader_count==0)
sem_post(&mutex);

sem_post(&rcmutex);

pthread_exit(“Success reader1 “);
}

void * reader2 ( void *arg)
{

sem_wait(&rcmutex);
reader_count++;
if(reader_count==1)
sem_wait(&mutex);
sem_post(&rcmutex);

reader_action(2);

sem_wait(&rcmutex);

reader_count–;
if ( reader_count==0)
sem_post(&mutex);

sem_post(&rcmutex);

pthread_exit(“Success reader2 “);
}

void * writer ( void *arg)
{
int i;
for (i=0 ; i<10;++i)
{

sem_wait (&mutex);
write_action(i);
sem_post(&mutex);
}
pthread_exit(“Success writer”);
}

int main()
{
pthread_t tid1,tid2,tid3,tid4,tid5,tid6;
void * ret_status;

sem_init( &mutex,0,1);
sem_init( &rcmutex,0,1);

pthread_create( &tid1,NULL, &reader1,NULL);
pthread_create( &tid2,NULL, &writer,NULL);
pthread_create( &tid3,NULL, &reader2,NULL);
pthread_create( &tid4,NULL, &reader1,NULL);
pthread_create( &tid5,NULL, &reader2,NULL);
pthread_create( &tid6,NULL, &reader1,NULL);

pthread_join(tid1 , &ret_status);
pthread_join(tid2 ,&ret_status);
pthread_join(tid3 ,&ret_status);
pthread_join(tid4 , &ret_status);
pthread_join(tid5 , &ret_status);
pthread_join(tid6 , &ret_status);

sem_destroy(&mutex);
sem_destroy(&rcmutex);
return (0);

}
The course is progressing smoothly. and looks interesting several fellow participants are also stimulating.

I forgot to take the card reader, so I am unable to post photos.  I had a walk around the JNTU campus in the morning and took several photos. May be I will beautify these blog enties with  photos and proper code snippets ( and build   proper pthread tutorial)   when I return.