6 Processes and threads - University of California, Riversidehtseng/classes/cs202... · Task #1 a =...

Experiencing processes and threadsHung-Wei Tseng

Recap: Tasks/processes

Virtual memoryheap

static data

CPUMemory

Task #1

a = 0x01234567

Virtual memoryheap

static data

CPUMemory

Task #2

a = 0xDEADBEEF

Virtual memoryheap

static data

CPUMemory

Task #3

a = 0x87654321

Virtual memoryheap

static data

CPUMemory

Task #4

a = 0x95273310

Each process has its own unique virtual memory address space, its own states of execution, its own set of I/Os

The same processor!The same memory

address!

Different values

Different values are preserved

Recap: Threads

Virtual memoryheap

static data

Task #1

a = 0x01234567

CPUPCThread #1

CPUPCThread #2

CPU PCThread #3

Virtual memoryheap

static data

Task #2

a = 0x01234567

CPUPCThread #1

CPUPCThread #2

CPU PCThread #3

Each process has its own unique virtual memory address space, its own states of execution, its own set of I/Os

Each thread has its own PC, states of execution, but shares memory address spaces, I/Os without threads within the

same process

• Threads + shared memory in a process • Processes + IPC/files/sockets • Processes + special shared memory module/library (e.g.,

boost)

Recap: Parallelizing an application

• pid_t fork(); • fork used to create processes (UNIX) • What does fork() do?

• Creates a new address space (for child) • Copies parent’s address space to child’s • Points kernel resources to the parent’s resources (e.g. open files) • Inserts child process into ready queue

• fork() returns twice • Returns the child’s PID to the parent • Returns “0” to the child

Recap: process API — fork()

• Process API • Thread programming and synchronization

Outline

The interface of managing processes (cont.)

