ben.vdl.go

// Copyright 2015 The Vanadium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This file was auto-generated by the vanadium vdl tool.
// Package: ben

// Package ben defines datastructures to archive microbenchmark results.
//
// These are the data structures common to tools described in
// https://docs.google.com/document/d/1v-iKwej3eYT_RNhPwQ81A9fa8H15Q6RzNyv2rrAeAUc/edit?usp=sharing
package ben

import (
	"fmt"
	"v.io/v23/vdl"
)

var _ = __VDLInit() // Must be first; see __VDLInit comments for details.

//////////////////////////////////////////////////
// Type definitions

// Cpu describes the CPU of the machine on which the microbenchmarks were run.
type Cpu struct {
	Architecture  string // Architecture of the CPU, e.g. "amd64", "386" etc.
	Description   string // A detailed description of the CPU, e.g., "Intel(R) Core(TM) i7-5557U CPU @ 3.10GHz"
	ClockSpeedMhz uint32 // Clock speed of the CPU in MHz
}

func (Cpu) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/services/ben.Cpu"`
}) {
}

func (m *Cpu) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	var4 := (m.Architecture == "")
	if var4 {
		if err := fieldsTarget1.ZeroField("Architecture"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Architecture")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget3.FromString(string(m.Architecture), tt.NonOptional().Field(0).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
				return err
			}
		}
	}
	var7 := (m.Description == "")
	if var7 {
		if err := fieldsTarget1.ZeroField("Description"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Description")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget6.FromString(string(m.Description), tt.NonOptional().Field(1).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
				return err
			}
		}
	}
	var10 := (m.ClockSpeedMhz == uint32(0))
	if var10 {
		if err := fieldsTarget1.ZeroField("ClockSpeedMhz"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("ClockSpeedMhz")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget9.FromUint(uint64(m.ClockSpeedMhz), tt.NonOptional().Field(2).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
				return err
			}
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *Cpu) MakeVDLTarget() vdl.Target {
	return &CpuTarget{Value: m}
}

type CpuTarget struct {
	Value               *Cpu
	architectureTarget  vdl.StringTarget
	descriptionTarget   vdl.StringTarget
	clockSpeedMhzTarget vdl.Uint32Target
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *CpuTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*Cpu)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *CpuTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Architecture":
		t.architectureTarget.Value = &t.Value.Architecture
		target, err := &t.architectureTarget, error(nil)
		return nil, target, err
	case "Description":
		t.descriptionTarget.Value = &t.Value.Description
		target, err := &t.descriptionTarget, error(nil)
		return nil, target, err
	case "ClockSpeedMhz":
		t.clockSpeedMhzTarget.Value = &t.Value.ClockSpeedMhz
		target, err := &t.clockSpeedMhzTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, vdl.ErrFieldNoExist
	}
}
func (t *CpuTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *CpuTarget) ZeroField(name string) error {
	switch name {
	case "Architecture":
		t.Value.Architecture = ""
		return nil
	case "Description":
		t.Value.Description = ""
		return nil
	case "ClockSpeedMhz":
		t.Value.ClockSpeedMhz = uint32(0)
		return nil
	default:
		return vdl.ErrFieldNoExist
	}
}
func (t *CpuTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

func (x Cpu) VDLIsZero() bool {
	return x == Cpu{}
}

func (x Cpu) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*Cpu)(nil)).Elem()); err != nil {
		return err
	}
	if x.Architecture != "" {
		if err := enc.NextField("Architecture"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.StringType); err != nil {
			return err
		}
		if err := enc.EncodeString(x.Architecture); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if x.Description != "" {
		if err := enc.NextField("Description"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.StringType); err != nil {
			return err
		}
		if err := enc.EncodeString(x.Description); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if x.ClockSpeedMhz != 0 {
		if err := enc.NextField("ClockSpeedMhz"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.Uint32Type); err != nil {
			return err
		}
		if err := enc.EncodeUint(uint64(x.ClockSpeedMhz)); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x *Cpu) VDLRead(dec vdl.Decoder) error {
	*x = Cpu{}
	if err := dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
	}
	for {
		f, err := dec.NextField()
		if err != nil {
			return err
		}
		switch f {
		case "":
			return dec.FinishValue()
		case "Architecture":
			if err := dec.StartValue(); err != nil {
				return err
			}
			var err error
			if x.Architecture, err = dec.DecodeString(); err != nil {
				return err
			}
			if err := dec.FinishValue(); err != nil {
				return err
			}
		case "Description":
			if err := dec.StartValue(); err != nil {
				return err
			}
			var err error
			if x.Description, err = dec.DecodeString(); err != nil {
				return err
			}
			if err := dec.FinishValue(); err != nil {
				return err
			}
		case "ClockSpeedMhz":
			if err := dec.StartValue(); err != nil {
				return err
			}
			tmp, err := dec.DecodeUint(32)
			if err != nil {
				return err
			}
			x.ClockSpeedMhz = uint32(tmp)
			if err := dec.FinishValue(); err != nil {
				return err
			}
		default:
			if err := dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

// Os describes the Operating System on which the microbenchmarks were run.
type Os struct {
	Name    string // Short name of the operating system: linux, darwin, android etc.
	Version string // Details of the distribution/version, e.g., "Ubuntu 14.04", "Mac OS X 10.11.2 15C50" etc.
}

func (Os) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/services/ben.Os"`
}) {
}

func (m *Os) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	var4 := (m.Name == "")
	if var4 {
		if err := fieldsTarget1.ZeroField("Name"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Name")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
				return err
			}
		}
	}
	var7 := (m.Version == "")
	if var7 {
		if err := fieldsTarget1.ZeroField("Version"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Version")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget6.FromString(string(m.Version), tt.NonOptional().Field(1).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
				return err
			}
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *Os) MakeVDLTarget() vdl.Target {
	return &OsTarget{Value: m}
}

type OsTarget struct {
	Value         *Os
	nameTarget    vdl.StringTarget
	versionTarget vdl.StringTarget
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *OsTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*Os)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *OsTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Name":
		t.nameTarget.Value = &t.Value.Name
		target, err := &t.nameTarget, error(nil)
		return nil, target, err
	case "Version":
		t.versionTarget.Value = &t.Value.Version
		target, err := &t.versionTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, vdl.ErrFieldNoExist
	}
}
func (t *OsTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *OsTarget) ZeroField(name string) error {
	switch name {
	case "Name":
		t.Value.Name = ""
		return nil
	case "Version":
		t.Value.Version = ""
		return nil
	default:
		return vdl.ErrFieldNoExist
	}
}
func (t *OsTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

func (x Os) VDLIsZero() bool {
	return x == Os{}
}

func (x Os) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*Os)(nil)).Elem()); err != nil {
		return err
	}
	if x.Name != "" {
		if err := enc.NextField("Name"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.StringType); err != nil {
			return err
		}
		if err := enc.EncodeString(x.Name); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if x.Version != "" {
		if err := enc.NextField("Version"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.StringType); err != nil {
			return err
		}
		if err := enc.EncodeString(x.Version); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x *Os) VDLRead(dec vdl.Decoder) error {
	*x = Os{}
	if err := dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
	}
	for {
		f, err := dec.NextField()
		if err != nil {
			return err
		}
		switch f {
		case "":
			return dec.FinishValue()
		case "Name":
			if err := dec.StartValue(); err != nil {
				return err
			}
			var err error
			if x.Name, err = dec.DecodeString(); err != nil {
				return err
			}
			if err := dec.FinishValue(); err != nil {
				return err
			}
		case "Version":
			if err := dec.StartValue(); err != nil {
				return err
			}
			var err error
			if x.Version, err = dec.DecodeString(); err != nil {
				return err
			}
			if err := dec.FinishValue(); err != nil {
				return err
			}
		default:
			if err := dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

// Scenario encapsulates the conditions on the machine on which the microbenchmarks were run.
type Scenario struct {
	Cpu   Cpu
	Os    Os
	Label string // Arbitrary string label assigned by the uploader.
}

func (Scenario) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/services/ben.Scenario"`
}) {
}

func (m *Scenario) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	var4 := (m.Cpu == Cpu{})
	if var4 {
		if err := fieldsTarget1.ZeroField("Cpu"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Cpu")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			if err := m.Cpu.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
				return err
			}
		}
	}
	var7 := (m.Os == Os{})
	if var7 {
		if err := fieldsTarget1.ZeroField("Os"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Os")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			if err := m.Os.FillVDLTarget(fieldTarget6, tt.NonOptional().Field(1).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
				return err
			}
		}
	}
	var10 := (m.Label == "")
	if var10 {
		if err := fieldsTarget1.ZeroField("Label"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Label")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget9.FromString(string(m.Label), tt.NonOptional().Field(2).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
				return err
			}
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *Scenario) MakeVDLTarget() vdl.Target {
	return &ScenarioTarget{Value: m}
}

