It's giving me segmentation fault when I am trying to execute with following
options
./main -r 10 -w 4 -s 10
(here 'r' is the number of reader thread
'w' is the number of writer thread
's' is the size of bytes)
But when I am exceuting it as follows it works fine
./main -r 10 -w 3 -s 10
Please look into it, why it's failing when I am trying to create 4 or more
number of writer threads.
/***********************************/
/*********** Header File **************/
/***********************************/
#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 **);
void *reader(void *);
void *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;
int j;
int k;
size_t Size;
unsigned long *ulptr;
parse_args (argc, argv);
printf ("%s: IPC Shared Memory TestSuite program\n", *argv);
printf ("\tNumber of writers = %d\n", num_writers);
printf ("\tNumber of readers = %d\n", num_readers);
printf ("\tBytes per writer = %d\n", buffer_size);
for (i=0; i<num_writers; i++)
{j=i*3;
Size=sizeof (int);
if ((shmid[j] = shmget (IPC_PRIVATE, Size, SHMEM_MODE)) < 0)
sys_error ("read_count shmget failed", __LINE__);
if ((long)(read_count[i] = (int *) shmat (shmid[j], 0, 0)) == -1)
sys_error ("shmat failed", __LINE__);
*(read_count[i]) = 0;
j++;
Size=sizeof (unsigned long) * num_readers;
if ((shmid[j] = shmget (IPC_PRIVATE, Size, SHMEM_MODE)) < 0)
sys_error("checksum shmget failed", __LINE__);
if ((long)(checksum[i] = (unsigned long *) shmat (shmid[j], 0, 0))
== -1)
sys_error("shmat failed", __LINE__);
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)
sys_error ("shmptr shmget failed", __LINE__);
if ((long)(shmptr[i] = shmat (shmid[j], 0, 0)) == -1)
sys_error ("shmat failed", __LINE__);
}
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)
sys_error ("Can't initialize mutex_r", __LINE__);
if (pthread_mutex_init (&cond_mutex[i], (pthread_mutexattr_t *)NULL))
sys_error ("Can't initialize cond_mutex", __LINE__);
if (pthread_cond_init (&cond_var[i], (pthread_condattr_t *)NULL))
sys_error ("cond_init(&cond_var) failed", __LINE__);
thread_hold[i]=1;
}
if (pthread_attr_init(&newattr))
sys_error ("attr_init(&newattr) failed", __LINE__);
#ifdef _LINUX_
/* the DEFAULT state for linux pthread_create is to be
"undetatched" or joinable */
/* if (pthread_attr_setdetachstate (&newattr, PTHREAD_CREATE_JOINABLE))
sys_error ("attr_setdetachstate(&newattr) failed",
__LINE__);*/
#else
if (pthread_attr_setdetachstate (&newattr,
PTHREAD_CREATE_UNDETACHED))
sys_error ("attr_setdetachstate(&newattr) failed",
__LINE__);
#endif
for (i = 0; i < num_writers; i++)
{
if (pthread_create (&writer_th[i], &newattr, writer,\
(void *) (long)i))
sys_error ("writer: pthread_create failed",\
__LINE__);
k=i*num_readers;
for (j = k; j < (k + num_readers) ; j++)
{
if (pthread_create (&reader_th[j], &newattr, reader,\
(void *) (long)j))
sys_error ("reader: pthread_create failed",\
__LINE__);
}
}
for (i = 0; i < num_writers; i++)
{
if (pthread_join( writer_th[i], NULL)) {
printf("writer_th: pthread_join return: %d\n",i);
sys_error("pthread_join bad status", __LINE__);
}
k=i*num_readers;
for (j = k; j < (k + num_readers) ; j++)
{
if (pthread_join( reader_th[j], NULL)) {
printf("reader_th: pthread_join return: %d\n",j);
sys_error("pthread_join bad status", __LINE__);
}
}
}
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);
}
/**************************************/
/*********** parseargs.c******************/
/**************************************/
#include "header.h"
int parse_args (int argc, char **argv)
{
int i;
int errflag = 0;
char *program_name = *argv;
extern char *optarg; /* Command line option */
while ((i = getopt(argc, argv, "c:s:g:?")) != EOF) {
switch (i) {
case 'c':
num_readers = atoi (optarg);
break;
case 's':
buffer_size = atoi (optarg);
break;
case 'g': /* number of group */
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;
int j;
for (i=0; i<num_writers; i++) {
if (pthread_mutex_destroy(&cond_mutex[i]) != 0)
sys_error ("Can't destroy cond_mutex", __LINE__);
if (pthread_mutex_destroy(&mutex_r[i]) != 0)
sys_error ("Can't destroy mutex_r", __LINE__);
}
for (i=0; i<num_writers; i++) {
/*
* Release shared memory regions
*/
j=i*3;
if (shmctl (shmid[j], IPC_RMID, 0) < 0)
sys_error ("read_count shmctl failed", __LINE__);
j++;
if (shmctl (shmid[j], IPC_RMID, 0) < 0)
sys_error ("checksum shmctl failed", __LINE__);
j++;
if (shmctl (shmid[j], IPC_RMID, 0) < 0)
sys_error ("shmptr shmctl failed", __LINE__);
}
}
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);
}
/**************************************/
/****************reader.c ***************/
/**************************************/
#include "header.h"
void *reader (void *parm)
{
int num_p = (int) (long)parm;
unsigned long cksum_r = 0; /* Shared memory regions checksum */
int i; /* Misc index */
int num_r; /* Misc index */
int num_w; /* Misc index */
char * ptr; /* Misc pointer */
unsigned long *ulptr_r; /* Misc pointer */
/*
* Wait for a READ_COUNT lock on the shared memory segment, then
* compute the checksum and release the READ_COUNT lock.
*/
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]))
sys_error ("Can't take cond lock", __LINE__);
/*
* Check to see if we need to wait: if yes, wait for the condition
* variable (blocking wait).
*/
while (thread_hold[num_w])
{
if (pthread_cond_wait (&cond_var[num_w], &cond_mutex[num_w]))
sys_error ("cond_wait failed", __LINE__);
}
if (pthread_mutex_unlock (&cond_mutex[num_w]))
sys_error ("Can't release cond lock", __LINE__);
if (pthread_mutex_lock(&mutex_r[num_w]))
sys_error ("Can't take read lock", __LINE__);
(*(read_count [num_w]))++;
if (pthread_mutex_unlock(&mutex_r[num_w]))
sys_error ("Can't release read lock", __LINE__);
for (i=0; i<buffer_size; i++)
cksum_r += *ptr++;
if (pthread_mutex_lock(&mutex_r[num_w]))
sys_error ("Can't take read lock", __LINE__);
(*(read_count[num_w]))--;
if (pthread_mutex_unlock(&mutex_r[num_w]))
sys_error ("Can't release 1 read lock", __LINE__);
/*
* Store the resulting checksum and print out a message
*/
*ulptr_r = cksum_r;
printf ("\t\treader (%03d) of writer (%03d): checksum %08lx\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;
data = num_w;
for (ptr=shmptr[num_w]; ptr < (shmptr[num_w]+buffer_size); ptr++) {
*ptr = data++;
cksum_w += *ptr;
}
if (pthread_mutex_lock (&cond_mutex[num_w]))
sys_error ("mutex_lock(&cond_mutex) failed", __LINE__);
thread_hold[num_w]=0;
if (pthread_cond_broadcast (&cond_var[num_w]))
sys_error ("cond_signal(&cond_var) failed", __LINE__);
if (pthread_mutex_unlock (&cond_mutex[num_w]))
sys_error ("mutex_unlock(&cond_mutex) failed", __LINE__);
cksum[num_w] = cksum_w;
printf ("\t\twriter (%03d): shared memory checksum %04ld\n", \
num_w, cksum_w);
return NULL;
}
--
View this message in context:
http://www.nabble.com/Error-in-the-Program-tp19220523p19286327.html
Sent from the C-prog mailing list archive at Nabble.com.
