Thread Prog in C language (seg fault)

Could anyone please help me in finding out the reason behind segmentation fault. This program is working fine as long as the command line input is as follows:

./test -r 300 -w 3 -s 100 (gives desired o/p)
./test -r 100 -w 3 -s 200 (gives desired o/p)
./test -r 10 -w 3 -s 10 (gives desired o/p)

But at the same time this program fails the moment I am trying to give following command line input


./test -r 3 -w 4 -s 100 (seg fault)
./test -r 1 -w 4 -s 10 (seg fault)

I have tried my level best to resolve this and to find out the reason behind failing. But could not able to find the solution. While using dbx I came to know the point where it's failing but unfortunately I don't know how to resolve it.


I have mentioned the dbx output below to have a look at it and it may save your time to help me in solving this problem.

midibm14:subh:/home/users/subh/demo #dbx test
Type 'help' for help.
reading symbolic information ...
(dbx) stop in main
[1] stop in main
(dbx) r -r 300 -w 3 -s 100
[1] stopped in main at line 14 ($t1)
14 parse_args(argc, argv);
(dbx) c
test: Shared Memory Test Program

Number of writers thread = 3
Number of readers thread = 300
Shared Memory Size in Bytes = 100


execution completed
(dbx) q
midibm14:subh:/home/users/subh/demo #dbx test
Type 'help' for help.
reading symbolic information ...
(dbx) stop in main
[1] stop in main
(dbx) r -r 1 -w 4 -s 100
[1] stopped in main at line 14 ($t1)
14 parse_args(argc, argv);
(dbx) cont
test: Shared Memory Test Program

Number of writers thread = 4
Number of readers thread = 1
Shared Memory Size in Bytes = 100

Shmat Failed Here *** : Shared Memory Attach Error : Too many open files

execution completed
(dbx)

It's failing when I tried to increase the "-w option" in the 2nd execution.

Let me summarise the problem once again. I can run this program with the writer thread ("-w option") less than or equal to 3. But I can't run this program with the writer thread ("-w option") 4 or more.

May I request you to look into the problem and please provide me the solution.

Code:

---


/*********************************************/
/****************** head.h *********************/
/*********************************************/
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/limits.h>
#include <sys/signal.h>


/********************* User Defined Data ***************/

#define MAX_THREAD_NUMBER      30000
#define MAX_WRITER_NUMBER      100
#define MAX_READER_NUMBER      999
#define DEFAULT_NUM_READERS    2
#define DEFAULT_NUM_WRITERS    2
#define SHMEM_MODE              (SHM_R | SHM_W)
/*#define DEFAULT_SHMEM_SIZE    2000000000*/
#define DEFAULT_SHMEM_SIZE      200
#define MB                      (1024*1024)
#define MAX_SHMEM_NUMBER        100




#define USAGE  "\nUsage: %s [-r num_readers] [-w num_writers] [-s shmem_size]\n
\n" \
                "\t-r num_readers  number of reader thread to create\n" \
                "\t-w num_writers  number of writer thread to create\n" \
                "\t-s buffer_size  size of shmem segments in bytes\n"  \
                "\t                must be less than 256MB\n\n"



/************ Global Functions ****************/

void parse_args(int , char **);
void *reader(void *);
void *writer(void *);
void error(const char *, int);
void release();
/*int sys_error(const char *, int);*/


/************ Global Variables ****************/

pthread_t *writer_th;
pthread_t *reader_th;


int              thread_hold[MAX_WRITER_NUMBER];
pthread_mutex_t  cond_mutex[MAX_WRITER_NUMBER];
pthread_mutex_t  mutex_r[MAX_WRITER_NUMBER];
pthread_cond_t  cond_var[MAX_WRITER_NUMBER];


int          *read_count[MAX_WRITER_NUMBER];
char          *shmptr[MAX_READER_NUMBER];
unsigned long *checksum[MAX_WRITER_NUMBER];
unsigned long cksum[MAX_WRITER_NUMBER];


int      shmem_size = DEFAULT_SHMEM_SIZE;
pid_t    parent_pid;


