DOCSLIB.ORG

HP Decset for Openvms Guide to the Module Management System

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
HP Decset for Openvms Guide to the Module Management System HP DECset for OpenVMS Guide to the Module Management System Order Number: AA–P119J–TE July 2005 This guide describes the Module Management System (MMS) and explains how to get started using its basic features. Revision/Update Information: This is a revised manual. Operating System Version: OpenVMS I64 Version 8.2 OpenVMS Alpha Version 7.3–2 or 8.2 OpenVMS VAX Version 7.3 Windowing System Version: DECwindows Motif for OpenVMS I64 Version 1.5 DECwindows Motif for OpenVMS Alpha Version 1.3–1 or 1.5 DECwindows Motif for OpenVMS VAX Version 1.2–6 Software Version: HP DECset Version 12.7 for OpenVMS Hewlett-Packard Company Palo Alto, California © Copyright 2005 Hewlett-Packard Development Company, L.P. Confidential computer software. Valid license from HP required for possession, use or copying. Consistent with FAR 12.211 and 12.212, Commercial Computer Software, Computer Software Documentation, and Technical Data for Commercial Items are licensed to the U.S. Government under vendor’s standard commercial license. The information contained herein is subject to change without notice. The only warranties for HP products and services are set forth in the express warranty statements accompanying such products and services. Nothing herein should be construed as constituting an additional warranty. HP shall not be liable for technical or editorial errors or omissions contained herein. Intel and Itanium are trademarks or registered trademarks of Intel Corporation or its subsidiaries in the United States and other countries. Java is a US trademark of Sun Microsystems, Inc. Microsoft, Windows, and Windows NT are U.S. registered trademarks of Microsoft Corporation. Printed in the US Contents Preface ..................................................... xi 1 Introduction to MMS 1.1 Overview ........................................... 1–1 1.2 Invoking MMS ....................................... 1–2 1.3 Getting Help ........................................ 1–3 1.4 MMS Concepts ....................................... 1–3 1.4.1 Description Files .................................. 1–3 1.4.2 Targets .......................................... 1–4 1.4.3 Sources .......................................... 1–4 1.4.4 Action Lines . ................................... 1–4 1.4.5 Built-In Rules . ................................... 1–4 1.4.6 Dependencies . ................................... 1–5 1.5 MMS File Processing .................................. 1–6 1.6 MMS User Interface ................................... 1–7 1.6.1 Menu Bar ........................................ 1–8 1.6.1.1 MMS Options Menu . ........................... 1–9 1.6.2 Build Activation Area . ........................... 1–14 1.6.3 MMS Description File Area .......................... 1–16 1.6.4 Build Log Area . ................................... 1–16 1.7 Building Software Systems . ........................... 1–17 1.7.1 Single-Source System ............................... 1–17 1.7.2 Multiple-Source System . ........................... 1–19 1.7.3 Multiple-Language System .......................... 1–20 1.7.4 System with Include Files ........................... 1–22 1.7.5 System with Multiple Targets ........................ 1–24 1.7.6 System with an Object Library ....................... 1–27 1.8 Rebuilding Software Systems . ........................... 1–29 1.8.1 Single-Source System ............................... 1–31 1.8.2 Multiple-Source System . ........................... 1–31 1.8.3 Multiple-Language System .......................... 1–32 1.8.4 System with Include Files ........................... 1–32 iii 1.8.5 System with Multiple Targets ........................ 1–32 1.8.6 System with an Object Library ....................... 1–32 2 MMS Description Files 2.1 Creating the Description File ............................ 2–1 2.1.1 Writing Dependency Rules . ........................ 2–2 2.1.2 Specifying the Target on the Command Line ............. 2–4 2.1.3 Using Mnemonic Names for Targets and Sources . ....... 2–4 2.1.3.1 Specifying Target and Source Files . ................ 2–5 2.1.3.2 Specifying Multiple Targets and Sources ............. 2–6 2.1.3.3 Hierarchy of Dependency-Rule Application ........... 2–7 2.2 Using Built-In Rules . ................................ 2–8 2.2.1 Suffixes Precedence List ............................. 2–10 2.2.2 Default Macros .................................... 2–12 2.3 Defining Your Own Macros ............................. 2–12 2.3.1 Formatting Macro Definitions ........................ 2–14 2.3.2 Order of Processing Macros . ........................ 2–15 2.3.3 Nested Macro Expansion ............................ 2–15 2.3.4 Using Predefined Functions . ........................ 2–16 2.3.4.1 Text Processing Functions ........................ 2–17 2.3.4.2 File Specification Functions ....................... 2–19 2.3.4.3 Macro Functions ............................... 2–20 2.3.5 Invoking Macros . ................................ 2–20 2.3.6 Defining Macros on the Command Line . ................ 2–21 2.3.6.1 Redefining User-Defined Macros . ................ 2–22 2.3.6.2 Redefining Default Macros ........................ 2–22 2.3.7 Redefining Macros in a Description File ................ 2–24 2.4 Using Special Macros . ................................ 2–24 2.5 Defining Your Own Rules ............................... 2–26 2.5.1 Creating a User-Defined Rule ........................ 2–26 2.5.2 Using User-Defined Rules . ........................ 2–28 2.6 Using Action Lines .................................... 2–28 2.6.1 Multiple Action Lines ............................... 2–30 2.6.2 $STATUS and $SEVERITY . ........................ 2–31 2.6.3 MMS$STATUS and MMS$SEVEREST_STATUS . ....... 2–31 2.6.4 Action-Line Prefixes................................ 2–32 2.6.5 Ignore Prefix(-)................................... 2–33 2.6.6 Silent Prefix(@) .................................. 2–33 2.6.7 Action Status Prefix(?)............................. 2–34 2.6.8 Action-Line Restrictions ............................. 2–34 2.7 Using Directives ...................................... 2–35 2.7.1 .ACTION_STATUS Directive . ........................ 2–36 iv 2.7.2 .IGNORE Directive ................................ 2–38 2.7.3 .IGNORE_ALL Directive . ........................... 2–40 2.7.4 .SILENT Directive ................................. 2–40 2.7.5 .DEFAULT Directive ............................... 2–41 2.7.6 .SUFFIXES, .SUFFIXES_AFTER, .SUFFIXES_BEFORE, and .SUFFIXES_DELETE Directives ................... 2–42 2.7.6.1 Adding a New File Extension to the Suffixes List ...... 2–43 2.7.6.2 Using the .SUFFIXES Directive in a Description File . 2–43 2.7.6.3 Building a System with a New File Extension ......... 2–45 2.7.6.4 Using the .SUFFIXES Directive with CMS Files ....... 2–46 2.7.7 .INCLUDE Directive ............................... 2–47 2.7.8 .FIRST Directive .................................. 2–47 2.7.9 .LAST Directive ................................... 2–49 2.7.10 .IF, .IFDEF, .ELSE, .ELSIF, and .ENDIF Directives ....... 2–50 2.8 Generating the MMS Description File Automatically .......... 2–54 2.8.1 Using the DECwindows User Interface ................. 2–54 2.8.1.1 MMS Description File Generator Dialog Box .......... 2–55 2.8.1.2 MMS Sources Dialog Box ......................... 2–57 2.8.2 Using the Automatic Description File Generator .......... 2–60 2.8.2.1 Application Dependencies ........................ 2–60 2.8.2.2 Trigger Summary Dependencies . ................... 2–61 3 Advanced Description File Techniques 3.1 Using Double-Colon Dependencies ........................ 3–1 3.2 Maintaining a Library of Object Files . ................... 3–3 3.3 Invoking MMS from a Description File . ................... 3–3 3.3.1 Using the $(MMS) Reserved Macro . ................... 3–4 3.3.2 Process Quotas for MMS Subprocesses ................. 3–4 3.3.3 Process Quotas for Using MMS ....................... 3–5 3.3.4 MMS Reserved Macros . ........................... 3–5 3.4 Invoking MMS from a Command Procedure ................ 3–7 3.5 Invoking a Command Procedure from a Description File ....... 3–9 3.6 Changing System Build Options ......................... 3–10 3.7 Gathering Statistics ................................... 3–12 3.7.1 Finding Missing Sources . ........................... 3–12 3.7.2 Creating a Checkpoint File .......................... 3–12 3.8 Creating and Using Time Stamps ........................ 3–14 3.8.1 Using DCL Symbols ................................ 3–14 3.8.2 Using Include Files ................................ 3–15 3.9 Deleting Files Selectively ............................... 3–17 3.9.1 Using a Command Procedure ......................... 3–17 3.9.2 Using a Macro Definition . ........................... 3–18 v 3.10 Using Parallel Processing .............................. 3–19 3.11 Using MMS in Complex Examples ........................ 3–20 3.11.1 MMS and Object Libraries . ........................ 3–20 3.11.2 Producing Multiple Outputs with MMS . ................ 3–26 3.11.2.1 Independent Outputs ............................ 3–27 3.11.2.2 Dependent Outputs ............................. 3–27 3.11.3 Multiple Outputs Workaround ........................ 3–29 4 Accessing Libraries and Other Objects 4.1 Creating and Accessing Files in OpenVMS Libraries . ....... 4–1 4.1.1 Formatting Library Module Specifications ............... 4–1 4.1.2 Using Logical Names in a Library Module Specification .... 4–2 4.1.3 Specifying Multiple Modules . ........................ 4–2 4.1.4 Accessing Library Modules
Load more

