University of Kansas Electrical Engineering Computer Science Jerry James and Douglas Niehaus Information and Telecommunication Technology Center Electrical.

Slides:



Advertisements
Similar presentations
Construction process lasts until coding and testing is completed consists of design and implementation reasons for this phase –analysis model is not sufficiently.
Advertisements

Identifying, Modifying, Creating, and Removing Monitor Rules for SOC Ricardo Contreras Andrea Zisman
A Brief Introduction. Acknowledgements  The material in this tutorial is based in part on: Concurrency: State Models & Java Programming, by Jeff Magee.
Chapter 4 Threads, SMP, and Microkernels Patricia Roy Manatee Community College, Venice, FL ©2008, Prentice Hall Operating Systems: Internals and Design.
SKELETON BASED PERFORMANCE PREDICTION ON SHARED NETWORKS Sukhdeep Sodhi Microsoft Corp Jaspal Subhlok University of Houston.
Introduction to LabVIEW 8.5
Object-Oriented Design & Programming Fawzi Emad Chau-Wen Tseng Department of Computer Science University of Maryland, College Park.
L4-1-S1 UML Overview © M.E. Fayad SJSU -- CmpE Software Architectures Dr. M.E. Fayad, Professor Computer Engineering Department, Room #283I.
CS 290C: Formal Models for Web Software Lecture 10: Language Based Modeling and Analysis of Navigation Errors Instructor: Tevfik Bultan.
1: Operating Systems Overview
I/O Hardware n Incredible variety of I/O devices n Common concepts: – Port – connection point to the computer – Bus (daisy chain or shared direct access)
University of Kansas Construction & Integration of Distributed Systems Jerry James Oct. 30, 2000.
1 CMSC 132: Object-Oriented Programming II Software Development IV Department of Computer Science University of Maryland, College Park.
February 21, 2008 Center for Hybrid and Embedded Software Systems Mapping A Timed Functional Specification to a Precision.
 2004 Deitel & Associates, Inc. All rights reserved. Chapter 4 – Thread Concepts Outline 4.1 Introduction 4.2Definition of Thread 4.3Motivation for Threads.
Bellevue University CIS 205: Introduction to Programming Using C++ Lecture 1: Getting Started by George Lamperti & BU Faculty.
4.7.1 Thread Signal Delivery Two types of signals –Synchronous: Occur as a direct result of program execution Should be delivered to currently executing.
1.2 Language Processing Activities The fundamental language processing activities divided into two parts. 1. Program generation activities 2. Program execution.
1.3 Executing Programs. How is Computer Code Transformed into an Executable? Interpreters Compilers Hybrid systems.
Processes Part I Processes & Threads* *Referred to slides by Dr. Sanjeev Setia at George Mason University Chapter 3.
What is Concurrent Programming? Maram Bani Younes.
© Janice Regan, CMPT 128, Jan CMPT 128 Introduction to Computing Science for Engineering Students Creating a program.
Concurrency Programming Chapter 2. The Role of Abstraction Scientific descriptions of the world are based on abstractions. A living animal is a system.
Engineering Law-Governed Approaches How to reuse, extend and compose interaction specifications Gustavo Carvalho, Carlos Lucena
ICOM 5995: Performance Instrumentation and Visualization for High Performance Computer Systems Lecture 7 October 16, 2002 Nayda G. Santiago.
Threads, Thread management & Resource Management.
COP 4620 / 5625 Programming Language Translation / Compiler Writing Fall 2003 Lecture 10, 10/30/2003 Prof. Roy Levow.
Operating Systems Lecture 2 Processes and Threads Adapted from Operating Systems Lecture Notes, Copyright 1997 Martin C. Rinard. Zhiqing Liu School of.
Basic Concepts Software Architecture. What is Software Architecture? Definition: – A software architecture is the set of principal design decisions about.
Model-Driven Analysis Frameworks for Embedded Systems George Edwards USC Center for Systems and Software Engineering
Lecture 2 Foundations and Definitions Processes/Threads.
 2004 Deitel & Associates, Inc. All rights reserved. 1 Chapter 4 – Thread Concepts Outline 4.1 Introduction 4.2Definition of Thread 4.3Motivation for.
Software Development Cycle What is Software? Instructions (computer programs) that when executed provide desired function and performance Data structures.
IPDPS 2005, slide 1 Automatic Construction and Evaluation of “Performance Skeletons” ( Predicting Performance in an Unpredictable World ) Sukhdeep Sodhi.
Unit-1 Introduction Prepared by: Prof. Harish I Rathod
Introduction to LabVIEW 8.5
The Cosmic Cube Charles L. Seitz Presented By: Jason D. Robey 2 APR 03.
1 The BUMP model of response planning: Intermittent predictive control accounts for 10 Hz physiological tremor Robin T. Bye* and Peter D. Neilson Neuroengineering.
Chapter 2 Processes and Threads Introduction 2.2 Processes A Process is the execution of a Program More specifically… – A process is a program.
Debugging parallel programs. Breakpoint debugging Probably the most widely familiar method of debugging programs is breakpoint debugging. In this method,
1 Threads, SMP, and Microkernels Chapter Multithreading Operating system supports multiple threads of execution within a single process MS-DOS.
Celluloid An interactive media sequencing language.
Software Engineering Laboratory, Department of Computer Science, Graduate School of Information Science and Technology, Osaka University IWPSE 2003 Program.
Allen D. Malony Department of Computer and Information Science TAU Performance Research Laboratory University of Oregon Discussion:
CISC Machine Learning for Solving Systems Problems Presented by: Suman Chander B Dept of Computer & Information Sciences University of Delaware Automatic.
CSCI 444 / CIS 644 Event Driven Programming. Outline I.What is an event driven system? II.What is event driven programming? III.Course Overview.
Debugging TI RTOS TEAM 4 JORGE JIMENEZ JHONY MEDRANO ALBIEN FEZGA.
Review of Parnas’ Criteria for Decomposing Systems into Modules Zheng Wang, Yuan Zhang Michigan State University 04/19/2002.
Threads-Process Interaction. CONTENTS  Threads  Process interaction.
Source Level Debugging of Parallel Programs Roland Wismüller LRR-TUM, TU München Germany.
CS223: Software Engineering
 Simulation enables the study of complex system.  Simulation is a good approach when analytic study of a system is not possible or very complex.  Informational,