int      num_readers = DEFAULT_NUM_READERS;
int      buffer_size = DEFAULT_SHMEM_SIZE;
int      num_writers = DEFAULT_NUM_WRITERS;
int      shmid[MAX_THREAD_NUMBER + MAX_WRITER_NUMBER];


/*********************************************/
/****************** test.c *********************/
/*********************************************/


#include "head.h"


int main(int argc, char **argv)
{
        pthread_attr_t  newattr;

        int    i, j, k;
        size_t Size;

        unsigned long *ulptr;


        parse_args(argc, argv);


        printf("%s: Shared Memory Test Program\n\n", *argv);

        printf("\tNumber of  writers thread  = %d\n", num_writers);
        printf("\tNumber of  readers thread  = %d\n", num_readers);
        printf("\tShared Memory Size in Bytes = %d\n", buffer_size);
        printf("\n");



        for(i = 0; i < num_writers; i++) {
        j = i * 3;

        Size = sizeof(int);

        if((shmid[j] = shmget(IPC_PRIVATE, Size, SHMEM_MODE)) < 0)
                perror("Shmget Error");


        if((long)(read_count[i] = (int *) shmat(shmid[j], 0, 0)) == -1)
                perror("Shmat Error");


        *(read_count[i]) = 0;
        j++;
        Size = sizeof(unsigned long) * num_readers;

        if((shmid[j] = shmget(IPC_PRIVATE, Size, SHMEM_MODE)) < 0)
                perror("Checksum Shmget Failed");


        if((long)(checksum[i] = (unsigned long *) \
                                        shmat(shmid[j], 0, 0)) == -1)
                perror("Shmat : Shared Memory Attach Error ");


        ulptr = checksum[i];

        for(k = 0; k < num_readers; k++)
        {
                *ulptr = 0;
                ulptr++;
        }

        Size = buffer_size;
        j++;

        if((shmid[j] = shmget(IPC_PRIVATE, Size, SHMEM_MODE)) < 0)
                perror("Shmptr Shmget Failed");


        if((long)(shmptr[i] = shmat(shmid[j], 0, 0)) == -1)
                perror("Shmat Failed Here *** : Shared Memory Attach Error ");

        }

}


void parse_args(int argc, char **argv)
{
        int        i;
        int        errflag = 0;
        char        *program_name = *argv;
        extern char *optarg;


        while((i = getopt(argc, argv, "r:s:w:?")) != EOF) {
                switch (i) {
                        case 'r':
                                num_readers = atoi(optarg);
                                break;
                        case 's':
                                buffer_size = atoi(optarg);
                                break;
                        case 'w':
                                num_writers = atoi(optarg);
                                break;
                        case '?':
                                errflag++;
                                break;
                }
        }

        if(num_writers >= MAX_WRITER_NUMBER) {
                errflag++;
                fprintf(stderr, "ERROR: num_writers must be less\
                                      than %d\n", MAX_WRITER_NUMBER);
        }

        if(num_readers >= MAX_READER_NUMBER) {
                errflag++;
                fprintf(stderr, "ERROR: num_readers must be less\
                                        than %d\n", MAX_READER_NUMBER);
        }

        i = num_readers * num_writers;

        if(i >= MAX_THREAD_NUMBER) {
                errflag++;
                fprintf(stderr, "ERROR: maximun threads number\
                        must be less than %d\n", MAX_THREAD_NUMBER);
        }

        if(errflag) {
                fprintf(stderr, USAGE, program_name);
                exit (2);
        }
}

---

If an error occurs, you're allowing execution to continue. Use this construct instead:

Code:

---

if (error)
{
  perror("error");
  exit(1);
}

---

>> Shared Memory Attach Error : Too many open files
That's EMFILE. When shmat() returns EMFILE "The number of shared memory segments attached to the calling process would exceed the system-imposed limit."

Having an entire shared memory segment for just one int is a bit wasteful. You may want to consider allocating one segment large enough to accommodate all the shared data.

gg

Actually I have sent you a piece of code. Here is the complete program to have a look at it.

I am able to run it successfully

./main -r 300 -w 3 -s 100
./main -r 100 -w 2 -s 100
./main -r 30 -w 3 -s 100


