diff options
Diffstat (limited to 'testing/web-platform/tests/webnn/resources/utils.js')
-rw-r--r-- | testing/web-platform/tests/webnn/resources/utils.js | 337 |
1 files changed, 321 insertions, 16 deletions
diff --git a/testing/web-platform/tests/webnn/resources/utils.js b/testing/web-platform/tests/webnn/resources/utils.js index 375c71174a..d1dc0675a7 100644 --- a/testing/web-platform/tests/webnn/resources/utils.js +++ b/testing/web-platform/tests/webnn/resources/utils.js @@ -13,20 +13,33 @@ const TypedArrayDict = { int64: BigInt64Array, }; -const getTypedArrayData = (type, data) => { +// The maximum index to validate for the output's expected value. +const kMaximumIndexToValidate = 1000; + +const getTypedArrayData = (type, size, data) => { let outData; + if (type === 'float16') { + if (typeof (data) === 'number' && size > 1) { + return new TypedArrayDict[type](size).fill(toHalf(data)); + } // workaround to convert Float16 to Uint16 outData = new TypedArrayDict[type](data.length); for (let i = 0; i < data.length; i++) { outData[i] = toHalf(data[i]); } } else if (type === 'int64') { + if (typeof (data) === 'number' && size > 1) { + return new TypedArrayDict[type](size).fill(BigInt(data)); + } outData = new TypedArrayDict[type](data.length); for (let i = 0; i < data.length; i++) { outData[i] = BigInt(data[i]); } } else { + if (typeof (data) === 'number' && size > 1) { + return new TypedArrayDict[type](size).fill(data); + } outData = new TypedArrayDict[type](data); } return outData; @@ -67,25 +80,26 @@ const loadTests = (operationName) => { }; /** - * Get exptected data and data type from given resources with output name. - * @param {Array} resources - An array of expected resources + * Get expected resource from given resources with output name. + * @param {Array} resources - An array of given resources * @param {String} outputName - An output name - * @returns {Array.<[Number[], String]>} An array of expected data array and data type + * @returns {Object} An object of expected resource */ -const getExpectedDataAndType = (resources, outputName) => { +const getNamedResource = (resources, outputName) => { let ret; - for (let subResources of resources) { - if (subResources.name === outputName) { - ret = [subResources.data, subResources.type]; + for (let resource of resources) { + if (resource.name === outputName) { + ret = resource; break; } } if (ret === undefined) { - throw new Error(`Failed to get expected data sources and type by ${outputName}`); + throw new Error(`Failed to get expected resource by ${outputName}`); } return ret; }; + /** * Get ULP tolerance of conv2d/convTranspose2d operation. * @param {Object} resources - Resources used for building a graph @@ -521,13 +535,14 @@ const checkResults = (operationName, namedOutputOperands, outputs, resources) => if (Array.isArray(expected)) { // the outputs of split() or gru() is a sequence for (let operandName in namedOutputOperands) { + const suboutputResource = getNamedResource(expected, operandName); + assert_array_equals(namedOutputOperands[operandName].shape(), suboutputResource.shape ?? []); outputData = outputs[operandName]; - // for some operations which may have multi outputs of different types - [expectedData, operandType] = getExpectedDataAndType(expected, operandName); tolerance = getPrecisonTolerance(operationName, metricType, resources); - doAssert(operationName, outputData, expectedData, tolerance, operandType, metricType) + doAssert(operationName, outputData, suboutputResource.data, tolerance, suboutputResource.type, metricType) } } else { + assert_array_equals(namedOutputOperands[expected.name].shape(), expected.shape ?? []); outputData = outputs[expected.name]; expectedData = expected.data; operandType = expected.type; @@ -543,7 +558,11 @@ const checkResults = (operationName, namedOutputOperands, outputs, resources) => * @returns {MLOperand} A constant operand */ const createConstantOperand = (builder, resources) => { - const bufferView = new TypedArrayDict[resources.type](resources.data); + const bufferView = (typeof (resources.data) === 'number' && + sizeOfShape(resources.shape) > 1) ? + new TypedArrayDict[resources.type](sizeOfShape(resources.shape)) + .fill(resources.data) : + new TypedArrayDict[resources.type](resources.data); return builder.constant({dataType: resources.type, type: resources.type, dimensions: resources.shape}, bufferView); }; @@ -801,14 +820,17 @@ const buildGraph = (operationName, builder, resources, buildFunc) => { // the inputs of concat() is a sequence for (let subInput of resources.inputs) { if (!subInput.hasOwnProperty('constant') || !subInput.constant) { - inputs[subInput.name] = getTypedArrayData(subInput.type, subInput.data); + inputs[subInput.name] = getTypedArrayData( + subInput.type, sizeOfShape(subInput.shape), subInput.data); } } } else { for (let inputName in resources.inputs) { const subTestByName = resources.inputs[inputName]; if (!subTestByName.hasOwnProperty('constant') || !subTestByName.constant) { - inputs[inputName] = getTypedArrayData(subTestByName.type, subTestByName.data); + inputs[inputName] = getTypedArrayData( + subTestByName.type, sizeOfShape(subTestByName.shape), + subTestByName.data); } } } @@ -931,6 +953,7 @@ const toHalf = (value) => { * WebNN buffer creation. * @param {MLContext} context - the context used to create the buffer. * @param {Number} bufferSize - Size of the buffer to create, in bytes. + * @returns {MLBuffer} the created buffer. */ const createBuffer = (context, bufferSize) => { let buffer; @@ -980,4 +1003,286 @@ const testCreateWebNNBuffer = (testName, bufferSize, deviceType = 'cpu') => { promise_test(async () => { createBuffer(context, bufferSize); }, `${testName} / ${bufferSize}`); -};
\ No newline at end of file +}; + +/** + * Asserts the buffer data in MLBuffer matches expected. + * @param {MLContext} ml_context - The context used to create the buffer. + * @param {MLBuffer} ml_buffer - The buffer to read and compare data. + * @param {Array} expected - Array of the expected data in the buffer. + */ +const assert_buffer_data_equals = async (ml_context, ml_buffer, expected) => { + const actual = await ml_context.readBuffer(ml_buffer); + assert_array_equals( + new expected.constructor(actual), expected, + 'Read buffer data equals expected data.'); +}; + +/** + * WebNN write buffer operation test. + * @param {String} testName - The name of the test operation. + * @param {String} deviceType - The execution device type for this test. + */ +const testWriteWebNNBuffer = (testName, deviceType = 'cpu') => { + let ml_context; + promise_setup(async () => { + ml_context = await navigator.ml.createContext({deviceType}); + }); + + promise_test(async () => { + let ml_buffer = createBuffer(ml_context, 4); + + // MLBuffer was unsupported for the deviceType. + if (ml_buffer === undefined) { + return; + } + + let array_buffer = new ArrayBuffer(ml_buffer.size); + + // Writing with a size that goes past that source buffer length. + assert_throws_js( + TypeError, + () => ml_context.writeBuffer( + ml_buffer, new Uint8Array(array_buffer), /*srcOffset=*/ 0, + /*srcSize=*/ ml_buffer.size + 1)); + assert_throws_js( + TypeError, + () => ml_context.writeBuffer( + ml_buffer, new Uint8Array(array_buffer), /*srcOffset=*/ 3, + /*srcSize=*/ 4)); + + // Writing with a source offset that is out of range of the source size. + assert_throws_js( + TypeError, + () => ml_context.writeBuffer( + ml_buffer, new Uint8Array(array_buffer), + /*srcOffset=*/ ml_buffer.size + 1)); + + // Writing with a source offset that is out of range of implicit copy size. + assert_throws_js( + TypeError, + () => ml_context.writeBuffer( + ml_buffer, new Uint8Array(array_buffer), + /*srcOffset=*/ ml_buffer.size + 1, /*srcSize=*/ undefined)); + + assert_throws_js( + TypeError, + () => ml_context.writeBuffer( + ml_buffer, new Uint8Array(array_buffer), /*srcOffset=*/ undefined, + /*srcSize=*/ ml_buffer.size + 1)); + + assert_throws_js( + TypeError, + () => ml_context.writeBuffer( + ml_buffer, Uint8Array.from([0xEE, 0xEE, 0xEE, 0xEE, 0xEE]))); + }, `${testName} / error`); + + promise_test(async () => { + let ml_buffer = createBuffer(ml_context, 4); + + // MLBuffer was unsupported for the deviceType. + if (ml_buffer === undefined) { + return; + } + + // Writing data to a destroyed MLBuffer should throw. + ml_buffer.destroy(); + + assert_throws_dom( + 'InvalidStateError', + () => + ml_context.writeBuffer(ml_buffer, new Uint8Array(ml_buffer.size))); + }, `${testName} / destroy`); + + promise_test(async () => { + let ml_buffer = createBuffer(ml_context, 4); + + // MLBuffer was unsupported for the deviceType. + if (ml_buffer === undefined) { + return; + } + + const array_buffer = new ArrayBuffer(ml_buffer.size); + const detached_buffer = array_buffer.transfer(); + assert_true(array_buffer.detached, 'array buffer should be detached.'); + + ml_context.writeBuffer(ml_buffer, array_buffer); + }, `${testName} / detached`); + + promise_test(async () => { + let ml_buffer = createBuffer(ml_context, 4); + + // MLBuffer was unsupported for the deviceType. + if (ml_buffer === undefined) { + return; + } + + let another_ml_context = await navigator.ml.createContext({deviceType}); + let another_ml_buffer = createBuffer(another_ml_context, ml_buffer.size); + + let input_data = new Uint8Array(ml_buffer.size).fill(0xAA); + assert_throws_js( + TypeError, () => ml_context.writeBuffer(another_ml_buffer, input_data)); + assert_throws_js( + TypeError, () => another_ml_context.writeBuffer(ml_buffer, input_data)); + }, `${testName} / context_mismatch`); +}; + +/** + * WebNN read buffer operation test. + * @param {String} testName - The name of the test operation. + * @param {String} deviceType - The execution device type for this test. + */ +const testReadWebNNBuffer = (testName, deviceType = 'cpu') => { + let ml_context; + promise_setup(async () => { + ml_context = await navigator.ml.createContext({deviceType}); + }); + + promise_test(async t => { + let ml_buffer = createBuffer(ml_context, 4); + + // MLBuffer was unsupported for the deviceType. + if (ml_buffer === undefined) { + return; + } + + // Reading a destroyed MLBuffer should reject. + ml_buffer.destroy(); + + await promise_rejects_dom( + t, 'InvalidStateError', ml_context.readBuffer(ml_buffer)); + }, `${testName} / destroy`); + + promise_test(async () => { + let ml_buffer = createBuffer(ml_context, 4); + + // MLBuffer was unsupported for the deviceType. + if (ml_buffer === undefined) { + return; + } + + // Initialize the buffer. + ml_context.writeBuffer( + ml_buffer, Uint8Array.from([0xAA, 0xAA, 0xAA, 0xAA])); + + ml_context.writeBuffer(ml_buffer, Uint32Array.from([0xBBBBBBBB])); + await assert_buffer_data_equals( + ml_context, ml_buffer, Uint32Array.from([0xBBBBBBBB])); + ; + }, `${testName} / full_size`); + + promise_test(async () => { + let ml_buffer = createBuffer(ml_context, 4); + + // MLBuffer was unsupported for the deviceType. + if (ml_buffer === undefined) { + return; + } + + // Initialize the buffer. + ml_context.writeBuffer( + ml_buffer, Uint8Array.from([0xAA, 0xAA, 0xAA, 0xAA])); + + // Writing to the remainder of the buffer from source offset. + ml_context.writeBuffer( + ml_buffer, Uint8Array.from([0xCC, 0xCC, 0xBB, 0xBB]), + /*srcOffset=*/ 2); + await assert_buffer_data_equals( + ml_context, ml_buffer, Uint8Array.from([0xBB, 0xBB, 0xAA, 0xAA])); + }, `${testName} / src_offset_only`); + + promise_test(async () => { + let ml_buffer = createBuffer(ml_context, 4); + + // MLBuffer was unsupported for the deviceType. + if (ml_buffer === undefined) { + return; + } + + // Initialize the buffer. + const input_data = [0xAA, 0xAA, 0xAA, 0xAA]; + ml_context.writeBuffer(ml_buffer, Uint8Array.from(input_data)); + + // Writing zero bytes at the end of the buffer. + ml_context.writeBuffer( + ml_buffer, Uint32Array.from([0xBBBBBBBB]), /*srcOffset=*/ 1); + await assert_buffer_data_equals( + ml_context, ml_buffer, Uint8Array.from(input_data)); + }, `${testName} / zero_write`); + + promise_test(async () => { + let ml_buffer = createBuffer(ml_context, 4); + + // MLBuffer was unsupported for the deviceType. + if (ml_buffer === undefined) { + return; + } + + // Initialize the buffer. + ml_context.writeBuffer( + ml_buffer, Uint8Array.from([0xAA, 0xAA, 0xAA, 0xAA])); + + // Writing with both a source offset and size. + ml_context.writeBuffer( + ml_buffer, Uint8Array.from([0xDD, 0xDD, 0xCC, 0xDD]), + /*srcOffset=*/ 2, /*srcSize=*/ 1); + await assert_buffer_data_equals( + ml_context, ml_buffer, Uint8Array.from([0xCC, 0xAA, 0xAA, 0xAA])); + }, `${testName} / src_offset_and_size`); + + promise_test(async () => { + let ml_buffer = createBuffer(ml_context, 4); + + // MLBuffer was unsupported for the deviceType. + if (ml_buffer === undefined) { + return; + } + + // Initialize the buffer. + ml_context.writeBuffer( + ml_buffer, Uint8Array.from([0xAA, 0xAA, 0xAA, 0xAA])); + + // Using an offset allows a larger source buffer to fit. + ml_context.writeBuffer( + ml_buffer, Uint8Array.from([0xEE, 0xEE, 0xEE, 0xEE, 0xEE]), + /*srcOffset=*/ 1); + await assert_buffer_data_equals( + ml_context, ml_buffer, Uint8Array.from([0xEE, 0xEE, 0xEE, 0xEE])); + }, `${testName} / larger_src_data`); + + promise_test(async () => { + let ml_buffer = createBuffer(ml_context, 4); + + // MLBuffer was unsupported for the deviceType. + if (ml_buffer === undefined) { + return; + } + + const input_data = [0xAA, 0xAA, 0xAA, 0xAA]; + + // Writing with a source offset of undefined should be treated as 0. + ml_context.writeBuffer( + ml_buffer, Uint8Array.from(input_data), /*srcOffset=*/ undefined, + /*srcSize=*/ input_data.length); + await assert_buffer_data_equals( + ml_context, ml_buffer, Uint8Array.from(input_data)); + }, `${testName} / no_src_offset`); + + promise_test(async t => { + let ml_buffer = createBuffer(ml_context, 4); + + // MLBuffer was unsupported for the deviceType. + if (ml_buffer === undefined) { + return; + } + + let another_ml_context = await navigator.ml.createContext({deviceType}); + let another_ml_buffer = createBuffer(another_ml_context, ml_buffer.size); + + await promise_rejects_js( + t, TypeError, ml_context.readBuffer(another_ml_buffer)); + await promise_rejects_js( + t, TypeError, another_ml_context.readBuffer(ml_buffer)); + }, `${testName} / context_mismatch`); +}; |