Parallel memory allocation

As a newbie in concurent programing, and because for now there aren't any tool for in-job nativearray allocation, I try to write terrifying code like this.

Code (CSharp):

1.  
2. unsafe struct TestJob : IJobParallelFor
3. {
4.        public int someLength; // can't be 0
5.  
6.        public void Execute(int index){
7.  
8.               int* ptr;
9.               if (someLength > 8) {
10.                    ptr = (int*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<int>() * someLength , 4, Allocator.TempJob);
11.              }
12.              else {
13.                    ptr = stackalloc int[someLength];
14.              }
15.  
16.              // do some reads and writes to allocated buffer
17.  
18.             if (someLength > 8) {
19.                  UnsafeUtility.Free(ptr, Allocator.TempJob);
20.             }
21.        }
22. }

And it works most of times, but in some rare cases where more then one agents use this kind of code, I have hard crashes, and especially when I allocate in stack, but also when allocation was in heap only. As I understand there I have data race, because each thread doesn't know about each other pointers, and they can point to the same memory, or memory can overlaps with each other.

Am I understand this right?

 

Thanks for reply. Yes I also started think that TempJob is bad choice here.

So in theory this can work, but in my code between allocation and deallocation, I'm doing something bad?

P.S. Anyway I have plans to rewrite this to avoid in-job allocation, but it can cause some unnecessary overhead.

 

Ok, for now I decided to have two variants with in-job allocation and without. And will try find some bugs in in-job version. And when 19.1 will be in stable state I will switch to NativeArray with Allocator.Temp.

Thanks!

 

Good day,

What would be the difference in performance between Marshal.AllocHGlobal(); and UnsafeUtility.Malloc()?

 

@Joachim_Ante For persistent memory allocator what was the key factor when choosing the TLSF in favor of let's say tcmalloc/jemalloc/smmalloc (if you compared it to any of them)? Lowest memory fragmentation? And another question: any lock mechanisms are used in the allocator implementations?

 

Much appreciate your answer.

 

I've always been a tad confused between Temp and TempJob, I think I got it now!

 

I did a few tests with allocators.
I allocate and deallocate 64 bytes 1000 times per frame after 5 sec of runtime. I do this for each allocator type.
Tested in build and editor, almost no differences. Results are from the build with attached profiler.

First allocation:

Each next allocation:

Spoiler: Test code

Code (CSharp):

1. using System;
2. using System.Runtime.InteropServices;
3. using Smmalloc;
4. using Unity.Collections;
5. using Unity.Collections.LowLevel.Unsafe;
6. using UnityEngine;
7. using UnityEngine.Profiling;
8.  
9. public class AllocTest : MonoBehaviour
10. {
11.     public float StartDelay        = 5f;
12.     public int   FramesToRun       = 10;
13.     public int   AllocationsPerRun = 1000;
14.  
15.     private        int              _currentFrame = 0;
16.     private        SmmallocInstance smmalloc;
17.     private        IntPtr[]         _pointers;
18.     private unsafe void*[]          _rawPointers;
19.  
20.     unsafe void Start()
21.     {
22.         smmalloc = new SmmallocInstance(8, 16 * 1024 * 1024);
23.         smmalloc.CreateThreadCache(4 * 1024, CacheWarmupOptions.Hot);
24.         _pointers    = new IntPtr[AllocationsPerRun];
25.         _rawPointers = new void*[AllocationsPerRun];
26.     }
27.  
28.     void Update()
29.     {
30.         if (Time.realtimeSinceStartup < StartDelay) return;
31.  
32.         if (_currentFrame < FramesToRun)
33.         {
34.             Profiler.BeginSample("SMMALLOC ALLOCATOR");
35.          
36.             for (int i = 0; i < AllocationsPerRun; i++)
37.             {
38.                 var memory = smmalloc.Malloc(64);
39.                 _pointers[i] = memory;
40.             }
41.  
42.             for (int i = 0; i < AllocationsPerRun; i++)
43.             {
44.                 smmalloc.Free(_pointers[i]);
45.             }
46.  
47.             Profiler.EndSample();
48.  
49.             Profiler.BeginSample("UNITY TEMP ALLOCATOR");
50.          
51.             for (int i = 0; i < AllocationsPerRun; i++)
52.                 unsafe
53.                 {
54.                     var memory = UnsafeUtility.Malloc(64, 4, Allocator.Temp);
55.                     _rawPointers[i] = memory;
56.                 }
57.  
58.             for (int i = 0; i < AllocationsPerRun; i++)
59.                 unsafe
60.                 {
61.                     UnsafeUtility.Free(_rawPointers[i], Allocator.Temp);
62.                 }
63.          
64.             Profiler.EndSample();
65.          
66.             Profiler.BeginSample("UNITY TEMPJOB ALLOCATOR");
67.          
68.             for (int i = 0; i < AllocationsPerRun; i++)
69.                 unsafe
70.                 {
71.                     var memory = UnsafeUtility.Malloc(64, 4, Allocator.TempJob);
72.                     _rawPointers[i] = memory;
73.                 }
74.  
75.             for (int i = 0; i < AllocationsPerRun; i++)
76.                 unsafe
77.                 {
78.                     UnsafeUtility.Free(_rawPointers[i], Allocator.TempJob);
79.                 }
80.          
81.             Profiler.EndSample();
82.          
83.             Profiler.BeginSample("UNITY PERSISTENT ALLOCATOR");
84.          
85.             for (int i = 0; i < AllocationsPerRun; i++)
86.                 unsafe
87.                 {
88.                     var memory = UnsafeUtility.Malloc(64, 4, Allocator.Persistent);
89.                     _rawPointers[i] = memory;
90.                 }
91.  
92.             for (int i = 0; i < AllocationsPerRun; i++)
93.                 unsafe
94.                 {
95.                     UnsafeUtility.Free(_rawPointers[i], Allocator.Persistent);
96.                 }
97.          
98.             Profiler.EndSample();
99.          
100.             Profiler.BeginSample("MARSHAL ALLOCATOR");
101.          
102.             for (int i = 0; i < AllocationsPerRun; i++)
103.             {
104.                 var memory = Marshal.AllocHGlobal(64);
105.                 _pointers[i] = memory;
106.             }
107.  
108.             for (int i = 0; i < AllocationsPerRun; i++)
109.             {
110.                 Marshal.FreeHGlobal(_pointers[i]);
111.             }
112.  
113.             Profiler.EndSample();
114.          
115.             _currentFrame++;
116.         }
117.     }
118.  
119.     private void OnDestroy()
120.     {
121.         smmalloc.DestroyThreadCache();
122.         smmalloc.Dispose();
123.     }
124. }

The smmalloc and marshal both can be used for unknown lifetime, so they should be compared to Persistent unity allocator.

 

Bump.

Is there any more information regarding these questions? Both regarding picking the inbuilt TLSF allocator over tcmalloc/jemalloc/smmalloc and also regarding locks in the allocator.