XV6學習（11）Lab thread: Multithreading

代碼放在github上。

這一次實驗感覺挺簡單的，特別是后面兩個小實驗。主要就是對多線程和鎖進行一個學習。

Uthread: switching between threads

這一個實驗是要實現一個簡單的用戶級線程，寫完之后發現原來用戶級線程的簡單實現也沒有想象的那么復雜。

首先定義一個context結構體保存線程上下文，並加入到thread結構體中。在上下文中只需要保存被調用者保存的寄存器，即sp和s0-s11，ra用來保存線程的返回地址，類似於進程中的pc。

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]，因為棧是從高地址向低地址增長的。

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指令來恢復下一個線程的執行。

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之前加鎖，在函數結束時釋放鎖。

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);
  }
  ...
}

表級鎖的結果如下：

$ ./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

可以看出表級鎖多線程的性能甚至比單線程要低，這是因為表級鎖將所有的操作都串行化了，無法利用多線程的性能，而多線程的初始化和切換以及鎖的獲取和釋放本身也會帶來一定的性能開銷。

桶級鎖的結果如下：

$ ./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進行等待。

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);
}