pthread_rwlock_unlock()
by Tracey Hughes, Cameron Hughes
Professional Multicore Programming: Design and Implementation for C++ Developers
- Copyright
- About the Authors
- Credits
- Acknowledgments
- Introduction
- 1. The New Architecture
- 2. Four Effective Multicore Designs
- 2.1. The AMD Multicore Opteron
- 2.2. The Sun UltraSparc T1 Multiprocessor
- 2.3. The IBM Cell Broadband Engine
- 2.4. Intel Core 2 Duo Processor
- 2.5. Summary
- 3. The Challenges of Multicore Programming
- 3.1. What Is the Sequential Model?
- 3.2. What Is Concurrency?
- 3.3. Software Development
- 3.3.1. Challenge #1: Software Decomposition
- 3.3.2. Challenge #2: Task-to-Task Communication
- 3.3.3. Challenge #3: Concurrent Access to Data or Resources by Multiple Tasks or Agents
- 3.3.4. Challenge #4: Identifying the Relationships between Concurrently Executing Tasks
- 3.3.5. Challenge #5: Controlling Resource Contention Between Tasks
- 3.3.6. Challenge #6: How Many Processes or Threads Are Enough?
- 3.3.7. Challenges #7 and #8: Finding Reliable and Reproducible Debugging and Testing
- 3.3.8. Challenge #9: Communicating a Design That Has Multiprocessing Components
- 3.3.9. Challenge #10: Implementing Multiprocessing and Multithreading in C++
- 3.4. C++ Developers Have to Learn New Libraries
- 3.5. Processor Architecture Challenges
- 3.6. Summary
- 4. The Operating System's Role
- 4.1. What Part Does the Operating System Play?
- 4.1.1. Providing a Consistent Interface
- 4.1.2. Managing Hardware Resources and Other Software Applications
- 4.1.3. The Developer's Interaction with the Operating System
- 4.1.4. Core Operating System Services
- 4.1.5. The Application Programmer's Interface
- 4.2. Decomposition and the Operating System's Role
- 4.3. Hiding the Operating System's Role
- 4.4. Summary
- 4.1. What Part Does the Operating System Play?
- 5. Processes, C++ Interface Classes, and Predicates
- 5.1. We Say Multicore, We Mean Multiprocessor
- 5.2. What Is a Process?
- 5.3. Why Processes and Not Threads?
- 5.4. Using posix_spawn()
- 5.5. Who Is the Parent? Who Is the Child?
- 5.6. Processes: A Closer Look
- 5.7. Monitoring Processes with the ps Utility
- 5.8. Setting and Getting Process Priorities
- 5.9. What Is a Context Switch?
- 5.10. The Activities in Process Creation
- 5.11. Working with Process Environment Variables
- 5.12. Using system() to Spawn Processes
- 5.13. Killing a Process
- 5.14. Process Resources
- 5.15. What Are Asynchronous and Synchronous Processes
- 5.16. The wait() Function Call
- 5.17. Predicates, Processes, and Interface Classes
- 5.18. Summary
- 6. Multithreading
- 6.1. What Is a Thread?
- 6.2. Comparing Threads to Processes
- 6.3. Setting Thread Attributes
- 6.4. The Architecture of a Thread
- 6.5. A Simple Threaded Program
- 6.6. Creating Threads
- 6.7. Managing Threads
- 6.8. Extending the Thread Interface Class
- 6.9. Summary
- 7. Communication and Synchronization of Concurrent Tasks
- 7.1. Communication and Synchronization
- 7.1.1. Dependency Relationships
- 7.1.2. Counting Tasks Dependencies
- 7.1.3. What Is Interprocess Communication?
- 7.1.4. What Are Interthread Communications?
- 7.2. Synchronizing Concurrency
- 7.2.1. Types of Synchronization
- 7.2.2. Synchronizing Access to Data
- 7.2.2.1. Critical Sections
- 7.2.2.2. PRAM Model
- 7.2.2.2.1. Concurrent and Exclusive Memory Access
- 7.2.2.2.2. Concurrent Tasks: Coordinating Order of Execution
- 7.2.2.2.3. Relationships between Cooperating Tasks
- 7.2.2.2.4. Start-to-Start (SS) Relationship
- 7.2.2.2.5. Finish-to-Start (FS) Relationship
- 7.2.2.2.6. Start-to-Finish Relationship
- 7.2.2.2.7. Finish-to-Finish Relationship
- 7.2.3. Synchronization Mechanisms
- 7.2.3.1. Semaphores
- 7.2.3.2. Program Profile 7-4
- 7.2.3.2.1. Program Name:
- 7.2.3.2.2. Description:
- 7.2.3.2.3. Libraries Required:
- 7.2.3.2.4. Headers Required:
- 7.2.3.2.5. Compile and Link Instructions:
- 7.2.3.2.6. Test Environment:
- 7.2.3.2.7. Processors:
- 7.2.3.2.8. Execution Instructions:
- 7.2.3.2.9. Notes:
- 7.2.3.2.10. Mutex Semaphores
- 7.2.3.2.11. Using the Mutex Attribute Object
- 7.2.3.2.12. Using Mutex Semaphores to Manage Critical Sections
- 7.2.3.3. Read-Write Locks
- 7.2.3.4. Program Profile 7-5
- 7.2.3.5. Condition Variables
- 7.2.3.6. Program Profile 7-6
- 7.2.3.7. Thread-Safe Data Structures
- 7.3. Thread Strategy Approaches
- 7.4. Decomposition and Encapsulation of Work
- 7.5. Summary
- 7.1. Communication and Synchronization
- 8. PADL and PBS: Approaches to Application Design
- 8.1. Designing Applications for Massive Multicore Processors
- 8.2. What Is PADL?
- 8.2.1. Layer 5: Application Architecture Selection
- 8.2.1.1. What Are Agents?
- 8.2.1.2. What Is a Multiagent Architecture?
- 8.2.1.3. From Problem Statements to Multiagent Architectures
- 8.2.1.4. Blackboard Architectures
- 8.2.1.5. Approaches to Structuring the Blackboard
- 8.2.1.5.1. A "Question and Answer Browser" Blackboard Example
- 8.2.1.5.2. Where's the Parallelism? Where's the Blackboard?
- 8.2.1.5.3. Components of the Solution
- 8.2.1.5.4. Knowledge Sources for the Browser Program
- 8.2.1.5.5. Is a Blackboard a Good Fit?
- 8.2.1.5.6. The Blackboard as an Iterative Shared Solution Space
- 8.2.1.6. The Anatomy of a Knowledge Source
- 8.2.1.7. Concurrency Flexibility of the Application Architecture
- 8.2.2. Layer 4: Concurrency Models in PADL
- 8.2.3. Layer 3: The Implementation Model of PADL
- 8.2.3.1. C++ Components to the Rescue
- 8.2.3.2. The Intel Threading Building Blocks
- 8.2.3.3. Program Profile 8-1
- 8.2.3.3.1. Program Name:
- 8.2.3.3.2. Description:
- 8.2.3.3.3. Libraries Required:
- 8.2.3.3.4. Additional Source Files Needed:
- 8.2.3.3.5. User-Defined Headers Required:
- 8.2.3.3.6. Compile and Link Instructions:
- 8.2.3.3.7. Test Environment:
- 8.2.3.3.8. Processors:
- 8.2.3.3.9. Notes:
- 8.2.3.3.10. Obtaining the TBB library
- 8.2.3.4. The Parallel STL Library
- 8.2.3.5. The "Implementation Layer" Mapping
- 8.2.3.6. PADL: Layer 3 Type Control Strategies
- 8.2.1. Layer 5: Application Architecture Selection
- 8.3. The Predicate Breakdown Structure (PBS)
- 8.4. Summary
- 9. Modeling Software Systems That Require Concurrency
- 9.1. What Is UML?
- 9.2. Modeling the Structure of a System
- 9.2.1. The Class Model
- 9.2.2. Visualizing Classes
- 9.2.3. Ordering the Attributes and Services
- 9.2.4. Visualizing Instances of a Class
- 9.2.5. Visualizing Template Classes
- 9.2.6. Showing the Relationship between Classes and Objects
- 9.2.7. Visualizing Interface Classes
- 9.2.8. The Organization of Interactive Objects
- 9.3. UML and Concurrent Behavior
- 9.4. Visualizing the Whole System
- 9.5. Summary
- 10. Testing and Logical Fault Tolerance for Parallel Programs
- 10.1. Can You Just Skip the Testing?
- 10.2. Five Concurrency Challenges That Must Be Checked during Testing
- 10.3. Failure: The Result of Defects and Faults
- 10.4. How Do You Approach Defect Removal for Parallel Programs?
- 10.4.1. The Problem Statement
- 10.4.2. A Simple Strategy and Rough-Cut Solution Model
- 10.4.3. A Revised Solution Model Using Layer 5 from PADL
- 10.4.4. The PBS of the Agent Solution Model
- 10.5. What Are the Standard Software Engineering Tests?
- 10.5.1. Software Verification and Validation
- 10.5.2. The Code Doesn't Work — Now What?
- 10.5.3. What Is Logical Fault Tolerance?
- 10.5.4. Predicate Exceptions and Possible Worlds
- 10.5.5. What Is Model Checking?
- 10.6. Summary
- A. UML for Concurrent Design
- B. Concurrency Models
- B.1. Interprocess and Interthread Communication
- B.2. Boss/Worker Approach 1 with Threads
- B.3. Boss/Worker Approach 1 with Processes
- B.4. Boss/Worker Approach 2 with Threads
- B.5. Boss/Worker Approach 3 with Threads
- B.6. Peer-to-Peer Approach 1 with Threads
- B.7. Peer-to-Peer Approach 1 with Processes
- B.8. Peer-to-Peer Approach 2 with Threads
- B.9. Peer-to-Peer Approach 2 with Processes
- B.10. Workpile Approach 1
- B.11. Workpile Approach 2
- B.12. Pipeline Approach with Threads
- B.13. Producer/Consumer Approach 1 with Threads
- B.14. Producer/Consumer Approach 2 with Threads
- B.15. Producer/Consumer Approach 3 with Threads
- B.16. Monitor Approach
- B.17. Blackboard Approach with Threads
- B.18. Data Level Parallelism: SIMD Approach
- B.19. Data Level Parallelism: MIMD Approach
- B.20. PRAM Model
- C. POSIX Standard for Thread Management
- pthread_atfork()
- pthread_attr_destroy()
- pthread_attr_getdetachstate()
- pthread_attr_getguardsize()
- pthread_attr_getinheritsched()
- pthread_attr_getschedparam()
- pthread_attr_getschedpolicy()
- pthread_attr_getscope()
- pthread_attr_getstack()
- pthread_attr_getstackaddr()
- pthread_attr_getstacksize()
- pthread_attr_init()
- pthread_attr_setdetachstate()
- pthread_attr_setguardsize()
- pthread_attr_setinheritsched()
- pthread_attr_setschedparam()
- pthread_attr_setschedpolicy()
- pthread_attr_setscope()
- pthread_attr_setstack()
- pthread_attr_setstackaddr()
- pthread_attr_setstacksize()
- pthread_cancel()
- pthread_cond_broadcast()
- pthread_cond_destroy()
- pthread_cond_signal()
- pthread_cond_timedwait()
- pthread_condattr_destroy()
- pthread_condattr_getclock()
- pthread_condattr_getpshared()
- pthread_condattr_init()
- pthread_condattr_setclock()
- pthread_condattr_setpshared()
- pthread_create()
- pthread_detach()
- pthread_equal()
- pthread_exit()
- pthread_getconcurrency()
- pthread_getcpuclockid()
- pthread_getschedparam()
- pthread_getspecific()
- pthread_join()
- pthread_kill()
- pthread_mutex_destroy()
- pthread_mutex_getprioceiling()
- pthread_mutex_init()
- pthread_mutex_lock()
- pthread_mutex_setprioceiling()
- pthread_mutex_timedlock()
- pthread_mutex_trylock()
- pthread_mutexattr_destroy()
- pthread_mutexattr_getprioceiling()
- pthread_mutexattr_getprotocol()
- pthread_mutexattr_getpshared()
- pthread_mutexattr_gettype()
- pthread_mutexattr_init()
- pthread_mutexattr_setprioceiling()
- pthread_mutexattr_setprotocol()
- pthread_mutexattr_setpshared()
- pthread_mutexattr_settype()
- pthread_once()
- pthread_rwlock_destroy()
- pthread_rwlock_rdlock()
- pthread_rwlock_timedrdlock()
- pthread_rwlock_timedwrlock()
- pthread_rwlock_tryrdlock()
- pthread_rwlock_trywrlock()
- pthread_rwlock_unlock()
- pthread_rwlock_wrlock()
- pthread_rwlockattr_destroy()
- pthread_rwlockattr_getpshared()
- pthread_rwlockattr_init()
- pthread_rwlockattr_setpshared()
- pthread_self()
- pthread_setcancelstate()
- pthread_setconcurrency()
- pthread_setschedparam()
- Pthread_setschedprio()
- pthread_setspecific()
- pthread_testcancel()
- D. POSIX Standard for Process Management
- posix_spawn()
- posix_spawn_file_actions_addclose()
- posix_spawn_file_actions_adddup2()
- posix_spawn_file_actions_addopen()
- posix_spawn_file_actions_destroy()
- posix_spawnattr_destroy()
- posix_spawnattr_getflags()
- posix_spawnattr_getpgroup()
- pisix_spawnattr_getschedparam()
- posix_spawnattr_getschedpolicy()
- Bibliography
Name
DESCRIPTION
The pthread_rivlock_unlock() function shall release a lock held on the read-write lock object referenced by rwlock. Results are undefined if the read-write lock rwlock is not held by the calling thread.
If this function is called to release a read lock from the read-write lock object and there are other read locks currently held on this read-write lock object, the read-write lock object remains in the read locked state. If this function releases the last read lock for this read-write lock object, the read-write lock object shall be put in the unlocked state with no owners.
If this function is called to release a write lock for this read-write lock object, the read-write lock object shall be put in the unlocked state.
TPS If there are threads blocked on the lock when it becomes available, the scheduling policy shall tps determine which thread (s) shall acquire the lock. If the Thread Execution Scheduling option is supported, when threads executing with the scheduling policies SCHED_FIFO, SCHED_RR, or SCHED_SPORADIC are waiting on the lock, they shall acquire the lock in priority order when the lock becomes available. For equal priority threads, write locks shall take precedence over read locks. If the Thread Execution Scheduling option is not supported, it is implementation-defined whether write locks take precedence over read locks.
Results are undefined if any of these functions are called with an uninitialized read-write lock.
RETURN VALUE
If successful, the pthread_rwlock_unlock() function shall return zero; otherwise, an error number shall be returned to indicate the error.
ERRORS
The pthread_rwlock_unlock() function may fail if:
[EINVAL] | The value specified by rwlock does not refer to an initialized read-write lock object. |
[EPERM] | The current thread does not hold a lock on the read-write lock. |
The pthread_rwlock_unlock() function shall not return an error code of [EINTR].
SEE ALSO
pthread_rwlock_destroy(), pthread_rwlock_rdlock(), pthread_rwlock_timedrdlock(), pthread_wlock_timedwrlock(), pthread_rwlock_tryrdlock(), pthread_rwlock_trywrlock(), pthread_rwlock_wrlock(), the Base Definitions volume of IEEE Std 1003.1-2001, <pthread.h>
Issue 6
The following changes are made for alignment with IEEE Std 1003.lj-2000:
The margin code in the SYNOPSIS is changed to THR to indicate that the functionality is now part of the Threads option (previously it was part of the Read-Write Locks option in IEEE Std 1003.lj-2000 and also part of the XSI extension).
The DESCRIPTION is updated as follows:
The conditions under which writers have precedence over readers are specified.
The concept of read-write lock owner is deleted.
The SEE ALSO section is updated.
-
No Comment