Recommended publications
  • Linux-Kernel
    linux-kernel #linux- kernel Table of Contents About 1 Chapter 1: Getting started with linux-kernel 2 Remarks 2 Versions 2 Examples 2 Installation or Setup 2 Download extract and enter to the kernel directory 2 Build the dependencies, compile the kernel and modules. 3 Chapter 2: Creation and usage of Kernel Threads 4 Introduction 4 Examples 4 Creation of kernel threads 4 Chapter 3: Event Tracing 6 Examples 6 Tracing I2C Events 6 Chapter 4: Fork System call 7 Examples 7 fork() system call 7 Chapter 5: How to find the right person for help. 9 Introduction 9 Examples 9 Find the "likely" maintainers for the FTDI USB serial converter 9 Chapter 6: Linux Hello World Device driver 10 Examples 10 An empty kernel module 10 Building and running the module 10 Chapter 7: Linux: Named Pipes(FIFO) 12 Examples 12 What is Named Pipe (FIFO) 12 Credits 13 About You can share this PDF with anyone you feel could benefit from it, downloaded the latest version from: linux-kernel It is an unofficial and free linux-kernel ebook created for educational purposes. All the content is extracted from Stack Overflow Documentation, which is written by many hardworking individuals at Stack Overflow. It is neither affiliated with Stack Overflow nor official linux-kernel. The content is released under Creative Commons BY-SA, and the list of contributors to each chapter are provided in the credits section at the end of this book. Images may be copyright of their respective owners unless otherwise specified. All trademarks and registered trademarks are the property of their respective company owners.
    [Show full text]
  • The Big Picture So Far Today: Process Management
    The Big Picture So Far From the Architecture to the OS to the User: Architectural resources, OS management, and User Abstractions. Hardware abstraction Example OS Services User abstraction Processor Process management, Scheduling, Traps, Process protection, accounting, synchronization Memory Management, Protection, virtual memory Address spaces I/O devices Concurrency with CPU, Interrupt Terminal, mouse, printer, handling system calls File System File management, Persistence Files Distributed systems Networking, security, distributed file Remote procedure calls, system network file system System calls Four architectures for designing OS kernels Computer Science CS377: Operating Systems Lecture 4, page 1 Today: Process Management • A process as the unit of execution. • How are processes represented in the OS? • What are possible execution states and how does the system move from one state to another? • How are processes created in the system? • How do processes communicate? Is this efficient? Computer Science CS377: Operating Systems Lecture 4, page 2 What's in a Process? • Process: dynamic execution context of an executing program • Several processes may run the same program, but each is a distinct process with its own state (e.g., MS Word). • A process executes sequentially, one instruction at a time • Process state consists of at least: ! the code for the running program, ! the static data for the running program, ! space for dynamic data (the heap), the heap pointer (HP), ! the Program Counter (PC), indicating the next instruction, ! an execution stack with the program's call chain (the stack), the stack pointer (SP) ! values of CPU registers ! a set of OS resources in use (e.g., open files) ! process execution state (ready, running, etc.).
    [Show full text]
  • 6.087 Practical Programming in C, Lecture 14
    Outline Review Inter process communication Signals Fork Pipes FIFO Spotlights 1 6.087 Lecture 14 – January 29, 2010 Review Inter process communication Signals Fork Pipes FIFO Spotlights 2 Review: multithreading • Race conditions • non-determinism in thread order. • can be prevented by synchronization • atomic operations necessary for synchronization • Mutex: Allows a single thread to own it • Semaphores: Generalization of mutex, allows N threads to acquire it at a time. • P(s) : acquires a lock • V(s) : releases lock • sem_init(),sem_destroy() • sem_wait(),sem_trywait(),sem_post() • Other problems: deadlock, starvation 2 Sockets • <sys/socket.h> • enables client-server computing • Client: connect() • Server: bind(),listen(),accept() • I/O: write(),send(),read(),recv() 3 6.087 Lecture 14 – January 29, 2010 Review Inter process communication Signals Fork Pipes FIFO Spotlights 4 Preliminaries • Each process has its own address space. Therefore, individual processes cannot communicate unlike threads. • Interprocess communication: Linux/Unix provides several ways to allow communications • signal • pipes • FIFO queues • shared memory • semaphores • sockets 4 <signals.h> • Unix/Linux allows us to handle exceptions that arise during execution (e.g., interrupt, floating point error, segmentation fault etc.). • A process recieves a signal when such a condition occurs. void (∗signal(int sig,void(∗handler)(int )))( int ) • determines how subsequent signals will be handled. • pre-defined behavior: SIG_DFL (default), SIG_IGN (ignore) • returns the previous handler. 5 <signal.h> Valid signals: SIGABRT abnormal termination SIGFPE floating point error SIGILL illegal instruction SIGINT interrupt SIGSEGV segmentation fault SIGTERM termination request SIGBUS bus error SIGQUIT quit The two signals SIGSTOP,SIGKILL cannot be handled. 6 <signal.h> int raise( int sig) can be used to send signal sig to the program.
    [Show full text]
  • Lecture 4: September 13 4.1 Process State
    CMPSCI 377 Operating Systems Fall 2012 Lecture 4: September 13 Lecturer: Prashant Shenoy TA: Sean Barker & Demetre Lavigne 4.1 Process State 4.1.1 Process A process is a dynamic instance of a computer program that is being sequentially executed by a computer system that has the ability to run several computer programs concurrently. A computer program itself is just a passive collection of instructions, while a process is the actual execution of those instructions. Several processes may be associated with the same program; for example, opening up several windows of the same program typically means more than one process is being executed. The state of a process consists of - code for the running program (text segment), its static data, its heap and the heap pointer (HP) where dynamic data is kept, program counter (PC), stack and the stack pointer (SP), value of CPU registers, set of OS resources in use (list of open files etc.), and the current process execution state (new, ready, running etc.). Some state may be stored in registers, such as the program counter. 4.1.2 Process Execution States Processes go through various process states which determine how the process is handled by the operating system kernel. The specific implementations of these states vary in different operating systems, and the names of these states are not standardised, but the general high-level functionality is the same. When a process is first started/created, it is in new state. It needs to wait for the process scheduler (of the operating system) to set its status to "new" and load it into main memory from secondary storage device (such as a hard disk or a CD-ROM).
    [Show full text]
  • Pid T Fork(Void); Description: Fork Creates a Child Process That Differs
    pid_t fork(void); Description: fork creates a child process that differs from the parent process only in its PID and PPID, and in the fact that resource utilizations are set to 0. File locks and pending signals are not inherited. Returns: On success, the PID of the child process is returned in the parent's thread of execution, and a 0 is returned in the child's thread of execution. int execve(const char *filename, char *const argv [], char *const envp[]); Description: execve() executes the program pointed to by filename. filename must be either a binary executable, or a script. argv is an array of argument strings passed to the new program. envp is an array of strings, conventionally of the form key=value, which are passed as environment to the new program. Returns: execve() does not return on success, and the text, data, bss, and stack of the calling process are overwritten by that of the program loaded. pid_t wait(int *status); pid_t waitpid(pid_t pid, int *status, int options); Description: The wait function suspends execution of the current process until a child has exited, or until a signal is delivered whose action is to terminate the current process or to call a signal handling function. The waitpid function suspends execution of the current process until a child as specified by the pid argument has exited, or until a signal is delivered whose action is to terminate the current process or to call a signal handling function. If a child has already exited by the time of the call (a so-called \zombie" process), the function returns immediately.
    [Show full text]
  • System Calls & Signals
    CS345 OPERATING SYSTEMS System calls & Signals Panagiotis Papadopoulos [email protected] 1 SYSTEM CALL When a program invokes a system call, it is interrupted and the system switches to Kernel space. The Kernel then saves the process execution context (so that it can resume the program later) and determines what is being requested. The Kernel carefully checks that the request is valid and that the process invoking the system call has enough privilege. For instance some system calls can only be called by a user with superuser privilege (often referred to as root). If everything is good, the Kernel processes the request in Kernel Mode and can access the device drivers in charge of controlling the hardware (e.g. reading a character inputted from the keyboard). The Kernel can read and modify the data of the calling process as it has access to memory in User Space (e.g. it can copy the keyboard character into a buffer that the calling process has access to) When the Kernel is done processing the request, it restores the process execution context that was saved when the system call was invoked, and control returns to the calling program which continues executing. 2 SYSTEM CALLS FORK() 3 THE FORK() SYSTEM CALL (1/2) • A process calling fork()spawns a child process. • The child is almost an identical clone of the parent: • Program Text (segment .text) • Stack (ss) • PCB (eg. registers) • Data (segment .data) #include <sys/types.h> #include <unistd.h> pid_t fork(void); 4 THE FORK() SYSTEM CALL (2/2) • The fork()is one of the those system calls, which is called once, but returns twice! Consider a piece of program • After fork()both the parent and the child are ..
    [Show full text]
  • CS415: Systems Programming
    CS415: Systems Programming Process Related Systems Call (System, Fork, EXEC) Most of the slides in this lecture are either from or adapted from the slides provided by Dr. Ahmad Barghash Creating processes • Method (1) using system • The system function in the standard C library provides an easy way to execute a command from within a program, much as if the command had been typed into a shell. #include <stdlib.h> int main () { int return_value; return_value = system (“ls -l /”); return return_value; } Creating processes • Method (2) using fork and exec • Linux provides one function, fork, that makes a child process that is an exact copy of its parent process • Linux provides another set of functions, the exec family, that causes a particular process to cease being an instance of one program and to instead become an instance of another program • To spawn a new process, you first use fork to make a copy of the current process. Then you use exec to transform one of these processes into an instance of the program you want to spawn int fork(void) • Description: create a child process • Returns: process ID of the new process int fork(void) parent getpid() : 60 fork() getpid() : 60 getppid() : 59 getppid() : 59 fork_pid : 61 parent fork_pid = fork() child fork() getpid() : 61 getppid() : 60 fork_pid : 0 fork() - Example Using fork to duplicate a program’s process #include <stdio.h> #include <sys/types.h> #include <unistd.h> int main () { pid_t child_pid; printf (“the main program process ID is %d\n”, (int) getpid ()); child_pid = fork (); if (child_pid != 0) { printf (“this is the parent process, with id %d\n”, (int) getpid ()); printf (“the child’s process ID is %d\n”, (int) child_pid); } else printf (“this is the child process, with id %d\n”, (int) getpid ()); return 0; } Contd.
    [Show full text]
  • Operating Systems Homework Assignment 2
    Operating Systems Homework Assignment 2 Preparation For this homework assignment, you need to get familiar with a Linux system (Ubuntu, Fedora, CentOS, etc.). There are two options to run Linux on your Desktop (or Laptop) computer: 1. Run a copy of a virtual machine freely available on-line in your own PC environment using Virtual Box. Create your own Linux virtual machine (Linux as a guest operating system) in Windows. You may consider installing MS Windows as a guest OS in Linux host. OS-X can host Linux and/or Windows as guest Operating systems by installing Virtual Box. 2. Or on any hardware system that you can control, you need to install a Linux system (Fedora, CentOS Server, Ubuntu, Ubuntu Server). Tasks to Be Performed • Write the programs listed (questions from Q1 to Q6), run the program examples, and try to answer the questions. Reference for the Assignment Some useful shell commands for process control Command Descriptions & When placed at the end of a command, execute that command in the background. Interrupt and stop the currently running process program. The program remains CTRL + "Z" stopped and waiting in the background for you to resume it. Bring a command in the background to the foreground or resume an interrupted program. fg [%jobnum] If the job number is omitted, the most recently interrupted or background job is put in the foreground. Place an interrupted command into the background. bg [%jobnum] If the job number is omitted, the most recently interrupted job is put in the background. jobs List all background jobs.
    [Show full text]
  • Lecture 22 Systems Programming Process Control
    Lecture 22 Systems Programming Process Control A process is defined as an instance of a program that is currently running. A uni processor system can still execute multiple processes giving the appearance of a multi- processor machine. A call to a program spawns a process. If a mail program is called by n users then n processes or instances are created and executed by the unix system. Many operating systems including windows and unix executes many processes at the same time. When a program is called, a process is created and a process ID is issued. The process ID is given by the function getpid() defined in <unistd.h>. The prototype for pid( ) is given by #include < unistd.h > pid_t getpid(void); In a uni-processor machine, each process takes turns running and for a short duration, a process takes time interval called a timeslice. The unix command ps can be used to list all current process status. ps PID TTY TIME CMD 10150 pts/16 00:00:00 csh 31462 pts/16 00:00:00 ps The command ps lists the process ID (PID), the terminal name(TTY), the amount of time the process has used so far(TIME) and the command it is executing(CMD). Ps command only displays the current user processes. But we can get all the processes with the flag (- a) and in long format with flag (-l) ps –a ps -l ps -al Information provided by each process may include the following. PID The process ID in integer form PPID The parent process ID in integer form STAT The state of the process TIME CPU time used by the process (in seconds) TT Control terminal of the process COMMAND The user command that started the process Copyright @ 2008 Ananda Gunawardena Each process has a process ID that can be obtained using the getpid() a system call declared in unistd.h.
    [Show full text]
  • Processes Computer Science 240 Laboratory 12 Operating System
    Processes Computer Science 240 Laboratory 12 Operating System The set of software that controls the overall operation of a computer system, typically by performing such tasks as memory allocation, job scheduling, and input/output control. Kernel The part of the operating system that runs in privileged or supervisory mode (has access to all instructions and memory in the system). It does all sorts of things like interact with hardware, do file I/O, and spawn off processes. The kernel is the center of the operating system that manages everything. Shell A user interface for access to an operating system's services, which translates user commands to low-level calls to the kernel. Process Instance of a program in execution. A process provides the illusion that the program has exclusive use of the processor and exclusive use of the memory system. In Linux, when you run a program by typing the name of an executable object file to the shell, the shell creates a new process with the help of the kernel. Context A program runs in the context of some process, where the context is the state needed to run correctly. State consists of: • Program’s code and data stored in memory • Stack • Registers • Program Counter • Environment variables • Set of open file descriptors Context Switch The kernel maintains a context for each process. When the kernel preempts the running process with a new process or a previously running process, it is called a context switch: the context of the curent process must be saved, the context of the new process must be asserted, and then control is passed to the preempting process.
    [Show full text]
  • Processes and Threads
    Lecture Notes for CS347: Operating Systems Mythili Vutukuru, Department of Computer Science and Engineering, IIT Bombay 2. Processes and Threads 2.1 Life cycle of a process • Recall that the process is a basic unit of execution in an OS. The main job of any OS is to run processes, while managing their lifecycle from creation to termination. Processes are typically created in Unix-like systems by forking from an existing process. The OS starts the first init process after bootup, and all subsequent processes are descendents of this process. • A process can create a child process using the fork system call. After the fork, the memory image of the child process is a complete copy of the memory image of the parent (the child and parent memory images may diverge subsequently). The fork system call returns in both the parent and child processes, with different return values. In the parent, it returns the pid of the new child process. In the child, it returns 0. Both processes then resume execution from the instruction right after fork, and can be scheduled as independent entities by the CPU scheduler. • A typical use case of fork is to create a child and run the exec system call in the child. The exec system call loads a new executable into the memory image of the process calling it, enabling the child process to do something different from what the parent is already doing. All processes (beyond the first process) are created with this fork+exec combination in Unix-like operating systems. • A simple OS would create a complete copy of the parent’s memory image for the child.
    [Show full text]
  • Operating Systems Processes and Threads
    COS 318: Operating Systems Processes and Threads Prof. Margaret Martonosi Computer Science Department Princeton University http://www.cs.princeton.edu/courses/archive/fall11/cos318 Today’s Topics Processes Concurrency Threads Reminder: Hope you’re all busy implementing your assignment 2 (Traditional) OS Abstractions Processes - thread of control with context Files- In Unix, this is “everything else” Regular file – named, linear stream of data bytes Sockets - endpoints of communication, possible between unrelated processes Pipes - unidirectional I/O stream, can be unnamed Devices Process Most fundamental concept in OS Process: a program in execution one or more threads (units of work) associated system resources Program vs. process program: a passive entity process: an active entity For a program to execute, a process is created for that program Program and Process main() main() { { heap ... ... foo() foo() ... ... } } stack bar() bar() { { registers ... ... PC } } Program Process 5 Process vs. Program Process > program Program is just part of process state Example: many users can run the same program • Each process has its own address space, i.e., even though program has single set of variable names, each process will have different values Process < program A program can invoke more than one process Example: Fork off processes 6 Simplest Process Sequential execution No concurrency inside a process Everything happens sequentially Some coordination may be required Process state Registers Main memory I/O devices • File system • Communication ports … 7 Process Abstraction Unit of scheduling One (or more*) sequential threads of control program counter, register values, call stack Unit of resource allocation address space (code and data), open files sometimes called tasks or jobs Operations on processes: fork (clone-style creation), wait (parent on child), exit (self-termination), signal, kill.
    [Show full text]