Review

A thread is a basic unit of CPU utilization.

Thread Concept

Pros:

• Handling many similar tasks
• Exploiting multicore systems
• Thread creation is lightweight

Examples:

• Client-server applications
• Most operating system kernels are multithreaded

Multicore Programming

Parallelism

• Data Parallelism
  • Mapreduce
  • Distributed Machine Learning
• Task Parallelism
  • Federated Submodel Learning
  • Distributed Machine Learning

Amdahl’s Law

Formula:

• P: the proportion of the serial portion
• N: the number of parallel parts

It is determined by the proportion of the serial portion

Multithreading Models

Lightweight process (LWP): A mapping between user threads and kernel threads

Multithreading models

Thread Libraries

Tools for manage threads

• POSIX Pthreads
• Java Threads
• Win32 Threads

Pthreads

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

#include <pthread.h> 
#include <stdio.h> 
#include <stdlib.h> 
int sum; /* this data is shared by the thread(s) */ 
void *runner(void *param); /* threads call this function */ 
int main(int argc, char *argv[]) 
{
pthread_t tid; /* create thread identifier */ 
pthread_attr_t attr; /* create thread attributes */ 
/* set the default attributes of the thread */ 
pthread_attr_init(&attr); 
/* create the thread */ 
pthread_create(&tid, &attr, runner, argv[1]); 
/* wait for the thread to exit */ 
pthread_join(tid, NULL); 
printf("sum = %d ∖ n",sum);

Implicit Threading

• Thread Pools
  • Create a number of threads in advance and have them wait for tasks to arrive
• Fork-Join
  • Divide and conquer
• OpenMP
  • A parallel programming interface
• Grand Central Dispatch
  • Apple’s parallel programming framework
• Intel Threading Building Blocks
  • Intel’s parallel programming framework

Threading Issues

On Kernel and User

Having studied operating systems up to this point, I have noticed the concepts of Kernel and User appearing everywhere, so here are some of my own explorations and thoughts.

Origins

• Multics (1960s)
  A time-sharing operating system developed jointly by MIT, Bell Labs and General Electric, which was the first to introduce a hierarchical protection mechanism (Protection Rings). The system is divided into multiple privilege levels (e.g. Ring 0 to Ring 3), where:

  • Kernel Mode: runs at the highest privilege level (e.g. Ring 0) and can access all hardware resources and system data.
  • User Mode: runs at a lower privilege level (e.g. Ring 3) with restricted access to sensitive resources.

• UNIX’s inheritance and simplification
  When Ken Thompson and Dennis Ritchie at Bell Labs designed UNIX, they were inspired by Multics but simplified the protection mechanism, keeping only two modes:

  • Kernel mode: executes kernel code and operates the hardware directly.
  • User mode: runs application programs, which request kernel services through system calls.

Why separate user mode from kernel mode?

• Security: prevents user programs from damaging the kernel, whether maliciously or by mistake.
• Stability: a crashing user program does not affect the kernel.
• Resource management: the kernel centrally schedules hardware resources (such as the CPU and memory).

Thoughts

The design philosophy behind kernel mode and user mode is a classic case of seizing the principal contradiction while setting aside the secondary ones. It also reflects strict hierarchical design.

Translated from the Chinese original.