12-28-2009
Quote:
Originally Posted by
fpmurphy
Interlocked variables/operations are mostly a Microsoft win32 thing. Because some architectures capable of running Linux do not have the necessary hardware support, interlocked variables/operations are not available in Linux user space. They are available only in the kernel and only on some architectures.
If I'm reading it right, an interlocked variable looks a lot like a linux futex, the atomic part of which
does happen in userspace.
10 More Discussions You Might Find Interesting
1. Programming
Hi all,
I am working in a UNIX/C environment. I would like to understand more about MUTEX and Threads. Can someone explain me these
concepts and how they are related.
Vijay (2 Replies)
Discussion started by: vthasan
2 Replies
2. UNIX for Dummies Questions & Answers
Can anyone explain me what mutexes are in
multithreading environment? (2 Replies)
Discussion started by: sagar
2 Replies
3. Shell Programming and Scripting
A shell in crontab per 5 min write a file
B shell in crontab per 6 min read a file
how to lock the share file a ;avioid confilict in write and read?
Thx : -) (1 Reply)
Discussion started by: zz_xm
1 Replies
4. Programming
Hi, I have two tasks 'Read' and 'Write' which reads and writes on a file "abc.txt" respectively.
Now I need to restrict the Write operation on the file while Read is going on, But can allow two Reads at a time.
ie. two Reads can happen simultaneously, but Write can't happen at Read is going on.
... (3 Replies)
Discussion started by: satheeshalle
3 Replies
5. Programming
Hi,
can someone explain me the difference between mutex and semaphores?
Thanks (1 Reply)
Discussion started by: rvan
1 Replies
6. UNIX for Dummies Questions & Answers
can u tell me what is the exact difference b/w mutex and semaphore
and what is the diff b/w counting semaphore and binary semaphore
amit (1 Reply)
Discussion started by: amitpansuria
1 Replies
7. Shell Programming and Scripting
Hello Everyone,
I just joined this forum and this is my first post.
I would like to know how can I impliment basic read/write locks in perl. I have a database (file) which can be accessed simultaneously but has to be locked while writing.
If there is no such support in perl, my next... (6 Replies)
Discussion started by: superuser84
6 Replies
8. Programming
I am trying to use mutex in my multi-tread project, but they don't seem to work.
I have created a simple demonstration of the problem. This is NOT how I would use a mutex, only a demonstration of the problem:
#include <stdio.h>
#include <pthread.h>
int main()
{
int val;
... (3 Replies)
Discussion started by: ChrisWilliams
3 Replies
9. Programming
Hi all,
I have a scenario where I need to use the mutex locks. The mutex locks are working fine, but sometimes I am getting into the dead lock situation.
Below is the summary of my code :
MUTEX LOCK
performTask();
MUTEX UNLOCK.
In some cases I get into the situation where... (2 Replies)
Discussion started by: cjjoy
2 Replies
10. Programming
Hello,
I have got some issue with the struct variable with passed arguments
the variable in the sturct is only recognize the last value their assigned to
I'm pretty confused why the mutex didn't work out
here is my program:
#include<stdio.h>
#include<pthread.h>
pthread_mutex_t lock... (3 Replies)
Discussion started by: michael23
3 Replies
LEARN ABOUT NETBSD
atomic_cas_ptr_ni
ATOMIC_CAS(3) BSD Library Functions Manual ATOMIC_CAS(3)
NAME
atomic_cas, atomic_cas_32, atomic_cas_uint, atomic_cas_ulong, atomic_cas_ptr, atomic_cas_64, atomic_cas_32_ni, atomic_cas_uint_ni,
atomic_cas_ulong_ni, atomic_cas_ptr_ni, atomic_cas_64_ni -- atomic compare-and-swap operations
SYNOPSIS
#include <sys/atomic.h>
uint32_t
atomic_cas_32(volatile uint32_t *ptr, uint32_t old, uint32_t new);
unsigned int
atomic_cas_uint(volatile unsigned int *ptr, unsigned int old, unsigned int new);
unsigned long
atomic_cas_ulong(volatile unsigned long *ptr, unsigned long old, unsigned long new);
void *
atomic_cas_ptr(volatile void *ptr, void *old, void *new);
uint64_t
atomic_cas_64(volatile uint64_t *ptr, uint64_t old, uint64_t new);
uint32_t
atomic_cas_32_ni(volatile uint32_t *ptr, uint32_t old, uint32_t new);
unsigned int
atomic_cas_uint_ni(volatile unsigned int *ptr, unsigned int old, unsigned int new);
unsigned long
atomic_cas_ulong_ni(volatile unsigned long *ptr, unsigned long old, unsigned long new);
void *
atomic_cas_ptr_ni(volatile void *ptr, void *old, void *new);
uint64_t
atomic_cas_64_ni(volatile uint64_t *ptr, uint64_t old, uint64_t new);
DESCRIPTION
The atomic_cas family of functions perform a compare-and-swap operation in an atomic fashion. The value of the variable referenced by ptr is
compared against old. If the values are equal, new is stored in the variable referenced by ptr.
The old value of the variable referenced by ptr is always returned regardless of whether or not the new value was stored. Applications can
test for success of the operation by comparing the return value to the value passed as old; if they are equal then the new value was stored.
The non-interlocked variants, *_ni(), guarantee atomicity within the same CPU with respect to interrupts and preemption. For example, they
are suitable for synchronizing compare-and-swap operations on a variable shared by a thread and an interrupt that are bound to the same CPU.
The *_ni() variants are not atomic with respect to different CPUs. *_ni() variants should avoid the interprocessor synchronization overhead
of the standard compare-and-swap operations.
The 64-bit variants of these functions are available only on platforms that can support atomic 64-bit memory access. Applications can check
for the availability of 64-bit atomic memory operations by testing if the pre-processor macro __HAVE_ATOMIC64_OPS is defined.
SEE ALSO
atomic_ops(3)
HISTORY
The atomic_cas functions first appeared in NetBSD 5.0.
NOTES
On some architectures, a *_ni() variant is merely an alias for the corresponding standard compare-and-swap operation. While the non-inter-
locked variant behaves correctly on those architectures, it does not avoid the interprocessor synchronization overhead.
BSD
February 11, 2010 BSD