Spike模拟器上RISC-V代理内核的多核启动

Anemone 发布于

最后更新于

文章访问量

lab1_challenge3 多核启动及运行

挑战内容

该挑战包含2个应用程序user/app0.c和user/app1.c,之前的实验都在单核环境下进行,在本次实验中，需要修改操作系统内核使其支持两核并发运行，并且在每个核上加载一个程序运行，等到两个程序都执行完毕后退出并关闭模拟器。

应用

  • user/app0.c
    1
    2
    3
    4
    5
    6
    7
    #include "user_lib.h"
    #include "util/types.h"

    int main(void) {
      printu(">>> app0 is expected to be executed by hart0\n");
      exit(0);
    }
  • user/app1.c
    1
    2
    3
    4
    5
    6
    7
    #include "user_lib.h"
    #include "util/types.h"

    int main(void) {
      printu(">>> app1 is expected to be executed by hart1\n");
      exit(0);
    }

具体情况

在RISC-V处理器中，每一个CPU称作一个hart(hardware thread)，并从0开始编号。此实验要求启动两个CPU，它们的编号分别为0和1。

  • 本实验中，需要修改内核代码，使得riscv-pke能够通过spike启动两个CPU(hart)，并且让CPU0执行app0，让CPU1执行app1。
  • user0.lds和user1.lds中规定了app0从0x81000000处开始加载，app1从0x81500000处开始加载。
  • kernel/config.h中的NCPU规定了操作系统内核支持的核数，在本实验设置为2，即需要能够通过spike -p2 riscv-pke app0 app1让pke正确地启动两核并发的操作系统并执行app0和app1。
  • 内核中有很多使用sprint输出的内容，为了分别每一条输出是哪个核执行的，需要在相应的sprint处添加一个hartid的输出项。

输入

1
2
3
4
$ git checkout lab1_challenge3_multicore
$ git merge lab1_3_irq -m "continue to work on lab1_challenge3"
$ make clean;make
$ spike -p2 ./obj/riscv-pke ./obj/app0 ./obj/app1

输出

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
HTIF is available!
(Emulated) memory size: 2048 MB
In m_start, hartid:0
hartid = 0: Enter supervisor mode...
hartid = 0: Application: ./obj/app0
hartid = 0: Application program entry point (virtual address): 0x0000000081000000
hartid = 0: Switch to user mode...
In m_start, hartid:1
hartid = 1: Enter supervisor mode...
hartid = 1: Application: ./obj/app1
hartid = 1: Application program entry point (virtual address): 0x0000000085000000
hartid = 1: Switch to user mode...
hartid = 0: >>> app0 is expected to be executed by hart0
hartid = 1: >>> app1 is expected to be executed by hart1
hartid = 0: User exit with code:0.
hartid = 1: User exit with code:0.
hartid = 0: shutdown with code:0.
System is shutting down with exit code 0.

指导

  • spike模拟器通过HTIF与host机器的物理设备进行交互，在pke启动时，会在M mode对spike模拟器的一些虚拟设备和HTIF接口进行初始化。这个初始化的过程只能被执行一次，而非每个核都执行一次。并且在spike和HTIF初始化完成之前，需要用同步机制保证每个核都不会访问他们相应的资源。
  • 每个核的时钟周期和时钟中断应该是独立的，不能受其他核的干扰。即你需要分开管理每个hart上运行应用的tick。
  • 单核实验中，pke会从命令行第一个参数加载应用程序，但是本次实验需要从命令行前两个参数加载两个程序。你需要阅读并修改elf.c来让pke能从命令行加载第二个app。
  • 之前的实验在单核的基础上开展，且没有内存管理机制，所以user app使用到的一些内存地址是固定的（见kernel/config.h）。即使实验基础代码在elf文件中为两个app指定了不同的起始地址，两个核同时加载并运行的它们时，其部分内存地址也会重叠并出错。你应当想办法分离两个app的内存。
  • 在之前的单核实验中，有一个全局的current变量来指示当前正在执行的进程，以便处理中断。然而在多核环境下，每个核的中断是独立的，在处理好中断后，各个核应当恢复到其原本执行的用户app。你需要让每个核能知道他们在执行什么app。
  • 在单核环境下，一个核的用户进程调用exit退出时，会立即关闭模拟器；而在多核环境下，这会强使其他核也停止工作。正确的退出方式是，同步等到所有核执行完毕之后再关闭模拟器。本次实验中，你应当让CPU0负责关闭模拟器。

具体内容

1.mint.c/m_start更改，确保多核启动时只进行一次初始化操作，并对counter变量原子操作。

1
2
3
4
5
6
7
8
9
//
// m_start: machine mode C entry point.
//
void m_start(uintptr_t hartid, uintptr_t dtb) {
  spike_file_init();
  sprint("In m_start, hartid:%d\n", hartid);
  init_dtb(dtb);
  ...
}

