Foundations of Programming - Karl Seguin

Chapter 7 - Back to Basics: Memory
Pinning
Pinning occurs when an object is locked to a specific address on the heap. Pinned memory cannot be
compacted by the garbage collector resulting in fragmentation. Why do values get pinned? The most
common cause is because your code is interacting with unmanaged code. When the .NET garbage
collector compacts the heap, it updates all references in managed code, but it has no way to jump into
unmanaged code and do the same. Therefore, before interoping it must first pin objects in memory.
Since many methods within the .NET framework rely on unmanaged code, pinning can happen without
you knowing about it (the scenario I'm most familiar with are the .NET Socket classes which rely on
unmanaged implementations and pin buffers).
A common way around this type of pinning is to declare large objects which don't cause as much
fragmentation as many small ones (this is even more true considering large objects are placed in a
special heap (called the Large Object Heap (LOH) which isn't compacted at all). For example, rather than
creating hundreds of 4KB buffers, you can create 1 large buffer and assign chunks of it yourself. For an
example as well as more information on pinning, I suggest you read Greg Young's advanced post on
pinning and asynchronous sockets.
There's a second reason why an object might be pinned - when you explicitly make it happen. In C# (not
in VB.NET) if you compile your assembly with the unsafe option, you can pin an object via the fixed
statement. While extensive pinning can cause memory pressures on the system, judicial use of the
fixed statement can greatly improve performance. Why? Because a pinned object can be manipulated
directly with pointer arithmetic - this isn't possible if the object isn't pinned because the garbage
collector might reallocate your object somewhere else in memory.
Take for example this efficient ASCII string to integer conversion which runs over 6 times faster than
using int.Parse.
public unsafe static int Parse(string stringToConvert)
{
int value = 0;
int length = stringToConvert.Length;
fixed(char* characters = stringToConvert)
{
for (int i = 0; i < length; ++i)
{
value = 10 * value + (characters[i] - 48);
}
}
return value;
}
Unless you're doing something abnormal, there should never be a need to mark your assembly as
unsafe and take advantage of the fixed statement. The above code will easily crash (pass null as the
string and see what happens), isn't nearly as feature rich as int.Parse, and in the scale of things is
extremely risky while providing no benefits.
Foundations of Programming Copyright © Karl Seguin www.codebetter.com
62