But I am not able to run the program as follows(It gives me the segmentation fault) and the reason is not known to me.

./main -r 1 -w 4 -s 100

I don't know why it fails, if I give "-w option" (4 or more). It works if "-w option" is less than or equal to 3.
It'll be of great help if you can look at the whole program and let me know where I am doing wrong. If possible do also provide me the solution as I gave up and have no clue to solve it.

Code:

---


/****************************************************/
/********************** header.h ********************/
/****************************************************/

#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/signal.h>


/********************* User Defined Data ***************/

#define MAX_THREAD_NUMBER      5000
#define MAX_WRITER_NUMBER      100
#define MAX_READER_NUMBER      400
#define DEFAULT_NUM_READERS    2
#define DEFAULT_NUM_WRITERS    2
#define SHMEM_MODE              (SHM_R | SHM_W)
#define DEFAULT_SHMEM_SIZE      20000
#define MB                      (1024*1024)
#define MAX_SHMEM_NUMBER        11



#define USAGE  "\nUsage: %s [-r num_readers] [-w num_writers] [-s shmem_size]\n
\n" \
                "\t-r num_readers  number of reader thread to create\n" \
                "\t-w num_writers  number of writer thread to create\n" \
                "\t-s buffer_size  size of shmem segments in bytes\n"  \
                "\t                must be less than 256MB\n\n"



/************ Global Functions ****************/

int  parse_args(int , char **);
int *reader(void *);
int *writer(void *);
int  error(const char *, int);
int  release();
/*int sys_error(const char *, int);*/


/************ Global Variables ****************/

pthread_t *writer_th;
pthread_t *reader_th;


int              thread_hold[MAX_WRITER_NUMBER];
pthread_mutex_t  cond_mutex[MAX_WRITER_NUMBER];
pthread_mutex_t  mutex_r[MAX_WRITER_NUMBER];
pthread_cond_t  cond_var[MAX_WRITER_NUMBER];


int          *read_count[MAX_WRITER_NUMBER];
char          *shmptr[MAX_WRITER_NUMBER];
unsigned long *checksum[MAX_WRITER_NUMBER];
unsigned long cksum[MAX_WRITER_NUMBER];


int      shmem_size = DEFAULT_SHMEM_SIZE;
pid_t    parent_pid;


int      num_readers = DEFAULT_NUM_READERS;
int      buffer_size = DEFAULT_SHMEM_SIZE;
int      num_writers = DEFAULT_NUM_WRITERS;
int      shmid[MAX_THREAD_NUMBER + MAX_WRITER_NUMBER];



/****************************************************/
/********************** main.c **********************/
/****************************************************/

#include "header.h"


