Translating C programs using POSIX thread into CSP for refinement checking

Size: px
Start display at page:

Download "Translating C programs using POSIX thread into CSP for refinement checking"

Transcription

1 Translating C programs using POSIX thread into CSP for refinement checking Hisabumi HATSUGAI hatsugai@principia-m.com PRINCIPIA Limited PRINCIPIA Limited 1

2 Pthread Model Checker An easy-to-use model checker for C programs using POSIX thread Models can be written in C Three types of checks can be performed: Assertions Deadlock detection Invalid operations for mutexes and condition variables Checking can be performed in parallel. 25 Producers/Consumers BUFLEN=23 Np=Nc=4 20 Speed up PRINCIPIA Limited Number of workers

3 Internal Process of PTMC Model in C convert to LTS LTS convert to checker checker in C void *producer(void *arg) { while (true) { pthread_mutex_lock(&mutex); while (count == N) { pthread_cond_wait(&cv, &mutex); count++; pthread_cond_signal(&cv2); pthread_mutex_unlock(&mutex); return NULL; (lock mutex):23 [24] IN() [25] IN(t18) OUT(t18) [23] IN() (lock mutex):21 [29] IN() (unlock mutex):27 (load-scalar t18 count):22 (signal cv2):26 (lock mutex):37 [17] IN() [18] IN(t16) OUT(t16) [16] IN() (lock mutex):35 [22] IN() (unlock mutex):41 (load-scalar t16 count):36 (signal cv):40 void *consumer(void *arg) { while (true) { pthread_mutex_lock(&mutex); while (count == 0) { pthread_cond_wait(&cv2, &mutex); count--; pthread_cond_signal(&cv); pthread_mutex_unlock(&mutex); return NULL; [26] IN() [(= t18 4)] [(not (= t18 4))] (wait cv mutex):22 (load-scalar t19 count):22 [27] IN(t19) OUT(t19) (store-scalar count (+ t19 1)): PRINCIPIA Limited 3 [28] IN() [19] IN() [(= t16 0)] [(not (= t16 0))] (wait cv2 mutex):36 (load-scalar t17 count):36 [20] IN(t17) OUT(t17) (store-scalar count (- t17 1)):39 [21] IN()

4 Checking assertions is not enough Pthread Model Checker supports "Global Assertions" which can be used for checking simple safety properties. int count; >= 0 && count <= N) The following checks are not supported Divergence detection Liveness Refinement relations 2017 PRINCIPIA Limited 4

5 Translating LTS into CSP Model in C convert to LTS LTS convert to checker checker in C (def (S1 ($pid Ip)) (par (set) (S2 $pid) (S22 (+ 1 0))))) (def SYSTEM (par X (seq (S1 0) (! terminate SKIP)) (par (set terminate) CVM0 PM0 (GVS-count 0) (GVS-putp 0) (GVS-getp 0) (GVA-buf (make-list L-buf 0))))) translate into CSP CSP model CSP refinemt checker SSG 2017 PRINCIPIA Limited 5

6 Transition labels Transition Labels in LTS tau assert Accessing to global variables load-scalar/load-array store-scalar/store-array Thread creation and termination create exit join Mutex operations lock unlock Condition variables operations wait signal broadcast (lock mutex):23 [26] IN() [24] IN() [25] IN(t18) OUT(t18) [27] IN(t19) OUT(t19) [23] IN() (lock mutex):21 [29] IN() (unlock mutex):27 (load-scalar t18 count):22 [(= t18 4)] [(not (= t18 4))] (wait cv mutex):22 (load-scalar t19 count):22 (store-scalar count (+ t19 1)):25 [28] IN() (signal cv2): PRINCIPIA Limited 6

7 Structure of CSP processes thread 0 thread 1 thread 2 thread 3 Mutex and Condition Variables lock unlock wait signal broadcast Retcode exit join global var rd-* wr-* 2017 PRINCIPIA Limited 7

8 Mutexes and condition variables (def (CVM (ms (list mutex-state Nm)) (mss (list (set Ip) Nm)) (css (list (set pmpair) Nc))) (? lock (p m) (CVM ms (update mss m (adjoin (ref mss m) p)) css)) (? unlock (p m) (CVM (update ms m Unlock) mss css)) (? wait (p c m) (CVM (update ms m Unlock) mss (update css c (adjoin (ref css c) (PMPair p m))))) (? signal (p c) (let ((s (ref css c))) (if (empty? s) (CVM ms mss css) (xndc pm s (case pm ((PMPair q m) (CVM ms (update mss m (adjoin (ref mss m) q)) (update css c (remove s pm))))))))) (xalt m (collect-mutex-index ms mss) (xalt q (ref mss m) (! (ret q) (CVM (update ms m (Lock q)) (update mss m (remove (ref mss m) q)) css)))) (! terminate SKIP))) (defch ret (defch lock (defch unlock (defch wait (defch signal (defch broadcast Ip) Ip Im) Ip Im) Ip Ic Im) Ip Ic) Ip Ic) 2017 PRINCIPIA Limited 8

9 Retcode process for exit and join (deftype proc-state Running (Done Di)) (defch exit Ip Di) (defch join Ip Di) (def (PM (xs (list proc-state Np))) (? exit (pid retcode) (PM (update xs pid (Done retcode)))) (? join (pid retcode) (= (Done retcode) (ref xs pid)) (PM xs)) (! terminate SKIP))) 2017 PRINCIPIA Limited 9

10 Global variables Scalar (defch rd-count Di) (defch wr-count Di) (def (GVS-count (x Di)) (! (rd-count x) (GVS-count x)) (? wr-count (x) (GVS-count x)) (! terminate SKIP))) Array (def L-buf 3) (deftypename I-buf (int 0 L-buf)) (defch rd-buf I-buf Di) (defch wr-buf I-buf Di) (def (GVA-buf (xs (list Di 3))) (? rd-buf (k x) (= x (ref xs k)) (GVA-buf xs)) (? wr-buf (k x) (GVA-buf (update xs k x))) (! terminate SKIP))) 2017 PRINCIPIA Limited 10

