Question Understanding profiler information

ATMLVE · Aug 25, 2023

I'm working on optimizing the terrain generation of a procedural planet system. It uses LOD quadtrees so the meshes are frequently updated. Main questions are bolded. I'll post the jobs code below, but for now I'm more looking for conceptual help to get leads to follow.

I've implemented a job system to calculate each vertex's position, as my original method was so slow. It's still slow now but I'm trying to interpret what the profiler is telling me.

Below is what the profiler looks like on a heavy frame when I'm recalculating everything, I do have settings higher than I'd like in order to see what's really chewing memory:

In the middle section, the main thread, the big blocks of functions labeled amidst all the color are mostly job stuff like JobHandle, WaitForJobGroupID, but also garbage collection. Why would the jobs not actually running in here? I see the large garbage collection and I realize it's pretty brutal to run this many jobs as each one needs an array. Because it's running quads, each quad has a set number of vertices depending on it's detail level so I think I should be able to re-use the same native array many times, is that the case and would that help? I've worked some with lists and arrays and know instantiating tons of arrays is generally a big no-no.

In either case, each block not running my little batches of jobs is either empty or full of blue script job stuff.

Another question is down below I see 10 workers, but why is only worker 2 doing anything and why is it doing it so choppily? Below is a zoomed-in section of an arbitrary point:

Is there theoretically a way my code could be factored such that all those little blocks of yellowbrown on worker2 could be run successively and across several more threads, or am I misunderstanding what I should be able to accomplish?

The code that runs the job, once per every single quad:

Code (CSharp):

var vertexArray = new Unity.Collections.NativeArray<Vector3>(vertices, Unity.Collections.Allocator.TempJob);

var job = new EvaluateVertexPointJob

{

jobVertices = vertexArray,

transformMatrix = transformMatrix,

quadIndex = quadIndex,

planetSize = 50

};

var jobHandle = job.Schedule(vertices.Length, vertices.Length);

jobHandle.Complete();

vertexArray.CopyTo(vertices);

vertexArray.Dispose();

The code for the job only is below. Self-conscious disclaimer, I didn't write most of this, and a lot it has been mercilessly butchered just to make the code do the math it should be doing and output something without errors. I refactored the several different scripts I had and squashed them all into one supermonster with complicated references replaced by hardcoded placeholders just to see if I could get anything out of it.

Code (CSharp):

using System;

using Unity.Collections;

using Unity.Jobs;

using Unity.Mathematics;

using UnityEngine;

public struct EvaluateVertexPointJob : IJobParallelFor

