Insufficient memory on creating vertex buffers

Question

I'm building a voxel world generator with XNA where the voxels are rendered as polygonal cubes. The world is divided into 1024 chunks of 32x32x256 cubes each (as 32 chunks by 32 chunks), and each chunk has its own index and vertex buffer. Since each chunk is different, vertex buffer size is determined on runtime.

To prevent massive stalling on opening the program, only one chunk is re-built per frame until all chunks are built. Occasionally the program crashes with an "insufficient memory" related error that is caused by the line that creates the vertex buffer. Here is how I set them up:

 vb = new VertexBuffer(
      device,
      VertexPositionColorNormal.VertexDeclaration,
      nextIndex,
      BufferUsage.None
 );

 ib = new IndexBuffer(
      device, IndexElementSize.ThirtyTwoBits,
      nextIndex,
      BufferUsage.None
 );

My vertex structure is not very large, using only a Vector3 for position and Byte4 for color and normal lookup info:

public struct VertexPositionColorNormal : IVertexType
{
    public Vector3 Position;
    public uint Data;

    public readonly static VertexDeclaration VertexDeclaration = new VertexDeclaration
    (
        new VertexElement(0, VertexElementFormat.Vector3, VertexElementUsage.Position, 0),
        new VertexElement(12, VertexElementFormat.Byte4, VertexElementUsage.TextureCoordinate, 0)
    );

    VertexDeclaration IVertexType.VertexDeclaration { get { return VertexDeclaration; } }
}

NextIndex is the number of vertices and indices allocated to the buffers (always 1 index per vertex).

Am I making too many buffers? It crashes despite the GC showing only about 12 MB of usage so I guess memory fragmentation is a problem when creating lots of buffers in a short time? Should I use a smaller amount of buffers that store more data and have several chunks share them?

EDIT: I estimate roughly 0.75 to 1 GB of memory used in the vertex buffers. My graphics card has 2GB of VRAM. Though I also know sometimes not all the vertex data may be stored in VRAM at one time.

Answer 1

I've never had this problem before, but I've also noticed you're using BufferUsage.None. This enum has two possible states: None and WriteOnly. In all my coding, I've always used WriteOnly.

From the documentation for BufferUsage, it states that WriteOnly does the best memory location for writing/rendering, but the downside is you can't read the data from the buffer. It might be worth while trying out WriteOnly, and seeing if it solves the problem, especially if you don't plan on reading from the buffers.

Your Vertex Declaration also looks odd, using a uint to store Color and Normal data. I dunno what your reasons behind this is, but because its not the standard way of doing it, it might be causing a problem. My VertexPositionNormalColor is usually set up like this. Don't think its likely, but I know from experience how an innocent looking line of code can be a major bug monster.

Lastly, in the creation of both vertex and index buffers, you seem to be assuming that the vertexCount = indexCount. Don't know what circumstances would cause this to be true unless you're rendering a triangle.

Another possibilty is that during the creation of your VertexBuffer, you are hitting the internal limit. I know from previous experience with terrain generated from a heightmap that VertexBuffers will only hold so many elements. There is the possibility (especially if your voxels are generated at run time dynamically) that one chunk has a few too many voxels in it.

A good way to test this cause would be to bump your game world down to 512 chunks, and then test repeatedly to see if the error occurs.

EDIT:

I've had a bit of a look around, and this link here might offer an explanation. They are reporting a near identical error (might actually be the same given the age of the thread and changes in C#/the XNA API), and have a discussion about VRAM memory allocation with multiple vertex buffers.

Chances are, you try to create a VertexBuffer in VRAM, but there isn't a free block big enough to store it, and your application errors with an 'InsufficentMemory' exception. You can work around this by creating smaller VertexBuffers by reducing the complexity of the data in them or creating fewer VertexBuffers by increasing the size of your chunks so each buffer gets allocated more fairly in VRAM.

Further explaination:

Note that memory allocation for object is random, so if it finds a large enough chunk of free memory, it'll store it in there somewhere. This means you could have 256MB of memory free in total, and have a 64MB object to store, but your largest free chunk is 32MB. Even though the total memory exceeds the size of your object, the largest free chunk that we could use is smaller than the requested object size, so we report an OutOfMemory or InsufficentMemory error (or something similar) to the application