76 lines
2.4 KiB
Plaintext
76 lines
2.4 KiB
Plaintext
Jose Caban
|
|
gtg184g
|
|
CS4210 HW#1
|
|
|
|
Question 1:
|
|
-----------
|
|
|
|
struct RecMutex {
|
|
pthread_mutex_t mutex;
|
|
pthread_cond_t locked;
|
|
int lock;
|
|
int owner;
|
|
};
|
|
|
|
int rec_mutex_lock(RecMutex *rmutex) {
|
|
|
|
//CurrentThread is owner, increment lock
|
|
if (rmutex->owner == CurrentThread()) {
|
|
rmutex->lock++;
|
|
return 0;
|
|
} else {
|
|
//Lock the mutex
|
|
pthread_mutex_lock(&(rmutex->mutex));
|
|
|
|
//Wait until the lock is free
|
|
while (rmutex->lock != 0) {
|
|
pthread_cond_wait( &(rmutex->locked), &(rmutex->mutex) );
|
|
}
|
|
|
|
//Set structure paramaters
|
|
rmutex->owner = CurrentThread();
|
|
rmutex->lock = 1;
|
|
pthread_mutex_unlock(&(rmutex->mutex));
|
|
|
|
return 0; //Everything is A-OK
|
|
}
|
|
}
|
|
|
|
int rec_mutex_unlock(RecMutex *rmutex) {
|
|
if (rmutex->owner == CurrentThread()) {
|
|
rmutex->lock--;
|
|
} else {
|
|
return -2; //called without reason = error
|
|
}
|
|
|
|
if (rmutex->lock == 0) {
|
|
rmutex->owner = -1;
|
|
pthread_cond_signal(&(rmutex->locked));
|
|
} else if (rmutex->lock < 0) {
|
|
return -1; //lock is broken = error
|
|
}
|
|
|
|
return 0; //everything is A-OK
|
|
}
|
|
|
|
int rec_mutex_init(RecMutex *rmutex) {
|
|
pthread_mutex_init(&(rmutex->mutex), NULL);
|
|
pthread_cond_init(&(rmutex->locked),NULL);
|
|
rmutex->lock = 0;
|
|
rmutex->owner = -1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
Question 2:
|
|
-----------
|
|
|
|
a) No context switch is needed (everything done at user level). Very fast since only a stack and program counter need to be switched.
|
|
b) The LWP has to be switched. This is relatively slow as it has to switch the process control block (with associated register data), accounting information, and memory information.
|
|
c) Full Context switch is needed. Slowest of these 4 situations. The memory address space has to be switched to that of the other process in addition to all the other contents of the LWP's associated with that process.
|
|
d) Faster than b and c (but slower than a) as it just requires switching between kernel threads. This basically means switching a small data structure and stack and is relatively fast.
|
|
|
|
Question 3:
|
|
-----------
|
|
|
|
Possible. Requires change to unlock return values to avoid using C++ local variables. I just didn't figure out the macro on my own, so I can't write it here out of pride :( |