{

public NativeArray<Vector3> jobVertices;

public Matrix4x4 transformMatrix;

public int quadIndex;

public float planetSize;

public void Execute(int i)

{

var pointOnCube = transformMatrix.MultiplyPoint(Presets.quadTemplateVertices[quadIndex][i]);

var pointOnUnitSphere = pointOnCube.normalized * planetSize;

//Debug.Log("int i = " + i);

//Debug.Log("jobVertices.Length = " + jobVertices.Length);

int[] Source = {

151, 160, 137, 91, 90, 15, 131, 13, 201, 95, 96, 53, 194, 233, 7, 225, 140, 36, 103, 30, 69, 142,

8, 99, 37, 240, 21, 10, 23, 190, 6, 148, 247, 120, 234, 75, 0, 26, 197, 62, 94, 252, 219, 203,

117, 35, 11, 32, 57, 177, 33, 88, 237, 149, 56, 87, 174, 20, 125, 136, 171, 168, 68, 175, 74, 165,

71, 134, 139, 48, 27, 166, 77, 146, 158, 231, 83, 111, 229, 122, 60, 211, 133, 230, 220, 105, 92, 41,

55, 46, 245, 40, 244, 102, 143, 54, 65, 25, 63, 161, 1, 216, 80, 73, 209, 76, 132, 187, 208, 89,

18, 169, 200, 196, 135, 130, 116, 188, 159, 86, 164, 100, 109, 198, 173, 186, 3, 64, 52, 217, 226, 250,

124, 123, 5, 202, 38, 147, 118, 126, 255, 82, 85, 212, 207, 206, 59, 227, 47, 16, 58, 17, 182, 189,

28, 42, 223, 183, 170, 213, 119, 248, 152, 2, 44, 154, 163, 70, 221, 153, 101, 155, 167, 43, 172, 9,

129, 22, 39, 253, 19, 98, 108, 110, 79, 113, 224, 232, 178, 185, 112, 104, 218, 246, 97, 228, 251, 34,

242, 193, 238, 210, 144, 12, 191, 179, 162, 241, 81, 51, 145, 235, 249, 14, 239, 107, 49, 192, 214, 31,

181, 199, 106, 157, 184, 84, 204, 176, 115, 121, 50, 45, 127, 4, 150, 254, 138, 236, 205, 93, 222, 114,

67, 29, 24, 72, 243, 141, 128, 195, 78, 66, 215, 61, 156, 180

};

const int RandomSize = 256;

const double Sqrt3 = 1.7320508075688772935;

const double Sqrt5 = 2.2360679774997896964;

int[] _random;

/// Skewing and unskewing factors for 2D, 3D and 4D,

/// some of them pre-multiplied.

const double F2 = 0.5 * (Sqrt3 - 1.0);

const double G2 = (3.0 - Sqrt3) / 6.0;

const double G22 = G2 * 2.0 - 1;

const double F3 = 1.0 / 3.0;

const double G3 = 1.0 / 6.0;

const double F4 = (Sqrt5 - 1.0) / 4.0;

const double G4 = (5.0 - Sqrt5) / 20.0;

const double G42 = G4 * 2.0;

const double G43 = G4 * 3.0;

const double G44 = G4 * 4.0 - 1.0;

/// <summary>

/// Gradient vectors for 3D (pointing to mid points of all edges of a unit

/// cube)

/// </summary>

//Debug.Log("jobVertices.Length = "+jobVertices.Length);

//Debug.Log("i = "+i);

if (i < jobVertices.Length && i > 1)

{

jobVertices[i] = CalculatePointOnPlanet(pointOnUnitSphere, planetSize);

}

Vector3 CalculatePointOnPlanet(Vector3 pointOnUnitSphere, float planetRadius)

{

float firstLayerValue; // store the first layer outside the main for loop so that it can be used for subsequent layers

float elevation;

firstLayerValue = EvaluateSimpleNoise(pointOnUnitSphere); // this does what the main for loop below does, just separately to be stored separately

elevation = firstLayerValue;

return (1 + elevation) * planetRadius * pointOnUnitSphere;

}

float EvaluateSimpleNoise(Vector3 point)

{

float noiseValue = 0;

float frequency = 0.2f;

float amplitude = 1;

// this code iterates layers of noise on top of each other. It starts by defining a placeholder variable v for iteration.

// v takes the current point of the unit sphere, multiplys by frequency and the offset within the noise, then evaluates that point within the noise function to get a height.

// that height, from -1 to 1, is converted to a value of 0 to 1, then multiplied by amplitude.

for (int j = 0; j < 2; j++)

{

float v = Evaluate(point * frequency);

noiseValue += (v + 1) * 0.5f * amplitude;

frequency *= 0.2f; // when roughness is greater than 1, the frequency will increase with each filter, adding finer detail (I think)

amplitude *= 0.2f; // amplitude is a modififer assigned to each point. When persistence is less than 1, the amplitude decreases with each layer.

/// <summary>

/// Generates value, typically in range [-1, 1]

/// </summary>

float Evaluate(UnityEngine.Vector3 point)

{

Randomize(0);

int[][] Grad3 =

{

new[] {1, 1, 0}, new[] {-1, 1, 0}, new[] {1, -1, 0},

new[] {-1, -1, 0}, new[] {1, 0, 1}, new[] {-1, 0, 1},

new[] {1, 0, -1}, new[] {-1, 0, -1}, new[] {0, 1, 1},

new[] {0, -1, 1}, new[] {0, 1, -1}, new[] {0, -1, -1}

};

double x = point.x;

double y = point.y;

double z = point.z;

double n0 = 0, n1 = 0, n2 = 0, n3 = 0;

// Noise contributions from the four corners

// Skew the input space to determine which simplex cell we're in

double s = (x + y + z) * F3;

// for 3D

int i = FastFloor(x + s);

int j = FastFloor(y + s);

int k = FastFloor(z + s);

double t = (i + j + k) * G3;

// The x,y,z distances from the cell origin

double x0 = x - (i - t);

double y0 = y - (j - t);

double z0 = z - (k - t);

// For the 3D case, the simplex shape is a slightly irregular tetrahedron.

// Determine which simplex we are in.

// Offsets for second corner of simplex in (i,j,k)

int i1, j1, k1;

// coords

int i2, j2, k2; // Offsets for third corner of simplex in (i,j,k) coords

if (x0 >= y0)

{

if (y0 >= z0)

{

// X Y Z order

i1 = 1;

j1 = 0;

k1 = 0;

i2 = 1;

j2 = 1;

k2 = 0;

}

else if (x0 >= z0)

{

// X Z Y order

i1 = 1;

j1 = 0;

k1 = 0;

i2 = 1;

j2 = 0;

k2 = 1;

}

else

{

// Z X Y order

i1 = 0;

j1 = 0;

k1 = 1;

i2 = 1;

j2 = 0;

k2 = 1;

}

}

else

{

// x0 < y0

if (y0 < z0)

{

// Z Y X order

i1 = 0;

j1 = 0;

k1 = 1;

i2 = 0;

j2 = 1;

k2 = 1;

}

else if (x0 < z0)

{

// Y Z X order

i1 = 0;

j1 = 1;

k1 = 0;

i2 = 0;

j2 = 1;

k2 = 1;

}

else

{

// Y X Z order

i1 = 0;

j1 = 1;

k1 = 0;

i2 = 1;

j2 = 1;

k2 = 0;

}

}

// A step of (1,0,0) in (i,j,k) means a step of (1-c,-c,-c) in (x,y,z),

// a step of (0,1,0) in (i,j,k) means a step of (-c,1-c,-c) in (x,y,z),

// and

// a step of (0,0,1) in (i,j,k) means a step of (-c,-c,1-c) in (x,y,z),

// where c = 1/6.

// Offsets for second corner in (x,y,z) coords

double x1 = x0 - i1 + G3;

double y1 = y0 - j1 + G3;

double z1 = z0 - k1 + G3;

// Offsets for third corner in (x,y,z)

double x2 = x0 - i2 + F3;

double y2 = y0 - j2 + F3;

double z2 = z0 - k2 + F3;

// Offsets for last corner in (x,y,z)

double x3 = x0 - 0.5;

double y3 = y0 - 0.5;

double z3 = z0 - 0.5;

// Work out the hashed gradient indices of the four simplex corners

int ii = i & 0xff;

int jj = j & 0xff;

int kk = k & 0xff;

// Calculate the contribution from the four corners

double t0 = 0.6 - x0 * x0 - y0 * y0 - z0 * z0;

if (t0 > 0)

{

t0 *= t0;

int gi0 = _random[ii + _random[jj + _random[kk]]] % 12;

n0 = t0 * t0 * Dot(Grad3[gi0], x0, y0, z0);

}

double t1 = 0.6 - x1 * x1 - y1 * y1 - z1 * z1;

if (t1 > 0)

{

t1 *= t1;

int gi1 = _random[ii + i1 + _random[jj + j1 + _random[kk + k1]]] % 12;

n1 = t1 * t1 * Dot(Grad3[gi1], x1, y1, z1);

}

double t2 = 0.6 - x2 * x2 - y2 * y2 - z2 * z2;

if (t2 > 0)

{

t2 *= t2;

int gi2 = _random[ii + i2 + _random[jj + j2 + _random[kk + k2]]] % 12;

n2 = t2 * t2 * Dot(Grad3[gi2], x2, y2, z2);

}

double t3 = 0.6 - x3 * x3 - y3 * y3 - z3 * z3;

if (t3 > 0)

{

t3 *= t3;

int gi3 = _random[ii + 1 + _random[jj + 1 + _random[kk + 1]]] % 12;

n3 = t3 * t3 * Dot(Grad3[gi3], x3, y3, z3);

}

// Add contributions from each corner to get the final noise value.

// The result is scaled to stay just inside [-1,1]

return (float)(n0 + n1 + n2 + n3) * 32;

}

void Randomize(int seed)

{

_random = new int[RandomSize * 2];

if (seed != 0)

{

// Shuffle the array using the given seed

// Unpack the seed into 4 bytes then perform a bitwise XOR operation

// with each byte

var F = new byte[4];

UnpackLittleUint32(seed, ref F);

for (int i = 0; i < Source.Length; i++)

{

_random[i] = Source[i] ^ F[0];

_random[i] ^= F[1];

_random[i] ^= F[2];

_random[i] ^= F[3];

_random[i + RandomSize] = _random[i];

}

}

else

{

for (int i = 0; i < RandomSize; i++)

_random[i + RandomSize] = _random[i] = Source[i];

}

}

double Dot(int[] g, double x, double y, double z)

{

return g[0] * x + g[1] * y + g[2] * z;

}

static int FastFloor(double x)

{

return x >= 0 ? (int)x : (int)x - 1;

}

/// <summary>

/// Unpack the given integer (int32) to an array of 4 bytes in little endian format.

/// If the length of the buffer is too smal, it wil be resized.

/// </summary>

/// <param name="value">The value.</param>

/// <param name="buffer">The output buffer.</param>

static byte[] UnpackLittleUint32(int value, ref byte[] buffer)

{

if (buffer.Length < 4)

Array.Resize(ref buffer, 4);

buffer[0] = (byte)(value & 0x00ff);

buffer[1] = (byte)((value & 0xff00) >> 8);

buffer[2] = (byte)((value & 0x00ff0000) >> 16);

buffer[3] = (byte)((value & 0xff000000) >> 24);

return buffer;

}

}

noiseValue = Mathf.Max(0, noiseValue) * 0.03f;

return noiseValue;

}

}

Oh and here's what the hierarchy looks like on this frame but I don't know if this is of use:

Per-Morten · Aug 25, 2023

So, I didn't dive super deep into your code, but I'll give you some headers about stuff that you should look at because it looks suspicious.

In your randomize function (which according to the hierarchy view is the one that's taking the most time), you're allocating a lot of memory (see the GC Allocs column in hierachy view). You're allocating 256 ints per call to random, and you're always giving in the same seed. Either preallocate and fill that array beforehand, or create buffer's that the jobs can reuse. Same with Source and Grad3.

Your lambdas/local functions should also be static, with all their arguments sent in to them, otherwise C# will heap allocate space for you to store the implicitly captured variables in (more GC allocs).

You should see a speed-up once you've gotten rid of all your GC allocations. At that point you should also be able to use burst on the job, which will net you an even greater speed up.

Regarding why you're only using 1 thread, could that be because when you schedule you're scheduling with a batch size of vertices.Length. Does it improve if you change your schedule call to: job.Schedule(vertices.Length, 1); ?

Also, if you enable callstack on memory in the profiler, you can see where memory is allocated from in the timeline view. That makes it easier to hunt down what your memory allocations are.

CodeSmile · Aug 25, 2023

Copy that about the inline functions. Those should be static. And you definitely should not allocate that "Source" array in each execute, make that static too! In fact, make it a native array to avoid the GC altogether.

If you want to do Burst a favor, be consistent and replace all the managed [] arrays with native collection types. The same goes for math types - don't use Vector3 in a bursted job, use the float3 from the Unity.Mathematics package, and the same goes for all math operations (Mathf.Max() => math.max()). And specifically that random! Why did you make your own in the first place? Could you use just any kind of random? If so, use math.random over yours, especially since yours may call Resize on the array.

Same goes for "FastFloor" and "Dot" - try replacing them with the appropriate math functions and check which is faster. Even though they may very well be faster than the Mathf and Vector3 implementations, chances are high that the (burstable) Mathematics implementations of these methods put yours to shame.

But the most performance critical aspect could easily be this:

Code (CSharp):

var jobHandle = job.Schedule(vertices.Length, vertices.Length);

jobHandle.Complete();

You are starting background jobs and force them to complete immediately. Instead, you should aim to schedule the jobs and either monitor the job handle for completion if you can delay receiving the results a couple frames later. If you need the results within the same frame, schedule in Update() and call Complete() in LateUpdate() to allow for (hopefully ample) time for the jobs to complete in the background while other main thread Update() calls are running.

ATMLVE · Aug 25, 2023

Thanks all for your help! I've implemented some of your suggestions to an extent and already seen a good bit of improvement. You were exactly right on my batch size, I have everything running on all ten threads now. I've made everything static too.

To answer the the bit about things like Source and _random, those come from a noise script that I didn't write but I also hardcoded some things just to make it run (hence why for instance it's generating the same random numbers every time). For real optimization there I'll need to dive into that on my own sometime.

The profiler now looks quite a bit different, but I'm even more confused on what it's telling me. Right now the hierarchy says a huge chunk of time is spent just waiting:

Why does that not appear to be evident in the timeline? It still seems like it's doing something constantly - the idle gaps in the main thread are full across all the job threads:

Per-Morten · Aug 25, 2023

ATMLVE said: ↑

Thanks all for your help! I've implemented some of your suggestions to an extent and already seen a good bit of improvement. You were exactly right on my batch size, I have everything running on all ten threads now. I've made everything static too.

To answer the the bit about things like Source and _random, those come from a noise script that I didn't write but I also hardcoded some things just to make it run (hence why for instance it's generating the same random numbers every time). For real optimization there I'll need to dive into that on my own sometime.
Click to expand...

