memory-model

It is well known that Java Language allows compliers to re-arrange lines of compiled code as long as the re-order makes no difference to the code semantics. However , the compiler is required to only bother about sematics as seen from the current thread . If this re-order affects semantics in a multithreaded situation , it usually causes concurrency issues ( memory visibility ) My question(s) : What is achieved by allowing this freedm to the compiler ? Is it really possible for the compiler to produce code which is more efficient by rearranging the code ? I am yet to see a practical case for

Let's say you have a simple class like this: class MyClass { private readonly int a; private int b; public MyClass(int a, int b) { this.a = a; this.b = b; } public int A { get { return a; } } public int B { get { return b; } } } I could use this class in a multi-threaded manner: MyClass value = null; Task.Run(() => { while (true) { value = new MyClass(1, 1); Thread.Sleep(10); } }); while (true) { MyClass result = value; if (result != null && (result.A != 1 || result.B != 1)) { throw new Exception(); } Thread.Sleep(10); } My question is: will I ever see this (or other similar multi-threaded

Consider the following code snippet taken from Herb Sutter's talk on atomics: The smart_ptr class contains a pimpl object called control_block_ptr containing the reference count refs . // Thread A: // smart_ptr copy ctor smart_ptr(const smart_ptr& other) { ... control_block_ptr = other->control_block_ptr; control_block_ptr->refs.fetch_add(1, memory_order_relaxed); ... } // Thread D: // smart_ptr destructor ~smart_ptr() { if (control_block_ptr->refs.fetch_sub(1, memory_order_acq_rel) == 0) { delete control_block_ptr; } } Herb Sutter says the increment of refs in Thread A can use memory_order

The new c++ standard introduces the notion of a memory model. There were already questions on SO about it, what does it mean, how does it change the way we write code in c++ and so on. I'm interested in getting to know how does the C++ memory model relate to the older, well known java memory model (1.5). Is it the same? Is it similar? Do they have any significant differences? If so, why? The java memory model has been around since a long time and many people know it quite decently, so I guess it might be helpful, not only for me, to learn the C++ memory model, by comparing it with the java one

The C++11 standard defines a memory model (1.7, 1.10) which contains memory orderings , which are, roughly, "sequentially-consistent", "acquire", "consume", "release", and "relaxed". Equally roughly, a program is correct only if it is race-free, which happens if all actions can be put in some order in which one action happens-before another one. The way that an action X happens-before an action Y is that either X is sequenced before Y (within one thread), or X inter-thread-happens-before Y . The latter condition is given, among others, when X synchronizes with Y , or X is dependency-ordered

I know that in C++ you can create an instance of a class on the stack like MyClass mc = MyClass(8.2); or on the heap like MyClass * mc = new MyClass(8.2); Can you do the same thing in C#? The only way I ever create a class in C# is by new ing it. No, it's not possible. All instances of all classes are always allocated on the heap. It is value types, including user defined struct types, that hold values, rather than references to values elsewhere, that can store a value in whatever location that variable happens to store its value in, which may not be the heap. 来源： https://stackoverflow.com