Skip to content

Commit

Permalink
cannon: Introduce reader and writer helpers to simplify code.
Browse files Browse the repository at this point in the history
  • Loading branch information
@ajsutton
ajsutton committed Sep 6, 2024
1 parent c32e2e7 commit 1dd7ebf
Show file tree
Hide file tree
Showing 5 changed files with 180 additions and 154 deletions.
116 changes: 33 additions & 83 deletions cannon/mipsevm/multithreaded/state.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -6,6 +6,7 @@ import (
"io"

"github.com/ethereum-optimism/optimism/cannon/mipsevm/versions"
"github.com/ethereum-optimism/optimism/cannon/serialize"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common/hexutil"
"github.com/ethereum/go-ethereum/crypto"
Expand Down Expand Up @@ -244,98 +245,72 @@ func (s *State) ThreadCount() int {
// len(LastHint) uint32 (0 when LastHint is nil)
// LastHint []byte
func (s *State) Serialize(out io.Writer) error {
if err := binary.Write(out, binary.BigEndian, versions.VersionMultiThreaded); err != nil {
bout := serialize.NewBinaryWriter(out)
if err := bout.WriteUInt(versions.VersionMultiThreaded); err != nil {
return err
}

if err := s.Memory.Serialize(out); err != nil {
return err
}
if _, err := out.Write(s.PreimageKey[:]); err != nil {
if err := bout.WriteHash(s.PreimageKey); err != nil {
return err
}
if err := binary.Write(out, binary.BigEndian, s.PreimageOffset); err != nil {
if err := bout.WriteUInt(s.PreimageOffset); err != nil {
return err
}
if err := binary.Write(out, binary.BigEndian, s.Heap); err != nil {
if err := bout.WriteUInt(s.Heap); err != nil {
return err
}
if err := binary.Write(out, binary.BigEndian, s.ExitCode); err != nil {
if err := bout.WriteUInt(s.ExitCode); err != nil {
return err
}
var exited uint8
if s.Exited {
exited = 1
}
if err := binary.Write(out, binary.BigEndian, exited); err != nil {
if err := bout.WriteBool(s.Exited); err != nil {
return err
}
if err := binary.Write(out, binary.BigEndian, s.Step); err != nil {
if err := bout.WriteUInt(s.Step); err != nil {
return err
}
if err := binary.Write(out, binary.BigEndian, s.StepsSinceLastContextSwitch); err != nil {
if err := bout.WriteUInt(s.StepsSinceLastContextSwitch); err != nil {
return err
}
if err := binary.Write(out, binary.BigEndian, s.Wakeup); err != nil {
if err := bout.WriteUInt(s.Wakeup); err != nil {
return err
}

var traverseRight uint8
if s.TraverseRight {
traverseRight = 1
}
if err := binary.Write(out, binary.BigEndian, traverseRight); err != nil {
if err := bout.WriteBool(s.TraverseRight); err != nil {
return err
}

if err := binary.Write(out, binary.BigEndian, s.NextThreadId); err != nil {
if err := bout.WriteUInt(s.NextThreadId); err != nil {
return err
}

if err := binary.Write(out, binary.BigEndian, uint32(len(s.LeftThreadStack))); err != nil {
if err := bout.WriteUInt(uint32(len(s.LeftThreadStack))); err != nil {
return err
}
for _, stack := range s.LeftThreadStack {
if err := stack.Serialize(out); err != nil {
return err
}
}

if err := binary.Write(out, binary.BigEndian, uint32(len(s.RightThreadStack))); err != nil {
if err := bout.WriteUInt(uint32(len(s.RightThreadStack))); err != nil {
return err
}
for _, stack := range s.RightThreadStack {
if err := stack.Serialize(out); err != nil {
return err
}
}

// Write the length of the last hint as a big endian uint32.
// Note that the length is set to 0 even if the hint is nil.
if s.LastHint == nil {
if err := binary.Write(out, binary.BigEndian, uint32(0)); err != nil {
return err
}
} else {
if err := binary.Write(out, binary.BigEndian, uint32(len(s.LastHint))); err != nil {
return err
}

n, err := out.Write(s.LastHint)
if err != nil {
return err
}
if n != len(s.LastHint) {
panic("failed to write full last hint")
}
if err := bout.WriteBytes(s.LastHint); err != nil {
return err
}

return nil
}

func (s *State) Deserialize(in io.Reader) error {
bin := serialize.NewBinaryReader(in)
var version versions.StateVersion
if err := binary.Read(in, binary.BigEndian, &version); err != nil {
if err := bin.ReadUInt(&version); err != nil {
return err
}
if version != versions.VersionMultiThreaded {
Expand All @@ -345,51 +320,40 @@ func (s *State) Deserialize(in io.Reader) error {
if err := s.Memory.Deserialize(in); err != nil {
return err
}
if _, err := io.ReadFull(in, s.PreimageKey[:]); err != nil {
if err := bin.ReadHash(&s.PreimageKey); err != nil {
return err
}
if err := binary.Read(in, binary.BigEndian, &s.PreimageOffset); err != nil {
if err := bin.ReadUInt(&s.PreimageOffset); err != nil {
return err
}
if err := binary.Read(in, binary.BigEndian, &s.Heap); err != nil {
if err := bin.ReadUInt(&s.Heap); err != nil {
return err
}
var exitCode uint8
if err := binary.Read(in, binary.BigEndian, &exitCode); err != nil {
if err := bin.ReadUInt(&s.ExitCode); err != nil {
return err
}
s.ExitCode = exitCode
var exited uint8
if err := binary.Read(in, binary.BigEndian, &exited); err != nil {
if err := bin.ReadBool(&s.Exited); err != nil {
return err
}
if exited == 1 {
s.Exited = true
} else {
s.Exited = false
}
if err := binary.Read(in, binary.BigEndian, &s.Step); err != nil {
if err := bin.ReadUInt(&s.Step); err != nil {
return err
}
if err := binary.Read(in, binary.BigEndian, &s.StepsSinceLastContextSwitch); err != nil {
if err := bin.ReadUInt(&s.StepsSinceLastContextSwitch); err != nil {
return err
}
if err := binary.Read(in, binary.BigEndian, &s.Wakeup); err != nil {
if err := bin.ReadUInt(&s.Wakeup); err != nil {
return err
}

var traverseRight uint8
if err := binary.Read(in, binary.BigEndian, &traverseRight); err != nil {
return nil
if err := bin.ReadBool(&s.TraverseRight); err != nil {
return err
}
s.TraverseRight = traverseRight != 0

if err := binary.Read(in, binary.BigEndian, &s.NextThreadId); err != nil {
if err := bin.ReadUInt(&s.NextThreadId); err != nil {
return err
}

var leftThreadStackSize uint32
if err := binary.Read(in, binary.BigEndian, &leftThreadStackSize); err != nil {
if err := bin.ReadUInt(&leftThreadStackSize); err != nil {
return err
}
s.LeftThreadStack = make([]*ThreadState, leftThreadStackSize)
Expand All @@ -401,7 +365,7 @@ func (s *State) Deserialize(in io.Reader) error {
}

var rightThreadStackSize uint32
if err := binary.Read(in, binary.BigEndian, &rightThreadStackSize); err != nil {
if err := bin.ReadUInt(&rightThreadStackSize); err != nil {
return err
}
s.RightThreadStack = make([]*ThreadState, rightThreadStackSize)
Expand All @@ -412,23 +376,9 @@ func (s *State) Deserialize(in io.Reader) error {
}
}

// Note that a zero length is always interpreted as nil
var lastHintLen uint32
if err := binary.Read(in, binary.BigEndian, &lastHintLen); err != nil {
if err := bin.ReadBytes((*[]byte)(&s.LastHint)); err != nil {
return err
}
if lastHintLen > 0 {
lastHint := make([]byte, lastHintLen)
n, err := in.Read(lastHint)
if err != nil {
return err
}
if n != int(lastHintLen) {
panic("failed to read full last hint")
}
s.LastHint = lastHint
}

return nil
}

Expand Down
Loading

0 comments on commit 1dd7ebf

Please sign in to comment.