程式碼放在[github](https://github.com/weijunji/xv6-6.S081)上。 這一次實驗感覺挺簡單的，特別是後面兩個小實驗。主要就是對多執行緒和鎖進行一個學習。 ## Uthread: switching between threads 這一個實驗是要實現一個簡單的使用者級執行緒，寫完之後發現原來使用者級執行緒的簡單實現也沒有想象的那麼複雜。 首先定義一個`context`結構體儲存執行緒上下文，並加入到`thread`結構體中。在上下文中只需要儲存被呼叫者儲存的暫存器，即`sp`和`s0-s11`，`ra`用來儲存執行緒的返回地址，類似於程序中的`pc`。 ```c struct thread_context{ uint64 ra; uint64 sp; uint64 fp; // s0 uint64 s1; uint64 s2; uint64 s3; uint64 s4; uint64 s5; uint64 s6; uint64 s7; uint64 s8; uint64 s9; uint64 s10; uint64 s11; }; struct thread { char stack[STACK_SIZE]; /* the thread's stack */ int state; /* FREE, RUNNING, RUNNABLE */ struct thread_context context; /* context of thread */ }; ``` 之後在`thread_create`中加入初始化程式碼，使`ra`指向執行緒的入口函式，`sp`和`fp`指向棧底。注意棧底應該是`t->stack[STACK_SIZE - 1]`，因為棧是從高地址向低地址增長的。 ```c void thread_create(void (*func)()) { ... // YOUR CODE HERE t->context.ra = (uint64)func; t->context.sp = (uint64)&t->stack[STACK_SIZE - 1]; t->context.fp = (uint64)&t->stack[STACK_SIZE - 1]; } ``` 最後實現`thread_switch`函式並在`thread_schedule`中通過`thread_switch((uint64)&t->context, (uint64)&next_thread->context);`呼叫即可。`thread_switch`需要對上下文進行保護和恢復，並通過設定`ra`暫存器和`ret`指令來恢復下一個執行緒的執行。 ```asm thread_switch: /* YOUR CODE HERE */ sd ra, 0(a0) sd sp, 8(a0) sd fp, 16(a0) sd s1, 24(a0) sd s2, 32(a0) sd s3, 40(a0) sd s4, 48(a0) sd s5, 56(a0) sd s6, 64(a0) sd s7, 72(a0) sd s8, 80(a0) sd s9, 88(a0) sd s10, 96(a0) sd s11, 104(a0) ld sp, 8(a1) ld fp, 16(a1) ld s1, 24(a1) ld s2, 32(a1) ld s3, 40(a1) ld s4, 48(a1) ld s5, 56(a1) ld s6, 64(a1) ld s7, 72(a1) ld s8, 80(a1) ld s9, 88(a1) ld s10, 96(a1) ld s11, 104(a1) ld ra, 0(a1) /* set return address to next thread */ ret /* return to ra */ ``` ## Using threads 這一個實驗是通過對雜湊表的並行操作來練習鎖的使用。程式碼就只放桶級鎖的。 因為測試程式是將put和get操作進行了分離的，因此只需要考慮put操作之間的互斥。在`put`函式讀寫bucket之前加鎖，在函式結束時釋放鎖。 ```c pthread_mutex_t lock[NBUCKET]; // 定義鎖 static void put(int key, int value) { int i = key % NBUCKET; // is the key already present? struct entry *e = 0; pthread_mutex_lock(&lock[i]); // 獲取鎖 for (e = table[i]; e != 0; e = e->next) { if (e->key == key) break; } if(e){ // update the existing key. e->value = value; } else { // the new is new. insert(key, value, &table[i], table[i]); } pthread_mutex_unlock(&lock[i]); // 釋放鎖 } int main(int argc, char *argv[]) { ... // 初始化鎖 for (int i = 0; i < NBUCKET; i++) { pthread_mutex_init(&lock[i], NULL); } ... } ``` 表級鎖的結果如下： ```shell $ ./ph 1 100000 puts, 7.336 seconds, 13631 puts/second 0: 0 keys missing 100000 gets, 7.599 seconds, 13160 gets/second $ ./ph 2 100000 puts, 8.965 seconds, 11155 puts/second 1: 0 keys missing 0: 0 keys missing 200000 gets, 7.397 seconds, 27036 gets/second ``` 可以看出表級鎖多執行緒的效能甚至比單執行緒要低，這是因為表級鎖將所有的操作都序列化了，無法利用多執行緒的效能，而多執行緒的初始化和切換以及鎖的獲取和釋放本身也會帶來一定的效能開銷。 桶級鎖的結果如下： ```shell $ ./ph 1 100000 puts, 7.429 seconds, 13461 puts/second 0: 0 keys missing 100000 gets, 7.242 seconds, 13809 gets/second $ ./ph 2 100000 puts, 4.472 seconds, 22359 puts/second 0: 0 keys missing 1: 0 keys missing 200000 gets, 7.347 seconds, 27221 gets/second ``` 可以看出在使用桶級鎖的情況下，多執行緒能夠帶來一定的加速，因為桶級鎖是允許不同桶之間的操作並行執行的，從而能夠利用多執行緒的優勢。 ## Barrier 這一個實驗是要實現一個屏障點，使所有執行緒都到達這個點之後才能繼續執行。主要就是練習POSIX的條件變數的使用。 只需要實現一個`barrier`函式即可。函式實現也沒有什麼多說的，就是加鎖然後判斷到達屏障點的執行緒數，如果所有執行緒都到達了就呼叫`pthread_cond_broadcast`喚醒其他執行緒，否則就呼叫`pthread_cond_wait`進行等待。 ```c static void barrier() { pthread_mutex_lock(&bstate.barrier_mutex); bstate.nthread++; if(bstate.nthread == nthread){ bstate.round++; bstate.nthread = 0; pthread_cond_broadcast(&bstate.barrier_cond); }else{ pthread_cond_wait(&bstate.barrier_cond, &bstate.barrier_mutex); } pthread_mutex_unlock(&bstate.barrier_mutex); } ```