randomx

README

RandomX (Golang Implementation)

Fork from git.dero.io/DERO_Foundation/RandomX. Also related, their Analysis of RandomX writeup.

Original code failed RandomX testcases and was implemented using big.Float.

This package implements RandomX without CGO, using only Golang code, pure float64 ops and two small assembly sections to implement CFROUND modes, with optional soft float implementation.

All test cases pass properly.

Uses minimal Go assembly due to having to set rounding mode natively. Native hard float can be added with supporting rounding mode under asm.

JIT is supported on a few platforms but can be hard-disabled via the disable_jit build flag, or at runtime.

A pure Golang implementation can be used on platforms without hard float support or via the purego build flag manually.

Platform	Supported	Hard Float	SuperScalar JIT	Notes
386	✅	✅	❌
amd64	✅	✅	✅*	JIT only on Unix
arm	✅*	❌	❌
arm64	✅	✅	❌
mips	✅*	❌	❌
mips64	✅*	❌	❌
riscv64	✅*	❌	❌
wasm	✅*	❌	❌

* these platforms only support software floating point / purego and will not be performant.

Documentation

Index

• Constants
• Variables
• func CreateSuperScalarInstruction(sins *SuperScalarInstruction, gen *Blake2Generator, instruction_len int, ...)
• func EMask(entropy uint64) uint64
• func MaskRegisterExponentMantissa(f float64, mode uint64) float64
• func ScaleNegate(f float64) float64
• func ScheduleMop(mop *MacroOP, portbusy [][]int, cycle int, depcycle int, commit bool) int
• func ScheduleUop(uop ExecutionPort, portbusy [][]int, cycle int, commit bool) int
• func SetRoundingMode(f *RegisterFile, mode uint8)
• func SmallPositiveFloatBits(entropy uint64) float64
• func StaticExponent(entropy uint64) uint64
• func Xor(a, b float64) float64
• type Blake2Generator
  • func Init_Blake2Generator(key []byte, nonce uint32) *Blake2Generator
  • func (b *Blake2Generator) GetByte() byte
  • func (b *Blake2Generator) GetUint32() uint32
• type ByteCode
  • func CompileProgramToByteCode(prog []byte) (bc ByteCode)
  • func (c *ByteCode) Execute(f *RegisterFile, pad *ScratchPad, eMask [2]uint64)
• type ByteCodeInstruction
• type ByteCodeInstructionOp
• type DecoderType
  • func FetchNextDecoder(ins *Instruction, cycle int, mulcount int, gen *Blake2Generator) DecoderType
  • func (d DecoderType) GetSize() int
  • func (d DecoderType) String() string
• type ExecutionPort
• type Instruction
  • func (ins *Instruction) GetLatency() int
  • func (ins *Instruction) GetSize() int
  • func (ins *Instruction) GetUOPCount() int
  • func (ins *Instruction) IsSimple() bool
• type MacroOP
  • func (m *MacroOP) GetLatency() int
  • func (m *MacroOP) GetSize() int
  • func (m *MacroOP) GetUOP1() ExecutionPort
  • func (m *MacroOP) GetUOP2() ExecutionPort
  • func (m *MacroOP) IsDependent() bool
  • func (m *MacroOP) IsEliminated() bool
  • func (m *MacroOP) IsSimple() bool
• type MemoryBlock
  • func (m *MemoryBlock) GetLine(addr uint64) *RegisterLine
• type MemoryRegisters
• type ProgramFunc
  • func (f ProgramFunc) Close() error
  • func (f ProgramFunc) Execute(v uintptr)
• type REG
• type Randomx_Cache
  • func Randomx_alloc_cache(flags uint64) *Randomx_Cache
  • func (cache *Randomx_Cache) Close() error
  • func (cache *Randomx_Cache) GetMixBlock(addr uint64) *RegisterLine
  • func (cache *Randomx_Cache) HasJIT() bool
  • func (cache *Randomx_Cache) Init(key []byte)
  • func (cache *Randomx_Cache) InitDatasetItem(rl *RegisterLine, itemNumber uint64)
  • func (cache *Randomx_Cache) InitDatasetItemJIT(rl *RegisterLine, itemNumber uint64)
  • func (cache *Randomx_Cache) VM_Initialize() *VM
• type Randomx_Dataset
• type Randomx_DatasetLight
  • func (d *Randomx_DatasetLight) InitDataset(startItem, endItem uint64)
  • func (d *Randomx_DatasetLight) PrefetchDataset(address uint64)
  • func (d *Randomx_DatasetLight) ReadDataset(address uint64, r, cache *RegisterLine)
