Skip to content

Commit

Permalink
wip memory addition
Browse files Browse the repository at this point in the history
  • Loading branch information
@jkktom
jkktom committed Sep 28, 2023
1 parent a16cdb4 commit 0e66d54
Show file tree
Hide file tree
Showing 2 changed files with 37 additions and 40 deletions.
22 changes: 11 additions & 11 deletions pkg/vm/memory/memory_value.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -26,17 +26,19 @@ func (address *MemoryAddress) Equal(other *MemoryAddress) bool {
}

// Adds a memory address and a field element
func (address *MemoryAddress) Add(lhs *MemoryAddress, rhs *f.Element) (*MemoryAddress, error) {
lhsOffset := new(f.Element).SetUint64(lhs.Offset)
newOffset := new(f.Element).Add(lhsOffset, rhs)
func (ma *MemoryAddress) Add(address *MemoryAddress, offset *f.Element) (*MemoryAddress, error) {
addressOffset := new(f.Element).SetUint64(address.Offset)
resOffset := new(f.Element).Add(addressOffset, offset)

if !newOffset.IsUint64() {
return nil, fmt.Errorf("new offset bigger than uint64: %s", rhs.Text(10))
if !resOffset.IsUint64() {
return nil, fmt.Errorf("new offset bigger than uint64: %s", resOffset.Text(10))
}

address.SegmentIndex = lhs.SegmentIndex
address.Offset = newOffset.Uint64()
return address, nil
resAddress := &MemoryAddress{
SegmentIndex: address.SegmentIndex,
Offset: resOffset.Uint64(),
}
return resAddress, nil
}

// Subs from a memory address a felt or another memory address in the same segment
Expand Down Expand Up @@ -220,11 +222,9 @@ func (mv *MemoryValue) Add(lhs, rhs *MemoryValue) (*MemoryValue, error) {
return nil, errors.New("rhs is not a felt")
}
mv.address, err = mv.address.Add(lhs.address, rhs.felt)
mv.felt = nil // Felt field is set to nil
} else {
if rhs.IsAddress() {
mv.address, err = rhs.address.Add(rhs.address, lhs.felt)
mv.felt = nil
mv.address, err = mv.address.Add(rhs.address, lhs.felt)
} else {
mv.felt = mv.felt.Add(lhs.felt, rhs.felt)
}
Expand Down
55 changes: 26 additions & 29 deletions pkg/vm/vm_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -348,69 +348,65 @@ func TestInferOperandSub(t *testing.T) {
assert.Equal(t, expectedOp0Cell, op0Cell)
}

func TestComputeRes_Unconstrained(t *testing.T) {
func TestComputeResUnconstrained(t *testing.T) {
vm := defaultVirtualMachine()
instruction := Instruction{Res: Unconstrained}

cellOp0 := &mem.Cell{Accessed: true, Value: mem.MemoryValueFromInt(10)}
cellOp1 := &mem.Cell{Accessed: true, Value: mem.MemoryValueFromInt(15)}

res, err := vm.computeRes(&instruction, cellOp0, cellOp1)
res, err := vm.computeRes(&instruction, nil, nil)
require.NoError(t, err)
assert.Nil(t, res)
}

func TestComputeRes_Op1(t *testing.T) {
func TestComputeResOp1(t *testing.T) {
vm := defaultVirtualMachine()
instruction := Instruction{Res: Op1}

cellOp0 := &mem.Cell{Accessed: true, Value: mem.MemoryValueFromInt(10)}
cellOp1 := &mem.Cell{Accessed: true, Value: mem.MemoryValueFromInt(15)}

res, err := vm.computeRes(&instruction, cellOp0, cellOp1)
res, err := vm.computeRes(&instruction, nil, cellOp1)
require.NoError(t, err)
expected := mem.MemoryValueFromInt(15)
assert.Equal(t, expected, res)
}

func TestComputeAddRes_AddrToFelt(t *testing.T) {
func TestComputeAddResAddrToFelt(t *testing.T) {
vm := defaultVirtualMachine()
instruction := Instruction{Res: AddOperands}

cellOp0 := &mem.Cell{Accessed: true, Value: mem.MemoryValueFromMemoryAddress(mem.NewMemoryAddress(2, 10))}
cellOp0 := &mem.Cell{Accessed: true, Value: mem.MemoryValueFromSegmentAndOffset(2, 10)}
cellOp1 := &mem.Cell{Accessed: true, Value: mem.MemoryValueFromInt(15)}

res, err := vm.computeRes(&instruction, cellOp0, cellOp1)
require.NoError(t, err)
expected := mem.MemoryValueFromMemoryAddress(mem.NewMemoryAddress(2, 25))
expected := mem.MemoryValueFromSegmentAndOffset(2, 25)
assert.Equal(t, expected, res)
}

func TestComputeAddRes_FeltToAddr(t *testing.T) {
func TestComputeAddResFeltToAddr(t *testing.T) {
vm := defaultVirtualMachine()
instruction := Instruction{Res: AddOperands}

cellOp0 := &mem.Cell{Accessed: true, Value: mem.MemoryValueFromInt(15)}
cellOp1 := &mem.Cell{Accessed: true, Value: mem.MemoryValueFromMemoryAddress(mem.NewMemoryAddress(2, 15))}
cellOp1 := &mem.Cell{Accessed: true, Value: mem.MemoryValueFromSegmentAndOffset(2, 15)}

res, err := vm.computeRes(&instruction, cellOp0, cellOp1)
require.NoError(t, err)
expected := mem.MemoryValueFromMemoryAddress(mem.NewMemoryAddress(2, 30))
expected := mem.MemoryValueFromSegmentAndOffset(2, 15)
assert.Equal(t, expected, res)
}

func TestComputeAddRes_BothAddrs(t *testing.T) {
func TestComputeAddResBothAddrs(t *testing.T) {
vm := defaultVirtualMachine()
instruction := Instruction{Res: AddOperands}

cellOp0 := &mem.Cell{Accessed: true, Value: mem.MemoryValueFromMemoryAddress(mem.NewMemoryAddress(2, 10))}
cellOp1 := &mem.Cell{Accessed: true, Value: mem.MemoryValueFromMemoryAddress(mem.NewMemoryAddress(2, 15))}
cellOp0 := &mem.Cell{Accessed: true, Value: mem.MemoryValueFromSegmentAndOffset(2, 10)}
cellOp1 := &mem.Cell{Accessed: true, Value: mem.MemoryValueFromSegmentAndOffset(2, 15)}

_, err := vm.computeRes(&instruction, cellOp0, cellOp1)
require.Error(t, err) // Expecting an error since adding two addresses is not allowed
}

func TestComputeAddRes_BothFelts(t *testing.T) {
func TestComputeAddResBothFelts(t *testing.T) {
vm := defaultVirtualMachine()
instruction := Instruction{Res: AddOperands}

Expand All @@ -424,7 +420,7 @@ func TestComputeAddRes_BothFelts(t *testing.T) {
}

// Felt should be Positive or Negative. Thus four test cases
func TestComputeMulRes_PToPFelt(t *testing.T) {
func TestComputeMulResPosToPosFelt(t *testing.T) {
//Positive Felt to Positive Felt compute
vm := defaultVirtualMachine()
instruction := Instruction{Res: MulOperands}
Expand All @@ -437,7 +433,8 @@ func TestComputeMulRes_PToPFelt(t *testing.T) {
expected := mem.MemoryValueFromInt(150)
assert.Equal(t, expected, res)
}
func TestComputeMulRes_NToPFelts(t *testing.T) {

func TestComputeMulResNegToPosFelts(t *testing.T) {
vm := defaultVirtualMachine()
instruction := Instruction{Res: MulOperands}
//Negative to Positive
Expand All @@ -450,7 +447,7 @@ func TestComputeMulRes_NToPFelts(t *testing.T) {
assert.Equal(t, expected, res)
}

func TestComputeMulRes_PToNFelt(t *testing.T) {
func TestComputeMulResPosToNegFelt(t *testing.T) {
vm := defaultVirtualMachine()
instruction := Instruction{Res: MulOperands}
//Positive to Negative
Expand All @@ -463,7 +460,7 @@ func TestComputeMulRes_PToNFelt(t *testing.T) {
assert.Equal(t, expected, res)
}

func TestComputeMulRes_NToNFelt(t *testing.T) {
func TestComputeMulResNegToNegFelt(t *testing.T) {
vm := defaultVirtualMachine()
instruction := Instruction{Res: MulOperands}
//Netagive to Negative
Expand All @@ -478,34 +475,34 @@ func TestComputeMulRes_NToNFelt(t *testing.T) {

// Multiplication does not involve addresses
// three failing cases
func TestComputeMulRes_AddrToFelt(t *testing.T) {
func TestComputeMulResAddrToFelt(t *testing.T) {
vm := defaultVirtualMachine()
instruction := Instruction{Res: MulOperands}

cellOp0 := &mem.Cell{Accessed: true, Value: mem.MemoryValueFromMemoryAddress(mem.NewMemoryAddress(2, 10))}
cellOp0 := &mem.Cell{Accessed: true, Value: mem.MemoryValueFromSegmentAndOffset(2, 10)}
cellOp1 := &mem.Cell{Accessed: true, Value: mem.MemoryValueFromInt(15)}

_, err := vm.computeRes(&instruction, cellOp0, cellOp1)
require.Error(t, err) // Expecting an error since multiplying an address with a felt is not allowed
}

func TestComputeMulRes_FeltToAddr(t *testing.T) {
func TestComputeMulResFeltToAddr(t *testing.T) {
vm := defaultVirtualMachine()
instruction := Instruction{Res: MulOperands}

cellOp0 := &mem.Cell{Accessed: true, Value: mem.MemoryValueFromInt(15)}
cellOp1 := &mem.Cell{Accessed: true, Value: mem.MemoryValueFromMemoryAddress(mem.NewMemoryAddress(2, 10))}
cellOp1 := &mem.Cell{Accessed: true, Value: mem.MemoryValueFromSegmentAndOffset(2, 10)}

_, err := vm.computeRes(&instruction, cellOp0, cellOp1)
require.Error(t, err)
}

func TestComputeMulRes_BothAddrs(t *testing.T) {
func TestComputeMulResBothAddrs(t *testing.T) {
vm := defaultVirtualMachine()
instruction := Instruction{Res: MulOperands}

cellOp0 := &mem.Cell{Accessed: true, Value: mem.MemoryValueFromMemoryAddress(mem.NewMemoryAddress(2, 10))}
cellOp1 := &mem.Cell{Accessed: true, Value: mem.MemoryValueFromMemoryAddress(mem.NewMemoryAddress(2, 15))}
cellOp0 := &mem.Cell{Accessed: true, Value: mem.MemoryValueFromSegmentAndOffset(2, 10)}
cellOp1 := &mem.Cell{Accessed: true, Value: mem.MemoryValueFromSegmentAndOffset(2, 15)}

_, err := vm.computeRes(&instruction, cellOp0, cellOp1)
require.Error(t, err) // Expecting an error since multiplying two addresses is not allowed
Expand Down

0 comments on commit 0e66d54

Please sign in to comment.