int main(int argc, char **argv)
{
        pthread_attr_t  newattr;

        int    i, j, k;
        size_t Size;

        unsigned long *ulptr;


        parse_args(argc, argv);


        printf("%s: Shared Memory Test Program\n\n", *argv);

        printf("\tNumber of  writers thread  = %d\n", num_writers);
        printf("\tNumber of  readers thread  = %d\n", num_readers);
        printf("\tShared Memory Size in Bytes = %d\n", buffer_size);
        printf("\n");



        for(i = 0; i < num_writers; i++) {
        j = i * 3;

        Size = sizeof(int);

        if((shmid[j] = shmget(IPC_PRIVATE, Size, SHMEM_MODE)) < 0)
                perror("Shmget Error");


        if((long)(read_count[i] = (int *) shmat(shmid[j], 0, 0)) == -1)
                perror("Shmat Error");


        *(read_count[i]) = 0;
        j++;
        Size = sizeof(unsigned long) * num_readers;

        if((shmid[j] = shmget(IPC_PRIVATE, Size, SHMEM_MODE)) < 0)
                perror("Checksum Shmget Failed");


        if((long)(checksum[i] = (unsigned long *) \
                                        shmat(shmid[j], 0, 0)) == -1)
                perror("Shmat Failed : Shared Memory Attach Error ");


        ulptr = checksum[i];

        for(k = 0; k < num_readers; k++)
        {
                *ulptr = 0;
                ulptr++;
        }

        Size = buffer_size;
        j++;

        if((shmid[j] = shmget(IPC_PRIVATE, Size, SHMEM_MODE)) < 0)
                perror("Shmptr Shmget Failed");


        if((long)(shmptr[i] = shmat(shmid[j], 0, 0)) == -1)
                perror("Shmat Failed Here *** : Shared Memory Attach Error ");

        }


        writer_th = (pthread_t *) malloc((size_t) (num_writers \
                                                  * sizeof(pthread_t)));
        reader_th = (pthread_t *) malloc((size_t) (num_writers \
                                    * num_readers * sizeof(pthread_t)));

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

        if(pthread_mutex_init(&mutex_r[i] , (pthread_mutexattr_t *)NULL) != 0)
                perror("Can't Initialise Mutex");


        if(pthread_mutex_init (&cond_mutex[i], (pthread_mutexattr_t *)NULL)!=0)
                perror("Can't Initialize Cond_Mutex");


        if(pthread_cond_init (&cond_var[i], (pthread_condattr_t *)NULL)!=0)
                perror("Cond_Var Failed");


        thread_hold[i] = 1;
        }
        if(pthread_attr_init(&newattr))
              perror("Attr_Init Failed");


        if(pthread_attr_setdetachstate(&newattr, PTHREAD_CREATE_UNDETACHED))
                perror("Attr_Setdetachstate Failed");



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


                if(pthread_create(&writer_th[i], &newattr, writer, \
                                                        (void *) (long)i))
                        perror("Writer Failed");

                k = i * num_readers;


                for(j = k; j < (k + num_readers) ; j++)
                {
                        if(pthread_create(&reader_th[j], &newattr, reader,\
                                                        (void *) (long)j))

                        perror("Reader Failed");
                }
        }


        for(i = 0; i < num_writers; i++)
        {
              if(pthread_join(writer_th[i], NULL)) {
                        printf("writer_th: pthread_join return: %d\n",i);

                        perror("Pthread_join Bad Status");
                }

                k = i * num_readers;


                for(j = k; j < (k + num_readers) ; j++)
                {
                        if(pthread_join(reader_th[j], NULL)) {
                        perror("Pthread_join Bad Status");
                        }
                }
        }

        for(i = 0; i < num_writers; i++)
        {
                ulptr = checksum[i];
                for(j = 0; j < num_readers; j++) {

                        if(cksum[i] != *ulptr )
                                error("checksums do not match", __LINE__);

                }
        }


        printf("\n\tMain: Readers calculated segment successfully\n");

        release();
        printf("\nsuccessful!\n");

        return(0);
}


/****************************************************/
/******************** reader.c **********************/
/****************************************************/

#include "header.h"



void *reader(void *parm)
{
        int num_p = (int) (long)parm;
        unsigned long cksum_r = 0;
        int    i, num_r, num_w;
        char    *ptr;
        unsigned long *ulptr_r;


        num_r = num_p % num_readers;
        num_w = num_p - num_r;
        num_w = num_w / num_readers;
        ptr = shmptr[num_w];
        ulptr_r = checksum[num_w];

        if(pthread_mutex_lock (&cond_mutex[num_w]))
                perror("Can't Take Cond Lock");

        while(thread_hold[num_w])
        {
                if(pthread_cond_wait(&cond_var[num_w], &cond_mutex[num_w]))
                        perror("cond_wait failed");
        }
        if(pthread_mutex_unlock(&cond_mutex[num_w]))
                perror("Release cond Lock Failed");

        if(pthread_mutex_lock(&mutex_r[num_w]))
                perror("Can't take read Lock");

        (*(read_count [num_w]))++;

        if(pthread_mutex_unlock(&mutex_r[num_w]))
                perror("Can't Release Read Lock");

        for(i = 0; i < buffer_size; i++)
                cksum_r += *ptr++;

        if(pthread_mutex_lock(&mutex_r[num_w]))
                perror("Can't Take Read Lock");

        (*(read_count[num_w]))--;

        if(pthread_mutex_unlock(&mutex_r[num_w]))
                perror("Can't Release 1 Read Lock");


        *ulptr_r = cksum_r;

        printf("\tReader (%d) of Writer (%d): checksum %04ld\n",\
                                                num_r,num_w,cksum_r);

        return NULL;
}


