atomicity

The cppreference documentation about memory orders says Typical use for relaxed memory ordering is incrementing counters, such as the reference counters of std::shared_ptr, since this only requires atomicity, but not ordering or synchronization ( note that decrementing the shared_ptr counters requires acquire-release synchronization with the destructor ) Does this mean that relaxed memory ordering don't actually result in atomicity with respect to the same variable? But rather just results in eventual consistency with respect to other relaxed memory loads and/or compare_exchange s? Using std:

Am I wrong to assume that the atomic::load should also act as a memory barrier ensuring that all previous non-atomic writes will become visible by other threads? To illustrate: volatile bool arm1 = false; std::atomic_bool arm2 = false; bool triggered = false; Thread1: arm1 = true; //std::std::atomic_thread_fence(std::memory_order_seq_cst); // this would do the trick if (arm2.load()) triggered = true; Thread2: arm2.store(true); if (arm1) triggered = true; I expected that after executing both 'triggered' would be true. Please don't suggest to make arm1 atomic, the point is to explore the

Say you have the following class public class AccessStatistics { private final int noPages, noErrors; public AccessStatistics(int noPages, int noErrors) { this.noPages = noPages; this.noErrors = noErrors; } public int getNoPages() { return noPages; } public int getNoErrors() { return noErrors; } } and you execute the following code private AtomicReference<AccessStatistics> stats = new AtomicReference<AccessStatistics>(new AccessStatistics(0, 0)); public void incrementPageCount(boolean wasError) { AccessStatistics prev, newValue; do { prev = stats.get(); int noPages = prev.getNoPages() + 1; int

I'm writing a Python 2.7 script. In summary, this script is being run every night on Linux and activates several processes. I'd like to ensure this script is not run multiple times in parallel (basically trying to mimic Singleton pattern but on application level) . Code Example def main(): # before doing anything, I'd like to know whether this # script was activated and alive. # if so, error out # do something if __name__ == "__main__": main() Suggestion The naive solution would be to create some kind of a lock file, that acts as a mutex. The first thing we do is to check whether this file

so I have a stored procedure (sql server 2008 r2) something like this BEGIN TRAN BEGIN TRY //critical section select value update value //end of critical section COMMIT END TRY BEGIN CATCH IF @@TRANCOUNT > 0 ROLLBACK END CATCH I want no two stored procedures read the same value. In other words read and update should be atomic. This code does this? If not how do I do it? Yes they are atomic but that does not mean that you will get the behaviour that you want here! The property you need to look at is isolation. To achieve the exclusion that you require you would need to make the SELECT operation

I spent hours to dig the behavior, first about those questions: Atomicity of `write(2)` to a local filesystem How can I synchronize -- make atomic -- writes on one file from from two processes? How does one programmatically determine if "write" system call is atomic on a particular file? What happens if a write system call is called on same file by 2 different processes simultaneously http://article.gmane.org/gmane.linux.kernel/43445 It seems if we use 'O_APPEND' flag when opening file, it will always be ok to logging to same file from multiple processes, on linux. And i believe python surely