改为

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//
// m_start: machine mode C entry point.
//
int counter = 0;
void m_start(uintptr_t hartid, uintptr_t dtb) {
  // only cpu0 (hartid == 0) will init
  if (hartid == 0) {
    // init the spike file interface (stdin,stdout,stderr)
    // functions with "spike_" prefix are all defined in codes under spike_interface/,
    // sprint is also defined in spike_interface/spike_utils.c
    spike_file_init();
    // init HTIF and memory by using the Device Table Blob (DTB)
    // init_dtb() is defined above.
    init_dtb(dtb);
  }
  sync_barrier(&counter, NCPU);
  sprint("In m_start, hartid:%d\n", hartid);

 ...
}

2.strap.c/smode_trap_handler更改，确保每个核的时钟周期和时钟中断独立。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// global variable that store the recorded "ticks". added @lab1_3
static uint64 g_ticks[NCPU] = {0};
//
void handle_mtimer_trap() {
  sprint("Ticks %d\n", g_ticks);
  // TODO (lab1_3): increase g_ticks to record this "tick", and then clear the "SIP"
  // field in sip register.
  // hint: use write_csr to disable the SIP_SSIP bit in sip.
  g_ticks[read_tp()]++;
  write_csr(sip, !SIP_SSIP);
}
// kernel/smode_trap.S will pass control to smode_trap_handler, when a trap happens
// in S-mode.
//
void smode_trap_handler(void) {
  ...

  assert(read_tp() < NCPU);
  process *p = &apps[read_tp()];
  // save user process counter.
  p->trapframe->epc = read_csr(sepc);

  ...

  // continue (come back to) the execution of current process.
  switch_to(p);
}

3.process.c更改，将全局current变量来改为process数组，确保多核环境下每个核的中断是独立的，在处理好中断后，各个核恢复到其原本执行的用户app。

1
2
3
4
5
6
7
8
9
10
11
// current points to the currently running user-mode application.
process* current = NULL;
//
// switch to a user-mode process
//
void switch_to(process* proc) {
  assert(proc);
  current = proc;
...
}

改为

1
2
3
4
5
6
7
8
9
10
11
// processes that are running on each CPU
process apps[NCPU];
//
// switch to a user-mode process
//
void switch_to(process* proc) {
  assert(proc);
...
  proc->trapframe->hartid = read_tp();
...
}

4.config.h内容，防止不同app内存重叠，分离两个app的内存。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#ifndef _CONFIG_H_
#define _CONFIG_H_

// we use two HART (cpu) in challenge3
#define NCPU 2

//interval of timer interrupt. added @lab1_3
#define TIMER_INTERVAL 1000000

#define DRAM_BASE (0x80000000 + (uint64)read_tp() * 0x4000000)

/* we use fixed physical (also logical) addresses for the stacks and trap frames as in
 Bare memory-mapping mode */
// user stack top
#define USER_STACK (0x81100000 + (uint64)read_tp() * 0x4000000)

// the stack used by PKE kernel when a syscall happens
#define USER_KSTACK (0x81200000 + (uint64)read_tp() * 0x4000000)

// the trap frame used to assemble the user "process"
#define USER_TRAP_FRAME (0x81300000 + (uint64)read_tp() * 0x4000000)

#endif

5.elf.c修改,让pke能从命令行加载第二个app。

1
2
3
4
5
6
7
8
9
10
11
12
13
//
// load the elf of user application, by using the spike file interface.
//
void load_bincode_from_host_elf(process *p) {
    // added
    int hartid = read_tp();
    ...
    sprint("hartid = %d: Application: %s\n", hartid, arg_bug_msg.argv[hartid]);
    ...
    info.f = spike_file_open(arg_bug_msg.argv[hartid], O_RDONLY, 0);
    ...
    sprint("hartid = %d: Application program entry point (virtual address): 0x%lx\n", hartid, p->trapframe->epc);
}

6.sysycall.c,多核环境下程序的正确退出方式，同步等到所有核执行完毕之后再关闭模拟器。本次实验中，让CPU0负责关闭模拟器。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
int exit_counter = 0;
//
// implement the SYS_user_exit syscall
//
ssize_t sys_user_exit(uint64 code) {
  int hartid = read_tp();
  sprint("hartid = %d: User exit with code:%d.\n", hartid, code);
  // in lab1, PKE considers only one app (one process). 
  // therefore, shutdown the system when the app calls exit()
  sync_barrier(&exit_counter, NCPU);
  if (hartid == 0) {
    sprint("hartid = %d: shutdown with code:%d.\n", hartid, code);
    shutdown(code);
  }
  while (1);
  return 0;
}

参考文档: 采用RISC-V代理内核的操作系统和系统能力培养实验

Anemone_

Anemone_

贵在坚持

6
3
0
NOTICE

技术支持:华为云OBS、Github-Page、阿里云域名、LeanCloud、Hexo、theme-Flexblock、Avatars

CATEGORYS
TAGS