support resizeable read/write memory (#1701)

* support resizeable read/write memory

This tweaks the way in which read/write memory handles out-of-bounds
accesses (i.e. reads).  Previously, this would panic.  However, now it
returns 0.

* minor fix

* minor tidying up

* linting

Author: DavePearce

pkg/test/zkc_unit_test.go

@@ -96,6 +96,10 @@ func Test_ZkcUnit_Basic_19(t *testing.T) {
 	checkZkcUnit(t, "zkc/unit/basic_19")
 }
 
+func Test_ZkcUnit_Basic_20(t *testing.T) {
+	checkZkcUnit(t, "zkc/unit/basic_20")
+}
+
 // ===================================================================
 // If-Else-If Tests
 // ===================================================================

pkg/zkc/vm/machine/base.go

@@ -129,20 +129,6 @@ func (p *Base[W]) Modules() []Module[W] {
 	return p.modules
 }
 
-// Read implementation of machine.Core interface
-func (p *Base[W]) Read(id uint, address []W) (data []W) {
-	var rm = p.modules[id].(memory.Memory[W])
-	// Perform read
-	return rm.Read(address)
-}
-
-// Write implementation of machine.Core interface
-func (p *Base[W]) Write(id uint, address []W, data []W) {
-	var wm = p.modules[id].(memory.Memory[W])
-	// Perform write
-	wm.Write(address, data)
-}
-
 // Depth returns the depth of the call stack.
 func (p *Base[W]) Depth() uint {
 	return uint(len(p.callstack))
@@ -296,12 +282,12 @@ func (p *Base[W]) executeInstruction(insn instruction.MicroInstruction[W], width
 	case *instruction.MemRead[W]:
 		var rom = p.modules[insn.Id].(memory.Memory[W])
 		// Read data words from tiven address
-		err = rom.FrameRead(frame, insn.Address, insn.Data)
+		err = rom.Read(frame, insn.Address, insn.Data)
 		// Fall thru
 	case *instruction.MemWrite[W]:
 		var rom = p.modules[insn.Id].(memory.Memory[W])
 		// Read data words from tiven address
-		err = rom.FrameWrite(frame, insn.Address, insn.Data)
+		err = rom.Write(frame, insn.Address, insn.Data)
 		// Fall thru
 
 	// ==============================================================

pkg/zkc/vm/machine/core.go

@@ -61,12 +61,6 @@ type Core[W any] interface {
 	// true if the last frame was popped off the stack (i.e. the machine has
 	// terminated).
 	Leave() bool
-	// Read location from ith module.  This must be a readable memory, otherwise
-	// this will panic.
-	Read(id uint, address []W) (data []W)
-	// Write location in ith module.  This must be a writeable memory, otherwise
-	// this will panic.
-	Write(id uint, address []W, data []W)
 }
 
 // Module represents an either a function or memory within the machine.

pkg/zkc/vm/memory/dynamic_array.go

@@ -0,0 +1,60 @@
+// Copyright Consensys Software Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+// the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+// an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+//
+// SPDX-License-Identifier: Apache-2.0
+package memory
+
+import (
+	"github.com/consensys/go-corset/pkg/schema/register"
+	"github.com/consensys/go-corset/pkg/zkc/vm/word"
+)
+
+// DynamicArray is a memory implementation backed by a dynamically sizing []W,
+// meaning that an out-of-bound read will return 0.  Reads are performed by
+// delegating address decoding to a D (an AddressDecoder) which translates the
+// incoming multi-word address tuple into a (start, end) index range, and then
+// returning the corresponding sub-slice of the backing data.
+//
+// The type parameter W is the word type (e.g. a field element or big.Int), and
+// D is the AddressDecoder strategy that encodes the layout of rows within the
+// flat slice.
+type DynamicArray[W word.Word[W]] struct {
+	StaticArray[W]
+}
+
+// newDynamicArray constructs a new array initialised with a given set of values.
+func newDynamicArray[W word.Word[W]](name string, registers []register.Register, init ...W) DynamicArray[W] {
+	var geometry = NewGeometry[W](registers)
+	//
+	return DynamicArray[W]{StaticArray[W]{geometry, name, init}}
+}
+
+// Read implementation for Memory interface.
+func (p *DynamicArray[W]) Read(frame []W, address []register.Id, data []register.Id) error {
+	var start, _ = p.geometry.FrameDecode(frame, address)
+	//
+	for i := range data {
+		frame[data[i].Unwrap()] = p.read(uint64(i) + start)
+	}
+	//
+	return nil
+}
+
+// Internal read function handles out-of-bounds accesses.
+func (p *DynamicArray[W]) read(address uint64) W {
+	if address < uint64(len(p.data)) {
+		return p.data[address]
+	}
+	// out-of-bounds access
+	var zero W
+	//
+	return zero
+}

pkg/zkc/vm/memory/memory.go

@@ -29,15 +29,16 @@ type Memory[W word.Word[W]] interface {
 	// Initialise this memory with the given contents.  This will overwrite any
 	// existing contents.
 	Initialise(contents []W)
-	// Read a given data-tuple from a given address-tuple.
-	Read(address []W) []W
-	// Write a given data-tuple to a given address-tuple, overwriting the
-	// previous value stored at that address.
-	Write(address []W, value []W)
-	// Read a given data-tuple from a given address-tuple.
-	FrameRead(frame []W, address []register.Id, data []register.Id) error
-	// Read a given data-tuple from a given address-tuple.
-	FrameWrite(frame []W, address []register.Id, data []register.Id) error
+	// Read (indirect) a given data-tuple from a given address-tuple. The
+	// address tuple is formed from the "frame" (i.e. the register-file) using
+	// the given register identifiers and, likewise, the target registers are
+	// given in data.
+	Read(frame []W, address []register.Id, data []register.Id) error
+	// Write (indirect) a given data-tuple at a given address-tuple.  The
+	// address tuple is formed from the "frame" (i.e. the register-file) using
+	// the given register identifiers and, likewise, the source registers are
+	// given in data.
+	Write(frame []W, address []register.Id, data []register.Id) error
 	// Return the contents of this memory as a sequence of words, where all rows
 	// are simply appended together.
 	Contents() []W

pkg/zkc/vm/memory/ram.go

@@ -22,12 +22,12 @@ import (
 // dynamically to include any cell which is written, where cells are initialised
 // with zero.
 type RandomAccess[W word.Word[W]] struct {
-	Array[W]
+	DynamicArray[W]
 }
 
 // NewRandomAccess constructs an empty random-access memory.
 func NewRandomAccess[W word.Word[W]](name string, registers []register.Register) *RandomAccess[W] {
 	return &RandomAccess[W]{
-		newArray[W](name, registers),
+		newDynamicArray[W](name, registers),
 	}
 }

pkg/zkc/vm/memory/rom.go

@@ -29,22 +29,17 @@ import (
 // to fixed tables used within the program (e.g. in a hash function such as
 // BLAKE or KECCAK, there are fixed lookup tables used as part of the program).
 type ReadOnly[W word.Word[W]] struct {
-	Array[W]
+	StaticArray[W]
 }
 
 // NewReadOnly constructs a new read-only memory initialised with a given set of values.
 func NewReadOnly[W word.Word[W]](name string, registers []register.Register, init ...W) *ReadOnly[W] {
 	return &ReadOnly[W]{
-		newArray[W](name, registers, init...),
+		newStaticArray[W](name, registers, init...),
 	}
 }
 
 // Write implementation for Memory interface.
-func (p *ReadOnly[W]) Write(address []W, data []W) {
-	panic("unsupported operation for read-only memory")
-}
-
-// FrameWrite implementation for Memory interface.
-func (p *ReadOnly[W]) FrameWrite(frame []W, address []register.Id, data []register.Id) error {
+func (p *ReadOnly[W]) Write(frame []W, address []register.Id, data []register.Id) error {
 	panic("unsupported operation for read-only memory")
 }

pkg/zkc/vm/memory/array.go pkg/zkc/vm/memory/static_array.gopkg/zkc/vm/memory/array.go renamed to pkg/zkc/vm/memory/static_array.go

@@ -17,52 +17,45 @@ import (
 	"github.com/consensys/go-corset/pkg/zkc/vm/word"
 )
 
-// Array is a flat-slice implementation of ReadOnlyMemory backed by a []W.
-// Reads are performed by delegating address decoding to a D (an AddressDecoder)
-// which translates the incoming multi-word address tuple into a (start, end)
-// index range, and then returning the corresponding sub-slice of the backing
-// data.
+// StaticArray is a memory implementation backed by a fixed-size []W, meaning
+// that an out-of-bound read will panic. Reads are performed by delegating
+// address decoding to a D (an AddressDecoder) which translates the incoming
+// multi-word address tuple into a (start, end) index range, and then returning
+// the corresponding sub-slice of the backing data.
 //
 // The type parameter W is the word type (e.g. a field element or big.Int), and
 // D is the AddressDecoder strategy that encodes the layout of rows within the
 // flat slice.
-type Array[W word.Word[W]] struct {
+type StaticArray[W word.Word[W]] struct {
 	geometry Geometry[W]
 	name     string
 	data     []W
 }
 
-// newArray constructs a new array initialised with a given set of values.
-func newArray[W word.Word[W]](name string, registers []register.Register, init ...W) Array[W] {
+// newStaticArray constructs a new array initialised with a given set of values.
+func newStaticArray[W word.Word[W]](name string, registers []register.Register, init ...W) StaticArray[W] {
 	var geometry = NewGeometry[W](registers)
 	//
-	return Array[W]{geometry, name, init}
+	return StaticArray[W]{geometry, name, init}
 }
 
 // Name implementation for Memory interface.
-func (p *Array[W]) Name() string {
+func (p *StaticArray[W]) Name() string {
 	return p.name
 }
 
 // Initialise implementation for Memory interface.
-func (p *Array[W]) Initialise(contents []W) {
+func (p *StaticArray[W]) Initialise(contents []W) {
 	p.data = contents
 }
 
 // Geometry implementation for Memory interface.
-func (p *Array[W]) Geometry() Geometry[W] {
+func (p *StaticArray[W]) Geometry() Geometry[W] {
 	return p.geometry
 }
 
 // Read implementation for Memory interface.
-func (p *Array[W]) Read(address []W) []W {
-	var start, end = p.geometry.Decode(address)
-	//
-	return p.data[start:end]
-}
-
-// FrameRead implementation for Memory interface.
-func (p *Array[W]) FrameRead(frame []W, address []register.Id, data []register.Id) error {
+func (p *StaticArray[W]) Read(frame []W, address []register.Id, data []register.Id) error {
 	var start, _ = p.geometry.FrameDecode(frame, address)
 	//
 	for i := range data {
@@ -72,8 +65,8 @@ func (p *Array[W]) FrameRead(frame []W, address []register.Id, data []register.I
 	return nil
 }
 
-// FrameWrite implementation for Memory interface.
-func (p *Array[W]) FrameWrite(frame []W, address []register.Id, data []register.Id) error {
+// Write implementation for Memory interface.
+func (p *StaticArray[W]) Write(frame []W, address []register.Id, data []register.Id) error {
 	var (
 		n          = uint64(len(p.data))
 		start, end = p.geometry.FrameDecode(frame, address)
@@ -92,23 +85,7 @@ func (p *Array[W]) FrameWrite(frame []W, address []register.Id, data []register.
 	return nil
 }
 
-// Write implementation for Memory interface.
-func (p *Array[W]) Write(address []W, data []W) {
-	var (
-		n          = uint64(len(p.data))
-		start, end = p.geometry.Decode(address)
-	)
-	// expand memory if needed
-	if n <= end {
-		ndata := make([]W, end)
-		copy(ndata, p.data)
-		p.data = ndata
-	}
-	//
-	copy(p.data[start:end], data)
-}
-
 // Contents implementation for Memory interface.
-func (p *Array[W]) Contents() []W {
+func (p *StaticArray[W]) Contents() []W {
 	return p.data
 }

pkg/zkc/vm/memory/wom.go

@@ -22,22 +22,17 @@ import (
 // starting from zero.  Thus, a WOM can be viewed as an output stream (which is
 // exactly what they are typically used for).
 type WriteOnce[W word.Word[W]] struct {
-	Array[W]
+	StaticArray[W]
 }
 
 // NewWriteOnce constructs an empty write-once memory.
 func NewWriteOnce[W word.Word[W]](name string, registers []register.Register) *WriteOnce[W] {
 	return &WriteOnce[W]{
-		newArray[W](name, registers),
+		newStaticArray[W](name, registers),
 	}
 }
 
 // Read implementation for Memory interface.
-func (p *WriteOnce[W]) Read(address []W) []W {
-	panic("unsupported operation for write-once memory")
-}
-
-// FrameRead implementation for Memory interface.
-func (p *WriteOnce[W]) FrameRead(frame []W, address []register.Id, data []register.Id) error {
+func (p *WriteOnce[W]) Read(frame []W, address []register.Id, data []register.Id) error {
 	panic("unsupported operation for write-once memory")
 }

testdata/zkc/unit/basic_20.accepts

@@ -0,0 +1,20 @@
+{ "data": "0x0302aa" }
+{ "data": "0x030200" }
+{ "data": "0x0403aaaa" }
+{ "data": "0x0f000f000000000000000000000000" }
+{ "data": "0x0f0101000000000000000000000000" }
+;;
+{ "data": "0x0f0200000000000000000000000000" }
+{ "data": "0x0f02000100000ff00000008000aa00" }
+{ "data": "0x0f020001000ff00000008000aa00ee" }
+{ "data": "0x0f020001000ff000008000aa00eeff" }
+;;
+{ "data": "0x0f0300000000000000000000000000" }
+{ "data": "0x0f030000aabbccddee000000000000" }
+{ "data": "0x0f030000aabbccddee112233445566" }
+;;
+{ "data": "0x0f04aa00aabbccddee112233445566" }
+{ "data": "0x0f06cc00aabbccddee112233445566" }
+{ "data": "0x0f0a2200aabbccddee112233445566" }
+;;
+{ "data": "0x0f0f0000aabbccddee112233445566" }