Source code
Revision control
Copy as Markdown
Other Tools
/*
Copyright (c) 2019 The Khronos Group Inc.
Use of this source code is governed by an MIT-style license that can be
found in the LICENSE.txt file.
*/
NoOverOptimizeOnUniformArrayTester = (function(){
var vshader = [
"attribute vec4 a_position;",
"void main()",
"{",
" gl_Position = a_position;",
"}"
].join('\n');
var fshader_max = [
"precision mediump float;",
"uniform vec4 colora[$(maxUniformVectors)];",
"void main()",
"{",
" gl_FragColor = vec4(colora[$(usedUniformVector)]);",
"}"
].join('\n');
var fshader_max_ab_ab = [
"precision mediump float;",
"uniform vec4 $(decl1);",
"uniform vec4 $(decl2);",
"void main()",
"{",
"gl_FragColor = vec4($(usage1) + $(usage2));",
"}"
].join('\n');
// MaxInt32 is 2^32-1. We need +1 of that to test overflow conditions
var MaxInt32PlusOne = 4294967296;
function setupTests(gl) {
var tests = [];
var maxUniformVectors = gl.getParameter(gl.MAX_FRAGMENT_UNIFORM_VECTORS);
// This test is to test drivers the have bugs related to optimizing
// an array of uniforms when only 1 of those uniforms is used.
tests.push({
desc: "using last element",
maxUniformVectors: maxUniformVectors,
usedUniformVector: maxUniformVectors - 1,
shader: "fshader-max",
color: [0, 1, 0, 1],
arrayName: "colora",
extraName: "colorb",
});
tests.push({
desc: "using first element",
maxUniformVectors: maxUniformVectors,
usedUniformVector: 0,
shader: "fshader-max",
color: [0, 1, 0, 1],
arrayName: "colora",
extraName: "colorb",
});
// Generate test shaders. We're trying to force the driver to
// overflow from 1 array into the next if it optimizes. So for example if it was C
//
// int big[4];
// int little[1];
// big[5] = 124;
//
// Would end up setting little[0] instead of big. Some drivers optimize
// where if you only use say 'big[3]' it will actually only allocate just 1 element
// for big.
//
// But, some drivers have a bug where the fact that they optimized big to 1 element
// does not get passed down to glUniform so when setting the uniform 'big[3]' they
// overwrite memory.
//
// If the driver crashes, yea. We found a bug. We can block the driver.
// Otherwise we try various combinations so that setting 'little[0]' first
// and then setting all elements of 'big' we hope it will overwrite 'little[0]'
// which will show the bug and again we can block the driver.
//
// We don't know how the driver will order, in memory, the various uniforms
// or for that matter we don't even know if they will be contiguous in memory
// but to hopefully expose any bugs we try various combinations.
//
// It could be the compiler orders uniforms alphabetically.
// It could be it orders them in order of declaration.
// It could be it orders them in order of usage.
//
// We also test using only first element of big or just the last element of big.
//
for (var nameOrder = 0; nameOrder < 2; ++nameOrder) {
var name1 = nameOrder ? "colora" : "colorb";
var name2 = nameOrder ? "colorb" : "colora";
for (var last = 0; last < 2; ++last) {
var usedUniformVector = last ? maxUniformVectors - 2 : 0;
for (var declOrder = 0; declOrder < 2; ++declOrder) {
var bigName = declOrder ? name1 : name2;
var littleName = declOrder ? name2 : name1;
var decl1 = bigName + "[" + (maxUniformVectors - 1) + "]";
var decl2 = littleName + "[1]";
if (declOrder) {
var t = decl1;
decl1 = decl2;
decl2 = t;
}
for (var usageOrder = 0; usageOrder < 2; ++usageOrder) {
var usage1 = bigName + "[" + usedUniformVector + "]";
var usage2 = littleName + "[0]";
if (usageOrder) {
var t = usage1;
usage1 = usage2;
usage2 = t;
}
var fSrc = wtu.replaceParams(fshader_max_ab_ab, {
decl1: decl1,
decl2: decl2,
usage1: usage1,
usage2: usage2,
});
var desc = "testing: " + name1 + ":" + name2 + " using " + (last ? "last" : "first") +
" creating uniforms " + decl1 + " " + decl2 + " and accessing " + usage1 + " " + usage2;
tests.push({
desc: desc,
maxUniformVectors: maxUniformVectors - 1,
usedUniformVector: usedUniformVector,
source: fSrc,
color: [0, 0, 0, 1],
arrayName: bigName,
extraName: littleName,
});
}
}
}
}
return tests;
};
function testUniformOptimizationIssues(test) {
debug("");
debug(test.desc);
var fshader = test.source;
if (!fshader) {
fshader = wtu.replaceParams(fshader_max, test);
}
var consoleElem = document.getElementById("console");
wtu.addShaderSource(
consoleElem, "vertex shader", vshader);
wtu.addShaderSource(
consoleElem, "fragment shader", fshader);
var program = wtu.loadProgram(gl, vshader, fshader);
gl.useProgram(program);
var colorbLocation = gl.getUniformLocation(program, test.extraName + "[0]");
if (colorbLocation) {
gl.uniform4fv(colorbLocation, [0, 1, 0, 0]);
}
// Ensure that requesting an array uniform past MaxInt32PlusOne returns no uniform
var nameMaxInt32PlusOne = test.arrayName + "[" + (test.usedUniformVector + MaxInt32PlusOne) + "]";
assertMsg(gl.getUniformLocation(program, nameMaxInt32PlusOne) === null,
"Requesting " + nameMaxInt32PlusOne + " uniform should return a null uniform location");
// Set just the used uniform
var name = test.arrayName + "[" + test.usedUniformVector + "]";
var uniformLocation = gl.getUniformLocation(program, name);
gl.uniform4fv(uniformLocation, test.color);
wtu.setupIndexedQuad(gl, 1);
wtu.clearAndDrawIndexedQuad(gl, 1);
wtu.checkCanvas(gl, [0, 255, 0, 255], "should be green");
// Set all the unused uniforms
var locations = [];
var allRequiredUniformLocationsQueryable = true;
for (var ii = 0; ii < test.maxUniformVectors; ++ii) {
var name = test.arrayName + "[" + ii + "]";
var uniformLocation = gl.getUniformLocation(program, name);
locations.push(uniformLocation);
if (ii == test.usedUniformVector) {
continue;
}
// Locations > usedUnformVector may not exist.
// Locations <= usedUniformVector MUST exist.
if (ii <= test.usedUniformVector && (uniformLocation === undefined || uniformLocation === null)) {
allRequiredUniformLocationsQueryable = false;
}
gl.uniform4fv(uniformLocation, [1, 0, 0, 1]);
}
if (allRequiredUniformLocationsQueryable) {
testPassed("allRequiredUniformLocationsQueryable is true.");
}
else {
testFailed("allRequiredUniformLocationsQueryable should be true. Was false.");
}
var positionLoc = gl.getAttribLocation(program, "a_position");
wtu.setupIndexedQuad(gl, 1, positionLoc);
wtu.clearAndDrawIndexedQuad(gl, 1);
wtu.checkCanvas(gl, [0, 255, 0, 255], "should be green");
// Check we can read & write each uniform.
// Note: uniforms past test.usedUniformVector might not exist.
for (var ii = 0; ii < test.maxUniformVectors; ++ii) {
gl.uniform4fv(locations[ii], [ii + 4, ii + 2, ii + 3, ii + 1]);
}
var kEpsilon = 0.01;
var isSame = function(v1, v2) {
return Math.abs(v1 - v2) < kEpsilon;
};
for (var ii = 0; ii < test.maxUniformVectors; ++ii) {
var location = locations[ii];
if (location) {
var value = gl.getUniform(program, locations[ii]);
if (!isSame(value[0], ii + 4) ||
!isSame(value[1], ii + 2) ||
!isSame(value[2], ii + 3) ||
!isSame(value[3], ii + 1)) {
testFailed("location: " + ii + " was not correct value");
break;
}
}
}
}
function runOneTest(gl, test) {
testUniformOptimizationIssues(test);
};
function runTests(gl, tests) {
debug("");
debug("Test drivers don't over optimize unused array elements");
for (var ii = 0; ii < tests.length; ++ii) {
runOneTest(gl, tests[ii]);
}
};
return {
setupTests : setupTests,
runTests : runTests
};
}());