1 inter process communication & timers. 2 time.h (page r:ch9 pp302-320) #include time_t...
TRANSCRIPT
![Page 1: 1 Inter Process Communication & Timers. 2 Time.h (page R:Ch9 pp302-320) #include time_t time(time_t *calptr); Epoch: 00:00 (midnight), Jan 1, 1970 GMT](https://reader035.vdocuments.site/reader035/viewer/2022062315/5697c0051a28abf838cc5004/html5/thumbnails/1.jpg)
1
Inter Process Communication & Timers
![Page 2: 1 Inter Process Communication & Timers. 2 Time.h (page R:Ch9 pp302-320) #include time_t time(time_t *calptr); Epoch: 00:00 (midnight), Jan 1, 1970 GMT](https://reader035.vdocuments.site/reader035/viewer/2022062315/5697c0051a28abf838cc5004/html5/thumbnails/2.jpg)
2
Time.h (page R:Ch9 pp302-320)
#include <time.h>time_t time(time_t *calptr);
Epoch: 00:00 (midnight), Jan 1, 1970 GMTDay is 86,400 secondstime_t is usually a longIf the long is 32 bits, time overflows in 2038
ExtensionsPOSIX:XSI microsecondsPOSIX:TMR nanoseconds
![Page 3: 1 Inter Process Communication & Timers. 2 Time.h (page R:Ch9 pp302-320) #include time_t time(time_t *calptr); Epoch: 00:00 (midnight), Jan 1, 1970 GMT](https://reader035.vdocuments.site/reader035/viewer/2022062315/5697c0051a28abf838cc5004/html5/thumbnails/3.jpg)
3
Timing a function
#include <stdio.h>#include <time.h>void function_to_time(void);
int main(void) { time_t tstart; tstart = time(NULL); function_to_time(); printf(“function_to_time took %f seconds of elapsed time\n”, difftime(time(NULL), tstart)); return(0);}
![Page 4: 1 Inter Process Communication & Timers. 2 Time.h (page R:Ch9 pp302-320) #include time_t time(time_t *calptr); Epoch: 00:00 (midnight), Jan 1, 1970 GMT](https://reader035.vdocuments.site/reader035/viewer/2022062315/5697c0051a28abf838cc5004/html5/thumbnails/4.jpg)
4
POSIX XSI
struct timevaltime_t tv_sec; /* seconds since the Epoch*/time_t tv_usec /* and microsoeconds*/
#include <sys/time.h>
int gettimeofday(struct timeval *restrict tp, void *restrict tzp);
tzp is null, historical
![Page 5: 1 Inter Process Communication & Timers. 2 Time.h (page R:Ch9 pp302-320) #include time_t time(time_t *calptr); Epoch: 00:00 (midnight), Jan 1, 1970 GMT](https://reader035.vdocuments.site/reader035/viewer/2022062315/5697c0051a28abf838cc5004/html5/thumbnails/5.jpg)
5
P307 Measure running time using gettimeofday
#include <stdio.h>#include <sys/time.h>#define MILLION 1000000L
void function_to_time(void);
int main(void) {long timedif;struct timeval tpend;struct timeval tpstart;
if (gettimeofday(&tpstart, NULL)) { fprintf(stderr, “Failed to get start time\n”); return 1; }
![Page 6: 1 Inter Process Communication & Timers. 2 Time.h (page R:Ch9 pp302-320) #include time_t time(time_t *calptr); Epoch: 00:00 (midnight), Jan 1, 1970 GMT](https://reader035.vdocuments.site/reader035/viewer/2022062315/5697c0051a28abf838cc5004/html5/thumbnails/6.jpg)
6
Measure running time using gettimeofday
function_to_time(); /* timed code goes here */if (gettimeofday(&tpend, NULL)) { fprintf(stderr, “Failed to get end time\n”); return 1; }
timedif = MILLION*(tpend.tv_sec - tpstart.tv_sec) + tpend.tv_usec – tpstart.tv_usec;printf(“The function_to_time took %ld microseconds\n”, timedif);return 0;}
![Page 7: 1 Inter Process Communication & Timers. 2 Time.h (page R:Ch9 pp302-320) #include time_t time(time_t *calptr); Epoch: 00:00 (midnight), Jan 1, 1970 GMT](https://reader035.vdocuments.site/reader035/viewer/2022062315/5697c0051a28abf838cc5004/html5/thumbnails/7.jpg)
7
Sleep & nanosleep
#include <unistd.h>
unsigned sleep(unsigned seconds);
sleep interacts with SIGALRM
#include <time.h>Int nanosleep(const struct timespec *rqtp, struct timespec *rmtp);
Resolution of CLOCK_REALTIME is of order 10ms
Does not affect SIGALRM
![Page 8: 1 Inter Process Communication & Timers. 2 Time.h (page R:Ch9 pp302-320) #include time_t time(time_t *calptr); Epoch: 00:00 (midnight), Jan 1, 1970 GMT](https://reader035.vdocuments.site/reader035/viewer/2022062315/5697c0051a28abf838cc5004/html5/thumbnails/8.jpg)
8
Producer Consumer
Problem occurs in system & application programming e.g. Web Server dispatches incoming web
requests to a waiting process(es) e.g. GUI events from keyboard,& mouse are
queued by O/S and consumed by applications.
![Page 9: 1 Inter Process Communication & Timers. 2 Time.h (page R:Ch9 pp302-320) #include time_t time(time_t *calptr); Epoch: 00:00 (midnight), Jan 1, 1970 GMT](https://reader035.vdocuments.site/reader035/viewer/2022062315/5697c0051a28abf838cc5004/html5/thumbnails/9.jpg)
9
Producer-Consumer Problem
Producers insert items Consumers remove items Shared bounded buffer
Efficient implementation is a circular buffer with an insert and a removal pointer.
insertPtr
removePtr
![Page 10: 1 Inter Process Communication & Timers. 2 Time.h (page R:Ch9 pp302-320) #include time_t time(time_t *calptr); Epoch: 00:00 (midnight), Jan 1, 1970 GMT](https://reader035.vdocuments.site/reader035/viewer/2022062315/5697c0051a28abf838cc5004/html5/thumbnails/10.jpg)
10
Challenge
Prevent buffer overflow Producer inserts too many items and the buffer
overflows Prevent buffer underflow
Producer inserts an item Consumer removes an item Consumer removes another item
Proper synchronization Mutual Exclusion Progress Bounded wait i.e. Prevent deadlock
![Page 11: 1 Inter Process Communication & Timers. 2 Time.h (page R:Ch9 pp302-320) #include time_t time(time_t *calptr); Epoch: 00:00 (midnight), Jan 1, 1970 GMT](https://reader035.vdocuments.site/reader035/viewer/2022062315/5697c0051a28abf838cc5004/html5/thumbnails/11.jpg)
11
2 Counting Semaphores and a mutex
Counting semaphore to count # items in buffer
Counting semaphore to count # free slots
Mutex to protect accesses to shared buffer & pointers.
![Page 12: 1 Inter Process Communication & Timers. 2 Time.h (page R:Ch9 pp302-320) #include time_t time(time_t *calptr); Epoch: 00:00 (midnight), Jan 1, 1970 GMT](https://reader035.vdocuments.site/reader035/viewer/2022062315/5697c0051a28abf838cc5004/html5/thumbnails/12.jpg)
12
Assembling the solution
sem_wait(slots), sem_post(slots) sem_wait(items), sem_post(items) mutex_lock(m) mutex_unlock(m)
insertptr=(insertptr+1) % N removalptr=(removalptr+1) % N
Initialize semaphore slots to size of buffer Initialize semaphore items to zero.
![Page 13: 1 Inter Process Communication & Timers. 2 Time.h (page R:Ch9 pp302-320) #include time_t time(time_t *calptr); Epoch: 00:00 (midnight), Jan 1, 1970 GMT](https://reader035.vdocuments.site/reader035/viewer/2022062315/5697c0051a28abf838cc5004/html5/thumbnails/13.jpg)
13
Pseudocode getItem()
sem_wait(items)
mutex_lock(mutex)result=buffer[ removePtr ];removePtr=(removePtr +1 ) % N
mutex_unlock(mutex)
sem_post(slots)
![Page 14: 1 Inter Process Communication & Timers. 2 Time.h (page R:Ch9 pp302-320) #include time_t time(time_t *calptr); Epoch: 00:00 (midnight), Jan 1, 1970 GMT](https://reader035.vdocuments.site/reader035/viewer/2022062315/5697c0051a28abf838cc5004/html5/thumbnails/14.jpg)
14
Pseudocode putItem(data)
sem_wait(slots)
mutex_lock(mutex)buffer[ insertPtr]= data;insertPtr=(insertPtr + 1 ) % N
mutex_unlock(mutex)
sem_post(items)
![Page 15: 1 Inter Process Communication & Timers. 2 Time.h (page R:Ch9 pp302-320) #include time_t time(time_t *calptr); Epoch: 00:00 (midnight), Jan 1, 1970 GMT](https://reader035.vdocuments.site/reader035/viewer/2022062315/5697c0051a28abf838cc5004/html5/thumbnails/15.jpg)
15
Analysis#1 What's the precise problem?putItem(data) {
mutex_lock(mutex)
sem_wait(slots) buffer[ insertPtr]= … insertPtr=…sem_post(items)
mutex_unlock(mutex)
}
getItem() {
mutex_lock(mutex)
sem_wait(items)
result=buffer[ removePtr ];
removePtr=…
sem_post(slots)
mutex_unlock(mutex)}
![Page 16: 1 Inter Process Communication & Timers. 2 Time.h (page R:Ch9 pp302-320) #include time_t time(time_t *calptr); Epoch: 00:00 (midnight), Jan 1, 1970 GMT](https://reader035.vdocuments.site/reader035/viewer/2022062315/5697c0051a28abf838cc5004/html5/thumbnails/16.jpg)
16
Deadlock e.g Consumer waits for producer to insert a new item but Producer is waiting for Consumer to release mutex
putItem(data) {
mutex_lock(mutex) #2
sem_wait(slots) buffer[ insertPtr]= … insertPtr=…sem_post(items)mutex_unlock(mutex)}
getItem() {
mutex_lock(mutex)
sem_wait(items) BLOCKS #1 result=buffer[ removePtr ]; removePtr=…sem_post(slots)mutex_unlock(mutex)}
![Page 17: 1 Inter Process Communication & Timers. 2 Time.h (page R:Ch9 pp302-320) #include time_t time(time_t *calptr); Epoch: 00:00 (midnight), Jan 1, 1970 GMT](https://reader035.vdocuments.site/reader035/viewer/2022062315/5697c0051a28abf838cc5004/html5/thumbnails/17.jpg)
17
Analysis#2
putItem(data) {
sem_wait(slots)
mutex_lock(mutex) buffer[ insertPtr]= … insertPtr=…sem_post(items)
mutex_unlock(mutex)}
getItem() {
sem_wait(items)
sem_post(slots)
mutex_lock(mutex)
result=buffer[ removePtr ];
removePtr=…
mutex_unlock(mutex)
}
![Page 18: 1 Inter Process Communication & Timers. 2 Time.h (page R:Ch9 pp302-320) #include time_t time(time_t *calptr); Epoch: 00:00 (midnight), Jan 1, 1970 GMT](https://reader035.vdocuments.site/reader035/viewer/2022062315/5697c0051a28abf838cc5004/html5/thumbnails/18.jpg)
18
Buffer overflow when reader removes item from a full buffer: Producer inserts item too earlyputItem(data) {
sem_wait(slots)
mutex_lock(mutex) buffer[ insertPtr]= … insertPtr=…sem_post(items)
mutex_unlock(mutex)}
getItem() {
sem_wait(items)
sem_post(slots)
mutex_lock(mutex)
result=buffer[ removePtr ];
removePtr=…
mutex_unlock(mutex)}
![Page 19: 1 Inter Process Communication & Timers. 2 Time.h (page R:Ch9 pp302-320) #include time_t time(time_t *calptr); Epoch: 00:00 (midnight), Jan 1, 1970 GMT](https://reader035.vdocuments.site/reader035/viewer/2022062315/5697c0051a28abf838cc5004/html5/thumbnails/19.jpg)
19
First Reader-Writer Problemreaders: read datawriters: write dataRule:
Multiple readers can read the data simultaneouslyOnly one writer can write the data at any timeA reader and a writer cannot be in critical section together.
Locking table: whether any two can be in the critical section simultaneously
Reader Writer
Reader OK No
Writer NO No
![Page 20: 1 Inter Process Communication & Timers. 2 Time.h (page R:Ch9 pp302-320) #include time_t time(time_t *calptr); Epoch: 00:00 (midnight), Jan 1, 1970 GMT](https://reader035.vdocuments.site/reader035/viewer/2022062315/5697c0051a28abf838cc5004/html5/thumbnails/20.jpg)
20
First Readers-Writers Problem(Readers have priority)
Let processes reading do so concurrently
Let processes writing do so one at a time
Introduce semaphores
Semaphore mutex = 1;
Semaphore wrt = 1;
int readc = 0; /* reader counter */
![Page 21: 1 Inter Process Communication & Timers. 2 Time.h (page R:Ch9 pp302-320) #include time_t time(time_t *calptr); Epoch: 00:00 (midnight), Jan 1, 1970 GMT](https://reader035.vdocuments.site/reader035/viewer/2022062315/5697c0051a28abf838cc5004/html5/thumbnails/21.jpg)
21
Writer
while (TRUE) {
Think_up_data(); /*noncritical section*/lock(&wrt);
do writing
unlock(&wrt);
}
Reader while (TRUE) { lock(&mutex); readcount =readcount+1;
if readcount == 1 then lock(&wrt); unlock(&mutex); do reading lock(&mutex)readcount=readcount-1; if readcount == 0 then unlock(&wrt); unlock(&mutex);
Use read data }
![Page 22: 1 Inter Process Communication & Timers. 2 Time.h (page R:Ch9 pp302-320) #include time_t time(time_t *calptr); Epoch: 00:00 (midnight), Jan 1, 1970 GMT](https://reader035.vdocuments.site/reader035/viewer/2022062315/5697c0051a28abf838cc5004/html5/thumbnails/22.jpg)
22
Topics: Hardware/OS Overview Chapter 1.1-1.7 (Stallings) Chapter 2.1-2.2 (Stallings) Chapter 1 (R&R) Keywords Need to know
Processors – registers Interrupts and Interrupt Handling Polling and Programmed I/O Basic Memory principles Kernel mode, user mode Multiprogramming, uni-programming Time sharing Buffer Overflow and security
![Page 23: 1 Inter Process Communication & Timers. 2 Time.h (page R:Ch9 pp302-320) #include time_t time(time_t *calptr); Epoch: 00:00 (midnight), Jan 1, 1970 GMT](https://reader035.vdocuments.site/reader035/viewer/2022062315/5697c0051a28abf838cc5004/html5/thumbnails/23.jpg)
23
Topics: Processes Chapter 3.1-3.4 (Stallings) Chapter 2 and 3 (R&R) Keywords need to know
What is process? What is the difference between process and program? What is the program image layout? Understand argument arrays What does it mean to have a thread-safe function? What is the difference between static and dynamic
variables? What are the major process states? What is the difference between dispatcher and scheduler? What is PCB? What happens when process switches from running to ready
state? What is process chain, process fan?
![Page 24: 1 Inter Process Communication & Timers. 2 Time.h (page R:Ch9 pp302-320) #include time_t time(time_t *calptr); Epoch: 00:00 (midnight), Jan 1, 1970 GMT](https://reader035.vdocuments.site/reader035/viewer/2022062315/5697c0051a28abf838cc5004/html5/thumbnails/24.jpg)
24
Topics: Threads
Chapter 12.1-12.5 (R&R) Chapter 4.1, 4.5 (Stallings) Keywords need to know
What is the difference between processes and threads?
What is the difference between user-level threads and kernel-level threads?
Detaching and joining threads What happens if you if you call exit(1) in a thread? What is a graceful way to exit a thread without
causing process termination?
![Page 25: 1 Inter Process Communication & Timers. 2 Time.h (page R:Ch9 pp302-320) #include time_t time(time_t *calptr); Epoch: 00:00 (midnight), Jan 1, 1970 GMT](https://reader035.vdocuments.site/reader035/viewer/2022062315/5697c0051a28abf838cc5004/html5/thumbnails/25.jpg)
25
Topics: Concurrency (Mutual Exclusion) Chapter 14.1-14.3 (R&R) Chapter 5.1-5.3 (Stallings – and don’t forget Appendix
A about the Software Solutions) Keywords need to know
What are the four conditions to provide appropriate synchronization and enter critical region?
What is the difference between counting semaphore and mutex?
What do sem_wait and sem_post do? How can counting semaphores be implemented using binary
semaphores? How can test_and_set be used for synchronization? How can you make a function atomic? Consider increment (i++) and decrement function (i--). How do
you ensure that race condition does not occur on the shared variable ‘i’ when two processes use them at the same time?
![Page 26: 1 Inter Process Communication & Timers. 2 Time.h (page R:Ch9 pp302-320) #include time_t time(time_t *calptr); Epoch: 00:00 (midnight), Jan 1, 1970 GMT](https://reader035.vdocuments.site/reader035/viewer/2022062315/5697c0051a28abf838cc5004/html5/thumbnails/26.jpg)
26
Topics: Thread Synchronization
Chapter 13.1-13.2 (R&R) Keywords to know
What are mutex locks? How do you initialize mutex locks? When would you use mutex instead of counting
semaphore? When would you use counting semaphore instead
of mutex? Are mutex functions interrupted by signals?
![Page 27: 1 Inter Process Communication & Timers. 2 Time.h (page R:Ch9 pp302-320) #include time_t time(time_t *calptr); Epoch: 00:00 (midnight), Jan 1, 1970 GMT](https://reader035.vdocuments.site/reader035/viewer/2022062315/5697c0051a28abf838cc5004/html5/thumbnails/27.jpg)
27
Topics: Scheduling
Chapter 9.1-9.2 Scheduling (Stallings) Keywords need to know
Scheduling policies FCFC, SJF, Round Robin, Priority Scheduling Preemptive vs. Non-Preemptive Scheduling Queues in Process management – what is ready
queue? How are process states related to process management queues?
What is average waiting time? What is the difference between process waiting
time and turn-around time?
![Page 28: 1 Inter Process Communication & Timers. 2 Time.h (page R:Ch9 pp302-320) #include time_t time(time_t *calptr); Epoch: 00:00 (midnight), Jan 1, 1970 GMT](https://reader035.vdocuments.site/reader035/viewer/2022062315/5697c0051a28abf838cc5004/html5/thumbnails/28.jpg)
28
Topics: Signals
Chapter 8.1-8.5 (R&R Keywords need to know
Signal basic concepts – generating signals, blocked, pending signals, delivered signals, ignored signals, …
What is signal mask and what are the operations to modify signal mask?
What is signal handler? What is the role of sigaction? How do you wait for signals?
![Page 29: 1 Inter Process Communication & Timers. 2 Time.h (page R:Ch9 pp302-320) #include time_t time(time_t *calptr); Epoch: 00:00 (midnight), Jan 1, 1970 GMT](https://reader035.vdocuments.site/reader035/viewer/2022062315/5697c0051a28abf838cc5004/html5/thumbnails/29.jpg)
29
Topics: Timers
Chapter 9.1-9.3 (R&R) Keywords need to know
Understand what the various time functions are for Gettimeofday Understand the different clock resolutions Sleep function
![Page 30: 1 Inter Process Communication & Timers. 2 Time.h (page R:Ch9 pp302-320) #include time_t time(time_t *calptr); Epoch: 00:00 (midnight), Jan 1, 1970 GMT](https://reader035.vdocuments.site/reader035/viewer/2022062315/5697c0051a28abf838cc5004/html5/thumbnails/30.jpg)
30
Topics: Classical Sync Problems
Chapter 5.3 and 6.6 (Stallings ) Keywords need to know
What is the producer-consumer problem? What are the various semaphores in the
producer/consumer solution for? What is the dining philosopher problem? What is the danger of a simple solution for dining
philosopher problem?