type ScenarioTarget struct {
	Value       *Scenario
	cpuTarget   CpuTarget
	osTarget    OsTarget
	labelTarget vdl.StringTarget
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *ScenarioTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*Scenario)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *ScenarioTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Cpu":
		t.cpuTarget.Value = &t.Value.Cpu
		target, err := &t.cpuTarget, error(nil)
		return nil, target, err
	case "Os":
		t.osTarget.Value = &t.Value.Os
		target, err := &t.osTarget, error(nil)
		return nil, target, err
	case "Label":
		t.labelTarget.Value = &t.Value.Label
		target, err := &t.labelTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, vdl.ErrFieldNoExist
	}
}
func (t *ScenarioTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *ScenarioTarget) ZeroField(name string) error {
	switch name {
	case "Cpu":
		t.Value.Cpu = Cpu{}
		return nil
	case "Os":
		t.Value.Os = Os{}
		return nil
	case "Label":
		t.Value.Label = ""
		return nil
	default:
		return vdl.ErrFieldNoExist
	}
}
func (t *ScenarioTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

func (x Scenario) VDLIsZero() bool {
	return x == Scenario{}
}

func (x Scenario) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*Scenario)(nil)).Elem()); err != nil {
		return err
	}
	if x.Cpu != (Cpu{}) {
		if err := enc.NextField("Cpu"); err != nil {
			return err
		}
		if err := x.Cpu.VDLWrite(enc); err != nil {
			return err
		}
	}
	if x.Os != (Os{}) {
		if err := enc.NextField("Os"); err != nil {
			return err
		}
		if err := x.Os.VDLWrite(enc); err != nil {
			return err
		}
	}
	if x.Label != "" {
		if err := enc.NextField("Label"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.StringType); err != nil {
			return err
		}
		if err := enc.EncodeString(x.Label); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x *Scenario) VDLRead(dec vdl.Decoder) error {
	*x = Scenario{}
	if err := dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
	}
	for {
		f, err := dec.NextField()
		if err != nil {
			return err
		}
		switch f {
		case "":
			return dec.FinishValue()
		case "Cpu":
			if err := x.Cpu.VDLRead(dec); err != nil {
				return err
			}
		case "Os":
			if err := x.Os.VDLRead(dec); err != nil {
				return err
			}
		case "Label":
			if err := dec.StartValue(); err != nil {
				return err
			}
			var err error
			if x.Label, err = dec.DecodeString(); err != nil {
				return err
			}
			if err := dec.FinishValue(); err != nil {
				return err
			}
		default:
			if err := dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

// SourceCode represents the state of the source code used to build the
// microbenchmarks.
//
// Typically it would be the commit hash of a git repository or the contents of
// a manifest of a jiri (https://github.com/vanadium/go.jiri) project and not
// the complete source code itself.
type SourceCode string

func (SourceCode) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/services/ben.SourceCode"`
}) {
}