/****************************************************/
/******************** writer.c **********************/
/****************************************************/


#include "header.h"



void *writer(void *parm)
{
        int num_w = (int) (long)parm;
        unsigned long cksum_w = 0;
        char  data = 0;
        char  *ptr;
        int count = 0;


        data = num_w;

        for(ptr = shmptr[num_w]; ptr < (shmptr[num_w]+buffer_size); ptr++) {
                *ptr = data++;
                cksum_w += *ptr;

        }

        /*perror("Writer: Writer failed here 0: ");*/

        if(pthread_mutex_lock(&cond_mutex[num_w]))
                perror("Mutex_lock Failed");


        thread_hold[num_w] = 0;


        if(pthread_cond_broadcast(&cond_var[num_w]))
                perror("cond_signal Failed");


        if(pthread_mutex_unlock(&cond_mutex[num_w]))
                perror("Mutex_unlock Failed");



        cksum[num_w] = cksum_w;
        printf("\n\tWriter (%d): shared memory checksum %04ld\n", \
                                                        num_w, cksum_w);


        return NULL;
}


/****************************************************/
/******************** parseargs.c *******************/
/****************************************************/

#include "header.h"


int parse_args(int argc, char **argv)
{
        int        i;
        int        errflag = 0;
        char        *program_name = *argv;
        extern char *optarg;


        while((i = getopt(argc, argv, "r:s:w:?")) != EOF) {
                switch (i) {
                        case 'r':
                                num_readers = atoi(optarg);
                                break;
                        case 's':
                                buffer_size = atoi(optarg);
                                break;
                        case 'w':
                                num_writers = atoi(optarg);
                                break;
                        case '?':
                                errflag++;
                                break;
                }
        }
        if(num_writers >= MAX_WRITER_NUMBER) {
                errflag++;
                fprintf(stderr, "ERROR: num_writers must be less\
                                      than %d\n", MAX_WRITER_NUMBER);
        }
        if(num_readers >= MAX_READER_NUMBER) {
                errflag++;
                fprintf(stderr, "ERROR: num_readers must be less\
                                        than %d\n", MAX_READER_NUMBER);
        }
        i = num_readers * num_writers;

        if(i >= MAX_THREAD_NUMBER) {
                errflag++;
                fprintf(stderr, "ERROR: maximun threads number\
                        must be less than %d\n", MAX_THREAD_NUMBER);
        }

        if(errflag) {
                fprintf(stderr, USAGE, program_name);
                exit (2);
        }
}


int release()
{
        int i, j;

        for(i = 0; i < num_writers; i++) {
        if(pthread_mutex_destroy(&cond_mutex[i]) != 0)
                perror("Can't destroy cond_mutex");

        if(pthread_mutex_destroy(&mutex_r[i]) != 0)
                perror("Can't destroy mutex_r");
        }


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

        j = i * 3;
        if(shmctl(shmid[j], IPC_RMID, 0) < 0)
                perror("Read_count shmctl Failed");
        j++;
        if(shmctl(shmid[j], IPC_RMID, 0) < 0)
                perror("checksum shmctl failed");
        j++;
        if(shmctl(shmid[j], IPC_RMID, 0) < 0)
                perror("shmptr shmctl failed");

        }
}



int sys_error(const char *msg, int line)
{
        char syserr_msg [256];

        sprintf(syserr_msg, "%s: %s\n", msg, strerror (errno));
        error(syserr_msg, line);
}

int error(const char *msg, int line)
{
        fprintf(stderr, "ERROR [line: %d] %s\n", line, msg);
        if(line>= 260)
        release();
        exit(-1);
}

---

Quote:

---

Originally Posted by Codeplug

If an error occurs, you're allowing execution to continue. Use this construct instead:

Code:

---

if (error)
{
  perror("error");
  exit(1);
}

---

>> Shared Memory Attach Error : Too many open files
That's EMFILE. When shmat() returns EMFILE "The number of shared memory segments attached to the calling process would exceed the system-imposed limit."

