[go: up one dir, main page]
Scribd
Upload
4 views6 pages

Exp7 and Exp8

The document contains multiple C programming experiments demonstrating inter-process communication techniques. It includes implementations of producer-consumer problems using threads, message passing with message queues, shared memory, and FIFO (named pipes). Each experiment showcases synchronization mechanisms and data sharing between processes or threads.

Uploaded by

hanshikanetha
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
4 views6 pages

Exp7 and Exp8

The document contains multiple C programming experiments demonstrating inter-process communication techniques. It includes implementations of producer-consumer problems using threads, message passing with message queues, shared memory, and FIFO (named pipes). Each experiment showcases synchronization mechanisms and data sharing between processes or threads.

Uploaded by

hanshikanetha
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
You are on page 1/ 6

===================================================================================

==========================================
Experiment 7:
Ans1:
===================================================================================
==========================================
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

#define BUFFER_SIZE 5

int buffer[BUFFER_SIZE];
int count = 0; // Number of items in the buffer
int in = 0; // Index for inserting into the buffer
int out = 0; // Index for removing from the buffer

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;


pthread_cond_t empty = PTHREAD_COND_INITIALIZER;
pthread_cond_t full = PTHREAD_COND_INITIALIZER;

void *producer(void *arg) {


int item;

for (int i = 0; i < 10; i++) {


item = rand() % 100; // Generate a random item

pthread_mutex_lock(&mutex);
while (count == BUFFER_SIZE) {
pthread_cond_wait(&empty, &mutex);
}

buffer[in] = item;
in = (in + 1) % BUFFER_SIZE;
count++;

printf("Produced item %d\n", item);

pthread_cond_signal(&full);
pthread_mutex_unlock(&mutex);
}

pthread_exit(NULL);
}

void *consumer(void *arg) {


int item;

for (int i = 0; i < 10; i++) {


pthread_mutex_lock(&mutex);
while (count == 0) {
pthread_cond_wait(&full, &mutex);
}

item = buffer[out];
out = (out + 1) % BUFFER_SIZE;
count--;
printf("Consumed item %d\n", item);

pthread_cond_signal(&empty);
pthread_mutex_unlock(&mutex);
}

pthread_exit(NULL);
}

int main() {
pthread_t producer_thread, consumer_thread;

// Create producer and consumer threads


pthread_create(&producer_thread, NULL, producer, NULL);
pthread_create(&consumer_thread, NULL, consumer, NULL);

// Join threads
pthread_join(producer_thread, NULL);
pthread_join(consumer_thread, NULL);

return 0;
}

Ans2:
===================================================================================
==========================================
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <semaphore.h>

#define NUM_READERS 3
#define NUM_WRITERS 1

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;


sem_t reader_sem, writer_sem;

int readers_count = 0;
int shared_variable = 0;

void *reader(void *arg) {


while (1) {
pthread_mutex_lock(&mutex);
readers_count++;
if (readers_count == 1) {
sem_wait(&writer_sem); // Wait if a writer is writing
}
pthread_mutex_unlock(&mutex);

// Reading operation
printf("Reader %d reads: %d\n", *((int *)arg), shared_variable);

pthread_mutex_lock(&mutex);
readers_count--;
if (readers_count == 0) {
sem_post(&writer_sem); // Signal writer to write
}
pthread_mutex_unlock(&mutex);
// Sleep to simulate reading time
sleep(rand() % 3);
}
pthread_exit(NULL);
}

void *writer(void *arg) {


while (1) {
sem_wait(&reader_sem); // Wait if any readers are active
sem_wait(&writer_sem); // Wait if another writer is writing

// Writing operation
shared_variable++;
printf("Writer writes: %d\n", shared_variable);

sem_post(&writer_sem); // Signal writer semaphore


sem_post(&reader_sem); // Signal reader semaphore

// Sleep to simulate writing time


sleep(rand() % 3);
}
pthread_exit(NULL);
}

