Compute Shaders Crashing

joesobo · January 20, 2021, 5:04pm

So i’ve been beginning to learn how to use Compute Shaders. I’ve follow a couple of tutorials so i’m really just getting started with them. However, when working on my latest project, I’ve been repeatedly crashing Unity with this error. I’m not really sure what this means or how to begin solving it. I did manage to figure out what part of my code was causing it though. It happens whenever I call Append() on an AppendStructuredBuffer. The buffer is already setup with type ComputeBufferType.Append.

for(int i = 0; triangulation[cellType][i] != -1; i +=3) {
        Triangle tri;
        tri.vertexA = float2(uv.x + relativeOffsets[triangulation[cellType][i]][0], uv.y + relativeOffsets[triangulation[cellType][i]][1]);
        tri.vertexB = float2(uv.x + relativeOffsets[triangulation[cellType][i+1]][0], uv.y + relativeOffsets[triangulation[cellType][i+1]][1]);
        tri.vertexC = float2(uv.x + relativeOffsets[triangulation[cellType][i+2]][0], uv.y + relativeOffsets[triangulation[cellType][i+2]][1]);
        _Triangles.Append(tri);
}

This is the code where it is crashing my compute shader. To be honest I’m not sure why it even gets to the Append in the first place as triangulation[cellType] should initially equal -1.
Any help would be much appreciated as I’m quite lost at the moment.

joesobo · January 22, 2021, 7:15am

At this point I’ve reached a dead end. I need to use the AppendStructuredBuffer as you can never be sure what index or how many triangles each thread will be adding. I have found no way of fixing this to far. Here is the rest of my code. I know its ugly and unclean, I’m just trying to see why this example doesn’t work.

Main Code

private void CreateBuffers() {
        int numPoints = voxelResolution * voxelResolution;
        int numVoxelsPerResolution = voxelResolution - 1;
        int numVoxels = numVoxelsPerResolution * numVoxelsPerResolution;
        int maxTriangleCount = numVoxels * 3;

        Debug.Log(verticeBuffer);
        if (!Application.isPlaying || (verticeBuffer == null || numPoints != verticeBuffer.count)) {
            if (Application.isPlaying) {
                ReleaseBuffers();
            }
            verticeBuffer = new ComputeBuffer(numPoints, sizeof(float) * 3);
            triangleBuffer = new ComputeBuffer(maxTriangleCount, sizeof(float) * 2 * 3 * 2, ComputeBufferType.Append);
            triCountBuffer = new ComputeBuffer(1, sizeof(int), ComputeBufferType.Raw);
            stateBuffer = new ComputeBuffer(numPoints, sizeof(int));
        }
    }

public void TriangulateChunk(VoxelChunk chunk) {
        chunk.mesh.Clear();

        // Compute Shader Here
        int numThreadsPerResolution = Mathf.CeilToInt(voxelResolution / threadSize);

        triangleBuffer.SetCounterValue(0);
        shader.SetBuffer(0, "_Vertices", verticeBuffer);
        shader.SetBuffer(0, "_Triangles", triangleBuffer);
        shader.SetBuffer(0, "_States", stateBuffer);
        shader.SetInt("_Resolution", voxelResolution);

        for (int i = 0; i < chunk.voxels.Length; i++) {
            statePositions[i] = chunk.voxels[i].state ? 1 : 0;
        }
        stateBuffer.SetData(statePositions);

        shader.Dispatch(0, numThreadsPerResolution, numThreadsPerResolution, 1);

        ComputeBuffer.CopyCount(triangleBuffer, triCountBuffer, 0);
        int[] triCountArray = { 0 };
        triCountBuffer.GetData(triCountArray);
        int numTris = triCountArray[0];

        Triangle[] tris = new Triangle[numTris];
        triangleBuffer.GetData(tris, 0, 0, numTris);

        var vertices = new Vector3[numTris * 3];
        var triangles = new int[numTris * 3];

        for (int i = 0; i < numTris; i++) {
            for (int j = 0; j < 3; j++) {
                triangles[i * 3 + j] = i * 3 + j;
                vertices[i * 3 + j] = tris[i][j];
            }
        }

        chunk.mesh.vertices = vertices;
        chunk.mesh.triangles = triangles;
        chunk.mesh.RecalculateNormals();
    }

Compute Shader

#pragma kernel CSMain

struct Triangle {
    float2 vertexA;
    float2 vertexB;
    float2 vertexC;
};

int edges[16] = {
    0x0,
    0x3,
    0x6,
    0x5,
    0x12,
    0x15,
    0x10,
    0x9,
    0x9,
    0x10,
    0x15,
    0x12,
    0x5,
    0x6,
    0x3,
    0x0
};

int triangulation[16][9] = {
    {-1, -1, -1, -1, -1, -1, -1, -1, -1},
    {0, 1, 4, -1, -1, -1, -1, -1, -1},
    {1, 2, 5, -1, -1, -1, -1, -1, -1},
    {0, 2, 4, 4, 2, 5, -1, -1, -1},
    {2, 3, 6, -1, -1, -1, -1, -1, -1},
    {0, 1, 4, 2, 3, 6, -1, -1, -1},
    {1, 3, 5, 5, 6, 3, -1, -1, -1},
    {0, 4, 5, 0, 3, 5, 3, 5, 6},
    {0, 3, 7, -1, -1, -1, -1, -1, -1},
    {1, 3, 4, 4, 7, 3, -1, -1, -1},
    {0, 3, 7, 1, 2, 5, -1, -1, -1},
    {3, 7, 4, 3, 2, 4, 2, 5, 4},
    {0, 2, 7, 7, 6, 2, -1, -1, -1},
    {1, 2, 7, 1, 7, 4, 2, 7, 6},
    {0, 1, 6, 0, 6, 7, 1, 6, 5},
    {-1, -1, -1, -1, -1, -1, -1, -1, -1}
};