Having an entire shared memory segment for just one int is a bit wasteful. You may want to consider allocating one segment large enough to accommodate all the shared data.

gg

---

Assuming the error is still the same, my answer is still the same.

gg

This code:

Code:

---

if(pthread_attr_setdetachstate(&newattr, PTHREAD_CREATE_UNDETACHED))
                perror("Attr_Setdetachstate Failed");

---

doesn't even compile, as there's no PTHREAD_CREATE_UNDETACHED defined.

You certainly don't want to create detached threads, as you're attempting to join them later...if I make this PTHREAD_CREATE_JOINABLE, I get no seg fault.

PTHREAD_CREATE_UNDETACHED is a non-standard name for PTHREAD_CREATE_JOINABLE. The latter should be preferred.

Since you're not creating any new processes, there's no point in using shared memory. Use memory from malloc instead.

>> I get no seg fault
Set your maximum number of shared segments per process to 3, then you should reproduce the error. This is typically referred to as the "SHMSEG" kernel parameter. Here's some info on how to set this for a few systems: http://vista.intersystems.com/csp/do...ixparms_kernel

gg

Thanks for pointing me towards right direction. The piece of code "PTHREAD_CREATE_UNDETACHED" I'll change it to "PTHREAD_CREATE_JOINABLE". But as far as I remember once I have commented these lines of code and tried to execute the program, but I have got the same run time error(segV). I'll check and re-confirm it.

My intention behind creating shared memory is that I'll access it from different part of the programs, now I am just trying to develop a "demo", if I am able to run it successfully then later will implement the same thing in my ongoing project (which is part of the requirement, and hence I have to stick with shared memory).

If you'll see in the program I am trying to create 3 shared memory segment for each writer thread ("-w writer thread") and these are as follows:

a) read_count[i] ==> to store the read count

b) checksum[i] ====> to store the checksums of reader threads

c) shmptr[i] =====> for storing the series of values

When I am doing this for 3 writer threads ( each writer threads has 3 shared segment), this is fine and the program executes perfectly. But when I am trying to create 12 shared segments for 4 diff writers thread ( per writer 3 segment again), it fails, I don't know why.....!!!!

I told you why in the second post...

shmat() fails and returns -1.
You call perror() and continue on as if no error occurred, eventually using a bad pointer.
shmat() fails due to error "EMFILE", which means "The number of shared memory segments attached to the calling process would exceed the system-imposed limit."

So it appears that the system is limiting your process to a maximum of 11 shared memory segments.

gg

I have changed few lines as you've suggested and the changes which I made are as follows:

a) if(pthread_attr_setdetachstate(&newattr, PTHREAD_CREATE_JOINABLE))
changed above line from "UNDETACHED" to "JOINABLE".

b) define MAX_SHMEM_NUMBER 100
changed it from 11 to 100.

But still I am getting the same error and the debug o/p is as follows:

(dbx) stop in main
[1] stop in main
(dbx) r -r 3 -w 4 -s 100
[1] stopped in main at line 15 in file "main.c" ($t1)
15 parse_args(argc, argv);
(dbx) c
main: Shared Memory Test Program

Number of writers thread = 4
Number of readers thread = 3
Shared Memory Size in Bytes = 100

Shmat Failed Here *** : Shared Memory Attach Error : Too many open files

Segmentation fault in reader at line 42 in file "reader.c" ($t15)
42 cksum_r += *ptr++;(dbx)


Any clue on "Segmentation fault in reader at line 42 in file "reader.c""
Why it's giving the seg fault in "cksum_r += *ptr++;"

When I have used the exit in my code, it terminates the further execution and exits here:

if((long)(shmptr[i] = shmat(shmid[j], 0, 0)) == -1)
perror("Shmat Failed Here *** : Shared Memory Attach Error ");
exit(1);

}

>> Why it's giving the seg fault in "cksum_r += *ptr++;"
Because the value of ptr is -1. Dereferencing the memory at address "-1" is causing the segmentation fault.

gg

could you please let me know how to fix it. I have given up on this.

