【MIT6.S081】Lab7: Multithreading(详细解答版)

实验内容网址：https://xv6.dgs.zone/labs/requirements/lab7.html

本实验的代码分支：https://gitee.com/dragonlalala/xv6-labs-2020/tree/thread2/

Uthread: switching between threads

关键点：线程切换、swtch

思路：

本实验完成的任务为用户级线程系统设计上下文切换机制。在进行本实验前需要仔细阅读11.3 XV6线程切换（一） | MIT6.S081和11.4 XV6线程切换（二） | MIT6.S081这两个文档。从一个线程切换到另一个线程需要保存旧线程的CPU寄存器，并恢复新线程先前保存的寄存器；栈指针和程序计数器被保存和恢复的事实意味着CPU将切换栈和执行中的代码。用户寄存器存在trapframe中，内核线程的寄存器存在context中。在本实验中需要保存和恢复的寄存器是位于context结构体中的寄存器。

为什么RISC-V中有32个寄存器，但是swtch函数中只保存并恢复了14个寄存器？

答：因为switch是按照一个普通函数来调用的，对于有些寄存器，swtch函数的调用者默认swtch函数会做修改，所以调用者已经在自己的栈上保存了这些寄存器，当函数返回时，这些寄存器会自动恢复。所以swtch函数里只需要保存Callee Saved Register就行。因为swtch函数是从C代码调用的，所以我们知道Caller Saved Register会被C编译器保存在当前的栈上。Caller Saved Register大概有15-18个，而我们在swtch函数中只需要处理C编译器不会保存，但是对于swtch函数又有用的一些寄存器。所以在切换线程的时候，我们只需要保存Callee Saved Register。

步骤&代码：

1. 首先定义一个tcontext结构体，结构体的内容与内核中context结构体的内容相同，这里为什么不使用内核中已经定义好的context结构体？因为这是一个用户程序，不好使用内核使用的数据结构。 ra（Return Address）寄存器保存的是当前函数的返回地址,sp（stack pointer）寄存器表示栈顶指针。

struct tcontext {
  uint64 ra;
  uint64 sp;

  // callee-saved
  uint64 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 tcontext my_context;  // 线程切换时需要保存的寄存器
  
};

2. 在线程建立时初始化ra和sp寄存器。将ra 寄存器赋值为func后，函数会跳转到func函数处去执行。sp寄存器赋值为线程的栈顶。不太懂这里为什么是+STACK_SIZE？

void 
thread_create(void (*func)())
{
  struct thread *t;

  for (t = all_thread; t < all_thread + MAX_THREAD; t++) {
    if (t->state == FREE) break;
  }
  t->state = RUNNABLE;
  // YOUR CODE HERE

  t->my_context.ra = (uint64)func;
  t->my_context.sp = (uint64)t->stack + STACK_SIZE;

}

3. 在thread_schedule(void)函数中调用线程切换函数。这个函数保存旧线程的寄存器，恢复新线程的寄存器。这个函数是汇编语言函数。

void 
thread_schedule(void)
{
  struct thread *t, *next_thread;

  /* Find another runnable thread. */
  next_thread = 0;
  t = current_thread + 1;
  for(int i = 0; i < MAX_THREAD; i++){
    if(t >= all_thread + MAX_THREAD)
      t = all_thread;
    if(t->state == RUNNABLE) {
      next_thread = t;
      break;
    }
    t = t + 1;
  }

  if (next_thread == 0) {
    printf("thread_schedule: no runnable threads\n");
    exit(-1);
  }

  if (current_thread != next_thread) {         /* switch threads?  */
    next_thread->state = RUNNING;
    t = current_thread;
    current_thread = next_thread;
    /* YOUR CODE HERE
     * Invoke thread_switch to switch from t to next_thread:
     * thread_switch(??, ??);
     */
    thread_switch((uint64)&t->my_context, (uint64)&next_thread->my_context);
  } else
    next_thread = 0;
}

