Unix™ Systems Programming [Electronic resources] : Communication, Concurrency, and Threads نسخه متنی

اینجــــا یک کتابخانه دیجیتالی است

با بیش از 100000 منبع الکترونیکی رایگان به زبان فارسی ، عربی و انگلیسی

اصطلاحنامه مجموعه ها مرورالفبایی لغت نامه دهخدا

➟

جستجو در لغت نامه

بیشتر

کتابخانه شخصی پرسش از کتابدار ارسال منبع

Unix™ Systems Programming [Electronic resources] : Communication, Concurrency, and Threads - نسخه متنی

Prentice Hall

| ،

افزودن به کتابخانه شخصی

میخواهم بخوانم

درحال خواندن

خوانده شده

ارسال به دوستان

آدرس پست الکترونیک گیرنده :

آدرس پست الکترونیک فرستنده :

نام و نام خانوارگی فرستنده :

پیغام برای گیرنده ( حداکثر 250 حرف ) :

کد امنیتی را وارد نمایید

ارسال

جستجو در متن کتاب

بیشتر

تنظیمات قلم

فونت

اندازه قلم

+ - پیش فرض

حالت نمایش

روز نیمروز شب

➟

جستجو در لغت نامه

بیشتر

لیست موضوعات

Sitemap

Table of content

About the Web Site

Acknowledgments

Part I: Fundamentals

Chapter 1. Technology's Impact on Programs

1.1 Terminology of Change

1.2 Time and Speed

1.3 Multiprogramming and Time Sharing

1.4 Concurrency at the Applications Level

1.5 Security and Fault Tolerance

1.6 Buffer Overflows for Breaking and Entering

1.7 UNIX Standards

1.8 Additional Reading

Chapter 2. Programs, Processes and Threads

2.1 How a Program Becomes a Process

2.2 Threads and Thread of Execution

2.3 Layout of a Program Image

2.4 Library Function Calls

2.5 Function Return Values and Errors

2.6 Argument Arrays

2.7 Thread-Safe Functions

2.8 Use of Static Variables

2.9 Structure of Static Objects

2.10 Process Environment

2.11 Process Termination

2.12 Exercise: An 'env' Utility

2.13 Exercise: Message Logging

2.14 Additional Reading

Chapter 3. Processes in UNIX

3.1 Process Identification

3.2 Process State

3.3 UNIX Process Creation and 'fork'

3.4 The 'wait' Function

3.5 The 'exec' Function

3.6 Background Processes and Daemons

3.7 Critical Sections

3.8 Exercise: Process Chains

3.9 Exercise: Process Fans

3.10 Additional Reading

Chapter 4. UNIX I/O

4.1 Device Terminology

4.2 Reading and Writing

4.3 Opening and Closing Files

4.4 The 'select' Function

4.5 The 'poll' Function

4.6 File Representation

4.7 Filters and Redirection

4.8 File Control

4.9 Exercise: Atomic Logging

4.10 Exercise: A 'cat' Utility

4.11 Additional Reading

Chapter 5. Files and Directories

5.1 UNIX File System Navigation

5.2 Directory Access

5.3 UNIX File System Implementation

5.4 Hard Links and Symbolic Links

5.5 Exercise: The 'which' Command

5.6 Exercise: Biffing

5.7 Exercise: News 'biff'

5.8 Exercise: Traversing Directories

5.9 Additional Reading

Chapter 6. UNIX Special Files

6.4 Pipes and the Client-Server Model

6.5 Terminal Control

6.6 Audio Device

6.7 Exercise: Audio

6.8 Exercise: Barriers

6.9 Exercise: The 'stty' Command

6.10 Exercise: Client-Server Revisited

6.11 Additional Reading

Chapter 7. Project: The Token Ring

7.1 Ring Topology

7.2 Ring Formation

7.3 Ring Exploration

7.4 Simple Communication

7.5 Mutual Exclusion with Tokens

7.6 Mutual Exclusion by Voting

7.7 Leader Election on an Anonymous Ring

