Unix%20Pipes

1
Unix Pipes

• Pipe sets up communication channel between two
  (related) processes.

Two processes connected by a pipe
37
2

• One process writes to the pipe, the other reads
  from the pipe.
• Looks exactly the same as reading from/to a file.
  
• System call
• int fd2
• pipe(fd0)
• fd0 now holds descriptor to read from pipe
• fd1 now holds descriptor to write into pipe

3
Simple Example

• include ltunistd.hgt / for Solaris /
• include ltfcntl.hgt
• include ltstdio.hgt
• char message "This is a message!!!"
• main()
• char buf1024
• int fd2
• pipe(fd) /create pipe/
• if (fork() ! 0) / I am the parent /
• write(fd1, message, strlen (message)
  1)
• else /Child code /
• read(fd0, buf, 1024)
• printf("Got this from MaMa!! s\n", buf)
  

4
Create a Pipeline

• Sometimes useful to connect a set of processes in
  a pipeline.

Process
Process
Pipe
Pipe
c
D
Process A writes to pipe AB, Process B reads from
AB and writes to BC Process C reads from BC and
writes to CD ..
5
Inherited File Descriptors

• Process created with three files stdin, stdout,
  and stderr (file descriptors 0, 1, 2).
• write(1, EEEE, 10) // goes to stdout
  (terminal) or printf
• read(0, buf, 4) //read from terminal

6
Redirecting stdin and stdout

• Can due on command line
• ./a.out gt tmp // write output to tmp rather than
  terminal.
• ./a.out lt foo // read from foo not terminal.
• When processing in a pipeline useful to redirect
  stdout of pipe n to stdin of pipe n1.
• Key When Unix allocates file descriptor, it
  always chooses the lowest available.
• If close stdin and open new file, e.g., close(0),
  fd open(foo, .) then fd 0 and all
  subsequent reads from stdin will read instead
  from foo.

7
main() int fd printf("this goes to
stdout\n") close(1) / close stdout / fd
open("foo",O_CREAT O_WRONLY) / fd 1!
/ printf("fd d\n", fd) //goes to file
"foo" printf("Should not see this either!\n")
//ditto
8
Dup System Call

• int dupfd dup(fd)
• Duplicates a file descriptor -- aliased
• Both point to same file, that being the argument
  to dup.
• Reads/writes from fd and dupfd going to the same
  file.
• Useful for situation such as
• want to write some output to standard out, then
  to a file, then back to standard out -- all using
  printf.
• Redirecting I/O for pipeline.

9
pipeline (process1, process2) / program names
/ char process1, process2 char buf1024
int fd2 pipe(fd0) /create
pipe/ if (fork() ! 0) / parent /
close(fd0) //don't need.
close(STD_OUTPUT)
dup(fd1) / sets stdout to this pipe end
/ close(fd1) //dont need. Already set
stdout to pipe. execl(process2,process2,0)

10
else / child /
close(fd1) close(STD_INPUT)
dup(fd0) / replace stdin
/ close(fd0)
execl(process1,process1,0)
11
fork()
exec
exec
stdout
stdin
12
Single and Multithreaded Processes
13
Benefits

• Responsiveness Separate thread to handle user
  input.
• Web server spawns separate thread to handle
  incoming request.
• Resource Sharing e.g., one code, data segment.
• Economy Much cheaper to create and switch than
  processes.
• Utilization of MP Architectures Assign each
  thread to a separate processor if available.

14

• Lightweight process.
• Threads share all process resources.
• State
• Thread ID, program counter, register set, and
  stack.
• User-level threads and kernel-level threads.

15
User Threads

• Thread management done by user-level threads
  library.
• Advantages
• Very fast Does not involve kernel in creation,
  scheduling, or switching.
• Disadvantages
• When a thread blocks, whole process blocks.

16
Kernel Threads

• Supported by the Kernel.
• Kernel creates, schedules, and switches threads.
• Advantage
• When one thread blocks, the whole process does
  not have to block.
• Thus can overlap I/O and computation.
• Disadvantage
• Slower since kernel is involved.

17
Multithreading Models

• Many-to-One
• One-to-One
• Many-to-Many

18
Many-to-One

• Many user-level threads mapped to single kernel
  thread.
• Used on systems that do not support kernel
  threads.

19
Many-to-One Model
20
One-to-One

• Each user-level thread maps to kernel thread.
• Examples
• - Windows 95/98/NT/2000
• - OS/2

21
One-to-one Model
22
Many-to-Many Model

• Allows many user level threads to be mapped to
  many kernel threads.
• Allows the operating system to create a
  sufficient number of kernel threads.
• Solaris 2
• Windows NT/2000 with the ThreadFiber package

23
Many-to-Many Model
24
Threading Issues

• Semantics of fork() and exec() system calls.
• Thread cancellation.

25
Pthreads

• a POSIX standard (IEEE 1003.1c) API for thread
  creation and synchronization.
• API specifies behavior of the thread library,
  implementation is up to development of the
  library.
• Common in UNIX operating systems.

26
Solaris 2 Threads
27
Solaris Process
28
Windows 2000 Threads

• Implements the one-to-one mapping.
• Each thread contains
• - a thread id
• - register set
• - separate user and kernel stacks
• - private data storage area