Registers in C#

Question

we all know the idea of stack and heap, but I recently read about a third option to save data: registers.

I have a hard time finding good articles about this type, what I found was: http://www.dotnetperls.com/method-parameter, and a lot of stuff for C, for example: http://igoro.com/archive/volatile-keyword-in-c-memory-model-explained/

The only real informations I have so far: every CPU has its own registers, which can be used to save data, which is accessed at the fastest way possible, for example in the for loops.

As far as I've seen, this en-registering is made by the CLR. Then I remembered this volatile-keyword, and if we look at MSDN:

The volatile keyword indicates that a field might be modified by multiple threads that are executing at the same time. Fields that are declared volatile are not subject to compiler optimizations that assume access by a single thread. This ensures that the most up-to-date value is present in the field at all times.

So does the Volatile exactly that? It tells the CLR not to use the CPU register but the stack/heap, which can be accesses by all CPUs/threads?

I'm sorry for my confusing question, but there is really little information on this topic around.

People focus far too much on the heap and the stack (and sometimes, as here, registers). It's highly unlikely that, in 99.99% of circumstances, you need to know the actual storage location of the objects that you're working with. — Damien_The_Unbeliever, Jun 13 '14 at 10:57
Think of a register as being the equivalent of your brain's memory when you're working on something, and think of the stack as the pile of papers on your desk that you need to work on. Then the set of books on your desk whose information you're currently using might be called the cache, and your library is the equivalent of DRAM. — user541686, Jun 13 '14 at 11:07

Guffa · Accepted Answer · 2014-06-13T11:14:26.273

6

"Every CPU has his own Register"

Every CPU has a set of registers, that are used for most operations that involve any data. Typically an instruction loads some data from memory into a register, then another instruction does some calculations on the data in the register.

The CPU has a few registers that are intended for data, some that are intended for pointers, and some special registers that keep track of program execution like the instruction pointer, the stack pointer and the flags register.

As the CPU has several registers, the JIT compiler can sometimes use a few of them as storage for local variables. Instead of allocating the variable on the stack, the register is dedicated to hold the value of the variable.

The volatile keyword doesn't affect how registers can be used for storage. If a variable can be accessed by different threads, then it's not the kind of variable that is a candidate to be stored in a register. In practive, it's just local variables with a limited scope and short life span that will be stored in registers.

edited Jun 13 '14 at 11:14

answered Jun 13 '14 at 11:07

Guffa

687,336
108
737
1,005

Are you sure about the Registering? http://stackoverflow.com/questions/72275/when-should-the-volatile-keyword-be-used-in-c , see Erics comment: "C#, "volatile" means not only "make sure that the compiler and the jitter do not perform any code reordering or register caching optimizations on this variable" – Matthias Müller Jun 16 '14 at 12:45
1

@MatthiasMüller: That applies to caching of values in registers, not storing values in registers. A cached value is a value stored on the stack/heap, and temporarily also kept in a register. – Guffa Jul 20 '14 at 17:27
`volatile` pretty much guarantees that the JIT won't use registers to hold the variable, since there's no guarantee that different threads will run on the same core. So declaring a variable as `volatile` will tell the compiler and JIT to avoid using registers for anything that could modify the value of the variable. Register usage is pretty much unavoidable in most architectures, but changes will be written to memory to satisfy the `volatile` constraint. – Corey Dec 13 '15 at 11:53

score 5 · Answer 2 · answered Jun 13 '14 at 11:04

That sentence is misleading in the sense that it is not a precise definition of what volatile guarantees. Volatile is not specified in terms of compiler optimizations. Also, restricting the compiler is not enough on ARM. The CPU must be restricted as well. I suggest you research what volatile guarantees exactly.

It is not even true that volatile prevents the use of registers. Volatile loads guarantee that the volatile variable is being read exactly as often as the program does it and in the same order.

When you write:

volatile int sharedVar = 0;

Console.WriteLine(sharedVar);
Console.WriteLine(sharedVar);

The JIT must read exactly two times. But it can still use registers to store the values read.

If the CLR can prove that sharedVar is never written to and always will have the value 0 it can even delete the reads. It probably has to insert memory barriers in some places instead of the reads because volatile accesses have certain ordering guarantees. But no load has to physically happen at all. (The current JIT does not do this optimization.)

Registers are an implementation detail. The CLR is not specified in terms of physical implementation. I understand you want to know about implementation details and that's fine. They do not matter much for what the CLR guarantees the programmer, though.

Registers in C#

2 Answers2

Linked