I would be surprised if you actually needed to do that much optimization after you get rid of the final GC allocations and begin to use burst. That thing is a beast, and can easily give 10x perf improvements just by enabling it on a job. Obviously, if you need to optimize further, then there's probably stuff you can do, but in my experience, just enabling burst solves 98% of my performance problems.

ATMLVE said: ↑

The profiler now looks quite a bit different, but I'm even more confused on what it's telling me. Right now the hierarchy says a huge chunk of time is spent just waiting:

Why does that not appear to be evident in the timeline? It still seems like it's doing something constantly - the idle gaps in the main thread are full across all the job threads:

Click to expand...

The hierarchy window only shows you the hierarchy of one thread at the time, and the default thread is the main thread. You see in the timeline that the main thread is idling 11 times, around 250ms each time, 250ms * 11 = 2750ms = ~2802ms which is the time the main thread is reported to be idling in the hierarchy window.

ATMLVE · Aug 25, 2023

I believe I got rid of a lot of the GC allocations. Unfortunately when I try and implement [BurstCompile] I get array index out of bounds exceptions. This doesn't make sense to me from my experience since all the other code is identical and works without it. Is there anything about burst compiling that could be the reason why for me to look into?

CodeSmile · Aug 26, 2023

Since you use a parallel job, the index passed into Execute is the one you are supposed to use for your arrays and none other, You can however disable this check with an attribute whose name I can‘t recall, I think NativeDisableParallelForRestriction which goes on the array fields.

Note that in that case you are responsible for ensuring that there won‘t be any (read/write) race conditions where at times one thread may write an index before another reads it, and other times it‘s the other way around, leading to different results.

Burst is really worth any extra refactoring you may need to do!

Per-Morten · Aug 26, 2023

NativeDisableParallelForRestriction sounds like the correct one yeah, but I thought that would trigger also if you didn't use burst?

A quick way to check if it's that is also to temporarily turn off the various burst safety systems. Like the jobsdebugger, and burst safety checks (note, you should turn these back on when you've done investigating, they're really helpful for catching errors).

ATMLVE · Aug 27, 2023

CodeSmile said: ↑

... the index passed into Execute is the one you are supposed to use for your arrays and none other ...
Click to expand...

This was my issue. I was using a Vector3[ ][ ] in the job, passing in a value for the first index to get it's array. That second index is already looping through the main iterator i, so I just assigned the first vector to a native array and passed it into the job and it worked. And oh my goodness you weren't kidding, it runs like lightning and there's still optimizing to do.

This is definitely cases solved for now, although to get this to work I tore my code apart, now I have to build everything back up again. I may run into more finnicky errors like this iterator issue, if so I'll be back. Thanks all here for your help.

ATMLVE · Aug 31, 2023

Progress update, I've refactored everything to work with jobs and results are very nice.

My main loop that runs once per second, before and after jobs/burst:

GC allocation is still up a bit but the actual lag is way down. At lower terrain resolutions the hitch is imperceptible. One major issue is there is a memory leak, so performance gets worse over time but I still have to hunt that down.

These are my surface normals jobs:

Code (CSharp):

using Unity.Burst;

using Unity.Collections;

using Unity.Jobs;

using Unity.VisualScripting;

using UnityEngine;

[BurstCompile]

public struct SurfaceNormalsJob : IJobParallelFor