Agenda  Quick Review  Finish Introduction  Java Threads.
© 2009 Artisan Software Tools. All rights reserved. Testing Solutions with UML/SysML Andrew Stuart, Matthew Hause.
Advanced Operating Systems CS6025 Spring 2016 Processes and Threads (Chapter 2)
Chapter Goals Describe the application development process and the role of methodologies, models, and tools Compare and contrast programming language generations.
Chapter 4 – Thread Concepts
Introduction to Operating Systems
SOFTWARE DESIGN AND ARCHITECTURE
Chapter 4 – Thread Concepts
Model-Driven Analysis Frameworks for Embedded Systems
Introduction to Operating Systems
What is Concurrent Programming?
What is Concurrent Programming?
Concurrency: Mutual Exclusion and Process Synchronization
What is Concurrent Programming?
Foundations and Definitions
Dynamic Binary Translators and Instrumenters
Presentation transcript:

University of Kansas Electrical Engineering Computer Science Jerry James and Douglas Niehaus Information and Telecommunication Technology Center Electrical Engineering and Computer Science Department University of Kansas A Method for Providing Complete Access to the Concurrent Programming Model

University of Kansas Electrical Engineering Computer Science Overview Problem Irreproducible Concurrent Behavior Background Definitions and Terms Solution Programming Environment Enhancements –Record and Control Implementation Conclusions

University of Kansas Electrical Engineering Computer Science Problem Concurrent software is important to many people Wide range of applications and contexts None of it is subject to scientifically valid experimentation Irreproducible behavior based on concurrency control Programming model does not constrain interleaving of concurrent components Concurrency control errors are often intermittent Happen in a few of all possible component interleavings Problematic target for model driven programming

University of Kansas Electrical Engineering Computer Science Background Multi-threading is one common form of concurrency Distribution is another Thread events include: Instruction execution (Basic Blocks) Context Switch, Signals, Read/Write, System Calls History of a thread is the set of events it experiences History of a computation is the interleaving of the thread histories Complete event history would be reproducible because it would include every relevant event Everything affecting thread behavior and interleaving

University of Kansas Electrical Engineering Computer Science Solution Record Computation Event History All important computation events Interleaving of computation thread histories Message arrival for distributed computations Programming environment support for executing/reproducing a specified history Recorded, or Synthesized BERT: implementation pattern enabling recording and control of all important computation events Multi-threaded and distributed Add reproducibility property to programming model

University of Kansas Electrical Engineering Computer Science Recording an Event History Thread Events Gathered by adaptation of GCC code profiling CPU Instruction Execution is basic thread event Entry to each Basic Block is an equivalent shorthand Basic block is a linear sequence of machine instructions –Entered at a label, Terminated by a jump (mostly) Thread interactions with environment Signals Read/Write System Calls

University of Kansas Electrical Engineering Computer Science Recording an Event History A Thread event history is the sequence of events it experiences during execution Context switches are not events but note where the computation switches from one thread to another A Computation event history is the concatenated segments of the histories of its component threads punctuated by context switches Distributed computations also track message delivery

University of Kansas Electrical Engineering Computer Science History Completeness A history is complete when it contains everything required to reproduce computation behavior Behaviors contained in “everything” depend on the semantics of the application computation Complete set Instruction execution (Basic Block) Context Switch Signals Read/Write (including messages) System calls

University of Kansas Electrical Engineering Computer Science Reproduce an Event History Clever Insight completes the reproduction environment Adds ability to attach a TCL/GDB script to a breakpoint Breakpoints at signal and context switch locations Clever Insight uses specified history and that produced by executing program to identify proper breakpoint context Requires the ability, from the programming environment, to context switch and deliver signals on demand Implemented with breakpoint scripts that take the required action and set the next breakpoint in the history

University of Kansas Electrical Engineering Computer Science Synthesize an Event History Test interesting concurrency scenarios Model generated would be great Not all history specifications correspond to possible scenarios Use Clever Insight to guide execution and thus construct a desired event history Specify the next context switch or signal point Clever Insight sets a breakpoint Compares predicted behavior to actual behavior

University of Kansas Electrical Engineering Computer Science BThreads: Reproducible Environment Compiler modifications for history recording BThreads is a user-level library implementing the POSIX multi-thread standard Provides both recording and control hooks Encapsulates system calls of interest Currently limited to CPU-bound computations Modified debugger (Clever Insight) for following recorded or synthesized event histories Well behaved target for abstract modeling of concurrent implementations of applications

University of Kansas Electrical Engineering Computer Science Conclusion This addresses a long-neglected concurrent programming need Our approach gives control over concurrency, which is necessary for the reproducibility property We have constructed a multithreaded example Another example exists for concurrency arising from distribution, based on single-machine simulation of the distributed environment KU-PNNI simulator

University of Kansas Electrical Engineering Computer Science Future Work Extension to include I/O Read/Write of files, and reproduction of byte streams Capture system call information transfer to computation Message histories for distributed computations Explicit Modeling support Execute synthesized event histories Instrument model specified data sets Post processing comparison of predicted and produced event histories Suggestions from modelers ??