Why POT textures work slower than non-pot?

Question

I use following function to load textures

public static int loadTexture(Bitmap bmp)
{
    final int[] textureHandle = new int[1];

    GLES20.glGenTextures(1, textureHandle, 0);
    if (textureHandle[0] != 0)
    {

        // Bind to the texture in OpenGL
        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, textureHandle[0]);

        // Set filtering
        GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_LINEAR);
        GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_LINEAR);
        //GLES20.glGenerateMipmap(textureHandle[0]);
        //adapt texture to POT
        int adaptedWidth= (int) Math.pow(2,Math.ceil(Math.log(bmp.getWidth())/Math.log(2d)));
        int adaptedHeight= (int) Math.pow(2,Math.ceil(Math.log(bmp.getHeight())/Math.log(2d)));
        Log.d("texture",adaptedWidth+","+adaptedHeight);

        Bitmap tmp = Bitmap.createScaledBitmap(bmp, adaptedWidth, adaptedHeight, false);
        Log.d("asize",tmp.getWidth()+","+tmp.getHeight());
        // Load the bitmap into the bound texture.
        GLUtils.texImage2D(GLES20.GL_TEXTURE_2D, 0, tmp, 0);
        //GLUtils.texImage2D(GLES20.GL_TEXTURE_2D, 0, bmp, 0);
        tmp.recycle();
        // Recycle the bitmap, since its data has been loaded into OpenGL.
        //bmp.recycle();
    }

    if (textureHandle[0] == 0)
    {
        throw new RuntimeException("Error loading texture.");
    }
    return textureHandle[0];
}

I got 14-17 fps with this code.Hovever if I load my bitmap(which is non POT) directly without adaptation to POT.FPS jumps to 28-30.I thought POT textures should work faster then non-POT.Is there explanation for this?

UPD:Rendering code:

@Override
public void onDrawFrame(GL10 gl) {
    //curScale=modelMatrix[SCALE_X];
    TimeMeasurer.reset();
    long curTS= SystemClock.uptimeMillis();
    long frameRenderTime=curTS-ts;
    //Log.d("renderer","FPS:"+1000.0/frameRenderTime);
    Log.d("renderer","frame render time:"+frameRenderTime);
    ts=curTS;
    GLES20.glClear(GLES20.GL_DEPTH_BUFFER_BIT | GLES20.GL_COLOR_BUFFER_BIT);
    if (piecesMesh!=null) {
        Matrix.setIdentityM(MVPMatrix,0);
        Matrix.multiplyMM(MVPMatrix,0,projMatrix,0,modelMatrix,0);
        drawPassivePieces();
        drawActivePieces();
        if (helper!=null) {
            drawHelper();
        }
    }
    TimeMeasurer.measure("onDrawFrame execution time:");
}
private void drawPassivePieces() {
    //shadows
    shadowProgram.useProgram();
    shadowProgram.setUniforms(MVPMatrix,textureMaskId);
    shadowMesh.bindPieceData(shadowProgram,false);
    shadowMesh.drawPieces(false);
    shadowMesh.disableAttributes(shadowProgram);
    //pieces
    piecesProgram.useProgram();
    piecesProgram.setUniforms(MVPMatrix, textureImageId, textureMaskId);
    piecesMesh.bindPieceData(piecesProgram,false);
    piecesMesh.drawPieces(false);
    piecesMesh.disableAttributes(piecesProgram);

}
private void drawActivePieces() {
    //shadows
    shadowProgram.useProgram();
    shadowProgram.setUniforms(MVPMatrix,textureMaskId);
    shadowMesh.bindPieceData(shadowProgram,true);
    shadowMesh.drawPieces(true);
    shadowMesh.disableAttributes(shadowProgram);
    //pieces
    piecesProgram.useProgram();
    piecesProgram.setUniforms(MVPMatrix, textureImageId, textureMaskId);
    piecesMesh.bindPieceData(piecesProgram,true);
    piecesMesh.drawPieces(true);
    piecesMesh.disableAttributes(piecesProgram);
}
public void drawHelper() {
    helperProgram.useProgram();
    helper.bindData(helperProgram);
    helper.draw();
    helper.disableAttributes(helperProgram);
}

Answer 1

Without a detailed performance analysis, it's not really possible to do more than speculate.

One likely cause is that your rendering is limited by memory bandwidth of texture sampling. If you make the texture larger, the total amount of memory accessed is larger, causing the slowdown.

Or, very related to the above, your cache hit rate for texture sampling drops if the sampled texels are spread out farther in memory, which happens when you upscale the texture. Lower cache hit rate means slower performance.

You really shouldn't artificially make the texture larger than necessary, unless it's needed due to the limited NPOT support in ES 2.0, and the hardware you use does not advertise the OES_texture_npot extension. I doubt that anybody has made hardware that prefers POT textures in a long time.