func (m *SourceCode) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if err := t.FromString(string((*m)), tt); err != nil {
		return err
	}
	return nil
}

func (m *SourceCode) MakeVDLTarget() vdl.Target {
	return &SourceCodeTarget{Value: m}
}

type SourceCodeTarget struct {
	Value *SourceCode
	vdl.TargetBase
}

func (t *SourceCodeTarget) FromString(src string, tt *vdl.Type) error {

	if ttWant := vdl.TypeOf((*SourceCode)(nil)); !vdl.Compatible(tt, ttWant) {
		return fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = SourceCode(src)

	return nil
}

func (x SourceCode) VDLIsZero() bool {
	return x == ""
}

func (x SourceCode) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*SourceCode)(nil))); err != nil {
		return err
	}
	if err := enc.EncodeString(string(x)); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x *SourceCode) VDLRead(dec vdl.Decoder) error {
	if err := dec.StartValue(); err != nil {
		return err
	}
	tmp, err := dec.DecodeString()
	if err != nil {
		return err
	}
	*x = SourceCode(tmp)
	return dec.FinishValue()
}

// Run encapsulates the results of a single microbenchmark run.
type Run struct {
	Name              string // Name of the microbenchmark. <package>.Benchmark<Name> in Go.
	Iterations        uint64
	NanoSecsPerOp     float64 // Nano-seconds per iteration.
	AllocsPerOp       uint64  // Memory allocations per iteration.
	AllocedBytesPerOp uint64  // Size of memory allocations per iteration.
	MegaBytesPerSec   float64 // Throughput in MB/s.
	Parallelism       uint32  // For Go, the GOMAXPROCS used during benchmark execution
}