• type Register
• type RegisterFile
  • func (rf *RegisterFile) Memory() *[RegisterFileSize]byte
• type RegisterLine
• type ScratchPad
  • func (pad *ScratchPad) Init(seed *[64]byte)
  • func (pad *ScratchPad) Load32(addr uint32) uint32
  • func (pad *ScratchPad) Load32F(addr uint32) (lo, hi float64)
  • func (pad *ScratchPad) Load32FA(addr uint32) [2]float64
  • func (pad *ScratchPad) Load64(addr uint32) uint64
  • func (pad *ScratchPad) Store64(addr uint32, val uint64)
• type SuperScalarInstruction
  • func (sins *SuperScalarInstruction) FixSrcReg()
  • func (sins *SuperScalarInstruction) Reset()
  • func (sins *SuperScalarInstruction) SelectDestination(preAllocatedAvailableRegisters []int, cycle int, allowChainedMul bool, ...) bool
  • func (sins *SuperScalarInstruction) SelectSource(preAllocatedAvailableRegisters []int, cycle int, Registers []Register, ...) bool
• type SuperScalarProgram
  • func Build_SuperScalar_Program(gen *Blake2Generator) SuperScalarProgram
  • func (p SuperScalarProgram) AddressRegister() int
  • func (p SuperScalarProgram) Program() []SuperScalarInstruction
• type VM
  • func (vm *VM) CalculateHash(input []byte, output *[32]byte)
  • func (vm *VM) InitScratchpad(seed *[64]byte)
  • func (vm *VM) Run(inputHash [64]byte, roundingMode uint8) (reg RegisterFile)
  • func (vm *VM) RunLoops(tempHash [64]byte) RegisterFile
• type VM_Instruction
  • func (ins VM_Instruction) Dst() byte
  • func (ins VM_Instruction) IMM() uint32
  • func (ins VM_Instruction) IMM64() uint64
  • func (ins VM_Instruction) Mod() byte
  • func (ins VM_Instruction) Opcode() byte
  • func (ins VM_Instruction) Src() byte

Constants

const (
	Null ExecutionPort = iota
	P0                 = 1
	P1                 = 2
	P5                 = 4
	P01                = P0 | P1
	P05                = P0 | P5
	P015               = P0 | P1 | P5
)

const (
	S_INVALID = 0xFF

	S_NOP      = 0xFE
	S_ISUB_R   = 0
	S_IXOR_R   = 1
	S_IADD_RS  = 2
	S_IMUL_R   = 3
	S_IROR_C   = 4
	S_IADD_C7  = 5
	S_IXOR_C7  = 6
	S_IADD_C8  = 7
	S_IXOR_C8  = 8
	S_IADD_C9  = 9
	S_IXOR_C9  = 10
	S_IMULH_R  = 11
	S_ISMULH_R = 12
	S_IMUL_RCP = 13
)

const (
	VM_NOP = ByteCodeInstructionOp(iota)
	VM_IADD_RS
	VM_IADD_M
	VM_IADD_MZ
	VM_ISUB_R
	VM_ISUB_I
	VM_ISUB_M
	VM_ISUB_MZ
	VM_IMUL_R
	VM_IMUL_I
	VM_IMUL_M
	VM_IMUL_MZ
	VM_IMULH_R
	VM_IMULH_M
	VM_IMULH_MZ
	VM_ISMULH_R
	VM_ISMULH_M
	VM_ISMULH_MZ
	VM_INEG_R
	VM_IXOR_R
	VM_IXOR_I
	VM_IXOR_M
	VM_IXOR_MZ
	VM_IROR_R
	VM_IROR_I
	VM_IROL_R
	VM_IROL_I
	VM_ISWAP_R
	VM_FSWAP_RF
	VM_FSWAP_RE
	VM_FADD_R
	VM_FADD_M
	VM_FSUB_R
	VM_FSUB_M
	VM_FSCAL_R
	VM_FMUL_R
	VM_FDIV_M
	VM_FSQRT_R
	VM_CFROUND
	VM_CBRANCH
	VM_ISTORE
)

const ArgonSaltSize uint32 = 8 //sizeof("" RANDOMX_ARGON_SALT) - 1

const CONDITIONMASK = (1 << RANDOMX_JUMP_BITS) - 1

const CONDITIONOFFSET = RANDOMX_JUMP_OFFSET

const CYCLE_MAP_SIZE int = RANDOMX_SUPERSCALAR_LATENCY + 4

