How do you upload texture data to a Sparse Texture using TexSubImage in OpenGL?

Question

I am following apitest on github, and am seeing some very strange behavior in my renderer.

It seems like the Virtual Pages are not receiving the correct image data.

Original Image is 500x311:

When i render this image using a Sparse Texture, i must resize the backing store to 512x384 (to be a mutliple of the page size) and my result is:

As you can see it looks like a portion of the subimage (a sub sub image) was loaded to each individual virtual page.

To test this, i cropped the image to the size of just 1 virtual page (256x128): here is the result:

as expected, the single virutal page was filled with the exact, correct, cropped image.

Lastly, I increased the crop size to be 2 virtual pages worth, 256x256, one on top of another. here is the result:

This proves that calling texSubimage with an amount of texelData larger than Virtual_Page_Size causes errors.

Does care need to be taken when passing data to glsubimage that is larger than the virtual page size? I see no logic for this in apitest so think this could be a driver issue. Or I am missing something major.

Here is some code:

I stored the Texture in a Texture Array and to simplify turned the array into just a texture2d. both produce the same exact result. Here is the Texture Memory Allocation:

_check_gl_error();
    glGenTextures(1, &mTexId);
    glBindTexture(GL_TEXTURE_2D, mTexId);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SPARSE_ARB, GL_TRUE);

    // TODO: This could be done once per internal format. For now, just do it every time.
    GLint indexCount = 0,
            xSize = 0,
            ySize = 0,
            zSize = 0;
    GLint bestIndex = -1,
            bestXSize = 0,
            bestYSize = 0;
    glGetInternalformativ(GL_TEXTURE_2D, internalformat, GL_NUM_VIRTUAL_PAGE_SIZES_ARB, 1, &indexCount);
    if(indexCount == 0) {
        fprintf(stdout, "No Virtual Page Sizes for given format");
        fflush(stdout);
    }
    _check_gl_error();
    for (GLint i = 0; i < indexCount; ++i) {
        glTexParameteri(GL_TEXTURE_2D, GL_VIRTUAL_PAGE_SIZE_INDEX_ARB, i);
        glGetInternalformativ(GL_TEXTURE_2D, internalformat, GL_VIRTUAL_PAGE_SIZE_X_ARB, 1, &xSize);
        glGetInternalformativ(GL_TEXTURE_2D, internalformat, GL_VIRTUAL_PAGE_SIZE_Y_ARB, 1, &ySize);
        glGetInternalformativ(GL_TEXTURE_2D, internalformat, GL_VIRTUAL_PAGE_SIZE_Z_ARB, 1, &zSize);
        // For our purposes, the "best" format is the one that winds up with Z=1 and the largest x and y sizes.
        if (zSize == 1) {
            if (xSize >= bestXSize && ySize >= bestYSize) {
                bestIndex = i;
                bestXSize = xSize;
                bestYSize = ySize;
            }
        }
    }
    _check_gl_error();

    mXTileSize = bestXSize;
    glTexParameteri(GL_TEXTURE_2D, GL_VIRTUAL_PAGE_SIZE_INDEX_ARB, bestIndex);
    _check_gl_error();

    //Need to ensure that the texture is a multiple of the tile size.
    physicalWidth = roundUpToMultiple(width, bestXSize);
    physicalHeight = roundUpToMultiple(height, bestYSize);

    // We've set all the necessary parameters, now it's time to create the sparse texture.
    glTexStorage2D(GL_TEXTURE_2D, levels, GL_RGBA8, physicalWidth, physicalHeight);
    _check_gl_error();
    for (GLsizei i = 0; i < slices; ++i) {
        mFreeList.push(i);
    }
    _check_gl_error();
    mHandle = glGetTextureHandleARB(mTexId);
    _check_gl_error();
    glMakeTextureHandleResidentARB(mHandle);
    _check_gl_error();

    mWidth = physicalWidth;
    mHeight = physicalHeight;
    mLevels = levels;

Here is what happens after the allocation:

glTextureSubImage2DEXT(mTexId, GL_TEXTURE_2D, level, 0, 0, width, height, GL_RGB, GL_UNSIGNED_BYTE, data);

I have tried making width and height the physical width of the backing store AND the width/height of the incoming image content. Neither produce desired results. I exclude mip levels for now. When I was using Mip levels and the texture array i was getting different results but similar behavior.

Also the image is loaded from SOIL and before i implemented sparse textures, that worked very well (before sparse i implemented bindless).