Introduc)on to pthreads. Shared memory Parallel Programming
|
|
- Mariah Osborne
- 6 years ago
- Views:
Transcription
1 Introduc)on to pthreads Shared memory Parallel Programming
2 pthreads Hello world Compute pi pthread func)ons Prac)ce Problem (OpenMP to pthreads) Sum and array Thread-safe Bounded FIFO Queue
3 pthread Hello World #include <stdio.h> #include <stdlib.h> #include <pthread.h> int thread_count; void *hello(void *id) { long myid = (long) id; prinp("hello from thread %ld of %d\n", myid, thread_count); return NULL;
4 pthread Hello World int main(int argc, char *argv[]) { long i; pthread_t *threads; thread_count = atoi(argv[1]); threads = malloc(thread_count*sizeof(pthread_t)); for (i = 0; i < thread_count; i++) pthread_create(&(threads[i]), NULL, hello, (void *) i); prinp("hello from the main thread\n"); for (i = 0; i < thread_count; i++) pthread_join(threads[i], NULL); free(threads);
5 Compute Approxima)on of Pi // includes not shown #define MAXTHREADS 100 int numintervals; int localintervals; double width; int numthreads; pthread_t threads[maxthreads]; double par)alresults[maxthreads];
6 Main Func)on (part 1) int main(int argc, char**argv) { int i; double pi; numthreads = atoi(argv[1]); numintervals = atoi(argv[2]); //Assume numintervals is a mul)ple of numthreads localintervals = numintervals / numthreads; width = 1.0/numIntervals; for (i = 0; i < numthreads; i++) { pthread_create(&threads[i], NULL, ComputePi, (void *)i);
7 Main Func)on (part 2) for (i = 0; i < numthreads; i++) { pthread_join(threads[i], NULL); for (i = 0; i <numthreads; i++) { pi = par)alresults[i] + pi; prinp("pi = %1.20f\n", pi);
8 ComputePi (part 1) void * ComputePi(void *arg) { int myid; int i; int start; int stop; double midpoint; double sum; myid = (int) arg; sum = 0.0;
9 ComputePi (part 2) start = myid*localintervals; stop = start+localintervals; for (i = start; i < stop; i++) { midpoint = width * ((double) i - 0.5); sum = sum + f(midpoint); par)alresults[myid] = width * sum;
10 Basic pthread Rou)nes pthread_create pthread_exit pthread_join pthread_detach pthread_mutex_init pthread_mutex_destro y pthread_mutex_lock pthread_mutex_trylock pthread_mutex_unlock Pthread_cond_init Pthread_cond_destroy Pthread_cond_wait Pthread_cond_signal Pthread_cond_broadcast
11 pthread_create int pthread_create ( pthread_t *thread_handle, const pthread_alr_t *alribute, void * (*thread_func)on)(void *), void *arg); pthread_t mythread; pthread_alr_t alr; int myarg; pthread_create ( &mythread, &alr, myfunc)on, (void *) &myarg);
12 pthread_exit void pthread_exit(void *value_ptr); pthread_exit( (void *) & myretcode) Consider punng a pthread_exit call in main if some threads may be running when main completes
13 pthread_join int pthread_join(pthread_t thread, void **value_ptr) pthread_join( otherthread, &retcode) retcode is value returned by the call to pthread_exit otherthread must be joinable
14 pthread_detach int pthread_detach(pthread_t thread) pthread_detach(pthread_self()) When the thread exits the space associated with the thread state can be recovered
15 pthread_mutex_init int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexalr_t *alr) pthread_mutex_init(&mymutex, NULL)
16 pthread_mutex_lock int pthread_mutex_lock(pthread_mutex_t *mutex) pthread_mutex_lock(&mymutex);
17 pthread_mutex_trylock int pthread_mutex_trylock(pthread_mutex_t *mutex) status = pthread_mutex_trylock(&mymutex)
18 pthread_mutex_unlock int pthread_mutex_unlock(pthread_mutex_t *mutex) pthread_mutex_unlock(&mymutex)
19 pthread_cond_init int pthread_cond_init(pthread_cond_t *cond, const pthread_condalr_t *alr) pthread_cond_init(&mycondvar, NULL) A mutex should be used with each condi)on variable
20 pthread_cond_signal int pthread_cond_signal(pthread_cond_t *cond) pthread_cond_signal(&mycondvar)
21 pthread_cond_wait int pthread_cond_wait(pthread_cond_t *, pthread_mutex_t *mutex) pthread_cond_wait(&mycondvar, &mymutex) Unlocks mymutex and wait for a signal mymutex is locked when a signal is received
22 pthread_cond_broadcast int pthread_cond_broadcast(pthread_cond_t *cond) pthread_cond_broadcast(&mycondvar)
23 Translate the OpenMP Code Segment to pthreads //x is an array of ints, size is a power of 2 rounds = (int) log2( (double) size); for ( j = 1, k = 2; j <= rounds; j++, k = k*2) { numthds = size / k; #pragma omp parallel default(shared) private(i) num_threads(numthds) { i = omp_get_thread_num(); i = i*k; if (x[i] < x[i+k/2]) x[i] = x[i+k/2]; prinp("%d\n ", x[0]);
24 Find Sum Create threads to find the sum of a segment of an array of ints Combine the segment sums into a single sum
25 Global Declara)ons #include <stdio.h> #include <pthread.h> #define ARRAYSIZE 1000 #define NUMTHREADS 4 #define SEGMENTSIZE 250 int data[arraysize]; pthread_t threads[numthreads]; pthread_mutex_t mutex; int globalsum;
26 Main Func)on int main(int argc, char ** argv) { int i; int start[numthreads]; for (i = 0; i <ARRAYSIZE; i++) data[i] = i; //ar)ficial test data for (i = 0; i < NUMTHREADS; i++) start[i] = i*segmentsize; pthread_mutex_init(&mutex, NULL); for (i = 0; i < NUMTHREADS; i++) pthread_create(&threads[i], NULL, par)alsum, (void *) &start[i]); for (i = 0; i < NUMTHREADS; i++) pthread_join(threads[i], NULL); prinp("global Sum = %d\n", globalsum); pthread_mutex_destroy(&mutex); pthread_exit(null);
27 Par)alSum void * par)alsum(void * start) { int begin; int localsum; int i; begin = *(int *) start; localsum = 0; for (i = 0; i < SEGMENTSIZE; i++) localsum = localsum + data[i+begin]; pthread_mutex_lock(&mutex); globalsum = globalsum + localsum; pthread_mutex_unlock(&mutex); pthread_exit(null);
28 Par)al Sum Modifica)on Modify the Par)al Sum program so it does not use a mutex. Use pthread_exit to return the local sum to the main program.
29 Shared Bounded Queue Implements a thread safe FIFO bounded queue Assumes one thread creates the queue and only one thread destroys the queue Func)ons implemented CreateQueue DestroyQueue insert delete
30 Queue.h (part 1) //includes not shown struct Queue { ; pthread_mutex_t mutex; pthread_cond_t notempty; pthread_cond_t notfull; void ** items; int maxsize; int currentsize; int front; int rear;
31 Queue.h (part 2) struct Queue *CreateQueue(int size); void insert(struct Queue *q, void *d); void delete(struct Queue *q, void **d); void DestroyQueue(struct Queue*q);
32 CreateQueue struct Queue *CreateQueue(int size) { struct Queue *q; ; q = (struct Queue *) malloc(sizeof(struct Queue)); q->maxsize = size; q->currentsize = 0; q->front = 0; q->rear = 0; q->items = (void **) malloc(size*sizeof(void *)); pthread_mutex_init(&q->mutex, NULL); pthread_cond_init(&q->notempty, NULL); pthread_cond_init(&q->notfull, NULL); return q;
33 Insert void insert(struct Queue *q, void *d) { pthread_mutex_lock(&q->mutex); while (q->currentsize == q->maxsize) { pthread_cond_wait(&q->notfull, &q->mutex); q->items[q->rear] = d; q->rear = (q->rear+1)%q->maxsize; q->currentsize++; pthread_cond_signal(&q->notempty); pthread_mutex_unlock(&q->mutex);
34 Delete void delete(struct Queue *q, void **d) { pthread_mutex_lock(&q->mutex); while (q->currentsize == 0) { pthread_cond_wait(&q->notempty, &q->mutex); *d = q->items[q->front]; q->front = (q->front+1)%q->maxsize; q->currentsize--; pthread_cond_signal(&q->notfull); pthread_mutex_unlock(&q->mutex);
35 Producer/Consumer Example Revisited Producer/Consumer example using a shared queue The producers produce posi)ve integers The consumer sums the integers it consumes When the consumer gets a -1 it quits and returns the sum it computed to the main thread
36 Producer void * producer(void * arg) { int i; int *j; struct Queue *q = (struct Queue *) arg; for (i = 0; i < 1000; i++) { j = (int *) malloc(sizeof(int)); *j = i; insert (q, (void *) j); pthread_exit(null);
37 Consumer (part 1) void *consumer(void * arg) { bool done; int sum =0; int *retval; int *j; struct Queue *q = (struct Queue *) arg; done = false;
38 Consumer (part 2) while(!done) { delete(q, (void **) &j); if (*j == -1) else done = true; sum = sum + *j; retval = (int *) malloc(sizeof(int)); *retval = sum; pthread_exit( (void *) retval);
39 Main (part 1) int main(int argc, char **argv) { int *retval; struct Queue *q; int numprods; int numcons; pthread_t prods[maxprods]; pthread_t cons[maxcons]; int sum; int i; int *j; numprods = atoi(argv[1]); numcons = atoi(argv[2]); q = CreateQueue(10);
40 Main (part 2) for (i = 0; i < numprods; i++) { pthread_create(&prods[i], NULL, producer, (void *) q); for (i = 0; i < numcons; i++) { pthread_create(&cons[i], NULL, consumer, (void *) q); for (i = 0; i <numprods; i++) { pthread_join(prods[i], NULL);
41 Main (part 3) for (i = 0; i <numcons; i++) { j = (int *) malloc(sizeof(int)); *j = -1; insert (q, (void *) j); for (i = 0; i <numcons; i++) { pthread_join(cons[i], (void **) &retval); sum = sum + (int) *retval; prinp("total %d\n", sum); DestroyQueue(q);
42 Prac)ce Problem pthread Version struct Args { int thread_num; int k; ; void *compare(void * args) { struct Args *a = (struct Args *) args; int k = a->k; int i = a->thread_num * k; if (x[i] < x[i+k/2]) x[i] = x[i+k/2]; pthread_exit(null);
43 Prac)ce Problem pthread Version rounds = (int) log2( (double) size); for ( j = 1, k = 2; j <= rounds; j++, k = k*2) { numthds = size / k; for (i = 0; i < numthds; i++) { args = (struct Args *) malloc(sizeof(struct Args)); args->thread_num = i; args->k = k; pthread_create(&threads[i], NULL, compare, (void *) args); for (i = 0; i < numthds; i++) pthread_join(threads[i], NULL); prinp("%d\n ", x[0]);
POSIX Threads. HUJI Spring 2011
POSIX Threads HUJI Spring 2011 Why Threads The primary motivation for using threads is to realize potential program performance gains and structuring. Overlapping CPU work with I/O. Priority/real-time
More informationThreads. Jo, Heeseung
Threads Jo, Heeseung Multi-threaded program 빠른실행 프로세스를새로생성에드는비용을절약 데이터공유 파일, Heap, Static, Code 의많은부분을공유 CPU 를보다효율적으로활용 코어가여러개일경우코어에 thread 를할당하는방식 2 Multi-threaded program Pros. Cons. 대량의데이터처리에적합 - CPU
More informationCOSC 6374 Parallel Computation. Shared memory programming with POSIX Threads. Edgar Gabriel. Fall References
COSC 6374 Parallel Computation Shared memory programming with POSIX Threads Fall 2012 References Some of the slides in this lecture is based on the following references: http://www.cobweb.ecn.purdue.edu/~eigenman/ece563/h
More informationRicardo Rocha. Department of Computer Science Faculty of Sciences University of Porto
Ricardo Rocha Department of Computer Science Faculty of Sciences University of Porto For more information please consult Advanced Programming in the UNIX Environment, 3rd Edition, W. Richard Stevens and
More informationThreads. Jo, Heeseung
Threads Jo, Heeseung Multi-threaded program 빠른실행 프로세스를새로생성에드는비용을절약 데이터공유 파일, Heap, Static, Code 의많은부분을공유 CPU 를보다효율적으로활용 코어가여러개일경우코어에 thread 를할당하는방식 2 Multi-threaded program Pros. Cons. 대량의데이터처리에적합 - CPU
More informationANSI/IEEE POSIX Standard Thread management
Pthread Prof. Jinkyu Jeong( jinkyu@skku.edu) TA Jinhong Kim( jinhong.kim@csl.skku.edu) TA Seokha Shin(seokha.shin@csl.skku.edu) Computer Systems Laboratory Sungkyunkwan University http://csl.skku.edu The
More informationPthreads. Jin-Soo Kim Computer Systems Laboratory Sungkyunkwan University
Pthreads Jin-Soo Kim (jinsookim@skku.edu) Computer Systems Laboratory Sungkyunkwan University http://csl.skku.edu The Pthreads API ANSI/IEEE POSIX1003.1-1995 Standard Thread management Work directly on
More informationPOSIX PTHREADS PROGRAMMING
POSIX PTHREADS PROGRAMMING Download the exercise code at http://www-micrel.deis.unibo.it/~capotondi/pthreads.zip Alessandro Capotondi alessandro.capotondi(@)unibo.it Hardware Software Design of Embedded
More informationPthreads (2) Dong-kun Shin Embedded Software Laboratory Sungkyunkwan University Embedded Software Lab.
1 Pthreads (2) Dong-kun Shin Embedded Software Laboratory Sungkyunkwan University http://nyx.skku.ac.kr Last Class Review 2 ANSI/IEEE POSIX1003.1-95 Standard Thread management Work directly on threads
More informationSynchronization and Semaphores. Copyright : University of Illinois CS 241 Staff 1
Synchronization and Semaphores Copyright : University of Illinois CS 241 Staff 1 Synchronization Primatives Counting Semaphores Permit a limited number of threads to execute a section of the code Binary
More informationThreads. Jinkyu Jeong Computer Systems Laboratory Sungkyunkwan University
Threads Jinkyu Jeong (jinkyu@skku.edu) Computer Systems Laboratory Sungkyunkwan University http://csl.skku.edu EEE3052: Introduction to Operating Systems, Fall 2017, Jinkyu Jeong (jinkyu@skku.edu) Concurrency
More informationThreads. lightweight processes
Threads lightweight processes 1 Motivation Processes are expensive to create. It takes quite a bit of time to switch between processes Communication between processes must be done through an external kernel
More informationSynchronization and Semaphores. Copyright : University of Illinois CS 241 Staff 1
Synchronization and Semaphores Copyright : University of Illinois CS 241 Staff 1 Synchronization Primatives Counting Semaphores Permit a limited number of threads to execute a section of the code Binary
More informationMultithreading Programming II
Multithreading Programming II Content Review Multithreading programming Race conditions Semaphores Thread safety Deadlock Review: Resource Sharing Access to shared resources need to be controlled to ensure
More informationAgenda. Process vs Thread. ! POSIX Threads Programming. Picture source:
Agenda POSIX Threads Programming 1 Process vs Thread process thread Picture source: https://computing.llnl.gov/tutorials/pthreads/ 2 Shared Memory Model Picture source: https://computing.llnl.gov/tutorials/pthreads/
More informationThreads need to synchronize their activities to effectively interact. This includes:
KING FAHD UNIVERSITY OF PETROLEUM AND MINERALS Information and Computer Science Department ICS 431 Operating Systems Lab # 8 Threads Synchronization ( Mutex & Condition Variables ) Objective: When multiple
More informationCSE 333 Section 9 - pthreads
CSE 333 Section 9 - pthreads Welcome back to section! We re glad that you re here :) Process A process has a virtual address space. Each process is started with a single thread, but can create additional
More informationChapter 4 Threads. Images from Silberschatz 03/12/18. CS460 Pacific University 1
Chapter 4 Threads Images from Silberschatz Pacific University 1 Threads Multiple lines of control inside one process What is shared? How many PCBs? Pacific University 2 Typical Usages Word Processor Web
More informationPosix Threads (Pthreads)
Posix Threads (Pthreads) Reference: Programming with POSIX Threads by David R. Butenhof, Addison Wesley, 1997 Threads: Introduction main: startthread( funk1 ) startthread( funk1 ) startthread( funk2 )
More informationSynchronization Primitives
Synchronization Primitives Locks Synchronization Mechanisms Very primitive constructs with minimal semantics Semaphores A generalization of locks Easy to understand, hard to program with Condition Variables
More informationCSE 333 SECTION 9. Threads
CSE 333 SECTION 9 Threads HW4 How s HW4 going? Any Questions? Threads Sequential execution of a program. Contained within a process. Multiple threads can exist within the same process. Every process starts
More informationParallel Computing: Programming Shared Address Space Platforms (Pthread) Jin, Hai
Parallel Computing: Programming Shared Address Space Platforms (Pthread) Jin, Hai School of Computer Science and Technology Huazhong University of Science and Technology Thread Basics! All memory in the
More informationHPCSE - I. «Introduction to multithreading» Panos Hadjidoukas
HPCSE - I «Introduction to multithreading» Panos Hadjidoukas 1 Processes and Threads POSIX Threads API Outline Thread management Synchronization with mutexes Deadlock and thread safety 2 Terminology -
More informationPthreads: POSIX Threads
Shared Memory Programming Using Pthreads (POSIX Threads) Lecturer: Arash Tavakkol arasht@ipm.ir Some slides come from Professor Henri Casanova @ http://navet.ics.hawaii.edu/~casanova/ and Professor Saman
More informationPOSIX threads CS 241. February 17, Copyright University of Illinois CS 241 Staff
POSIX threads CS 241 February 17, 2012 Copyright University of Illinois CS 241 Staff 1 Recall: Why threads over processes? Creating a new process can be expensive Time A call into the operating system
More informationA Programmer s View of Shared and Distributed Memory Architectures
A Programmer s View of Shared and Distributed Memory Architectures Overview Shared-memory Architecture: chip has some number of cores (e.g., Intel Skylake has up to 18 cores depending on the model) with
More informationMulti-threaded Programming
Multi-threaded Programming Trifon Ruskov ruskov@tu-varna.acad.bg Technical University of Varna - Bulgaria 1 Threads A thread is defined as an independent stream of instructions that can be scheduled to
More informationLecture 4. Threads vs. Processes. fork() Threads. Pthreads. Threads in C. Thread Programming January 21, 2005
Threads vs. Processes Lecture 4 Thread Programming January 21, 2005 fork() is expensive (time, memory) Interprocess communication is hard. Threads are lightweight processes: one process can contain several
More informationIntroduction to parallel computing
Introduction to parallel computing Shared Memory Programming with Pthreads (3) Zhiao Shi (modifications by Will French) Advanced Computing Center for Education & Research Vanderbilt University Last time
More informationCS-345 Operating Systems. Tutorial 2: Grocer-Client Threads, Shared Memory, Synchronization
CS-345 Operating Systems Tutorial 2: Grocer-Client Threads, Shared Memory, Synchronization Threads A thread is a lightweight process A thread exists within a process and uses the process resources. It
More informationThread and Synchronization
Thread and Synchronization pthread Programming (Module 19) Yann-Hang Lee Arizona State University yhlee@asu.edu (480) 727-7507 Summer 2014 Real-time Systems Lab, Computer Science and Engineering, ASU Pthread
More informationLSN 13 Linux Concurrency Mechanisms
LSN 13 Linux Concurrency Mechanisms ECT362 Operating Systems Department of Engineering Technology LSN 13 Creating Processes fork() system call Returns PID of the child process created The new process is
More informationMore Shared Memory Programming
More Shared Memory Programming Shared data structures We want to make data structures that can be shared by threads. For example, our program to copy a file from one disk to another used a shared FIFO
More informationProcess Synchronization
Process Synchronization Part III, Modified by M.Rebaudengo - 2013 Silberschatz, Galvin and Gagne 2009 POSIX Synchronization POSIX.1b standard was adopted in 1993 Pthreads API is OS-independent It provides:
More informationCSCI4430 Data Communication and Computer Networks. Pthread Programming. ZHANG, Mi Jan. 26, 2017
CSCI4430 Data Communication and Computer Networks Pthread Programming ZHANG, Mi Jan. 26, 2017 Outline Introduction What is Multi-thread Programming Why to use Multi-thread Programming Basic Pthread Programming
More informationIntroduction to PThreads and Basic Synchronization
Introduction to PThreads and Basic Synchronization Michael Jantz, Dr. Prasad Kulkarni Dr. Douglas Niehaus EECS 678 Pthreads Introduction Lab 1 Introduction In this lab, we will learn about some basic synchronization
More informationPOSIX Threads. Paolo Burgio
POSIX Threads Paolo Burgio paolo.burgio@unimore.it The POSIX IEEE standard Specifies an operating system interface similar to most UNIX systems It extends the C language with primitives that allows the
More informationreal time operating systems course
real time operating systems course 4 introduction to POSIX pthread programming introduction thread creation, join, end thread scheduling thread cancellation semaphores thread mutexes and condition variables
More informationTHREADS. Jo, Heeseung
THREADS Jo, Heeseung TODAY'S TOPICS Why threads? Threading issues 2 PROCESSES Heavy-weight A process includes many things: - An address space (all the code and data pages) - OS resources (e.g., open files)
More informationProgramming Languages
Programming Languages Dr. Michael Petter WS 2016/17 Exercise Sheet 3 Assignment 3.1 Lockfree vs. locked programming The purpose of the following exercises is to get acquainted with the pthreads library,
More informationShared Address Space Programming with Pthreads. CS 5334/4390 Spring 2014 Shirley Moore, Instructor February 18, 2014
Shared Address Space Programming with Pthreads CS 5334/4390 Spring 2014 Shirley Moore, Instructor February 18, 2014 1 Topic Overview Thread Basics The POSIX Thread API Mutual Exclusion Locks Condition
More informationWarm-up question (CS 261 review) What is the primary difference between processes and threads from a developer s perspective?
Warm-up question (CS 261 review) What is the primary difference between processes and threads from a developer s perspective? CS 470 Spring 2019 POSIX Mike Lam, Professor Multithreading & Pthreads MIMD
More informationTCSS 422: OPERATING SYSTEMS
TCSS 422: OPERATING SYSTEMS OBJECTIVES Introduction to threads Concurrency: An Introduction Wes J. Lloyd Institute of Technology University of Washington - Tacoma Race condition Critical section Thread
More informationProgramming Shared Address Space Platforms (cont.) Alexandre David B2-206
Programming Shared Address Space Platforms (cont.) Alexandre David B2-206 1 Today Finish thread synchronization. Effort for pthreads = synchronization. Effort for MPI = communication. OpenMP. Extra material
More informationpthreads Announcement Reminder: SMP1 due today Reminder: Please keep up with the reading assignments (see class webpage)
pthreads 1 Announcement Reminder: SMP1 due today Reminder: Please keep up with the reading assignments (see class webpage) 2 1 Thread Packages Kernel thread packages Implemented and supported at kernel
More informationCS345 Opera,ng Systems. Φροντιστήριο Άσκησης 2
CS345 Opera,ng Systems Φροντιστήριο Άσκησης 2 Inter- process communica0on Exchange data among processes Methods Signals Pipes Sockets Shared Memory Sockets Endpoint of communica,on link between two programs
More informationShared Memory Parallel Programming
Shared Memory Parallel Programming Abhishek Somani, Debdeep Mukhopadhyay Mentor Graphics, IIT Kharagpur August 2, 2015 Abhishek, Debdeep (IIT Kgp) Parallel Programming August 2, 2015 1 / 46 Overview 1
More informationCS510 Operating System Foundations. Jonathan Walpole
CS510 Operating System Foundations Jonathan Walpole Threads & Concurrency 2 Why Use Threads? Utilize multiple CPU s concurrently Low cost communication via shared memory Overlap computation and blocking
More informationMultithread Programming. Alexandre David
Multithread Programming Alexandre David 1.2.05 adavid@cs.aau.dk Comparison Directive based: OpenMP. Explicit parallel programming: pthreads shared memory focus on synchronization, MPI message passing focus
More informationRunning example. Threads. Overview. Programming Shared-memory Machines 3/21/2018
Running example Programming Shared-memory Machines Some slides adapted from Ananth Grama, Anshul Gupta, George Karypis, and Vipin Kumar ``Introduction to Parallel Computing'', Addison Wesley, 2003. Algorithmic
More informationData Races and Deadlocks! (or The Dangers of Threading) CS449 Fall 2017
Data Races and Deadlocks! (or The Dangers of Threading) CS449 Fall 2017 Data Race Shared Data: 465 1 8 5 6 209? tail A[] thread switch Enqueue(): A[tail] = 20; tail++; A[tail] = 9; tail++; Thread 0 Thread
More informationLocks and semaphores. Johan Montelius KTH
Locks and semaphores Johan Montelius KTH 2017 1 / 41 recap, what s the problem : # include < pthread.h> volatile int count = 0; void * hello ( void * arg ) { for ( int i = 0; i < 10; i ++) { count ++;
More informationCS333 Intro to Operating Systems. Jonathan Walpole
CS333 Intro to Operating Systems Jonathan Walpole Threads & Concurrency 2 Threads Processes have the following components: - an address space - a collection of operating system state - a CPU context or
More informationThread Posix: Condition Variables Algoritmi, Strutture Dati e Calcolo Parallelo. Daniele Loiacono
Thread Posix: Condition Variables Algoritmi, Strutture Dati e Calcolo Parallelo References The material in this set of slide is taken from two tutorials by Blaise Barney from the Lawrence Livermore National
More informationProgramming with Shared Memory
Chapter 8 Programming with Shared Memory 1 Shared memory multiprocessor system Any memory location can be accessible by any of the processors. A single address space exists, meaning that each memory location
More informationPthreads: Busy Wait, Mutexes, Semaphores, Condi9ons, and Barriers
Pthreads: Busy Wait, Mutexes, Semaphores, Condi9ons, and Barriers Bryan Mills Chapter 4.2-4.8 Spring 2017 A Shared Memory System Copyright 2010, Elsevier Inc. All rights Reserved Pthreads Pthreads is a
More informationChapter 4 Concurrent Programming
Chapter 4 Concurrent Programming 4.1. Introduction to Parallel Computing In the early days, most computers have only one processing element, known as the Central Processing Unit (CPU). Due to this hardware
More informationConcurrency and Synchronization. ECE 650 Systems Programming & Engineering Duke University, Spring 2018
Concurrency and Synchronization ECE 650 Systems Programming & Engineering Duke University, Spring 2018 Concurrency Multiprogramming Supported by most all current operating systems More than one unit of
More informationShared Memory: Virtual Shared Memory, Threads & OpenMP
Shared Memory: Virtual Shared Memory, Threads & OpenMP Eugen Betke University of Hamburg Department Informatik Scientific Computing 09.01.2012 Agenda 1 Introduction Architectures of Memory Systems 2 Virtual
More informationUnix. Threads & Concurrency. Erick Fredj Computer Science The Jerusalem College of Technology
Unix Threads & Concurrency Erick Fredj Computer Science The Jerusalem College of Technology 1 Threads Processes have the following components: an address space a collection of operating system state a
More informationCS444 1/28/05. Lab 03
CS444 1/28/05 Lab 03 Note All the code that is found in this lab guide can be found at the following web address: www.clarkson.edu/class/cs444/cs444.sp2005/labs/lab03/code/ Threading A thread is an independent
More informationProgramming with Shared Memory. Nguyễn Quang Hùng
Programming with Shared Memory Nguyễn Quang Hùng Outline Introduction Shared memory multiprocessors Constructs for specifying parallelism Creating concurrent processes Threads Sharing data Creating shared
More informationOct 2 and 4, 2006 Lecture 8: Threads, Contd
Oct 2 and 4, 2006 Lecture 8: Threads, Contd October 4, 2006 1 ADMIN I have posted lectures 3-7 on the web. Please use them in conjunction with the Notes you take in class. Some of the material in these
More informationXu Liu Derived from John Mellor-Crummey s COMP422 at Rice University
Programming Shared-memory Platforms with Pthreads Xu Liu Derived from John Mellor-Crummey s COMP422 at Rice University Topics for Today The POSIX thread API (Pthreads) Synchronization primitives in Pthreads
More informationC Grundlagen - Threads
Michael Strassberger saremox@linux.com Proseminar C Grundlagen Fachbereich Informatik Fakultaet fuer Mathematik, Informatik und Naturwissenschaften Universitaet Hamburg 3. Juli 2014 Table of Contents 1
More informationpthreads CS449 Fall 2017
pthreads CS449 Fall 2017 POSIX Portable Operating System Interface Standard interface between OS and program UNIX-derived OSes mostly follow POSIX Linux, macos, Android, etc. Windows requires separate
More informationCS F-MID Midterm October 25, 2001
Name (Last, First): This exam consists of 5 questions on 9 pages; be sure you have the entire exam before starting. The point value of each question is indicated at its beginning; the entire exam has 100
More informationThreads (SGG 4) Outline. Traditional Process: Single Activity. Example: A Text Editor with Multi-Activity. Instructor: Dr.
When in the Course of human events, it becomes necessary for one people to dissolve the political bands which have connected them with another, and to assume among the powers of the earth, the separate
More informationProgramming RT systems with pthreads
Programming RT systems with pthreads Giuseppe Lipari http://feanor.sssup.it/~lipari Scuola Superiore Sant Anna Pisa December 1, 2011 Outline 1 Timing utilities 2 Periodic threads 3 Scheduler selection
More informationA Note About Makefiles. In OneFS/BSD be sure to build using gmake You may have to remove -pedantic-errors from CFLAGS
PThreads A Note About Makefiles In OneFS/BSD be sure to build using gmake You may have to remove -pedantic-errors from CFLAGS Creating/Starting a Thread (1 of 4) #include typedef void *THREAD_PROC_t(
More informationComputer Systems Laboratory Sungkyunkwan University
Threads Jin-Soo Kim (jinsookim@skku.edu) Computer Systems Laboratory Sungkyunkwan University http://csl.skku.edu Today s Topics Why threads? Threading issues 2 Processes Heavy-weight A process includes
More informationCS 220: Introduction to Parallel Computing. Condition Variables. Lecture 24
CS 220: Introduction to Parallel Computing Condition Variables Lecture 24 Remember: Creating a Thread int pthread_create( pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void *),
More informationCS 5523 Operating Systems: Thread and Implementation
When in the Course of human events, it becomes necessary for one people to dissolve the political bands which have connected them with another, and to assume among the powers of the earth, the separate
More informationLocks and semaphores. Johan Montelius KTH
Locks and semaphores Johan Montelius KTH 2018 1 / 40 recap, what s the problem : # include < pthread.h> volatile int count = 0; void * hello ( void * arg ) { for ( int i = 0; i < 10; i ++) { count ++;
More informationPreview. What are Pthreads? The Thread ID. The Thread ID. The thread Creation. The thread Creation 10/25/2017
Preview What are Pthreads? What is Pthreads The Thread ID The Thread Creation The thread Termination The pthread_join() function Mutex The pthread_cancel function The pthread_cleanup_push() function The
More informationCondition Variables. Dongkun Shin, SKKU
Condition Variables 1 Why Condition? cases where a thread wishes to check whether a condition is true before continuing its execution 1 void *child(void *arg) { 2 printf("child\n"); 3 // XXX how to indicate
More informationCS Operating Systems: Threads (SGG 4)
When in the Course of human events, it becomes necessary for one people to dissolve the political bands which have connected them with another, and to assume among the powers of the earth, the separate
More informationCS240: Programming in C. Lecture 18: PThreads
CS240: Programming in C Lecture 18: PThreads Thread Creation Initially, your main() program comprises a single, default thread. pthread_create creates a new thread and makes it executable. This routine
More informationProgramming Shared Address Space Platforms (Chapter 7)
Programming Shared Address Space Platforms (Chapter 7) Alexandre David 1.2.05 This is about pthreads. 1 Comparison Directive based: OpenMP. Explicit parallel programming: pthreads shared memory focus on
More informationProgramming RT systems with pthreads
Programming RT systems with pthreads Giuseppe Lipari http://www.lifl.fr/~lipari CRIStAL - University de Lille 1 October 4, 2015 G. Lipari (CRIStAL) Programming RT systems with pthreads October 4, 2015
More informationParallel Threads Computing
High Performance Computing: Concepts, Methods & Means Parallel Threads Computing Prof. Thomas Sterling Department of Computer Science Louisiana State University February 6 th, 2007 Topics Introduction
More informationCS 333 Introduction to Operating Systems. Class 3 Threads & Concurrency. Jonathan Walpole Computer Science Portland State University
CS 333 Introduction to Operating Systems Class 3 Threads & Concurrency Jonathan Walpole Computer Science Portland State University 1 Process creation in UNIX All processes have a unique process id getpid(),
More informationModern Computer Architecture. Lecture 10 Multi-Core: pthreads, OpenMP Segmented Scan
Modern Computer Architecture Lecture 10 Multi-Core: pthreads, OpenMP Segmented Scan Outline Multi-Core: pthreads OpenMP Segmented Scan 2 Multi-Core: pthreads, OpenMP Multi- and Many-Core Systems I Tightly
More informationCSE 421/521 - Operating Systems Fall 2011 Recitations. Recitation - III Networking & Concurrent Programming Prof. Tevfik Kosar. Presented by...
CSE 421/521 - Operating Systems Fall 2011 Recitations Recitation - III Networking & Concurrent Programming Prof. Tevfik Kosar Presented by... University at Buffalo September..., 2011 1 Network Programming
More informationCondition Variables. Jinkyu Jeong Computer Systems Laboratory Sungkyunkwan University
Condition Variables Jinkyu Jeong (jinkyu@skku.edu) Computer Systems Laboratory Sungkyunkwan University http://csl.skku.edu EEE3052: Introduction to Operating Systems, Fall 2017, Jinkyu Jeong (jinkyu@skku.edu)
More informationPRINCIPLES OF OPERATING SYSTEMS
Department of Computer Science, University of Calgary PRINCIPLES OF OPERATING SYSTEMS Tutorial 9/10: Concurrency CPSC 457, Spring 2015 June 1-2, 2015 Announcement Midterm exam is rescheduled. The exam
More informationSolving the Producer Consumer Problem with PThreads
Solving the Producer Consumer Problem with PThreads Michael Jantz Dr. Prasad Kulkarni Dr. Douglas Niehaus EECS 678 Pthreads: Producer-Consumer 1 Introduction This lab is an extension of last week's lab.
More informationOperating System Labs. Yuanbin Wu
Operating System Labs Yuanbin Wu CS@ECNU Operating System Labs Project 4 Due: 10 Dec. Oral tests of Project 3 Date: Nov. 27 How 5min presentation 2min Q&A Operating System Labs Oral tests of Lab 3 Who
More information20-EECE-4029 Operating Systems Spring, 2015 John Franco
20-EECE-4029 Operating Systems Spring, 2015 John Franco First Exam name: Question 1: Semaphores The code below produces a line consisting of 10 each of the letters A, B, and C. What other relationship
More informationCSC Systems Programming Fall Lecture - XIV Concurrent Programming. Tevfik Ko!ar. Louisiana State University. November 2nd, 2010
CSC 4304 - Systems Programming Fall 2010 Lecture - XIV Concurrent Programming Tevfik Ko!ar Louisiana State University November 2nd, 2010 1 Concurrency Issues 2 Concurrency Issues 3 Synchronization Mechanism
More informationPre-lab #2 tutorial. ECE 254 Operating Systems and Systems Programming. May 24, 2012
Pre-lab #2 tutorial ECE 254 Operating Systems and Systems Programming May 24, 2012 Content Concurrency Concurrent Programming Thread vs. Process POSIX Threads Synchronization and Critical Sections Mutexes
More informationReal Time Operating Systems and Middleware
Real Time Operating Systems and Middleware POSIX Threads Synchronization Luca Abeni abeni@dit.unitn.it Real Time Operating Systems and Middleware p. 1 Threads Synchronisation All the threads running in
More informationConcurrent Programming
Concurrent Programming Prof. Jinkyu Jeong( jinkyu@skku.edu) TA Jinhong Kim( jinhong.kim@csl.skku.edu) TA Seokha Shin(seokha.shin@csl.skku.edu) Computer Systems Laboratory Sungkyunkwan University http://csl.skku.edu
More informationCS 470 Spring Mike Lam, Professor. Semaphores and Conditions
CS 470 Spring 2018 Mike Lam, Professor Semaphores and Conditions Synchronization mechanisms Busy-waiting (wasteful!) Atomic instructions (e.g., LOCK prefix in x86) Pthreads Mutex: simple mutual exclusion
More informationParalleland Distributed Programming. Concurrency
Paralleland Distributed Programming Concurrency Concurrency problems race condition synchronization hardware (eg matrix PCs) software (barrier, critical section, atomic operations) mutual exclusion critical
More informationParallel and Distributed Computing
Concurrent Programming with OpenMP Rodrigo Miragaia Rodrigues MSc in Information Systems and Computer Engineering DEA in Computational Engineering CS Department (DEI) Instituto Superior Técnico October
More informationCS 333 Introduction to Operating Systems. Class 3 Threads & Concurrency. Jonathan Walpole Computer Science Portland State University
CS 333 Introduction to Operating Systems Class 3 Threads & Concurrency Jonathan Walpole Computer Science Portland State University 1 The Process Concept 2 The Process Concept Process a program in execution
More informationConcurrent Programming
Concurrent Programming Prof. Jin-Soo Kim( jinsookim@skku.edu) TA Jinhong Kim( jinhong.kim@csl.skku.edu) Computer Systems Laboratory Sungkyunkwan University http://csl.skku.edu Echo Server Revisited int
More informationFaculté Polytechnique
Faculté Polytechnique Real-Time Systems - Practical Work 5 POSIX Threads Dr Frémal Sébastien Sebastien.FREMAL@umons.ac.be Ir Michel Bagein Michel.BAGEIN@umons.ac.be Prof. Pierre Manneback Pierre.MANNEBACK@umons.ac.be
More informationCondition Variables. Dongkun Shin, SKKU
Condition Variables 1 Why Condition? cases where a thread wishes to check whether a condition is true before continuing its execution 1 void *child(void *arg) { 2 printf("child\n"); 3 // XXX how to indicate
More information