const CacheLineAlignMask = (RANDOMX_DATASET_BASE_SIZE - 1) & (^(CacheLineSize - 1))

const CacheLineSize uint64 = RANDOMX_DATASET_ITEM_SIZE

const CacheSize uint64 = RANDOMX_ARGON_MEMORY * uint64(argon2.BlockSize)

const CodeAlign = 4096 //align code size to a multiple of 4 KiB

const DATASETEXTRAITEMS = RANDOMX_DATASET_EXTRA_SIZE / RANDOMX_DATASET_ITEM_SIZE

const HIGH = 1

const LOOK_FORWARD_CYCLES int = 4

const LOW = 0

const MAX_THROWAWAY_COUNT int = 256

const Mask = CacheSize/CacheLineSize - 1

const MaxRandomXInstrCodeSize = 32 //FDIV_M requires up to 32 bytes of x86 code

const MaxSuperscalarInstrSize = 14 //IMUL_RCP requires 14 bytes of x86 code

const RANDOMX_ARGON_ITERATIONS = 3

Number of Argon2d iterations for Cache initialization.

const RANDOMX_ARGON_LANES = 1

Number of parallel lanes for Cache initialization.

const RANDOMX_ARGON_MEMORY = 262144

see reference configuration.h Cache size in KiB. Must be a power of 2.

const RANDOMX_ARGON_SALT = "RandomX\x03"

Argon2d salt

const RANDOMX_CACHE_ACCESSES = 8

Number of random Cache accesses per Dataset item. Minimum is 2.

const RANDOMX_DATASET_BASE_SIZE = 2147483648

Dataset base size in bytes. Must be a power of 2.

const RANDOMX_DATASET_EXTRA_SIZE = 33554368

Dataset extra size. Must be divisible by 64.

const RANDOMX_DATASET_ITEM_SIZE uint64 = 64

const RANDOMX_FLAG_DEFAULT = uint64(0)

const RANDOMX_FLAG_JIT = uint64(1 << iota)

const RANDOMX_JUMP_BITS = 8

Jump condition mask size in bits.

const RANDOMX_JUMP_OFFSET = 8

Jump condition mask offset in bits. The sum of RANDOMX_JUMP_BITS and RANDOMX_JUMP_OFFSET must not exceed 16.

const RANDOMX_PROGRAM_COUNT = 8

Number of chained VM executions per hash.

const RANDOMX_PROGRAM_ITERATIONS = 2048

Number of iterations during VM execution.

const RANDOMX_PROGRAM_SIZE = 256

Number of instructions in a RandomX program. Must be divisible by 8.

const RANDOMX_SCRATCHPAD_L1 = 16384

Scratchpad L1 size in bytes. Must be a power of two (minimum 64) and less than or equal to RANDOMX_SCRATCHPAD_L2.

const RANDOMX_SCRATCHPAD_L2 = 262144

Scratchpad L2 size in bytes. Must be a power of two and less than or equal to RANDOMX_SCRATCHPAD_L3.

const RANDOMX_SCRATCHPAD_L3 = 2097152

Scratchpad L3 size in bytes. Must be a power of 2.

const RANDOMX_SUPERSCALAR_LATENCY = 170

Target latency for SuperscalarHash (in cycles of the reference CPU).

const RegisterFileSize = RegistersCount*8 + RegistersCountFloat*2*8*3

const RegisterNeedsDisplacement = 5

const RegisterNeedsSib = 4

const RegistersCount = 8

const RegistersCountFloat = 4

const ReserveCodeSize = CodeAlign //function prologue/epilogue + reserve

const STOREL3CONDITION = 14

const ScratchpadL1 = RANDOMX_SCRATCHPAD_L1 / 8

const ScratchpadL1Mask = (ScratchpadL1 - 1) * 8

const ScratchpadL1Mask16 = (ScratchpadL1/2 - 1) * 16

const ScratchpadL2 = RANDOMX_SCRATCHPAD_L2 / 8

const ScratchpadL2Mask = (ScratchpadL2 - 1) * 8

const ScratchpadL2Mask16 = (ScratchpadL2/2 - 1) * 16

const ScratchpadL3 = RANDOMX_SCRATCHPAD_L3 / 8

const ScratchpadL3Mask = (ScratchpadL3 - 1) * 8

const ScratchpadL3Mask64 = (ScratchpadL3/8 - 1) * 64

const ScratchpadSize uint32 = RANDOMX_SCRATCHPAD_L3

const SuperscalarMaxSize = 3*RANDOMX_SUPERSCALAR_LATENCY + 2