func (Run) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/services/ben.Run"`
}) {
}

func (m *Run) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	var4 := (m.Name == "")
	if var4 {
		if err := fieldsTarget1.ZeroField("Name"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Name")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
				return err
			}
		}
	}
	var7 := (m.Iterations == uint64(0))
	if var7 {
		if err := fieldsTarget1.ZeroField("Iterations"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Iterations")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget6.FromUint(uint64(m.Iterations), tt.NonOptional().Field(1).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
				return err
			}
		}
	}
	var10 := (m.NanoSecsPerOp == float64(0))
	if var10 {
		if err := fieldsTarget1.ZeroField("NanoSecsPerOp"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("NanoSecsPerOp")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget9.FromFloat(float64(m.NanoSecsPerOp), tt.NonOptional().Field(2).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
				return err
			}
		}
	}
	var13 := (m.AllocsPerOp == uint64(0))
	if var13 {
		if err := fieldsTarget1.ZeroField("AllocsPerOp"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("AllocsPerOp")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget12.FromUint(uint64(m.AllocsPerOp), tt.NonOptional().Field(3).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
				return err
			}
		}
	}
	var16 := (m.AllocedBytesPerOp == uint64(0))
	if var16 {
		if err := fieldsTarget1.ZeroField("AllocedBytesPerOp"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget14, fieldTarget15, err := fieldsTarget1.StartField("AllocedBytesPerOp")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget15.FromUint(uint64(m.AllocedBytesPerOp), tt.NonOptional().Field(4).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget14, fieldTarget15); err != nil {
				return err
			}
		}
	}
	var19 := (m.MegaBytesPerSec == float64(0))
	if var19 {
		if err := fieldsTarget1.ZeroField("MegaBytesPerSec"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget17, fieldTarget18, err := fieldsTarget1.StartField("MegaBytesPerSec")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget18.FromFloat(float64(m.MegaBytesPerSec), tt.NonOptional().Field(5).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget17, fieldTarget18); err != nil {
				return err
			}
		}
	}
	var22 := (m.Parallelism == uint32(0))
	if var22 {
		if err := fieldsTarget1.ZeroField("Parallelism"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget20, fieldTarget21, err := fieldsTarget1.StartField("Parallelism")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget21.FromUint(uint64(m.Parallelism), tt.NonOptional().Field(6).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget20, fieldTarget21); err != nil {
				return err
			}
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *Run) MakeVDLTarget() vdl.Target {
	return &RunTarget{Value: m}
}

type RunTarget struct {
	Value                   *Run
	nameTarget              vdl.StringTarget
	iterationsTarget        vdl.Uint64Target
	nanoSecsPerOpTarget     vdl.Float64Target
	allocsPerOpTarget       vdl.Uint64Target
	allocedBytesPerOpTarget vdl.Uint64Target
	megaBytesPerSecTarget   vdl.Float64Target
	parallelismTarget       vdl.Uint32Target
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *RunTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*Run)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *RunTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Name":
		t.nameTarget.Value = &t.Value.Name
		target, err := &t.nameTarget, error(nil)
		return nil, target, err
	case "Iterations":
		t.iterationsTarget.Value = &t.Value.Iterations
		target, err := &t.iterationsTarget, error(nil)
		return nil, target, err
	case "NanoSecsPerOp":
		t.nanoSecsPerOpTarget.Value = &t.Value.NanoSecsPerOp
		target, err := &t.nanoSecsPerOpTarget, error(nil)
		return nil, target, err
	case "AllocsPerOp":
		t.allocsPerOpTarget.Value = &t.Value.AllocsPerOp
		target, err := &t.allocsPerOpTarget, error(nil)
		return nil, target, err
	case "AllocedBytesPerOp":
		t.allocedBytesPerOpTarget.Value = &t.Value.AllocedBytesPerOp
		target, err := &t.allocedBytesPerOpTarget, error(nil)
		return nil, target, err
	case "MegaBytesPerSec":
		t.megaBytesPerSecTarget.Value = &t.Value.MegaBytesPerSec
		target, err := &t.megaBytesPerSecTarget, error(nil)
		return nil, target, err
	case "Parallelism":
		t.parallelismTarget.Value = &t.Value.Parallelism
		target, err := &t.parallelismTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, vdl.ErrFieldNoExist
	}
}
func (t *RunTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *RunTarget) ZeroField(name string) error {
	switch name {
	case "Name":
		t.Value.Name = ""
		return nil
	case "Iterations":
		t.Value.Iterations = uint64(0)
		return nil
	case "NanoSecsPerOp":
		t.Value.NanoSecsPerOp = float64(0)
		return nil
	case "AllocsPerOp":
		t.Value.AllocsPerOp = uint64(0)
		return nil
	case "AllocedBytesPerOp":
		t.Value.AllocedBytesPerOp = uint64(0)
		return nil
	case "MegaBytesPerSec":
		t.Value.MegaBytesPerSec = float64(0)
		return nil
	case "Parallelism":
		t.Value.Parallelism = uint32(0)
		return nil
	default:
		return vdl.ErrFieldNoExist
	}
}
func (t *RunTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

func (x Run) VDLIsZero() bool {
	return x == Run{}
}

func (x Run) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*Run)(nil)).Elem()); err != nil {
		return err
	}
	if x.Name != "" {
		if err := enc.NextField("Name"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.StringType); err != nil {
			return err
		}
		if err := enc.EncodeString(x.Name); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if x.Iterations != 0 {
		if err := enc.NextField("Iterations"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.Uint64Type); err != nil {
			return err
		}
		if err := enc.EncodeUint(x.Iterations); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if x.NanoSecsPerOp != 0 {
		if err := enc.NextField("NanoSecsPerOp"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.Float64Type); err != nil {
			return err
		}
		if err := enc.EncodeFloat(x.NanoSecsPerOp); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if x.AllocsPerOp != 0 {
		if err := enc.NextField("AllocsPerOp"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.Uint64Type); err != nil {
			return err
		}
		if err := enc.EncodeUint(x.AllocsPerOp); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if x.AllocedBytesPerOp != 0 {
		if err := enc.NextField("AllocedBytesPerOp"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.Uint64Type); err != nil {
			return err
		}
		if err := enc.EncodeUint(x.AllocedBytesPerOp); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if x.MegaBytesPerSec != 0 {
		if err := enc.NextField("MegaBytesPerSec"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.Float64Type); err != nil {
			return err
		}
		if err := enc.EncodeFloat(x.MegaBytesPerSec); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if x.Parallelism != 0 {
		if err := enc.NextField("Parallelism"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.Uint32Type); err != nil {
			return err
		}
		if err := enc.EncodeUint(uint64(x.Parallelism)); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x *Run) VDLRead(dec vdl.Decoder) error {
	*x = Run{}
	if err := dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
	}
	for {
		f, err := dec.NextField()
		if err != nil {
			return err
		}
		switch f {
		case "":
			return dec.FinishValue()
		case "Name":
			if err := dec.StartValue(); err != nil {
				return err
			}
			var err error
			if x.Name, err = dec.DecodeString(); err != nil {
				return err
			}
			if err := dec.FinishValue(); err != nil {
				return err
			}
		case "Iterations":
			if err := dec.StartValue(); err != nil {
				return err
			}
			var err error
			if x.Iterations, err = dec.DecodeUint(64); err != nil {
				return err
			}
			if err := dec.FinishValue(); err != nil {
				return err
			}
		case "NanoSecsPerOp":
			if err := dec.StartValue(); err != nil {
				return err
			}
			var err error
			if x.NanoSecsPerOp, err = dec.DecodeFloat(64); err != nil {
				return err
			}
			if err := dec.FinishValue(); err != nil {
				return err
			}
		case "AllocsPerOp":
			if err := dec.StartValue(); err != nil {
				return err
			}
			var err error
			if x.AllocsPerOp, err = dec.DecodeUint(64); err != nil {
				return err
			}
			if err := dec.FinishValue(); err != nil {
				return err
			}
		case "AllocedBytesPerOp":
			if err := dec.StartValue(); err != nil {
				return err
			}
			var err error
			if x.AllocedBytesPerOp, err = dec.DecodeUint(64); err != nil {
				return err
			}
			if err := dec.FinishValue(); err != nil {
				return err
			}
		case "MegaBytesPerSec":
			if err := dec.StartValue(); err != nil {
				return err
			}
			var err error
			if x.MegaBytesPerSec, err = dec.DecodeFloat(64); err != nil {
				return err
			}
			if err := dec.FinishValue(); err != nil {
				return err
			}
		case "Parallelism":
			if err := dec.StartValue(); err != nil {
				return err
			}
			tmp, err := dec.DecodeUint(32)
			if err != nil {
				return err
			}
			x.Parallelism = uint32(tmp)
			if err := dec.FinishValue(); err != nil {
				return err
			}
		default:
			if err := dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

var __VDLInitCalled bool

// __VDLInit performs vdl initialization.  It is safe to call multiple times.
// If you have an init ordering issue, just insert the following line verbatim
// into your source files in this package, right after the "package foo" clause:
//
//    var _ = __VDLInit()
//
// The purpose of this function is to ensure that vdl initialization occurs in
// the right order, and very early in the init sequence.  In particular, vdl
// registration and package variable initialization needs to occur before
// functions like vdl.TypeOf will work properly.
//
// This function returns a dummy value, so that it can be used to initialize the
// first var in the file, to take advantage of Go's defined init order.
func __VDLInit() struct{} {
	if __VDLInitCalled {
		return struct{}{}
	}
	__VDLInitCalled = true

	// Register types.
	vdl.Register((*Cpu)(nil))
	vdl.Register((*Os)(nil))
	vdl.Register((*Scenario)(nil))
	vdl.Register((*SourceCode)(nil))
	vdl.Register((*Run)(nil))

	return struct{}{}
}