学!
看了课以后对进程线程的理解又多了一些.
xv6 一个进程有两个线程, 分别是用户态运行的唯一用户线程, 和在内核态运行的内核线程. 陷入内核和返回用户态可以看作是线程切换的过程. 内核线程有自己的一个栈, 就是内核栈. 在 xv6 中被映射到了非常高的地址.
内核还有一个内核调度器线程, 这是内核最开始运行的线程, 他的栈是内核启动时设置好的, 在 0x8000000 之上一点点 (具体多少不重要). 内核启动最开始会设置寄存器的值, 其中就包括这个栈, 有了栈以后, 才可以"执行 c 语言代码".
内核线程之间通过 内核线程调度器 来切换. 内核线程调度器这个线程管理所有和进程有关的内核线程.
内核线程的切换, 其实代表着用户进程的切换.
内核线程通过 yeild 放弃 CPU, 然后切换到内核线程调度器, 由调度器决定下一个可以使用 CPU 的内核线程, 然后切换过去.
实现(伪)用户线程. 非常搞笑, 在代码里写一个和 kernel 中几乎一样的线程调度器…
理解了线程切换的过程就非常好做了. 把 kernel 的 context 和 switch.asm 拿过来用就行.
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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
|
.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 */
|
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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
|
...
// Saved registers for context switches.
struct context {
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 context context; /* thread's saved context */
};
void
thread_schedule(void)
{
...
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->context, (uint64)&next_thread->context);
}
...
}
void
thread_create(void (*func)())
{
...
// YOUR CODE HERE
t->context.ra = (uint64)func;
t->context.sp = (uint64)(t->stack + STACK_SIZE);
}
|
非常无聊, 给写操作加锁.
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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
|
--- a/notxv6/ph.c
+++ b/notxv6/ph.c
@@ -14,9 +14,17 @@ struct entry {
struct entry *next;
};
struct entry *table[NBUCKET];
+pthread_mutex_t locks[NBUCKET];
int keys[NKEYS];
int nthread = 1;
+void
+init_locks()
+{
+ for (int i = 0; i < NBUCKET; i++)
+ assert(pthread_mutex_init(&locks[i], NULL) == 0);
+}
+
double
now()
{
@@ -51,7 +59,9 @@ void put(int key, int value)
e->value = value;
} else {
:
// the new is new.
+ pthread_mutex_lock(&locks[i]);
insert(key, value, &table[i], table[i]);
+ pthread_mutex_unlock(&locks[i]);
}
}
@@ -107,6 +117,9 @@ main(int argc, char *argv[])
fprintf(stderr, "Usage: %s nthreads\n", argv[0]);
exit(-1);
}
+
+ init_locks();
+
nthread = atoi(argv[1]);
tha = malloc(sizeof(pthread_t) * nthread);
srandom(0);
|
非常无聊, 条件锁而已
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
static void
barrier()
{
// YOUR CODE HERE
//
// Block until all threads have called barrier() and
// then increment bstate.round.
pthread_mutex_lock(&bstate.barrier_mutex);
if (++bstate.nthread == nthread) {
bstate.nthread = 0;
bstate.round++;
pthread_cond_broadcast(&bstate.barrier_cond);
}
else
pthread_cond_wait(&bstate.barrier_cond, &bstate.barrier_mutex);
pthread_mutex_unlock(&bstate.barrier_mutex);
}
|
这下实现真用户级线程了. 感觉会很好玩. (不懂为啥不把这个当作 lab 内容) 下次有机会再写. (今天不想学习, lab 是打三维弹球打不动了来写的)