process and concurrency

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

struct task_struct {
 // Process status
    /* -1 unrunnable, 0 runnable, >0 stopped: */
 long     state;
 // Virtual memory structure
 struct mm_struct  *mm;
 // Process number
 pid_t     pid;
 // Pointer to parent process
 struct task_struct __rcu  *parent;
 // Children form the list of natural children:
 struct list_head  children;
 // Pointer to filesystem information:
 struct fs_struct  *fs;
 // Open file information:
 struct files_struct  *files;
};

 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
54
55
56
57
58
59
60
61
62
63

int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
                   void *(*start_routine) (void *), void *arg) {
    struct task_struct *new_thread;

    // Allocate memory for new thread's task_struct
    new_thread = allocate_task_struct();
    if (!new_thread) {
        return -1;
    }

    // Initialize the task_struct (simplified)
    new_thread->state = TASK_RUNNING;
    new_thread->flags = 0;
    new_thread->prio = DEFAULT_PRIORITY;
    new_thread->mm = NULL;
    new_thread->active_mm = current->active_mm;  // Share memory map with current task

    // Allocate and set up the new thread's user stack and kernel stack
    new_thread->user_stack = allocate_user_stack();
    new_thread->kernel_stack = allocate_kernel_stack();
    setup_new_thread_context(new_thread, start_routine, arg);

    // Add new_thread to the runqueue so that the scheduler can start it
    add_to_runqueue(new_thread);

    // Return the new thread's ID
    *thread = new_thread->pid;

    return 0;
}

void setup_new_thread_context(struct task_struct *new_thread, void *(*start_routine) (void *), void *arg) {
    // Set up the new thread's kernel stack and CPU context
    // so that it will start execution in start_routine when scheduled.
    setup_new_thread_kernel_stack_and_context(new_thread->kernel_stack, start_routine, arg);

    // Initialize the new thread's user stack
    setup_new_thread_user_stack(new_thread->user_stack, arg);
}

void setup_new_thread_kernel_stack_and_context(void *stack, void *(*start_routine) (void *), void *arg) {
    // Make room on the stack for the return address and the function argument
    stack -= sizeof(void *);

    // Put the argument onto the stack
    *((void **)stack) = arg;

    // Initialize the new thread's context
    struct cpu_context *context = &new_thread->context;

    // Set up the instruction pointer to point to start_routine
    context->ip = (unsigned long)start_routine;

    // Set up the stack pointer
    context->sp = (unsigned long)stack;
}

void setup_new_thread_user_stack(void *user_stack, void *arg) {
    // The actual implementation of this function can be quite complex
    // and is beyond the scope of this pseudocode. In general, this function
    // would set up the new thread's user stack so that it's ready to start
    // executing in user mode.
}

 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

// Thread struct definition
struct Thread {
    void* userStackPointer;
    void* userInstructionPointer;
    ....
 
};


// Pseudo code for thread switch from user space to kernel space
void switchToKernelSpace(Thread* currentThread) {
    // Save the current stack pointer
    currentThread->stackPointer = getCurrentStackPointer();
    
    // Save the current instruction pointer
    currentThread->instructionPointer = getCurrentInstructionPointer();
    
    // Switch to kernel stack
    switchStackToKernel();
    

    
    // Set the stack pointer to the kernel stack pointer
    setCurrentStackPointer(getKernelStackPointer());
    
    // Set the instruction pointer to the kernel mode entry point
    setCurrentInstructionPointer(getKernelEntryPoint());
    
    // Jump to the kernel mode entry point
    jumpToKernelMode();
}


	

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

   tap_do_read(...)
   {
       ...
   	DEFINE_WAIT(wait); //定义一个等待队列
       
   	while(!condition)
       {
           add_wait_queue(&wq_head, &wait); //将进程添加到等待队列中
           set_current_state(TASK_UNINTERRUPTIBLE); //设置进程的状态为睡眠态
           ...
               
           /* 主动调度 */
           schedule();
       
       	...
       }
   	...
}

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

// linux
#include <pthread.h>
#include <stdio.h>

void* myThreadFun(void *vargp) {
    printf("Printing from Thread \n");
    return NULL;
}
   
int main() {
    pthread_t thread_id;
    
    printf("Before Thread\n");
    
    // Create a new thread that will execute 'myThreadFun'
    pthread_create(&thread_id, NULL, myThreadFun, NULL);
    
    // Wait for the thread to finish
    pthread_join(thread_id, NULL);
    
    printf("After Thread\n");
    exit(0);
}

1
2
3

 task_struct{
	..
 }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

var  updateChan

go func: // producer 
	go:
	
		update<- 100, deposite
	
	go:
		update<- -50, withdraw


go func: // writer



	for ammout  :=  range updateChan
		balance+=amount

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

var searchChan
var dbChan 
go func:
	for _, ele := range array
		go search(ele, searchChan) // stage1,producer 

go func:
	var maps 
	for  result range   searchChan
		maps[result.url] = result.content


	go getDB(maps["google.com"],maps["facebook.com"],dbChan)
	go getDB(mapsp["twiter.com"],maps["abc.com"],dbChan)



go func:
	for result range dbChan