mirror of
https://github.com/gpujs/gpu.js.git
synced 2025-12-08 20:35:56 +00:00
575 lines
17 KiB
JavaScript
575 lines
17 KiB
JavaScript
const { assert, skip, test, module: describe, only } = require('qunit');
|
|
const { GPU } = require('../../src');
|
|
|
|
describe('feature: bitwise operators');
|
|
|
|
function testBitwiseAndSinglePrecision(mode) {
|
|
const gpu = new GPU({ mode });
|
|
const kernel = gpu.createKernel(function(v1, v2) {
|
|
return v1 & v2;
|
|
})
|
|
.setOutput([1])
|
|
.setPrecision('single');
|
|
|
|
for (let i = 0; i < 10; i++) {
|
|
for (let j = 0; j < 10; j++) {
|
|
assert.equal(kernel(i, j)[0], i & j);
|
|
}
|
|
}
|
|
|
|
gpu.destroy();
|
|
}
|
|
|
|
(GPU.isSinglePrecisionSupported ? test : skip)('bitwise AND single precision auto', () => {
|
|
testBitwiseAndSinglePrecision();
|
|
});
|
|
|
|
(GPU.isSinglePrecisionSupported ? test : skip)('bitwise AND single precision gpu', () => {
|
|
testBitwiseAndSinglePrecision('gpu');
|
|
});
|
|
|
|
(GPU.isWebGLSupported && GPU.isSinglePrecisionSupported ? test : skip)('bitwise AND single precision webgl', () => {
|
|
testBitwiseAndSinglePrecision('webgl');
|
|
});
|
|
|
|
(GPU.isWebGL2Supported ? test : skip)('bitwise AND single precision webgl2', () => {
|
|
testBitwiseAndSinglePrecision('webgl2');
|
|
});
|
|
|
|
(GPU.isHeadlessGLSupported && GPU.isSinglePrecisionSupported ? test : skip)('bitwise AND single precision headlessgl', () => {
|
|
testBitwiseAndSinglePrecision('headlessgl');
|
|
});
|
|
|
|
test('bitwise AND single precision cpu', () => {
|
|
testBitwiseAndSinglePrecision('cpu');
|
|
});
|
|
|
|
function testBitwiseAndUnsignedPrecision(mode) {
|
|
const gpu = new GPU({ mode });
|
|
const kernel = gpu.createKernel(function(v1, v2) {
|
|
return v1 & v2;
|
|
})
|
|
.setOutput([1])
|
|
.setPrecision('unsigned');
|
|
|
|
for (let i = 0; i < 10; i++) {
|
|
for (let j = 0; j < 10; j++) {
|
|
assert.equal(kernel(i, j)[0], i & j);
|
|
}
|
|
}
|
|
|
|
gpu.destroy();
|
|
}
|
|
|
|
test('bitwise AND unsigned precision auto', () => {
|
|
testBitwiseAndUnsignedPrecision();
|
|
});
|
|
|
|
test('bitwise AND unsigned precision gpu', () => {
|
|
testBitwiseAndUnsignedPrecision('gpu');
|
|
});
|
|
|
|
(GPU.isWebGLSupported ? test : skip)('bitwise AND unsigned precision webgl', () => {
|
|
testBitwiseAndUnsignedPrecision('webgl');
|
|
});
|
|
|
|
(GPU.isWebGL2Supported ? test : skip)('bitwise AND unsigned precision webgl2', () => {
|
|
testBitwiseAndUnsignedPrecision('webgl2');
|
|
});
|
|
|
|
(GPU.isHeadlessGLSupported ? test : skip)('bitwise AND unsigned precision headlessgl', () => {
|
|
testBitwiseAndUnsignedPrecision('headlessgl');
|
|
});
|
|
|
|
test('bitwise AND unsigned precision cpu', () => {
|
|
testBitwiseAndUnsignedPrecision('cpu');
|
|
});
|
|
|
|
function testBitwiseOrSinglePrecision(mode) {
|
|
const gpu = new GPU({ mode });
|
|
const kernel = gpu.createKernel(function(v1, v2) {
|
|
return v1 | v2;
|
|
})
|
|
.setOutput([1])
|
|
.setPrecision('single');
|
|
|
|
for (let i = 0; i < 10; i++) {
|
|
for (let j = 0; j < 10; j++) {
|
|
assert.equal(kernel(i, j)[0], i | j);
|
|
}
|
|
}
|
|
|
|
gpu.destroy();
|
|
}
|
|
|
|
(GPU.isSinglePrecisionSupported ? test : skip)('bitwise OR single precision auto', () => {
|
|
testBitwiseOrSinglePrecision();
|
|
});
|
|
|
|
(GPU.isSinglePrecisionSupported ? test : skip)('bitwise OR single precision gpu', () => {
|
|
testBitwiseOrSinglePrecision('gpu');
|
|
});
|
|
|
|
(GPU.isWebGLSupported && GPU.isSinglePrecisionSupported ? test : skip)('bitwise OR single precision webgl', () => {
|
|
testBitwiseOrSinglePrecision('webgl');
|
|
});
|
|
|
|
(GPU.isWebGL2Supported ? test : skip)('bitwise OR single precision webgl2', () => {
|
|
testBitwiseOrSinglePrecision('webgl2');
|
|
});
|
|
|
|
(GPU.isHeadlessGLSupported && GPU.isSinglePrecisionSupported? test : skip)('bitwise OR single precision headlessgl', () => {
|
|
testBitwiseOrSinglePrecision('headlessgl');
|
|
});
|
|
|
|
test('bitwise OR single precision cpu', () => {
|
|
testBitwiseOrSinglePrecision('cpu');
|
|
});
|
|
|
|
function testBitwiseOrUnsignedPrecision(mode) {
|
|
const gpu = new GPU({ mode });
|
|
const kernel = gpu.createKernel(function(v1, v2) {
|
|
return v1 | v2;
|
|
})
|
|
.setOutput([1])
|
|
.setPrecision('unsigned');
|
|
|
|
for (let i = 0; i < 10; i++) {
|
|
for (let j = 0; j < 10; j++) {
|
|
assert.equal(kernel(i, j)[0], i | j);
|
|
}
|
|
}
|
|
|
|
gpu.destroy();
|
|
}
|
|
|
|
test('bitwise OR unsigned precision auto', () => {
|
|
testBitwiseOrUnsignedPrecision();
|
|
});
|
|
|
|
test('bitwise OR unsigned precision gpu', () => {
|
|
testBitwiseOrUnsignedPrecision('gpu');
|
|
});
|
|
|
|
(GPU.isWebGLSupported ? test : skip)('bitwise OR unsigned precision webgl', () => {
|
|
testBitwiseOrUnsignedPrecision('webgl');
|
|
});
|
|
|
|
(GPU.isWebGL2Supported ? test : skip)('bitwise OR unsigned precision webgl2', () => {
|
|
testBitwiseOrUnsignedPrecision('webgl2');
|
|
});
|
|
|
|
(GPU.isHeadlessGLSupported ? test : skip)('bitwise OR unsigned precision headlessgl', () => {
|
|
testBitwiseOrUnsignedPrecision('headlessgl');
|
|
});
|
|
|
|
test('bitwise OR unsigned precision cpu', () => {
|
|
testBitwiseOrUnsignedPrecision('cpu');
|
|
});
|
|
|
|
function testBitwiseXORSinglePrecision(mode) {
|
|
const gpu = new GPU({ mode });
|
|
const kernel = gpu.createKernel(function(v1, v2) {
|
|
return v1 ^ v2;
|
|
})
|
|
.setOutput([1])
|
|
.setPrecision('single');
|
|
|
|
for (let i = 0; i < 10; i++) {
|
|
for (let j = 0; j < 10; j++) {
|
|
assert.equal(kernel(i, j)[0], i ^ j);
|
|
}
|
|
}
|
|
|
|
gpu.destroy();
|
|
}
|
|
|
|
(GPU.isSinglePrecisionSupported ? test : skip)('bitwise XOR single precision auto', () => {
|
|
testBitwiseXORSinglePrecision();
|
|
});
|
|
|
|
(GPU.isSinglePrecisionSupported ? test : skip)('bitwise XOR single precision gpu', () => {
|
|
testBitwiseXORSinglePrecision('gpu');
|
|
});
|
|
|
|
(GPU.isWebGLSupported && GPU.isSinglePrecisionSupported ? test : skip)('bitwise XOR single precision webgl', () => {
|
|
testBitwiseXORSinglePrecision('webgl');
|
|
});
|
|
|
|
(GPU.isWebGL2Supported ? test : skip)('bitwise XOR single precision webgl2', () => {
|
|
testBitwiseXORSinglePrecision('webgl2');
|
|
});
|
|
|
|
(GPU.isHeadlessGLSupported && GPU.isSinglePrecisionSupported ? test : skip)('bitwise XOR single precision headlessgl', () => {
|
|
testBitwiseXORSinglePrecision('headlessgl');
|
|
});
|
|
|
|
test('bitwise XOR single precision cpu', () => {
|
|
testBitwiseXORSinglePrecision('cpu');
|
|
});
|
|
|
|
function testBitwiseXORUnsignedPrecision(mode) {
|
|
const gpu = new GPU({ mode });
|
|
const kernel = gpu.createKernel(function(v1, v2) {
|
|
return v1 ^ v2;
|
|
})
|
|
.setOutput([1])
|
|
.setPrecision('unsigned');
|
|
|
|
for (let i = 0; i < 10; i++) {
|
|
for (let j = 0; j < 10; j++) {
|
|
assert.equal(kernel(i, j)[0], i ^ j);
|
|
}
|
|
}
|
|
|
|
gpu.destroy();
|
|
}
|
|
|
|
test('bitwise XOR unsigned precision auto', () => {
|
|
testBitwiseXORUnsignedPrecision();
|
|
});
|
|
|
|
test('bitwise XOR unsigned precision gpu', () => {
|
|
testBitwiseXORUnsignedPrecision('gpu');
|
|
});
|
|
|
|
(GPU.isWebGLSupported ? test : skip)('bitwise XOR unsigned precision webgl', () => {
|
|
testBitwiseXORUnsignedPrecision('webgl');
|
|
});
|
|
|
|
(GPU.isWebGL2Supported ? test : skip)('bitwise XOR unsigned precision webgl2', () => {
|
|
testBitwiseXORUnsignedPrecision('webgl2');
|
|
});
|
|
|
|
(GPU.isHeadlessGLSupported ? test : skip)('bitwise XOR unsigned precision headlessgl', () => {
|
|
testBitwiseXORUnsignedPrecision('headlessgl');
|
|
});
|
|
|
|
test('bitwise XOR unsigned precision cpu', () => {
|
|
testBitwiseXORUnsignedPrecision('cpu');
|
|
});
|
|
|
|
function testBitwiseNotSinglePrecision(mode) {
|
|
const gpu = new GPU({ mode });
|
|
const kernel = gpu.createKernel(function(v1) {
|
|
return ~v1;
|
|
})
|
|
.setOutput([1])
|
|
.setPrecision('single');
|
|
|
|
for (let i = 0; i < 10; i++) {
|
|
assert.equal(kernel(i)[0], ~i);
|
|
}
|
|
|
|
gpu.destroy();
|
|
}
|
|
|
|
(GPU.isSinglePrecisionSupported ? test : skip)('bitwise NOT single precision auto', () => {
|
|
testBitwiseNotSinglePrecision();
|
|
});
|
|
|
|
(GPU.isSinglePrecisionSupported ? test : skip)('bitwise NOT single precision gpu', () => {
|
|
testBitwiseNotSinglePrecision('gpu');
|
|
});
|
|
|
|
(GPU.isWebGLSupported && GPU.isSinglePrecisionSupported ? test : skip)('bitwise NOT single precision webgl', () => {
|
|
testBitwiseNotSinglePrecision('webgl');
|
|
});
|
|
|
|
(GPU.isWebGL2Supported ? test : skip)('bitwise NOT single precision webgl2', () => {
|
|
testBitwiseNotSinglePrecision('webgl2');
|
|
});
|
|
|
|
(GPU.isHeadlessGLSupported && GPU.isSinglePrecisionSupported ? test : skip)('bitwise NOT single precision headlessgl', () => {
|
|
testBitwiseNotSinglePrecision('headlessgl');
|
|
});
|
|
|
|
test('bitwise NOT single precision cpu', () => {
|
|
testBitwiseNotSinglePrecision('cpu');
|
|
});
|
|
|
|
function testBitwiseNotUnsignedPrecision(mode) {
|
|
const gpu = new GPU({ mode });
|
|
const kernel = gpu.createKernel(function(v1) {
|
|
return ~v1;
|
|
})
|
|
.setOutput([1])
|
|
.setPrecision('unsigned');
|
|
|
|
for (let i = 0; i < 10; i++) {
|
|
assert.equal(kernel(i)[0], ~i);
|
|
}
|
|
|
|
gpu.destroy();
|
|
}
|
|
|
|
test('bitwise NOT unsigned precision auto', () => {
|
|
testBitwiseNotUnsignedPrecision();
|
|
});
|
|
|
|
test('bitwise NOT unsigned precision gpu', () => {
|
|
testBitwiseNotUnsignedPrecision('gpu');
|
|
});
|
|
|
|
(GPU.isWebGLSupported ? test : skip)('bitwise NOT unsigned precision webgl', () => {
|
|
testBitwiseNotUnsignedPrecision('webgl');
|
|
});
|
|
|
|
(GPU.isWebGL2Supported ? test : skip)('bitwise NOT unsigned precision webgl2', () => {
|
|
testBitwiseNotUnsignedPrecision('webgl2');
|
|
});
|
|
|
|
(GPU.isHeadlessGLSupported ? test : skip)('bitwise NOT unsigned precision headlessgl', () => {
|
|
testBitwiseNotUnsignedPrecision('headlessgl');
|
|
});
|
|
|
|
test('bitwise NOT unsigned precision cpu', () => {
|
|
testBitwiseNotUnsignedPrecision('cpu');
|
|
});
|
|
|
|
function testBitwiseZeroFillLeftShiftSinglePrecision(mode) {
|
|
const gpu = new GPU({ mode });
|
|
const kernel = gpu.createKernel(function(v1, v2) {
|
|
return v1 << v2;
|
|
})
|
|
.setOutput([1])
|
|
.setPrecision('single');
|
|
|
|
for (let i = 0; i < 10; i++) {
|
|
for (let j = 0; j < 10; j++) {
|
|
assert.equal(kernel(i, j)[0], i << j);
|
|
}
|
|
}
|
|
|
|
gpu.destroy();
|
|
}
|
|
|
|
(GPU.isSinglePrecisionSupported ? test : skip)('bitwise zero fill left shift single precision auto', () => {
|
|
testBitwiseZeroFillLeftShiftSinglePrecision();
|
|
});
|
|
|
|
(GPU.isSinglePrecisionSupported ? test : skip)('bitwise zero fill left shift single precision gpu', () => {
|
|
testBitwiseZeroFillLeftShiftSinglePrecision('gpu');
|
|
});
|
|
|
|
(GPU.isWebGLSupported && GPU.isSinglePrecisionSupported ? test : skip)('bitwise zero fill left shift single precision webgl', () => {
|
|
testBitwiseZeroFillLeftShiftSinglePrecision('webgl');
|
|
});
|
|
|
|
(GPU.isWebGL2Supported ? test : skip)('bitwise zero fill left shift single precision webgl2', () => {
|
|
testBitwiseZeroFillLeftShiftSinglePrecision('webgl2');
|
|
});
|
|
|
|
(GPU.isHeadlessGLSupported && GPU.isSinglePrecisionSupported ? test : skip)('bitwise zero fill left shift single precision headlessgl', () => {
|
|
testBitwiseZeroFillLeftShiftSinglePrecision('headlessgl');
|
|
});
|
|
|
|
test('bitwise zero fill left shift single precision cpu', () => {
|
|
testBitwiseZeroFillLeftShiftSinglePrecision('cpu');
|
|
});
|
|
|
|
function testBitwiseZeroFillLeftShiftUnsignedPrecision(mode) {
|
|
const gpu = new GPU({ mode });
|
|
const kernel = gpu.createKernel(function(v1, v2) {
|
|
return v1 << v2;
|
|
})
|
|
.setOutput([1])
|
|
.setPrecision('unsigned');
|
|
|
|
for (let i = 0; i < 10; i++) {
|
|
for (let j = 0; j < 10; j++) {
|
|
assert.equal(kernel(i, j)[0], i << j);
|
|
}
|
|
}
|
|
|
|
gpu.destroy();
|
|
}
|
|
|
|
test('bitwise zero fill left shift unsigned precision auto', () => {
|
|
testBitwiseZeroFillLeftShiftUnsignedPrecision();
|
|
});
|
|
|
|
test('bitwise zero fill left shift unsigned precision gpu', () => {
|
|
testBitwiseZeroFillLeftShiftUnsignedPrecision('gpu');
|
|
});
|
|
|
|
(GPU.isWebGLSupported ? test : skip)('bitwise zero fill left shift unsigned precision webgl', () => {
|
|
testBitwiseZeroFillLeftShiftUnsignedPrecision('webgl');
|
|
});
|
|
|
|
(GPU.isWebGL2Supported ? test : skip)('bitwise zero fill left shift unsigned precision webgl2', () => {
|
|
testBitwiseZeroFillLeftShiftUnsignedPrecision('webgl2');
|
|
});
|
|
|
|
(GPU.isHeadlessGLSupported ? test : skip)('bitwise zero fill left shift unsigned precision headlessgl', () => {
|
|
testBitwiseZeroFillLeftShiftUnsignedPrecision('headlessgl');
|
|
});
|
|
|
|
test('bitwise zero fill left shift unsigned precision cpu', () => {
|
|
testBitwiseZeroFillLeftShiftUnsignedPrecision('cpu');
|
|
});
|
|
|
|
function testBitwiseSignedRightShiftSinglePrecision(mode) {
|
|
const gpu = new GPU({ mode });
|
|
const kernel = gpu.createKernel(function(v1, v2) {
|
|
return v1 >> v2;
|
|
})
|
|
.setOutput([1])
|
|
.setPrecision('single');
|
|
|
|
for (let i = 0; i < 10; i++) {
|
|
for (let j = 0; j < 10; j++) {
|
|
assert.equal(kernel(i, j)[0], i >> j);
|
|
}
|
|
}
|
|
|
|
gpu.destroy();
|
|
}
|
|
|
|
(GPU.isSinglePrecisionSupported ? test : skip)('bitwise signed fill right shift single precision auto', () => {
|
|
testBitwiseSignedRightShiftSinglePrecision();
|
|
});
|
|
|
|
(GPU.isSinglePrecisionSupported ? test : skip)('bitwise signed fill right shift single precision gpu', () => {
|
|
testBitwiseSignedRightShiftSinglePrecision('gpu');
|
|
});
|
|
|
|
(GPU.isWebGLSupported && GPU.isSinglePrecisionSupported ? test : skip)('bitwise signed fill right shift single precision webgl', () => {
|
|
testBitwiseSignedRightShiftSinglePrecision('webgl');
|
|
});
|
|
|
|
(GPU.isWebGL2Supported ? test : skip)('bitwise signed fill right shift single precision webgl2', () => {
|
|
testBitwiseSignedRightShiftSinglePrecision('webgl2');
|
|
});
|
|
|
|
(GPU.isHeadlessGLSupported && GPU.isSinglePrecisionSupported ? test : skip)('bitwise signed fill right shift single precision headlessgl', () => {
|
|
testBitwiseSignedRightShiftSinglePrecision('headlessgl');
|
|
});
|
|
|
|
test('bitwise signed fill right shift single precision cpu', () => {
|
|
testBitwiseSignedRightShiftSinglePrecision('cpu');
|
|
});
|
|
|
|
function testBitwiseSignedRightShiftUnsignedPrecision(mode) {
|
|
const gpu = new GPU({ mode });
|
|
const kernel = gpu.createKernel(function(v1, v2) {
|
|
return v1 >> v2;
|
|
})
|
|
.setOutput([1])
|
|
.setPrecision('unsigned');
|
|
|
|
for (let i = 0; i < 10; i++) {
|
|
for (let j = 0; j < 10; j++) {
|
|
assert.equal(kernel(i, j)[0], i >> j);
|
|
}
|
|
}
|
|
|
|
gpu.destroy();
|
|
}
|
|
|
|
test('bitwise signed fill right shift unsigned precision auto', () => {
|
|
testBitwiseSignedRightShiftUnsignedPrecision();
|
|
});
|
|
|
|
test('bitwise signed fill right shift unsigned precision gpu', () => {
|
|
testBitwiseSignedRightShiftUnsignedPrecision('gpu');
|
|
});
|
|
|
|
(GPU.isWebGLSupported ? test : skip)('bitwise signed fill right shift unsigned precision webgl', () => {
|
|
testBitwiseSignedRightShiftUnsignedPrecision('webgl');
|
|
});
|
|
|
|
(GPU.isWebGL2Supported ? test : skip)('bitwise signed fill right shift unsigned precision webgl2', () => {
|
|
testBitwiseSignedRightShiftUnsignedPrecision('webgl2');
|
|
});
|
|
|
|
(GPU.isHeadlessGLSupported ? test : skip)('bitwise signed fill right shift unsigned precision headlessgl', () => {
|
|
testBitwiseSignedRightShiftUnsignedPrecision('headlessgl');
|
|
});
|
|
|
|
test('bitwise signed fill right shift unsigned precision cpu', () => {
|
|
testBitwiseSignedRightShiftUnsignedPrecision('cpu');
|
|
});
|
|
|
|
function testBitwiseZeroFillRightShiftSinglePrecision(mode) {
|
|
const gpu = new GPU({ mode });
|
|
const kernel = gpu.createKernel(function(v1, v2) {
|
|
return v1 >>> v2;
|
|
})
|
|
.setOutput([1])
|
|
.setPrecision('single');
|
|
|
|
for (let i = 0; i < 10; i++) {
|
|
for (let j = 0; j < 10; j++) {
|
|
assert.equal(kernel(i, j)[0], i >>> j);
|
|
}
|
|
}
|
|
|
|
gpu.destroy();
|
|
}
|
|
|
|
(GPU.isSinglePrecisionSupported ? test : skip)('bitwise zero fill right shift single precision auto', () => {
|
|
testBitwiseZeroFillRightShiftSinglePrecision();
|
|
});
|
|
|
|
(GPU.isSinglePrecisionSupported ? test : skip)('bitwise zero fill right shift single precision gpu', () => {
|
|
testBitwiseZeroFillRightShiftSinglePrecision('gpu');
|
|
});
|
|
|
|
(GPU.isWebGLSupported && GPU.isSinglePrecisionSupported ? test : skip)('bitwise zero fill right shift single precision webgl', () => {
|
|
testBitwiseZeroFillRightShiftSinglePrecision('webgl');
|
|
});
|
|
|
|
(GPU.isWebGL2Supported ? test : skip)('bitwise zero fill right shift single precision webgl2', () => {
|
|
testBitwiseZeroFillRightShiftSinglePrecision('webgl2');
|
|
});
|
|
|
|
(GPU.isHeadlessGLSupported && GPU.isSinglePrecisionSupported ? test : skip)('bitwise zero fill right shift single precision headlessgl', () => {
|
|
testBitwiseZeroFillRightShiftSinglePrecision('headlessgl');
|
|
});
|
|
|
|
test('bitwise zero fill right shift single precision cpu', () => {
|
|
testBitwiseZeroFillRightShiftSinglePrecision('cpu');
|
|
});
|
|
|
|
function testBitwiseZeroFillRightShiftUnsignedPrecision(mode) {
|
|
const gpu = new GPU({ mode });
|
|
const kernel = gpu.createKernel(function(v1, v2) {
|
|
return v1 >>> v2;
|
|
})
|
|
.setOutput([1])
|
|
.setPrecision('unsigned');
|
|
|
|
for (let i = 0; i < 10; i++) {
|
|
for (let j = 0; j < 10; j++) {
|
|
assert.equal(kernel(i, j)[0], i >>> j);
|
|
}
|
|
}
|
|
|
|
gpu.destroy();
|
|
}
|
|
|
|
test('bitwise zero fill right shift unsigned precision auto', () => {
|
|
testBitwiseZeroFillRightShiftUnsignedPrecision();
|
|
});
|
|
|
|
test('bitwise zero fill right shift unsigned precision gpu', () => {
|
|
testBitwiseZeroFillRightShiftUnsignedPrecision('gpu');
|
|
});
|
|
|
|
(GPU.isWebGLSupported ? test : skip)('bitwise zero fill right shift unsigned precision webgl', () => {
|
|
testBitwiseZeroFillRightShiftUnsignedPrecision('webgl');
|
|
});
|
|
|
|
(GPU.isWebGL2Supported ? test : skip)('bitwise zero fill right shift unsigned precision webgl2', () => {
|
|
testBitwiseZeroFillRightShiftUnsignedPrecision('webgl2');
|
|
});
|
|
|
|
(GPU.isHeadlessGLSupported ? test : skip)('bitwise zero fill right shift unsigned precision headlessgl', () => {
|
|
testBitwiseZeroFillRightShiftUnsignedPrecision('headlessgl');
|
|
});
|
|
|
|
test('bitwise zero fill right shift unsigned precision cpu', () => {
|
|
testBitwiseZeroFillRightShiftUnsignedPrecision('cpu');
|
|
});
|