const SuperscalarProgramHeader = 128 //overhead per superscalar program

Variables

var ADD_EBX_I = []byte{0x81, 0xc3}

var ADD_RAX_RCX = []byte{0x48, 0x01, 0xC8}

var ADD_RDX_R = []byte{0x4c, 0x01}

var ADD_R_RAX = []byte{0x4C, 0x03}

var AND_EAX_I byte = 0x25

var AND_ECX_I = []byte{0x81, 0xe1}

var AND_OR_MOV_LDMXCSR = []byte{0x25, 0x00, 0x60, 0x00, 0x00, 0x0D, 0xC0, 0x9F, 0x00, 0x00, 0x50, 0x0F, 0xAE, 0x14, 0x24, 0x58}

var CALL = 0xe8

var CodeSize = uint32(RandomXCodeSize + SuperscalarSize)

var Decoder_To_Instruction_Length = [][]int{
	buffer0,
	buffer1,
	buffer2,
	buffer3,
	buffer4,
	buffer5,
}

var IADD_C7 = Instruction{Opcode: S_IADD_C7, UOP: M_Add_ri, SrcOP: -1}

var IADD_C8 = Instruction{Opcode: S_IADD_C8, UOP: M_Add_ri, SrcOP: -1}

var IADD_C9 = Instruction{Opcode: S_IADD_C9, UOP: M_Add_ri, SrcOP: -1}

var IADD_RS = Instruction{Opcode: S_IADD_RS, UOP: M_Lea_SIB, SrcOP: 0}

var IMULH_R = Instruction{Opcode: S_IMULH_R, UOP_Array: []MacroOP{M_Mov_rr, M_Mul_r, M_Mov_rr}, ResultOP: 1, DstOP: 0, SrcOP: 1}

var IMUL_R = Instruction{Opcode: S_IMUL_R, UOP: M_Imul_rr, SrcOP: 0}

var IMUL_RCP = Instruction{Opcode: S_IMUL_RCP, UOP_Array: []MacroOP{M_Mov_ri64, M_Imul_r_dependent}, ResultOP: 1, DstOP: 1, SrcOP: -1}

var IROR_C = Instruction{Opcode: S_IROR_C, UOP: M_Ror_ri, SrcOP: -1}

var ISMULH_R = Instruction{Opcode: S_ISMULH_R, UOP_Array: []MacroOP{M_Mov_rr, M_Imul_r, M_Mov_rr}, ResultOP: 1, DstOP: 0, SrcOP: 1}

var ISUB_R = Instruction{Opcode: S_ISUB_R, UOP: M_Sub_rr, SrcOP: 0}

SrcOP/DstOp are used to selected registers

var IXOR_C7 = Instruction{Opcode: S_IXOR_C7, UOP: M_Xor_ri, SrcOP: -1}

var IXOR_C8 = Instruction{Opcode: S_IXOR_C8, UOP: M_Xor_ri, SrcOP: -1}

var IXOR_C9 = Instruction{Opcode: S_IXOR_C9, UOP: M_Xor_ri, SrcOP: -1}

var IXOR_R = Instruction{Opcode: S_IXOR_R, UOP: M_Xor_rr, SrcOP: 0}

var JMP = 0xe9

var JNZ = []byte{0x0f, 0x85}

var JZ = []byte{0x0f, 0x84}

var JZ_SHORT = 0x74

var LEA_32 = []byte{0x41, 0x8d}

var MOVAPD = []byte{0x66, 0x0f, 0x29}

var MOVNTI = []byte{0x4c, 0x0f, 0xc3}

var MOV_EAX_I byte = 0xb8

var MOV_RAX_I = []byte{0x48, 0xb8}

var MOV_RCX_I = []byte{0x48, 0xb9}

var MOV_RCX_RAX_SAR_RCX_63 = []byte{0x48, 0x89, 0xc1, 0x48, 0xc1, 0xf9, 0x3f}

var MUL_RCX = []byte{0x48, 0xf7, 0xe1}

var M_Add_ri = MacroOP{"add r,i", 7, 1, P015, Null, false}

Size: 7 bytes (can be optionally padded with nop to 8 or 9 bytes)

var M_Add_rr = MacroOP{"add r,r", 3, 1, P015, Null, false}

3 byte instructions

var M_Imul_r = MacroOP{"imul r", 3, 4, P1, P5, false}

var M_Imul_r_dependent = MacroOP{"imul r", 3, 3, P1, Null, true} // this is the dependent version where current instruction depends on previous instruction