• What happens if we execute the following code?int main() {

int pid; if ((pid = fork()) == 0) { printf (”My pid is %d\n", getpid()); } printf (”Child pid is %d\n", pid); return 0;}

Recap: What will happen?

# of times “my pid” is printed my pid values printed # of times “child pid” is printed child pid values printed

A 1 7 2 7, 0B 1 2 2 7, 0C 2 7, 2 1 7D 1 0 2 7, 2E 1 7 1 7

Assume the parent’s PID is 2; child’s PID is 7.

• void exit(int status) • exit frees resources and terminates the process

• Runs an functions registered with atexit • Flush and close all open files/streams • Releases allocated memory. • Remove process from kernel data structures (e.g. queues)

• status is passed to parent process • By convention, 0 indicates “normal exit”

exit()

• What happens if we add an exit?int main() {

int pid; if ((pid = fork()) == 0) { printf (”My pid is %d\n", getpid()); exit(0); } printf (”Child pid is %d\n", pid); return 0;

If we add an exit …Assume the parent’s PID is 2; child’s PID is 7.

A 1 7 2 7, 0B 1 2 2 7, 0C 2 7, 2 1 7D 1 0 2 7, 2E 1 7 1 7

fork() and exit()

Virtual memory

int pid;

if ((pid = fork()) == 0) { printf(“My pid is %d\n”, getpid()); exit(); } printf(“Child pid is %d\n”, pid);

static data

pid: ? stack

fork() and exit()

Virtual memory

int pid;

static data

pid: ? stack

Virtual memory

int pid;

static data

pid: ? stack

fork() and exit()

Virtual memory

int pid;

static data

pid: ? stack

Virtual memory

int pid;

static data

pid: ? stack

Output: My pid is 7

fork() and exit()

Virtual memory

int pid;

static data

pid: ? stack

Virtual memory

int pid;

static data

pid: ? stack

Output: My pid is 7

fork() and exit()

Virtual memory

int pid;

static data

pid: ? stack

Output: My pid is 7

fork() and exit()

Virtual memory

int pid;

static data

pid: ? stack

Output: My pid is 7Child pid is 7

• What happens if we add an exit?int main() {

int pid; if ((pid = fork()) == 0) { printf (”My pid is %d\n", getpid()); exit(0); } printf (”Child pid is %d\n", pid); return 0;

If we add an exit …

A 1 7 2 7, 0B 1 2 2 7, 0C 2 7, 2 1 7D 1 0 2 7, 2E 1 7 1 7

Assume the parent’s PID is 2; child’s PID is 7.

• Consider the following codefork();printf(“moo\n”);fork();printf(“oink\n”);fork();printf(“baa\n”);How many animal noises will be printed?

A. 3 B. 6 C. 8 D. 14 E. 24

More forks

2x4x8x

• int execvp(char *prog, char *argv[]) • fork does not start a new program, just duplicates the current

program • What execvp does:

• Stops the current process • Overwrites process’ address space for the new program • Initializes hardware context and args for the new program • Inserts the process into the ready queue

• execvp does not create a new process

Starting a new program with execvp()

• Windows only has exec • Flexibility • Allows redirection & pipe

• The shell forks a new process whenever user invoke a program • After fork, the shell can setup any appropriate environment

variable to before exec • The shell can easily redirect the output in shell: a.out > file

Why separate fork() and exec()

exec()

Virtual memory

int pid; if ((pid = fork()) == 0) { execvp(“a.out”,NULL); printf(“My pid is %d\n”, getpid()); exit(); } printf(“Child pid is %d\n”, pid);

static data

pid: ? stack

fork() and exit()

Virtual memory

static data

pid: ? stack

Virtual memory

static data

pid: ? stack

fork() and exit()

Virtual memory

static data

pid: ? stack

Virtual memory

static data

pid: ? stack

Output: Child pid is 7

fork() and exit()

Virtual memory

static data

pid: ? stack

Virtual memory

static data

pid: ? stack

Output: Child pid is 7

fork() and exit()

Virtual memory

static data

pid: ? stack

Virtual memory

int main() { printf(“I am someone else now!\n”); }

static data

pid: ? stack

Output: Child pid is 7I am someone else now!

Let’s write our own shells

• Say, we want to do ./a • fork • exec(“./a”, NULL)

How to implement a shell

• Say, we want to do ./a • fork • exec(“./a”, NULL)

How to implement redirection in shell

Virtual memory

int pid, fd; char cmd[2048], prompt = “myshell$” while(gets(cmd) != NULL) { if ((pid = fork()) == 0) { execv(cmd,NULL); } else printf(“%s ”,prompt); }

static data

Virtual memory

int pid, fd; char cmd[2048], prompt = “myshell$” while(gets(cmd) != NULL) { if ((pid = fork()) == 0) { execv(cmd,NULL); } else printf(“%s ”,prompt); }

static data

The shell can respond to next input

• Say, we want to do ./a > b.txt • fork • The forked code opens b.txt • The forked code dup the file descriptor • The forked code assigns b.txt to stdin/stdout • The forked code closes b.txt • exec(“./a”, NULL)

• Say, we want to do ./a > b.txt • fork • The forked code opens b.txt • The forked code dup the file descriptor to stdin/stdout • The forked code closes b.txt • exec(“./a”, NULL)

Virtual memory

int pid, fd; char cmd[2048], prompt = “myshell$” while(gets(cmd) != NULL) { if ((pid = fork()) == 0) { fd = open(“b.txt”, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR); dup2(fd, stdout); close(fd); execv(“./a”,NULL); } else printf(“%s ”,prompt); }

static data

Virtual memory

int pid, fd; char cmd[2048], prompt = “myshell$” while(gets(cmd) != NULL) { if ((pid = fork()) == 0) { fd = open(“b.txt”, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR); dup2(fd, stdout); close(fd); execv(“./a”,NULL); } else printf(“%s ”,prompt); }

static data

The shell can respond to next input

Homework for you:Think about the case when your fork is equivalent to fork+exec()

• pid_t wait(int *stat) • pid_t waitpid(pid_t pid, int *stat, int opts)

• wait / waitpid suspends process until a child process ends • wait resumes when any child ends • waitpid resumes with child with pid ends • exit status info 1 is stored in *stat • Returns pid of child that ended, or -1 on error

• Unix requires a corresponding wait for every fork

wait()

• Zombie: process that exits but whose parent doesn’t call wait • Can’t be killed normally • Resources freed but pid remains in use

• Orphan: Process whose parent has exited before it has • Orphans are adopted by init process, which calls wait periodically

Zombies, Orphans, and Adoption

Thread programming & synchronization

The virtual memory of multithreaded applications

Virtual memory

static data

stack #1

stack #2

stack #3

Everything here is shared/visible among all threads within the same process!

Joint Banking

withdraw$20

deposit$10

current balance: $40

Bank of UCR

What is the new balance each would see?

Bank Account Race Condition

Step 1: TA runs and calls getBalance followed by adding amt (10) to bal

current balance: $40current balance: $50deposit(int amt) { int bal;

bal = getBalance(); bal = bal + amt; setBalance(bal); bal = checkBalance(); printReceipt(bal); }

Thread Awithdraw(int amt) { int bal;

bal = getBalance(); bal = bal - amt; setBalance(bal); bal = checkBalance(); printReceipt(bal); }

Thread B

Step 2: Switch to TB which calls getBalance, followed by subtracting amt (20) from bal

Thread B

Step 3: Switch back to TA which calls setBalance

Thread B

Step 4: Switch back to and finish TB by calling setBalance, followed by printReceipt

Thread B

Step 5: Finish TA by calling checkBalance, followed by printReceipt

Thread B

Honey, we need to chat

• If the shared variable, balance, initially has the value of 40, what value(s) might it hold after threads A and B finish after we call deposit(10) and withdraw(20)?

A. 30 B. 20 or 30 C. 20, 30, or 50 D. 10, 20, or 30

Joint Banking

deposit(int amt) { int bal;

Thread B

• Processor/compiler may reorder your memory operations/instructions

• Each processor core may not run at the same speed (cache misses, branch mis-prediction, I/O, voltage scaling and etc..)

• Threads may not be executed/scheduled right after it’s spawned

Processors/threads are not-deterministic

• Concurrency leads to multiple active processes/threads that share one or more resources

• Synchronization involves the orderly sharing of resources • All threads must be on the same page • Need to avoid race conditions

Synchronization

• Protect some pieces of code that access shared resources (memory, device, etc.)

• For safety, critical sections should: • Enforce mutual exclusion (i.e. only one thread at a time) • Execute atomically (all-or-nothing) before allowing another thread

Critical sections

• Which is the smallest code region in Thread A that we can make as a critical section to guarantee the outcome as 30?

Identifying Critical Sections

int deposit(int amt) { int bal; bal = getBalance(); bal = bal + amt; setBalance(bal); bal = checkBalance(); printReceipt(bal); return bal; }

Thread Aint withdraw(int amt) { int bal;

bal = getBalance(); bal = bal - amt; setBalance(bal); bal = checkBalance();

printReceipt(bal); return bal; }

Thread B

Critical sections

Thread B

• Entry section acts as barrier, only allowing a single thread in at a time

• Exit section should remove barrier for other threads’ entry

Critical section

bal = getBalance(); bal = bal + amt; setBalance(bal); bal = checkBalance();

printReceipt(bal); }

entry section

exit section

1. Mutual exclusion — at most one process/thread in its critical section

2. Progress/Fairness — a thread outside of its critical section cannot block another thread from entering its critical section

3. Progress/Fairness — a thread cannot be postponed indefinitely from entering its critical section

4. Accommodate nondeterminism — the solution should work regardless the speed of executing threads and the number of processors

Solving the “Critical Section Problem”

How to implement lock/unlock

The baseline

int main(int argc, char *argv[]) { if (argc != 2) { fprintf(stderr, "usage: main-first <loopcount>\n"); exit(1); } max = atoi(argv[1]); pthread_t p1, p2; printf("main: begin [balance = %d] [%x]\n”, \ balance, (unsigned int) &balance); Pthread_create(&p1, NULL, mythread, "A"); Pthread_create(&p2, NULL, mythread, "B"); // join waits for the threads to finish Pthread_join(p1, NULL); Pthread_join(p2, NULL); printf("main: done\n [balance: %d]\n [should: %d]\n", balance, max*2); return 0; }

void * mythread(void *arg) { char *letter = arg; int i; // stack (private per thread) printf("%s: begin [addr of i: %p]\n", letter, &i); for (i = 0; i < max; i++) { balance = balance + 1; // shared: only one } printf("%s: done\n", letter); return NULL; }

int max; volatile int balance = 0; // shared global variable

int max; volatile int balance = 0; // shared global variablepthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;

void * mythread(void *arg) { char *letter = arg; printf("%s: begin\n", letter); int i; for (i = 0; i < max; i++) { Pthread_mutex_lock(&lock); balance++; Pthread_mutex_unlock(&lock); } printf("%s: done\n", letter); return NULL; }

int main(int argc, char *argv[]) { if (argc != 2) { fprintf(stderr, "usage: main-first <loopcount>\n"); exit(1); } max = atoi(argv[1]); pthread_t p1, p2; printf("main: begin [balance = %d] [%x]\n", balance, (unsigned int) &balance); Pthread_create(&p1, NULL, mythread, "A"); Pthread_create(&p2, NULL, mythread, "B"); // join waits for the threads to finish Pthread_join(p1, NULL); Pthread_join(p2, NULL); printf("main: done\n [balance: %d]\n [should: %d]\n", balance, max*2); return 0; }

Use pthread_lock

int max; volatile int balance = 0; // shared global variablepthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;

void * mythread(void *arg) { char *letter = arg; printf("%s: begin\n", letter); int i; Pthread_mutex_lock(&lock); for (i = 0; i < max; i++) {

balance++; } Pthread_mutex_unlock(&lock); printf("%s: done\n", letter); return NULL; }

Use pthread_lock (coarser grain)

int max; volatile int balance = 0; // shared global variablevolatile unsigned int lock = 0;

void * mythread(void *arg) { char *letter = arg; printf("%s: begin\n", letter); int i; for (i = 0; i < max; i++) { SpinLock(&lock); balance++; SpinUnlock(&lock); } printf("%s: done\n", letter); return NULL; }

Use spin locks

void SpinLock(volatile unsigned int *lock) { while (*lock == 1) // TEST (lock) ; // spin *lock = 1; // SET (lock) }

void SpinUnlock(volatile unsigned int *lock) { *lock = 0; }

what if context switch happens here?

• Which of the following can disabling interrupts guarantee on multicore processors?

A. At most one process/thread in its critical section B. A thread outside of its critical section cannot block another

thread from entering its critical section C. A thread cannot be postponed indefinitely from entering its

critical section D. The solution should work regardless the speed of executing

threads and the number of processors E. None of the above

Disable interrupts?

What if the thread hold the critical section crashes?

What if we have multiple processors?

Use spin locks

void SpinLock(volatile unsigned int *lock) { while (*lock == 1) // TEST (lock) ; // spin *lock = 1; // SET (lock) }

void SpinUnlock(volatile unsigned int *lock) { *lock = 0; }

what if context switch happens here?

— the lock must be updated atomically

Use spin locks

static inline uint xchg(volatile unsigned int *addr, unsigned int newval) { uint result; asm volatile("lock; xchgl %0, %1" : "+m" (*addr), "=a" (result) : "1" (newval) : "cc"); return result; }

void SpinLock(volatile unsigned int *lock) { // what code should go here? }

void SpinUnlock(volatile unsigned int *lock) { // what code should go here? }

a prefix to xchgl that locks the whole cache lineexchange the content in %0 and %1

Use spin locks

static inline uint xchg(volatile unsigned int *addr, unsigned int newval) { uint result; asm volatile("lock; xchgl %0, %1" : "+m" (*addr), "=a" (result) : "1" (newval) : "cc"); return result; }

void SpinLock(volatile unsigned int *lock) { while (xchg(lock, 1) == 1); }

void SpinUnlock(volatile unsigned int *lock) { xchg(lock, 0); }

Semaphores

• Also referred to as “producer-consumer” problem • Producer places items in shared buffer • Consumer removes items from shared buffer

Bounded-Buffer Problem

producer consumer

5 22 18 38 2 15buffer

Without synchronization, you may write

int main(int argc, char *argv[]) { pthread_t p; printf("parent: begin\n"); // init here Pthread_create(&p, NULL, child, NULL); int in = 0; while(TRUE) { int item = …; buffer[in] = item; in = (in + 1) % BUFF_SIZE; } printf("parent: end\n"); return 0; }

void *child(void *arg) { int out = 0; printf("child\n"); while(TRUE) { int item = buffer[out]; out = (out + 1) % BUFF_SIZE; // do something w/ item } return NULL; }

int buffer[BUFF_SIZE]; // shared global

Use locksint main(int argc, char *argv[]) { pthread_t p; printf("parent: begin\n"); // init here Pthread_create(&p, NULL, child, NULL); int in = 0; while(TRUE) { int item = …; Pthread_mutex_lock(&lock); buffer[in] = item; in = (in + 1) % BUFF_SIZE; Pthread_mutex_unlock(&lock); } printf("parent: end\n"); return 0; }

void *child(void *arg) { int out = 0; printf("child\n"); while(TRUE) { Pthread_mutex_lock(&lock); int item = buffer[out]; out = (out + 1) % BUFF_SIZE; Pthread_mutex_unlock(&lock); // do something w/ item } return NULL; }

int buffer[BUFF_SIZE]; // shared globalvolatile unsigned int lock = 0;

You cannot produce and consume simultaneously!

• Reading quiz due next Tuesday • Project will be up next Tuesday after class

• You need to install Ubuntu 16.04.6 in VirtualBox • You can have up to 1 classmate working together with you — 2 in a

Announcement

6 Processes and threads - University of California, Riversidehtseng/classes/cs202... · Task #1 a =...

Documents

Notebook PC X120-H.CSVPG (X120-R) Features: CPU : Atom ... · Notebook PC X120-H.CSVPG (X120-R) Features: CPU : Atom Processor N270 LCD Fine Bright WSVGA LED LCD Video :lntel GMA

CPU Scheduling. Basic Concepts Scheduling Criteria Scheduling Algorithms Multiple-Processor Scheduling Real-Time Scheduling Thread Scheduling Operating

PCM-4330 PC/104 486 CPU Module with Flat Panel/CRT Interface · PC/104 486 CPU Module with Flat Panel/CRT Interface. ... n Character set loading into display memory for screen segments

Chap 4 Multithreaded Programming. Thread A thread is a basic unit of CPU utilization It comprises a thread ID, a program counter, a register set and a

WWW CPU PC CD-ROM. floppy disks speakers a mouse a keyboard

Zephyr Power Management - eLinux.org · Kernel scheduling and idling ... System Power Management happens in Idle Thread ... CPU Low Power State CPU clock gated Peripherals active

Chapter 5: CPU Schedulingksrao/caos2018files/cpu-scheduling.pdf · Chapter 5: CPU Scheduling Basic Concepts Scheduling Criteria Scheduling Algorithms Thread Scheduling Multiple-Processor

P7-IBM PC 5150 - Nanjing University PC... · The IBM PC line Model name Model # Introduced CPU Features PC 5150 August 1981 8088 Floppy disk or cassette system ˙˝ 5160 March 1983

Series 800 Mighty Mouse UN Mating Thread PC Tail or Solder ... · Series 800 Mighty Mouse UN Mating Thread ... minimum protrusion inside enclosures and integral board ... E THREAD

Chapter 10: Multiprocessor & Real-time Scheduling Dynamic scheduling Wednesday, October 5, 2011 Load sharing CPU Core Core Core Core Memory Thread Thread Thread Thread Thread Thread

E350 Dual Core processor VOT133 - GfK EtilizeVDD100 Optical Disk Drive VOT133 PC Mini VOT133 and VDD100 = VOT133 PC MINI COMPUTER CORE CPU Processor Type AMD E-350 CPU Processor Speed

Cool RoadRunner III PC/104-Plus CPU · PDF fileCool RoadRunner III PC/104-Plus CPU board ... The TwisterT SMA system controller provides superior communication performance between

Saurav Karmakar. Chapter 5: CPU Scheduling Basic Concepts Scheduling Criteria Scheduling Algorithms Thread Scheduling Multiple-Processor Scheduling

EXTREME PERFORMANCE LIQUID CPU COOLER - Inet.se · EXTREME PERFORMANCE LIQUID CPU COOLER. Note: Most newer PC cases include a CPU cutout to allow access to the bottom of the motherboard

CPU Z80 CPU MCS-51 COMPUTER PC - Etteamet-lab3a ยังมี cpu ตระกูล mcs-51เบอร์ p89v51rd2 เป็น cpu ... ic eprom lab3a-51 บรรจุตัวอย่างโปรแกรมการทดลอง

IJ a PC OS: windows 1 0 : nvidia1080ti CPU : HD : IOOOGB ...itolab.is.ocha.ac.jp/visws2019/poster/visws2019-p18.pdf · IJ a PC OS: windows 1 0 : nvidia1080ti CPU : HD : IOOOGB SSD

SHARC programming model - eng.auburn.edu › ~nelsovp › courses › elec2220 › slides... · Resume main thread Handling an interrupt request. 1. 2. 3. 5. 4. CPU in “Thread Mode”

TEC Thermal Printer B-470 SERIES · (Revision Date: Oct. 14 '94) 2.1 Replacing the PS Unit, I/F PC Board and CPU PC Board 2.1 Replacing the PS Unit, I/F PC Board and CPU PC Board

Operating Systems - os-course.github.io · (in Xv6: eip) Stack Registers PC (in Xv6: eip) Stack thread thread thread. Communication between threads The code segment is shared between

LHCb trigger upgrade and data preservation activities in Padova · 2014. 7. 16. · 3 LHCb trigger upgrade Event Builder PC PCIe40 CPU/GPU PCIe40 PCIe40 Event Builder PC CPU/GPU High