It works fine when I give the input as follows:

./main -r 300 -w 3 -s 100
./main -r 600 -w 3 -s 1000

(-r option is fine between 1 and 750)

It fails the moment I am giving the input as follows:

./main -r 10 -w 4 -s 100
./main -r 1 -w 4 -s 100

(I can't give 4 or more for -w option)

I am really helpless, would request you to give me some solution for this.

Without changing the code, all you can do is ask the system administrator to increase the number of allowed per-process shared memory segments.

>> would request you to give me some solution for this
As I mentioned in the 2nd post, this can be fixed by using a single shared memory segment for all shared data. That means you call shmget() and shmat() only once. Then use that one block of shared memory for all your needs.

gg

I am not sure, but what I believe is that for each writer I am creating 3 shared memory segments.

like for each writer I am creating

Code:

---

for(i = 0; i < num_writers; i++) {
   
        read_count[i] ===> shmget() and shmat()
        checksum[i]    ===> shmget() and shmat()
        shmptr[i]        ===> shmget() and shmat()
}

---

This works fine when num_writers is 3 but it fails when num_writers is 4 or more. Anyway will try other way also as you suggested (will create only 1 segment).

Dear All,

Any Clue on this... I am trying to implement the features (mentioned below) in the code which is already posted in previous message.

Imagining that there are four threads - 2 writers and 2 readers and we have one shared memory segment with one block in it.

All threads are contending for the same block of shared memory.
The Writers will write just one message each and the readers will attempt to read, process and respond.

A typical run would look like this :-

1.Writer 1 & Writer 2 read in a unique buffer from two different files and store these in malloced blocks of memory.

2. Writer 1 contends for the shared memory segment with the other 3 threads and if he get it - locks the segment.

3. Writer 1 writes the message to the segment along with a header defining the length of the buffer he has written,his thread ID, and a flag showing it is an 'inbound' operation and then appends the buffer he has read from file.
He then unlocks the segment. And immediately starts polling to get back a response.

4. Reader 1 or Reader 2 contend to read from shared memory. Reader 1 wins the race and locks the block

5. Reader 1 reads in the buffer, parses the header to make sure it is a 'inbound' request,

IF it is a 'inbound' requests he reads in the message as defined by length field in the header then xors the buffer or rot13's the buffer and moves to point 6.

ELSE He unlocks the buffer because it's not an inbound request.

6. Reader 1 then clears that block of shared memory and writes back a header which has in it
The threadid of the sender, the length of the xor'd or rot13'd buffer and a flag indicating it is a 'outbound' operation.
He the writes the buffer onto the back of this and unlocks the shared memory block.

7. Writer 1 is polling for a response. He wins the race with the other 3 threads and locks the block.
He peaks into the shared memory and reads the header.
IF the operation is 'outbound' i.e from a reader thread and the threadid is his then he moves to point 8.
ELSE he unlocks the blocks because it is not a response for him and or it is an 'inbound' request from Writer 2.

8. Writer 1 xors or rot13's the response message and then compares it with the message he sent which he stored in
malloced memory in point 1.
IF it matches he signals success by writing a suitable message to standard out.
IF it doesn't he writes the block to a error file along with the block he sent and exits the process witn a suitable error code and
error message to standard error.

When both writer 1 and writer 2 have written their message, got back a response and check it is correct.

Of course all of this is happening at once. So writer 1 and writer 2 are both trying to lock the blocks and send 'inbound' messages
and readers 1 and readers 2 are simultaneously trying to lock the same block to read from it, process the message and respond.

So what part do you need help with? What have you done so far?

gg

I am able to create multiple threads and a shared memory segment...

Now I want to write into one block of shared memory (need to divide the single shared memory into multiple blocks) as follows:

blockid, threadid, and data.

For example one single block of a shared memory should contain blockid, threadid and data.

where the blockid will be block1, block2, block3 and so on......
threadid will be thread1, thread2, thread3 and so on....
data will be user input data "string format"

Once I am able to write as above, then I should be in a position to read the data from the reader thread by specifying the threadid and blockid and also if the reader threads want to modify the data, so it can modify the data.

On top of it we need to assure that either of the reader thread or writer thread should access any particular block of shared memory at any instance of time, but not both at a time.

I am sending you the code attached along with this post, could you please help me out.....

The easiest thing to do is to create a structure of containing all the shared data for each block. Then use the shared memory as an array of these blocks.

Code:

---

typedef struct 
{
    int block_id;
    int thread_id;
    char data[1024];
} DataBlock;

---

You could also put a pthread_mutex_t in each block and use it to synchronize access to each block. In order to use a pthread mutex in shared memory (by multiple processes), you have to call pthread_mutexattr_setpshared(). This is not supported by all systems. If yours doesn't support it, then you'll have to use a SysV or Posix semaphore instead.

Header files should not contain definitions (declarations that allocate storage). Your header.h has several definitions (the global variables). Each source file that includes that header will get it's own copy of each global (which can result in linker errors). If you want to share a global variable across source files, you put the definition of the global in only one source, then put an extern declaration in the header. For example:
main.c - "int g_global;"
header.h - "extern int g_global;"

gg

Many many thanks to you for providing hints. But I have no idea/clue that how I'll pass this structure to writer thread, and once I am able to pass this structure to writer thread and the writer thread is able to write some data into it, then again how do I pass this structure to reader thread. "setpshared() is supported on AIX also, but I am sorry to say that don't know how to use it.

>> how I'll pass this structure to writer thread, ... how do I pass this structure to reader thread.
The thread functions take a void* parameter, which you give when calling pthread_create. Your code already passes a integer index to the thread functions. You can continue to use that as an index into the DataBlock array.

>> setpshared() is supported on AIX also, but ... don't know how to use it
pthread_mutexattr_init
pthread_mutexattr_setpshared
pthread_mutex_init
Check your man pages. There's example code here: http://www.opengroup.org/onlinepubs/...r_destroy.html

gg

I have created the structure as follows:

Code:

---


typedef sturct
{
        int thread_id;
        int block_id;
        char string[1024];
}DataBlock;

DataBlock *writeparm;

---

But my writer fails, it doesn't return after writing. It stops immediately after writing the data and it doesn't pass control to the reader and stops further execution of the program

"Codeplug"May I have your kind attention please on this. I don't why my writer function is failing.....

One more question I would like to ask on this....

You can continue to use that as an index into the DataBlock array.

When I tried to pass structure variable (DataBlock *writeparm), then I got the compilation error.....

I thought of doing it in differenet way, like passing 2 variable to writer function but that also doesn't work. Right now I am passing one variable in the writer function...

void *writer(void *parm)

I tried this way void *writer(void *parm, char *file), but this gives me lots of lots of error.....

Can we pass 2 variables to writer function, if yes then how can we....

Can you post your "fixed" code. I think you are under-allocated, by the way. But I would need to see the newer code to confirm whether or not you have fixed that problem yet.

I am trying to divide the shared memory into multiple blocks in such a way that

Problem 1:
writer thread1 should write into first block of shared memory and another thread reader thread1 should read and modify the date by referring to a particular block of shared memory

Attempt which I made:

I have created a structure as follows and using that structure pointer trying to write some data into shared memory, and with another structure pointer variable I am trying to read the data. But both the reader and writer failing and the reason is not known to me. Please provide me some input on this

Code:

---

typedef struct{
        int  block_id;
        int  thread_id;
        char  string[1024];
}DataBlock;

DataBlock* writeparm;
DataBlock* readparm;

---

Please see the writer.c file and reader.c file in the attachment.

Problem 2:

I am trying pass one more variable to reader and writer functions in reader and writer file but this also fails, as of now I am passing only one variable to these functions as parameters.

Code:

---

void *reader(void *);
void *writer(void *);

---

What I am trying to attempt:

If I am able to pass two variables to both these function then other variable I can use as a file pointer and hopefully that may sort out the problem, but this also gives me strange kind of error. This is what I am trying to do

Code:

---

void *reader(void *, void *);
void *writer(void *, void *);

---

But when I tried this I couldn't succeed... Please give some on this also.

P.S-: I have attached the code (shmem.zip), please have a look at it.