latency is 1 lower

var M_Imul_rr = MacroOP{"imul r,r", 4, 3, P1, Null, false}

var M_Lea_SIB = MacroOP{"lea r,r+r*s", 4, 1, P01, Null, false}

Size: 4 bytes

var M_Mov_ri64 = MacroOP{"mov rax,i64", 10, 1, P015, Null, false}

Size: 10 bytes

var M_Mov_rr = MacroOP{"mov r,r", 3, 0, Null, Null, false}

var M_Mul_r = MacroOP{"mul r", 3, 4, P1, P5, false}

var M_Ror_ri = MacroOP{"ror r,i", 4, 1, P05, Null, false}

var M_Sub_rr = MacroOP{"sub r,r", 3, 1, P015, Null, false}

var M_Xor_ri = MacroOP{"xor r,i", 7, 1, P015, Null, false}

var M_Xor_rr = MacroOP{"xor r,r", 3, 1, P015, Null, false}

var NEG_RAX = []byte{0x48, 0xF7, 0xD8}

var NOP1 = []byte{0x90}

var NOP2 = []byte{0x66, 0x90}

var NOP3 = []byte{0x66, 0x66, 0x90}

var NOP4 = []byte{0x0F, 0x1F, 0x40, 0x00}

var NOP5 = []byte{0x0F, 0x1F, 0x44, 0x00, 0x00}

var NOP6 = []byte{0x66, 0x0F, 0x1F, 0x44, 0x00, 0x00}

var NOP7 = []byte{0x0F, 0x1F, 0x80, 0x00, 0x00, 0x00, 0x00}

var NOP8 = []byte{0x0F, 0x1F, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00}

var PADD_OPCODES = []byte{0xfc, 0xfd, 0xfe, 0xd4}

var RAX_ADD_SBB_1 = []byte{0x48, 0x83, 0xC0, 0x01, 0x48, 0x83, 0xD8, 0x00}

var RET byte = 0xc3

var REX_81 = []byte{0x49, 0x81}

var REX_ADDPD = []byte{0x66, 0x41, 0x0f, 0x58}

var REX_ADD_I = []byte{0x49, 0x81}

var REX_ADD_RM = []byte{0x4c, 0x03}

var REX_ADD_RR = []byte{0x4d, 0x03}

var REX_ANDPS_XMM12 = []byte{0x45, 0x0F, 0x54, 0xE5, 0x45, 0x0F, 0x56, 0xE6}

var REX_CMP_M32I = []byte{0x81, 0x3c, 0x06}

var REX_CMP_R32I = []byte{0x41, 0x81}

var REX_CVTDQ2PD_XMM12 = []byte{0xf3, 0x44, 0x0f, 0xe6, 0x24, 0x06}

var REX_DIVPD = []byte{0x66, 0x41, 0x0f, 0x5e}

var REX_IMUL_MEM = []byte{0x48, 0xf7, 0x2c, 0x0e}

var REX_IMUL_RM = []byte{0x4c, 0x0f, 0xaf}

var REX_IMUL_RR = []byte{0x4d, 0x0f, 0xaf}

var REX_IMUL_RRI = []byte{0x4d, 0x69}

var REX_LEA = []byte{0x4f, 0x8d}

var REX_MAXPD = []byte{0x66, 0x41, 0x0f, 0x5f}

var REX_MOV_MR = []byte{0x4c, 0x89}

var REX_MOV_R64R = []byte{0x4c, 0x8b}

var REX_MOV_RR = []byte{0x41, 0x8b}

var REX_MOV_RR64 = []byte{0x49, 0x8b}

var REX_MULPD = []byte{0x66, 0x41, 0x0f, 0x59}

var REX_MUL_M = []byte{0x48, 0xf7}

var REX_MUL_MEM = []byte{0x48, 0xf7, 0x24, 0x0e}

var REX_MUL_R = []byte{0x49, 0xf7}

var REX_NEG = []byte{0x49, 0xF7}

var REX_PADD = []byte{0x66, 0x44, 0x0f}

var REX_ROT_CL = []byte{0x49, 0xd3}

var REX_ROT_I8 = []byte{0x49, 0xc1}

var REX_SH = []byte{0x49, 0xc1}

var REX_SHR_RAX = []byte{0x48, 0xc1, 0xe8}

var REX_SHR_RDX = []byte{0x48, 0xc1, 0xea}

var REX_SUBPD = []byte{0x66, 0x41, 0x0f, 0x5c}

var REX_SUB_RM = []byte{0x4c, 0x2b}

