EXPERIMENT NO-2
AIM: To Write a Shell program to check the given number is even or odd.
ALGORITHM:
SEPT 1: Start the program.
STEP 2: Read the value of n.
STEP 3: Calculate „r=expr $n%2‟.
STEP 4: If the value of r equals 0 then print the number is even
STEP 5: If the value of r not equal to 0 then print the number is odd.
PROGRAM:
echo "Enter the Number"
read n
r=`expr $n % 2`
if [ $r -eq 0 ]
then
echo "$n is Even number"
else
echo "$n is Odd number"
fi
Output:
EXPERIMENT NO-3
AIM: Write a Shell program to swap the two integers.
ALGORITHM:
SEPT 1: Start the program.
STEP 2: Read the value of a,b.
STEP 3: Calculate the swapping of two values by using a temporary variable temp.
STEP 4: Print the value of a and b.
PROGRAM:
echo "Enter Two Numbers"
read a b
temp=$a
a=$b
b=$temp
echo "after swapping"
echo $a $b
Output:
EXPERIMENT NO-4
Aim: Write a Shell program to find the factorial of a number
ALGORITHM:
SEPT 1: Start the program.
STEP 2: Read the value of n.
STEP 3: Calculate „i=expr $n-1‟.
STEP 4: If the value of i is greater than 1 then calculate „n=expr $n \* $i‟ and „i=expr $i – 1‟
STEP 5: Print the factorial of the given number.
PROGRAM:
echo "Enter a Number"
read n i=`expr $n - 1`
p=1
while [ $i -ge 1 ]
do
n=`expr $n \* $i`
i=`expr $i - 1`
done
echo "The Factorial of the given Number is $n"
Output:
EXPERIMENT NO-5
Aim: write a shell program to generate fibonacci series
Algorithm:
Step1: Define how many terms (n) of the Fibonacci series you want to generate.
Step2: Set first = 0 and second = 1 as the initial two Fibonacci numbers.
Step3:
Print the current Fibonacci number.
Calculate the next number: next = first + second.
Update values: first = second, second = next.
Step4: Repeat until the required n terms are generated.
Program:
echo "Enter the number of terms:"
read n
first=0
second=1
echo "Fibonacci Series:"
for (( i=0; i<n; i++ ))
do
echo -n "$first "
next=$((first + second))
first=$second
second=$next
done
echo
Output:
EXPERIMENT NO-6
Aim: Write a C program using the following system calls (fork, exec).
Algorithm:
1. Initialize the program and define pid_t variable for process management.
2. Invoke fork() to create a child process.
o If fork() fails, print an error.
o If fork() succeeds, identify whether the process is child or parent.
3. In the child process:
o Print a message indicating execution inside WSL.
o Call execl() to replace the child process with ls -l.
o Handle errors if exec() fails.
4. In the parent process:
o Print a message indicating process tracking.
o Use wait() to synchronize execution.
o Print completion status.
Program:
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
int main() {
pid_t pid;
// Create a child process
pid = fork();
if (pid < 0) {
// Error handling
perror("Fork failed");
return 1;
}
else if (pid == 0) {
// Child process
printf("Child process running in WSL with PID %d\n", getpid());
// Execute a new process (e.g., listing files in the current directory)
execl("/usr/bin/ls", "ls", "-l", (char *)NULL);
// If exec fails
perror("Exec failed");
return 1;
}
else {
// Parent process
printf("Parent process running in WSL with PID %d, waiting for child process to finish\n",
getpid());
// Wait for child process to complete
wait(NULL);
printf("Child process finished execution\n");
}
return 0;
}
Output:
EXPERIMENT NO-7
Aim: Write a C program using the following system calls (get_pid, exit).
Algorithm:
1. Start
2. Retrieve Process ID
o Use the system call getpid() to obtain the current process's PID.
o Print the process ID.
3. Prepare for termination
o Print a message indicating that the process is exiting.
4. Terminate the process
o Use the system call exit(0) to exit immediately.
5. End
Program:
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main() {
printf("Process running with PID: %d\n", getpid());
printf("Exiting the process now.\n");
exit(0); // Exiting the process
return 0; // This will never execute due to exit()
}
Output:
EXPERIMENT NO-8
Aim: Write a C program using the I/O system calls (open, read, write, etc).
Program:
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#define BUFFER_SIZE 1024
int main() {
int source_fd, dest_fd;
char buffer[BUFFER_SIZE];
ssize_t bytes_read;
// Open the source file for reading
source_fd = open("input.txt", O_RDONLY);
if (source_fd < 0) {
perror("Error opening input file");
return 1;
}
// Open the destination file for writing (create if doesn't exist)
dest_fd = open("output.txt", O_WRONLY | O_CREAT | O_TRUNC, 0644);
if (dest_fd < 0) {
perror("Error opening output file");
close(source_fd);
return 1;
}
// Read data from source file and write to destination file
while ((bytes_read = read(source_fd, buffer, BUFFER_SIZE)) > 0) {
if (write(dest_fd, buffer, bytes_read) < 0) {
perror("Error writing to output file");
close(source_fd);
close(dest_fd);
return 1;
}
}
// Close files
close(source_fd);
close(dest_fd);
printf("File copy operation completed successfully.\n");
return 0;
}
Output:
EXPERIMENT NO- 9
Aim: Write a C program to simulate CPU scheduling algorithms: FCFS, SJF, and Round
Robin
a)FCFS:
Program:
#include <stdio.h>
// Function to calculate waiting time and turnaround time
void findWaitingTime(int processes[], int n, int bt[], int wt[]) {
wt[0] = 0; // First process has no waiting time
for (int i = 1; i < n; i++) {
wt[i] = bt[i - 1] + wt[i - 1];
}
}
void findTurnaroundTime(int processes[], int n, int bt[], int wt[], int tat[]) {
for (int i = 0; i < n; i++) {
tat[i] = bt[i] + wt[i];
}
}
void findAvgTime(int processes[], int n, int bt[]) {
int wt[n], tat[n];
float total_wt = 0, total_tat = 0;
findWaitingTime(processes, n, bt, wt);
findTurnaroundTime(processes, n, bt, wt, tat);
printf("\nFCFS Scheduling:\n\nP BT WT TAT\n");
for (int i = 0; i < n; i++) {
printf("P%d %d %d %d\n", processes[i], bt[i], wt[i], tat[i]);
total_wt += wt[i];
total_tat += tat[i];
}
printf("\nAverage Waiting Time: %.2f\n", total_wt / n);
printf("Average Turnaround Time: %.2f\n", total_tat / n);
}
int main() {
int processes[] = {1, 2, 3}; // Process IDs
int n = sizeof(processes) / sizeof(processes[0]);
int bt[] = {5, 8, 6}; // Burst time of processes
printf("FCFS Output\n");
findAvgTime(processes, n, bt);
return 0;
}
Output:
b)SJF:
Program:
#include <stdio.h>
// Function to sort processes by Burst Time (BT)
void sortByBurstTime(int n, int processes[], int bt[]) {
for (int i = 0; i < n - 1; i++) {
for (int j = i + 1; j < n; j++) {
if (bt[i] > bt[j]) {
// Swap burst time
int temp = bt[i];
bt[i] = bt[j];
bt[j] = temp;
// Swap process IDs
temp = processes[i];
processes[i] = processes[j];
processes[j] = temp;
}
}
}
}
// Function to calculate Waiting Time (WT)
void findWaitingTime(int n, int bt[], int wt[]) {
wt[0] = 0; // First process has no waiting time
for (int i = 1; i < n; i++) {
wt[i] = bt[i - 1] + wt[i - 1];
}
}
// Function to calculate Turnaround Time (TAT)
void findTurnaroundTime(int n, int bt[], int wt[], int tat[]) {
for (int i = 0; i < n; i++) {
tat[i] = bt[i] + wt[i];
}
}
void findAvgTime(int n, int processes[], int bt[]) {
int wt[n], tat[n];
float total_wt = 0, total_tat = 0;
// Sort processes by shortest burst time
sortByBurstTime(n, processes, bt);
findWaitingTime(n, bt, wt);
findTurnaroundTime(n, bt, wt, tat);
printf("\nSJF Scheduling:\n\nP BT WT TAT\n");
for (int i = 0; i < n; i++) {
printf("P%d %d %d %d\n", processes[i], bt[i], wt[i], tat[i]);
total_wt += wt[i];
total_tat += tat[i];
}
printf("\nAverage Waiting Time: %.2f\n", total_wt / n);
printf("Average Turnaround Time: %.2f\n", total_tat / n);
}
int main() {
int processes[] = {1, 2, 3}; // Process IDs
int n = sizeof(processes) / sizeof(processes[0]);
int bt[] = {8, 5, 6}; // Burst time of processes (unsorted)
printf("SJF Output\n");
findAvgTime(n, processes, bt);
return 0;
}
Output:
c)Round Robin:
Program:
#include <stdio.h>
// Function to implement Round Robin scheduling
void findWaitingTime(int processes[], int n, int bt[], int quantum, int wt[]) {
int rem_bt[n]; // Remaining burst times
for (int i = 0; i < n; i++)
rem_bt[i] = bt[i];
int t = 0; // Current time
while (1) {
int done = 1;
for (int i = 0; i < n; i++) {
if (rem_bt[i] > 0) {
done = 0;
if (rem_bt[i] > quantum) {
t += quantum;
rem_bt[i] -= quantum;
} else {
t += rem_bt[i];
wt[i] = t - bt[i];
rem_bt[i] = 0;
}
}
}
if (done) break;
}
}
// Function to calculate Turnaround Time
void findTurnaroundTime(int n, int bt[], int wt[], int tat[]) {
for (int i = 0; i < n; i++)
tat[i] = bt[i] + wt[i];
}
void findAvgTime(int processes[], int n, int bt[], int quantum) {
int wt[n], tat[n];
float total_wt = 0, total_tat = 0;
findWaitingTime(processes, n, bt, quantum, wt);
findTurnaroundTime(n, bt, wt, tat);
printf("\nRound Robin Scheduling:\n\nP BT WT TAT\n");
for (int i = 0; i < n; i++) {
printf("P%d %d %d %d\n", processes[i], bt[i], wt[i], tat[i]);
total_wt += wt[i];
total_tat += tat[i];
}
printf("\nAverage Waiting Time: %.2f\n", total_wt / n);
printf("Average Turnaround Time: %.2f\n", total_tat / n);
}
int main() {
int processes[] = {1, 2, 3}; // Process IDs
int n = sizeof(processes) / sizeof(processes[0]);
int bt[] = {5, 8, 6}; // Burst time of processes
int quantum = 3; // Time Quantum
printf("Round Robin Output\n");
findAvgTime(processes, n, bt, quantum);
return 0;
}
Output:
EXPERIMENT NO-10
Aim: Implement the Producer-Consumer problem using semaphores.
Program:
#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>
#include <unistd.h>
#define BUFFER_SIZE 5 // Size of buffer
int buffer[BUFFER_SIZE];
int count = 0; // Number of items in buffer
sem_t empty, full; // Semaphores for synchronization
pthread_mutex_t mutex; // Mutex for critical section
void *producer(void *arg) {
for (int i = 1; i <= 10; i++) {
sem_wait(&empty); // Wait if buffer is full
pthread_mutex_lock(&mutex);
buffer[count++] = i;
printf("Producer produced: %d\n", i);
pthread_mutex_unlock(&mutex);
sem_post(&full); // Signal consumer
sleep(1);
}
return NULL;
}
void *consumer(void *arg) {
for (int i = 1; i <= 10; i++) {
sem_wait(&full); // Wait if buffer is empty
pthread_mutex_lock(&mutex);
int item = buffer[--count];
printf("Consumer consumed: %d\n", item);
pthread_mutex_unlock(&mutex);
sem_post(&empty); // Signal producer
sleep(2);
}
return NULL;
}
int main() {
pthread_t prod, cons;
sem_init(&empty, 0, BUFFER_SIZE);
sem_init(&full, 0, 0);
pthread_mutex_init(&mutex, NULL);
pthread_create(&prod, NULL, producer, NULL);
pthread_create(&cons, NULL, consumer, NULL);
pthread_join(prod, NULL);
pthread_join(cons, NULL);
sem_destroy(&empty);
sem_destroy(&full);
pthread_mutex_destroy(&mutex);
return 0;
}
Output:
EXPERIMENT NO-11
Aim: Implement the Dining Philospher problem using semaphores.
Program:
#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>
#include <unistd.h>
#define N 5 // Number of philosophers
sem_t forks[N]; // Semaphores representing forks
sem_t mutex; // Semaphore to prevent deadlock
void *philosopher(void *arg) {
int id = *(int *)arg;
while (1) {
printf("Philosopher %d is thinking\n", id);
sleep(1);
// Pick up forks
sem_wait(&mutex); // Prevent deadlock
sem_wait(&forks[id]); // Pick left fork
sem_wait(&forks[(id + 1) % N]); // Pick right fork
sem_post(&mutex);
printf("Philosopher %d is eating\n", id);
sleep(2);
// Put down forks
sem_post(&forks[id]); // Release left fork
sem_post(&forks[(id + 1) % N]); // Release right fork
printf("Philosopher %d finished eating\n", id);
sleep(1);
}
}
int main() {
pthread_t philosophers[N];
int ids[N];
sem_init(&mutex, 0, 1);
for (int i = 0; i < N; i++)
sem_init(&forks[i], 0, 1);
for (int i = 0; i < N; i++) {
ids[i] = i;
pthread_create(&philosophers[i], NULL, philosopher, &ids[i]);
}
for (int i = 0; i < N; i++)
pthread_join(philosophers[i], NULL);
for (int i = 0; i < N; i++)
sem_destroy(&forks[i]);
sem_destroy(&mutex);
return 0;
}
Output:
