Skip to content

Commit

Permalink
make vm.Pc a value
Browse files Browse the repository at this point in the history
  • Loading branch information
@omerfirmak
omerfirmak committed Sep 29, 2023
1 parent 0c1f70d commit 6f305c4
Show file tree
Hide file tree
Showing 4 changed files with 40 additions and 40 deletions.
34 changes: 17 additions & 17 deletions pkg/runners/zero/zero.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -50,7 +50,7 @@ func (runner *ZeroRunner) Run() error {
return fmt.Errorf("initializing main entry point: %w", err)
}

err = runner.RunUntilPc(end)
err = runner.RunUntilPc(&end)
if err != nil {
return err
}
Expand All @@ -70,15 +70,15 @@ func (runner *ZeroRunner) Run() error {
return nil
}

func (runner *ZeroRunner) InitializeMainEntrypoint() (*memory.MemoryAddress, error) {
func (runner *ZeroRunner) InitializeMainEntrypoint() (memory.MemoryAddress, error) {
if runner.proofmode {
startPc, ok := runner.program.Labels["__start__"]
if !ok {
return nil, errors.New("start label not found. Try compiling with `--proof_mode`")
return memory.MemoryAddress{}, errors.New("start label not found. Try compiling with `--proof_mode`")
}
endPc, ok := runner.program.Labels["__end__"]
if !ok {
return nil, errors.New("end label not found. Try compiling with `--proof_mode`")
return memory.MemoryAddress{}, errors.New("end label not found. Try compiling with `--proof_mode`")
}

offset := runner.segments()[VM.ExecutionSegment].Len()
Expand All @@ -94,20 +94,20 @@ func (runner *ZeroRunner) InitializeMainEntrypoint() (*memory.MemoryAddress, err
&dummyFPValue,
)
if err != nil {
return nil, err
return memory.MemoryAddress{}, err
}

dummyPCValue := memory.MemoryValueFromUint[uint64](0)
// set dummy pc value
err = runner.memory().Write(VM.ExecutionSegment, offset+1, &dummyPCValue)
if err != nil {
return nil, err
return memory.MemoryAddress{}, err
}

runner.vm.Context.Pc = &memory.MemoryAddress{SegmentIndex: VM.ProgramSegment, Offset: startPc}
runner.vm.Context.Pc = memory.MemoryAddress{SegmentIndex: VM.ProgramSegment, Offset: startPc}
runner.vm.Context.Ap = offset + 2
runner.vm.Context.Fp = runner.vm.Context.Ap
return &memory.MemoryAddress{SegmentIndex: VM.ProgramSegment, Offset: endPc}, nil
return memory.MemoryAddress{SegmentIndex: VM.ProgramSegment, Offset: endPc}, nil
}

returnFp := memory.MemoryValueFromSegmentAndOffset(
Expand All @@ -119,34 +119,34 @@ func (runner *ZeroRunner) InitializeMainEntrypoint() (*memory.MemoryAddress, err

func (runner *ZeroRunner) InitializeEntrypoint(
funcName string, arguments []*f.Element, returnFp *memory.MemoryValue,
) (*memory.MemoryAddress, error) {
) (memory.MemoryAddress, error) {
segmentIndex := runner.memory().AllocateEmptySegment()
end := &memory.MemoryAddress{SegmentIndex: uint64(segmentIndex), Offset: 0}
end := memory.MemoryAddress{SegmentIndex: uint64(segmentIndex), Offset: 0}
// write arguments
for i := range arguments {
v := memory.MemoryValueFromFieldElement(arguments[i])
err := runner.memory().Write(VM.ExecutionSegment, uint64(i), &v)
if err != nil {
return nil, err
return memory.MemoryAddress{}, err
}
}
offset := runner.segments()[VM.ExecutionSegment].Len()
err := runner.memory().Write(VM.ExecutionSegment, offset, returnFp)
if err != nil {
return nil, err
return memory.MemoryAddress{}, err
}
endMV := memory.MemoryValueFromMemoryAddress(end)
endMV := memory.MemoryValueFromMemoryAddress(&end)
err = runner.memory().Write(VM.ExecutionSegment, offset+1, &endMV)
if err != nil {
return nil, err
return memory.MemoryAddress{}, err
}

pc, ok := runner.program.Entrypoints[funcName]
if !ok {
return nil, fmt.Errorf("unknwon entrypoint: %s", funcName)
return memory.MemoryAddress{}, fmt.Errorf("unknwon entrypoint: %s", funcName)
}

runner.vm.Context.Pc = &memory.MemoryAddress{SegmentIndex: VM.ProgramSegment, Offset: pc}
runner.vm.Context.Pc = memory.MemoryAddress{SegmentIndex: VM.ProgramSegment, Offset: pc}
runner.vm.Context.Ap = offset + 2
runner.vm.Context.Fp = runner.vm.Context.Ap

Expand Down Expand Up @@ -216,7 +216,7 @@ func (runner *ZeroRunner) segments() []*memory.Segment {
return runner.vm.MemoryManager.Memory.Segments
}

func (runner *ZeroRunner) pc() *memory.MemoryAddress {
func (runner *ZeroRunner) pc() memory.MemoryAddress {
return runner.vm.Context.Pc
}

Expand Down
16 changes: 8 additions & 8 deletions pkg/runners/zero/zero_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -30,11 +30,11 @@ func TestSimpleProgram(t *testing.T) {
endPc, err := runner.InitializeMainEntrypoint()
require.NoError(t, err)

expectedPc := &memory.MemoryAddress{SegmentIndex: 3, Offset: 0}
expectedPc := memory.MemoryAddress{SegmentIndex: 3, Offset: 0}

require.Equal(t, expectedPc, endPc)

err = runner.RunUntilPc(endPc)
err = runner.RunUntilPc(&endPc)
require.NoError(t, err)

executionSegment := runner.segments()[VM.ExecutionSegment]
Expand All @@ -45,7 +45,7 @@ func TestSimpleProgram(t *testing.T) {
// return fp
&memory.MemoryAddress{SegmentIndex: 2, Offset: 0},
// next pc
expectedPc,
&expectedPc,
2,
3,
4,
Expand Down Expand Up @@ -76,10 +76,10 @@ func TestStepLimitExceeded(t *testing.T) {
endPc, err := runner.InitializeMainEntrypoint()
require.NoError(t, err)

expectedPc := &memory.MemoryAddress{SegmentIndex: 3, Offset: 0}
expectedPc := memory.MemoryAddress{SegmentIndex: 3, Offset: 0}
require.Equal(t, expectedPc, endPc)

err = runner.RunUntilPc(endPc)
err = runner.RunUntilPc(&endPc)
require.ErrorContains(t, err, "step limit exceeded")

executionSegment := runner.segments()[VM.ExecutionSegment]
Expand All @@ -90,7 +90,7 @@ func TestStepLimitExceeded(t *testing.T) {
// return fp
&memory.MemoryAddress{SegmentIndex: 2, Offset: 0},
// next pc
expectedPc,
&expectedPc,
2,
3,
5,
Expand All @@ -103,7 +103,7 @@ func TestStepLimitExceeded(t *testing.T) {
assert.Equal(t, uint64(2), runner.vm.Context.Ap)
assert.Equal(t, uint64(2), runner.vm.Context.Fp)
// the fourth instruction starts at 0:6 because all previous one have size 2
assert.Equal(t, &memory.MemoryAddress{SegmentIndex: 0, Offset: 6}, runner.vm.Context.Pc)
assert.Equal(t, memory.MemoryAddress{SegmentIndex: 0, Offset: 6}, runner.vm.Context.Pc)
// step limit exceeded
assert.Equal(t, uint64(3), runner.steps())
}
Expand Down Expand Up @@ -158,7 +158,7 @@ func TestStepLimitExceededProofMode(t *testing.T) {
assert.Equal(t, uint64(2), runner.vm.Context.Ap)
assert.Equal(t, uint64(2), runner.vm.Context.Fp)
// it repeats the last instruction at 0:12
assert.Equal(t, &memory.MemoryAddress{SegmentIndex: 0, Offset: 12}, runner.vm.Context.Pc)
assert.Equal(t, memory.MemoryAddress{SegmentIndex: 0, Offset: 12}, runner.vm.Context.Pc)
// step limit exceeded
assert.Equal(t, uint64(maxstep), runner.steps())
}
Expand Down
12 changes: 6 additions & 6 deletions pkg/vm/vm.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -24,7 +24,7 @@ type HintRunner interface {

// Represents the current execution context of the vm
type Context struct {
Pc *mem.MemoryAddress
Pc mem.MemoryAddress
Fp uint64
Ap uint64
}
Expand Down Expand Up @@ -108,7 +108,7 @@ func NewVirtualMachine(programBytecode []*f.Element, config VirtualMachineConfig
Context: Context{
Fp: 0,
Ap: 0,
Pc: &mem.MemoryAddress{
Pc: mem.MemoryAddress{
SegmentIndex: ProgramSegment,
Offset: 0,
},
Expand All @@ -127,7 +127,7 @@ func (vm *VirtualMachine) RunStep(hintRunner HintRunner) error {
// if instruction is not in cache, redecode and store it
instruction, ok := vm.instructions[vm.Context.Pc.Offset]
if !ok {
memoryValue, err := vm.MemoryManager.Memory.ReadFromAddress(vm.Context.Pc)
memoryValue, err := vm.MemoryManager.Memory.ReadFromAddress(&vm.Context.Pc)
if err != nil {
return fmt.Errorf("reading instruction: %w", err)
}
Expand Down Expand Up @@ -205,7 +205,7 @@ func (vm *VirtualMachine) RunInstruction(instruction *Instruction) error {
return fmt.Errorf("fp update: %w", err)
}

vm.Context.Pc = &nextPc
vm.Context.Pc = nextPc
vm.Context.Ap = nextAp
vm.Context.Fp = nextFp

Expand Down Expand Up @@ -433,7 +433,7 @@ func (vm *VirtualMachine) updatePc(
if err != nil {
return mem.MemoryAddress{}, fmt.Errorf("relative jump: %w", err)
}
newPc := *vm.Context.Pc
newPc := vm.Context.Pc
err = newPc.Add(&newPc, val)
return newPc, err
case Jnz:
Expand Down Expand Up @@ -464,7 +464,7 @@ func (vm *VirtualMachine) updatePc(
return mem.MemoryAddress{}, err
}

newPc := *vm.Context.Pc
newPc := vm.Context.Pc
err = newPc.Add(&newPc, val)
return newPc, err

Expand Down
18 changes: 9 additions & 9 deletions pkg/vm/vm_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -169,8 +169,8 @@ func TestGetImmCellOp1(t *testing.T) {
)

// Prepare vm with dummy values
const offOp1 = 1 // target imm
vm.Context.Pc = &mem.MemoryAddress{SegmentIndex: 0, Offset: 1} // "current instruction"
const offOp1 = 1 // target imm
vm.Context.Pc = mem.MemoryAddress{SegmentIndex: 0, Offset: 1} // "current instruction"

instruction := Instruction{
OffOp1: offOp1,
Expand Down Expand Up @@ -388,7 +388,7 @@ func TestOpcodeAssertionAssertEq(t *testing.T) {
func TestUpdatePcNextInstr(t *testing.T) {
vm := defaultVirtualMachine()

vm.Context.Pc = &mem.MemoryAddress{SegmentIndex: 0, Offset: 3}
vm.Context.Pc = mem.MemoryAddress{SegmentIndex: 0, Offset: 3}
instruction := Instruction{
PcUpdate: NextInstr,
Op1Source: Op0, // anything but imm
Expand All @@ -402,7 +402,7 @@ func TestUpdatePcNextInstr(t *testing.T) {
func TestUpdatePcNextInstrImm(t *testing.T) {
vm := defaultVirtualMachine()

vm.Context.Pc = &mem.MemoryAddress{SegmentIndex: 0, Offset: 3}
vm.Context.Pc = mem.MemoryAddress{SegmentIndex: 0, Offset: 3}
instruction := Instruction{
PcUpdate: NextInstr,
Op1Source: Imm,
Expand All @@ -416,7 +416,7 @@ func TestUpdatePcNextInstrImm(t *testing.T) {
func TestUpdatePcJump(t *testing.T) {
vm := defaultVirtualMachine()

vm.Context.Pc = &mem.MemoryAddress{SegmentIndex: 0, Offset: 3}
vm.Context.Pc = mem.MemoryAddress{SegmentIndex: 0, Offset: 3}
jumpAddr := uint64(10)
res := mem.MemoryValueFromSegmentAndOffset(0, jumpAddr)

Expand All @@ -432,7 +432,7 @@ func TestUpdatePcJump(t *testing.T) {
func TestUpdatePcJumpRel(t *testing.T) {
vm := defaultVirtualMachine()

vm.Context.Pc = &mem.MemoryAddress{SegmentIndex: 0, Offset: 3}
vm.Context.Pc = mem.MemoryAddress{SegmentIndex: 0, Offset: 3}
relAddr := uint64(10)
res := mem.MemoryValueFromInt(relAddr)

Expand All @@ -453,7 +453,7 @@ func TestUpdatePcJnz(t *testing.T) {
dstAddr := mem.MemoryAddress{SegmentIndex: ExecutionSegment, Offset: 0}
op1Addr := mem.MemoryAddress{SegmentIndex: ExecutionSegment, Offset: 1}

vm.Context.Pc = &mem.MemoryAddress{SegmentIndex: 0, Offset: 11}
vm.Context.Pc = mem.MemoryAddress{SegmentIndex: 0, Offset: 11}
res := mem.MemoryValueFromInt(10)
instruction := Instruction{
PcUpdate: Jnz,
Expand All @@ -470,7 +470,7 @@ func TestUpdatePcJnzDstZero(t *testing.T) {
writeToDataSegment(vm, 0, mem.MemoryValueFromInt(0)) //dstCell
dstAddr := mem.MemoryAddress{SegmentIndex: ExecutionSegment, Offset: 0}

vm.Context.Pc = &mem.MemoryAddress{SegmentIndex: 0, Offset: 11}
vm.Context.Pc = mem.MemoryAddress{SegmentIndex: 0, Offset: 11}

instruction := Instruction{
PcUpdate: Jnz,
Expand All @@ -487,7 +487,7 @@ func TestUpdatePcJnzDstZeroImm(t *testing.T) {
writeToDataSegment(vm, 0, mem.MemoryValueFromInt(0)) //dstCell
dstAddr := mem.MemoryAddress{SegmentIndex: ExecutionSegment, Offset: 0}

vm.Context.Pc = &mem.MemoryAddress{SegmentIndex: 0, Offset: 9}
vm.Context.Pc = mem.MemoryAddress{SegmentIndex: 0, Offset: 9}

instruction := Instruction{
PcUpdate: Jnz,
Expand Down

0 comments on commit 6f305c4

Please sign in to comment.