mirror of
https://github.com/morluto/rea
synced 2026-10-26 14:25:49 -04:00
morluto
1222 lines
44 KiB
TypeScript
1222 lines
44 KiB
TypeScript
import { expect, it, onTestFinished } from "vitest";
|
|
import { writeFile } from "node:fs/promises";
|
|
import { join } from "node:path";
|
|
import { deflateSync } from "node:zlib";
|
|
import { createHash } from "node:crypto";
|
|
import { parseEvidence } from "../../../src/domain/evidence.js";
|
|
import { gpuCodeObjectsPartialSchema } from "../../../src/domain/gpu/gpuCodeObjects.js";
|
|
import { GpuCodeObjectsProvider } from "../../../src/gpu/GpuCodeObjectsProvider.js";
|
|
import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js";
|
|
import {
|
|
cudaFixture,
|
|
cubinFixture,
|
|
ccobFixture,
|
|
hipFixture,
|
|
peGpuFixture,
|
|
elfFixture,
|
|
ptxFixture,
|
|
amdFixture,
|
|
amdNoteFixture,
|
|
llvmBitcodeFixture,
|
|
} from "../../fixtures/gpu/codeObjects.js";
|
|
const inspect = async (
|
|
bytes: Buffer,
|
|
options: {
|
|
analysis?: "inventory" | "kernels";
|
|
targets?: string[];
|
|
object_ids?: string[];
|
|
expected_sha256?: string;
|
|
} = {},
|
|
) => {
|
|
const root = await createTestTempDirectory("rea-gpu-"),
|
|
path = join(root, "no-format-extension");
|
|
await writeFile(path, bytes);
|
|
const provider = new GpuCodeObjectsProvider();
|
|
onTestFinished(() => provider.close());
|
|
return provider.inspect({ path, analysis: "kernels", ...options });
|
|
};
|
|
it.each(["none", "zstd"] as const)(
|
|
"reads selected CUDA metadata and PTX with %s compression",
|
|
async (compression) => {
|
|
const result = await inspect(cudaFixture(compression));
|
|
if (!result.ok) throw result.error;
|
|
expect(result.value.coverage).toMatchObject({
|
|
discovery: "complete",
|
|
payloads: "complete",
|
|
});
|
|
expect(
|
|
result.value.kernels.map((row) => [
|
|
row.name,
|
|
row.parameter_count,
|
|
row.parameter_bytes,
|
|
row.shared_bytes,
|
|
row.registers.physical,
|
|
]),
|
|
).toEqual([
|
|
["add_one", 2, 12, 32, null],
|
|
["add_one", 2, 12, 1056, 10],
|
|
]);
|
|
expect(result.value.ptx_artifacts[0]!.text).toBe(ptxFixture);
|
|
expect(
|
|
result.value.kernels[1]!.parameters.map((row) => [
|
|
row.ordinal,
|
|
row.offset,
|
|
row.size,
|
|
]),
|
|
).toEqual([
|
|
[0, 0, 8],
|
|
[1, 8, 4],
|
|
]);
|
|
},
|
|
);
|
|
it("retains the unsupported legacy CUDA compression declaration and extents", async () => {
|
|
const result = await inspect(
|
|
cudaFixture("legacy", [
|
|
{ kind: 1, target: 80, bytes: Buffer.from(ptxFixture), flags: 4 },
|
|
]),
|
|
);
|
|
if (!result.ok) throw result.error;
|
|
expect(result.value.objects[0]).toMatchObject({
|
|
compression: "unsupported",
|
|
compression_id: expect.stringContaining("cuda-flags:0x1015"),
|
|
encoded_size: deflateSync(Buffer.from(ptxFixture)).length,
|
|
decoded_size: Buffer.byteLength(ptxFixture),
|
|
inspection: "unsupported",
|
|
});
|
|
expect(result.value.ptx_artifacts).toEqual([]);
|
|
expect(result.value.kernels).toEqual([]);
|
|
expect(result.value.objects[0]!.limitations.join(" ")).toContain(
|
|
"compression/version is not supported",
|
|
);
|
|
});
|
|
it.each([1, 2, 3] as const)(
|
|
"reads CCOB v%d zlib/Zstd and retains exact decoded provenance",
|
|
async (version) => {
|
|
for (const method of ["zlib", "zstd"] as const) {
|
|
const result = await inspect(ccobFixture(version, method));
|
|
if (!result.ok) throw result.error;
|
|
expect(result.value.kernels[0]).toMatchObject({
|
|
name: "add_one",
|
|
parameter_count: 2,
|
|
parameter_bytes: 12,
|
|
registers: { sgpr: 6, vgpr: 2 },
|
|
shared_bytes: 0,
|
|
});
|
|
expect(result.value.objects[2]!.location.container_id).toBe(
|
|
result.value.objects[0]!.id,
|
|
);
|
|
}
|
|
},
|
|
);
|
|
it("does not decode unselected payloads and keeps stable positional identities", async () => {
|
|
const bytes = cudaFixture("zstd");
|
|
const inventory = await inspect(bytes, { analysis: "inventory" }),
|
|
selected = await inspect(bytes, { targets: ["sm_90"] });
|
|
if (!inventory.ok) throw inventory.error;
|
|
if (!selected.ok) throw selected.error;
|
|
expect(inventory.value.kernels).toEqual([]);
|
|
expect(selected.value.objects.map((row) => row.id)).toEqual(
|
|
inventory.value.objects.map((row) => row.id),
|
|
);
|
|
expect(selected.value.ptx_artifacts).toEqual([]);
|
|
expect(selected.value.kernels).toHaveLength(1);
|
|
expect(selected.value.coverage.payloads).toBe("partial");
|
|
});
|
|
it.each(["cubin", "ptx"] as const)(
|
|
"retains conflicting container and %s target declarations as partial facts",
|
|
async (kind) => {
|
|
const bytes = cudaFixture("none", [
|
|
{
|
|
kind: kind === "cubin" ? 2 : 1,
|
|
target: 80,
|
|
bytes:
|
|
kind === "cubin"
|
|
? cubinFixture({ architecture: 90 })
|
|
: Buffer.from(ptxFixture.replace("sm_80", "sm_90")),
|
|
},
|
|
]);
|
|
const result = await inspect(bytes, { targets: ["sm_80"] });
|
|
if (!result.ok) throw result.error;
|
|
expect(result.value.objects[0]).toMatchObject({
|
|
target: "sm_80",
|
|
payload_target: "sm_90",
|
|
target_consistency: "conflict",
|
|
inspection: "partial",
|
|
});
|
|
expect(result.value.coverage.payloads).toBe("partial");
|
|
expect(result.value.kernels).toHaveLength(1);
|
|
expect(result.value.kernels[0]!.limitations.join(" ")).toContain(
|
|
"inventory sm_80; payload sm_90",
|
|
);
|
|
const unexamined = await inspect(bytes, { targets: ["sm_90"] });
|
|
if (!unexamined.ok) throw unexamined.error;
|
|
expect(unexamined.value.objects[0]).toMatchObject({
|
|
target: "sm_80",
|
|
payload_target: null,
|
|
target_consistency: "unexamined",
|
|
inspection: "not-selected",
|
|
});
|
|
expect(unexamined.value.coverage.payloads).toBe("partial");
|
|
},
|
|
);
|
|
it("keeps CUBIN base-only agreement distinct from verified feature-profile agreement", async () => {
|
|
const bytes = cudaFixture("none", [
|
|
{ kind: 2, target: 90, bytes: cubinFixture({ architecture: 90 }) },
|
|
]);
|
|
bytes.writeBigUInt64LE(bytes.readBigUInt64LE(16 + 40) | 0x100000n, 16 + 40);
|
|
const result = await inspect(bytes, { targets: ["sm_90a"] });
|
|
if (!result.ok) throw result.error;
|
|
expect(result.value.objects[0]).toMatchObject({
|
|
target: "sm_90a",
|
|
payload_target: "sm_90",
|
|
target_consistency: "base-only",
|
|
inspection: "complete",
|
|
});
|
|
});
|
|
it.each([
|
|
[100, 0x06006402],
|
|
[101, 0x06006502],
|
|
[103, 0x05006702],
|
|
[120, 0x06007802],
|
|
[121, 0x06007902],
|
|
])(
|
|
"reads ABI-qualified CUDA target sm_%d from released NVIDIA header flags",
|
|
async (architecture, flags) => {
|
|
const result = await inspect(cubinFixture({ osAbi: 0x41, flags }));
|
|
if (!result.ok) throw result.error;
|
|
expect(result.value.objects[0]).toMatchObject({
|
|
target: `sm_${architecture}`,
|
|
payload_target: `sm_${architecture}`,
|
|
target_consistency: "single-source",
|
|
inspection: "complete",
|
|
cuda_target_header: {
|
|
os_abi: 0x41,
|
|
flags: `0x${flags.toString(16).padStart(8, "0")}`,
|
|
},
|
|
});
|
|
},
|
|
);
|
|
it("keeps unsupported CUDA flag layouts unknown while retaining raw header evidence", async () => {
|
|
const result = await inspect(
|
|
cubinFixture({ osAbi: 0x41, flags: 0x06016402 }),
|
|
);
|
|
if (!result.ok) throw result.error;
|
|
expect(result.value.objects[0]).toMatchObject({
|
|
target: null,
|
|
payload_target: null,
|
|
target_consistency: "unknown",
|
|
inspection: "partial",
|
|
cuda_target_header: { os_abi: 0x41, flags: "0x06016402" },
|
|
});
|
|
expect(result.value.kernels).toHaveLength(1);
|
|
expect(result.value.kernels[0]!.limitations.join(" ")).toContain(
|
|
"target encoding is unknown",
|
|
);
|
|
const inventory = await inspect(
|
|
cubinFixture({ osAbi: 0x41, flags: 0x06016402 }),
|
|
{ analysis: "inventory" },
|
|
);
|
|
if (!inventory.ok) throw inventory.error;
|
|
expect(inventory.value.coverage.discovery).toBe("partial");
|
|
});
|
|
it("discovers standalone AMD targets before exact selection", async () => {
|
|
const bytes = amdFixture(),
|
|
target = "amdgcn-amd-amdhsa--gfx900";
|
|
const inventory = await inspect(bytes, { analysis: "inventory" });
|
|
const selected = await inspect(bytes, { targets: [target] });
|
|
const skipped = await inspect(bytes, {
|
|
targets: ["amdgcn-amd-amdhsa--gfx1100"],
|
|
});
|
|
if (!inventory.ok) throw inventory.error;
|
|
if (!selected.ok) throw selected.error;
|
|
if (!skipped.ok) throw skipped.error;
|
|
expect(inventory.value.objects[0]).toMatchObject({
|
|
target,
|
|
inspection: "inventory",
|
|
sha256: null,
|
|
});
|
|
expect(inventory.value.kernels).toEqual([]);
|
|
expect(selected.value.objects[0]).toMatchObject({
|
|
target,
|
|
inspection: "complete",
|
|
id: inventory.value.objects[0]!.id,
|
|
});
|
|
expect(selected.value.kernels).toHaveLength(1);
|
|
expect(selected.value.kernels[0]).toMatchObject({
|
|
representation: "amdgpu-metadata",
|
|
parameter_bytes: 12,
|
|
});
|
|
expect(skipped.value.objects[0]).toMatchObject({
|
|
target,
|
|
inspection: "not-selected",
|
|
sha256: null,
|
|
});
|
|
expect(skipped.value.kernels).toEqual([]);
|
|
expect(skipped.value.coverage.payloads).toBe("partial");
|
|
});
|
|
it("derives V3 AMDGPU processor identity from ELF flags when the note omits it", async () => {
|
|
const bytes = amdFixture(false, undefined, null);
|
|
// EF_AMDGPU_MACH=0x2c identifies gfx900; high bits include feature flags.
|
|
bytes.writeUInt32LE(0x12c, 48);
|
|
const inventory = await inspect(bytes, { analysis: "inventory" });
|
|
if (!inventory.ok) throw inventory.error;
|
|
expect(inventory.value.objects[0]).toMatchObject({
|
|
target: "gfx900",
|
|
target_consistency: "single-source",
|
|
inspection: "inventory",
|
|
});
|
|
const selected = await inspect(bytes, { targets: ["gfx900"] });
|
|
if (!selected.ok) throw selected.error;
|
|
expect(selected.value.kernels).toHaveLength(1);
|
|
expect(selected.value.kernels[0]).toMatchObject({ parameter_bytes: 12 });
|
|
});
|
|
it("keeps AMDGPU processor identity unknown when ELF flags are unassigned", async () => {
|
|
const bytes = amdFixture(false, undefined, null);
|
|
bytes.writeUInt32LE(0x17f, 48);
|
|
const result = await inspect(bytes, { analysis: "inventory" });
|
|
if (!result.ok) throw result.error;
|
|
expect(result.value.objects[0]).toMatchObject({
|
|
target: null,
|
|
target_consistency: "unknown",
|
|
inspection: "inventory",
|
|
});
|
|
});
|
|
it.each([false, true])(
|
|
"keeps HIP bitcode representation unsupported with wrapped=%s and no declared processor",
|
|
async (wrapped) => {
|
|
const payload = llvmBitcodeFixture(wrapped),
|
|
bytes = hipFixture(payload, "hip-amdgcn-amd-amdhsa--");
|
|
for (const analysis of ["inventory", "kernels"] as const) {
|
|
const result = await inspect(bytes, { analysis });
|
|
if (!result.ok) throw result.error;
|
|
const row = result.value.objects.find(({ kind }) => kind === "amdgpu")!;
|
|
expect(row).toMatchObject({
|
|
bundle_id: "hip-amdgcn-amd-amdhsa--",
|
|
target: null,
|
|
payload_target: null,
|
|
inspection: analysis === "inventory" ? "inventory" : "unsupported",
|
|
encoded_size: payload.length,
|
|
location: { size: payload.length },
|
|
sha256:
|
|
analysis === "inventory"
|
|
? null
|
|
: createHash("sha256").update(payload).digest("hex"),
|
|
});
|
|
expect(row.limitations.join(" ")).toContain("LLVM bitcode");
|
|
expect(row.limitations.join(" ")).not.toContain("not an ELF image");
|
|
expect(result.value.coverage).toMatchObject({
|
|
discovery: "partial",
|
|
payloads: analysis === "inventory" ? "not-requested" : "partial",
|
|
});
|
|
expect(result.value.kernels).toEqual([]);
|
|
}
|
|
},
|
|
);
|
|
it.each([
|
|
["amdgcn", "gfx900:xnack+"],
|
|
["amdgcn", "gfx900+xnack"],
|
|
["amdgcn", "gfx900:sramecc-:xnack+"],
|
|
["amdgpu", "gfx900:xnack+"],
|
|
["amdgpu9", "gfx900:xnack+"],
|
|
["amdgpu9.00", "gfx900:sramecc-:xnack+"],
|
|
])(
|
|
"preserves matching AMDGPU %s note features with ELF processor flags (%s)",
|
|
async (triple, target) => {
|
|
const noteTarget = `${triple}-amd-amdhsa--${target}`;
|
|
const payload = amdFixture(false, undefined, noteTarget);
|
|
payload.writeUInt32LE(0x12c, 48);
|
|
const result = await inspect(
|
|
hipFixture(payload, `hipv4-amdgcn-amd-amdhsa--${target}`),
|
|
{ targets: [target] },
|
|
);
|
|
if (!result.ok) throw result.error;
|
|
expect(
|
|
result.value.objects.find(({ kind }) => kind === "amdgpu"),
|
|
).toMatchObject({
|
|
target,
|
|
payload_target: noteTarget,
|
|
target_consistency: "consistent",
|
|
inspection: "complete",
|
|
});
|
|
expect(result.value.kernels).toHaveLength(1);
|
|
expect(result.value.coverage.payloads).toBe("complete");
|
|
},
|
|
);
|
|
it.each(["amdgcn", "amdgpu9.00"])(
|
|
"does not choose between conflicting AMDGPU %s note and ELF processor identities",
|
|
async (triple) => {
|
|
const bytes = amdFixture(
|
|
false,
|
|
undefined,
|
|
`${triple}-amd-amdhsa--gfx900:xnack+`,
|
|
);
|
|
bytes.writeUInt32LE(0x141, 48); // EF_AMDGPU_MACH gfx1100
|
|
const result = await inspect(bytes);
|
|
if (!result.ok) throw result.error;
|
|
expect(result.value.objects[0]).toMatchObject({
|
|
target: null,
|
|
target_consistency: "unknown",
|
|
inspection: "partial",
|
|
});
|
|
expect(result.value.objects[0]!.limitations.join(" ")).toContain(
|
|
"processor flags conflict with target note metadata",
|
|
);
|
|
expect(result.value.kernels).toHaveLength(1);
|
|
},
|
|
);
|
|
it.each([
|
|
"producer-specific-gpu-target",
|
|
"amdgpu9.00-amd-amdhsa--gfx900:xnack",
|
|
])(
|
|
"retains the unrecognized AMDGPU note target %s without substituting ELF processor flags",
|
|
async (noteTarget) => {
|
|
const result = await inspect(
|
|
hipFixture(amdFixture(false, undefined, noteTarget)),
|
|
{ targets: ["gfx900"] },
|
|
);
|
|
if (!result.ok) throw result.error;
|
|
const row = result.value.objects.find(({ kind }) => kind === "amdgpu");
|
|
expect(row).toMatchObject({
|
|
target: "gfx900",
|
|
payload_target: noteTarget,
|
|
target_consistency: "unknown",
|
|
inspection: "complete",
|
|
});
|
|
expect(result.value.coverage.payloads).toBe("complete");
|
|
expect(result.value.kernels).toMatchObject([
|
|
{ name: "add_one", parameter_bytes: 12, registers: { sgpr: 6, vgpr: 2 } },
|
|
]);
|
|
expect(row?.limitations.join(" ")).not.toContain(
|
|
"Conflicting target declarations",
|
|
);
|
|
expect(result.value.kernels[0]?.limitations.join(" ")).not.toContain(
|
|
"Conflicting target declarations",
|
|
);
|
|
},
|
|
);
|
|
it("retains kernels from conflicting AMDGPU notes without choosing either note or ELF flags", async () => {
|
|
const bytes = amdFixture(
|
|
false,
|
|
amdNoteFixture(false, "amdgcn-amd-amdhsa--gfx1100"),
|
|
);
|
|
const result = await inspect(bytes);
|
|
if (!result.ok) throw result.error;
|
|
expect(result.value.objects).toMatchObject([
|
|
{
|
|
kind: "amdgpu",
|
|
target: null,
|
|
payload_target: null,
|
|
target_consistency: "unknown",
|
|
inspection: "partial",
|
|
},
|
|
]);
|
|
expect(result.value.objects[0]?.limitations).toContain(
|
|
"AMDGPU notes declare conflicting processor targets; processor identity is unknown",
|
|
);
|
|
expect(result.value.coverage).toMatchObject({
|
|
discovery: "partial",
|
|
payloads: "partial",
|
|
});
|
|
expect(result.value.kernels).toMatchObject([
|
|
{ name: "add_one", parameter_bytes: 12, registers: { sgpr: 6, vgpr: 2 } },
|
|
{ name: "add_one", parameter_bytes: 12, registers: { sgpr: 6, vgpr: 2 } },
|
|
]);
|
|
expect(new Set(result.value.kernels.map(({ id }) => id)).size).toBe(2);
|
|
const selected = await inspect(bytes, { targets: ["gfx900"] });
|
|
if (!selected.ok) throw selected.error;
|
|
expect(selected.value.objects[0]).toMatchObject({
|
|
target: null,
|
|
payload_target: null,
|
|
target_consistency: "unknown",
|
|
inspection: "not-selected",
|
|
});
|
|
expect(selected.value.kernels).toEqual([]);
|
|
});
|
|
it.each(
|
|
[
|
|
"amdgcn-amd-amdhsa-unknown-",
|
|
"amdgpu9.00-amd-amdhsa--",
|
|
"amdgpu9.00-amd-amdhsa-unknown-",
|
|
].flatMap((prefix) =>
|
|
(
|
|
[
|
|
["gfx900", "gfx900", "consistent"],
|
|
["gfx1100", "gfx900", "conflict"],
|
|
["gfx900", "gfx900:xnack+", "unknown"],
|
|
["gfx900", "gfx900+xnack", "unknown"],
|
|
["gfx900+xnack", "gfx900", "unknown"],
|
|
["GFX900", "gfx900", "unknown"],
|
|
["gfx900", "GFX900", "unknown"],
|
|
] as const
|
|
).map(([inventoryTarget, payloadTargetId, consistency]) => ({
|
|
inventoryTarget,
|
|
payloadTarget: `${prefix}${payloadTargetId}`,
|
|
consistency,
|
|
})),
|
|
),
|
|
)(
|
|
"compares AMDGPU inventory $inventoryTarget with note $payloadTarget as $consistency",
|
|
async ({ inventoryTarget, payloadTarget, consistency }) => {
|
|
const bytes = hipFixture(
|
|
amdFixture(false, undefined, payloadTarget),
|
|
`hipv4-amdgcn-amd-amdhsa--${inventoryTarget}`,
|
|
);
|
|
const result = await inspect(bytes, { targets: [inventoryTarget] });
|
|
if (!result.ok) throw result.error;
|
|
const row = result.value.objects.find((value) => value.kind === "amdgpu")!;
|
|
expect(row.payload_target).toBe(payloadTarget);
|
|
expect(result.value.kernels).toHaveLength(1);
|
|
if (consistency === "conflict") {
|
|
expect(row).toMatchObject({
|
|
target: inventoryTarget,
|
|
target_consistency: "conflict",
|
|
inspection: "partial",
|
|
});
|
|
expect(result.value.coverage.payloads).toBe("partial");
|
|
expect(result.value.kernels[0]!.limitations.join(" ")).toContain(
|
|
"Conflicting target declarations",
|
|
);
|
|
} else {
|
|
expect(row).toMatchObject({
|
|
target: inventoryTarget,
|
|
target_consistency: consistency,
|
|
inspection: "complete",
|
|
});
|
|
expect(result.value.coverage.payloads).toBe("complete");
|
|
expect(result.value.kernels[0]!.limitations.join(" ")).not.toContain(
|
|
"Conflicting target declarations",
|
|
);
|
|
}
|
|
},
|
|
);
|
|
it.each([
|
|
"hipv4-amdgcn-amd-amdhsa--gfx900",
|
|
"hipv4-amdgcn-amd-amdhsa-gfx900",
|
|
"hipv4-amdgcn-amd-amdhsa-opaque",
|
|
"hipv4-amdgpu9.00-amd-amdhsa--gfx900",
|
|
])("keeps discovered HIP targets selectable for %s", async (targetId) => {
|
|
const bytes = hipFixture(amdFixture(), targetId);
|
|
const inventory = await inspect(bytes, { analysis: "inventory" });
|
|
if (!inventory.ok) throw inventory.error;
|
|
const row = inventory.value.objects.find((value) => value.kind === "amdgpu")!;
|
|
expect(row.target).not.toBeNull();
|
|
const selected = await inspect(bytes, { targets: [row.target!] });
|
|
if (!selected.ok) throw selected.error;
|
|
expect(selected.value.kernels).toHaveLength(1);
|
|
expect(
|
|
selected.value.objects.find((value) => value.kind === "amdgpu"),
|
|
).toMatchObject({
|
|
target: row.target,
|
|
payload_target: "amdgcn-amd-amdhsa--gfx900",
|
|
target_consistency: targetId.endsWith("opaque")
|
|
? "single-source"
|
|
: "consistent",
|
|
inspection: "complete",
|
|
});
|
|
});
|
|
it.each(["gfx11-generic", "gfx9-4-generic"] as const)(
|
|
"preserves and exactly selects the generic AMDGPU processor %s",
|
|
async (processor) => {
|
|
const noteTarget = `amdgcn-amd-amdhsa--${processor}`;
|
|
const payload = amdFixture(false, undefined, noteTarget);
|
|
payload.writeUInt32LE(processor === "gfx11-generic" ? 0x54 : 0x5f, 48);
|
|
const bytes = hipFixture(payload, `hipv4-amdgcn-amd-amdhsa--${processor}`);
|
|
const result = await inspect(bytes, { targets: [processor] });
|
|
if (!result.ok) throw result.error;
|
|
expect(
|
|
result.value.objects.find(({ kind }) => kind === "amdgpu"),
|
|
).toMatchObject({
|
|
kind: "amdgpu",
|
|
target: processor,
|
|
payload_target: noteTarget,
|
|
target_consistency: "consistent",
|
|
inspection: "complete",
|
|
});
|
|
expect(result.value.kernels).toHaveLength(1);
|
|
},
|
|
);
|
|
it("recognizes a modern AMDGPU triple inside compressed CCOB v3", async () => {
|
|
const targetId = "hipv4-amdgpu9.00-amd-amdhsa--gfx900";
|
|
const bytes = ccobFixture(3, "zstd", hipFixture(amdFixture(), targetId));
|
|
const result = await inspect(bytes);
|
|
if (!result.ok) throw result.error;
|
|
expect(
|
|
result.value.objects.find(({ bundle_id }) => bundle_id === targetId),
|
|
).toMatchObject({
|
|
kind: "amdgpu",
|
|
target: "gfx900",
|
|
payload_target: "amdgcn-amd-amdhsa--gfx900",
|
|
target_consistency: "consistent",
|
|
inspection: "complete",
|
|
});
|
|
expect(result.value.kernels).toHaveLength(1);
|
|
});
|
|
it("bounds standalone AMD note discovery before retaining metadata", async () => {
|
|
const result = await inspect(
|
|
elfFixture(224, [
|
|
{ name: ".note", type: 7, bytes: Buffer.alloc(8 * 1024 * 1024 + 1) },
|
|
]),
|
|
{ analysis: "inventory" },
|
|
);
|
|
if (!result.ok) throw result.error;
|
|
expect(result.value.objects[0]).toMatchObject({
|
|
target: "gfx900",
|
|
inspection: "capacity",
|
|
});
|
|
expect(result.value.objects[0]!.limitations).toContain(
|
|
"AMDGPU ELF note discovery exceeds the 8 MiB retained metadata budget",
|
|
);
|
|
expect(result.value.kernels).toEqual([]);
|
|
});
|
|
it("reads PE raw-size fallback and ELF-host section locations", async () => {
|
|
for (const bytes of [
|
|
peGpuFixture(),
|
|
elfFixture(62, [{ name: ".nv_fatbin", bytes: cudaFixture() }]),
|
|
]) {
|
|
const result = await inspect(bytes);
|
|
if (!result.ok) throw result.error;
|
|
expect(result.value.kernels).toHaveLength(2);
|
|
expect(result.value.objects[0]!.location.section_index).not.toBeNull();
|
|
expect(result.value.objects[1]!.location.container_id).toBe(
|
|
result.value.objects[0]!.id,
|
|
);
|
|
}
|
|
});
|
|
it("coalesces aliased CUDA metadata before expanding the temporary index", async () => {
|
|
const bytes = cubinFixture({ globalRecords: 65536, globalAliases: 1024 });
|
|
expect(bytes.length).toBeLessThan(1024 * 1024);
|
|
const result = await inspect(bytes);
|
|
if (!result.ok) throw result.error;
|
|
expect(result.value.objects[0]!.inspection).toBe("complete");
|
|
expect(result.value.kernels).toHaveLength(1);
|
|
expect(result.value.kernels[0]!.registers.physical).toBe(10);
|
|
});
|
|
it("retains unknown PTX virtual counts and partial payload coverage", async () => {
|
|
const result = await inspect(
|
|
Buffer.from(ptxFixture.replace("%r<9>", "r0, r1, %r<4>, %s<8>")),
|
|
);
|
|
if (!result.ok) throw result.error;
|
|
expect(result.value.kernels[0]!.registers.virtual[0]).toEqual({
|
|
type: ".b32",
|
|
count: 14,
|
|
});
|
|
const unsupported = await inspect(
|
|
Buffer.from(ptxFixture.replace("%r<9>", "%r[4]")),
|
|
);
|
|
if (!unsupported.ok) throw unsupported.error;
|
|
expect(unsupported.value.objects[0]!.inspection).toBe("partial");
|
|
expect(unsupported.value.coverage.payloads).toBe("partial");
|
|
expect(unsupported.value.kernels[0]!.registers.virtual[0]).toEqual({
|
|
type: ".b32",
|
|
count: null,
|
|
});
|
|
});
|
|
it.each(["spaced", "compact", "mixed"])(
|
|
"counts %s PTX register keywords while retaining byte provenance",
|
|
async (spacing) => {
|
|
const directive = spacing === "spaced" ? ".reg " : ".reg";
|
|
const header = ".version 8.8\n.target sm_80\n// GPU 寄存器 🎯\n";
|
|
const entry = `.entry k() { ${directive}.b32 %r<4>; ${spacing === "mixed" ? ".reg " : directive}.b32 r0, r1, %r4; ${directive}.b64 %rd<2>; ret; }`;
|
|
const source = header + entry;
|
|
const result = await inspect(Buffer.from(source));
|
|
if (!result.ok) throw result.error;
|
|
expect(result.value.objects[0]!.inspection).toBe("complete");
|
|
expect(result.value.coverage.payloads).toBe("complete");
|
|
expect(result.value.ptx_artifacts[0]!.text).toBe(source);
|
|
const kernel = result.value.kernels[0]!;
|
|
expect(kernel.registers.virtual).toEqual([
|
|
{ type: ".b32", count: 7 },
|
|
{ type: ".b64", count: 2 },
|
|
]);
|
|
expect(kernel.location).toMatchObject({
|
|
offset: Buffer.byteLength(header),
|
|
size: Buffer.byteLength(entry),
|
|
});
|
|
},
|
|
);
|
|
it("keeps unsupported compact PTX register types partial", async () => {
|
|
const result = await inspect(
|
|
Buffer.from(ptxFixture.replace(".reg .b32", ".reg.v2.b32")),
|
|
);
|
|
if (!result.ok) throw result.error;
|
|
expect(result.value.objects[0]!.inspection).toBe("partial");
|
|
expect(result.value.coverage.payloads).toBe("partial");
|
|
expect(result.value.kernels[0]!.registers.virtual).toEqual([
|
|
{ type: ".v2 .b32", count: null },
|
|
{ type: ".b64", count: 5 },
|
|
]);
|
|
});
|
|
it.each([64, 65])(
|
|
"counts all %d scalar names in one PTX register list",
|
|
async (count) => {
|
|
const names = Array.from(
|
|
{ length: count },
|
|
(_, index) => `%r${index}`,
|
|
).join(", ");
|
|
const result = await inspect(
|
|
Buffer.from(
|
|
`.version 8.8\n.target sm_80\n.address_size 64\n.entry k() { .reg .b32 ${names}; ret; }\n`,
|
|
),
|
|
);
|
|
if (!result.ok) throw result.error;
|
|
expect(result.value.objects[0]!.inspection).toBe("complete");
|
|
expect(result.value.coverage.payloads).toBe("complete");
|
|
expect(result.value.kernels[0]!.registers.virtual).toEqual([
|
|
{ type: ".b32", count },
|
|
]);
|
|
},
|
|
);
|
|
it("retains PTX kernels before and after a long scalar register list", async () => {
|
|
const names = Array.from({ length: 65 }, (_, index) => `%r${index}`).join(
|
|
", ",
|
|
);
|
|
const result = await inspect(
|
|
Buffer.from(
|
|
`.version 8.8\n.target sm_80\n.address_size 64\n.entry before() { ret; }\n.entry affected() { .reg .b32 ${names}; ret; }\n.entry after() { ret; }\n`,
|
|
),
|
|
);
|
|
if (!result.ok) throw result.error;
|
|
expect(result.value.objects[0]!.inspection).toBe("complete");
|
|
expect(result.value.coverage.payloads).toBe("complete");
|
|
expect(result.value.kernels.map((kernel) => kernel.name)).toEqual([
|
|
"before",
|
|
"affected",
|
|
"after",
|
|
]);
|
|
expect(result.value.kernels[1]!.registers.virtual).toEqual([
|
|
{ type: ".b32", count: 65 },
|
|
]);
|
|
});
|
|
it("retains later PTX kernels when a virtual register total overflows", async () => {
|
|
const result = await inspect(
|
|
Buffer.from(
|
|
".version 8.8\n.target sm_80\n.address_size 64\n.entry before() { ret; }\n.entry affected() { .reg .b32 %r<9007199254740991>, %s; ret; }\n.entry after() { ret; }\n",
|
|
),
|
|
);
|
|
if (!result.ok) throw result.error;
|
|
expect(result.value.objects[0]!.inspection).toBe("partial");
|
|
expect(result.value.coverage.payloads).toBe("partial");
|
|
expect(result.value.kernels.map((kernel) => kernel.name)).toEqual([
|
|
"before",
|
|
"affected",
|
|
"after",
|
|
]);
|
|
expect(result.value.kernels[1]!.registers.virtual).toEqual([
|
|
{ type: ".b32", count: null },
|
|
]);
|
|
});
|
|
it.each([
|
|
".entry k { ret; }",
|
|
".entry k() { ret; }",
|
|
".entry k .maxntid 1 { ret; }",
|
|
])("inspects PTX entry with optional parameters: %s", async (entry) => {
|
|
const result = await inspect(
|
|
Buffer.from(`.version 7.0\n.target sm_80\n.address_size 64\n${entry}`),
|
|
);
|
|
if (!result.ok) throw result.error;
|
|
expect(result.value.objects[0]!.inspection).toBe("complete");
|
|
expect(result.value.coverage.payloads).toBe("complete");
|
|
expect(result.value.kernels).toMatchObject([
|
|
{ name: "k", parameter_count: 0, parameter_bytes: 0, parameters: [] },
|
|
]);
|
|
});
|
|
it.each([
|
|
["parameter", ".u64 output", ".u64 .vendor_specific output"],
|
|
["shared", "scratch[32]", "scratch[]"],
|
|
] as const)(
|
|
"marks unknown PTX %s declarations partial while retaining known facts",
|
|
async (kind, from, to) => {
|
|
const bytes = Buffer.from(ptxFixture.replace(from, to));
|
|
const result = await inspect(bytes);
|
|
if (!result.ok) throw result.error;
|
|
expect(result.value.objects[0]!.inspection).toBe("partial");
|
|
expect(result.value.coverage.payloads).toBe("partial");
|
|
expect(result.value.ptx_artifacts[0]!.text).toBe(bytes.toString());
|
|
const kernel = result.value.kernels[0]!;
|
|
expect(kernel.registers.virtual[0]).toEqual({ type: ".b32", count: 9 });
|
|
expect(kernel.limitations.join(" ")).toContain(`PTX ${kind} declarations`);
|
|
if (kind === "parameter") {
|
|
expect(kernel.parameter_count).toBe(2);
|
|
expect(kernel.parameter_bytes).toBeNull();
|
|
expect(
|
|
kernel.parameters.map(({ size, offset }) => [size, offset]),
|
|
).toEqual([
|
|
[null, null],
|
|
[4, null],
|
|
]);
|
|
expect(kernel.shared_bytes).toBe(32);
|
|
} else {
|
|
expect(kernel.parameter_bytes).toBe(12);
|
|
expect(kernel.shared_bytes).toBeNull();
|
|
}
|
|
},
|
|
);
|
|
it.each([
|
|
".ptr .global",
|
|
".ptr .global .align 16",
|
|
".ptr.global.align 16",
|
|
".ptr .global.align 16",
|
|
".ptr.global .align 16",
|
|
])(
|
|
"keeps PTX pointer qualifiers %s complete through the provider",
|
|
async (qualifiers) => {
|
|
const bytes = Buffer.from(
|
|
ptxFixture.replace(".u64 output", `.u64 ${qualifiers} output`),
|
|
);
|
|
const result = await inspect(bytes);
|
|
if (!result.ok) throw result.error;
|
|
expect(result.value.objects[0]!.inspection).toBe("complete");
|
|
expect(result.value.coverage.payloads).toBe("complete");
|
|
expect(result.value.ptx_artifacts[0]!.text).toBe(bytes.toString());
|
|
expect(result.value.kernels[0]).toMatchObject({
|
|
parameter_count: 2,
|
|
parameter_bytes: 12,
|
|
parameters: [
|
|
{ name: "output", offset: 0, size: 8 },
|
|
{ name: "value", offset: 8, size: 4 },
|
|
],
|
|
});
|
|
},
|
|
);
|
|
it.each([".align 8 .b8", ".b8 .align 8"])(
|
|
"retains PTX array parameter identity and layout with %s",
|
|
async (type) => {
|
|
const bytes = Buffer.from(
|
|
ptxFixture.replace(".u64 output", `${type} payload[8]`),
|
|
);
|
|
const result = await inspect(bytes);
|
|
if (!result.ok) throw result.error;
|
|
expect(result.value.objects[0]!.inspection).toBe("complete");
|
|
expect(result.value.coverage.payloads).toBe("complete");
|
|
expect(result.value.ptx_artifacts[0]!.text).toBe(bytes.toString());
|
|
expect(result.value.kernels[0]).toMatchObject({
|
|
parameter_count: 2,
|
|
parameter_bytes: 12,
|
|
parameters: [
|
|
{ name: "payload", type: ".b8", offset: 0, size: 8 },
|
|
{ name: "value", offset: 8, size: 4 },
|
|
],
|
|
});
|
|
},
|
|
);
|
|
it.each([".b8 .align 3", ".align 8 .b8 .align 8"])(
|
|
"retains PTX names and partial layout for unsupported alignment %s",
|
|
async (type) => {
|
|
const bytes = Buffer.from(
|
|
ptxFixture.replace(".u64 output", `${type} payload[8]`),
|
|
);
|
|
const result = await inspect(bytes);
|
|
if (!result.ok) throw result.error;
|
|
expect(result.value.objects[0]!.inspection).toBe("partial");
|
|
expect(result.value.coverage.payloads).toBe("partial");
|
|
expect(result.value.kernels[0]).toMatchObject({
|
|
parameter_count: 2,
|
|
parameter_bytes: null,
|
|
parameters: [
|
|
{ name: "payload", type: ".b8", offset: null, size: null },
|
|
{ name: "value", offset: null, size: 4 },
|
|
],
|
|
});
|
|
},
|
|
);
|
|
it.each(["whitespace", "comment"] as const)(
|
|
"recognizes standalone PTX after more than 64 KiB of leading %s",
|
|
async (kind) => {
|
|
const prefix =
|
|
kind === "whitespace"
|
|
? " ".repeat(70 * 1024)
|
|
: `/*${"x".repeat(70 * 1024)}*/\n`;
|
|
const bytes = Buffer.from(prefix + ptxFixture);
|
|
const inventory = await inspect(bytes, { analysis: "inventory" });
|
|
const selected = await inspect(bytes, { targets: ["sm_80"] });
|
|
if (!inventory.ok) throw inventory.error;
|
|
if (!selected.ok) throw selected.error;
|
|
expect(inventory.value.objects[0]!.target).toBe("sm_80");
|
|
expect(selected.value.kernels).toHaveLength(1);
|
|
expect(selected.value.kernels[0]!.location.offset).toBeGreaterThan(
|
|
64 * 1024,
|
|
);
|
|
},
|
|
);
|
|
it("uses a later module target when selecting standalone PTX", async () => {
|
|
const bytes = Buffer.from(
|
|
".version 8.8\n.target sm_80\n.entry first() { ret; }\n.target sm_90\n",
|
|
);
|
|
const inventory = await inspect(bytes, { analysis: "inventory" });
|
|
const selected = await inspect(bytes, { targets: ["sm_90"] });
|
|
if (!inventory.ok) throw inventory.error;
|
|
if (!selected.ok) throw selected.error;
|
|
expect(inventory.value.objects[0]!.target).toBe("sm_90");
|
|
expect(selected.value.kernels.map(({ name }) => name)).toEqual(["first"]);
|
|
});
|
|
it.each(["truncated", "invalid", "extension"] as const)(
|
|
"retains earlier AMD kernel declarations after a later %s note",
|
|
async (kind) => {
|
|
const tail = Buffer.alloc(kind === "truncated" ? 3 : 24);
|
|
if (kind !== "truncated") {
|
|
tail.writeUInt32LE(7, 0);
|
|
tail.writeUInt32LE(kind === "invalid" ? 1 : 3, 4);
|
|
tail.writeUInt32LE(32, 8);
|
|
tail.write("AMDGPU\0", 12);
|
|
tail[20] = kind === "invalid" ? 0xc1 : 0xd4;
|
|
}
|
|
const payloadTarget = "amdgcn-amd-amdhsa--gfx900";
|
|
for (const { bytes, target, consistency } of [
|
|
{
|
|
bytes: amdFixture(false, tail),
|
|
target: payloadTarget,
|
|
consistency: "single-source",
|
|
},
|
|
{
|
|
bytes: hipFixture(amdFixture(false, tail)),
|
|
target: "gfx900",
|
|
consistency: "consistent",
|
|
},
|
|
]) {
|
|
const result = await inspect(bytes);
|
|
if (!result.ok) throw result.error;
|
|
expect(result.value.kernels).toHaveLength(1);
|
|
expect(result.value.kernels[0]).toMatchObject({
|
|
name: "add_one",
|
|
parameter_bytes: 12,
|
|
registers: { sgpr: 6, vgpr: 2 },
|
|
});
|
|
expect(
|
|
result.value.objects.find((row) => row.kind === "amdgpu")!.inspection,
|
|
).toBe(kind === "extension" ? "unsupported" : "malformed");
|
|
const identity = {
|
|
target,
|
|
payload_target: payloadTarget,
|
|
target_consistency: consistency,
|
|
};
|
|
expect(
|
|
result.value.objects.find((row) => row.kind === "amdgpu"),
|
|
).toMatchObject(identity);
|
|
expect(result.value.coverage.payloads).toBe("partial");
|
|
const selected = await inspect(bytes, { targets: [target] });
|
|
if (!selected.ok) throw selected.error;
|
|
expect(
|
|
selected.value.objects.find((row) => row.kind === "amdgpu"),
|
|
).toMatchObject(identity);
|
|
expect(selected.value.kernels).toEqual(result.value.kernels);
|
|
expect(selected.value.coverage.payloads).toBe("partial");
|
|
const skipped = await inspect(bytes, {
|
|
targets: [target === "gfx900" ? payloadTarget : "gfx900"],
|
|
});
|
|
if (!skipped.ok) throw skipped.error;
|
|
expect(
|
|
skipped.value.objects.find((row) => row.kind === "amdgpu"),
|
|
).toMatchObject(
|
|
target === payloadTarget
|
|
? {
|
|
...identity,
|
|
inspection: kind === "extension" ? "unsupported" : "malformed",
|
|
}
|
|
: {
|
|
target,
|
|
payload_target: null,
|
|
target_consistency: "unexamined",
|
|
inspection: "not-selected",
|
|
},
|
|
);
|
|
expect(skipped.value.kernels).toEqual([]);
|
|
}
|
|
},
|
|
);
|
|
it("bounds cumulative CUDA records across separate in-range metadata sections", async () => {
|
|
const record = Buffer.from("042f0800010000000a000000", "hex"),
|
|
records = Buffer.alloc(record.length * 131073);
|
|
for (let offset = 0; offset < records.length; offset += record.length)
|
|
record.copy(records, offset);
|
|
const result = await inspect(
|
|
elfFixture(190, [
|
|
{ name: ".nv.info", type: 0x70000000, bytes: records },
|
|
{ name: ".nv.info", type: 0x70000000, bytes: records },
|
|
]),
|
|
);
|
|
if (!result.ok) throw result.error;
|
|
expect(result.value.objects[0]!.inspection).toBe("capacity");
|
|
expect(result.value.objects[0]!.limitations.join(" ")).toContain(
|
|
"aggregate record/symbol visits",
|
|
);
|
|
});
|
|
it.each(["section-names", "symbols"] as const)(
|
|
"retains partial CUBIN coverage when %s are unavailable",
|
|
async (missing) => {
|
|
const bytes = cubinFixture();
|
|
if (missing === "section-names") bytes.writeUInt16LE(0, 62);
|
|
else bytes.writeUInt32LE(1, Number(bytes.readBigUInt64LE(40)) + 3 * 64 + 4);
|
|
const result = await inspect(bytes);
|
|
if (!result.ok) throw result.error;
|
|
expect(result.value.objects[0]!.inspection).toBe("partial");
|
|
expect(result.value.coverage.payloads).toBe("partial");
|
|
expect(result.value.kernels).toHaveLength(missing === "symbols" ? 0 : 1);
|
|
expect(result.value.objects[0]!.limitations.join(" ")).toContain(
|
|
missing === "symbols"
|
|
? "kernel declaration coverage is unknown"
|
|
: "named metadata coverage is partial",
|
|
);
|
|
},
|
|
);
|
|
it.each([9, 10])(
|
|
"preserves parameters and register coverage for text count %d",
|
|
async (textRegisters) => {
|
|
const name = "kernel_" + "argument".repeat(64);
|
|
const result = await inspect(
|
|
cubinFixture({ name, textRegisters, globalRegisters: 10 }),
|
|
);
|
|
if (!result.ok) throw result.error;
|
|
const conflict = textRegisters !== 10;
|
|
expect(result.value.kernels[0]).toMatchObject({
|
|
name,
|
|
parameter_count: 2,
|
|
registers: { physical: conflict ? null : 10 },
|
|
});
|
|
expect(result.value.objects[0]!.inspection).toBe(
|
|
conflict ? "partial" : "complete",
|
|
);
|
|
expect(result.value.coverage.payloads).toBe(
|
|
conflict ? "partial" : "complete",
|
|
);
|
|
expect(
|
|
result.value.kernels[0]!.limitations.some((value) =>
|
|
value.includes("Conflicting"),
|
|
),
|
|
).toBe(conflict);
|
|
},
|
|
);
|
|
it("iterates flat concatenated fatbins beyond the genuine container nesting limit", async () => {
|
|
const result = await inspect(
|
|
Buffer.concat(Array.from({ length: 20 }, () => cudaFixture())),
|
|
);
|
|
if (!result.ok) throw result.error;
|
|
expect(result.value.objects).toHaveLength(40);
|
|
expect(result.value.kernels).toHaveLength(40);
|
|
expect(result.value.coverage.discovery).toBe("complete");
|
|
});
|
|
it("reports checksum corruption and unknown compression as partial, retaining known entries", async () => {
|
|
const corrupt = ccobFixture();
|
|
corrupt[16] = corrupt[16]! ^ 1;
|
|
const result = await inspect(corrupt);
|
|
if (!result.ok) throw result.error;
|
|
expect(result.value.coverage.discovery).toBe("partial");
|
|
expect(result.value.objects[0]!.inspection).toBe("malformed");
|
|
const unknown = ccobFixture();
|
|
unknown.writeUInt16LE(99, 6);
|
|
const unsupported = await inspect(unknown);
|
|
if (!unsupported.ok) throw unsupported.error;
|
|
expect(unsupported.value.objects[0]!.inspection).toBe("unsupported");
|
|
});
|
|
it("rejects out-of-range bundle entries without guessing a payload", async () => {
|
|
const bytes = hipFixture();
|
|
bytes.writeBigUInt64LE(BigInt(bytes.length + 1), 32);
|
|
const result = await inspect(bytes);
|
|
expect(result).toMatchObject({
|
|
ok: false,
|
|
error: { _tag: "BinaryTargetError" },
|
|
});
|
|
});
|
|
|
|
it("preserves standalone PTX BOM and trailing NUL bytes in the retained text artifact", async () => {
|
|
const bytes = Buffer.from("\uFEFF" + ptxFixture + "\0");
|
|
const result = await inspect(bytes);
|
|
if (!result.ok) throw result.error;
|
|
expect(
|
|
Buffer.compare(Buffer.from(result.value.ptx_artifacts[0]!.text), bytes),
|
|
).toBe(0);
|
|
expect(result.value.ptx_artifacts[0]!.byte_length).toBe(bytes.length);
|
|
});
|
|
it("rejects a changed full-file identity before applying positional object selection", async () => {
|
|
const bytes = cudaFixture();
|
|
const result = await inspect(bytes, {
|
|
expected_sha256: "0".repeat(64),
|
|
object_ids: ["file@10"],
|
|
});
|
|
expect(result).toMatchObject({
|
|
ok: false,
|
|
error: { _tag: "AnalysisArtifactChangedError" },
|
|
});
|
|
});
|
|
it("iterates mixed plain/CCOB bundles without counting flat records as nesting", async () => {
|
|
const records = Array.from({ length: 20 }, (_, index) =>
|
|
index % 2 === 0 ? hipFixture() : ccobFixture(),
|
|
);
|
|
const result = await inspect(Buffer.concat(records));
|
|
if (!result.ok) throw result.error;
|
|
expect(result.value.kernels).toHaveLength(20);
|
|
expect(result.value.coverage.discovery).toBe("complete");
|
|
});
|
|
it("does not recognize a CCOB signature after its first byte is corrupted", async () => {
|
|
const bytes = ccobFixture(3, "zlib");
|
|
bytes[0] = bytes[0]! | 0x80;
|
|
const result = await inspect(bytes);
|
|
expect(result).toMatchObject({
|
|
ok: false,
|
|
error: { _tag: "AnalysisUnsupportedTargetError" },
|
|
});
|
|
});
|
|
it("requires the PTX version directive before any module content", async () => {
|
|
const result = await inspect(Buffer.from(`unexpected-prefix ${ptxFixture}`));
|
|
expect(result).toMatchObject({
|
|
ok: false,
|
|
error: { _tag: "AnalysisUnsupportedTargetError" },
|
|
});
|
|
});
|
|
it("retains an embedded CCOB with a corrupted signature as unsupported", async () => {
|
|
const bytes = ccobFixture(3, "zlib");
|
|
bytes[0] = bytes[0]! | 0x80;
|
|
const result = await inspect(
|
|
elfFixture(62, [{ name: ".hip_fatbin", bytes }]),
|
|
);
|
|
if (!result.ok) throw result.error;
|
|
expect(result.value.coverage.discovery).toBe("partial");
|
|
expect(result.value.kernels).toEqual([]);
|
|
expect(result.value.objects).toContainEqual(
|
|
expect.objectContaining({
|
|
kind: "native-section",
|
|
inspection: "unsupported",
|
|
limitations: expect.arrayContaining([
|
|
"No supported CUDA/HIP container or PTX declarations were identified",
|
|
]),
|
|
}),
|
|
);
|
|
});
|
|
it.each([
|
|
["unknown COFF machine", 0xffff],
|
|
["x86 machine with a PE32+ optional header", 0x14c],
|
|
] as const)(
|
|
"discovers PE GPU sections with %s",
|
|
async (_description, machine) => {
|
|
const bytes = peGpuFixture();
|
|
const pe = bytes.readUInt32LE(60);
|
|
bytes.writeUInt16LE(machine, pe + 4);
|
|
const result = await inspect(bytes);
|
|
if (!result.ok) throw result.error;
|
|
expect(result.value.format).toBe("pe");
|
|
expect(result.value.artifact.sha256).toBe(
|
|
createHash("sha256").update(bytes).digest("hex"),
|
|
);
|
|
expect(result.value.coverage).toMatchObject({
|
|
discovery: "complete",
|
|
payloads: "complete",
|
|
});
|
|
expect(result.value.kernels.map(({ name }) => name)).toEqual([
|
|
"add_one",
|
|
"add_one",
|
|
]);
|
|
expect(result.value.ptx_artifacts[0]!.text).toBe(ptxFixture);
|
|
},
|
|
);
|
|
it("does not dispatch a high-bit-corrupted DOS signature to the PE parser", async () => {
|
|
const bytes = peGpuFixture(Buffer.from(ptxFixture));
|
|
bytes[0] = bytes[0]! | 0x80;
|
|
const result = await inspect(bytes);
|
|
expect(result).toMatchObject({
|
|
ok: false,
|
|
error: { _tag: "AnalysisUnsupportedTargetError" },
|
|
});
|
|
});
|
|
it.each(["zlib", "zstd"] as const)(
|
|
"uses each legacy CCOB v1 %s stream boundary across alignment padding",
|
|
async (codec) => {
|
|
const first = ccobFixture(1, codec),
|
|
second = ccobFixture(2, "zlib"),
|
|
padding = Buffer.alloc((8 - (first.length % 8)) % 8);
|
|
const result = await inspect(Buffer.concat([first, padding, second]));
|
|
if (!result.ok) throw result.error;
|
|
const bundles = result.value.objects.filter(
|
|
({ kind }) => kind === "hip-bundle",
|
|
);
|
|
expect(bundles).toHaveLength(2);
|
|
expect(
|
|
bundles.map(({ inspection, decoded_size }) => [inspection, decoded_size]),
|
|
).toEqual([
|
|
["complete", expect.any(Number)],
|
|
["complete", expect.any(Number)],
|
|
]);
|
|
expect(bundles[0]!.sha256).toBe(bundles[1]!.sha256);
|
|
expect(bundles[0]!.encoded_size).toBe(first.length - 20);
|
|
expect(bundles[0]!.location.size).toBe(first.length - 20);
|
|
expect(bundles[1]!.metadata_location.offset).toBe(
|
|
first.length + padding.length,
|
|
);
|
|
expect(result.value.kernels).toHaveLength(2);
|
|
expect(result.value.coverage.discovery).toBe("complete");
|
|
},
|
|
);
|
|
it("keeps a later CCOB bundle after a truncated legacy v1 stream", async () => {
|
|
const truncated = ccobFixture(1, "zlib").subarray(0, -1),
|
|
later = ccobFixture(2, "zlib");
|
|
const result = await inspect(Buffer.concat([truncated, later]));
|
|
if (!result.ok) throw result.error;
|
|
const bundles = result.value.objects.filter(
|
|
({ kind }) => kind === "hip-bundle",
|
|
);
|
|
expect(bundles).toHaveLength(2);
|
|
expect(bundles.map(({ inspection }) => inspection)).toEqual([
|
|
"malformed",
|
|
"complete",
|
|
]);
|
|
expect(result.value.kernels).toHaveLength(1);
|
|
expect(result.value.coverage.discovery).toBe("partial");
|
|
expect(bundles[0]!.limitations.join(" ")).toContain(
|
|
"uncertain recovery candidate",
|
|
);
|
|
});
|
|
it.each(["checksum", "decoded-size"] as const)(
|
|
"preserves a completed v1 codec extent after a bad %s declaration",
|
|
async (declaration) => {
|
|
const bundle = hipFixture(
|
|
Buffer.from("ordinary CCOB marker"),
|
|
"host-other",
|
|
),
|
|
compressed = deflateSync(bundle, { level: 0 }),
|
|
header = Buffer.from(ccobFixture(1, "zlib", bundle).subarray(0, 20));
|
|
if (declaration === "checksum") header[12] = header[12]! ^ 1;
|
|
else header.writeUInt32LE(bundle.length + 1, 8);
|
|
const first = Buffer.concat([header, compressed]);
|
|
const result = await inspect(
|
|
Buffer.concat([first, ccobFixture(2, "zlib")]),
|
|
);
|
|
if (!result.ok) throw result.error;
|
|
const wrappers = result.value.objects.filter(
|
|
({ kind }) => kind === "hip-bundle",
|
|
);
|
|
expect(wrappers.map(({ inspection }) => inspection)).toEqual([
|
|
"malformed",
|
|
"complete",
|
|
]);
|
|
expect(wrappers[0]).toMatchObject({
|
|
encoded_size: compressed.length,
|
|
location: { size: compressed.length },
|
|
});
|
|
expect(wrappers[0]!.limitations.join(" ")).not.toContain("recovery");
|
|
expect(wrappers[1]!.metadata_location.offset).toBe(first.length);
|
|
expect(result.value.coverage.discovery).toBe("partial");
|
|
},
|
|
);
|
|
it("continues at the declared CCOB boundary after an unsupported codec", async () => {
|
|
const unknown = ccobFixture();
|
|
unknown.writeUInt16LE(99, 6);
|
|
const result = await inspect(Buffer.concat([unknown, ccobFixture()]));
|
|
if (!result.ok) throw result.error;
|
|
expect(result.value.kernels).toHaveLength(1);
|
|
expect(result.value.coverage.discovery).toBe("partial");
|
|
});
|
|
|
|
it("refuses escaped PTX report expansion while preserving bounded interrupted facts", async () => {
|
|
const text = ptxFixture + "\n//" + "\u0001".repeat(3 * 1024 * 1024);
|
|
const result = await inspect(Buffer.from(text));
|
|
expect(result).toMatchObject({
|
|
ok: false,
|
|
error: { _tag: "AnalysisResourceConstraintError" },
|
|
});
|
|
if (result.ok) throw new Error("expected representation capacity refusal");
|
|
const partial = gpuCodeObjectsPartialSchema.parse(
|
|
parseEvidence(result.error.partialObservation).normalized_result,
|
|
);
|
|
expect(partial.ptx_artifacts).toEqual([]);
|
|
expect(partial.objects).toHaveLength(1);
|
|
expect(partial.artifact.sha256).toBeNull();
|
|
});
|