4. 仿照内核中swtch.S文件中的swtch函数，在uthread_switch.S文件中添加如下代码：

    .text

    /*
         * save the old thread's registers,
         * restore the new thread's registers.
         */

    .globl thread_switch
thread_switch:
    /* YOUR CODE HERE */
    sd ra, 0(a0)
    sd sp, 8(a0)
    sd s0, 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 ra, 0(a1)
    ld sp, 8(a1)
    ld s0, 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)
    
    ret    /* return to ra */

首先，ra寄存器被保存在了a0寄存器指向的地址。a0寄存器对应了thread_switch函数的第一个参数，从前面可以看出这是当前线程的context对象地址 ；a1寄存器对应了thread_switch函数的第二个参数，从前面可以看出这是即将要切换到的下一个线程的context对象地址。

所以函数中上半部分是将当前的寄存器保存在当前线程对应的context对象中，函数的下半部分是将下一个线程的寄存器，也就是我们将要切换到的线程的寄存器恢复到CPU的寄存器中。之后函数就返回了。所以下一个线程的ra寄存器指向的是thread_switch函数返回的地址，也就是thread_schedule函数。

Using threads

关键点：锁

思路：

这道题同时运行两个线程时，会出现丢键的情况，原因就是2个线程同时对哈希表进行insert或者修改，导致插入或者修改不成功。那就在put()函数中加入锁。在某些情况下，并发put()在哈希表中读取或写入的内存中没有重叠，因此不需要锁来相互保护。题目中有5个哈希表，因此每个哈希表都用一个互斥锁，避免插入或者修改哈希表时键的丢失。那么就直接按照这个方法完成代码！

步骤&代码：

1. 定义一个locks数组，有NBUCKET个。

pthread_mutex_t locks[NBUCKET]; // declare a lock

2. 在main()函数中初始化互斥锁。

  if (argc < 2) {
    fprintf(stderr, "Usage: %s nthreads\n", argv[0]);
    exit(-1);
  }
  for (int i = 0; i < NBUCKET; i++)
  {
    pthread_mutex_init(&locks[i], NULL);
  }
  
  nthread = atoi(argv[1]);
  tha = malloc(sizeof(pthread_

3. 在put()函数中开头获得锁，完成插入或者修改后释放锁。

static 
void put(int key, int value)
{
  
  int i = key % NBUCKET;
  pthread_mutex_lock(&locks[i]); // acquire lock
  // is the key already present?
  struct entry *e = 0;
  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(&locks[i]); // release lock
}

Barrier

思路：

本题的目标是在所有线程到达barrier时，才能进入下一轮的循环中。若总共有N个线程，对于前N-1个线程，进入barrier时需要获得锁，然后在cond上睡眠，此时会释放mutex，以供其他线程获得锁来进入barrier内部。当最后一个线程N进入barrier，获取锁。此时其他N-1个线程正在cond上睡眠。线程N唤醒睡在cond的所有线程，此时为了防止线程提前进入到下一个循环，此时锁是线程N持有的，线程N退出barrier前释放锁，然后便可以进行下一轮循环了。

代码：

static void 
barrier()
{
  // YOUR CODE HERE
  // Block until all threads have called barrier() and
  // then increment bstate.round.
  // 获得锁
  pthread_mutex_lock(&bstate.barrier_mutex); // acquire lock
  // 到达barrier的线程数量+1
  bstate.nthread++;
  if(bstate.nthread == nthread){
    // 所有线程都到达barrier
    // 轮数+1
    bstate.round++;
    // 将bstate.nthread 置零，重新开始一轮
    bstate.nthread = 0;
    // 唤醒睡在cond的所有线程
    pthread_cond_broadcast(&bstate.barrier_cond);

  }else{
    // 在cond上进入睡眠，释放锁mutex，在醒来时重新获取
    pthread_cond_wait(&bstate.barrier_cond, &bstate.barrier_mutex);
  }
  // 释放锁
  pthread_mutex_unlock(&bstate.barrier_mutex); // release lock
}