Cacheline contention

I'm running multiple jobs in parallel which share a NativeArray and each job stores a unique index it can read/write to. Is it worth ensuring one item per cacheline to avoid invalidating that line?

I ask because I noticed in the NativeHashMap source they're using an IntsPerCacheLine value throughout. I haven't looked in detail but seems to be used for cacheline per thread data which I assume is to avoid contention.

Spoiler

Code (CSharp):

1. struct ComputeData {
2.     Entity entity;
3.     float mass;
4. }
5.  
6. Job : IJob {
7.     int writeIndex;
8.     [NativeDisableContainerSafetyRestriction]
9.     NativeArray<ComputeData> sharedData;
10.  
11.     void Execute() {
12.         // ... do something
13.         sharedData[writeIndex] = new ComputeData {..};
14.     }
15. }
16.  
17. void OnUpdate() {
18.     var sharedData = new NativeArray<ComputeData>(numJobs, Allocator.TempJob);
19.  
20.     for (int i = 0; i < numJobs; i++)
21.     {
22.         new Job {
23.             writeIndex = i,
24.             sharedData = sharedData
25.         }.Schedule(inputDeps)
26.     }
27.     ...
28. }

 

Ok thankyou.

My next question then would be are NativeArray allocations cacheline aligned by default?

- Edit - Not the component ones in chunks, the ones we allocate ourselves. I.e.
var array = new NativeArray<int>(Allocator.TempJob)