int main() {
pthread_t readers[NUM_READERS], writers[NUM_WRITERS];
int reader_ids[NUM_READERS], writer_ids[NUM_WRITERS];

// Initialize semaphores
sem_init(&reader_sem, 0, NUM_READERS);
sem_init(&writer_sem, 0, 1);

// Create reader threads


for (int i = 0; i < NUM_READERS; i++) {
reader_ids[i] = i + 1;
pthread_create(&readers[i], NULL, reader, &reader_ids[i]);
}

// Create writer threads


for (int i = 0; i < NUM_WRITERS; i++) {
writer_ids[i] = i + 1;
pthread_create(&writers[i], NULL, writer, &writer_ids[i]);
}

// Join reader threads


for (int i = 0; i < NUM_READERS; i++) {
pthread_join(readers[i], NULL);
}

// Join writer threads


for (int i = 0; i < NUM_WRITERS; i++) {
pthread_join(writers[i], NULL);
}

// Destroy semaphores
sem_destroy(&reader_sem);
sem_destroy(&writer_sem);
return 0;
}

===================================================================================
==========================================
Experiment 8:
Ans1:
===================================================================================
==========================================
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>

#define BUF_SIZE 1024

int main() {
int sfd, rfd;
char *s_fifo = "/tmp/sender", *r_fifo = "/tmp/receiver", buf[BUF_SIZE];

mkfifo(s_fifo, 0666); mkfifo(r_fifo, 0666);


sfd = open(s_fifo, O_WRONLY); rfd = open(r_fifo, O_RDONLY);

printf("Sender program\nEnter message to send: ");


fgets(buf, BUF_SIZE, stdin); write(sfd, buf, strlen(buf) + 1);

printf("Receiver program\n");
read(rfd, buf, BUF_SIZE); printf("Received: %s", buf);

close(sfd); close(rfd); unlink(s_fifo); unlink(r_fifo);


return 0;
}

Ans2:
===================================================================================
==========================================
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <string.h>

#define SHM_SIZE 1024

struct shared_data { int written; char message[SHM_SIZE]; };

int main() {
int shmid;
key_t key = 1234;
struct shared_data *shared_memory;

shmid = shmget(key, sizeof(struct shared_data), IPC_CREAT | 0666);


if (shmid == -1) { perror("shmget"); exit(EXIT_FAILURE); }

shared_memory = shmat(shmid, NULL, 0);


if (shared_memory == (void *)-1) { perror("shmat"); exit(EXIT_FAILURE); }

printf("Producer process\nEnter message to write into shared memory: ");


fgets(shared_memory->message, SHM_SIZE, stdin);
shared_memory->written = 1;

shmdt(shared_memory);

printf("\nConsumer process\n");
while (!shared_memory->written) { sleep(1); }
printf("Received message from shared memory: %s", shared_memory->message);

shmctl(shmid, IPC_RMID, NULL);

return 0;
}

Ans3:
===================================================================================
==========================================
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <signal.h>

#define MSG_SIZE 128

struct message { long mtype; char mtext[MSG_SIZE]; };

void sender_handler(int sig) { printf("Sender received signal %d\n", sig); }


void receiver_handler(int sig) { printf("Receiver received signal %d\n", sig); }

int main() {
pid_t pid;
key_t key = ftok("/tmp", 'A');
int msqid;
struct message msg;

msqid = msgget(key, IPC_CREAT | 0666);


if (msqid == -1) { perror("msgget"); exit(EXIT_FAILURE); }

pid = fork();
if (pid < 0) { perror("fork"); exit(EXIT_FAILURE); }
else if (pid == 0) { signal(SIGUSR1, SIG_IGN);
signal(SIGUSR2, sender_handler); sleep(1);
msg.mtype = 1; sprintf(msg.mtext, "Hello from sender!");
if (msgsnd(msqid, &msg, sizeof(msg.mtext), 0) == -1) { perror("msgsnd");
exit(EXIT_FAILURE); } }
else {
signal(SIGUSR1, receiver_handler);
signal(SIGUSR2, SIG_IGN);
printf("Receiver waiting for message...\n");
if (msgrcv(msqid, &msg, sizeof(msg.mtext), 1, 0) == -1) {
perror("msgrcv"); exit(EXIT_FAILURE); }
printf("Received message from sender: %s\n", msg.mtext);
if (msgctl(msqid, IPC_RMID, NULL) == -1) { perror("msgctl");
exit(EXIT_FAILURE); } }

return 0;
}

You might also like