Pthread Mutex Error Codes
Contents |
and unlock a mutex SYNOPSIS #include <pthread.h>
int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_trylock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);
DESCRIPTION The mutex object referenced by mutex shall be locked by a call to pthread_mutex_lock() that returns zero pthread mutex example or [EOWNERDEAD]. If the mutex is already locked by another thread, the calling
Pthread Mutex Lock
thread shall block until the mutex becomes available. This operation shall return with the mutex object referenced by mutex in the pthread mutex init locked state with the calling thread as its owner. If a thread attempts to relock a mutex that it has already locked, pthread_mutex_lock() shall behave as described in the Relock column of the following
Pthread Mutex Attributes
table. If a thread attempts to unlock a mutex that it has not locked or a mutex which is unlocked, pthread_mutex_unlock() shall behave as described in the Unlock When Not Owner column of the following table. Mutex Type Robustness Relock Unlock When Not Owner NORMAL non-robust deadlock undefined behavior NORMAL robust deadlock error returned ERRORCHECK either error returned error returned RECURSIVE either recursive error returned (see pthread recursive mutex below) DEFAULT non-robust undefined undefined behavior behavior DEFAULT robust undefined error returned behavior If the mutex type is PTHREAD_MUTEX_DEFAULT, the behavior of pthread_mutex_lock() may correspond to one of the three other standard mutex types as described in the table above. If it does not correspond to one of those three, the behavior is undefined for the cases marked . Where the table indicates recursive behavior, the mutex shall maintain the concept of a lock count. When a thread successfully acquires a mutex for the first time, the lock count shall be set to one. Every time a thread relocks this mutex, the lock count shall be incremented by one. Each time the thread unlocks the mutex, the lock count shall be decremented by one. When the lock count reaches zero, the mutex shall become available for other threads to acquire. The pthread_mutex_trylock() function shall be equivalent to pthread_mutex_lock(), except that if the mutex object referenced by mutex is currently locked (by any thread, including the current thread), the call shall return immediately. If the mutex type is PTHREAD_MUTEX_RECURSIVE and the mutex is currently owned by the calling thread, the mutex lock count shall be increment
here for a quick overview of the site Help Center Detailed answers to any questions you might have Meta Discuss the workings and policies of this site About Us Learn more about Stack Overflow the company Business Learn more about
Pthread Mutex Unlock
hiring developers or posting ads with us Stack Overflow Questions Jobs Documentation Tags Users Badges Ask
Pthread Mutex Initializer
Question x Dismiss Join the Stack Overflow Community Stack Overflow is a community of 6.2 million programmers, just like you, helping each other. pthread mutex example c++ Join them; it only takes a minute: Sign up pthread_mutex_lock returns invalid argument up vote 4 down vote favorite I am working on some C code and am having a problem with locking a mutex. The code does a http://pubs.opengroup.org/onlinepubs/9699919799/functions/pthread_mutex_lock.html call to a function and this function locks a mutex to ensure a file pointer doesn't get overwritten, this works fine for several instances, probably about 10-20 separate calls of the function being called, but on the next call, pthread_mutex_lock will return with a result of 22. I've then put this result into strerror(); and got back invalid argument. What does invalid argument means, thanks for any help you can provide. c debugging pthreads mutex share|improve this question edited http://stackoverflow.com/questions/12781944/pthread-mutex-lock-returns-invalid-argument Oct 8 '12 at 12:43 vy32 9,0311661128 asked Oct 8 '12 at 12:39 Boardy 9,90554168284 add a comment| 2 Answers 2 active oldest votes up vote 4 down vote accepted Sounds like you have a threading problem or a wild point somewhere else in your program. Try printing the value of the mutex pointer. Try having another thread that simply locks the mutex and then prints to a log file the time and that the lock was successful, then unlocks the mutex. I suspect the problem is not where you are looking. Also, as other have said here, your best bet is to create a very small test program that demonstrates the problem and post it here. Chances are you won't be able to get that small program to demonstrate the error. Then slowly add all of your original code into the small program until the error returns. If it returns, you now know what caused the problem. If it doesn't return, you're done. share|improve this answer answered Oct 8 '12 at 12:43 vy32 9,0311661128 add a comment| up vote 7 down vote 22 is ENVAL error code which means invlalid argument. Make sure that you have initilized you mutex, or if at some point you have unitilized it somewhere. Also man pthread_mutex_lock says: EINVAL The mutex was created with the protocol attribute having the value PTHREAD_PRIO_PROTECT and the calling thread's priority
API Compiling Threaded Programs Thread Management Creating and Terminating Threads Passing Arguments to Threads Joining and Detaching Threads Stack Management Miscellaneous Routines Exercise 1 Mutex Variables Mutex Variables Overview Creating and Destroying Mutexes Locking and Unlocking Mutexes https://computing.llnl.gov/tutorials/pthreads/ Condition Variables Condition Variables Overview Creating and Destroying Condition Variables Waiting and Signaling http://www.domaigne.com/blog/computing/pthreads-errors-and-errno/ on Condition Variables Monitoring, Debugging and Performance Analysis Tools for Pthreads LLNL Specific Information and Recommendations Topics Not Covered Exercise 2 References and More Information Appendix A: Pthread Library Routines Reference Abstract In shared memory multiprocessor architectures, threads can be used to implement parallelism. Historically, hardware vendors have implemented their own proprietary versions pthread mutex of threads, making portability a concern for software developers. For UNIX systems, a standardized C language threads programming interface has been specified by the IEEE POSIX 1003.1c standard. Implementations that adhere to this standard are referred to as POSIX threads, or Pthreads. The tutorial begins with an introduction to concepts, motivations, and design considerations for using Pthreads. Each of the three major classes of routines in the pthread mutex example Pthreads API are then covered: Thread Management, Mutex Variables, and Condition Variables. Example codes are used throughout to demonstrate how to use most of the Pthreads routines needed by a new Pthreads programmer. The tutorial concludes with a discussion of LLNL specifics and how to mix MPI with pthreads. A lab exercise, with numerous example codes (C Language) is also included. Level/Prerequisites: This tutorial is ideal for those who are new to parallel programming with pthreads. A basic understanding of parallel programming in C is required. For those who are unfamiliar with Parallel Programming in general, the material covered in EC3500: Introduction to Parallel Computing would be helpful. Pthreads Overview What is a Thread? Technically, a thread is defined as an independent stream of instructions that can be scheduled to run as such by the operating system. But what does this mean? To the software developer, the concept of a "procedure" that runs independently from its main program may best describe a thread. To go one step further, imagine a main program (a.out) that contains a number of procedures. Then imagine all of these procedures being able to be scheduled to run simultaneously and/or independently by the ope
to the Single Unix Specification standard consisted to submit an example of use for pthread_sigmask()[1]. Since my proposal was going to be viewed by many Austin Group's contributors (some being "recognized UNIX authority"), I tried to make my example as perfect as possible. In an academic fashion, I checked every function's return code for possible errors. That's where I got it wrong for the Pthreads APIs. Oh well, they do not use errno… The Problem: Before the advent of Pthreads, POSIX functions used to return -1 on error, and set the corresponding error code in the global variable errno[2]. This mechanism has a few drawbacks even for single-threaded process: it is not simple to return -1 as valid value. a signal handler may change the errno value between the point a function set errno, and the point where you check the errno variable. Of course, a global errno doesn't work for multi-threaded processes. Indeed, a thread could execute a function that modifies errno just before you check the value in another thread. The (Pthreads) Solution: Since Pthreads, the errno variable is thread-local. That is, every thread has its own "errno copy". If you (or a system function) set the errno variable in one thread, it won't affect the errno value in any other thread. This is shown in the example below. Download errno_01.c1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 /*------------------------------ errno_01.c -------------------------------* compile with: cc -pthread errno_01.c -o errno_01 Copyright Loic Domaigne. Licensed under the Apache License, Version 2.0. *--------------------------------------------------------------------------*/ #include