11 example Threads (defch internal) (defch assertion-violation) (def (S32 ($pid Ip) (c Di)) (! (wr-count (+ c 1)) (S33 $pid)))) (def (S31 ($pid Ip) (k Di) (c Di)) (if (= (if (= (if (= k 2) 1 0) 0) 1 0) 0) STOP (! (wr-putp (+ k 1)) (S32 $pid c))) (if (= (if (= k 2) 1 0) 0) STOP (! (wr-putp 0) (S32 $pid c))))) (def (S30 ($pid Ip) (c Di) (k Di)) (let (((x Di) 2)) (! internal (S28 $pid x k c))))) 2017 PRINCIPIA Limited 11

12 Specification: Assertion Violation (def NO-ASSERTION-VIOLATION (RUN (diff event (set assertion-violation)))) (def (RUN A) (xalt e A (! e (RUN A)))) (check (deadlock SYSTEM)) (check (traces NO-ASSERTION-VIOLATION SYSTEM)) 2017 PRINCIPIA Limited 12

13 Safety verification void *producer(void *arg) { while (true) { int c, k, x; pthread_mutex_lock(&mutex); loop: c = count; if (c == N) { pthread_cond_wait(&cv, &mutex); goto loop; k = putp; AMB x = 0; OR AMB x = 1; OR x = 2; buf[k] = x; if (k == N - 1) putp = 0; else putp = k + 1; count = c + 1; pthread_cond_signal(&cv2); pthread_mutex_unlock(&mutex); return NULL; void consumer0(void) { while (true) { int c, k, x; pthread_mutex_lock(&mutex); loop: c = count; if (c == 0) { pthread_cond_wait(&cv2, &mutex); goto loop; k = getp; x = buf[k]; if (k == N - 1) getp = 0; else getp = k + 1; count = c - 1; pthread_cond_signal(&cv); pthread_mutex_unlock(&mutex); 2017 PRINCIPIA Limited 13 Producer 0 Producer 1 Producer 2 Producer 3 Queue Consumer 0 Consumer 1 Consumer 2 AMB x = 0; OR AMB x = 1; OR x = 2; Nondeterministic choice statement

14 Specification: Safety (def SPEC (let ((A (diff event (chset rd-buf wr-buf assertion-violation)))) (OBSERVER A (list)))) (def (OBSERVER (A (set event)) (xs (list Di L-buf))) (? rd-buf (k x) (and (not (null? xs)) (= x (car xs))) (OBSERVER A (cdr xs))) (? wr-buf (k x) (< (length xs) L-buf) (OBSERVER A (append1 xs x))) (xalt e A (! e (OBSERVER A xs))))) 2017 PRINCIPIA Limited 14

15 Conclusion Developped a LTS to CSP translator in Pthread Model Checker. Refinement checking can be performed for C programs using POSIX thread with Pthread Model Checker and SSG. Pthread Model Checker SSG Specification in CSP Model in C using POSIX thread 2017 PRINCIPIA Limited 15

Parallel and On-the-fly CSP Refinement Checking

Parallel and On-the-fly CSP Refinement Checking Parallel and On-the-fly CSP Refinement Checking Hisabumi HATSUGAI isaac@principia-m.com PRINCIPIA Limited. http://www.principia-m.com/ 2014 PRINCIPIA Limited. Contents 1. SSG Goals and Design Decisions

More information

Condition Variables. Dongkun Shin, SKKU

Condition 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

Operating Systems CMPSCI 377 Spring Mark Corner University of Massachusetts Amherst

Operating Systems CMPSCI 377 Spring Mark Corner University of Massachusetts Amherst Operating Systems CMPSCI 377 Spring 2017 Mark Corner University of Massachusetts Amherst What is a Monitor? Ties data and the synchronization operations together Monitors guarantee mutual exclusion, i.e.,

More information

Condition Variables. Dongkun Shin, SKKU

Condition 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

Locks and semaphores. Johan Montelius KTH

Locks 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 information

Ricardo Rocha. Department of Computer Science Faculty of Sciences University of Porto

Ricardo 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 information

1. Introduction. 2. Project Submission and Deliverables

1. Introduction. 2. Project Submission and Deliverables Spring 2018 Programming Project 2 Due 11:59 PM, Wednesday, 3/21/18 (3/21 is the Wednesday after Spring Break, so if you don t want to work on the program over break or save all the work for those last

More information

CS 470 Spring Mike Lam, Professor. Semaphores and Conditions

CS 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 information

CSE 333 SECTION 9. Threads

CSE 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 information

CS-537: Midterm Exam (Fall 2013) Professor McFlub

CS-537: Midterm Exam (Fall 2013) Professor McFlub CS-537: Midterm Exam (Fall 2013) Professor McFlub Please Read All Questions Carefully! There are fourteen (14) total numbered pages. Please put your NAME (mandatory) on THIS page, and this page only. Name:

More information

Data Races and Deadlocks! (or The Dangers of Threading) CS449 Fall 2017

Data 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 information

POSIX Threads. HUJI Spring 2011

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 information

Condition Variables. Figure 29.1: A Parent Waiting For Its Child

Condition Variables. Figure 29.1: A Parent Waiting For Its Child 29 Condition Variables Thus far we have developed the notion of a lock and seen how one can be properly built with the right combination of hardware and OS support. Unfortunately, locks are not the only

More information

Synchronization and Semaphores. Copyright : University of Illinois CS 241 Staff 1

Synchronization 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 information

Locks and semaphores. Johan Montelius KTH

Locks 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 information

recap, what s the problem Locks and semaphores Total Store Order Peterson s algorithm Johan Montelius 0 0 a = 1 b = 1 read b read a

recap, what s the problem Locks and semaphores Total Store Order Peterson s algorithm Johan Montelius 0 0 a = 1 b = 1 read b read a recap, what s the problem Locks and semaphores Johan Montelius KTH 2017 # include < pthread.h> volatile int count = 0; void * hello ( void * arg ) { for ( int i = 0; i < 10; i ++) { count ++; int main

More information

COSC 6374 Parallel Computation. Shared memory programming with POSIX Threads. Edgar Gabriel. Fall References

COSC 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 information

CS F-MID Midterm October 25, 2001

CS 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 information

Multithreading Programming II

Multithreading 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 information

Introduction to parallel computing

Introduction 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 information

Operating systems and concurrency (B08)

Operating systems and concurrency (B08) Operating systems and concurrency (B08) David Kendall Northumbria University David Kendall (Northumbria University) Operating systems and concurrency (B08) 1 / 20 Introduction Semaphores provide an unstructured

More information

CS 220: Introduction to Parallel Computing. Condition Variables. Lecture 24

CS 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 information

30. Condition Variables

30. Condition Variables 30. Condition Variables Oerating System: Three Easy Pieces AOS@UC 1 Condition Variables There are many cases where a thread wishes to check whether a condition is true before continuing its execution.

More information

CS 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 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 information

More Shared Memory Programming

More 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 information

The course that gives CMU its Zip! Concurrency II: Synchronization Nov 14, 2000

The course that gives CMU its Zip! Concurrency II: Synchronization Nov 14, 2000 5-3 The course that gives CMU its Zip! Concurrency II: Synchronization Nov 4, 000 Topics Progress graphs Semaphores Mutex and condition variables Barrier synchronization Timeout waiting A version of badcnt.c

More information

Warm-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? 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 information

LSN 13 Linux Concurrency Mechanisms

LSN 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 information

CSCI4430 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 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 information

Operating Systems (2INC0) 2017/18

Operating Systems (2INC0) 2017/18 Operating Systems (2INC0) 2017/18 Condition Synchronization (07) Dr. Courtesy of Prof. Dr. Johan Lukkien System Architecture and Networking Group Agenda Condition synchronization motivation condition variables

More information

CS 153 Lab6. Kishore Kumar Pusukuri

CS 153 Lab6. Kishore Kumar Pusukuri Outline Mutex vs Condition Variables Unlocking and locking mutex leads spinning or polling, wastes CPU time. We could sleep for some amount of time, but we do not know how long to sleep. A mutex is for

More information

Global variables and resources are shared between threads within the same process. Each thread has its own stack and program counter (see Fig 2-7).

Global variables and resources are shared between threads within the same process. Each thread has its own stack and program counter (see Fig 2-7). Threads One way to reduce context switch time is to run lightweight processes within the same address space. This abstraction is often called a thread. Look at Figure 2-6. Global variables and resources

More information

Shared Memory Programming. Parallel Programming Overview

Shared Memory Programming. Parallel Programming Overview Shared Memory Programming Arvind Krishnamurthy Fall 2004 Parallel Programming Overview Basic parallel programming problems: 1. Creating parallelism & managing parallelism Scheduling to guarantee parallelism

More information

Condition Variables CS 241. Prof. Brighten Godfrey. March 16, University of Illinois

Condition Variables CS 241. Prof. Brighten Godfrey. March 16, University of Illinois Condition Variables CS 241 Prof. Brighten Godfrey March 16, 2012 University of Illinois 1 Synchronization primitives Mutex locks Used for exclusive access to a shared resource (critical section) Operations:

More information

Synchronising Threads

Synchronising Threads Synchronising Threads David Chisnall March 1, 2011 First Rule for Maintainable Concurrent Code No data may be both mutable and aliased Harder Problems Data is shared and mutable Access to it must be protected

More information

CS 3723 Operating Systems: Final Review

CS 3723 Operating Systems: Final Review CS 3723 Operating Systems: Final Review Outline Threads Synchronizations Pthread Synchronizations Instructor: Dr. Tongping Liu 1 2 Threads: Outline Context Switches of Processes: Expensive Motivation and

More information

Case Study: Using Inspect to Verify and fix bugs in a Work Stealing Deque Simulator

Case Study: Using Inspect to Verify and fix bugs in a Work Stealing Deque Simulator Case Study: Using Inspect to Verify and fix bugs in a Work Stealing Deque Simulator Wei-Fan Chiang 1 Introduction Writing bug-free multi-threaded programs is hard. Bugs in these programs have various types

More information

Context-Switch-Directed Verification in DIVINE

Context-Switch-Directed Verification in DIVINE Context-Switch-Directed Verification in DIVINE MEMICS 2014 Vladimír Štill Petr Ročkai Jiří Barnat Faculty of Informatics Masaryk University, Brno October 18, 2014 Vladimír Štill et al. Context-Switch-Directed

More information

Synchronization and Semaphores. Copyright : University of Illinois CS 241 Staff 1

Synchronization 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 information

CS 3214 Midterm. Here is the distribution of midterm scores for both sections (combined). Midterm Scores 20. # Problem Points Score

CS 3214 Midterm. Here is the distribution of midterm scores for both sections (combined). Midterm Scores 20. # Problem Points Score CS 3214 Here is the distribution of midterm scores for both sections (combined). Scores 20 18 16 14 12 10 8 6 4 2 15 20 25 30 35 40 45 50 55 60 65 70 75 80 85 90 95 100 0 The overall average was 58 points.

More information

Testing Concurrent Programs: Model Checking SPIN. Bengt Jonsson

Testing Concurrent Programs: Model Checking SPIN. Bengt Jonsson Testing Concurrent Programs: Model Checking SPIN Bengt Jonsson Model Checking Section Weeks 15 and 16. Goal: Understand and use the basics of Model checking, using state space exploration Modeling parallel

More information

Overview. Thread Packages. Threads The Thread Model (1) The Thread Model (2) The Thread Model (3) Thread Usage (1)

Overview. Thread Packages. Threads The Thread Model (1) The Thread Model (2) The Thread Model (3) Thread Usage (1) Overview Thread Packages Thomas Plagemann With slides from O. Anshus, C. Griwodz, M. van Steen, and A. Tanenbaum What are threads? Why threads? Example: Da CaPo 1.0 Thread implementation User level level

More information

Condition Variables & Semaphores

Condition Variables & Semaphores Condition Variables & Semaphores Nima Honarmand (Based on slides by Prof. Andrea Arpaci-Dusseau) Review: Concurrency Objectives Mutual Exclusion A & B don t run at the same time Solved using locks Ordering

More information

Copyright 2008 CS655 System Modeling and Analysis. Korea Advanced Institute of Science and Technology

Copyright 2008 CS655 System Modeling and Analysis. Korea Advanced Institute of Science and Technology The Spin Model Checker : Part I Copyright 2008 CS655 System Korea Advanced Institute of Science and Technology System Spec. In Promela Req. Spec. In LTL Overview of the Spin Architecture Spin Model pan.c

More information

Software Model Checking. Xiangyu Zhang

Software Model Checking. Xiangyu Zhang Software Model Checking Xiangyu Zhang Symbolic Software Model Checking CS510 S o f t w a r e E n g i n e e r i n g Symbolic analysis explicitly explores individual paths, encodes and resolves path conditions

More information

CS 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 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 information

The Spin Model Checker : Part I. Moonzoo Kim KAIST

The Spin Model Checker : Part I. Moonzoo Kim KAIST The Spin Model Checker : Part I Moonzoo Kim KAIST Hierarchy of SW Coverage Criteria Complete Value Coverage CVC (SW) Model checking Complete Path Coverage CPC Concolic testing All-DU-Paths Coverage ADUP

More information

[537] Concurrency Bugs. Tyler Harter

[537] Concurrency Bugs. Tyler Harter [537] Concurrency Bugs Tyler Harter Review Semaphores CV s vs. Semaphores CV rules of thumb: - Keep state in addition to CV s - Always do wait/signal with lock held - Whenever you acquire a lock, recheck

More information

CS 153 Lab4 and 5. Kishore Kumar Pusukuri. Kishore Kumar Pusukuri CS 153 Lab4 and 5

CS 153 Lab4 and 5. Kishore Kumar Pusukuri. Kishore Kumar Pusukuri CS 153 Lab4 and 5 CS 153 Lab4 and 5 Kishore Kumar Pusukuri Outline Introduction A thread is a straightforward concept : a single sequential flow of control. In traditional operating systems, each process has an address

More information

CS 261 Fall Mike Lam, Professor. Threads

CS 261 Fall Mike Lam, Professor. Threads CS 261 Fall 2017 Mike Lam, Professor Threads Parallel computing Goal: concurrent or parallel computing Take advantage of multiple hardware units to solve multiple problems simultaneously Motivations: Maintain

More information

CS-537: Midterm Exam (Fall 2013) Professor McFlub: The Solutions Edition

CS-537: Midterm Exam (Fall 2013) Professor McFlub: The Solutions Edition CS-537: Midterm Exam (Fall 2013) Professor McFlub: The Solutions Edition Please Read All Questions Carefully! There are fourteen (14) total numbered pages. Please put your NAME (mandatory) on THIS page,

More information

High Performance Computing Course Notes Shared Memory Parallel Programming

High Performance Computing Course Notes Shared Memory Parallel Programming High Performance Computing Course Notes 2009-2010 2010 Shared Memory Parallel Programming Techniques Multiprocessing User space multithreading Operating system-supported (or kernel) multithreading Distributed

More information

Patrick Trentin Formal Methods Lab Class, Feb 26, 2016

Patrick Trentin  Formal Methods Lab Class, Feb 26, 2016 Spin: Introduction Patrick Trentin patrick.trentin@unitn.it http://disi.unitn.it/~trentin Formal Methods Lab Class, Feb 26, 2016 These slides are derived from those by Stefano Tonetta, Alberto Griggio,

More information

CS 471 Operating Systems. Yue Cheng. George Mason University Fall 2017

CS 471 Operating Systems. Yue Cheng. George Mason University Fall 2017 CS 471 Operating Systems Yue Cheng George Mason University Fall 2017 1 Review: Sync Terminology Worksheet 2 Review: Semaphores 3 Semaphores o Motivation: Avoid busy waiting by blocking a process execution

More information

Having a BLAST with SLAM

Having a BLAST with SLAM Having a BLAST with SLAM # #2 Topic: Software Model Checking via Counter-Example Guided Abstraction Refinement There are easily two dozen SLAM/BLAST/MAGIC papers; I will skim. #3 SLAM Overview INPUT: Program

More information

Pre-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 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 information

HPCSE - I. «Introduction to multithreading» Panos Hadjidoukas

HPCSE - 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 information

Real Time Operating Systems and Middleware

Real 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 information

Synchronization II. Today. ! Condition Variables! Semaphores! Monitors! and some classical problems Next time. ! Deadlocks

Synchronization II. Today. ! Condition Variables! Semaphores! Monitors! and some classical problems Next time. ! Deadlocks Synchronization II Today Condition Variables Semaphores Monitors and some classical problems Next time Deadlocks Condition variables Many times a thread wants to check whether a condition is true before

More information

Operating Systems Structure

Operating Systems Structure Operating Systems Structure Monolithic systems basic structure: A main program that invokes the requested service procedure. A set of service procedures that carry out the system calls. A set of utility

More information

Chapter 2 Processes and Threads

Chapter 2 Processes and Threads MODERN OPERATING SYSTEMS Third Edition ANDREW S. TANENBAUM Chapter 2 Processes and Threads The Process Model Figure 2-1. (a) Multiprogramming of four programs. (b) Conceptual model of four independent,

More information

Introduc)on to pthreads. Shared memory Parallel Programming

Introduc)on to pthreads. Shared memory Parallel Programming Introduc)on to pthreads Shared memory Parallel Programming pthreads Hello world Compute pi pthread func)ons Prac)ce Problem (OpenMP to pthreads) Sum and array Thread-safe Bounded FIFO Queue pthread Hello

More information

4/6/2011. Model Checking. Encoding test specifications. Model Checking. Encoding test specifications. Model Checking CS 4271

4/6/2011. Model Checking. Encoding test specifications. Model Checking. Encoding test specifications. Model Checking CS 4271 Mel Checking LTL Property System Mel Mel Checking CS 4271 Mel Checking OR Abhik Roychoudhury http://www.comp.nus.edu.sg/~abhik Yes No, with Counter-example trace 2 Recap: Mel Checking for mel-based testing

More information

Having a BLAST with SLAM

Having a BLAST with SLAM Having a BLAST with SLAM # #2 Topic: Software Model Checking via Counter-Example Guided Abstraction Refinement There are easily two dozen SLAM/BLAST/MAGIC papers; I will skim. #3 SLAM Overview INPUT: Program

More information

TermComp Proposal: Pushdown Systems as a Model for Programs with Procedures

TermComp Proposal: Pushdown Systems as a Model for Programs with Procedures TermComp Proposal: Pushdown Systems as a Model for Programs with Procedures Marc Brockschmidt Andrey Rybalchenko Microsoft Research June 5, 2014 Abstract A program with procedures can be formally modelled

More information

Patrick Trentin Formal Methods Lab Class, March 03, 2017

Patrick Trentin  Formal Methods Lab Class, March 03, 2017 Spin: Introduction Patrick Trentin patrick.trentin@unitn.it http://disi.unitn.it/trentin Formal Methods Lab Class, March 03, 2017 These slides are derived from those by Stefano Tonetta, Alberto Griggio,

More information

Warm-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? Warm-up question (CS 261 review) What is the primary difference between processes and threads from a developer s perspective? CS 470 Spring 2018 POSIX Mike Lam, Professor Multithreading & Pthreads MIMD

More information

Multicore and Multiprocessor Systems: Part I

Multicore and Multiprocessor Systems: Part I Chapter 3 Multicore and Multiprocessor Systems: Part I Max Planck Institute Magdeburg Jens Saak, Scientific Computing II 44/337 Symmetric Multiprocessing Definition (Symmetric Multiprocessing (SMP)) The

More information

Don t trust other people to get it right! Exploiting a bug in the Xilinx Microkernel s Mutex implementation

Don t trust other people to get it right! Exploiting a bug in the Xilinx Microkernel s Mutex implementation Don t trust other people to get it right! Exploiting a bug in the Xilinx Microkernel s Mutex implementation Bernhard H.C. Sputh PIPRG Meeting on the 29.01.2007 Contents 1 Introduction 2 2 The Xilinx Microkernel

More information

Programming with Shared Memory PART I. HPC Fall 2010 Prof. Robert van Engelen

Programming with Shared Memory PART I. HPC Fall 2010 Prof. Robert van Engelen Programming with Shared Memory PART I HPC Fall 2010 Prof. Robert van Engelen Overview Shared memory machines Programming strategies for shared memory machines Allocating shared data for IPC Processes and

More information

CMSC421: Principles of Operating Systems

CMSC421: Principles of Operating Systems CMSC421: Principles of Operating Systems Nilanjan Banerjee Assistant Professor, University of Maryland Baltimore County nilanb@umbc.edu http://www.csee.umbc.edu/~nilanb/teaching/421/ Principles of Operating

More information

PRINCIPLES OF OPERATING SYSTEMS

PRINCIPLES 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 information

Programming with Shared Memory. Nguyễn Quang Hùng

Programming 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 information

Monitors & Condition Synchronization

Monitors & Condition Synchronization Chapter 5 Monitors & Condition Synchronization controller 1 Monitors & Condition Synchronization Concepts: monitors (and controllers): encapsulated data + access procedures + mutual exclusion + condition

More information

Programming with Threads Dec 7, 2009"

Programming with Threads Dec 7, 2009 Programming with Threads Dec 7, 2009" Administrivia" 2! Shared Variables in Threaded C Programs" 3! Threads Memory Model" 4! Example of Threads Accessing Another Threadʼs Stack" char **ptr; /* global */

More information

Thread Coordination -Managing Concurrency

Thread Coordination -Managing Concurrency Thread Coordination -Managing Concurrency David E. Culler CS162 Operating Systems and Systems Programming Lecture 8 Sept 17, 2014 h

More information

Operating systems fundamentals - B06

Operating systems fundamentals - B06 Operating systems fundamentals - B06 David Kendall Northumbria University David Kendall (Northumbria University) Operating systems fundamentals - B06 1 / 12 Introduction Introduction to threads Reminder

More information

CMSC421: Principles of Operating Systems

CMSC421: Principles of Operating Systems CMSC421: Principles of Operating Systems Nilanjan Banerjee Assistant Professor, University of Maryland Baltimore County nilanb@umbc.edu http://www.csee.umbc.edu/~nilanb/teaching/421/ Principles of Operating

More information

CS-345 Operating Systems. Tutorial 2: Grocer-Client Threads, Shared Memory, Synchronization

CS-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 information

Computer Aided Verification 2015 The SPIN model checker

Computer Aided Verification 2015 The SPIN model checker Computer Aided Verification 2015 The SPIN model checker Grigory Fedyukovich Universita della Svizzera Italiana March 11, 2015 Material borrowed from Roberto Bruttomesso Outline 1 Introduction 2 PROcess

More information

Threads. studykorner.org

Threads. studykorner.org Threads Thread Subpart of a process Basic unit of CPU utilization Smallest set of programmed instructions, can be managed independently by OS No independent existence (process dependent) Light Weight Process

More information

The Spin Model Checker : Part I/II

The Spin Model Checker : Part I/II The Spin Model Checker : Part I/II Moonzoo Kim CS Dept. KAIST Korea Advanced Institute of Science and Technology Motivation: Tragic Accidents Caused by SW Bugs 2 Cost of Software Errors June 2002 Software

More information

Having a BLAST with SLAM

Having a BLAST with SLAM Having a BLAST with SLAM Meeting, CSCI 555, Fall 20 Announcements Homework 0 due Sat Questions? Move Tue office hours to -5pm 2 Software Model Checking via Counterexample Guided Abstraction Refinement

More information

Lecture Outline. CS 5523 Operating Systems: Concurrency and Synchronization. a = 0; b = 0; // Initial state Thread 1. Objectives.

Lecture Outline. CS 5523 Operating Systems: Concurrency and Synchronization. a = 0; b = 0; // Initial state Thread 1. Objectives. CS 5523 Operating Systems: Concurrency and Synchronization Thank Dr. Dakai Zhu and Dr. Palden Lama for providing their slides. Lecture Outline Problems with concurrent access to shared data Ø Race condition

More information

CS 510/13. Predicate Abstraction

CS 510/13. Predicate Abstraction CS 50/3 Predicate Abstraction Predicate Abstraction Extract a finite state model from an infinite state system Used to prove assertions or safety properties Successfully applied for verification of C programs

More information

CSci 4061 Introduction to Operating Systems. Synchronization Basics: Locks

CSci 4061 Introduction to Operating Systems. Synchronization Basics: Locks CSci 4061 Introduction to Operating Systems Synchronization Basics: Locks Synchronization Outline Basics Locks Condition Variables Semaphores Basics Race condition: threads + shared data Outcome (data

More information

POSIX PTHREADS PROGRAMMING

POSIX 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 information

Monitors & Condition Synchronisation

Monitors & Condition Synchronisation Chapter 5 Monitors & Condition Synchronisation controller 1 Monitors & Condition Synchronisation Concepts: monitors (and controllers): encapsulated data + access procedures + mutual exclusion + condition

More information

In class we examined the need for concurrent execution paths like a consumer and a producer to synchronize their access to a shared ring buffer.

In class we examined the need for concurrent execution paths like a consumer and a producer to synchronize their access to a shared ring buffer. In class we examined the need for concurrent execution paths like a consumer and a producer to synchronize their access to a shared ring buffer. Below are a set of global objects which are accessible to

More information

Project 3-2. Mutex & CV

Project 3-2. Mutex & CV SSE3044 Introduction to Operating Systems Prof. Jinkyu Jeong Project 3-2. Mutex & CV 2018.05.30 (Wed.) TAs 이규선 (gyusun.lee@csl.skku.edu) / 안민우 (minwoo.ahn@csl.skku.edu) Project Plan Total 4 projects 1)

More information

CS 3723 Operating Systems: Final Review

CS 3723 Operating Systems: Final Review CS 3723 Operating Systems: Final Review Instructor: Dr. Tongping Liu Lecture Outline High-level synchronization structure: Monitor Pthread mutex Conditional variables Barrier Threading Issues 1 2 Monitors

More information

Verifying Concurrent Programs

Verifying Concurrent Programs Verifying Concurrent Programs Daniel Kroening 8 May 1 June 01 Outline Shared-Variable Concurrency Predicate Abstraction for Concurrent Programs Boolean Programs with Bounded Replication Boolean Programs

More information

CS 3305 Intro to Threads. Lecture 6

CS 3305 Intro to Threads. Lecture 6 CS 3305 Intro to Threads Lecture 6 Introduction Multiple applications run concurrently! This means that there are multiple processes running on a computer Introduction Applications often need to perform

More information

Chap. 6 Part 1. CIS*3090 Fall Fall 2016 CIS*3090 Parallel Programming 1

Chap. 6 Part 1. CIS*3090 Fall Fall 2016 CIS*3090 Parallel Programming 1 Chap. 6 Part 1 CIS*3090 Fall 2016 Fall 2016 CIS*3090 Parallel Programming 1 Chap 6: specific programming techniques Languages and libraries Authors blur the distinction Languages: access parallel programming

More information

Introduction to Embedded Systems

Introduction to Embedded Systems Introduction to Embedded Systems Edward A. Lee & Sanjit Seshia UC Berkeley EECS 124 Spring 2008 Copyright 2008, Edward A. Lee & Sanjit Seshia, All rights reserved Lecture 17: Concurrency 2: Threads Definition

More information

SPIN: Introduction and Examples

SPIN: Introduction and Examples SPIN: Introduction and Examples Alessandra Giordani agiordani@disi.unitn.it http://disi.unitn.it/~agiordani Formal Methods Lab Class, September 28, 2014 *These slides are derived from those by Stefano

More information

i219 Software Design Methodology 11. Software model checking Kazuhiro Ogata (JAIST) Outline of lecture

i219 Software Design Methodology 11. Software model checking Kazuhiro Ogata (JAIST) Outline of lecture i219 Software Design Methodology 11. Software model checking Kazuhiro Ogata (JAIST) Outline of lecture 2 Concurrency Model checking Java Pathfinder (JPF) Detecting race condition Bounded buffer problem

More information

Programming in Parallel COMP755

Programming in Parallel COMP755 Programming in Parallel COMP755 All games have morals; and the game of Snakes and Ladders captures, as no other activity can hope to do, the eternal truth that for every ladder you hope to climb, a snake

More information

Synchronization II. q Condition Variables q Semaphores and monitors q Some classical problems q Next time: Deadlocks

Synchronization II. q Condition Variables q Semaphores and monitors q Some classical problems q Next time: Deadlocks Synchronization II q Condition Variables q Semaphores and monitors q Some classical problems q Next time: Deadlocks Condition variables Locks are not enough to build concurrent programs Many times a thread

More information

Multithreading and Interactive Programs

Multithreading and Interactive Programs Multithreading and Interactive Programs CS160: User Interfaces John Canny. Last time Model-View-Controller Break up a component into Model of the data supporting the App View determining the look of the

More information