int relativeOffsets[8][2] = {
    {0, 0},
    {0, 1},
    {1, 0},
    {1, 1},
    {0, 0.5},
    {0.5, 0},
    {1, 0.5},
    {0.5, 1}
};

RWStructuredBuffer<float3> _Vertices;
AppendStructuredBuffer<Triangle> _Triangles;
RWStructuredBuffer<uint> _States;
uint _Resolution;

int2 GetUV (int3 id) {
    return id.xy;
}

int indexFromCoord(int x, int y) {
    return y * _Resolution + x;
}

void TriangulateCellRows(int2 uv) {
    if (uv.x >= _Resolution-1 || uv.y >= _Resolution-1) {
        return;
    }

    int squareCornerStates[4] = {
        _States[indexFromCoord(uv.x, uv.y)],
        _States[indexFromCoord(uv.x + 1, uv.y)],
        _States[indexFromCoord(uv.x, uv.y + 1)],
        _States[indexFromCoord(uv.x + 1, uv.y + 1)],
    };

    int cellType = 0;
    if (squareCornerStates[0] == 1) cellType |= 1;
    if (squareCornerStates[1] == 1) cellType |= 2;
    if (squareCornerStates[2] == 1) cellType |= 4;
    if (squareCornerStates[3] == 1) cellType |= 8;

    for(int i = 0; triangulation[cellType][i] != -1; i +=3) {
        Triangle tri;
        tri.vertexA = float2(uv.x + relativeOffsets[triangulation[cellType][i]][0], uv.y + relativeOffsets[triangulation[cellType][i]][1]);
        tri.vertexB = float2(uv.x + relativeOffsets[triangulation[cellType][i+1]][0], uv.y + relativeOffsets[triangulation[cellType][i+1]][1]);
        tri.vertexC = float2(uv.x + relativeOffsets[triangulation[cellType][i+2]][0], uv.y + relativeOffsets[triangulation[cellType][i+2]][1]);
        _Triangles.Append(tri);
    }
}

[numthreads(8,8,1)]
void CSMain (int3 id : SV_DispatchThreadID)
{
    int2 uv = GetUV(id);
    TriangulateCellRows(uv);
}

aleksandrk · January 22, 2021, 5:55pm

This means that the GPU cannot finish the work in a sensible amount of time.
What’s the value you use for “voxelResolution” and how many chunks do you have?

joesobo · January 22, 2021, 11:57pm

Only a single chunk on a 8x8 resolution. The CPU had no trouble with it before I started converting to using a computeShader.

joesobo · January 23, 2021, 2:42am

Is there a way to extend the time (seems like a bad solution), or is this definitely some sort of infinite loop thats causing it to take too long?

aleksandrk · January 23, 2021, 6:49am

There might be a problem with your for(int i = 0; triangulation[cellType] *!= -1; i +=3) loop. Some arrays in triangulation are not terminated by “-1”. It looks like it can read out of bounds, and I’m not sure if it’s reading the next row or just getting some “default” value, which is likely a zero.*
Try appending a terminating “-1” in each (making it triangulation[16][10]).

joesobo · January 23, 2021, 5:27pm

Ok that was definitely an issue, that I’m surprised I hadn’t run into before. Unfortunately it still didn’t fix my error. When I think about it, it shouldn’t have really played an effect. On the first iteration the entire grid is completely empty, which means cellType will always equal 0. Whentriangulation[cellType]* runs its always should get*
{-1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, from the triangulation table. Obviously this should break the loop.
I ran some more tests and when I append a single triangle with vertices outside the loop it runs.
When I try to append empty vertices instead of the specific positioned ones while still inside the loop it crashes.
Also when I completely remove the entire loop or all of its contents it runs
This leads me to believe that its not the contents of triangulation that are causing the problem, but maybe by the number of triangles that are being appended? 0 runs fine, 1 runs fine, even 2 when I manually append from outside the loop. This confuses the heck out of me since the triangulation shouldn’t run at all initially, meaning 0 triangles should get added, which should run fine (similar to how it runs without the loop present).
So how does a loop that shouldn’t run, keep crashing my program (but only when it has contents)?
If it helps at all I uploaded everything from the project into a git repo. https://github.com/joesobo/Compute-Shaders-Learning. Maybe you could take a look? All you have to do is open up the Main scene.

joesobo · January 23, 2021, 11:32pm

I believe I figured it out. For anyone creating an array within the compute shader, make sure to set it to static. No idea why that caused the crash, but it fixed it

Topic		Replies	Views
AppendStructuredBuffer not working as expected Unity Engine Shaders , SRP , Question	1	1711	October 31, 2022
Append buffer is trowing random integers when I only want 60 Unity Engine Shaders , Bug	7	670	August 30, 2023
Compute shader, append type issues (not always returning buffer) Unity Engine Shaders	2	2515	October 25, 2015
[Compute Shader] Compiler crashes when trying to read value from an array. Unity Engine Shaders , Bug	5	1906	November 21, 2022
Debugging compute shader driver crash in editor Questions & Answers legacy-topics	2	1050	April 26, 2023

Compute Shaders Crashing

Related topics