멀티 태스크

1struct TaskContext {
2  uint64_t cr3, rip, rflags, reserved1;             // offset 0x00
3  uint64_t cs, ss, fs, gs;                          // offset 0x20
4  uint64_t rax, rbx, rcx, rdx, rdi, rsi, rsp, rbp;  // offset 0x40
5  uint64_t r8, r9, r10, r11, r12, r13, r14, r15;    // offset 0x80
6  std::array<uint8_t, 512> fxsaved_area;            // offset 0xc0
7} __attribute__((packed));

 1; Registers: RDI, RSI
 2global SwitchContext
 3SwitchContext:  ; void SwitchContext(void* next_ctx, void* current_ctx);
 4    mov [rsi + 0x40], rax
 5    mov [rsi + 0x48], rbx
 6    mov [rsi + 0x50], rcx
 7    mov [rsi + 0x58], rdx
 8    mov [rsi + 0x60], rdi
 9    mov [rsi + 0x68], rsi
10
11    lea rax, [rsp + 8]     ; call SwitchContext 로 들어왔기 때문에 rsp가 push(-8) 되어 있을 것이다. 
12    mov [rsi + 0x70], rax  ; RSP
13    mov [rsi + 0x78], rbp
14
15    mov rax, [rsp]         ; 마찬가지로 call SwitchContext 로 들어왔기 때문에 현재 rsp는 리턴주소가 있을 것이다.
16    mov [rsi + 0x08], rax  ; RIP   
17    mov rax, cr3
18    mov [rsi + 0x00], rax  ; CR3
19    pushfq
20    pop qword [rsi + 0x10] ; RFLAGS
21
22    fxsave [rsi + 0xc0]    ; XMM0 등 의 부동소수점 레지스터 저장
23    // ...
24
25    ; iret 을 사용하기 위한 스택프레임 세팅
26    push qword [rdi + 0x28] ; SS
27    push qword [rdi + 0x70] ; RSP
28    push qword [rdi + 0x10] ; RFLAGS
29    push qword [rdi + 0x20] ; CS
30    push qword [rdi + 0x08] ; RIP
31
32    fxrstor [rdi + 0xc0]
33
34    mov rax, [rdi + 0x40]
35    mov rbx, [rdi + 0x48]
36    mov rcx, [rdi + 0x50]
37
38    // rdi는 사용중이기 때문에 맨 마지막에..
39    mov rdi, [rdi + 0x60]
40
41    o64 iret

 1// 일단 동시?에 실행시킬 TaskB 함수를 만든다. 
 2void TaskB(int task_id, int data) { ... }
 3
 4// 태스크 전환 시 저장할 레지스터들을 담을 컨텍스트
 5alignas(16) TaskContext task_b_ctx, task_a_ctx;
 6
 7extern "C" void KernelMainNewStack(...) {
 8  // TaskB 를 실행할 컨텍스트는 직접 지정해야한다. 
 9  std::vector<uint64_t> task_b_stack(1024);
10  uint64_t task_b_stack_end = reinterpret_cast<uint64_t>(&task_b_stack[1024]);
11
12  memset(&task_b_ctx, 0, sizeof(task_b_ctx));
13  task_b_ctx.rip = reinterpret_cast<uint64_t>(TaskB);
14  task_b_ctx.rdi = 1;    // Task B 의 첫번째 인자
15  task_b_ctx.rsi = 42;   // Task B 의 두번째 인자
16
17  // 페이징 테이블을 가리키는 CR3, 세그멘테이션, 플래그 레지스터 세팅 
18  task_b_ctx.cr3 = GetCR3();   // 현재 값 그대로 씀
19  task_b_ctx.rflags = 0x202;   // 0x200 은 IF(인터럽트)라서 세팅해야 인터럽트를 받을 수 있다.
20  task_b_ctx.cs = kKernelCS;   // 현재 값 그대로 씀
21  task_b_ctx.ss = kKernelSS;
22  // x86_64 스택 얼라인먼트 제약으로 인해 16byte로 정렬하고, 
23  // 리턴주소를 push한 것 처럼 8byte만큼 미리 빼둔다. 
24  task_b_ctx.rsp = (task_b_stack_end & ~0xflu) - 8;
25
26  // [24:27]은 부동소수점 계산 관련 MXCSR 레지스터(4byte)인데, 
27  // 부동소수점을 사용하지 않아도 세팅해야 정상적으로 동작하기 때문에 세팅함. 
28  *reinterpret_cast<uint32_t*>(&task_b_ctx.fxsaved_area[24]) = 0x1f80;

1  // event loop
2  while (true) {
3    // ...
4    __asm__("cli");
5    if (main_queue->size() == 0) {
6      __asm__("sti");
7      SwitchContext(&task_b_ctx, &task_a_ctx);
8      continue;
9    }

 1void TaskB(int task_id, int data) {
 2  printk("TaskB: task_id=%d, data=%d\n", task_id, data);
 3  char str[128];
 4  int count = 0;
 5  // TaskB 관련 작업
 6  while (true) {
 7    ++count;
 8    sprintf(str, "%010d", count);
 9    FillRectangle(*task_b_window->Writer(), {24, 28}, {8 * 10, 16}, {0xc6, 0xc6, 0xc6});
10    WriteString(*task_b_window->Writer(), {24, 28}, str, {0, 0, 0});
11    // Task B의 context에서 Task A(메인스레드)의 context로 전환
12    SwitchContext(&task_a_ctx, &task_b_ctx);
13  }
14}

 1const int kTaskTimerPeriod = static_cast<int>(kTimerFreq * 0.02);
 2const int kTaskTimerValue = std::numeric_limits<int>::min();
 3
 4void InitializeTask() {
 5  current_task = &task_a_ctx;
 6
 7  __asm__("cli");
 8  timer_manager->AddTimer(
 9    Timer{timer_manager->CurrentTick() + kTaskTimerPeriod, kTaskTimerValue});
10  __asm__("sti");
11}

 1bool TimerManager::Tick() {
 2  ++tick_;
 3
 4  bool task_timer_timeout = false;
 5  while (true) {
 6    const auto& t = timers_.top();
 7    if (t.Timeout() > tick_) {
 8      break;
 9    }
10
11    if (t.Value() == kTaskTimerValue) {
12      task_timer_timeout = true;
13      timers_.pop();
14      timers_.push(Timer{tick_ + kTaskTimerPeriod, kTaskTimerValue});
15      continue;
16    }
17
18    Message m{Message::kTimerTimeout};
19    m.arg.timer.timeout = t.Timeout();
20    m.arg.timer.value = t.Value();
21    msg_queue_.push_back(m);
22
23    timers_.pop();
24  }
25
26  return task_timer_timeout;
27}

1void LAPICTimerOnInterrupt() {
2  const bool task_timer_timeout = timer_manager->Tick();
3  NotifyEndOfInterrupt();
4
5  if (task_timer_timeout) {
6    // 그냥 내부적으로 Task A <-> Task B 를 반복하는 함수이다. 
7    SwitchTask();
8  }
9}

 1// 함수 포인터를 쉽게 사용하기 위해 Task의 entry 함수 타입을 정의한다.
 2using TaskFunc = void (uint64_t, int64_t);
 3
 4class Task {
 5public:
 6  static const size_t kDefaultStackBytes = 4096;
 7  Task(uint64_t id);
 8  Task& InitContext(TaskFunc* f, int64_t data);
 9  TaskContext& Context();
10
11private:
12  uint64_t id_;
13  std::vector<uint64_t> stack_;
14  alignas(16) TaskContext context_;
15};
16
17// 이전에는 수동으로 작업하던 컨텍스트 초기화를 함수로 만듦
18Task& Task::InitContext(TaskFunc* f, int64_t data) {
19  // 스택은 4096 byte
20  const size_t stack_size = kDefaultStackBytes / sizeof(stack_[0]);
21  stack_.resize(stack_size);
22  uint64_t stack_end = reinterpret_cast<uint64_t>(&stack_[stack_size]);
23
24  memset(&context_, 0, sizeof(context_));
25  context_.cr3 = GetCR3();
26  context_.rflags = 0x202;
27  context_.cs = kKernelCS;
28  context_.ss = kKernelSS;
29  context_.rsp = (stack_end & ~0xflu) - 0x8;
30  context_.rip = reinterpret_cast<uint64_t>(f);
31  context_.rdi = id_;
32  context_.rsi = data;
33
34  *reinterpret_cast<uint32_t*>(&context_.fxsave_area[24]) = 0x1f80;
35  return *this;
36}

 1class TaskManager {
 2public:
 3  TaskManager();
 4  Task& NewTask();
 5  void SwitchTask();
 6
 7private:
 8  std::vector<std::unique_ptr<Task>> tasks_{};
 9  uint64_t latest_id_{0};
10  size_t current_task_index_{0};
11};
12
13TaskManager::TaskManager() {
14  // TaskManager가 생성될때 커널의 Task를 하나 만든다.
15  NewTask();
16}
17
18// 이전에는 Task a와 b만 전환했는데, task_manager가 관리하는 모든 태스크를 20ms 씩 실행시킨다. 
19void TaskManager::SwitchTask() {
20  size_t next_task_index = current_task_index_ + 1;
21  if (next_task_index >= tasks_.size()) {
22    next_task_index = 0;
23  }
24  Task& current_task = *tasks_[current_task_index_];
25  Task& next_task = *tasks_[next_task_index];
26  current_task_index_ = next_task_index;
27
28  SwitchContext(&next_task.Context(), &current_task.Context());
29}

 1class TaskManager {
 2public:
 3  TaskManager();
 4  Task& NewTask();
 5  void SwitchTask(bool current_sleep = false);
 6
 7  // 태스크를 직접적으로 컨트롤하는 슬립과 웨이크업 함수
 8  void Sleep(Task* task);
 9  Error Sleep(uint64_t id);
10  void Wakeup(Task* task);
11  Error Wakeup(uint64_t id);
12
13private:
14  std::vector<std::unique_ptr<Task>> tasks_{};
15  uint64_t latest_id_{0};
16  // 실행 큐. [0] 인덱스의 태스크가 현재 실행중인 태스크로 간주한다.
17  std::deque<Task*> running_{};
18};
19
20void TaskManager::SwitchTask(bool current_sleep) {
21  Task* current_task = running_.front();
22  running_.pop_front();
23  // 슬립으로 전환할 태스크가 아니라면 실행 큐의 맨 뒤에 다시 삽입한다. 
24  if (!current_sleep) {
25    running_.push_back(current_task);
26  }
27  Task* next_task = running_.front();
28
29  SwitchContext(&next_task.Context(), &current_task.Context());
30}
31
32void TaskManager::Sleep(Task* task) {
33  auto it std::find(running_.begin(), running_.end(), task);
34  // 맨 앞에서 발견됐다는 것은 실행중인 태스크(자기자신)라는 의미이다.
35  if (it == running_.begin()) {
36    // 20ms를 다 사용하지 않고 즉시 컨텍스트 스위칭 (+실행큐에서 제거)
37    SwitchTask(true);
38    return;
39  }
40
41  if (it == running_.end()) {
42    return;
43  }
44  // 해당되는 태스크를 실행큐에서 삭제함 
45  running_.erase(it);
46}

 1class Task {
 2public:
 3  static const size_t kDefaultStackBytes = 4096;
 4  Task(uint64_t id);
 5  Task& InitContext(TaskFunc* f, int64_t data);
 6  TaskContext& Context();
 7  uint64_t ID() const;
 8  Task& Sleep();
 9  Task& Wakeup();
10  void SendMessage(const Message& msg);
11  std::optional<Message> ReceiveMessage();
12
13private:
14  uint64_t id_;
15  std::vector<uint64_t> stack_;
16  alignas(16) TaskContext context_;
17  std::deque<Message> msgs_;
18};
19
20// 자신의 메시지큐에 메시지를 넣고 태스크가 실행될수 있도록 CPU를 할당(Wakeup)해준다.
21void Task::SendMessage(const Message& msg) {
22  msgs_.push_back(msg);
23  Wakeup();
24}
25
26// 메시지가 있다면 Message 리턴, 없다면 nullopt를 리턴한다.
27// task_manager에서 각 태스크에 메시지가 들어왔는지 확인하고 메시지를 처리할 수 있도록한다. 
28std::optional<Message> Task::ReceiveMessage() {
29  if (msgs_.empty()) {
30    return std::nullopt;
31  }
32
33  auto m = msgs_.front();
34  msgs_.pop_front();
35  return m;
36}

 1  // event loop
 2  while (true) {
 3    __asm__("cli");
 4    const auto tick = timer_manager->CurrentTick();
 5
 6    // 이벤트 루프 안에서 main_task의 메시지 큐를 이용해야 한다.
 7    // 메시지가 없다면 Sleep 상태로 두고, 메시지가 큐에 들어갈때 Wakeup이 호출될 것이다. 
 8    auto msg = main_task.ReceiveMessage();
 9    if (!msg) {
10      main_task.Sleep();
11      __asm__("sti");
12      continue;
13    }
14    __asm__("sti");

 1__attribute__((interrupt))
 2void IntHandlerXHCI(InterruptFrame* frame) {
 3  // 1번 태스크에 메시지를 보낸다.
 4  task_manager->SendMessage(1, Message{Message::kInterruptXHCI});
 5  NotifyEndOfInterrupt();
 6}
 7
 8__attribute__((interrupt))
 9void IntHandlerLAPICTimer(InterruptFrame* frame) {
10  LAPICTimerOnInterrupt();
11}
12
13void LAPICTimerOnInterrupt() {
14  // Tick 함수 안에서 SendMessage 를 한다. 
15  const bool task_timer_timeout = timer_manager->Tick();
16  NotifyEndOfInterrupt();
17
18  if (task_timer_timeout) {
19    task_manager->SwitchTask();
20  }
21}

 1class TaskManager {
 2public:
 3  // level: 0 lowest, kMaxLevel = highest
 4  static const int kMaxLevel = 3;
 5
 6  TaskManager();
 7  Task& NewTask();
 8  void SwitchTask(bool current_sleep = false);
 9
10  void Sleep(Task* task);
11  Error Sleep(uint64_t id);
12  // 태스크를 깨울(실행시킬) 때 어떤 레벨의 큐에 넣을지 우선순위를 지정해줘야 한다. 
13  void Wakeup(Task* task, int level = -1);
14  Error Wakeup(uint64_t id, int level = -1);
15  Error SendMessage(uint64_t id, const Message& msg);
16  Task& CurrentTask();
17
18private:
19  std::vector<std::unique_ptr<Task>> tasks_{};
20  uint64_t latest_id_{0};
21  // 레벨이 0 ~ kMaxLevel 이기 때문에 레벨만큼 러닝큐를 만들어야 한다.
22  std::array<std::deque<Task*>, kMaxLevel + 1> running_{};
23  int current_level_{kMaxLevel};
24  bool level_changed_{false};
25  // 태스크의 레벨을 변경하는 함수
26  void ChangeLevelRunning(Task* task, int level);
27};
28
29// 태스크 변경 시 우선순위를 생각해서 변경해야 한다. 
30// 현재 레벨의 큐를 모두 비우고 다시 높은 우선순위 큐를 찾아서 처리하도록 구현했다.
31void TaskManager::SwitchTask(bool current_sleep) {
32  // 현재 레벨에 맞는 큐 가져옴
33  auto& level_queue = running_[current_level_];
34  // 태스크를 꺼냄 (현재 실행중인 태스크)
35  Task* current_task = level_queue.front();
36  level_queue.pop_front();
37
38  if (!current_sleep) {
39    level_queue.push_back(current_task);
40  }
41  // 비어있는 경우 레벨 변경 필요
42  if (level_queue.empty()) {
43    level_changed_ = true;
44  }
45
46  if (level_changed_) {
47    level_changed_ = false;
48    // 레벨 변경이 필요한 경우 가장 높은 우선순위 큐부터 확인한다. 
49    for (int lv = kMaxLevel; lv >= 0; --lv) {
50      if (!running_[lv].empty()) {
51        current_level_ = lv;
52        break;
53      }
54    }
55  }
56
57  Task* next_task = running_[current_level_].front();
58  SwitchContext(&next_task->Context(), &current_task->Context());
59}

 1void TaskManager::Sleep(Task* task) {
 2  if (!task->Running()) {   // 이미 슬립이라면 작업 안함
 3    return;
 4  }
 5
 6  task->SetRunning(false);
 7  // 현재 실행중인 자기자신이라면 태스크를 전환하면서 슬립
 8  if (task == running_[current_level_].front()) {
 9    SwitchTask(true);
10    return;
11  }
12  // 자기자신이 아니면 그냥 지우면 끝이다. 
13  Erase(running_[task->Level()], task);
14}
15
16// 얘는 자기 자신일수가 없다. CPU 점유도 없이 코드가 실행될 수 없으니까
17void TaskManager::Wakeup(Task* task, int level) {
18  // 태스크가 이미 running_ 큐에 있다면 레벨만 변경한다.
19  if (task->Running()) {
20    ChangeLevelRunning(task, level);
21    return;
22  }
23  // 인자로 받은 level 이 0보다 작다면 기존 레벨 유지
24  if (level < 0) {
25    level = task->Level();
26  }
27  task->SetLevel(level);
28  task->SetRunning(true);
29
30  // 태스크를 해당되는 레벨 큐에 넣고, 만약 현재 실행중인 레벨보다 우선순위가 높다면
31  // 다음 SwitchTask 에서 실행할 큐 레벨을 변경해서 이 태스크를 실행시키도록 한다.
32  running_[level].push_back(task);
33  if (level > current_level_) {
34    level_changed_ = true;
35  }
36  return;
37}

 1void TaskManager::ChangeLevelRunning(Task* task, int level) {
 2  // 레벨을 변경할 필요가 없는경우
 3  if (level < 0 || level == task->Level()) {
 4    return;
 5  }
 6  // 맨앞이 아니라면 자유롭게 큐에서 꺼내서 원하는 레벨에 넣는다.
 7  // CPU가 실행중인 태스크 자기 자신이 아니라는 의미이다. 
 8  if (task != running_[current_level_].front()) {
 9    Erase(running_[task->Level()], task);
10    running_[level].push_back(task);
11    if (level > current_level_) {
12      level_changed_ = true;
13    }
14    return;
15  }
16
17  // 만약 자기자신이라면 큐를 이동시킨다.
18  // 어차피 컨텍스트는 적당히 작업 끝나면 전환되니까 무시해도 된다.
19  // 현재 실행중인 태스크이기 때문에 task_manager에서도 현재 실행중인 큐니까
20  // current_level_ 도 수정해줘야 한다. 
21  running_[current_level_].pop_front();
22  // 현재 실행중이였기 때문에 맨앞에 추가된다.
23  running_[level].push_front(task);
24  task->SetLevel(level);
25  if (level >= current_level_) {
26    current_level_ = level;   // 현재 레벨이 높아짐
27  } else {
28    current_level_ = level;   // 현재 레벨이 낮아짐
29    level_changed_ = true;    // 레벨이 낮아졌다면 SwitchTask에서 낮은레벨을 실행하게 되기 때문에 true로 변경해야한다.
30  }
31}

 1TaskManager::TaskManager() {
 2  Task& task = NewTask()
 3    .SetLevel(current_level_)
 4    .SetRunning(true);
 5  running_[current_level_].push_back(&task);
 6
 7  // hlt만 실행하는 유휴 태스크.
 8  Task& idle = NewTask()
 9    .InitContext(TaskIdle, 0)
10    .SetLevel(0)
11    .SetRunning(true);
12  // 0번 우선순위는 유휴태스크 전용이다. (가장 낮은 우선순위)
13  running_[0].push_back(&idle);
14}

 1  // event loop
 2  while (true) {
 3    switch (msg->type) {
 4    // ...
 5    case Message::kLayer:
 6      // 들어온 Draw 메시지를 처리한다. 
 7      ProcessLayerMessage(*msg);
 8      __asm__("cli");
 9      // Draw를 요청한 task에 완료됐다고 통지한다. 
10      task_manager->SendMessage(msg->src_task, Message{Message::kLayerFinish});
11      __asm__("sti");
12      break;
13    default:
14      Log(kError, "Unknown message type: %d\n", msg->type);
15    }
16  }
17
18// 이 함수 안에서 layer_manager->Draw 를 대신 호출해준다.
19// 이 함수가 실행되는 곳은 메인루프이기 때문에 항상 메인스레드가 그리게된다.
20void ProcessLayerMessage(const Message& msg) {
21  const auto& arg = msg.arg.layer;
22  switch (arg.op) {Add commentMore actions
23  case LayerOperation::Move:
24    layer_manager->Move(arg.layer_id, {arg.x, arg.y});
25    break;
26  case LayerOperation::MoveRelative:
27    layer_manager->MoveRelative(arg.layer_id, {arg.x, arg.y});
28    break;
29  case LayerOperation::Draw:
30    layer_manager->Draw(arg.layer_id);
31    break;
32  }
33}

 1void TaskB(uint64_t task_id, int64_t data) {
 2  printk("TaskB: task_id=%lu, data=%lx\n", task_id, data);
 3  char str[128];
 4  int count = 0;
 5  // 결국엔 태스크의 전환도 TaskTimer의 인터럽트에서 발생하기 때문에 인터럽트를 막아둬야한다. 
 6  // 막지 않으면 태스크가 전환되어 다른 태스크가 리턴될 수 있다.
 7  __asm__("cli");
 8  Task& task = task_manager->CurrentTask();
 9  __asm__("sti");
10
11  while (true) {
12    ++count;
13    sprintf(str, "%010d", count);
14    FillRectangle(*task_b_window->Writer(), {24, 28}, {8 * 10, 16}, {0xc6, 0xc6, 0xc6});
15    WriteString(*task_b_window->Writer(), {24, 28}, str, {0, 0, 0});
16
17    // 메인태스크에 Draw를 요청하는 메시지를 보낸다.
18    Message msg{Message::kLayer, task_id};
19    msg.arg.layer.layer_id = task_b_window_layer_id;
20    msg.arg.layer.op = LayerOperation::Draw;
21    __asm__("cli");
22    task_manager->SendMessage(1, msg);
23    __asm__("sti");
24
25    // 응답을 대기하는 루프.
26    while (true) {
27      __asm__("cli");
28      // Sleep 상태로 대기한다. 메시지가 도착하면 Wakeup이 호출되어 깨어난다.
29      auto msg = task.ReceiveMessage();
30      if (!msg) {
31        task.Sleep();
32        __asm__("sti");
33        continue;
34      }
35      // 만약 원하는 메시지가 왔다면 break로 탈출
36      if (msg->type == Message::kLayerFinish) {
37        break;
38      }
39    }
40  }
41}