{

public NativeArray<int> jobTrianglesA;

public NativeArray<int> jobTrianglesB;

public NativeArray<int> jobTrianglesC;

public NativeArray<Vector3> jobPointA;

public NativeArray<Vector3> jobPointB;

public NativeArray<Vector3> jobPointC;

public NativeArray<int> jobEdgeFansVertexIndicesA;

public NativeArray<int> jobEdgeFansVertexIndicesB;

public NativeArray<int> jobEdgeFansVertexIndicesC;

public NativeArray<Vector3> jobNormals;

public void Execute(int i) // i loops through the vertices

{

Vector3 triangleNormal = SurfaceNormalFromIndices(jobPointA[i], jobPointB[i], jobPointC[i]); // calculate the normal of this triangle

// Explanation with previous code

{

// This would check if the edgefansIndices entry at the index of the first vertex of the triangle was 0 (aka if the vertex was inside the chunk and not at the edge)

// If it was, then we would just grab the normals' index at that vertex, and apply the normal to that vertex.

// However within this burst compile job, I cannot access whatever index I want from normals,

// so instead below, I take the extra step to check if the current iterator i is equal to the vertex currently being considered. If it is, I apply it.

// An issue with this method though is that it doesn't work.

//if (edgefansIndices[vertexIndexA] == 0) edgefansVertexIndicesA[i] = edgefansIndices[vertexIndexA];

//{

// normals[vertexIndexA] += triangleNormal;

//}

//if (edgefansIndices[vertexIndexB] == 0)

//{

// normals[vertexIndexB] += triangleNormal;

//}

//if (edgefansIndices[vertexIndexC] == 0)

//{

// normals[vertexIndexC] += triangleNormal;

//}

}

if (jobEdgeFansVertexIndicesA[i] == 0)

{

jobNormals[jobTrianglesA[i]] += triangleNormal;

}

if (jobEdgeFansVertexIndicesB[i] == 0)

{

jobNormals[jobTrianglesB[i]] += triangleNormal;

}

if (jobEdgeFansVertexIndicesC[i] == 0)

{

jobNormals[jobTrianglesC[i]] += triangleNormal;

}

static Vector3 SurfaceNormalFromIndices(Vector3 jobPointA, Vector3 jobPointB, Vector3 jobPointC)

{

// Get an aproximation of the vertex normal using two other vertices that share the same triangle

Vector3 sideAB = jobPointB - jobPointA;

Vector3 sideAC = jobPointC - jobPointA;

Vector3 side = Vector3.Cross(sideAB, sideAC);

return side.normalized;

}

}

}

public struct SurfaceBorderNormalsJobBorder : IJobParallelFor

{

public NativeArray<int> jobTrianglesA;

public NativeArray<int> jobTrianglesB;

public NativeArray<int> jobTrianglesC;

public NativeArray<Vector3> jobPointA;

public NativeArray<Vector3> jobPointB;

public NativeArray<Vector3> jobPointC;

public int quadRes;

public NativeArray<Vector3> jobNormals;

public void Execute(int i) // i loops through the vertices

{

if (i < jobTrianglesA.Length)

{

int vertexIndexA = jobTrianglesA[i];

int vertexIndexB = jobTrianglesB[i];

int vertexIndexC = jobTrianglesC[i];

Vector3 triangleNormal = SurfaceNormalFromIndices(jobPointA[i], jobPointB[i], jobPointC[i]); // calculate the normal of this triangle

// Previous code

{

// This would check if the edgefansIndices entry at the index of the first vertex of the triangle was 0 (aka if the vertex was inside the chunk and not at the edge)

// If it was, then we would just grab the normals' index at that vertex, and apply the normal to that vertex.

// However within this burst compile job, I cannot access whatever index I want from normals,

// so instead below, I take the extra step to check if the current iterator i is equal to the vertex currently being considered. If it is, I apply it.

// An issue with this method though is that it doesn't work.

//if (edgefansIndices[vertexIndexA] == 0) edgefansVertexIndicesA[i] = edgefansIndices[vertexIndexA];

//{

// normals[vertexIndexA] += triangleNormal;

//}

//if (edgefansIndices[vertexIndexB] == 0)

//{

// normals[vertexIndexB] += triangleNormal;

//}

//if (edgefansIndices[vertexIndexC] == 0)

//{

// normals[vertexIndexC] += triangleNormal;

//}

}

if (vertexIndexA >= 0 && (vertexIndexA % (quadRes + 1) == 0 ||

vertexIndexA % (quadRes + 1) == quadRes ||

(vertexIndexA >= 0 && vertexIndexA <= quadRes) ||

(vertexIndexA >= (quadRes + 1) * quadRes && vertexIndexA < (quadRes + 1) * (quadRes + 1))))

{

jobNormals[jobTrianglesA[i]] += triangleNormal;

}

if (vertexIndexB >= 0 && (vertexIndexB % (quadRes + 1) == 0 ||

vertexIndexB % (quadRes + 1) == quadRes ||

(vertexIndexB >= 0 && vertexIndexB <= quadRes) ||

(vertexIndexB >= (quadRes + 1) * quadRes && vertexIndexB < (quadRes + 1) * (quadRes + 1))))

{

jobNormals[jobTrianglesB[i]] += triangleNormal;

}

if (vertexIndexC >= 0 && (vertexIndexC % (quadRes + 1) == 0 ||

vertexIndexC % (quadRes + 1) == quadRes ||

(vertexIndexC >= 0 && vertexIndexC <= quadRes) ||

(vertexIndexC >= (quadRes + 1) * quadRes && vertexIndexC < (quadRes + 1) * (quadRes + 1))))

{

jobNormals[jobTrianglesC[i]] += triangleNormal;

}

static Vector3 SurfaceNormalFromIndices(Vector3 jobPointA, Vector3 jobPointB, Vector3 jobPointC)

{

// Get an aproximation of the vertex normal using two other vertices that share the same triangle

Vector3 sideAB = jobPointB - jobPointA;

Vector3 sideAC = jobPointC - jobPointA;

Vector3 side = Vector3.Cross(sideAB, sideAC);

return side.normalized;

}

}

}

}

Per-Morten · Sep 1, 2023

Quick note, you haven't burst compiled your SurfaceBorderNormalsJobBorder. An easy way to check if a job is burst compiled (without checking the code obviously) is to check the timeline view in the profiler and see if that job has a greenish tint.

Also, now that you've gotten your code a bit more under control you can change your math to using unity mathematics. You can use NativeArray.Reinterpret<float3>() to translate from the vector3 arrays.

Don't have that much else to say without seeing the surrounding code. Also, regarding the memory leak, if it's a memory leak from the NativeArray's you can check where it's allocated from by using the Show Full Stack Traces:

ATMLVE · Sep 1, 2023

Per-Morten said: ↑

Quick note, you haven't burst compiled your SurfaceBorderNormalsJobBorder. An easy way to check if a job is burst compiled (without checking the code obviously) is to check the timeline view in the profiler and see if that job has a greenish tint.

Also, now that you've gotten your code a bit more under control you can change your math to using unity mathematics. You can use NativeArray.Reinterpret<float3>() to translate from the vector3 arrays.

Don't have that much else to say without seeing the surrounding code. Also, regarding the memory leak, if it's a memory leak from the NativeArray's you can check where it's allocated from by using the Show Full Stack Traces:

View attachment 1296687
Click to expand...

Thanks for your reply. I'd originally tried putting [BurstCompile] down there and it said I only needed it once on the page, but I'm clearly misremembering as I did try later and it worked. The snippet I posted is using burst compile for all jobs. As for the memory leak, that was silly simple, I just wasn't disposing of some arrays I wasn't even using.

For the math, can you direct me towards some info on specifically what you mean? And are you saying to use NativeArray.Reinterpret<float3>() on my allocated native arrays and it'll make the jobs run faster?

