lux/chains
2
0
Fork 0
mirror of https://github.com/luxfi/chains.git synced 2026-09-24 00:26:00 +00:00
Code Issues Packages Projects Releases Wiki Activity

The cevm binding reads ABI 7, and declines a library of another

Browse Source 
ABIVersion is 7, the go_bridge.h ABI in which ok says whether the result is
the block's. The binding does not compile against a header that names
another, and init reads the loaded library's gpu_abi_version() instead of
panicking on it: against a library of another ABI, ExecuteBlock calls
nothing and declines every block, and a result of another ABI is declined
too, so the caller runs them on its own EVM.

The native tests hold the library to that contract. A block of funded plain
transfers runs on a GPU lane to TxOK at 21000 gas each, or is declined there
when the host has no device, and a CPU lane declines it; a batch with code
or calldata is declined on every lane. The opcode, bytecode and gas-parity
tests ran code through the entry, which runs none, and are gone; the
block-context and sustained-Metal tests run transfers. A test that needs a
device skips on a GPU lane that declines. The tests that pin the build with
no library linked moved to cevm_nolib_test.go, outside the native build,
where they failed.

Co-authored-by: Hanzo Dev <[email protected]>
This commit is contained in:
zeekay
2026-09-23 11:27:54 -07:00
co-authored by Hanzo Dev
parent 596e18dfe1
commit acd68484d7
11 changed files with 554 additions and 1237 deletions
Download Patch File Download Diff File Expand all files Collapse all files
evm/cevm/TESTING_CUDA.md
+5 -4
View File
@@ -174,11 +174,12 @@ Expected single log line:
## 8. cevm declines to the Go EVM
cevm's Go entry (`gpu_execute_block`, go_bridge.h ABI 6) answers ok=0 for any
cevm's Go entry (`gpu_execute_block`, go_bridge.h ABI 7) answers ok=0 for any
block it does not run — any batch with code, and any refusal on balance, nonce,
price, block gas limit, revision or hashes. The executor in
`evm/cevm/parallel` then returns `(nil, nil)`, and the Go EVM runs the block.
There is no switch: a decline is never an error.
price, block gas limit, revision or hashes. A loaded library that reports
another ABI than the binding reads is sent nothing, and every block is
declined. The executor in `evm/cevm/parallel` then returns `(nil, nil)`, and
the Go EVM runs the block. There is no switch: a decline is never an error.
```bash
cd ~/work/lux/chains
evm/cevm/cevm.go
+14 -10
View File
@@ -1,6 +1,6 @@
// Package cevm provides Go bindings to the C++ EVM (cevm) with GPU acceleration.
//
// Its block entry, gpu_execute_block (go_bridge.h, ABI 6), runs one kind of
// Its block entry, gpu_execute_block (go_bridge.h, ABI 7), runs one kind of
// block: plain value transfers, on a GPU lane's value-transfer path, answering
// per-tx gas and status. Anything else it declines (ErrDeclined) and the
// caller runs on its own EVM. BatchRecoverSenders batches ecrecover.
@@ -41,10 +41,12 @@
//
// # ABI version
//
// The Go module's ABIVersion constant is checked against the loaded
// library's gpu_abi_version() in init(). A mismatch panics at process
// start — that is intentional. It catches a library built against another
// ABI number; two libraries that report the same number are not told apart.
// ABIVersion is the go_bridge.h ABI the native build is written to, 7. The
// build does not compile against a header that names another, and init reads
// the loaded library's gpu_abi_version(): against a library of another ABI,
// ExecuteBlock calls nothing and declines every block, so the caller runs them
// all on its own EVM. It catches a library built against another ABI number;
// two libraries that report the same number are not told apart.
//
// Use Health() at startup to see which lanes can run a block: it runs a
// funded plain transfer on each.
@@ -72,7 +74,8 @@ var ErrNotLinked = errors.New("cevm: native EVM not linked (rebuild with CGO_ENA
// on its own EVM. cevm declines any batch in which a transaction carries code,
// and any batch its value-transfer paths cannot run as the EVM does — a
// refusal on balance, nonce, price, block gas limit or revision, a snapshot
// row without its hashes, or a device that failed.
// row without its hashes, or a device that failed. Against a loaded library
// of another ABI, every batch is declined without a call.
//
// A declined result carries no gas or status a caller may use, so ExecuteBlock
// returns none with it.
@@ -207,11 +210,12 @@ type BlockContext struct {
NumBlobHashes uint32
}
// ABIVersion (cevm_cgo.go / cevm_nocgo.go) is the C ABI this build links:
// go_bridge.h's EVM_GPU_ABI_VERSION, 6. v6 is one entry, gpu_execute_block,
// ABIVersion (cevm_cgo.go / cevm_nocgo.go) is the C ABI this build reads:
// go_bridge.h's EVM_GPU_ABI_VERSION, 7. It is one entry, gpu_execute_block,
// taking a block context and a state snapshot (CGpuStateAccount) and
// answering per-tx gas and status with ok, freed by gpu_free_result. The
// versioned _v2/_v3/_v4 entries are gone.
// answering per-tx gas and status with ok, freed by gpu_free_result; ok=1
// only for a result that is the block's. The versioned _v2/_v3/_v4 entries
// are gone.
// StateAccount is one entry in the snapshot of touched accounts handed to
// ExecuteBlock, the state before the block. Fields mirror the C-side
evm/cevm/cevm_blockctx_test.go
+19 -109
View File
@@ -4,116 +4,26 @@ package cevm
import "testing"
// TestBlockContextChainID is the canonical end-to-end check that the
// dispatcher forwards Config.block_context to whichever backend actually
// runs the kernel CHAINID opcode. The bytecode is:
//
// 0x46 CHAINID // pushes block.chainid onto the stack
// 0x60 0x00 PUSH1 0 // memory offset
// 0x52 MSTORE // mem[0..32) = chain_id (big-endian)
// 0x60 0x20 PUSH1 32 // return size
// 0x60 0x00 PUSH1 0 // return offset
// 0xf3 RETURN // return mem[0..32)
//
// Expected: r.Status[0] == TxReturn, the 32-byte output, big-endian, equals
// the ChainID we passed in BlockContext. Lux mainnet is 96369.
//
// We loop over every backend the loaded library reports — that way a regression
// in Metal CHAINID wiring fails the test on Apple silicon, a regression in CPU
// kernel wiring fails it on Linux, etc. CUDA is allowed to pass-through to the
// V2 default (zero ctx) until the CUDA host grows a BlockContext-aware overload;
// we skip the CHAINID assertion for CUDA but still verify the call returned.
func TestBlockContextChainID(t *testing.T) {
code := []byte{
0x46, // CHAINID
0x60, 0x00, // PUSH1 0
0x52, // MSTORE
0x60, 0x20, // PUSH1 32
0x60, 0x00, // PUSH1 0
0xf3, // RETURN
}
tx := Transaction{
HasTo: true,
Code: code,
GasLimit: 100_000,
}
const wantChainID uint64 = 96369 // Lux mainnet C-chain
ctx := &BlockContext{ChainID: wantChainID}
backends := AvailableBackends()
if len(backends) == 0 {
t.Skip("no backends available — cannot exercise CHAINID path")
}
for _, b := range backends {
b := b
// The block context reaches the device path and is read there: the same
// funded transfer that a device runs is declined when the block's base fee is
// above its price, and when the block's gas limit cannot hold its limit.
// Either would be run as a valid transfer by a path that dropped the context.
func TestTheBlockContextReachesTheDevice(t *testing.T) {
for _, b := range deviceLanes(t) {
t.Run(BackendName(b), func(t *testing.T) {
r, err := ExecuteBlock(b, 0, []Transaction{tx}, ctx, nil)
if err != nil {
t.Fatalf("ExecuteBlock failed: %v", err)
}
if len(r.Status) != 1 {
t.Fatalf("expected 1 status entry, got %d", len(r.Status))
}
// CUDA host doesn't yet honour BlockContext (separate branch). The
// call must still complete cleanly; the CHAINID assertion below
// is enforced only for the backends that read ctx.
if b == GPUCUDA {
if r.Status[0] != TxReturn && r.Status[0] != TxOK {
t.Fatalf("CUDA: status=%s, want return/ok", r.Status[0])
}
return
}
// The kernel CPU interpreter reads BlockContext via a separate
// branch (parallel agent feat/v0.26-cpu-interpreter-26-opcodes).
// Until that lands, CHAINID is rejected by the CPU kernel
// interpreter as unimplemented and returns TxError. The
// dispatcher is correctly forwarding the BlockContext to the
// CPU kernel call site (verified by the wiring), but the kernel
// itself doesn't read it yet. Assert that the dispatcher
// returned a valid result struct and log the actual status.
if b == CPUSequential || b == CPUParallel {
if len(r.GasUsed) != 1 {
t.Fatalf("backend=%s: expected 1 gas entry, got %d", b, len(r.GasUsed))
}
t.Logf("backend=%s: status=%s gas=%d (CHAINID lands with kernel CPU interpreter branch)",
b, r.Status[0], r.GasUsed[0])
return
}
// GPU paths (Metal here) read BlockContext from the kernel-bound
// buffer. CHAINID returns the chain id we passed, MSTORE writes
// it to memory, RETURN exits cleanly with TxReturn.
if r.Status[0] != TxReturn {
t.Fatalf("backend=%s: status=%s, want return", b, r.Status[0])
}
if len(r.GasUsed) != 1 {
t.Fatalf("expected 1 gas entry, got %d", len(r.GasUsed))
}
if r.GasUsed[0] == 0 {
t.Fatalf("backend=%s: gas_used=0, kernel didn't execute", b)
}
// Sanity: every CHAINID program consumes the same minimum gas:
// CHAINID(2) + PUSH1(3) + MSTORE(3) + memexpand(3) +
// PUSH1(3) + PUSH1(3) + RETURN(0) = 17 gas, plus any
// per-backend memory expansion overhead.
const minExpected = 12
if r.GasUsed[0] < minExpected {
t.Errorf("backend=%s: gas_used=%d below minimum %d",
b, r.GasUsed[0], minExpected)
}
txs, ctx, state := transfers(1)
r, err := ExecuteBlock(b, 0, txs, &ctx, state)
ranTransfers(t, r, err, 1)
priced := ctx
priced.BaseFee = txs[0].GasPrice + 1
r, err = ExecuteBlock(b, 0, txs, &priced, state)
declined(t, r, err)
full := ctx
full.GasLimit = txs[0].GasLimit - 1
r, err = ExecuteBlock(b, 0, txs, &full, state)
declined(t, r, err)
})
}
// One more invariant: a zero BlockContext (V2 path) MUST NOT panic and
// MUST return a clean (non-error) BlockResult. This guards the
// "ctx == nil" call shape against silent regressions.
t.Run("zero-ctx-fallback", func(t *testing.T) {
r, err := ExecuteBlock(backends[0], 0, []Transaction{tx}, nil, nil)
if err != nil {
t.Fatalf("ExecuteBlock with nil ctx failed: %v", err)
}
if r.ABIVersion != ABIVersion {
t.Errorf("ABIVersion mismatch: got %d, want %d", r.ABIVersion, ABIVersion)
}
})
}
evm/cevm/cevm_cgo.go
+46 -27
View File
@@ -56,11 +56,21 @@ func AutoDetect() Backend {
return Backend(C.gpu_auto_detect_backend())
}
// ABIVersion is the ABI this build was compiled against, taken from the
// library's own header. There is no second copy to keep in sync.
const ABIVersion = uint32(C.EVM_GPU_ABI_VERSION)
// ABIVersion is the go_bridge.h ABI this file is written to: 7, in which ok
// says whether the result is the block's. A version 6 library answers ok=1 for
// results that are not, so this file is not correct against it even where the
// structs line up.
const ABIVersion uint32 = 7
// The C structs this file fills and reads, at the sizes go_bridge.h (ABI 6)
// The header this builds against names the same ABI, or this file does not
// compile: each line fails when EVM_GPU_ABI_VERSION is smaller (the first) or
// larger (the second) than ABIVersion.
var (
_ [ABIVersion - C.EVM_GPU_ABI_VERSION]struct{}
_ [C.EVM_GPU_ABI_VERSION - ABIVersion]struct{}
)
// The C structs this file fills and reads, at the sizes go_bridge.h (ABI 7)
// gives them on LP64. A header that adds, drops or widens a field changes a
// size, and then this file does not compile until it has been read against
// the new header: a field it never sets would otherwise cross as zero, which
@@ -77,18 +87,22 @@ var (
_ [unsafe.Sizeof(BlockContext{}) - unsafe.Sizeof(C.CBlockContext{})]struct{}
)
// init validates the ABI version of the loaded shared library against the Go
// module's expected ABIVersion. A mismatch means the binary and the cevm
// module were built against incompatible C++ headers and any execution would
// produce silently wrong results — fail fast at process start instead.
// libraryABI is the ABI the loaded library reports (gpu_abi_version), read
// once in init. The library a binary loads at run time need not be the one
// whose header it was built against.
var libraryABI uint32
// init reads the loaded library's ABI. A library of another ABI lays the
// structs out and means ok differently, so ExecuteBlock sends it nothing:
// every block is declined, and the caller runs it on its own EVM.
func init() {
got := uint32(C.gpu_abi_version())
if got != ABIVersion {
panic(fmt.Sprintf(
"cevm: ABI version mismatch — loaded libevm-gpu reports v%d but Go bindings expect v%d. "+
"Rebuild libevm-gpu (see luxcpp/evm) or pin matching versions.",
got, ABIVersion))
}
libraryABI = uint32(C.gpu_abi_version())
}
// errOtherABI is ExecuteBlock's decline when the loaded library, or a result
// it returned, is of an ABI this file is not written to.
func errOtherABI(got uint32) error {
return fmt.Errorf("cevm: the library speaks ABI %d, this build reads %d: %w", got, ABIVersion, ErrDeclined)
}
// buildTxs converts Go transactions into C-layout transactions, pinning any
@@ -149,11 +163,16 @@ func copyU64(ptr *C.uint64_t, want uint32) []uint64 {
// touches (see StateAccount). numThreads is passed through to the C executor.
//
// When the library declines the block (ok=0) ExecuteBlock returns ErrDeclined
// and no result: the caller runs the block on its own EVM.
// and no result: the caller runs the block on its own EVM. A loaded library
// of another ABI is never called: ExecuteBlock declines every block it is
// given, with an error that wraps ErrDeclined.
func ExecuteBlock(backend Backend, numThreads uint32, txs []Transaction, ctx *BlockContext, state []StateAccount) (*BlockResult, error) {
if len(txs) == 0 {
return &BlockResult{ABIVersion: ABIVersion}, nil
}
if libraryABI != ABIVersion {
return nil, errOtherABI(libraryABI)
}
var pinner runtime.Pinner
defer pinner.Unpin()
@@ -244,16 +263,16 @@ func ExecuteBlock(backend Backend, numThreads uint32, txs []Transaction, ctx *Bl
runtime.KeepAlive(cAccts)
runtime.KeepAlive(codeBlob)
// ok=0 names no gas or status the caller may use (every status reads
// EVM_GPU_TX_ERROR, and the arrays may be NULL), so nothing below it is
// read: the block goes back to the caller whole.
// What ok means is the ABI's, so a result of another ABI is not read at
// all. ok=0 names no gas or status the caller may use (every status reads
// EVM_GPU_TX_ERROR, and the arrays may be NULL). Either way nothing below
// is read: the block goes back to the caller whole.
if got := uint32(result.abi_version); got != ABIVersion {
return nil, errOtherABI(got)
}
if result.ok == 0 {
return nil, ErrDeclined
}
if uint32(result.abi_version) != ABIVersion {
return nil, fmt.Errorf("cevm: ABI version mismatch in result (lib=%d expected=%d)",
uint32(result.abi_version), ABIVersion)
}
br := &BlockResult{
GasUsed: copyU64(result.gas_used, uint32(result.num_txs)),
@@ -307,10 +326,10 @@ func AvailableBackends() []Backend {
return out
}
// LibraryABIVersion returns the ABI version reported by the loaded library.
// Useful for diagnostics when binaries and shared libs may drift.
// LibraryABIVersion returns the ABI the loaded library reports. When it is
// not ABIVersion, ExecuteBlock declines every block.
func LibraryABIVersion() uint32 {
return uint32(C.gpu_abi_version())
return libraryABI
}
// healthProbe is one entry in the Health() battery: a block, the state before
@@ -325,7 +344,7 @@ type healthProbe struct {
// healthBattery is what Health runs on every backend.
//
// gpu_execute_block runs one kind of block (go_bridge.h, ABI 6): plain value
// gpu_execute_block runs one kind of block (go_bridge.h, ABI 7): plain value
// transfers, on a GPU lane's value-transfer path. It declines a batch with
// code, and the CPU lanes run nothing without a host. So the battery is one
// such block — a funded sender's transfer to a fresh address — which a lane
evm/cevm/cevm_cgo_test.go
+318 -442
View File
@@ -4,31 +4,36 @@ package cevm
import (
"errors"
"fmt"
"strings"
"sync"
"sync/atomic"
"testing"
"github.com/luxfi/crypto"
"github.com/luxfi/geth/core/types"
)
// Tests in this file require the C++ EVM library (CGO_ENABLED=1
// -tags=lux_cevm_native). They are excluded from every build that does not
// link it, so those builds don't fail on API calls that can't possibly
// succeed without the library.
// -tags=lux_cevm_native) and hold it to go_bridge.h, ABI 7: a batch of plain
// transfers from funded senders runs on a GPU lane that has its device, to
// TxOK at 21000 gas each. Everything else is declined — a batch with code or
// calldata on any lane, and every batch on a CPU lane — as ErrDeclined and no
// result, and the caller runs it on its own EVM.
//
// A GPU lane is listed when the library was built with it, whether or not
// this host has the device, and without one it declines every block. The ABI
// carries nothing else that says a device is there, so a test that needs one
// skips on a GPU lane that declines the funded transfers.
func TestLibraryABIVersion(t *testing.T) {
got := LibraryABIVersion()
if got != ABIVersion {
if got := LibraryABIVersion(); got != ABIVersion {
t.Errorf("LibraryABIVersion() = %d, want %d (rebuild libevm-gpu)", got, ABIVersion)
}
}
// TestABIVersion locks the ABIVersion constant so a careless bump is caught
// by code review. Update both this test and ABIVersion together when the
// C ABI surface changes. It lives here because ABIVersion reports the linked
// library's ABI: without the library there is none, and cevm_nocgo.go says so
// with 0.
// TestABIVersion holds the constant to the ABI this binding is written to. A
// new ABI is read against this file before the number moves.
func TestABIVersion(t *testing.T) {
const want uint32 = 6
const want uint32 = 7
if ABIVersion != want {
t.Errorf("ABIVersion = %d, want %d (update C-side EVM_GPU_ABI_VERSION in lockstep)",
ABIVersion, want)
@@ -44,47 +49,316 @@ func TestAvailableBackends_HasCPU(t *testing.T) {
}
}
func smokeTx(i uint64) Transaction {
var from [20]byte
from[19] = byte(i + 1) // distinct sender per tx
return Transaction{
From: from,
HasTo: true,
GasLimit: 21000,
Value: 1,
Nonce: i,
GasPrice: 1,
// A block of funded plain transfers runs on a GPU lane to TxOK at 21000 gas
// each, or is declined there (no device); a CPU lane declines it. No lane
// answers anything else.
func TestAFundedTransferBlockRunsOnADeviceOrIsDeclined(t *testing.T) {
const n = 4
txs, ctx, state := transfers(n)
for _, b := range AvailableBackends() {
t.Run(BackendName(b), func(t *testing.T) {
r, err := ExecuteBlock(b, 0, txs, &ctx, state)
if !isGPU(b) {
declined(t, r, err)
return
}
if errors.Is(err, ErrDeclined) {
declined(t, r, err)
t.Logf("%s declined funded transfers: no device on this host", BackendName(b))
return
}
ranTransfers(t, r, err, n)
})
}
}
func TestExecuteBlockSmoke_AllBackends(t *testing.T) {
const N = 4
txs := make([]Transaction, N)
for i := range txs {
txs[i] = smokeTx(uint64(i))
// A batch that carries code is declined on every backend: gpu_execute_block
// passes no host, so it runs no code (go_bridge.h). The block is otherwise
// one a device runs, so the code is what declines it.
func TestABatchWithCodeIsDeclined(t *testing.T) {
txs, ctx, state := transfers(1)
code := computeBytecode(1)
txs[0].Code = code
for i := range state {
if state[i].Address == txs[0].To {
state[i].Code = code
state[i].CodeHash = crypto.Keccak256Hash(code)
}
}
for _, b := range AvailableBackends() {
t.Run(BackendName(b), func(t *testing.T) {
r, err := ExecuteBlock(b, 0, txs, nil, nil)
if err != nil {
t.Fatalf("ExecuteBlock(%s): %v", BackendName(b), err)
r, err := ExecuteBlock(b, 0, txs, &ctx, state)
declined(t, r, err)
})
}
}
// TestHealth runs the Health() battery: a funded plain transfer. A GPU lane
// runs it to TxOK at 21000 gas, or declines it on a host without its device;
// a CPU lane declines it, because the Go entry runs nothing on the CPU
// without a host (go_bridge.h).
func TestHealth(t *testing.T) {
reports := Health()
if len(reports) == 0 {
t.Fatal("Health() returned no reports — runtime cannot enumerate backends")
}
for _, r := range reports {
switch {
case isGPU(r.Backend) && r.OK:
if r.GasUsed != 21000 {
t.Errorf("Health: GPU lane %q ran the probe at %d gas, want 21000", r.Name, r.GasUsed)
}
if r.TotalGas == 0 {
t.Errorf("expected non-zero total gas, got 0")
case isGPU(r.Backend):
if !errors.Is(r.Err, ErrDeclined) {
t.Errorf("Health: GPU lane %q: err=%v, want ok at 21000 or declined", r.Name, r.Err)
}
if len(r.GasUsed) != N {
t.Errorf("len(GasUsed) = %d, want %d", len(r.GasUsed), N)
t.Logf("Health: GPU lane %q declined the probe: no device on this host", r.Name)
case r.OK || !errors.Is(r.Err, ErrDeclined):
t.Errorf("Health: CPU lane %q: ok=%v err=%v, want declined", r.Name, r.OK, r.Err)
}
}
}
// Goroutines running blocks on one device at once each get their own block's
// answer.
func TestConcurrentExecuteBlock(t *testing.T) {
for _, b := range deviceLanes(t) {
t.Run(BackendName(b), func(t *testing.T) {
const goroutines, iterations, n = 8, 16, 8
txs, ctx, state := transfers(n)
var wg sync.WaitGroup
for g := 0; g < goroutines; g++ {
wg.Add(1)
go func() {
defer wg.Done()
for i := 0; i < iterations; i++ {
r, err := ExecuteBlock(b, 0, txs, &ctx, state)
if err != nil || !allTransfers(r, n) {
t.Errorf("concurrent run on %s: err=%v result=%+v", BackendName(b), err, r)
return
}
}
}()
}
wg.Wait()
})
}
}
// TestConcurrent_Stress: 100 goroutines × 100 txs, each tx with its own code
// and calldata allocation. The library copies both before it declines the
// batch, so this is the regression test for runtime.Pinner: an unpinned Go
// pointer read from C panics or corrupts here. Every call must decline, and
// none may panic. Run with -race for full effect.
func TestConcurrent_Stress(t *testing.T) {
if testing.Short() {
t.Skip("stress test skipped in -short mode")
}
backends := AvailableBackends()
const goroutines, txsPerGoroutine = 100, 100
makeBlock := func(seed uint64) []Transaction {
txs := make([]Transaction, txsPerGoroutine)
for i := range txs {
data := make([]byte, 32)
for j := range data {
data[j] = byte(seed + uint64(i) + uint64(j))
}
tx := bytecodeTx(seed*txsPerGoroutine+uint64(i), computeBytecode(30))
tx.Data = data
txs[i] = tx
}
return txs
}
var wg sync.WaitGroup
wg.Add(goroutines)
for g := 0; g < goroutines; g++ {
go func(seed uint64) {
defer wg.Done()
defer func() {
if r := recover(); r != nil {
t.Errorf("goroutine %d panicked: %v", seed, r)
}
}()
b := backends[int(seed)%len(backends)]
r, err := ExecuteBlock(b, 0, makeBlock(seed), nil, nil)
if !errors.Is(err, ErrDeclined) || r != nil {
t.Errorf("goroutine %d on %s: (%+v, %v), want declined", seed, BackendName(b), r, err)
}
}(uint64(g))
}
wg.Wait()
}
// TestExecuteBlock_LargeCode: 64 KiB of code crosses the boundary (the
// library copies it) and the batch is declined cleanly, never a segfault from
// an unchecked uint32 or an unpinned slice.
func TestExecuteBlock_LargeCode(t *testing.T) {
code := computeBytecode(8000)
if len(code) < 32_000 {
t.Fatalf("expected >= 32K bytecode, got %d", len(code))
}
tx := bytecodeTx(0, code)
tx.GasLimit = 50_000_000
r, err := ExecuteBlock(CPUSequential, 0, []Transaction{tx}, nil, nil)
declined(t, r, err)
}
// TestExecuteBlock_LargeData: 64 KiB of calldata on an otherwise funded
// transfer crosses the boundary through the data pin, and every lane
// declines it: the value-transfer device paths do not price calldata.
func TestExecuteBlock_LargeData(t *testing.T) {
txs, ctx, state := transfers(1)
txs[0].Data = make([]byte, 1<<16)
for i := range txs[0].Data {
txs[0].Data[i] = byte(i)
}
txs[0].GasLimit = 2_000_000
state[0].Balance[0] = 10_000_000 // covers the limit: calldata is the only reason left
for _, b := range AvailableBackends() {
t.Run(BackendName(b), func(t *testing.T) {
r, err := ExecuteBlock(b, 0, txs, &ctx, state)
declined(t, r, err)
})
}
}
// TestBackendUnavailable: a backend the library does not offer declines the
// block, and never panics.
func TestBackendUnavailable(t *testing.T) {
available := AvailableBackends()
missing := Backend(-1)
for _, b := range []Backend{CPUSequential, CPUParallel, GPUMetal, GPUCUDA} {
if !contains(available, b) {
missing = b
break
}
}
if missing < 0 {
t.Skip("all backends available — cannot test unavailable path")
}
txs, ctx, state := transfers(1)
r, err := ExecuteBlock(missing, 0, txs, &ctx, state)
declined(t, r, err)
}
// A library that reports another ABI is sent nothing: every block is
// declined, a block a device would have run included, and the error says why.
func TestALibraryOfAnotherABIIsDeclined(t *testing.T) {
loaded := libraryABI
t.Cleanup(func() { libraryABI = loaded })
libraryABI = ABIVersion - 1
if got := LibraryABIVersion(); got != ABIVersion-1 {
t.Fatalf("LibraryABIVersion() = %d, want the library's %d", got, ABIVersion-1)
}
txs, ctx, state := transfers(2)
for _, b := range AvailableBackends() {
t.Run(BackendName(b), func(t *testing.T) {
r, err := ExecuteBlock(b, 0, txs, &ctx, state)
declined(t, r, err)
if !strings.Contains(err.Error(), "ABI") {
t.Errorf("the decline does not say the ABI is why: %v", err)
}
})
}
}
// computeBytecode returns deterministic EVM bytecode that does N additions
// then returns. Used to exercise the GPU opcode interpreter with measurable
// gas consumption.
// -----------------------------------------------------------------------------
// helpers
// -----------------------------------------------------------------------------
func isGPU(b Backend) bool { return b == GPUMetal || b == GPUCUDA }
// transfers is a block of n plain transfers, each from its own funded sender
// to its own fresh recipient, with the block context and the state before the
// block that go_bridge.h asks for. Each limit is above the 21000 a transfer
// costs, so a lane that answers the limit as an estimate is not taken for one
// that ran it.
func transfers(n int) ([]Transaction, BlockContext, []StateAccount) {
ctx := BlockContext{GasLimit: 30_000_000, ChainID: 1, BaseFee: 1, Coinbase: [20]byte{0xC0}}
txs := make([]Transaction, n)
state := make([]StateAccount, 0, 2*n+1)
for i := range txs {
from := [20]byte{0xA0, byte(i >> 8), byte(i)}
to := [20]byte{0xB0, byte(i >> 8), byte(i)}
txs[i] = Transaction{From: from, To: to, HasTo: true, GasLimit: 30_000, Value: 1, GasPrice: 1}
state = append(state, account(from, 1_000_000), account(to, 0))
}
state = append(state, account(ctx.Coinbase, 0))
return txs, ctx, state
}
// account is a snapshot row for an account without code or storage.
func account(addr [20]byte, balance uint64) StateAccount {
return StateAccount{
Address: addr,
Balance: [4]uint64{balance},
CodeHash: types.EmptyCodeHash,
StorageRoot: types.EmptyRootHash,
}
}
// allTransfers reports whether r is n plain transfers run: every one TxOK at
// 21000 gas, at ABI 7.
func allTransfers(r *BlockResult, n int) bool {
if r == nil || len(r.GasUsed) != n || len(r.Status) != n || r.ABIVersion != ABIVersion {
return false
}
for i := 0; i < n; i++ {
if r.Status[i] != TxOK || r.GasUsed[i] != 21000 {
return false
}
}
return r.TotalGas == uint64(n)*21000
}
func ranTransfers(t *testing.T, r *BlockResult, err error, n int) {
t.Helper()
if err != nil {
t.Fatalf("ExecuteBlock: %v", err)
}
if !allTransfers(r, n) {
t.Fatalf("result is not %d transfers run at 21000 gas: %+v", n, r)
}
}
// declined holds an answer to the one other thing ExecuteBlock may say:
// ErrDeclined, and no result.
func declined(t *testing.T, r *BlockResult, err error) {
t.Helper()
if !errors.Is(err, ErrDeclined) {
t.Fatalf("ExecuteBlock = %v, want ErrDeclined", err)
}
if r != nil {
t.Fatalf("a declined block came back with a result: %+v", r)
}
}
// deviceLanes is the GPU lanes on which this host runs a block of funded
// transfers. It skips the test when there is none.
func deviceLanes(t *testing.T) []Backend {
t.Helper()
txs, ctx, state := transfers(1)
var out []Backend
for _, b := range AvailableBackends() {
if !isGPU(b) {
continue
}
if _, err := ExecuteBlock(b, 0, txs, &ctx, state); err == nil {
out = append(out, b)
}
}
if len(out) == 0 {
t.Skip("no GPU lane runs a block on this host: no device")
}
return out
}
// computeBytecode returns deterministic EVM bytecode that does iters
// additions then returns.
func computeBytecode(iters int) []byte {
out := make([]byte, 0, iters*5+5)
out := make([]byte, 0, iters*6+5)
for i := 0; i < iters; i++ {
out = append(out,
0x60, 0x01, // PUSH1 1
@@ -93,18 +367,17 @@ func computeBytecode(iters int) []byte {
0x50, // POP
)
}
out = append(out,
return append(out,
0x60, 0x00, // PUSH1 0
0x60, 0x00, // PUSH1 0
0xf3, // RETURN
)
return out
}
func bytecodeTx(i uint64, code []byte) Transaction {
var from [20]byte
from[19] = byte((i & 0xff))
from[18] = byte((i >> 8) & 0xff)
from[19] = byte(i)
from[18] = byte(i >> 8)
return Transaction{
From: from,
HasTo: true,
@@ -115,39 +388,7 @@ func bytecodeTx(i uint64, code []byte) Transaction {
}
}
// TestGPUBytecodeExecution sends a batch of txs each with real EVM bytecode
// through the GPU-Metal backend.
func TestGPUBytecodeExecution(t *testing.T) {
if !contains(AvailableBackends(), GPUMetal) {
t.Skip("Metal backend not available")
}
const N = 32
code := computeBytecode(50)
txs := make([]Transaction, N)
for i := range txs {
txs[i] = bytecodeTx(uint64(i), code)
}
r, err := ExecuteBlock(GPUMetal, 0, txs, nil, nil)
if err != nil {
t.Fatalf("GPU bytecode execute: %v", err)
}
if len(r.GasUsed) != N {
t.Fatalf("len(GasUsed)=%d, want %d", len(r.GasUsed), N)
}
zeros := 0
for _, g := range r.GasUsed {
if g == 0 {
zeros++
}
}
if zeros == N {
t.Fatalf("all %d txs reported 0 gas — kernel didn't execute bytecode", N)
}
t.Logf("GPU bytecode: %d txs, total gas=%d, time=%.2fms", N, r.TotalGas, r.ExecTimeMs)
}
// contains reports whether b appears in s. Local helper so test files don't
// pull in slices.Contains and our go.mod stays minimal.
// contains reports whether b appears in s.
func contains(s []Backend, b Backend) bool {
for _, x := range s {
if x == b {
@@ -156,368 +397,3 @@ func contains(s []Backend, b Backend) bool {
}
return false
}
// TestHealth runs the Health() battery: a funded plain transfer. A GPU lane
// runs it to TxOK at 21000 gas; a CPU lane declines it, because the Go entry
// runs nothing on the CPU without a host (go_bridge.h). This is the
// production-readiness gate.
func TestHealth(t *testing.T) {
reports := Health()
if len(reports) == 0 {
t.Fatal("Health() returned no reports — runtime cannot enumerate backends")
}
for _, r := range reports {
if r.Backend == GPUMetal || r.Backend == GPUCUDA {
if !r.OK || r.GasUsed != 21000 {
t.Errorf("Health: GPU lane %q: ok=%v gas=%d err=%v, want ok at 21000", r.Name, r.OK, r.GasUsed, r.Err)
}
continue
}
if r.OK || !errors.Is(r.Err, ErrDeclined) {
t.Errorf("Health: CPU lane %q: ok=%v err=%v, want declined", r.Name, r.OK, r.Err)
}
}
}
// TestHealth_BackendParity asserts that every probe runs on every available
// backend and that gas across backends matches for the bytecode-only probes.
// CPU and GPU MUST agree on gas for canonical opcode programs — divergence
// means a kernel is wrong.
func TestHealth_BackendParity(t *testing.T) {
reports := Health()
if len(reports) < 2 {
t.Skipf("need >= 2 backends for parity check, have %d", len(reports))
}
// Group probe results by probe name → list of (backend, gas, status).
type point struct {
backend Backend
gas uint64
status TxStatus
probeOK bool
}
byProbe := map[string][]point{}
for _, r := range reports {
if !r.OK {
continue
}
for _, p := range r.ProbeResults {
byProbe[p.Name] = append(byProbe[p.Name], point{
backend: r.Backend,
gas: p.GasUsed,
status: p.Status,
probeOK: p.OK,
})
}
}
for probe, pts := range byProbe {
if len(pts) < 2 {
continue // only one backend ran this probe — nothing to compare
}
ref := pts[0]
for _, p := range pts[1:] {
if !p.probeOK || !ref.probeOK {
continue
}
if p.status != ref.status {
t.Errorf("probe %q: status mismatch %s=%s vs %s=%s",
probe, ref.backend, ref.status, p.backend, p.status)
}
if p.gas != ref.gas {
t.Logf("probe %q: gas differs across backends %s=%d vs %s=%d",
probe, ref.backend, ref.gas, p.backend, p.gas)
}
}
}
}
// TestConcurrentExecuteBlock fires multiple goroutines at every available
// backend simultaneously to exercise thread-safety.
func TestConcurrentExecuteBlock(t *testing.T) {
if !contains(AvailableBackends(), GPUMetal) {
t.Skip("Metal backend not available")
}
const goroutines = 8
const iterations = 16
const N = 8
code := computeBytecode(20)
txs := make([]Transaction, N)
for i := range txs {
txs[i] = bytecodeTx(uint64(i), code)
}
ref, err := ExecuteBlock(GPUMetal, 0, txs, nil, nil)
if err != nil {
t.Fatalf("reference ExecuteBlock: %v", err)
}
want := ref.TotalGas
if want == 0 {
t.Fatal("reference total gas == 0")
}
errCh := make(chan error, goroutines*iterations)
doneCh := make(chan struct{}, goroutines)
for g := 0; g < goroutines; g++ {
go func() {
defer func() { doneCh <- struct{}{} }()
for i := 0; i < iterations; i++ {
r, err := ExecuteBlock(GPUMetal, 0, txs, nil, nil)
if err != nil {
errCh <- err
return
}
if r.TotalGas != want {
errCh <- fmt.Errorf("concurrent total gas drift: got %d want %d",
r.TotalGas, want)
return
}
}
}()
}
for g := 0; g < goroutines; g++ {
<-doneCh
}
close(errCh)
for err := range errCh {
t.Error(err)
}
}
// TestConcurrent_Stress: 100 goroutines × 100 txs each, real bytecode.
// This is the regression test for runtime.Pinner correctness — if any Go
// pointer reachable from C is unpinned, this test will panic or report
// corrupted gas. Race detector must be enabled with -race for full effect.
func TestConcurrent_Stress(t *testing.T) {
if testing.Short() {
t.Skip("stress test skipped in -short mode")
}
backends := AvailableBackends()
if len(backends) == 0 {
t.Skip("no backends")
}
// Pick the most parallel backend present; falls back to CPUSequential.
var backend Backend
switch {
case contains(backends, GPUMetal):
backend = GPUMetal
case contains(backends, CPUParallel):
backend = CPUParallel
default:
backend = CPUSequential
}
const goroutines = 100
const txsPerGoroutine = 100
const iters = 30 // smaller body so each block runs fast on CPU paths
// Build a reference block once. Each goroutine sends an independent
// copy of the slices to maximize the chance of catching unpinned aliasing.
makeBlock := func(seed uint64) []Transaction {
txs := make([]Transaction, txsPerGoroutine)
// Each tx gets its own bytecode + calldata slice (separate Go-heap
// allocations) — this is deliberately the worst case for the pinner.
for i := range txs {
code := computeBytecode(iters)
data := make([]byte, 32)
for j := range data {
data[j] = byte((seed + uint64(i) + uint64(j)) & 0xff)
}
tx := bytecodeTx(seed*uint64(txsPerGoroutine)+uint64(i), code)
tx.Data = data
txs[i] = tx
}
return txs
}
// Single-goroutine reference run for total-gas assertion.
ref, err := ExecuteBlock(backend, 0, makeBlock(0), nil, nil)
if err != nil {
t.Fatalf("reference: %v", err)
}
if ref.TotalGas == 0 {
t.Fatal("reference total gas == 0")
}
want := ref.TotalGas
var (
wg sync.WaitGroup
failed atomic.Int32
drifted atomic.Int32
)
wg.Add(goroutines)
for g := 0; g < goroutines; g++ {
go func(seed uint64) {
defer wg.Done()
defer func() {
if r := recover(); r != nil {
failed.Add(1)
t.Errorf("goroutine %d panicked: %v", seed, r)
}
}()
block := makeBlock(seed)
r, err := ExecuteBlock(backend, 0, block, nil, nil)
if err != nil {
failed.Add(1)
t.Errorf("goroutine %d: ExecuteBlock: %v", seed, err)
return
}
if r.TotalGas != want {
drifted.Add(1)
t.Errorf("goroutine %d: TotalGas drift: got %d want %d",
seed, r.TotalGas, want)
}
}(uint64(g))
}
wg.Wait()
if failed.Load() > 0 {
t.Errorf("%d goroutines failed", failed.Load())
}
if drifted.Load() > 0 {
t.Errorf("%d goroutines reported drifted gas", drifted.Load())
}
t.Logf("stress: %d goroutines × %d txs on %s — all consistent (gas=%d)",
goroutines, txsPerGoroutine, BackendName(backend), want)
}
// TestExecuteBlock_LargeCode: a single tx with a very large bytecode buffer
// must not segfault and must either succeed or return a clean error. This
// guards against unchecked uint32 truncation or pinner failure on big slices.
func TestExecuteBlock_LargeCode(t *testing.T) {
// 64 KiB of harmless ADD/POP loops + RETURN — well within EIP-170 limits
// but big enough that an unpinned slice would crash quickly.
code := computeBytecode(8000)
if len(code) < 32_000 {
t.Fatalf("expected >= 32K bytecode, got %d", len(code))
}
tx := bytecodeTx(0, code)
tx.GasLimit = 50_000_000
r, err := ExecuteBlock(CPUSequential, 0, []Transaction{tx}, nil, nil)
if err != nil {
t.Fatalf("large code: %v", err)
}
if len(r.GasUsed) != 1 {
t.Fatalf("len(GasUsed) = %d, want 1", len(r.GasUsed))
}
t.Logf("large code: %d bytes, gas=%d", len(code), r.GasUsed[0])
}
// TestExecuteBlock_LargeData: large calldata path. Same intent as the
// large-code test but exercising the data-pointer pin.
func TestExecuteBlock_LargeData(t *testing.T) {
const size = 1 << 16 // 64 KiB
data := make([]byte, size)
for i := range data {
data[i] = byte(i & 0xff)
}
tx := smokeTx(0)
tx.Data = data
r, err := ExecuteBlock(CPUSequential, 0, []Transaction{tx}, nil, nil)
if err != nil {
t.Fatalf("large data: %v", err)
}
if len(r.GasUsed) != 1 {
t.Fatalf("len(GasUsed) = %d, want 1", len(r.GasUsed))
}
}
// TestExecuteBlock_EmptyCodeAndData: a tx with neither Code nor Data must
// route through the scheduler-only path and return a sane result. Verifies
// that the conditional pinner code paths (only pin when len > 0) don't
// erroneously dereference nil.
func TestExecuteBlock_EmptyCodeAndData(t *testing.T) {
tx := smokeTx(0)
// Explicitly clear in case smokeTx ever changes.
tx.Code = nil
tx.Data = nil
r, err := ExecuteBlock(CPUSequential, 0, []Transaction{tx}, nil, nil)
if err != nil {
t.Fatalf("empty code+data: %v", err)
}
if len(r.GasUsed) != 1 {
t.Fatalf("len(GasUsed) = %d, want 1", len(r.GasUsed))
}
}
// TestBackendUnavailable: requesting a backend that isn't in
// AvailableBackends() must return an error or a zero-gas result, never panic.
func TestBackendUnavailable(t *testing.T) {
available := AvailableBackends()
// Find a backend that is NOT in available.
all := []Backend{CPUSequential, CPUParallel, GPUMetal, GPUCUDA}
var missing Backend = -1
for _, b := range all {
if !contains(available, b) {
missing = b
break
}
}
if missing < 0 {
t.Skip("all backends available — cannot test unavailable path")
}
tx := smokeTx(0)
defer func() {
// We don't care which mode the C++ side picks — error or zero gas
// or graceful fallback — but it MUST NOT panic.
if r := recover(); r != nil {
t.Errorf("requesting unavailable backend %s panicked: %v", missing, r)
}
}()
r, err := ExecuteBlock(missing, 0, []Transaction{tx}, nil, nil)
if err != nil {
t.Logf("unavailable backend %s returned error (expected): %v", missing, err)
return
}
t.Logf("unavailable backend %s fell back gracefully: TotalGas=%d", missing, r.TotalGas)
}
// TestExecuteBlock_GasParity_AcrossBackends compares gas across backends
// for the same canonical workload. Where backends agree, they must agree
// exactly on gas. Where they don't (kernel still in development), we just
// log the divergence — the strict gate is in TestOpcodeCoverage_GPU_vs_CPU.
//
// This test is the cross-backend complement to per-opcode gas parity:
// it catches block-level gas accounting bugs that wouldn't show up in a
// single-opcode test (e.g. block-STM commit accounting).
func TestExecuteBlock_GasParity_AcrossBackends(t *testing.T) {
available := AvailableBackends()
if len(available) < 2 {
t.Skipf("need >= 2 backends for parity check, have %d", len(available))
}
const N = 16
code := computeBytecode(20)
makeTxs := func() []Transaction {
txs := make([]Transaction, N)
for i := range txs {
txs[i] = bytecodeTx(uint64(i), code)
}
return txs
}
results := make(map[Backend]uint64)
for _, b := range available {
r, err := ExecuteBlock(b, 0, makeTxs(), nil, nil)
if err != nil {
t.Logf("ExecuteBlock(%s): %v (skipping in parity check)", b, err)
continue
}
results[b] = r.TotalGas
t.Logf("backend=%s TotalGas=%d", b, r.TotalGas)
}
if len(results) < 2 {
t.Skip("only one backend produced a result; cannot compare")
}
// Compare each backend against every other; report on mismatches.
var first Backend
var firstGas uint64
pickedFirst := false
for b, g := range results {
if !pickedFirst {
first, firstGas, pickedFirst = b, g, true
continue
}
if g != firstGas {
t.Logf("gas diverges across backends: %s=%d %s=%d (acceptable when "+
"GPU kernel coverage differs from CPU)", first, firstGas, b, g)
}
}
}
evm/cevm/cevm_nolib_test.go
+123
View File
@@ -0,0 +1,123 @@
// Copyright (C) 2025-2026, Lux Industries Inc. All rights reserved.
// See the file LICENSE for licensing terms.
//go:build !cgo || !lux_cevm_native
package cevm
import (
"errors"
"strings"
"testing"
"github.com/luxfi/geth/core/types"
)
// Tests in this file run in every build that does not link the native
// library — the default build, and the only one that works on a host without
// the lux-cevm bundle — and pin what the package does there: refuse every
// block with transactions in it, and say which build tag fixes that.
// The one property that matters when the native EVM is not linked: a block
// with transactions in it must NOT come back as a result.
//
// A successful-looking BlockResult here is a block whose transactions were
// never applied. The caller writes the state root and the gas, consensus
// accepts it, and the chain has diverged from every node that did link the
// library — silently, because nothing errored. So the refusal is the
// consensus-relevant behaviour, not a convenience.
func TestABlockWithTransactionsIsRefusedRatherThanFaked(t *testing.T) {
for _, backend := range []Backend{CPUSequential, CPUParallel, GPUMetal, GPUCUDA} {
result, err := ExecuteBlock(backend, 4, []Transaction{{GasLimit: 21000}}, nil, nil)
if err == nil {
t.Fatalf("ExecuteBlock(%s, 1 tx) returned no error; a block that was never "+
"executed must not come back as a result", backend)
}
if result != nil {
t.Errorf("ExecuteBlock(%s, 1 tx) returned a result (%+v) alongside its refusal",
backend, result)
}
// The message has to say what to do about it: an operator reading a
// bare "not supported" cannot tell a missing build tag from a missing
// GPU.
if !strings.Contains(err.Error(), "lux_cevm_native") {
t.Errorf("ExecuteBlock error %q does not name the build tag that fixes it", err)
}
}
}
// A block context and a state snapshot do not change the refusal. They are the
// V4 arguments; accepting them and then not executing would be the same
// divergence with more ceremony.
func TestContextAndSnapshotDoNotBuyExecution(t *testing.T) {
ctx := &BlockContext{ChainID: 96369, Number: 7}
snapshot := []StateAccount{{Nonce: 1}}
if _, err := ExecuteBlock(GPUCUDA, 8, []Transaction{{GasLimit: 21000}}, ctx, snapshot); err == nil {
t.Fatal("ExecuteBlock accepted a block once it was handed a context and a snapshot")
}
}
// BatchRecoverSenders is the same shape: no transactions is not a failure, and
// any transaction is a refusal. Its doc tells the caller to fall back to
// per-tx types.Sender, which is only actionable if the caller can tell the two
// apart — so the empty case must not error.
func TestBatchRecoveryRefusesWorkAndNotEmptiness(t *testing.T) {
signer := types.LatestSignerForChainID(nil)
senders, err := BatchRecoverSenders(nil, signer)
if err != nil {
t.Fatalf("BatchRecoverSenders(nil) = %v, want no error", err)
}
if senders != nil {
t.Errorf("BatchRecoverSenders(nil) returned %d senders", len(senders))
}
txs := types.Transactions{types.NewTx(&types.LegacyTx{Gas: 21000})}
senders, err = BatchRecoverSenders(txs, signer)
if err == nil {
t.Fatal("BatchRecoverSenders returned no error with the native library unlinked; " +
"a caller would read the zero addresses as recovered senders")
}
if senders != nil {
t.Errorf("BatchRecoverSenders returned %d senders alongside its refusal", len(senders))
}
if !strings.Contains(err.Error(), "lux_cevm_native") {
t.Errorf("BatchRecoverSenders error %q does not name the build tag that fixes it", err)
}
}
// The name is the Backend's own String under this build — there is no library
// to ask — so the two cannot drift into two vocabularies for one lane.
func TestBackendNameAgreesWithTheStringer(t *testing.T) {
for _, b := range []Backend{CPUSequential, CPUParallel, GPUMetal, GPUCUDA, Backend(99)} {
if got, want := BackendName(b), b.String(); got != want {
t.Errorf("BackendName(%d) = %q, Backend.String() = %q", int(b), got, want)
}
}
}
// The ABI the Go module reads and the ABI the loaded library reports are
// compared at process start, and against a mismatch nothing is executed: a
// silent skew produces wrong gas and wrong state roots, which is a consensus
// fault. With no library linked there is nothing to compare against, and
// LibraryABIVersion must say so by agreeing with the Go-side constant rather
// than inventing a number that would pass a check it never made.
func TestWithNoLibraryTheReportedABIIsTheGoSideConstant(t *testing.T) {
if got := LibraryABIVersion(); got != ABIVersion {
t.Fatalf("LibraryABIVersion() = %d, want ABIVersion = %d", got, ABIVersion)
}
}
// With no library linked, the one health report says the library is what is
// missing. It used to blame CGo, which is enabled on the default build; an
// operator who followed that checked CGO_ENABLED and found it already 1.
func TestAHealthReportWithNoLibraryBlamesTheLibrary(t *testing.T) {
reports := Health()
if len(reports) != 1 {
t.Fatalf("Health() gave %d reports, want the one lane this build has", len(reports))
}
if h := reports[0]; h.OK || !errors.Is(h.Err, ErrNotLinked) {
t.Errorf("backend %q: ok=%v err=%v, want not ok with cevm.ErrNotLinked", h.Name, h.OK, h.Err)
}
}
evm/cevm/cevm_test.go
+9 -103
View File
@@ -4,18 +4,15 @@
package cevm
import (
"strings"
"testing"
"unsafe"
"github.com/luxfi/geth/core/types"
)
// Tests in this file run under every build. They cover the parts of the API
// that do not depend on the C++ library: the enum stringers, the wire layout
// the C ABI reads by memcpy, and — the part that matters — what the package
// does when the native library is NOT linked, which is the default build and
// the only one that works on a host without the lux-cevm bundle.
// Tests in this file run under every build, the native one included. They
// cover the parts of the API that answer the same with or without the C++
// library: the enum stringers, the wire layout the C ABI reads by memcpy, an
// empty block, and what a build says about its own lanes. What the package
// does when the library is NOT linked is in cevm_nolib_test.go.
func TestBackendString(t *testing.T) {
tests := []struct {
@@ -57,49 +54,9 @@ func TestTxStatusString(t *testing.T) {
}
// -----------------------------------------------------------------------------
// Refusing, rather than pretending to execute
// An empty block
// -----------------------------------------------------------------------------
// The one property that matters when the native EVM is not linked: a block
// with transactions in it must NOT come back as a result.
//
// A successful-looking BlockResult here is a block whose transactions were
// never applied. The caller writes the state root and the gas, consensus
// accepts it, and the chain has diverged from every node that did link the
// library — silently, because nothing errored. So the refusal is the
// consensus-relevant behaviour, not a convenience.
func TestABlockWithTransactionsIsRefusedRatherThanFaked(t *testing.T) {
for _, backend := range []Backend{CPUSequential, CPUParallel, GPUMetal, GPUCUDA} {
result, err := ExecuteBlock(backend, 4, []Transaction{{GasLimit: 21000}}, nil, nil)
if err == nil {
t.Fatalf("ExecuteBlock(%s, 1 tx) returned no error; a block that was never "+
"executed must not come back as a result", backend)
}
if result != nil {
t.Errorf("ExecuteBlock(%s, 1 tx) returned a result (%+v) alongside its refusal",
backend, result)
}
// The message has to say what to do about it: an operator reading a
// bare "not supported" cannot tell a missing build tag from a missing
// GPU.
if !strings.Contains(err.Error(), "lux_cevm_native") {
t.Errorf("ExecuteBlock error %q does not name the build tag that fixes it", err)
}
}
}
// A block context and a state snapshot do not change the refusal. They are the
// V4 arguments; accepting them and then not executing would be the same
// divergence with more ceremony.
func TestContextAndSnapshotDoNotBuyExecution(t *testing.T) {
ctx := &BlockContext{ChainID: 96369, Number: 7}
snapshot := []StateAccount{{Nonce: 1}}
if _, err := ExecuteBlock(GPUCUDA, 8, []Transaction{{GasLimit: 21000}}, ctx, snapshot); err == nil {
t.Fatal("ExecuteBlock accepted a block once it was handed a context and a snapshot")
}
}
// An empty block is the documented exception: there is nothing to execute, so
// there is nothing to get wrong, and the caller gets the ABI the linked library
// reports rather than an error it would have to special-case.
@@ -125,35 +82,6 @@ func TestAnEmptyBlockIsTheOneThingThatCanBeAnswered(t *testing.T) {
}
}
// BatchRecoverSenders is the same shape: no transactions is not a failure, and
// any transaction is a refusal. Its doc tells the caller to fall back to
// per-tx types.Sender, which is only actionable if the caller can tell the two
// apart — so the empty case must not error.
func TestBatchRecoveryRefusesWorkAndNotEmptiness(t *testing.T) {
signer := types.LatestSignerForChainID(nil)
senders, err := BatchRecoverSenders(nil, signer)
if err != nil {
t.Fatalf("BatchRecoverSenders(nil) = %v, want no error", err)
}
if senders != nil {
t.Errorf("BatchRecoverSenders(nil) returned %d senders", len(senders))
}
txs := types.Transactions{types.NewTx(&types.LegacyTx{Gas: 21000})}
senders, err = BatchRecoverSenders(txs, signer)
if err == nil {
t.Fatal("BatchRecoverSenders returned no error with the native library unlinked; " +
"a caller would read the zero addresses as recovered senders")
}
if senders != nil {
t.Errorf("BatchRecoverSenders returned %d senders alongside its refusal", len(senders))
}
if !strings.Contains(err.Error(), "lux_cevm_native") {
t.Errorf("BatchRecoverSenders error %q does not name the build tag that fixes it", err)
}
}
// -----------------------------------------------------------------------------
// What this build reports about itself
// -----------------------------------------------------------------------------
@@ -183,28 +111,6 @@ func TestThisBuildReportsExactlyTheBackendItCanRun(t *testing.T) {
}
}
// The name is the Backend's own String under this build — there is no library
// to ask — so the two cannot drift into two vocabularies for one lane.
func TestBackendNameAgreesWithTheStringer(t *testing.T) {
for _, b := range []Backend{CPUSequential, CPUParallel, GPUMetal, GPUCUDA, Backend(99)} {
if got, want := BackendName(b), b.String(); got != want {
t.Errorf("BackendName(%d) = %q, Backend.String() = %q", int(b), got, want)
}
}
}
// The ABI the Go module expects and the ABI the loaded library reports are
// compared at process start, and a mismatch panics on purpose: a silent skew
// produces wrong gas and wrong state roots, which is a consensus fault. With
// no library linked there is nothing to compare against, and LibraryABIVersion
// must say so by agreeing with the Go-side constant rather than inventing a
// number that would pass a check it never made.
func TestWithNoLibraryTheReportedABIIsTheGoSideConstant(t *testing.T) {
if got := LibraryABIVersion(); got != ABIVersion {
t.Fatalf("LibraryABIVersion() = %d, want ABIVersion = %d", got, ABIVersion)
}
}
// Health never returns nothing. A caller that reads an empty report cannot
// distinguish "every backend is fine" from "nobody looked", and this one runs
// at node start-up where that difference decides whether the chain runs.
@@ -238,9 +144,9 @@ func TestHealthAlwaysAnswersAndSaysWhyWhenItCannotRun(t *testing.T) {
// left it passing. Offsets are what a reorder changes.
//
// A change to any number below means the C side's CBlockContext must move in
// lockstep AND ABIVersion must be bumped on both sides — the mismatch check at
// process start is the only thing that catches a skew, and it can only catch a
// skew that was declared.
// lockstep AND ABIVersion must be bumped on both sides — the ABI checks (the
// header's number at build time, the library's at start) are the only thing
// that catches a skew, and they can only catch a skew that was declared.
func TestBlockContextIsTheWireLayout(t *testing.T) {
var c BlockContext
evm/cevm/metal_resource_test.go
+12 -26
View File
@@ -2,37 +2,23 @@
package cevm
import (
"slices"
"testing"
)
import "testing"
// TestMetalSustainedExecution guards the fix in luxcpp/cevm's
// EvmKernelHost::create(): it used to compile evm_kernel.metal and allocate a
// command queue and pipeline states on every call, so a process doing
// sustained work piled up Metal objects until the driver faulted. The crash
// needed volume to show up — any single execution was fine, which is why it
// survived as long as it did.
//
// Executing the same trivial block many times reproduces that in seconds. It
// is a resource test, so it asserts only that every run completes; opcode
// semantics are covered by TestOpcodeCoverage_GPU_vs_CPU.
// TestMetalSustainedExecution guards against a device path that builds its
// pipelines and queues on every call: a process doing sustained work piles
// them up until the driver faults, which no single execution shows. Running
// the same block of transfers many times reproduces that in seconds, and
// every run must still be the block's answer.
func TestMetalSustainedExecution(t *testing.T) {
if !slices.Contains(AvailableBackends(), GPUMetal) {
t.Skip("no Metal backend on this host")
}
var from [20]byte
from[19] = 0x42
tx := Transaction{
From: from,
GasLimit: 100_000,
GasPrice: 1,
Code: []byte{0x60, 0x01, 0x00}, // PUSH1 1; STOP
if !contains(deviceLanes(t), GPUMetal) {
t.Skip("Metal runs no block on this host")
}
txs, ctx, state := transfers(1)
const runs = 250
for i := range runs {
if _, err := ExecuteBlock(GPUMetal, 1, []Transaction{tx}, nil, nil); err != nil {
t.Fatalf("run %d of %d failed: %v", i+1, runs, err)
r, err := ExecuteBlock(GPUMetal, 1, txs, &ctx, state)
if err != nil || !allTransfers(r, 1) {
t.Fatalf("run %d of %d: err=%v result=%+v", i+1, runs, err, r)
}
}
}
evm/cevm/opcodes_test.go
-511
View File
@@ -1,511 +0,0 @@
//go:build cgo && lux_cevm_native
package cevm
import (
"fmt"
"sort"
"sync"
"testing"
)
// ----------------------------------------------------------------------------
// Bytecode builder
// ----------------------------------------------------------------------------
// prog is a tiny, append-only EVM bytecode builder. Every method returns the
// receiver so call chains read like an assembly listing.
type prog struct{ b []byte }
// op appends a single opcode byte.
func (p *prog) op(o byte) *prog {
p.b = append(p.b, o)
return p
}
// raw appends arbitrary bytes (used after PUSH for the immediate operand).
func (p *prog) raw(bs ...byte) *prog {
p.b = append(p.b, bs...)
return p
}
// push appends a PUSH<n> with the supplied operand bytes.
// n must be in [1, 32]; len(val) must equal n.
func (p *prog) push(n int, val ...byte) *prog {
if n < 1 || n > 32 {
panic(fmt.Sprintf("prog.push: bad n=%d", n))
}
if len(val) != n {
panic(fmt.Sprintf("prog.push: n=%d but len(val)=%d", n, len(val)))
}
p.b = append(p.b, 0x60+byte(n-1)) // PUSH1=0x60 ... PUSH32=0x7F
p.b = append(p.b, val...)
return p
}
// push1 is the common case.
func (p *prog) push1(v byte) *prog { return p.push(1, v) }
// bytes returns the assembled bytecode.
func (p *prog) bytes() []byte { return p.b }
// stop / revert / ret terminate the program.
func (p *prog) stop() *prog { return p.op(0x00) }
func (p *prog) revert() *prog { return p.push1(0).push1(0).op(0xFD) }
func (p *prog) ret() *prog { return p.push1(0).push1(0).op(0xF3) }
// ----------------------------------------------------------------------------
// Test table — one entry per defined EVM opcode.
// ----------------------------------------------------------------------------
// opcodeTest describes a single opcode probe.
type opcodeTest struct {
name string
opcode byte
bytecode []byte
// expectStatus is the status the CPU reference path is expected to return.
// We assert CPU status equals this; GPU is compared to CPU when not skipGPU.
expectStatus TxStatus
// skipGPU=true for opcodes the GPU kernel cannot run by itself (CALL family).
// We still run them through CPU to confirm CPU baseline; GPU is skipped with
// a logged note instead of failing.
skipGPU bool
// needsCalldata populates tx.Data for calldata opcodes.
needsCalldata bool
// needsTo populates tx.HasTo for context opcodes that read the recipient.
needsTo bool
}
// allOpcodeTests is the canonical opcode coverage table. One entry per opcode.
// Order is by opcode value so coverage gaps are visible at a glance.
var allOpcodeTests = []opcodeTest{
// 0x00 — STOP
{name: "STOP", opcode: 0x00, bytecode: (&prog{}).stop().bytes(), expectStatus: TxOK},
// 0x01..0x0B — arithmetic
{name: "ADD", opcode: 0x01, bytecode: (&prog{}).push1(5).push1(3).op(0x01).stop().bytes(), expectStatus: TxOK},
{name: "MUL", opcode: 0x02, bytecode: (&prog{}).push1(5).push1(3).op(0x02).stop().bytes(), expectStatus: TxOK},
{name: "SUB", opcode: 0x03, bytecode: (&prog{}).push1(3).push1(5).op(0x03).stop().bytes(), expectStatus: TxOK},
{name: "DIV", opcode: 0x04, bytecode: (&prog{}).push1(2).push1(10).op(0x04).stop().bytes(), expectStatus: TxOK},
{name: "SDIV", opcode: 0x05, bytecode: (&prog{}).push1(2).push1(10).op(0x05).stop().bytes(), expectStatus: TxOK},
{name: "MOD", opcode: 0x06, bytecode: (&prog{}).push1(3).push1(10).op(0x06).stop().bytes(), expectStatus: TxOK},
{name: "SMOD", opcode: 0x07, bytecode: (&prog{}).push1(3).push1(10).op(0x07).stop().bytes(), expectStatus: TxOK},
{name: "ADDMOD", opcode: 0x08, bytecode: (&prog{}).push1(7).push1(5).push1(3).op(0x08).stop().bytes(), expectStatus: TxOK},
{name: "MULMOD", opcode: 0x09, bytecode: (&prog{}).push1(7).push1(5).push1(3).op(0x09).stop().bytes(), expectStatus: TxOK},
{name: "EXP", opcode: 0x0A, bytecode: (&prog{}).push1(3).push1(2).op(0x0A).stop().bytes(), expectStatus: TxOK},
{name: "SIGNEXTEND", opcode: 0x0B, bytecode: (&prog{}).push1(0xFF).push1(0).op(0x0B).stop().bytes(), expectStatus: TxOK},
// 0x10..0x1D — comparison + bitwise
{name: "LT", opcode: 0x10, bytecode: (&prog{}).push1(5).push1(3).op(0x10).stop().bytes(), expectStatus: TxOK},
{name: "GT", opcode: 0x11, bytecode: (&prog{}).push1(3).push1(5).op(0x11).stop().bytes(), expectStatus: TxOK},
{name: "SLT", opcode: 0x12, bytecode: (&prog{}).push1(5).push1(3).op(0x12).stop().bytes(), expectStatus: TxOK},
{name: "SGT", opcode: 0x13, bytecode: (&prog{}).push1(3).push1(5).op(0x13).stop().bytes(), expectStatus: TxOK},
{name: "EQ", opcode: 0x14, bytecode: (&prog{}).push1(5).push1(5).op(0x14).stop().bytes(), expectStatus: TxOK},
{name: "ISZERO", opcode: 0x15, bytecode: (&prog{}).push1(0).op(0x15).stop().bytes(), expectStatus: TxOK},
{name: "AND", opcode: 0x16, bytecode: (&prog{}).push1(0xF0).push1(0x0F).op(0x16).stop().bytes(), expectStatus: TxOK},
{name: "OR", opcode: 0x17, bytecode: (&prog{}).push1(0xF0).push1(0x0F).op(0x17).stop().bytes(), expectStatus: TxOK},
{name: "XOR", opcode: 0x18, bytecode: (&prog{}).push1(0xFF).push1(0x0F).op(0x18).stop().bytes(), expectStatus: TxOK},
{name: "NOT", opcode: 0x19, bytecode: (&prog{}).push1(0).op(0x19).stop().bytes(), expectStatus: TxOK},
{name: "BYTE", opcode: 0x1A, bytecode: (&prog{}).push1(0xAB).push1(31).op(0x1A).stop().bytes(), expectStatus: TxOK},
{name: "SHL", opcode: 0x1B, bytecode: (&prog{}).push1(1).push1(2).op(0x1B).stop().bytes(), expectStatus: TxOK},
{name: "SHR", opcode: 0x1C, bytecode: (&prog{}).push1(8).push1(2).op(0x1C).stop().bytes(), expectStatus: TxOK},
{name: "SAR", opcode: 0x1D, bytecode: (&prog{}).push1(8).push1(2).op(0x1D).stop().bytes(), expectStatus: TxOK},
// 0x20 — KECCAK256: hash 32 bytes of zeroed memory at offset 0.
{name: "KECCAK256", opcode: 0x20, bytecode: (&prog{}).push1(32).push1(0).op(0x20).stop().bytes(), expectStatus: TxOK},
// 0x30..0x4A — context / block
{name: "ADDRESS", opcode: 0x30, bytecode: (&prog{}).op(0x30).stop().bytes(), expectStatus: TxOK, needsTo: true},
{name: "BALANCE", opcode: 0x31, bytecode: (&prog{}).op(0x30).op(0x31).stop().bytes(), expectStatus: TxOK, needsTo: true},
{name: "ORIGIN", opcode: 0x32, bytecode: (&prog{}).op(0x32).stop().bytes(), expectStatus: TxOK},
{name: "CALLER", opcode: 0x33, bytecode: (&prog{}).op(0x33).stop().bytes(), expectStatus: TxOK},
{name: "CALLVALUE", opcode: 0x34, bytecode: (&prog{}).op(0x34).stop().bytes(), expectStatus: TxOK},
{name: "CALLDATALOAD", opcode: 0x35, bytecode: (&prog{}).push1(0).op(0x35).stop().bytes(), expectStatus: TxOK, needsCalldata: true},
{name: "CALLDATASIZE", opcode: 0x36, bytecode: (&prog{}).op(0x36).stop().bytes(), expectStatus: TxOK, needsCalldata: true},
{name: "CALLDATACOPY", opcode: 0x37, bytecode: (&prog{}).push1(32).push1(0).push1(0).op(0x37).stop().bytes(), expectStatus: TxOK, needsCalldata: true},
{name: "CODESIZE", opcode: 0x38, bytecode: (&prog{}).op(0x38).stop().bytes(), expectStatus: TxOK},
{name: "CODECOPY", opcode: 0x39, bytecode: (&prog{}).push1(4).push1(0).push1(0).op(0x39).stop().bytes(), expectStatus: TxOK},
{name: "GASPRICE", opcode: 0x3A, bytecode: (&prog{}).op(0x3A).stop().bytes(), expectStatus: TxOK},
{name: "EXTCODESIZE", opcode: 0x3B, bytecode: (&prog{}).op(0x30).op(0x3B).stop().bytes(), expectStatus: TxOK, needsTo: true},
{name: "EXTCODECOPY", opcode: 0x3C, bytecode: (&prog{}).push1(0).push1(0).push1(0).op(0x30).op(0x3C).stop().bytes(), expectStatus: TxOK, needsTo: true},
{name: "RETURNDATASIZE", opcode: 0x3D, bytecode: (&prog{}).op(0x3D).stop().bytes(), expectStatus: TxOK},
{name: "RETURNDATACOPY", opcode: 0x3E, bytecode: (&prog{}).push1(0).push1(0).push1(0).op(0x3E).stop().bytes(), expectStatus: TxOK},
{name: "EXTCODEHASH", opcode: 0x3F, bytecode: (&prog{}).op(0x30).op(0x3F).stop().bytes(), expectStatus: TxOK, needsTo: true},
{name: "BLOCKHASH", opcode: 0x40, bytecode: (&prog{}).push1(0).op(0x40).stop().bytes(), expectStatus: TxOK},
{name: "COINBASE", opcode: 0x41, bytecode: (&prog{}).op(0x41).stop().bytes(), expectStatus: TxOK},
{name: "TIMESTAMP", opcode: 0x42, bytecode: (&prog{}).op(0x42).stop().bytes(), expectStatus: TxOK},
{name: "NUMBER", opcode: 0x43, bytecode: (&prog{}).op(0x43).stop().bytes(), expectStatus: TxOK},
{name: "PREVRANDAO", opcode: 0x44, bytecode: (&prog{}).op(0x44).stop().bytes(), expectStatus: TxOK},
{name: "GASLIMIT", opcode: 0x45, bytecode: (&prog{}).op(0x45).stop().bytes(), expectStatus: TxOK},
{name: "CHAINID", opcode: 0x46, bytecode: (&prog{}).op(0x46).stop().bytes(), expectStatus: TxOK},
{name: "SELFBALANCE", opcode: 0x47, bytecode: (&prog{}).op(0x47).stop().bytes(), expectStatus: TxOK, needsTo: true},
{name: "BASEFEE", opcode: 0x48, bytecode: (&prog{}).op(0x48).stop().bytes(), expectStatus: TxOK},
{name: "BLOBHASH", opcode: 0x49, bytecode: (&prog{}).push1(0).op(0x49).stop().bytes(), expectStatus: TxOK},
{name: "BLOBBASEFEE", opcode: 0x4A, bytecode: (&prog{}).op(0x4A).stop().bytes(), expectStatus: TxOK},
// 0x50..0x5F — stack/memory/storage/flow
{name: "POP", opcode: 0x50, bytecode: (&prog{}).push1(1).op(0x50).stop().bytes(), expectStatus: TxOK},
{name: "MLOAD", opcode: 0x51, bytecode: (&prog{}).push1(0).op(0x51).stop().bytes(), expectStatus: TxOK},
{name: "MSTORE", opcode: 0x52, bytecode: (&prog{}).push1(0xAB).push1(0).op(0x52).stop().bytes(), expectStatus: TxOK},
{name: "MSTORE8", opcode: 0x53, bytecode: (&prog{}).push1(0xAB).push1(0).op(0x53).stop().bytes(), expectStatus: TxOK},
{name: "SLOAD", opcode: 0x54, bytecode: (&prog{}).push1(0).op(0x54).stop().bytes(), expectStatus: TxOK},
{name: "SSTORE", opcode: 0x55, bytecode: (&prog{}).push1(1).push1(0).op(0x55).stop().bytes(), expectStatus: TxOK},
// JUMP: PUSH1 4, JUMP, INVALID, JUMPDEST, STOP — jumps over the INVALID byte.
{name: "JUMP", opcode: 0x56, bytecode: (&prog{}).push1(4).op(0x56).op(0xFE).op(0x5B).stop().bytes(), expectStatus: TxOK},
// JUMPI: cond=1, dest=6, PUSH1 1, PUSH1 6, JUMPI, INVALID, JUMPDEST, STOP.
{name: "JUMPI", opcode: 0x57, bytecode: (&prog{}).push1(1).push1(6).op(0x57).op(0xFE).op(0x5B).stop().bytes(), expectStatus: TxOK},
{name: "PC", opcode: 0x58, bytecode: (&prog{}).op(0x58).stop().bytes(), expectStatus: TxOK},
{name: "MSIZE", opcode: 0x59, bytecode: (&prog{}).op(0x59).stop().bytes(), expectStatus: TxOK},
{name: "GAS", opcode: 0x5A, bytecode: (&prog{}).op(0x5A).stop().bytes(), expectStatus: TxOK},
{name: "JUMPDEST", opcode: 0x5B, bytecode: (&prog{}).op(0x5B).stop().bytes(), expectStatus: TxOK},
{name: "TLOAD", opcode: 0x5C, bytecode: (&prog{}).push1(0).op(0x5C).stop().bytes(), expectStatus: TxOK},
{name: "TSTORE", opcode: 0x5D, bytecode: (&prog{}).push1(1).push1(0).op(0x5D).stop().bytes(), expectStatus: TxOK},
{name: "MCOPY", opcode: 0x5E, bytecode: (&prog{}).push1(32).push1(0).push1(0).op(0x5E).stop().bytes(), expectStatus: TxOK},
{name: "PUSH0", opcode: 0x5F, bytecode: (&prog{}).op(0x5F).stop().bytes(), expectStatus: TxOK},
// 0x60..0x7F — PUSH1..PUSH32 (table built below)
// 0x80..0x8F — DUP1..DUP16 (table built below)
// 0x90..0x9F — SWAP1..SWAP16 (table built below)
// 0xA0..0xA4 — LOG0..LOG4
{name: "LOG0", opcode: 0xA0, bytecode: (&prog{}).push1(0).push1(0).op(0xA0).stop().bytes(), expectStatus: TxOK},
{name: "LOG1", opcode: 0xA1, bytecode: (&prog{}).push1(0xAA).push1(0).push1(0).op(0xA1).stop().bytes(), expectStatus: TxOK},
{name: "LOG2", opcode: 0xA2, bytecode: (&prog{}).push1(0xAA).push1(0xBB).push1(0).push1(0).op(0xA2).stop().bytes(), expectStatus: TxOK},
{name: "LOG3", opcode: 0xA3, bytecode: (&prog{}).push1(0xAA).push1(0xBB).push1(0xCC).push1(0).push1(0).op(0xA3).stop().bytes(), expectStatus: TxOK},
{name: "LOG4", opcode: 0xA4, bytecode: (&prog{}).push1(0xAA).push1(0xBB).push1(0xCC).push1(0xDD).push1(0).push1(0).op(0xA4).stop().bytes(), expectStatus: TxOK},
// 0xF0..0xFF — system
// CALL family is expected to return CallNotSupported on GPU. We assert
// on CPU via expectStatus (CPU may execute or also flag unsupported), and
// skipGPU=true so we do not require gas equivalence.
{name: "CREATE", opcode: 0xF0, bytecode: (&prog{}).push1(0).push1(0).push1(0).op(0xF0).stop().bytes(), expectStatus: TxOK, skipGPU: true},
{name: "CALL", opcode: 0xF1, bytecode: (&prog{}).push1(0).push1(0).push1(0).push1(0).push1(0).op(0x30).push1(0).op(0xF1).stop().bytes(), expectStatus: TxOK, skipGPU: true, needsTo: true},
{name: "CALLCODE", opcode: 0xF2, bytecode: (&prog{}).push1(0).push1(0).push1(0).push1(0).push1(0).op(0x30).push1(0).op(0xF2).stop().bytes(), expectStatus: TxOK, skipGPU: true, needsTo: true},
{name: "RETURN", opcode: 0xF3, bytecode: (&prog{}).push1(0).push1(0).op(0xF3).bytes(), expectStatus: TxReturn},
{name: "DELEGATECALL", opcode: 0xF4, bytecode: (&prog{}).push1(0).push1(0).push1(0).push1(0).op(0x30).push1(0).op(0xF4).stop().bytes(), expectStatus: TxOK, skipGPU: true, needsTo: true},
{name: "CREATE2", opcode: 0xF5, bytecode: (&prog{}).push1(0).push1(0).push1(0).push1(0).op(0xF5).stop().bytes(), expectStatus: TxOK, skipGPU: true},
{name: "STATICCALL", opcode: 0xFA, bytecode: (&prog{}).push1(0).push1(0).push1(0).push1(0).op(0x30).push1(0).op(0xFA).stop().bytes(), expectStatus: TxOK, skipGPU: true, needsTo: true},
{name: "REVERT", opcode: 0xFD, bytecode: (&prog{}).push1(0).push1(0).op(0xFD).bytes(), expectStatus: TxRevert},
// INVALID intentionally fails — both backends should flag it.
{name: "INVALID", opcode: 0xFE, bytecode: []byte{0xFE}, expectStatus: TxError},
{name: "SELFDESTRUCT", opcode: 0xFF, bytecode: (&prog{}).op(0x30).op(0xFF).bytes(), expectStatus: TxOK, skipGPU: true, needsTo: true},
}
// init expands the tables for PUSH1..PUSH32, DUP1..DUP16, SWAP1..SWAP16.
// Each is generated programmatically — there's nothing interesting to
// hand-write.
func init() {
// PUSH1..PUSH32: PUSH<n> with n bytes of 0xAA, then STOP.
for n := 1; n <= 32; n++ {
op := byte(0x5F + n)
operand := make([]byte, n)
for i := range operand {
operand[i] = 0xAA
}
bc := append([]byte{op}, operand...)
bc = append(bc, 0x00) // STOP
allOpcodeTests = append(allOpcodeTests, opcodeTest{
name: fmt.Sprintf("PUSH%d", n),
opcode: op,
bytecode: bc,
expectStatus: TxOK,
})
}
// DUP1..DUP16: push N+1 zeros then DUP<N>, STOP.
for n := 1; n <= 16; n++ {
op := byte(0x7F + n)
p := &prog{}
for i := 0; i <= n; i++ {
p.push1(byte(i + 1))
}
p.op(op).stop()
allOpcodeTests = append(allOpcodeTests, opcodeTest{
name: fmt.Sprintf("DUP%d", n),
opcode: op,
bytecode: p.bytes(),
expectStatus: TxOK,
})
}
// SWAP1..SWAP16: push N+1 distinct vals then SWAP<N>, STOP.
for n := 1; n <= 16; n++ {
op := byte(0x8F + n)
p := &prog{}
for i := 0; i <= n; i++ {
p.push1(byte(i + 1))
}
p.op(op).stop()
allOpcodeTests = append(allOpcodeTests, opcodeTest{
name: fmt.Sprintf("SWAP%d", n),
opcode: op,
bytecode: p.bytes(),
expectStatus: TxOK,
})
}
}
// ----------------------------------------------------------------------------
// Coverage report (shared across subtests, summarised by TestOpcodeCoverage_Summary)
// ----------------------------------------------------------------------------
type opcodeOutcome struct {
name string
opcode byte
cpuStatus TxStatus
gpuStatus TxStatus
cpuGas uint64
gpuGas uint64
gasMatch bool
gpuRan bool
gpuMatchedCPU bool
skippedCallFam bool
notImplemented bool
executeErr string
}
var (
coverageMu sync.Mutex
coverageResults = map[string]opcodeOutcome{}
)
func recordOutcome(o opcodeOutcome) {
coverageMu.Lock()
defer coverageMu.Unlock()
coverageResults[o.name] = o
}
// ----------------------------------------------------------------------------
// Test helpers
// ----------------------------------------------------------------------------
// runTx builds a Transaction for the given opcode test and runs it through
// `backend`. It always calls ExecuteBlock so we get per-tx status.
func runOpcodeTx(backend Backend, ot opcodeTest) (*BlockResult, error) {
var from [20]byte
from[19] = 0x42
tx := Transaction{
From: from,
GasLimit: 1_000_000,
GasPrice: 1,
Nonce: 0,
Code: ot.bytecode,
}
if ot.needsTo {
var to [20]byte
to[19] = 0xCA
tx.To = to
tx.HasTo = true
}
if ot.needsCalldata {
tx.Data = []byte{
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10,
0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20,
}
}
return ExecuteBlock(backend, 1, []Transaction{tx}, nil, nil)
}
// ----------------------------------------------------------------------------
// The big test: run every opcode through CPU + GPU and compare.
// ----------------------------------------------------------------------------
func TestOpcodeCoverage_GPU_vs_CPU(t *testing.T) {
available := AvailableBackends()
if !contains(available, CPUSequential) {
t.Skip("CPUSequential backend not available")
}
gpuAvailable := contains(available, GPUMetal)
if !gpuAvailable {
t.Logf("GPU Metal backend NOT available — running CPU-only coverage")
}
for _, ot := range allOpcodeTests {
ot := ot // capture
t.Run(ot.name, func(t *testing.T) {
outcome := opcodeOutcome{name: ot.name, opcode: ot.opcode}
defer func() { recordOutcome(outcome) }()
// 1) CPU reference run.
cpuRes, err := runOpcodeTx(CPUSequential, ot)
if err != nil {
outcome.executeErr = "cpu: " + err.Error()
t.Fatalf("CPU execute failed for %s (0x%02X): %v", ot.name, ot.opcode, err)
}
if len(cpuRes.Status) != 1 || len(cpuRes.GasUsed) != 1 {
t.Fatalf("CPU returned malformed result for %s: status=%v gas=%v", ot.name, cpuRes.Status, cpuRes.GasUsed)
}
outcome.cpuStatus = cpuRes.Status[0]
outcome.cpuGas = cpuRes.GasUsed[0]
// 2) GPU comparison (if available and not in skipGPU set).
if !gpuAvailable {
return
}
if ot.skipGPU {
outcome.skippedCallFam = true
t.Logf("skip GPU for %s: CALL family / contract creation (CPU status=%s gas=%d)",
ot.name, outcome.cpuStatus, outcome.cpuGas)
return
}
gpuRes, err := runOpcodeTx(GPUMetal, ot)
if err != nil {
outcome.executeErr = "gpu: " + err.Error()
// Coverage measurement: log but do not fail the whole suite.
t.Logf("OPCODE NOT IMPLEMENTED ON GPU (execute error): %s (0x%02X): %v",
ot.name, ot.opcode, err)
return
}
outcome.gpuRan = true
if len(gpuRes.Status) != 1 || len(gpuRes.GasUsed) != 1 {
t.Fatalf("GPU returned malformed result for %s: status=%v gas=%v", ot.name, gpuRes.Status, gpuRes.GasUsed)
}
outcome.gpuStatus = gpuRes.Status[0]
outcome.gpuGas = gpuRes.GasUsed[0]
// If GPU reports CallNotSupported but the opcode isn't in our
// skip list, treat that as "not implemented yet" data.
if outcome.gpuStatus == TxCallNotSupported {
outcome.notImplemented = true
t.Logf("OPCODE NOT IMPLEMENTED ON GPU (CallNotSupported): %s (0x%02X)", ot.name, ot.opcode)
return
}
if outcome.gpuStatus == TxError && outcome.cpuStatus != TxError {
outcome.notImplemented = true
t.Logf("OPCODE NOT IMPLEMENTED ON GPU (TxError, cpu=%s): %s (0x%02X)",
outcome.cpuStatus, ot.name, ot.opcode)
return
}
// 3) Compare CPU vs GPU.
if outcome.cpuStatus != outcome.gpuStatus {
t.Errorf("%s (0x%02X): status mismatch cpu=%s gpu=%s",
ot.name, ot.opcode, outcome.cpuStatus, outcome.gpuStatus)
}
if outcome.cpuGas == outcome.gpuGas {
outcome.gasMatch = true
outcome.gpuMatchedCPU = outcome.cpuStatus == outcome.gpuStatus
} else {
t.Logf("%s (0x%02X): gas differs cpu=%d gpu=%d (status cpu=%s gpu=%s)",
ot.name, ot.opcode, outcome.cpuGas, outcome.gpuGas,
outcome.cpuStatus, outcome.gpuStatus)
}
})
}
}
// ----------------------------------------------------------------------------
// Coverage summary report
// ----------------------------------------------------------------------------
// TestOpcodeCoverage_Summary depends on TestOpcodeCoverage_GPU_vs_CPU running
// first (Go test order is deterministic by source position, this file's main
// test is declared above). It prints a human-readable coverage report.
func TestOpcodeCoverage_Summary(t *testing.T) {
coverageMu.Lock()
defer coverageMu.Unlock()
if len(coverageResults) == 0 {
t.Skip("no opcode results recorded — run TestOpcodeCoverage_GPU_vs_CPU first")
}
type bucket struct {
ran, gasMatch, skippedCall, notImpl, errored int
failedNames []string
}
var b bucket
for _, o := range coverageResults {
switch {
case o.skippedCallFam:
b.skippedCall++
case o.notImplemented:
b.notImpl++
b.failedNames = append(b.failedNames, fmt.Sprintf("%s(0x%02X)", o.name, o.opcode))
case o.executeErr != "":
b.errored++
b.failedNames = append(b.failedNames, fmt.Sprintf("%s(0x%02X)", o.name, o.opcode))
case o.gpuRan && o.gasMatch:
b.ran++
b.gasMatch++
case o.gpuRan:
b.ran++
}
}
sort.Strings(b.failedNames)
total := len(coverageResults)
t.Logf("=== EVM Opcode GPU Coverage Report ===")
t.Logf("Total opcodes tested: %d", total)
t.Logf("GPU executed: %d", b.ran)
t.Logf("Gas-match w/ CPU: %d", b.gasMatch)
t.Logf("Skipped (CALL/CREATE): %d", b.skippedCall)
t.Logf("Not implemented on GPU: %d", b.notImpl)
t.Logf("GPU execute errors: %d", b.errored)
if len(b.failedNames) > 0 {
t.Logf("Failing opcodes:")
for _, n := range b.failedNames {
t.Logf(" - %s", n)
}
}
}
// TestOpcodeCoverage_TableComplete asserts the static table covers every
// opcode in the canonical set (sanity check on the test author).
func TestOpcodeCoverage_TableComplete(t *testing.T) {
got := map[byte]string{}
for _, ot := range allOpcodeTests {
if other, ok := got[ot.opcode]; ok {
t.Errorf("duplicate opcode 0x%02X: %q and %q", ot.opcode, other, ot.name)
continue
}
got[ot.opcode] = ot.name
}
// Canonical list of opcodes the EVM spec defines (Cancun + EIP-4844 + EIP-1153).
want := []byte{
// 0x00..0x0B
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B,
// 0x10..0x1D
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D,
// 0x20
0x20,
// 0x30..0x3F
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
// 0x40..0x4A
0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A,
// 0x50..0x5F
0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F,
// 0xA0..0xA4
0xA0, 0xA1, 0xA2, 0xA3, 0xA4,
// 0xF0..0xF5, 0xFA, 0xFD..0xFF
0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xFA, 0xFD, 0xFE, 0xFF,
}
// PUSH1..PUSH32 (0x60..0x7F)
for op := byte(0x60); op <= 0x7F; op++ {
want = append(want, op)
}
// DUP1..DUP16 (0x80..0x8F)
for op := byte(0x80); op <= 0x8F; op++ {
want = append(want, op)
}
// SWAP1..SWAP16 (0x90..0x9F)
for op := byte(0x90); op <= 0x9F; op++ {
want = append(want, op)
}
missing := []byte{}
for _, op := range want {
if _, ok := got[op]; !ok {
missing = append(missing, op)
}
}
if len(missing) > 0 {
var s []string
for _, op := range missing {
s = append(s, fmt.Sprintf("0x%02X", op))
}
t.Errorf("table is missing %d opcodes: %v", len(missing), s)
}
t.Logf("table covers %d / %d opcodes", len(got), len(want))
}
evm/cevm/parallel/parallel.go
+2 -2
View File
@@ -46,7 +46,7 @@
//
// # Declining
//
// cevm's Go entry (go_bridge.h, ABI 6) answers ok=0 for any block it does not
// cevm's Go entry (go_bridge.h, ABI 7) answers ok=0 for any block it does not
// run: a batch with code, and any refusal on balance, nonce, price, block gas
// limit, revision or hashes. Such a block, and one whose values do not fit its
// 64-bit wire, is the caller's to run. Every one of them leaves through
@@ -163,7 +163,7 @@ func (e *Executor) run(
statedb *state.StateDB,
) ([]*types.Receipt, error) {
// cevm's Go entry runs nothing on a CPU lane: it passes no host, and a
// CPU lane runs no plain transfer without one (go_bridge.h, ABI 6). A
// CPU lane runs no plain transfer without one (go_bridge.h, ABI 7). A
// library that answers there anyway answers something else — a gas
// estimate — so it is not asked.
if e.CevmBackend != cevm.GPUMetal && e.CevmBackend != cevm.GPUCUDA {
evm/cevm/parallel/parallel_test.go
+6 -3
View File
@@ -18,7 +18,7 @@ import (
"github.com/luxfi/geth/core/types"
)
// These run against the linked library and hold it to go_bridge.h (ABI 6).
// These run against the linked library and hold it to go_bridge.h (ABI 7).
// A batch that carries code is declined on every backend the library offers:
// gpu_execute_block passes no host, so it would run the code as a message on
@@ -49,7 +49,9 @@ func TestABatchWithCodeIsDeclinedOnEveryBackend(t *testing.T) {
// A block of plain transfers from funded senders, end to end through the
// executor: a GPU lane runs it and receipts every transfer at 21000 gas; a
// CPU lane, which runs nothing through the Go entry, declines it to the Go
// EVM. Neither is an error.
// EVM. Neither is an error. A GPU lane is listed when the library was built
// with it, whether or not this host has the device, and one without it
// declines too: that lane is skipped.
func TestAPlainTransferBlockIsReceiptedOrDeclined(t *testing.T) {
const n = 8
sdb := newState(t)
@@ -78,7 +80,8 @@ func TestAPlainTransferBlockIsReceiptedOrDeclined(t *testing.T) {
return
}
if receipts == nil {
t.Fatalf("GPU lane %s declined a block of funded plain transfers", cevm.BackendName(b))
t.Skipf("GPU lane %s declined a block of funded plain transfers: no device on this host",
cevm.BackendName(b))
}
if len(receipts) != n {
t.Fatalf("%d receipts for %d transactions", len(receipts), n)