var array = new int[5]<\/code> . It is perfectly normal to use it – it is well known and intuitive solution. However, we can also allocate such a buffer on the stack. On the one hand it entails some risks, but on the other it can safe some memory for us.<\/p>\n\n\n\nStackalloc<\/h1>\n\n\n\n
Stackalloc<\/a> is an expression that allocates a block of memory on the stack. Thanks to that we can allocate a buffer on the stack instead on the heap. To do that we can use Span<\/a> struct: Span<int> span = stackalloc int[7];<\/code>. The syntactic seems to be pretty intuitive and understandable.<\/p>\n\n\n\nBE CAREFUL: As it stands in the documentation<\/a>: “The amount of memory available on the stack is limited. If you allocate too much memory on the stack, a\u00a0StackOverflowException<\/a>\u00a0is thrown”. It is also important to mention that the StackOverflowException<\/a> is kind of exception that cannot be caught. In other words, StackOverflowException<\/a> = application termination. It doesn’t mean that it shouldn’t be used at all. It does mean that it should be used with great care and awareness.<\/p>\n\n\n\nExample<\/h1>\n\n\n\n
Let’s consider the following StackallocExecutor<\/code> class:<\/p>\n\n\n\npublic class StackallocExecutor\r\n{\r\n private readonly int _size;\r\n private readonly Random _random;\r\n\r\n public StackallocExecutor(int size)\r\n {\r\n _size = size;\r\n _random = new Random();\r\n }\r\n\r\n public int Stackalloc()\r\n {\r\n Span<int> span = stackalloc int[_size];\r\n\r\n for (int i = 0; i < span.Length; i++)\r\n span[i] = _random.Next();\r\n\r\n for (int i = 0; i < span.Length; i++)\r\n if (i % 2 == 1)\r\n span[i] += 1;\r\n\r\n var max = span[0];\r\n\r\n for (int i = 1; i < span.Length; i++)\r\n if (span[i] > max)\r\n max = span[i];\r\n\r\n return max;\r\n }\r\n\r\n public int NoStackalloc()\r\n {\r\n var array = new int[_size];\r\n\r\n for (int i = 0; i < array.Length; i++)\r\n array[i] = _random.Next();\r\n\r\n for (int i = 0; i < array.Length; i++)\r\n if (i % 2 == 1)\r\n array[i] += 1;\r\n\r\n var max = array[0];\r\n\r\n for (int i = 1; i < array.Length; i++)\r\n if (array[i] > max)\r\n max = array[i];\r\n\r\n return max;\r\n }\r\n}<\/code><\/pre>\n\n\n\nThe class has two methods Stackalloc<\/code> and NoStackalloc<\/code>. Both of them do the the same – create a buffer, populate the buffer, add “1” to the odd indexes and return the max value. Maybe it is not the most real-world scenario but I hadn’t better idea at the time of writing the code\ud83d\ude01.<\/p>\n\n\n\nAlright, but what’s the cool thing about the stackalloc at all? Let’s see the benchmark result!<\/p>\n\n\n\n
Benchmark<\/h1>\n\n\n\n
This time the crucial part of the results is the last column, i.e. “Allocated”.<\/p>\n\n\n\n![\"\"](\"https:\/\/baldsolutions.com\/wp-content\/uploads\/2022\/05\/image.png\")
<\/figure>\n\n\n\nAs you can see, no matter what the size of buffer is, the “Allocated” value for the Stackalloc<\/code> method is the same. NoStackalloc<\/code> method does quite the opposite, the greater size, the greater allocations.<\/p>\n\n\n\nSummary<\/h1>\n\n\n\n
To sum up, having an ability to allocate reasonably small buffer on the stack seems to be interesting and useful feature. However, the StackOverflowException<\/a> is still there and might kill the application without hesitation.<\/p>\n\n\n\nAs always I’ve prepared an example and you can find it on my github<\/a>, project: stackalloc<\/a>, benchmark project: stackalloc-benchmark<\/a>.
I encourage you to go through the code, debug it and try to test your own scenarios e.g. killing an application with StackOverflowException (for me the following throws the exception):<\/p>\n\n\n\nvar size = 1_000_000;\r\nvar executor = new StackallocExecutor(size);\r\nexecutor.Stackalloc();<\/code><\/pre>\n\n\n\nHave a nice day, bye!<\/p>\n","protected":false},"excerpt":{"rendered":"
Introduction Allocating some kind of a buffer (e.g. array) on a heap is a quite straightforward behaviour. It happens anytime we do something like this:…<\/p>\n