ATMLVE · Sep 1, 2023

I have another question. So I have a monobehevior script that generates a bunch of arrays, once, and then it's done.

Then on my once-per-second update, I check which chunks I need to update and do all this code I've been working on here, and by far the largest performance hit for me right now is allocating my native arrays for the jobs. What I'm doing is taking those original monobehevior arrays and allocating native arrays from them for every chunk I need to generate or update.

Can I boost my performance by making those initial arrays native arrays from the getgo, and then making copies of them? Would that not help since I'm still allocating a new native array in either case? And if that's the case, is there anything else I can do for this use case?

Per-Morten · Sep 3, 2023

ATMLVE said: ↑

For the math, can you direct me towards some info on specifically what you mean? And are you saying to use NativeArray.Reinterpret<float3>() on my allocated native arrays and it'll make the jobs run faster?
Click to expand...

If you change all the places you use Vector3 in your jobs to float3, and change your math functions to use Unity.Mathematics.math, then you might see a speed improvement. However, when you change your job NativeArray<Vector3> 'input parameters' to NativeArray<float3> you'll probably get a compiler error at the place where you assign them. However, at that place you can do NativeArray.Reinterpret<float3>. Here's an example:

Code (CSharp):

void Update()

{

var myVector3Array = new NativeArray<Vector3>(N, Allocator.TempJob);

new MyFloat3Job

{

MyFloat3Array = myVector3Array.Reinterpret<float3>()

}

.Schedule();

// ...

}

[BurstCompile]

struct MyFloat3Job

: IJob

{

public NativeArray<float3> MyFloat3Array;

// ...

}

Note, be a bit careful with NativeArray.Reinterpret as it's reinterpreting the underlying memory. In my experience it's no problem to reinterpret from Vector3 to float3 (or visa versa), but if you're reinterpreting between other types you need to ensure that the types match what you expect. Also, a better alternative is to make your NativeArray<float3> from the start if that's an option for you.

ATMLVE said: ↑

Can I boost my performance by making those initial arrays native arrays from the getgo, and then making copies of them? Would that not help since I'm still allocating a new native array in either case? And if that's the case, is there anything else I can do for this use case?
Click to expand...

Hard to say without more info, but in general, pre-allocating and reusing memory is good. Also, do you need to make copies of your arrays?

ATMLVE · Sep 6, 2023

Thank you, after some necessary changes I'm now sitting waiting for jobs again so my work isn't nearly done. In a similar vein, how can I use the same NativeArray across multiple jobs at once? I have an array that I initialize as readonly that I only need information from for the job, I do not write to it. But no matter what I try I get the same error, "The previously scheduled job A writes to the Unity.Collections.NativeArray`1[System.Int32] B"

Also for my jobs, I'm creating empty native arrays to put into the job which fills them with values and outputs that. Is that sort of thing a 'correct practice' or do I have the wrong idea?

ATMLVE · Sep 7, 2023

Sorry for the double post but let me lay out my example:

I have a large terrain mesh made of many chunks for the LOD system. As the player moves, they cause small chunks to be deleted and new smaller chunks to be created for the LOD system: every second, the code checks if any chunks should be updated and updates them as needed (In a real scenario it would be based on how far the player moves - besides the point).

