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>
This commit is contained in:
ShuaixinHuangandmorluto authored and GitHub committed 2026-11-19 11:48:14 +00:00
1 parent 9477d34fa5
commit 50ed816a06
3 files changed
+100 -23

No files matched your search

+36
View File
@@ -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(
+27 -22
View File
@@ -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 =
+37 -1
View File
@@ -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(