多线程'固定'

Question

I have a huge array that is being analyzed differently by two threads:

• Data is large- no copies allowed
• Threads must process concurrently
• Must disable bounds checking for maximum performance

Therefore, each thread looks something like this:

unsafe void Thread(UInt16[] data)
{
  fixed(UInt16* pData = data)
  {
    UInt16* pDataEnd = pData + data.Length;
    for(UInt16* pCur=pData; pCur != pDataEnd; pCur++)
    {
      // do stuff
    }
  }
}

Since there is no mutex ( intentionally ), I'm wondering if it's safe to use two fixed statements on the same data on parallel threads?? Presumably the second fixed should return the same pointer as the first, because memory is already pinned... and when the first completes, it won't really unpin memory because there is a second fixed() still active.. Has anyone tried this scenario?

Answer 1

According to "CLR via C#" it is safe to do so.

The compiler sets a 'pinned' flag on pData variable (on the pointer, not on the array instance).

So multiple/recursive use should be OK.

Answer 2

Maybe instead of using fixed, you could use GCHandle.Alloc to pin the array:

// not inside your thread, but were you init your shared array
GCHandle handle = GCHandle.Alloc(anArray, GCHandleType.Pinned);
IntPtr intPtr = handle.AddrOfPinnedObject();


// your thread
void Worker(IntPtr pArray)
{
  unsafe
  {
     UInt16* ptr = (UInt16*) pArray.ToPointer();
      ....
  }
}        

Answer 3

If all you need to do is

 for(int i = 0; i < data.Length; i++)
 {
     // do stuff with data[i]
 }

the bounds check is eliminated by the JIT compiler. So no need for unsafe code.

Note that this does not hold if your access pattern is more complex than that.