dom/canvas/test/webgl-conf/checkout/extra/buffer-sizes.html

   1 <!--
   2 Copyright (c) 2019 The Khronos Group Inc.
   3 Use of this source code is governed by an MIT-style license that can be
   4 found in the LICENSE.txt file.
   5 -->
   6
   7 <!DOCTYPE html>
   8 <html>
   9 <head>
  10 <meta charset="utf-8">
  11 <title>Buffer allocation test</title>
  12 <link rel="stylesheet" href="../resources/js-test-style.css"/>
  13 <script src="../js/js-test-pre.js"></script>
  14 <script src="../js/webgl-test-utils.js"> </script>
  15 </head>
  16 <body>
  17 <div id="canvasParent"></div>
  18 <div id="description"></div>
  19 <div id="console"></div>
  20 <script id="vshader" type="x-shader/x-vertex">
  21 attribute vec2 inPosition;
  22 attribute vec4 inColor0;
  23 attribute vec4 inColor1;
  24 attribute vec4 inColor2;
  25 attribute vec4 inColor3;
  26 attribute vec4 inColor4;
  27 attribute vec4 inColor5;
  28 attribute vec4 inColor6;
  29 attribute vec4 inColor7;
  30
  31 varying vec4 color;
  32
  33 void main()
  34 {
  35     color = abs(inColor0) + abs(inColor1) + abs(inColor2) + abs(inColor3) +
  36             abs(inColor4) + abs(inColor5) + abs(inColor6) + abs(inColor7);
  37
  38     color = clamp(color, vec4(0.0), vec4(1.0));
  39
  40     gl_Position = vec4(inPosition, 0.0, 1.0);
  41 }
  42 </script>
  43 <script id="fshader" type="x-shader/x-fragment">
  44 precision mediump float;
  45
  46 varying vec4 color;
  47
  48 void main()
  49 {
  50     if (color == vec4(0.0))
  51         discard;
  52
  53     gl_FragColor = color;
  54 }
  55 </script>
  56
  57 <script>
  58 description("Allocates a number of different sized buffers and checks that the buffers are cleared " +
  59             "OR that the allocation results in gl.OUT_OF_MEMORY or context loss.");
  60 var wtu = WebGLTestUtils;
  61
  62 // The shader processes eight vec4 attributes at once to reduce the amount of
  63 // draw calls.
  64 var numColorAttrs = 8;
  65
  66 // Process 64 squares at once to also reduce the amount of draw calls.
  67 var vertices = [];
  68 var w = 0.25;
  69 for (var x = -1; x < 1; x += w) {
  70     for (var y = -1; y < 1; y += w) {
  71         vertices.push(x + w, y + w);
  72         vertices.push(x,     y + w);
  73         vertices.push(x,     y    );
  74
  75         vertices.push(x + w, y + w);
  76         vertices.push(x,     y    );
  77         vertices.push(x + w, y    );
  78     }
  79 }
  80 var numVertices = (vertices.length / 2);
  81
  82 var gl;
  83 var squareBuffer;
  84 var error = 0;
  85 var expectContextLost = false;
  86
  87 function initGLForBufferSizesTest() {
  88     var canvas = document.createElement("canvas");
  89     canvas.width = 40;
  90     canvas.height = 40;
  91     var parent = document.getElementById("canvasParent");
  92     parent.innerHTML = '';
  93     parent.appendChild(canvas);
  94     gl = wtu.create3DContext(canvas);
  95     var attribs = ["inPosition", "inColor0", "inColor1", "inColor2", "inColor3",
  96                    "inColor4", "inColor5", "inColor6", "inColor7"];
  97     wtu.setupProgram(gl, ["vshader", "fshader"], attribs);
  98     gl.enableVertexAttribArray(0);
  99     for (var i = 0; i < numColorAttrs; i++) {
 100         gl.enableVertexAttribArray(1 + i);
 101     }
 102     gl.disable(gl.DEPTH_TEST);
 103     gl.disable(gl.BLEND);
 104
 105     squareBuffer = gl.createBuffer();
 106
 107     gl.bindBuffer(gl.ARRAY_BUFFER, squareBuffer);
 108     gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(vertices), gl.STATIC_DRAW);
 109 }
 110
 111 function createBuffer(size, allowedToFail) {
 112     var msg = "Calling bufferData with size=" + size;
 113     var buffer = gl.createBuffer();
 114
 115     gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
 116     gl.bufferData(gl.ARRAY_BUFFER, size, gl.STATIC_DRAW);
 117
 118     error = gl.getError();
 119     if (error !== gl.NO_ERROR) {
 120         gl.deleteBuffer(buffer);
 121         if (allowedToFail) {
 122             if (error === gl.OUT_OF_MEMORY) {
 123                 testPassed(msg + " failed with gl.OUT_OF_MEMORY (this is allowed)");
 124                 return null;
 125             } else if (error === gl.CONTEXT_LOST_WEBGL) {
 126                 testPassed(msg + " failed with gl.CONTEXT_LOST_WEBGL (this is allowed)");
 127                 return null;
 128             }
 129         }
 130         testFailed(msg + " failed with error " + wtu.glEnumToString(gl, error));
 131         return null;
 132     }
 133
 134     testPassed(msg + " did not result in any errors");
 135     var reportedSize = gl.getBufferParameter(gl.ARRAY_BUFFER, gl.BUFFER_SIZE);
 136     expectContextLost = false;
 137     if (reportedSize === null) {
 138         testPassed("Null size reported by gl, this should happen if the context is lost which is allowed.");
 139         expectContextLost = true;
 140     } else if (reportedSize !== size) {
 141         if (size > Math.pow(2, 32)) {
 142             testPassed("gl reported different size " + reportedSize + " for the buffer, but this is expected since " +
 143                        "the requested size was above what the return value of getBufferParameter can represent.");
 144         } else {
 145             testFailed("gl reported different size " + reportedSize + " for the buffer.");
 146         }
 147     } else {
 148         testPassed("Size reported by gl was the same as the requested size.");
 149     }
 150
 151     return buffer;
 152 }
 153
 154 // Draw a square on the canvas using attributes from the clear buffer created with bufferData.
 155 function drawWithBuffer(buffer, allowedToFail) {
 156     gl.clearColor(0, 1, 0, 1);
 157     gl.clear(gl.COLOR_BUFFER_BIT);
 158
 159     gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
 160     var size = gl.getBufferParameter(gl.ARRAY_BUFFER, gl.BUFFER_SIZE);
 161     // Each vec4 is 16 bytes
 162     var increment = numVertices * numColorAttrs * 16;
 163     for (var offset = 0; offset + increment <= size; offset += increment) {
 164         gl.bindBuffer(gl.ARRAY_BUFFER, squareBuffer);
 165         gl.vertexAttribPointer(0, 2, gl.FLOAT, false, 0, 0);
 166
 167         for (var i = 0; i < numColorAttrs; i++) {
 168             gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
 169             gl.vertexAttribPointer(1 + i, 4, gl.FLOAT, false, 0,
 170                                    offset + increment * i / numColorAttrs);
 171         }
 172         gl.drawArrays(gl.TRIANGLES, 0, numVertices);
 173         error = gl.getError();
 174
 175         if (error !== gl.NO_ERROR) {
 176             if (allowedToFail) {
 177                 if (error === gl.OUT_OF_MEMORY) {
 178                     testPassed("drawArrays failed with gl.OUT_OF_MEMORY (this is allowed)");
 179                     return;
 180                 } else if (error === gl.CONTEXT_LOST_WEBGL) {
 181                     testPassed("drawArrays failed with gl.CONTEXT_LOST_WEBGL (this is allowed)");
 182                     return;
 183                 }
 184             }
 185             testFailed("drawArrays failed with error " + wtu.glEnumToString(gl, error));
 186             return;
 187         }
 188     }
 189     wtu.checkCanvas(gl, [0, 255, 0, 255], "should be green");
 190 }
 191
 192
 193 // To be able to confirm the whole buffer has been cleared, the size needs to
 194 // be divisible by the amount of vertices. Thus most sizes are multiples of 3.
 195 var tests = [
 196     // Reasonable sized buffers.
 197     { size: 3 * 1024,              allowedToFail: false, tryDrawing: true },
 198     { size: 3 * 1024 * 1024,       allowedToFail: false, tryDrawing: true },
 199     { size: 3 * 1024 * 1024 * 16,  allowedToFail: false, tryDrawing: true },
 200
 201     // Huge buffers, which are meant to test out of memory handling.
 202     // Allowed failures are gl.OUT_OF_MEMORY or context loss.
 203     // Succeeding in the allocations is allowed as well for forward compatibility.
 204
 205     // 1.5 GB allocation for stressing lower-end 32-bit systems.
 206     // Allocation is likely to succeed on higher-end hardware.
 207     { size: 3 * 1024 * 1024 * 512, allowedToFail: true,  tryDrawing: true },
 208     // A buffer that no implementation will be able to allocate for some time
 209     // to come. To do this, we use half of the lower 43-bit half of a 44-bit
 210     // memory address space, so that the size is still valid on current common
 211     // 64-bit implementations, and also below 52-bit limit for exact conversion
 212     // from float to long long in WebIDL (though 2^n should be safe anyway).
 213     // The 4 TB size is large enough that even extrapolating the historical
 214     // exponential growth trend of memory sizes, hardware in 2020's should
 215     // still have some trouble actually doing the allocation.
 216     { size: (1 << 12) * (1 << 30), allowedToFail: true,  tryDrawing: false }
 217 ];
 218
 219 function finishBufferSizesTest() {
 220     gl.deleteBuffer(squareBuffer);
 221     finishTest();
 222 }
 223
 224 var testIndex = -1;
 225 function runNextTest() {
 226     ++testIndex;
 227     if (testIndex > 0 && tests[testIndex - 1].allowedToFail) {
 228         if (gl.isContextLost() || error === gl.OUT_OF_MEMORY) {
 229             initGLForBufferSizesTest();
 230         } else if (expectContextLost) {
 231             testFailed("Context was not lost after timeout even though gl.getBufferParameter returned null.");
 232         }
 233     }
 234     var buffer = createBuffer(tests[testIndex].size, tests[testIndex].allowedToFail);
 235     if (buffer) {
 236         if (tests[testIndex].tryDrawing) {
 237             drawWithBuffer(buffer, tests[testIndex].allowedToFail);
 238         }
 239         gl.deleteBuffer(buffer);
 240     }
 241
 242     if (testIndex + 1 >= tests.length) {
 243         finishBufferSizesTest();
 244     } else {
 245         if (tests[testIndex + 1].allowedToFail && !tests[testIndex].allowedToFail) {
 246             if (!confirm("The following tests can cause unresponsiveness or instability. Press OK to continue.")) {
 247                 testFailed("Tests aborted");
 248                 return;
 249             }
 250         }
 251         if (tests[testIndex].allowedToFail) {
 252             // Give plenty of time for possible context loss
 253             setTimeout(runNextTest(), 5000);
 254         } else {
 255             runNextTest();
 256         }
 257     }
 258 };
 259
 260 initGLForBufferSizesTest();
 261 runNextTest();
 262
 263 var successfullyParsed = true;
 264 </script>
 265
 266 </body>
 267 </html>
 268