Docs & rules

beehive-lab/TornadoVMGitHub

This is a public, read-only report. Striff reads this repository's docs, turns each sentence that makes a claim about the code into a rule, and checks the rule against the code on the default branch. How this works

mastera86db1aLast read Oct 3

Is this yours? Install to manage it

Once installed, Striff checks every pull request.

Rules summary
Documents
Rules
139
62
46
6
19
21
16
10
10
1
1
2
2
8
8
8
56
32 docs
beehive-lab/TornadoVMOpen repository

beehive-lab/TornadoVM — documented rules

139 of 139 rules, printed November 17, 2026.

The sentence in your docs
Concern Kernel-entry resolution, Where TaskUtils.resolveViaSerializedLambda, Notes lambda → SerializedLambda → Method
TaskUtils has a resolveViaSerializedLambda method
Holds
Concern SPI (no HotSpot type), Where TornadoBackendProvider.createBackend(OptionValues, TornadoVMConfigAccess), Notes backends construct reflection providers directly
TornadoBackendProvider has a createBackend method
Holds
OCLHotSpotBackendFactory.createJITCompiler → new TornadoMetaAccessProvider(), new TornadoConstantReflectionProvider(snippetReflection) (no HotSpotJVMCIRuntime param).
3 rules from this sentence
OCLHotSpotBackendFactory depends on TornadoMetaAccessProvider
Holds
OCLHotSpotBackendFactory depends on TornadoConstantReflectionProvider
Holds
OCLHotSpotBackendFactory has createJITCompiler
Holds
The *GraphBuilderPlugins.registerInvocationPlugins signature must take jdk.vm.ci.meta.MetaAccessProvider, not HotSpotMetaAccessProvider.
OCLGraphBuilderPlugins has registerInvocationPlugins
Holds
OCLFieldBuffer resolves the object type via TornadoCoreRuntime.getTornadoRuntime().getMetaAccess() and the reflection ResolvedJavaType (no HotSpotResolvedJavaType cast).
OCLFieldBuffer depends on TornadoCoreRuntime
Holds
graal/phases/TornadoOpenCLIntrinsicsReplacements (registered in OCLHighTier right after HighTierLoweringPhase).
OCLHighTier depends on TornadoOpenCLIntrinsicsReplacements
Holds
Also OCLLoweringProvider#isLocalArrayInput matches surviving contains("LocalArray") invokes at lowering time.
OCLLoweringProvider has isLocalArrayInput
Holds
OCLBackend.emitMethodParameters continues past a KernelContext/AtomicInteger parameter so it is not emitted as a __global buffer arg.
2 rules from this sentence
OCLBackend depends on KernelContext
Holds
OCLBackend has emitMethodParameters
Holds
OCLNodeLIRBuilder.emitPrologue — a KernelContext/AtomicInteger parameter whose only remaining usages are FrameStates (deopt) must not load a buffer;
OCLNodeLIRBuilder has emitPrologue
Holds
OCLLoweringProvider uses (int) TornadoOptions.PANAMA_OBJECT_HEADER_SIZE for panama array element addresses;
OCLLoweringProvider depends on TornadoOptions
Holds
OCLAssembler.formatConstant escapes a TornadoObjectConstant wrapping a String as a C string literal (a HotSpotObjectConstant no longer appears on the reflection path).
2 rules from this sentence
OCLAssembler depends on TornadoObjectConstant
Holds
OCLAssembler has formatConstant
Holds
OCLGraphBuilderPlugins.registerNativeArrayAccessPlugins → registerNativeArrayGetSet(Int/Float/ Double/Long/Short/Byte/Int8/Char) + registerHalfFloatArrayGetSet + the arch-neutral arrayElementAddress helper (&segment[(baseIndex+index)*elementBytes]).
OCLGraphBuilderPlugins has registerNativeArrayAccessPlugins
Holds
Note that the TornadoVM profiler works only if enabled in the execution plan (via the withProfiler method).
TornadoExecutionPlan has a withProfiler method
Holds
FloatArray has an init method
HoldsPR #1069 · Sep 30
FloatArray has a clear method
HoldsPR #1069 · Sep 30
local only means the operation is supported when the array was allocated with KernelContext.allocateIntLocalArray(int);
KernelContext has an allocateIntLocalArray method
Holds
The Task-Graph API also defines a method, named transferToDevice to set which arrays need to be copied to the target accelerator.
TaskGraph has a transferToDevice method
HoldsPR #1069 · Sep 30
Similar to transferToDevice, the TaskGraph API also offers a call to sync the data back from the device to the host. The API call is transferToHost with the following parameters:
TaskGraph has transferToHost
HoldsPR #1069 · Sep 30
TornadoVM supports batch processing through the following API call withBatch of the TornadoExecutionPlan API.
TornadoExecutionPlan has withBatch
HoldsPR #1069 · Sep 30
Tile exposes getDType, getRank, getDimension and getElement (JVM path only, for tests and host debugging);
4 rules from this sentence
Tile has getDType
HoldsPR #1069 · Sep 30
Tile has getRank
HoldsPR #1069 · Sep 30
Tile has getDimension
HoldsPR #1069 · Sep 30
Tile has getElement
HoldsPR #1069 · Sep 30
TensorView exposes getDType, getRank, getExtent, and getElementOffset/getRowStride for a strided view;
5 rules from this sentence
TensorView has getDType
HoldsPR #1069 · Sep 30
TensorView has getRank
HoldsPR #1069 · Sep 30
TensorView has getExtent
HoldsPR #1069 · Sep 30
TensorView has getElementOffset
HoldsPR #1069 · Sep 30
TensorView has getRowStride
HoldsPR #1069 · Sep 30
PartitionView adds getTileDimension and getBlockCount.
2 rules from this sentence
PartitionView has getTileDimension
HoldsPR #1069 · Sep 30
PartitionView has getBlockCount
HoldsPR #1069 · Sep 30
Factories (uk.ac.manchester.tornado.cublas.CuBlas):
CuBlas is in uk.ac.manchester.tornado.cublas
Holds
Factory cublasSgemv(op, m, n, alpha, A, lda, x, incx, beta, y, incy), Operation y = alpha·op(A)·x + beta·y
CuBlas has a cublasSgemv method
Holds
Factory cublasSgemm(opA, opB, m, n, k, alpha, A, lda, B, ldb, beta, C, ldc), Operation C = alpha·op(A)·op(B) + beta·C
CuBlas has a cublasSgemm method
Holds
Factory cublasSgemmTF32(...), Operation SGEMM using TF32 tensor cores
CuBlas has a cublasSgemmTF32 method
Holds
Factory cublasGemmExFP16(...), Operation FP16 inputs and output, tensor-core GEMM
CuBlas has a cublasGemmExFP16 method
Holds
Factory cublasGemmExFP16FP32(...), Operation FP16 inputs, FP32 output — keeps accumulation precision at the boundary
CuBlas has a cublasGemmExFP16FP32 method
Holds
Factory cublasGemmExBF16(...), Operation BF16 inputs and output ( BFloat16Array ), tensor-core GEMM
CuBlas has a cublasGemmExBF16 method
Holds
Factory cublasSgemmStridedBatched(...), Operation batched SGEMM
CuBlas has a cublasSgemmStridedBatched method
Holds
Factory ltMatmulFP32 / ltMatmulFP16, Epilogue none
2 rules from this sentence
CuBlasLt has ltMatmulFP32
Holds
CuBlasLt has ltMatmulFP16
Holds
Factory ltMatmulFP8, Epilogue none (E4M3 operands, FP16 output, TN form, ld multiple of 16 B)
CuBlasLt has ltMatmulFP8
Holds
Factory ltMatmulBiasFP16, Epilogue BIAS
CuBlasLt has ltMatmulBiasFP16
Holds
Factory ltMatmulGeluBiasFP16, Epilogue GELU_BIAS (tanh approximation)
CuBlasLt has ltMatmulGeluBiasFP16
Holds
Factory cufftForwardC2C / cufftInverseC2C(input, output, n, batch), Transform 1D complex→complex
2 rules from this sentence
CuFft has cufftForwardC2C
Holds
CuFft has a cufftInverseC2C method
Holds
Factory cufftForwardR2C / cufftInverseC2R(input, output, n, batch), Transform real↔complex (Hermitian, n ↔ n/2+1 )
2 rules from this sentence
CuFft has cufftForwardR2C
Holds
CuFft has a cufftInverseC2R method
Holds
Factory cufftForwardZ2Z / cufftInverseZ2Z(input, output, n, batch), Transform FP64 complex→complex, 1D
2 rules from this sentence
CuFft has cufftForwardZ2Z
Holds
CuFft has a cufftInverseZ2Z method
Holds
Factory cufftForward2dC2C / cufftInverse2dC2C(input, output, nx, ny), Transform 2D complex→complex
2 rules from this sentence
CuFft has cufftForward2dC2C
Holds
CuFft has a cufftInverse2dC2C method
Holds
Factory cudnnSoftmax(input, output, rows, cols), Operation per-row numerically-stable softmax
CuDnn has a cudnnSoftmax method
Holds
Factory cudnnRelu / cudnnSigmoid / cudnnTanh(input, output, size), Operation activations
3 rules from this sentence
CuDnn has a cudnnRelu method
Holds
CuDnn has a cudnnSigmoid method
Holds
CuDnn has a cudnnTanh method
Holds
Factory cudnnMaxPool2d(input, output, n, c, h, w, window, stride), Operation 2D max pooling
CuDnn has a cudnnMaxPool2d method
Holds
Factory cudnnConv2d(input, filter, output, n, c, h, w, k, r, s, pad, stride), Operation 2D convolution
CuDnn has a cudnnConv2d method
Holds
Factory sdpaForward(q, k, v, o, b, h, sQ, sKv, d, scale, causal), Operation fused scaled-dot-product attention (FP16, BHSD)
CuDnn has a sdpaForward method
Holds
Factory cutlassSgemm(m, n, k, alpha, A, B, beta, C), Operation FP32 SIMT GEMM
Cutlass has a cutlassSgemm method
Holds
Factory cutlassHgemm(m, n, k, alpha, A, B, beta, D), Operation FP16 tensor-core GEMM, FP32 accumulate
Cutlass has a cutlassHgemm method
Holds
Factory cutlassHgemmBatched(m, n, k, alpha, A, B, beta, C, batchCount), Operation batched FP16 tensor-core GEMM
Cutlass has a cutlassHgemmBatched method
Holds
Factory cutlassBgemm(m, n, k, alpha, A, B, beta, C), Operation BF16 tensor-core GEMM ( BFloat16Array )
Cutlass has a cutlassBgemm method
Holds
Factory cutlassGemmBiasRelu(m, n, k, A, B, bias, D), Operation fused relu(A·B + bias)
Cutlass has a cutlassGemmBiasRelu method
Holds
Factory cutlassGemmBiasGelu(m, n, k, A, B, bias, D), Operation fused gelu(A·B + bias)
Cutlass has a cutlassGemmBiasGelu method
Holds
Factory cutlassGemmBiasSilu(m, n, k, A, B, bias, D), Operation fused silu(A·B + bias)
Cutlass has a cutlassGemmBiasSilu method
Holds
Factory cutlassGemmBiasSigmoid(m, n, k, A, B, bias, D), Operation fused sigmoid(A·B + bias)
Cutlass has a cutlassGemmBiasSigmoid method
Holds
Factory cutlassGemmBiasTanh(m, n, k, A, B, bias, D), Operation fused tanh(A·B + bias)
Cutlass has a cutlassGemmBiasTanh method
Holds
Factory cutlassGemmBiasHardSwish(m, n, k, A, B, bias, D), Operation fused hardswish(A·B + bias)
Cutlass has a cutlassGemmBiasHardSwish method
Holds
Factory cusparseSpMV(rows, cols, nnz, csrRowOffsets, csrColInd, csrValues, x, y), Operation y = A·x
Cusparse has a cusparseSpMV method
Holds
Factory cusparseSpMM(rows, k, n, nnz, csrRowOffsets, csrColInd, csrValues, b, c), Operation C = A·B , dense B / C row-major
Cusparse has a cusparseSpMM method
Holds
Option withPreCompilation(), What it does JIT every task graph up front For hybrid plans this also runs each provider's prepare() , so native contexts, plans and workspaces exist before the first execution — the same reason it is a prerequisite for graph capture, Backends all
TornadoExecutionPlan has a withPreCompilation method
Holds
Option withIntraPlanConcurrency(), What it does Routes DAG-independent work (H2D, kernels, D2H) to separate role streams so it can overlap, with ordering preserved through device events derived from the bytecode dependency DAG Off by default, Backends CUDA no-op on OpenCL/Metal
TornadoExecutionPlan has a withIntraPlanConcurrency method
Holds
Option withStagedTransfers(), What it does Stages non-batched read-only transfers through pinned host memory instead of the direct path, Backends CUDA no-op on OpenCL/Metal
TornadoExecutionPlan has a withStagedTransfers method
Holds
Option withMemoryLimit("8GB"), What it does Caps device memory for the plan Worth setting explicitly when library workspaces sit alongside large operands, Backends all
TornadoExecutionPlan has a withMemoryLimit method
Holds
Option withWarmUpIterations(n), What it does Runs the whole plan n times first — transfers, compilation and execution — before the measured run, Backends all
TornadoExecutionPlan has a withWarmUpIterations method
Holds
TornadoExecutionPlan.transferToDevice(Object...) uploads the current host contents of specific objects without running the plan.
TornadoExecutionPlan has a transferToDevice method
Holds
…and add the same class name to src/main/resources/META-INF/services/uk.ac.manchester.tornado.runtime.library.spi.TornadoLibraryProvider.
TornadoLibraryProvider is in uk.ac.manchester.tornado.runtime.library.spi
Holds
LibraryContext — marker;
LibraryContext is in uk.ac.manchester.tornado.runtime.library.spi
Holds
LibraryInvocation — per-call payload: getArg(i), getDevicePointer(i), isReference(i), getContext(), getTuning().
LibraryInvocation is in uk.ac.manchester.tornado.runtime.library.spi
Holds
getArg(i), getDevicePointer(i), isReference(i), getContext(), getTuning().
5 rules from this sentence
LibraryInvocation has a getArg method
Holds
LibraryInvocation has a getDevicePointer method
Holds
LibraryInvocation has an isReference method
Holds
LibraryInvocation has a getContext method
Holds
LibraryInvocation has a getTuning method
Holds
TornadoNativeStreamSupport — getNativeStream(planId) / getNativeContext(planId), implemented by the CUDA backend device.
2 rules from this sentence
TornadoNativeStreamSupport has a getNativeStream method
Holds
TornadoNativeStreamSupport has a getNativeContext method
Holds
Factory cublasSgemv, cuBLAS function cublasSgemv, Types FloatArray, Semantics y = α·op(A)·x + β·y
CuBlas has a cublasSgemv method
HoldsPR #1069 · Sep 30
Factory cublasSgemm, cuBLAS function cublasSgemm, Types FloatArray, Semantics C = α·op(A)·op(B) + β·C
CuBlas has a cublasSgemm method
HoldsPR #1069 · Sep 30
Factory cublasSgemmTF32, cuBLAS function cublasSgemm + TF32 math mode, Types FloatArray, Semantics Same as cublasSgemm , executed on TF32 Tensor Cores (~1e-4 rel error, up to 1.6x faster)
CuBlas has a cublasSgemmTF32 method
HoldsPR #1069 · Sep 30
Factory cublasSgemmStridedBatched, cuBLAS function cublasSgemmStridedBatched, Types FloatArray, Semantics C[i] = α·op(A[i])·op(B[i]) + β·C[i] for a whole batch in one call operand i lives at base + i stride in one flat array
CuBlas has a cublasSgemmStridedBatched method
HoldsPR #1069 · Sep 30
Factory cublasGemmExFP16, cuBLAS function cublasGemmEx, Types HalfFloatArray in/out, Semantics FP16 GEMM with FP32 Tensor Core accumulation
CuBlas has a cublasGemmExFP16 method
HoldsPR #1069 · Sep 30
Factory cublasGemmExFP16FP32, cuBLAS function cublasGemmEx, Types HalfFloatArray in, FloatArray out, Semantics FP16 inputs, FP32 output (standard inference config)
CuBlas has a cublasGemmExFP16FP32 method
HoldsPR #1069 · Sep 30
Factory CuBlasLt.ltMatmulFP32, cuBLAS function cublasLtMatmul, Types FloatArray, Semantics FP32 matmul (heuristic algorithm, plan cached per shape)
CuBlasLt has a ltMatmulFP32 method
HoldsPR #1069 · Sep 30
Factory CuBlasLt.ltMatmulFP16, cuBLAS function cublasLtMatmul, Types HalfFloatArray, Semantics FP16 matmul, FP32 Tensor Core accumulation
CuBlasLt has a ltMatmulFP16 method
HoldsPR #1069 · Sep 30
Factory CuBlasLt.ltMatmulBiasFP16, cuBLAS function cublasLtMatmul + BIAS, Types HalfFloatArray, Semantics C = op(A)·op(B) + bias, fused
CuBlasLt has a ltMatmulBiasFP16 method
HoldsPR #1069 · Sep 30
Factory CuBlasLt.ltMatmulGeluBiasFP16, cuBLAS function cublasLtMatmul + GELU_BIAS, Types HalfFloatArray, Semantics C = GELU(op(A)·op(B) + bias), fully fused transformer MLP block
CuBlasLt has a ltMatmulGeluBiasFP16 method
HoldsPR #1069 · Sep 30
CUDA Graphs: supported — plans (whose creation allocates a device work area) are built in the provider's prepare() hook, which the runtime invokes before capture starts, so the FFT pipeline is captured and replayed like any other library task (see TestCuFft#testRoundTripWithCudaGraph).
CuFftLibraryProvider has a prepare method
Holds
Factory Cusparse.cusparseSpMV(rows, cols, nnz, csrRowOffsets, csrColInd, csrValues, x, y), Operation y = A · x
Cusparse has a cusparseSpMV method
Holds
Factory Cusparse.cusparseSpMM(rows, k, n, nnz, csrRowOffsets, csrColInd, csrValues, B, C), Operation C = A · B (dense B k×n, C rows×n)
Cusparse has a cusparseSpMM method
Holds
those have no C ABI to call, so here they are Java records in registries, and the long handles the backend passes around for programs, kernels and events are registry keys rather than raw pointers (real Metal objects -- devices, queues, buffers, libraries, pipelines, command buffers -- stay raw pointers).
Metal depends on MetalObjects
HoldsPR #1069 · Sep 30
139 rules from 9 docs

More open-source reports

Every report →

Other public repositories whose docs Striff read and checked against their code.