var REX_SUB_RR = []byte{0x4d, 0x2b}

var REX_TEST = []byte{0x49, 0xF7}

var REX_XCHG = []byte{0x4d, 0x87}

var REX_XORPS = []byte{0x41, 0x0f, 0x57}

var REX_XOR_EAX = []byte{0x41, 0x33}

var REX_XOR_RAX_R64 = []byte{0x49, 0x33}

var REX_XOR_RI = []byte{0x49, 0x81}

var REX_XOR_RM = []byte{0x4c, 0x33}

var REX_XOR_RR = []byte{0x4D, 0x33}

var ROL_RAX = []byte{0x48, 0xc1, 0xc0}

var RandomXCodeSize = alignSize[uint64](ReserveCodeSize+MaxRandomXInstrCodeSize*RANDOMX_PROGRAM_SIZE, CodeAlign)

var SAR_RAX_I8 = []byte{0x48, 0xC1, 0xF8}

var SAR_RDX_I8 = []byte{0x48, 0xC1, 0xFA}

var SETS_AL_ADD_RDX_RAX = []byte{0x0F, 0x98, 0xC0, 0x48, 0x03, 0xD0}

var SHUFPD = []byte{0x66, 0x0f, 0xc6}

var SQRTPD = []byte{0x66, 0x0f, 0x51}

var SUB_EBX = []byte{0x83, 0xEB, 0x01}

var SUB_RDX_R = []byte{0x4c, 0x29}

var SuperscalarSize = alignSize[uint64](ReserveCodeSize+(SuperscalarProgramHeader+MaxSuperscalarInstrSize*SuperscalarMaxSize)*RANDOMX_CACHE_ACCESSES, CodeAlign)

var TEST_RDX_RDX = []byte{0x48, 0x85, 0xD2}

var XOR_EAX_EAX = []byte{0x33, 0xC0}

var XOR_ECX_ECX = []byte{0x33, 0xC9}

Functions

func CreateSuperScalarInstruction

func CreateSuperScalarInstruction(sins *SuperScalarInstruction, gen *Blake2Generator, instruction_len int, decoder_type int, islast, isfirst bool)

func EMask

func EMask(entropy uint64) uint64

func MaskRegisterExponentMantissa

func MaskRegisterExponentMantissa(f float64, mode uint64) float64

func ScaleNegate

func ScaleNegate(f float64) float64

func ScheduleMop

func ScheduleMop(mop *MacroOP, portbusy [][]int, cycle int, depcycle int, commit bool) int

func ScheduleUop

func ScheduleUop(uop ExecutionPort, portbusy [][]int, cycle int, commit bool) int

ScheduleUop schedule the uop as early as possible

func SetRoundingMode

func SetRoundingMode(f *RegisterFile, mode uint8)

func SmallPositiveFloatBits

func SmallPositiveFloatBits(entropy uint64) float64

func StaticExponent

func StaticExponent(entropy uint64) uint64

func Xor

func Xor(a, b float64) float64

Types

type Blake2Generator

type Blake2Generator struct {
	// contains filtered or unexported fields
}

func Init_Blake2Generator

func Init_Blake2Generator(key []byte, nonce uint32) *Blake2Generator

func (*Blake2Generator) GetByte

func (b *Blake2Generator) GetByte() byte

func (*Blake2Generator) GetUint32

func (b *Blake2Generator) GetUint32() uint32

type ByteCode

type ByteCode [RANDOMX_PROGRAM_SIZE]ByteCodeInstruction

func CompileProgramToByteCode

func CompileProgramToByteCode(prog []byte) (bc ByteCode)

CompileProgramToByteCode this will interpret single vm instruction into executable opcodes reference https://github.com/tevador/RandomX/blob/master/doc/specs.md#52-integer-instructions

func (*ByteCode) Execute

func (c *ByteCode) Execute(f *RegisterFile, pad *ScratchPad, eMask [2]uint64)

Execute Runs a RandomX program with the given register file and scratchpad Warning: This will call asm.SetRoundingMode directly It is the caller's responsibility to set and restore the mode to softfloat64.RoundingModeToNearest between full executions Additionally, runtime.LockOSThread and defer runtime.UnlockOSThread is recommended to prevent other goroutines sharing these changes

type ByteCodeInstruction

type ByteCodeInstruction struct {
	Dst, Src byte
	ImmB     uint8
	Opcode   ByteCodeInstructionOp
	MemMask  uint32
	Imm      uint64
	EMask    uint64
}

type ByteCodeInstructionOp