For my job, right now I have every chunk updating in series - I update all of one chunk, then the next chunk, then the next, etc. This is slow because every chunk needs its vertices calculated, then its triangles, then its normals. It was actually fine before doing it this way, but after reintegrating noise calculation and optimizing everything else so much, the time it takes to calculate the vertices is now a huge bottleneck (at least I think that's what this is displaying):

Here below is my vertices job scheduler with comments. There is a lot that goes into the job but most of it is actually hardcoded stuff. I would love to schedule all of these at once, then complete them all once they're all started. The problem is I can't do that with NativeArrays because of the issue in my last post. Even though the only thing at all that I'm actually modifying is jobVertices, which starts out blank in the first place and seems so silly I need to even create an array and pass it in for that purpose in the first place. Every other array I only need to read, not write to.

Code (CSharp):

public void StartVerticesJob()

{

vertexArray = new NativeArray<Vector3>(chunkVertices.Length, Allocator.TempJob);

vertexQuadArray = new NativeArray<Vector3>(Presets.quadTemplateVertices[quadIndex], Allocator.TempJob);

var verticesJob = new EvaluateVertexPointJob

{

jobVertices = vertexArray, // *always starts blank

jobQuadTemplateVertices = vertexQuadArray, // array that is set per chunk of vertices and is one of 16 arrays for every job. Could have the entire thing one array, and just tell job which area to look at

transformMatrix = transformMatrix, // variable that depends on chunk position - I believe what ultimately determines where in the unit cube these vertices are

_random = terrainFace.planetScript._random, // *hardcoded array

Source = terrainFace.planetScript.Source, // *hardcoded array

Grad3 = terrainFace.planetScript.Grad3, // *hardcoded array

noiseFilterValues = terrainFace.noiseFilterValues,// *hardcoded array of the noise filter values, would be static during real gameplay

planetSize = terrainFace.planetScript.planetSize, // *hardcoded variable

valueCount = terrainFace.noiseFilterValuesCount // *hardcoded variable

};

jobHandlerVertices = verticesJob.Schedule(Mathf.Max(chunkVertices.Length, terrainFace.planetScript._random.Length), 512);

}

This is the actual job, the 3D noise calculator. I haven't converted anything to float3 / unity.mathematics yet:

Code (CSharp):

using System;

using Unity.Collections;

using Unity.Jobs;

using Unity.Mathematics;

using UnityEngine;

using Unity.Burst;

[BurstCompile]

public struct EvaluateVertexPointJob : IJobParallelFor

{

public NativeArray<Vector3> jobVertices;

[ReadOnly] public NativeArray<Vector3> jobQuadTemplateVertices;

public Matrix4x4 transformMatrix;

public float planetSize;

[ReadOnly] public NativeArray<float> noiseFilterValues;

public int valueCount;

[ReadOnly] public NativeArray<int> Source;

[ReadOnly] public NativeArray<int> Grad3;

public NativeArray<int> _random;

public void Execute(int i)

{

if (i < jobVertices.Length)

{

var pointOnCube = transformMatrix.MultiplyPoint(jobQuadTemplateVertices[i]);

var pointOnUnitSphere = pointOnCube.normalized * planetSize;

const int RandomSize = 256;

/// Skewing and unskewing factors for 2D, 3D and 4D,

/// some of them pre-multiplied.

const double F3 = 1.0 / 3.0;

const double G3 = 1.0 / 6.0;

Randomize(0, _random, Source);

jobVertices[i] = CalculatePointOnPlanet(pointOnUnitSphere, planetSize, _random, Grad3, noiseFilterValues, valueCount);

static float3 CalculatePointOnPlanet(float3 pointOnUnitSphere, float planetRadius, NativeArray<int> _random, NativeArray<int> Grad3, NativeArray<float> noiseFilterValues, int valueCount)

{

float elevation = EvaluateSimpleNoise(pointOnUnitSphere, _random, Grad3, noiseFilterValues, valueCount); // this does what the main for loop below does, just separately to be stored separately

//if (noiseFilterValues[0] == 1)

//{

// // this below is a small if/else statement. If useFirstLayerAsMask is true, then mask takes the value of firstLayerValue,

// // which is the current iteration i but just on the first layer only. If not, then mask is set to 1 to give it no effect.

// //float mask = (noiseFilterValues[j].useFirstLayerAsMask) ? firstLayerValue : 1;

// elevation += EvaluateSimpleNoise(pointOnUnitSphere, _random, Grad3, noiseFilterValues);// * mask;

//}

return (1 + elevation) * planetRadius * pointOnUnitSphere;

}

static float EvaluateSimpleNoise(Vector3 point, NativeArray<int> _random, NativeArray<int> Grad3, NativeArray<float> noiseFilterValues, int valueCount)

{

float firstLayerValue = 1;

float elevation = 0;

float noiseValue = 0;

for (int k = 0; k < noiseFilterValues.Length / valueCount; k++) // starts at 1 because the first layer is store seperately

{

int n = 0;

int iterator = k * valueCount;

float layerEnabled = noiseFilterValues[iterator]; n++;

if (layerEnabled == 1)

{

float useFirstLayerAsMask = noiseFilterValues[iterator + n]; n++;

float numLayers = noiseFilterValues[iterator + n]; n++;

float noiseStrength = noiseFilterValues[iterator + n]; n++;

float baseRoughness = noiseFilterValues[iterator + n]; n++;

float noiseRoughness = noiseFilterValues[iterator + n]; n++;

float persistence = noiseFilterValues[iterator + n]; n++;

float minValue = noiseFilterValues[iterator + n]; n++;

float weight = noiseFilterValues[iterator + n];

Vector3 center = new Vector3(0, 0, 0);

noiseValue = 0;

float frequency = baseRoughness / 100;

float amplitude = 1;

// this code iterates layers of noise on top of each other. It starts by defining a placeholder variable v for iteration.

// v takes the current point of the unit sphere, multiplys by frequency and the offset within the noise, then evaluates that point within the noise function to get a height.

// that height, from -1 to 1, is converted to a value of 0 to 1, then multiplied by amplitude.

for (int j = 0; j < numLayers; j++)

{

float v = Evaluate((point * frequency) + center, _random, Grad3);

noiseValue += (v + 1) * 0.5f * amplitude;

frequency *= noiseRoughness / 50; // when roughness is greater than 1, the frequency will increase with each filter, adding finer detail (I think)

amplitude *= persistence / 50; // amplitude is a modififer assigned to each point. When persistence is less than 1, the amplitude decreases with each layer.

}

noiseValue = Mathf.Max(0, noiseValue - minValue) * noiseStrength / 100;

if (k == 0)

{

firstLayerValue = noiseValue;

}

else if (useFirstLayerAsMask == 1)

{

noiseValue = noiseValue * firstLayerValue;

}

}

elevation += noiseValue;

}

return elevation;

}

//static float EvaluateRigidNoise(Vector3 point, NativeArray<int> _random, NativeArray<int> Grad3)

//{

// float noiseValue = 0;

// float frequency = baseRoughness / 100;

// float amplitude = 1;

// weight = 1; // create a weight for detail

// // this code iterates layers of noise on top of each other. It starts by defining a placeholder variable v for iteration.

// // v takes the current point of the unit sphere, multiplys by frequency and the offset within the noise, then evaluates that point within the noise function to get a height.

// // that height, from -1 to 1, is converted to a value of 0 to 1, then multiplied by amplitude.

// for (int j = 0; j < numLayers; j++)

// {

// //for rigid noise, instead of converting -1to1 to 0to1, it takes the absolute value, subtracts it from 1, then increase it exponentially to get peakier values

// float v = 1 - Mathf.Abs(Evaluate((point * frequency) + center, _random, Grad3));

// v *= v;

// v *= weight; // weight and v should increase in detail the higher up they are. 2:30 in ep 04

// weight = Mathf.Clamp01(v * weight / 50); // multiply by the weight but ensure it stays between 0 and 1

// noiseValue += v * amplitude;

// frequency *= noiseRoughness; // when roughness is greater than 1, the frequency will increase with each filter, adding finer detail (I think)

// amplitude *= persistence; // amplitude is a modififer assigned to each point. When persistence is less than 1, the amplitude decreases with each layer.

// }

// noiseValue = Mathf.Max(0, noiseValue - minValue);

// return noiseValue * noiseStrength / 100;

//}

static float Evaluate(float3 point, NativeArray<int> _random, NativeArray<int> Grad3)

{

double x = point.x;

double y = point.y;

double z = point.z;

double n0 = 0, n1 = 0, n2 = 0, n3 = 0;

// Noise contributions from the four corners

// Skew the input space to determine which simplex cell we're in

double s = (x + y + z) * F3;

// for 3D

int i = FastFloor(x + s);

int j = FastFloor(y + s);

int k = FastFloor(z + s);

double t = (i + j + k) * G3;

// The x,y,z distances from the cell origin

double x0 = x - (i - t);

double y0 = y - (j - t);

double z0 = z - (k - t);

// For the 3D case, the simplex shape is a slightly irregular tetrahedron.

// Determine which simplex we are in.

// Offsets for second corner of simplex in (i,j,k)

int i1, j1, k1;

// coords

int i2, j2, k2; // Offsets for third corner of simplex in (i,j,k) coords

if (x0 >= y0)

{

if (y0 >= z0)

{

// X Y Z order

i1 = 1;

j1 = 0;

k1 = 0;

i2 = 1;

j2 = 1;

k2 = 0;

}

else if (x0 >= z0)

{

// X Z Y order

i1 = 1;

j1 = 0;

k1 = 0;

i2 = 1;

j2 = 0;

k2 = 1;

}

else

{

// Z X Y order

i1 = 0;

j1 = 0;

k1 = 1;

i2 = 1;

j2 = 0;

k2 = 1;

}

}

else

{

// x0 < y0

if (y0 < z0)

{

// Z Y X order

i1 = 0;

j1 = 0;

k1 = 1;

i2 = 0;

j2 = 1;

k2 = 1;

}

else if (x0 < z0)

{

// Y Z X order

i1 = 0;

j1 = 1;

k1 = 0;

i2 = 0;

j2 = 1;

k2 = 1;

}

else

{

// Y X Z order

i1 = 0;

j1 = 1;

k1 = 0;

i2 = 1;

j2 = 1;

k2 = 0;

}

}

// A step of (1,0,0) in (i,j,k) means a step of (1-c,-c,-c) in (x,y,z),

// a step of (0,1,0) in (i,j,k) means a step of (-c,1-c,-c) in (x,y,z),

// and

// a step of (0,0,1) in (i,j,k) means a step of (-c,-c,1-c) in (x,y,z),

// where c = 1/6.

// Offsets for second corner in (x,y,z) coords

double x1 = x0 - i1 + G3;

double y1 = y0 - j1 + G3;

double z1 = z0 - k1 + G3;

// Offsets for third corner in (x,y,z)

double x2 = x0 - i2 + F3;

double y2 = y0 - j2 + F3;

double z2 = z0 - k2 + F3;

// Offsets for last corner in (x,y,z)

double x3 = x0 - 0.5;

double y3 = y0 - 0.5;

double z3 = z0 - 0.5;

// Work out the hashed gradient indices of the four simplex corners

int ii = i & 0xff;

int jj = j & 0xff;

int kk = k & 0xff;

// Calculate the contribution from the four corners

double t0 = 0.6 - x0 * x0 - y0 * y0 - z0 * z0;

if (t0 > 0)

{

t0 *= t0;

int gi0 = _random[ii + _random[jj + _random[kk]]] % 12;

n0 = t0 * t0 * Dot(Grad3[gi0 * 3], Grad3[gi0 * 3 + 1], Grad3[gi0 * 3 + 2], x0, y0, z0);

}

double t1 = 0.6 - x1 * x1 - y1 * y1 - z1 * z1;

if (t1 > 0)

{

t1 *= t1;

int gi1 = _random[ii + i1 + _random[jj + j1 + _random[kk + k1]]] % 12;

n1 = t1 * t1 * Dot(Grad3[gi1 * 3], Grad3[gi1 * 3 + 1], Grad3[gi1 * 3 + 2], x1, y1, z1);

}

double t2 = 0.6 - x2 * x2 - y2 * y2 - z2 * z2;

if (t2 > 0)

{

t2 *= t2;

int gi2 = _random[ii + i2 + _random[jj + j2 + _random[kk + k2]]] % 12;

n2 = t2 * t2 * Dot(Grad3[gi2 * 3], Grad3[gi2 * 3 + 1], Grad3[gi2 * 3 + 2], x2, y2, z2);

}

double t3 = 0.6 - x3 * x3 - y3 * y3 - z3 * z3;

if (t3 > 0)

{

t3 *= t3;

int gi3 = _random[ii + 1 + _random[jj + 1 + _random[kk + 1]]] % 12;

n3 = t3 * t3 * Dot(Grad3[gi3 * 3], Grad3[gi3 * 3 + 1], Grad3[gi3 * 3 + 2], x3, y3, z3);

}

// Add contributions from each corner to get the final noise value.

// The result is scaled to stay just inside [-1,1]

return (float)(n0 + n1 + n2 + n3) * 32;

}

static void Randomize(int seed, NativeArray<int> _random, NativeArray<int> Source)

{

if (seed != 0)

{

// Shuffle the array using the given seed

// Unpack the seed into 4 bytes then perform a bitwise XOR operation

// with each byte

//var F = new byte[4];

//NativeArray<byte> F = new NativeArray<byte>(4, Allocator.TempJob);

//UnpackLittleUint32(seed, F);

byte buffer1 = (byte)(seed & 0x00ff);

byte buffer2 = (byte)((seed & 0xff00) >> 8);

byte buffer3 = (byte)((seed & 0x00ff0000) >> 16);

byte buffer4 = (byte)((seed & 0xff000000) >> 24);

for (int i = 0; i < Source.Length; i++)

{

_random[i] = Source[i] ^ buffer1;

_random[i] ^= buffer2;

_random[i] ^= buffer3;

_random[i] ^= buffer4;

_random[i + RandomSize] = _random[i];

}

}

else

{

for (int i = 0; i < RandomSize; i++)

_random[i + RandomSize] = _random[i] = Source[i];

}

}

static double Dot(int g0, int g1, int g2, double x, double y, double z)

{

return g0 * x + g1 * y + g2 * z;

}

static int FastFloor(double x)

{

return x >= 0 ? (int)x : (int)x - 1;

}

/// <summary>

/// Unpack the given integer (int32) to an array of 4 bytes in little endian format.

/// If the length of the buffer is too smal, it wil be resized.

/// </summary>

/// <param name="value">The value.</param>

/// <param name="buffer">The output buffer.</param>

//static NativeArray<byte> UnpackLittleUint32(int value, NativeArray<byte> buffer)

//{

// //if (buffer.Length < 4)

// // Array.Resize(ref buffer, 4);

// buffer[0] = (byte)(value & 0x00ff);

// buffer[1] = (byte)((value & 0xff00) >> 8);

// buffer[2] = (byte)((value & 0x00ff0000) >> 16);

// buffer[3] = (byte)((value & 0xff000000) >> 24);

// return buffer;

//}

}

}

}

Per-Morten · Sep 7, 2023

ATMLVE said: ↑

Thank you, after some necessary changes I'm now sitting waiting for jobs again so my work isn't nearly done. In a similar vein, how can I use the same NativeArray across multiple jobs at once? I have an array that I initialize as readonly that I only need information from for the job, I do not write to it. But no matter what I try I get the same error, "The previously scheduled job A writes to the Unity.Collections.NativeArray`1[System.Int32] B"
Click to expand...

I'll look into your posts a bit more deeply later. But to fix this error, add the [ReadOnly] attribute to the native arrays in your job that you're only reading from. Like this:

Code (CSharp):

[BurstCompile]

public struct EvaluateVertexPointJob

: IJobParallelFor

{

// ...

[ReadOnly]

public NativeArray<int> Source;

// ...

}

ATMLVE · Sep 7, 2023

Per-Morten said: ↑

I'll look into your posts a bit more deeply later. But to fix this error, add the [ReadOnly] attribute to the native arrays in your job that you're only reading from. Like this:

Code (CSharp):

[BurstCompile]

public struct EvaluateVertexPointJob

: IJobParallelFor

{

// ...

[ReadOnly]

public NativeArray<int> Source;

// ...

}

Click to expand...

Thanks, I swear I tried that and it didn't work. Which, whoops, I am actually writing to _random in there as well, I'll need to figure out how to fix that. I've updated my code in post #16 with the [ReadOnly]s.

Edit - If I have 100 little native arrays that I have to create, do stuff on, then copy to a main array (which I'm doing and shows up in the profiler) could it theoretically be better to have one giant array that I allocate and copy only once? Or is the hangup the total number of array entries being allocated/copied, and the amount of arrays those values are in is irrelevant?

Per-Morten · Sep 7, 2023

ATMLVE said: ↑

Thanks, I swear I tried that and it didn't work. Which, whoops, I am actually writing to _random in there as well, I'll need to figure out how to fix that. I've updated my code in post #16 with the [ReadOnly]s.

Edit - If I have 100 little native arrays that I have to create, do stuff on, then copy to a main array (which I'm doing and shows up in the profiler) could it theoretically be better to have one giant array that I allocate and copy only once? Or is the hangup the total number of array entries being allocated/copied, and the amount of arrays those values are in is irrelevant?
Click to expand...

Instead of copying, are you able to write directly to the main array, through NativeArray.GetSubArray for example?

Also, how many vertices do you normally have in a chunk?

It's still also a bit unclear to me what is actually debug code, and what's not in the EvaluateVertexPointJob. For instance, you still call Randomize with 0, is that just for debugging? Why do you do the i < jobVertices.Length, are you ever scheduling more "iterations" than jobVertices.Length?

Also, do you need those random numbers to be the same each time in Evaluate for the algorithm to function properly, or do you just need a random number? (if so, unity.mathematics.random is probably a better bet, then you don't need the array either). The noiseFilterValues, is that just a struct that you've put into multiple floats?
I'm not familiar with the problem you're working with at all, so these might be stupid questions, it's just the questions I'm asking myself when looking at your code.

If I were you now, I would dig more into what in the EvaluateVertexPointJob, that is taking time (if that's the job that is taking the most time). You can create your own profiler markers that you pass into the job. Like this:

Code (CSharp):

using Unity.Profiling;

public class MyClass

{

static readonly ProfilerMarker MyProfilerMarker = new ProfilerMarker("MyProfilerMarkerName");

void Update()

{

new MyJob

{

Marker = MyProfilerMarker

}.Schedule().Complete();

}

[BurstCompile]

public struct MyJob : IJob

{

public ProfilerMarker Marker;

public void Execute()

{

using var _ = Marker.Auto();

}

}

}

Create multiple markers for the different sections of your code that you want to profile. I would create a marker per static function you have in the EvaluateVertexPointJob.

ATMLVE · Sep 7, 2023

Per-Morten said: ↑

Instead of copying, are you able to write directly to the main array, through NativeArray.GetSubArray for example?
Click to expand...

No idea, I'll look into it!

Per-Morten said: ↑

I'm not familiar with the problem you're working with at all, so these might be stupid questions, it's just the questions I'm asking myself when looking at your code.
Click to expand...

That's fair, and since you asked them, I'm happy to answer. I just might learn something.

"Also, how many vertices do you normally have in a chunk?"
The resolution+1 squared. I've been doing my testing at a resolution of 16, so 289 vertices. It'd be nice to have that in real time but I can go as low as a resolution of 4 probably (so only 25 vertices). At a reasonable update interval, one update would go through several hundred chunks.

"It's still also a bit unclear to me what is actually debug code, and what's not in the EvaluateVertexPointJob. For instance, you still call Randomize with 0, is that just for debugging?"
This is a good question and I'm still working through this part. The noise.cs file I was using has a few quirks, I'm not entirely sure how it works and it was clearly not cleaned up before its release as most of the variables listed at the start aren't even used. Ideally I would be passing my own generated seed here but I haven't gotten that far.

"Why do you do the i < jobVertices.Length, are you ever scheduling more "iterations" than jobVertices.Length?"
Yes, and maybe you can teach me something here. I only need to loop through the vertices for each vertex, but the native arrays I'm passing in can be larger - for instance, _random, Source, and Grad3 (all from noise.cs) are larger than 25, so at a resolution of 4 the job throws index out of bounds errors at me otherwise. I've tried a few things to solve this and ended up bootlegging it this way.

"Also, do you need those random numbers to be the same each time in Evaluate for the algorithm to function properly, or do you just need a random number? (if so, unity.mathematics.random is probably a better bet, then you don't need the array either)."
Answering this one the same as the other, I'm not quite sure what this 3D noise script actually needs...

"The noiseFilterValues, is that just a struct that you've put into multiple floats?"
Yes, coming from Sebastian Lague the noise filters have lots of values and there can be an arbitrary number of filters. I pass all this stuff into one single array of floats (and I haven't actually finalized this so not passing all of them yet):

Per-Morten said: ↑

If I were you now, I would dig more into what in the EvaluateVertexPointJob, that is taking time (if that's the job that is taking the most time). You can create your own profiler markers that you pass into the job. Like this:
Create multiple markers for the different sections of your code that you want to profile. I would create a marker per static function you have in the EvaluateVertexPointJob."
Click to expand...

I'll get started on this too, thanks!

ATMLVE · Sep 8, 2023

I have some excellent news for me, after making lots of arrays ReadOnly I was able to isolate the vertex jobs to starting all them first and then finishing them all second (rather than one by one like before). Deep profiling time for this job alone went from 60-90 ms down to around 6-7ms. The frame hitching during an update at my high resolution of 16 is now about as imperceptible as it used to be at 4 (~one sixteenth the number of vertices), and I still have optimizations I can do.

ATMLVE · Sep 11, 2023

Now for some bad news, I'm now getting a pretty regular crash when I seemingly am initiating a lot of jobs at once. However this only happens in the editor, I can cause it without fail within seconds in play mode but cannot cause it within a build.

Edit - this was a bug and is fixed in the latest version:
https://issuetracker.unity3d.com/product/unity/issues/guid/ECSB-424

Native Crash Reporting
=================================================================
Got a UNKNOWN while executing native code. This usually indicates
a fatal error in the mono runtime or one of the native libraries
used by your application.
=================================================================

=================================================================
Managed Stacktrace:
=================================================================
at <unknown> <0xffffffff>
at Unity.Jobs.LowLevel.Unsafe.JobsUtility:ScheduleParallelFor_Injected <0x000c2>
at Unity.Jobs.LowLevel.Unsafe.JobsUtility:ScheduleParallelFor <0x00062>
at Unity.Jobs.IJobParallelForExtensions:Schedule <0x000fa>
at Chunk:StartVerticesJob <0x007e2>
at TerrainFace:UpdateTree <0x00262>
at Planet:UpdateMesh <0x0007a>
at <PlanetGenerationLoop>d__29:MoveNext <0x0011a>
at UnityEngine.SetupCoroutine:InvokeMoveNext <0x00081>
at <Module>:runtime_invoke_void_object_intptr <0x000ae>
=================================================================
Received signal SIGSEGV
Obtained 32 stack frames
0x00007ff639878717 (Unity) `anonymous namespace'::ScheduleManagedJobParallelFor_Internal
0x00007ff639877828 (Unity) ScheduleManagedJobParallelFor
0x00007ff638d5db6e (Unity) JobsUtility_CUSTOM_ScheduleParallelFor_Injected
0x000001975d8f4883 (Mono JIT Code) (wrapper managed-to-native) Unity.Jobs.LowLevel.Unsafe.JobsUtility:ScheduleParallelFor_Injected (Unity.Jobs.LowLevel.Unsafe.JobsUtility/JobScheduleParameters&,int,int,Unity.Jobs.JobHandle&)
0x000001975d8f4743 (Mono JIT Code) Unity.Jobs.LowLevel.Unsafe.JobsUtility:ScheduleParallelFor (Unity.Jobs.LowLevel.Unsafe.JobsUtility/JobScheduleParameters&,int,int)
0x000001975d8f3cdb (Mono JIT Code) Unity.Jobs.IJobParallelForExtensions:Schedule<EvaluateVertexPointJob> (EvaluateVertexPointJob,int,int,Unity.Jobs.JobHandle)
0x000001975d8f3a63 (Mono JIT Code) Chunk:StartVerticesJob () (at C:/Users/ATMLVE/Space Game 1/Assets/Scripts/Planet Generation/Chunk.cs:349)
..... trimmed

ATMLVE · Sep 20, 2023

I have a conceptual question I may as well ask here. I have my vertex job, it runs Execute(int i), inside it are some methods for math. In my code I run several different versions of this job that are almost the same, but not quite. They do all the same math, but the format I send the data in is slightly different or with one extra array for some data I need. But again the math they do is all entirely the same.

The easiest way I had approached this is to just copy and paste the code to make a separate job and make the changes I needed. Lazy enough, except now I have four different copies of the same job with slight differences and I'm trying to iterate on the math itself and it's a drag copy and pasting it four times, of course.

Is there a way to handle this where I can have one series of methods written once that four separate jobs all reference? The things I've tried so far have given me errors.

Search Unity

Unity ID

Useful Searches

Question Understanding profiler information