Operating Systems Course: Jacobs University Bremen Date: Dr. Jürgen Schönwälder Deadline:

Transcription

1 Operating Systems Course: Jacobs University Bremen Date: Dr. Jürgen Schönwälder Deadline: Problem Sheet #2 Problem 2.1: home-made busy-waiting semaphore (2+3 = 5 points) In this problem you will implement a busy-waiting semaphore for the x86 architecture. Instead of a tsl (test and set) instruction, on the Intel platform you have an atomic xchg instruction that atomically exchanges the values of a memory location and a register (or two registers). We have provided a wrapper for this instruction, so you do not have to write any assembly code. You can find the skeleton code at a) Implement a simple spinlock where the calling thread spins in a loop (busy waiting) repeatedly checking until the lock becomes available. Provide the implementation for the functions spinlock init(), spinlock lock() and spinlock unlock(). b) Wrap your spinlock in a structure to create a counting semaphore. Again, three functions have to be written: semaphore init(), semaphore up() and semaphore down() with the same semantics as on the slides, except that on semaphore down() the thread sits in a tight loop, rather than sleeping. Solution: p2-solution.c Homebrew spinlocks and semaphores. Josip Dzolonga * * Compile with gcc -m32. typedef int spinlock_t; #define SPINLOCK_LOCKED 1 #define SPINLOCK_UNLOCKED 0 typedef struct spinlock_t splck; int s; semaphore_t; * Atomically set the location pointed by where to the value of * value and return the old value. * * You are not required to understand the assembly code. static int xchg(int * where, int value) int ret; asm ("xchgl (%1), %2 \n\t;" "movl %2, %0 \n\t;" : "=r" (ret) /* output : "r" (where), "r" (value) /* input );

2 return ret; * Lock the spinlock pointed to by splck. static void spinlock_lock(spinlock_t *splck) while (xchg(splck, SPINLOCK_LOCKED) == SPINLOCK_LOCKED) sched_yield(); * Unlock the spinlock pointed to by splck. static void spinlock_unlock(spinlock_t *splck) (void) xchg(splck, SPINLOCK_UNLOCKED); * Initialize the spinlock pointed to by splck. static void spinlock_init(spinlock_t *splck) *splck = SPINLOCK_UNLOCKED; * Perform the UP operation on the semaphore pointed by sem. static void semaphore_up(semaphore_t *sem) spinlock_lock(&sem->splck); sem->s++; spinlock_unlock(&sem->splck); * Perform the DOWN operation on the semaphore pointed by sem. static void semaphore_down(semaphore_t *sem) int ok = 0; while (! ok) spinlock_lock(&sem->splck); if(sem->s > 0) sem->s--; ok = 1; spinlock_unlock(&sem->splck); sched_yield(); * Initialize the semaphore pointed to by sem with the value val.

3 static void semaphore_init(semaphore_t *sem, int val) spinlock_init(&sem->splck); sem->s = val; Problem 2.2: home-made busy-waiting semaphore performance testing (2+1+2 = 5 points) Now, that you have implemented busy-waiting semaphores, let s analyze their behaviour. One might think that they should perform well when we have small critical sections, because the overhead of system calls will be avoided. In this problem you will implement a simple problem with a small critical section and test this hypothesis. a) You have a sequence of 50 coins, each turned either heads up or tails up (they can be arbitrarily initialized). Furthermore, you have T threads and each one flips all of the 50 coins sequentially (and does this for 1,000 times). Write a program that implements this scenario, but make sure that no race condition occurs (one global semaphore will suffice) and that the critical section is small. b) One alternative to spinning in a tight loop would be to yield the processor. Implement this change by making a call to sched yield() (see the man page for details). Now, you have to measure if there will be a difference in performance. One precise way of doing this with nanosecond precision is by calling clock gettime() (see the man page for details). Plot the performance of both versions (with and without sched yield()) as you vary the number of threads from T = 2 to T = 20. c) What can you infer from the graphs? Is there any significant difference? If there is, explain what could be the reason. Solution: a) p2-coins.c Coin flipping test of home-made busy-waiting sempahores Josip Djolonga #if 0 #define YIELD #include <stdlib.h> #include <stdio.h> #include <string.h> #include <assert.h> #include <pthread.h> #include <stdint.h> #include <time.h> #include "p2-solution.c" #define NUM_COINS 50 #define NUM_THREADS 20 #define NUM_ITERATIONS 1000 #define NUM_RETRIES 100 static semaphore_t sem; static int coin[num_coins];

4 static void* worker(void *ptr) int j, i; for (j=0; j < NUM_ITERATIONS; j++) semaphore_down(&sem); for (i=0; i < NUM_COINS; i++) coin[i] = 1 - coin[i]; semaphore_up(&sem); return NULL; static unsigned long run(int num_threads) pthread_t threads[num_threads]; int i; struct timespec start, end; memset(coin, 0, sizeof(coin)); semaphore_init(&sem, 1); clock_gettime(clock_process_cputime_id, &start); for (i=0; i < num_threads; i++) if (pthread_create(threads + i, NULL, worker, NULL)!= 0) perror("pthread_create"); for (i=0; i < num_threads; i++) (void) pthread_join(threads[i], NULL); clock_gettime(clock_process_cputime_id, &end); for (i=0; i < NUM_COINS; i++) assert(coin[i] == 0); /* * Return the measured cpu time in microseconds so that it easily * fits into an unsigned long. return (end.tv_sec * end.tv_nsec / 1000) - (start.tv_sec * start.tv_nsec / 1000); int main(int argc, char *argv[]) pthread_t threads[num_threads]; double us = 0; int i, j; memset(coin, 0, sizeof(coin)); semaphore_init(&sem, 1); for (i=1; i <= NUM_THREADS; i++) /*

5 * Calculate the average cpu time over NUM_RETRIES retries and * print the result it in a gnuplot friendly way. for (j = 0; j < NUM_RETRIES; j++) us = us + 1 / (j+1) * (((double) run(i) / ) - us); printf("%d %lf (%d retries, %s)\n", i, us, NUM_RETRIES, "yield" #else "no-yield" ); return EXIT_SUCCESS; b) Calling sched yield() in the body of the while look in spinlock lock() and at the end of the while loop in semaphore down() leads to significant performace improvements. 6 CPU time (measured on cook using clock_gettime(clock_process_cputime_id,...) no-yield yield 5 CPU time in seconds Number of concurrent threads c) With the call the sched yield(), a thread spins until the next context switch or some other thread releases the lock. In case the number of concurrent threads grows larger than the number of available cores, the likelihood increases that a thread spins until its timeslice expires. By calling sched yield(), a context switch happens earlier, thus reducing the spinning time.