Is this code thread safe?

Question

This is a simplified version of some code that I currently support:

int SomeFunc() 
{
  const long lIndex = m_lCurrentIndex;
  int nSum = 0;
  nSum += m_someArray[lIndex];
  nSum += m_someArray[lIndex];
  return nSum;
}

lCurrentIndex is periodically updated by another thread. The question is; will create a local copy of m_CurrentIndex, make sure that both calls to m_someArray use the same index?

Note that this is a simplified example; I’m thinking about the concept of creating a local copy, and not about which code is shown here. I know that the compiler will put this value in a register, but it is still a local copy, and not reading from lCurrentIndex twice.

Thanks!

Edit: the initial assignment is safe, both guarantees are guaranteed to be 32 bits in our setup. Edit2: And they are correctly aligned on the 32-bit border (forgot about it)

Answer 1

, , , . (, , 8- ). , - , / , .

Answer 2

m_CurrentIndex , to m_someArray ?

SomeFunc, , . (lIndex) .

, : m_someArray[lIndex] ( lIndex) ; m_ someArray ; lIndex.

Answer 3

, , . , "". . , .

Answer 4

( , / , ). , , m_lCurrentIndex volatile. , .

Answer 5

, , - m_lCurrentIndex lIndex ? , , , , .:)

: , .

Answer 6

, , .

, . , " " m_lCurrentIndex lIndex .

x86 , m_lCurrentIndex DWORD , long DWORD ( x86), , . , x64 , long DWORD m_lCurrentIndex, DWORD long 64b, m_lCurrentIndex 64b, , . .

, CAS ( , , , , , ), , , .

Memory barries

: , , , , . , , . .

Answer 7

, . , m_lCurrentIndex . , , m_lCurrentIndex, . , , , lIndex. , m_lCurrentIndex lIndex .