7.8 Token Ring for Communication

7.9 Pipelined Preprocessor

7.10 Parallel Ring Algorithms

7.11 Flexible Ring

7.12 Additional Reading

Part II: Asynchronous Events

Chapter 8. Signals

8.1 Basic Signal Concepts

8.2 Generating Signals

8.3 Manipulating Signal Masks and Signal Sets

8.4 Catching and Ignoring Signals'sigaction'

8.5 Waiting for Signals'pause', 'sigsuspend' and 'sigwait'

8.6 Handling Signals: Errors and Async-signal Safety

8.7 Program Control with 'siglongjmp' and 'sigsetjmp'

8.8 Programming with Asynchronous I/O

8.9 Exercise: Dumping Statistics

8.10 Exercise: Spooling a Slow Device

8.11 Additional Reading

Chapter 9. Times and Timers

9.1 POSIX Times

9.2 Sleep Functions

9.3 POSIX:XSI Interval Timers

9.4 Realtime Signals

9.5 POSIX:TMR Interval Timers

9.6 Timer Drift, Overruns and Absolute Time

9.7 Additional Reading

Chapter 10. Project: Virtual Timers

10.1 Project Overview

10.2 Simple Timers

10.3 Setting One of Five Single Timers

10.4 Using Multiple Timers

10.5 A Robust Implementation of Multiple Timers

10.6 POSIX:TMR Timer Implementation

10.7 'mycron', a Small Cron Facility

10.8 Additional Reading

Chapter 11. Project: Cracking Shells

11.1 Building a Simple Shell

11.2 Redirection

11.4 Signal Handling in the Foreground

11.5 Process Groups, Sessions and Controlling Terminals

11.6 Background Processes in 'ush'

11.7 Job Control

11.8 Job Control for 'ush'

11.9 Additional Reading

Part III: Concurrency

Chapter 12. POSIX Threads

12.1 A Motivating Problem: Monitoring File Descriptors

12.2 Use of Threads to Monitor Multiple File Descriptors

12.3 Thread Management

12.4 Thread Safety

12.5 User Threads versus Kernel Threads

12.6 Thread Attributes

12.7 Exercise: Parallel File Copy

12.8 Additional Reading

Chapter 13. Thread Synchronization

13.1 POSIX Synchronization Functions

13.2 Mutex Locks

13.3 At-Most-Once and At-Least-Once-Execution

13.4 Condition Variables

13.5 Signal Handling and Threads

13.6 Readers and Writers

13.7 A 'strerror_r' Implementation

13.8 Deadlocks and Other Pesky Problems

13.9 Exercise: Multiple Barriers

13.10 Additional Reading

Chapter 14. Critical Sections and Semaphores

14.1 Dealing with Critical Sections

14.2 Semaphores

14.3 POSIX:SEM Unnamed Semaphores

14.4 POSIX:SEM Semaphore Operations

14.5 POSIX:SEM Named Semaphores

14.6 Exercise: License Manager

14.7 Additional Reading

Chapter 15. POSIX IPC

15.1 POSIX:XSI Interprocess Communication

15.2 POSIX:XSI Semaphore Sets

15.3 POSIX:XSI Shared Memory

15.4 POSIX:XSI Message Queues

15.5 Exercise: POSIX Unnamed Semaphores

15.6 Exercise: POSIX Named Semaphores

15.7 Exercise: Implementing Pipes with Shared Memory

15.8 Exercise: Implementing Pipes with Message Queues

15.9 Additional Reading

Chapter 16. Project: Producer Consumer Synchronization

16.1 The Producer-Consumer Problem

16.2 Bounded Buffer Protected by Mutex Locks

16.3 Buffer Implementation with Semaphores

16.4 Introduction to a Simple Producer-Consumer Problem

16.5 Bounded Buffer Implementation Using Condition Variables

16.6 Buffers with Done Conditions

16.7 Parallel File Copy

16.8 Threaded Print Server

16.9 Additional Reading

Chapter 17. Project: The Not Too Parallel Virtual Machine

