From 50ed816a06c4b4c879dcc560fa8da9ffbe572cba Mon Sep 17 00:00:00 2001 From: ShuaixinHuang <1836656514@qq.com> Date: Thu, 19 Nov 2026 19:48:14 +0800 Subject: [PATCH] fix(gpu): read PTX integer literals in array parameter layouts (#12229) * fix(gpu): read PTX integer literals in array parameter layouts * fix(gpu): keep overflowing PTX layouts partial --------- Co-authored-by: morluto <76467478+morluto@users.noreply.github.com> --- src/gpu/PtxKernels.test.ts | 36 +++++++++++++++++++ src/gpu/PtxKernels.ts | 49 ++++++++++++++------------ tests/boundary/gpu/codeObjects.test.ts | 38 +++++++++++++++++++- 3 files changed, 100 insertions(+), 23 deletions(-) diff --git a/src/gpu/PtxKernels.test.ts b/src/gpu/PtxKernels.test.ts index 379c8ccb6c..6e5372a5da 100644 --- a/src/gpu/PtxKernels.test.ts +++ b/src/gpu/PtxKernels.test.ts @@ -91,6 +91,42 @@ it.each([ expect(row!.coverage).toBe(coverage); }, ); +it.each(["010", "0x8", "0B1000", "8U"])( + "uses the PTX integer literal %s in parameter layout", + (extent) => { + const [row] = [ + ...readPtxKernels( + `.entry k(.param .b8 bytes[${extent}], .param .u32 count) { ret; }`, + "object", + ), + ]; + expect( + row?.kernel.parameters.map(({ offset, size }) => [offset, size]), + ).toEqual([ + [0, 8], + [8, 4], + ]); + expect(row?.coverage).toBe("complete"); + }, +); + +it.each(["08", "0x", "0b2", "0x20000000000000"])( + "keeps parameter layout unknown for an invalid or unsafe extent %s", + (extent) => { + const [row] = [ + ...readPtxKernels( + `.entry k(.param .b8 bytes[${extent}]) { ret; }`, + "object", + ), + ]; + expect(row?.kernel.parameters[0]).toMatchObject({ + name: "bytes", + size: null, + }); + expect(row?.coverage).toBe("partial"); + }, +); + it("retains a parameter name when a qualifier is unknown", () => { const [row] = [ ...readPtxKernels( diff --git a/src/gpu/PtxKernels.ts b/src/gpu/PtxKernels.ts index a0aab66d90..b3ae5aa3e4 100644 --- a/src/gpu/PtxKernels.ts +++ b/src/gpu/PtxKernels.ts @@ -82,9 +82,25 @@ const integer = (token: string | undefined): number | null => { const value = Number(token); return Number.isSafeInteger(value) ? value : null; }; +/** Read a single nonnegative PTX integer literal used as an array extent. */ +const arrayExtent = (token: string | undefined): number | null => { + if (token === undefined) return null; + const digits = token.endsWith("U") ? token.slice(0, -1) : token; + if (/^0[0-7]+$/u.test(digits)) { + const value = Number(`0o${digits.slice(1)}`); + return Number.isSafeInteger(value) ? value : null; + } + if (!/^0(?:[xX][0-9a-fA-F]+|[bB][01]+)$/u.test(digits)) + return integer(digits); + const value = Number(digits); + return Number.isSafeInteger(value) ? value : null; +}; const alignmentValue = (token: string | undefined): number | null => { const value = integer(token); - return value !== null && value > 0 && Number.isInteger(Math.log2(value)) + // A logarithm can round a neighboring large integer to a whole exponent. + return value !== null && + value > 0 && + 2 ** Math.round(Math.log2(value)) === value ? value : null; }; @@ -230,18 +246,14 @@ const declaration = ( const align = explicit ? alignment : size; if (dimensions.length === 1) { const dimension = dimensions[0]!, - count = dimension.length === 1 ? integer(dimension[0]) : null; + count = dimension.length === 1 ? arrayExtent(dimension[0]) : null; if (count === null || size === null || !Number.isSafeInteger(count * size)) layoutKnown = false; else size *= count; } - if ( - name === null || - align === null || - align <= 0 || - !Number.isInteger(Math.log2(align)) || - !layoutKnown - ) + // Explicit alignment was checked at admission. Natural alignment comes + // from the supported power-of-two scalar and vector sizes. + if (align === null || !layoutKnown) return { name, type, size: null, align: null }; return { name, type, size, align }; }; @@ -304,14 +316,12 @@ export function* readPtxKernels( if ( parameterBytes !== null && value.size !== null && - value.align !== null && - value.align > 0 && - Number.isSafeInteger(value.align) + value.align !== null ) { - offset = Math.ceil(parameterBytes / value.align) * value.align; - parameterBytes = Number.isSafeInteger(offset + value.size) - ? offset + value.size - : null; + const aligned = Math.ceil(parameterBytes / value.align) * value.align; + const end = aligned + value.size; + offset = Number.isSafeInteger(aligned) ? aligned : null; + parameterBytes = Number.isSafeInteger(end) ? end : null; } else parameterBytes = null; parameters.push({ ordinal: parameters.length, @@ -442,12 +452,7 @@ export function* readPtxKernels( declarationTokens.push(t.value); } const value = declaration(declarationTokens); - if ( - shared === null || - value.size === null || - value.align === null || - value.align === 0 - ) + if (shared === null || value.size === null || value.align === null) shared = null; else { const total = diff --git a/tests/boundary/gpu/codeObjects.test.ts b/tests/boundary/gpu/codeObjects.test.ts index 85321b4dda..324ac34b19 100644 --- a/tests/boundary/gpu/codeObjects.test.ts +++ b/tests/boundary/gpu/codeObjects.test.ts @@ -847,7 +847,43 @@ it.each([".align 8 .b8", ".b8 .align 8"])( }); }, ); -it.each([".b8 .align 3", ".align 8 .b8 .align 8"])( +it.each(["9007199254740991", "0x1fffffffffffff"])( + "retains PTX parameter facts when aligning an extent of %s exceeds the exact range", + async (extent) => { + const result = await inspect( + Buffer.from( + `.version 8.0 +.target sm_80 +.entry wide(.param .b8 payload[${extent}], .param .u32 count, .param .u8 tail) { ret; } +.entry later(.param .u32 value) { ret; }`, + ), + ); + if (!result.ok) throw result.error; + expect(result.value.coverage.payloads).toBe("partial"); + expect(result.value.kernels).toMatchObject([ + { + name: "wide", + parameter_bytes: null, + parameters: [ + { name: "payload", offset: 0, size: 9007199254740991 }, + { name: "count", offset: null, size: 4 }, + { name: "tail", offset: null, size: 1 }, + ], + }, + { + name: "later", + parameter_bytes: 4, + parameters: [{ name: "value", offset: 0, size: 4 }], + }, + ]); + }, +); + +it.each([ + ".b8 .align 3", + ".b8 .align 4503599627370495", + ".align 8 .b8 .align 8", +])( "retains PTX names and partial layout for unsupported alignment %s", async (type) => { const bytes = Buffer.from(