type ByteCodeInstructionOp int

type DecoderType

type DecoderType int

const Decoder3310 DecoderType = 5

const Decoder3733 DecoderType = 2

const Decoder4444 DecoderType = 4

const Decoder484 DecoderType = 0

const Decoder493 DecoderType = 3

const Decoder7333 DecoderType = 1

func FetchNextDecoder

func FetchNextDecoder(ins *Instruction, cycle int, mulcount int, gen *Blake2Generator) DecoderType

func (DecoderType) GetSize

func (d DecoderType) GetSize() int

func (DecoderType) String

func (d DecoderType) String() string

type ExecutionPort

type ExecutionPort byte

type Instruction

type Instruction struct {
	Opcode    byte
	UOP       MacroOP
	SrcOP     int
	ResultOP  int
	DstOP     int
	UOP_Array []MacroOP
}

func (*Instruction) GetLatency

func (ins *Instruction) GetLatency() int

func (*Instruction) GetSize

func (ins *Instruction) GetSize() int

func (*Instruction) GetUOPCount

func (ins *Instruction) GetUOPCount() int

func (*Instruction) IsSimple

func (ins *Instruction) IsSimple() bool

type MacroOP

type MacroOP struct {
	Name      string
	Size      int
	Latency   int
	UOP1      ExecutionPort
	UOP2      ExecutionPort
	Dependent bool
}

func (*MacroOP) GetLatency

func (m *MacroOP) GetLatency() int

func (*MacroOP) GetSize

func (m *MacroOP) GetSize() int

func (*MacroOP) GetUOP1

func (m *MacroOP) GetUOP1() ExecutionPort

func (*MacroOP) GetUOP2

func (m *MacroOP) GetUOP2() ExecutionPort

func (*MacroOP) IsDependent

func (m *MacroOP) IsDependent() bool

func (*MacroOP) IsEliminated

func (m *MacroOP) IsEliminated() bool

func (*MacroOP) IsSimple

func (m *MacroOP) IsSimple() bool

type MemoryBlock

type MemoryBlock [128]uint64

func (*MemoryBlock) GetLine

func (m *MemoryBlock) GetLine(addr uint64) *RegisterLine

type MemoryRegisters

type MemoryRegisters struct {
	// contains filtered or unexported fields
}

type ProgramFunc

type ProgramFunc []byte

func (ProgramFunc) Close

func (f ProgramFunc) Close() error

func (ProgramFunc) Execute

func (f ProgramFunc) Execute(v uintptr)

type REG

type REG struct {
	Hi uint64
	Lo uint64
}

type Randomx_Cache

type Randomx_Cache struct {
	Blocks []MemoryBlock

	Programs [RANDOMX_PROGRAM_COUNT]SuperScalarProgram

	JitPrograms [RANDOMX_PROGRAM_COUNT]ProgramFunc

	Flags uint64
}

func Randomx_alloc_cache

func Randomx_alloc_cache(flags uint64) *Randomx_Cache

func (*Randomx_Cache) Close

func (cache *Randomx_Cache) Close() error

func (*Randomx_Cache) GetMixBlock

func (cache *Randomx_Cache) GetMixBlock(addr uint64) *RegisterLine

GetMixBlock fetch a 64 byte block in uint64 form

func (*Randomx_Cache) HasJIT

func (cache *Randomx_Cache) HasJIT() bool

func (*Randomx_Cache) Init

func (cache *Randomx_Cache) Init(key []byte)

func (*Randomx_Cache) InitDatasetItem

func (cache *Randomx_Cache) InitDatasetItem(rl *RegisterLine, itemNumber uint64)

func (*Randomx_Cache) InitDatasetItemJIT

func (cache *Randomx_Cache) InitDatasetItemJIT(rl *RegisterLine, itemNumber uint64)

func (*Randomx_Cache) VM_Initialize

func (cache *Randomx_Cache) VM_Initialize() *VM

type Randomx_Dataset

type Randomx_Dataset interface {
	InitDataset(startItem, endItem uint64)
	ReadDataset(address uint64, r, cache *RegisterLine)
	PrefetchDataset(address uint64)
}

type Randomx_DatasetLight

type Randomx_DatasetLight struct {
	Cache  *Randomx_Cache
	Memory []uint64
}

func (*Randomx_DatasetLight) InitDataset

func (d *Randomx_DatasetLight) InitDataset(startItem, endItem uint64)

func (*Randomx_DatasetLight) PrefetchDataset

func (d *Randomx_DatasetLight) PrefetchDataset(address uint64)

