Scribd
Upload
64 views

Advanced Operating System

This document describes a synchronization problem involving students and a teaching assistant (TA). It involves coordinating the activities of student threads that alternate between programming and seeking help from the TA thread. Mutex locks, semaphores, and conditional variables are used to synchronize access to shared resources like chairs and the TA. The solution outline involves creating student and TA threads, using synchronization primitives to control access to resources and signal when help is needed/available, and simulating activities with random sleeps. Pseudocode is provided to illustrate how this problem could be implemented using POSIX threads.

Uploaded by

Shahid Ali
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
64 views

Advanced Operating System

This document describes a synchronization problem involving students and a teaching assistant (TA). It involves coordinating the activities of student threads that alternate between programming and seeking help from the TA thread. Mutex locks, semaphores, and conditional variables are used to synchronize access to shared resources like chairs and the TA. The solution outline involves creating student and TA threads, using synchronization primitives to control access to resources and signal when help is needed/available, and simulating activities with random sleeps. Pseudocode is provided to illustrate how this problem could be implemented using POSIX threads.

Uploaded by

Shahid Ali
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 10

Advanced Operating system

Assignment 3.

Submitted to
Dr. Sajid Hussain
By
Shaneela
2023-KIU-MS5090
The Sleeping Teaching Assistant

A university computer science department has a teaching assistant (TA)


who helps undergraduate students with their programming assignments
during regular office hours. The TA’s office is rather small and has room for
only one desk with a chair and computer. There are three chairs in the
hallway outside the office where students can sit and wait if the TA is
currently helping another student. When there are no students who need
help during office hours, the TA sits at the desk and takes a nap. If a
student arrives during office hours and finds the TA sleeping, the student
must awaken the TA to ask for help. If a student arrives and finds the TA
currently helping another student, the student sits on one of the chairs in
the hallway and waits. If no chairs are available, the student will come back
at a later time. Using POSIX threads, mutex locks, and semaphores,
implement a solution that coordinates the activities of the TA and the
students. Details for this assignment are provided below.

The Students and the TA

Using Pthreads begin by creating n students. Each will run as a separate


thread. The TA will run as a separate thread as well. Student threads will
alternate between programming for a period of time and seeking help from
the TA. If the TA is available, they will obtain help. Otherwise, they will
either sit in a chair in the hallway or, if no chairs are available, will resume
programming and will seek help at a later time. If a student arrives and
notices that the TA is sleeping, the student must notify the TA using a
semaphore. When the TA finishes helping a student, the TA must check to
see if there are students waiting for help in the hallway. If so, the TA must
help each of these students in turn. If no students are present, the TA may
return to napping.

Perhaps the best option for simulating students programming—as well as


the TA providing help to a student—is to have the appropriate threads sleep
for a random period of time.

Solution
This problem described a classic example of a synchronization
problem involving students and a teaching assistant (TA) using POSIX
threads, mutex locks, and semaphores to coordinate their activities.

Entities:

Students: There are 'n' student threads. Each student alternates


between programming and seeking help from the TA.

TA: The TA is a separate thread who helps students when they are
available.

Chairs: There are three chairs in the hallway outside the TA's office.
Students wait on these chairs if the TA is helping another student.

Actions and Synchronization:

Programming: Students spend some time programming before


seeking help. You can simulate this by having each student sleep for a
random period while they program.

Seeking Help: When a student needs help, they check if the TA is


available. If the TA is available, they obtain help; otherwise, they either
sit on a chair in the hallway (if available) or continue programming.
Awakening the TA: If a student arrives and finds the TA sleeping,
they need to notify the TA to wake up. You can use a semaphore to
implement this.

TA Helping Students: The TA helps students one at a time. After


helping a student, the TA checks if there are other students waiting in
the hallway (sitting on chairs). If so, the TA helps each waiting student
in turn.

Napping: If there are no students waiting, the TA can return to


napping.

Synchronization Techniques:

Mutex Locks: use of mutex locks to protect shared resources such as


chairs and to ensure that only one student or the TA accesses them at
a time.

Semaphores: Use semaphores to control the flow of students and the


TA. For example, you can use a semaphore to wake up the TA when a
student arrives and finds the TA sleeping.

Conditional Variables: Conditional variables can be used to make


students wait for the TA to help them if the TA is currently helping
another student.
Random Sleep: Simulate students' programming time by making
them sleep for random periods.

Here's a high-level outline of how to structure a program:

● Create threads for the TA and 'n' students.


● Use mutex locks to protect shared resources like chairs.
● Use semaphores to coordinate waking up the TA and signaling
when the TA is done helping a student.
● Implement logic in student and TA threads to perform the actions
described above based on synchronization primitives.
● Use random sleep to simulate programming time for students.

Code
#include <stdio.h>

#include <stdlib.h>

#include <pthread.h>

#include <semaphore.h>

#include <unistd.h>

#define NUM_STUDENTS 5

#define NUM_CHAIRS 3

pthread_mutex_t mutex;

sem_t student_sem, ta_sem;

int waiting_students = 0;
void *student_thread(void *id) {

int student_id = *(int *)id;

while (1) {

// Simulate programming time

printf("Student %d is programming.\n", student_id);

sleep(rand() % 5);

pthread_mutex_lock(&mutex);

if (waiting_students < NUM_CHAIRS) {

// Student takes a chair in the hallway

waiting_students++;

printf("Student %d is waiting in the hallway.\n", student_id);

pthread_mutex_unlock(&mutex);

sem_wait(&student_sem); // Notify TA

} else {

// No chairs available, student continues programming

pthread_mutex_unlock(&mutex);

printf("Student %d will come back later.\n", student_id);

}
}

void *ta_thread(void *arg) {

while (1) {

pthread_mutex_lock(&mutex);

if (waiting_students > 0) {

// TA helps a student

waiting_students--;

printf("TA is helping a student.\n");

sem_post(&student_sem); // Signal student that TA is available

pthread_mutex_unlock(&mutex);

sleep(rand() % 3); // Simulate TA helping time

} else {

// No students waiting, TA naps

pthread_mutex_unlock(&mutex);

printf("TA is napping.\n");

sem_wait(&ta_sem); // Wait until a student wakes TA up

int main() {
pthread_t students[NUM_STUDENTS], ta;

int student_ids[NUM_STUDENTS];

pthread_mutex_init(&mutex, NULL);

sem_init(&student_sem, 0, 0);

sem_init(&ta_sem, 0, 0);

// Create TA thread

pthread_create(&ta, NULL, ta_thread, NULL);

// Create student threads

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

student_ids[i] = i + 1;

pthread_create(&students[i], NULL, student_thread,


&student_ids[i]);

// Join threads (never reached in this simplified example)

pthread_join(ta, NULL);

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

pthread_join(students[i], NULL);

pthread_mutex_destroy(&mutex);
sem_destroy(&student_sem);

sem_destroy(&ta_sem);

return 0;

Output

You might also like