17.1 PVM History, Terminology, and Architecture

17.2 The Not Too Parallel Virtual Machine

17.3 NTPVM Project Overview

17.4 I/O and Testing of Dispatcher

17.5 Single Task with No Input

17.6 Sequential Tasks

17.7 Concurrent Tasks

17.8 Packet Communication, Broadcast and Barriers

17.9 Termination and Signals

17.10 Ordered Message Delivery

17.11 Additional Reading

Part IV: Communication

Chapter 18. Connection-Oriented Communication

18.1 The Client-Server Model

18.2 Communication Channels

18.3 Connection-Oriented Server Strategies

18.4 Universal Internet Communication Interface (UICI)

18.5 UICI Implementations of Different Server Strategies

18.6 UICI Clients

18.7 Socket Implementation of UICI

18.8 Host Names and IP Addresses

18.9 Thread-Safe UICI

18.10 Exercise: Ping Server

18.11 Exercise: Transmission of Audio

18.12 Additional Reading

Chapter 19. Project: WWW Redirection

19.1 The World Wide Web

19.2 Uniform Resource Locators (URLs)

19.3 HTTP Primer

19.4 Web Communication Patterns

19.5 Pass-through Monitoring of Single Connections

19.6 Tunnel Server Implementation

19.7 Server Driver for Testing

19.8 HTTP Header Parsing

19.9 Simple Proxy Server

19.10 Proxy Monitor

19.11 Proxy Cache

19.12 Gateways as Portals

19.13 Gateway for Load Balancing

19.14 Postmortem

19.15 Additional Reading

Chapter 20. Connectionless Communication and Multicast

20.1 Introduction to Connectionless Communication

20.2 Simplified Interface for Connectionless Communication

20.3 Simple-Request Protocols

20.4 Request-Reply Protocols

20.5 Request-Reply with Timeouts and Retries

20.6 Request-Reply-Acknowledge Protocols

20.7 Implementation of UICI UDP

20.8 Comparison of UDP and TCP

20.10 Exercise: UDP Port Server

20.11 Exercise: Stateless File Server

20.12 Additional Reading

Chapter 21. Project: Internet Radio

21.1 Project Overview

21.2 Audio Device Simulation

21.3 UDP Implementation with One Program and One Receiver

21.4 UDP Implementation with Multiple Programs and Receivers

21.5 UDP Implementation of Radio Broadcasts

21.6 Multicast Implementation of Radio Broadcasts

21.7 TCP Implementation Differences

21.8 Receiving Streaming Audio Through a Browser

21.9 Additional Reading

Chapter 22. Project: Server Performance

22.1 Server Performance Costs

22.2 Server Architectures

22.3 Project Overview

22.4 Single-Client Driver

22.5 Multiple-Client Driver

22.6 Thread-per-request and Process-per-request Implementations

22.7 Thread-worker-pool Strategy

22.8 Thread-worker Pool with Bounded Buffer

22.9 Process-worker Pool

22.10 Influence of Disk I/O

22.11 Performance Studies

22.12 Report Writing

22.13 Additional Reading

Appendix A. UNIX Fundamentals

A.1 Manual Pages

A.2 Compilation

A.4 Debugging Aids

A.5 Identifiers, Storage Classes and Linkage Classes

A.6 Additional Reading

Appendix B. Restart Library

Appendix C. UICI Implementation

C.1 Connection-Oriented UICI TCP Implementation

C.2 Name Resolution Implementations

C.3 Connectionless UICI UDP Implementation

Appendix D. Logging Functions

D.1 Local Atomic Logging

D.2 Remote Logging

Appendix E. POSIX Extensions

توضیحات

افزودن یادداشت جدید

13.9 Exercise: Multiple Barriers

Reimplement the barrier of Program 13.13 so that it supports multiple barriers. One possible approach is to use an array or a linked list of barriers. Explore different designs with respect to synchronization. Is it better to use a single bmutex lock and bcond condition variable to synchronize all the barriers, or should each barrier get its own synchronization? Why?