func (*Randomx_DatasetLight) ReadDataset

func (d *Randomx_DatasetLight) ReadDataset(address uint64, r, cache *RegisterLine)

type Register

type Register struct {
	Value       uint64
	Latency     int
	LastOpGroup int
	LastOpPar   int //-1 = immediate , 0 to 7 register
	Status      int // can be RegisterNeedsDisplacement = 5; //x86 r13 register

}

type RegisterFile

type RegisterFile struct {
	R RegisterLine
	F [RegistersCountFloat][2]float64
	E [RegistersCountFloat][2]float64
	A [RegistersCountFloat][2]float64

	FPRC uint8
}

func (*RegisterFile) Memory

func (rf *RegisterFile) Memory() *[RegisterFileSize]byte

type RegisterLine

type RegisterLine [RegistersCount]uint64

type ScratchPad

type ScratchPad [ScratchpadSize]byte

func (*ScratchPad) Init

func (pad *ScratchPad) Init(seed *[64]byte)

func (*ScratchPad) Load32

func (pad *ScratchPad) Load32(addr uint32) uint32

func (*ScratchPad) Load32F

func (pad *ScratchPad) Load32F(addr uint32) (lo, hi float64)

func (*ScratchPad) Load32FA

func (pad *ScratchPad) Load32FA(addr uint32) [2]float64

func (*ScratchPad) Load64

func (pad *ScratchPad) Load64(addr uint32) uint64

func (*ScratchPad) Store64

func (pad *ScratchPad) Store64(addr uint32, val uint64)

type SuperScalarInstruction

type SuperScalarInstruction struct {
	Opcode           byte
	Dst_Reg          int
	Src_Reg          int
	Mod              byte
	Imm32            uint32
	Type             int
	OpGroup          int
	OpGroupPar       int
	GroupParIsSource int

	CanReuse bool
	// contains filtered or unexported fields
}

SuperScalarInstruction superscalar program is built with superscalar instructions

func (*SuperScalarInstruction) FixSrcReg

func (sins *SuperScalarInstruction) FixSrcReg()

func (*SuperScalarInstruction) Reset

func (sins *SuperScalarInstruction) Reset()

func (*SuperScalarInstruction) SelectDestination

func (sins *SuperScalarInstruction) SelectDestination(preAllocatedAvailableRegisters []int, cycle int, allowChainedMul bool, Registers []Register, gen *Blake2Generator) bool

func (*SuperScalarInstruction) SelectSource

func (sins *SuperScalarInstruction) SelectSource(preAllocatedAvailableRegisters []int, cycle int, Registers []Register, gen *Blake2Generator) bool

type SuperScalarProgram

type SuperScalarProgram []SuperScalarInstruction

func Build_SuperScalar_Program

func Build_SuperScalar_Program(gen *Blake2Generator) SuperScalarProgram

func (SuperScalarProgram) AddressRegister

func (p SuperScalarProgram) AddressRegister() int

func (SuperScalarProgram) Program

func (p SuperScalarProgram) Program() []SuperScalarInstruction

type VM

type VM struct {
	ScratchPad ScratchPad

	Dataset Randomx_Dataset
}

func (*VM) CalculateHash

func (vm *VM) CalculateHash(input []byte, output *[32]byte)

func (*VM) InitScratchpad

func (vm *VM) InitScratchpad(seed *[64]byte)

func (*VM) Run

func (vm *VM) Run(inputHash [64]byte, roundingMode uint8) (reg RegisterFile)

Run calculate hash based on input Warning: Underlying callers will run float64 SetRoundingMode directly It is the caller's responsibility to set and restore the mode to IEEE 754 roundTiesToEven between full executions Additionally, runtime.LockOSThread and defer runtime.UnlockOSThread is recommended to prevent other goroutines sharing these changes

func (*VM) RunLoops

func (vm *VM) RunLoops(tempHash [64]byte) RegisterFile

type VM_Instruction

type VM_Instruction [8]byte // it is hardcode 8 bytes

VM_Instruction since go does not have union, use byte array

func (VM_Instruction) Dst

func (ins VM_Instruction) Dst() byte

func (VM_Instruction) IMM

func (ins VM_Instruction) IMM() uint32

func (VM_Instruction) IMM64

func (ins VM_Instruction) IMM64() uint64

func (VM_Instruction) Mod

func (ins VM_Instruction) Mod() byte

func (VM_Instruction) Opcode

func (ins VM_Instruction) Opcode() byte

func (VM_Instruction) Src

func (ins VM_Instruction) Src() byte