services/ben/ben.vdl.go - release.go.x.ref - Git at Google

 // 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
 	}

 	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Architecture")
 	if err != vdl.ErrFieldNoExist && err != nil {
 		return err
 	}
 	if err != vdl.ErrFieldNoExist {
 		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
 		}
 	}
 	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Description")
 	if err != vdl.ErrFieldNoExist && err != nil {
 		return err
 	}
 	if err != vdl.ErrFieldNoExist {
 		if err := fieldTarget5.FromString(string(m.Description), tt.NonOptional().Field(1).Type); err != nil {
 			return err
 		}
 		if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
 			return err
 		}
 	}
 	keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("ClockSpeedMhz")
 	if err != vdl.ErrFieldNoExist && err != nil {
 		return err
 	}
 	if err != vdl.ErrFieldNoExist {
 		if err := fieldTarget7.FromUint(uint64(m.ClockSpeedMhz), tt.NonOptional().Field(2).Type); err != nil {
 			return err
 		}
 		if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); 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, fmt.Errorf("field %s not in struct v.io/x/ref/services/ben.Cpu", name)
 	}
 }
 func (t *CpuTarget) FinishField(_, _ vdl.Target) error {
 	return nil
 }
 func (t *CpuTarget) FinishFields(_ vdl.FieldsTarget) error {

 	return nil
 }

 // 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
 	}

 	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Name")
 	if err != vdl.ErrFieldNoExist && err != nil {
 		return err
 	}
 	if err != vdl.ErrFieldNoExist {
 		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
 		}
 	}
 	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Version")
 	if err != vdl.ErrFieldNoExist && err != nil {
 		return err
 	}
 	if err != vdl.ErrFieldNoExist {
 		if err := fieldTarget5.FromString(string(m.Version), tt.NonOptional().Field(1).Type); err != nil {
 			return err
 		}
 		if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); 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, fmt.Errorf("field %s not in struct v.io/x/ref/services/ben.Os", name)
 	}
 }
 func (t *OsTarget) FinishField(_, _ vdl.Target) error {
 	return nil
 }
 func (t *OsTarget) FinishFields(_ vdl.FieldsTarget) error {

 	return nil
 }

 // 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
 	}

 	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Cpu")
 	if err != vdl.ErrFieldNoExist && err != nil {
 		return err
 	}
 	if err != vdl.ErrFieldNoExist {

 		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
 		}
 	}
 	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Os")
 	if err != vdl.ErrFieldNoExist && err != nil {
 		return err
 	}
 	if err != vdl.ErrFieldNoExist {

 		if err := m.Os.FillVDLTarget(fieldTarget5, tt.NonOptional().Field(1).Type); err != nil {
 			return err
 		}
 		if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
 			return err
 		}
 	}
 	keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("Label")
 	if err != vdl.ErrFieldNoExist && err != nil {
 		return err
 	}
 	if err != vdl.ErrFieldNoExist {
 		if err := fieldTarget7.FromString(string(m.Label), tt.NonOptional().Field(2).Type); err != nil {
 			return err
 		}
 		if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); 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, fmt.Errorf("field %s not in struct v.io/x/ref/services/ben.Scenario", name)
 	}
 }
 func (t *ScenarioTarget) FinishField(_, _ vdl.Target) error {
 	return nil
 }
 func (t *ScenarioTarget) FinishFields(_ vdl.FieldsTarget) error {

 	return nil
 }

 // 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
 }

 // 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
 	}

 	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Name")
 	if err != vdl.ErrFieldNoExist && err != nil {
 		return err
 	}
 	if err != vdl.ErrFieldNoExist {
 		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
 		}
 	}
 	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Iterations")
 	if err != vdl.ErrFieldNoExist && err != nil {
 		return err
 	}
 	if err != vdl.ErrFieldNoExist {
 		if err := fieldTarget5.FromUint(uint64(m.Iterations), tt.NonOptional().Field(1).Type); err != nil {
 			return err
 		}
 		if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
 			return err
 		}
 	}
 	keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("NanoSecsPerOp")
 	if err != vdl.ErrFieldNoExist && err != nil {
 		return err
 	}
 	if err != vdl.ErrFieldNoExist {
 		if err := fieldTarget7.FromFloat(float64(m.NanoSecsPerOp), tt.NonOptional().Field(2).Type); err != nil {
 			return err
 		}
 		if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
 			return err
 		}
 	}
 	keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("AllocsPerOp")
 	if err != vdl.ErrFieldNoExist && err != nil {
 		return err
 	}
 	if err != vdl.ErrFieldNoExist {
 		if err := fieldTarget9.FromUint(uint64(m.AllocsPerOp), tt.NonOptional().Field(3).Type); err != nil {
 			return err
 		}
 		if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
 			return err
 		}
 	}
 	keyTarget10, fieldTarget11, err := fieldsTarget1.StartField("AllocedBytesPerOp")
 	if err != vdl.ErrFieldNoExist && err != nil {
 		return err
 	}
 	if err != vdl.ErrFieldNoExist {
 		if err := fieldTarget11.FromUint(uint64(m.AllocedBytesPerOp), tt.NonOptional().Field(4).Type); err != nil {
 			return err
 		}
 		if err := fieldsTarget1.FinishField(keyTarget10, fieldTarget11); err != nil {
 			return err
 		}
 	}
 	keyTarget12, fieldTarget13, err := fieldsTarget1.StartField("MegaBytesPerSec")
 	if err != vdl.ErrFieldNoExist && err != nil {
 		return err
 	}
 	if err != vdl.ErrFieldNoExist {
 		if err := fieldTarget13.FromFloat(float64(m.MegaBytesPerSec), tt.NonOptional().Field(5).Type); err != nil {
 			return err
 		}
 		if err := fieldsTarget1.FinishField(keyTarget12, fieldTarget13); err != nil {
 			return err
 		}
 	}
 	keyTarget14, fieldTarget15, err := fieldsTarget1.StartField("Parallelism")
 	if err != vdl.ErrFieldNoExist && err != nil {
 		return err
 	}
 	if err != vdl.ErrFieldNoExist {
 		if err := fieldTarget15.FromUint(uint64(m.Parallelism), tt.NonOptional().Field(6).Type); err != nil {
 			return err
 		}
 		if err := fieldsTarget1.FinishField(keyTarget14, fieldTarget15); 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, fmt.Errorf("field %s not in struct v.io/x/ref/services/ben.Run", name)
 	}
 }
 func (t *RunTarget) FinishField(_, _ vdl.Target) error {
 	return nil
 }
 func (t *RunTarget) FinishFields(_ vdl.FieldsTarget) error {

 	return nil
 }

 // Create zero values for each type.
 var (
 	__VDLZeroCpu        = Cpu{}
 	__VDLZeroOs         = Os{}
 	__VDLZeroScenario   = Scenario{}
 	__VDLZeroSourceCode = SourceCode("")
 	__VDLZeroRun        = Run{}
 )

 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{}{}
 	}

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

 	return struct{}{}
 }
	// 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
	}

	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Architecture")
	if err != vdl.ErrFieldNoExist && err != nil {
	return err
	}
	if err != vdl.ErrFieldNoExist {
	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
	}
	}
	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Description")
	if err != vdl.ErrFieldNoExist && err != nil {
	return err
	}
	if err != vdl.ErrFieldNoExist {
	if err := fieldTarget5.FromString(string(m.Description), tt.NonOptional().Field(1).Type); err != nil {
	return err
	}
	if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
	return err
	}
	}
	keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("ClockSpeedMhz")
	if err != vdl.ErrFieldNoExist && err != nil {
	return err
	}
	if err != vdl.ErrFieldNoExist {
	if err := fieldTarget7.FromUint(uint64(m.ClockSpeedMhz), tt.NonOptional().Field(2).Type); err != nil {
	return err
	}
	if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); 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, fmt.Errorf("field %s not in struct v.io/x/ref/services/ben.Cpu", name)
	}
	}
	func (t *CpuTarget) FinishField(_, _ vdl.Target) error {
	return nil
	}
	func (t *CpuTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
	}

	// 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
	}

	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Name")
	if err != vdl.ErrFieldNoExist && err != nil {
	return err
	}
	if err != vdl.ErrFieldNoExist {
	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
	}
	}
	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Version")
	if err != vdl.ErrFieldNoExist && err != nil {
	return err
	}
	if err != vdl.ErrFieldNoExist {
	if err := fieldTarget5.FromString(string(m.Version), tt.NonOptional().Field(1).Type); err != nil {
	return err
	}
	if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); 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, fmt.Errorf("field %s not in struct v.io/x/ref/services/ben.Os", name)
	}
	}
	func (t *OsTarget) FinishField(_, _ vdl.Target) error {
	return nil
	}
	func (t *OsTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
	}

	// 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
	}

	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Cpu")
	if err != vdl.ErrFieldNoExist && err != nil {
	return err
	}
	if err != vdl.ErrFieldNoExist {

	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
	}
	}
	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Os")
	if err != vdl.ErrFieldNoExist && err != nil {
	return err
	}
	if err != vdl.ErrFieldNoExist {

	if err := m.Os.FillVDLTarget(fieldTarget5, tt.NonOptional().Field(1).Type); err != nil {
	return err
	}
	if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
	return err
	}
	}
	keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("Label")
	if err != vdl.ErrFieldNoExist && err != nil {
	return err
	}
	if err != vdl.ErrFieldNoExist {
	if err := fieldTarget7.FromString(string(m.Label), tt.NonOptional().Field(2).Type); err != nil {
	return err
	}
	if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); 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, fmt.Errorf("field %s not in struct v.io/x/ref/services/ben.Scenario", name)
	}
	}
	func (t *ScenarioTarget) FinishField(_, _ vdl.Target) error {
	return nil
	}
	func (t *ScenarioTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
	}

	// 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
	}

	// 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
	}

	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Name")
	if err != vdl.ErrFieldNoExist && err != nil {
	return err
	}
	if err != vdl.ErrFieldNoExist {
	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
	}
	}
	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Iterations")
	if err != vdl.ErrFieldNoExist && err != nil {
	return err
	}
	if err != vdl.ErrFieldNoExist {
	if err := fieldTarget5.FromUint(uint64(m.Iterations), tt.NonOptional().Field(1).Type); err != nil {
	return err
	}
	if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
	return err
	}
	}
	keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("NanoSecsPerOp")
	if err != vdl.ErrFieldNoExist && err != nil {
	return err
	}
	if err != vdl.ErrFieldNoExist {
	if err := fieldTarget7.FromFloat(float64(m.NanoSecsPerOp), tt.NonOptional().Field(2).Type); err != nil {
	return err
	}
	if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
	return err
	}
	}
	keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("AllocsPerOp")
	if err != vdl.ErrFieldNoExist && err != nil {
	return err
	}
	if err != vdl.ErrFieldNoExist {
	if err := fieldTarget9.FromUint(uint64(m.AllocsPerOp), tt.NonOptional().Field(3).Type); err != nil {
	return err
	}
	if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
	return err
	}
	}
	keyTarget10, fieldTarget11, err := fieldsTarget1.StartField("AllocedBytesPerOp")
	if err != vdl.ErrFieldNoExist && err != nil {
	return err
	}
	if err != vdl.ErrFieldNoExist {
	if err := fieldTarget11.FromUint(uint64(m.AllocedBytesPerOp), tt.NonOptional().Field(4).Type); err != nil {
	return err
	}
	if err := fieldsTarget1.FinishField(keyTarget10, fieldTarget11); err != nil {
	return err
	}
	}
	keyTarget12, fieldTarget13, err := fieldsTarget1.StartField("MegaBytesPerSec")
	if err != vdl.ErrFieldNoExist && err != nil {
	return err
	}
	if err != vdl.ErrFieldNoExist {
	if err := fieldTarget13.FromFloat(float64(m.MegaBytesPerSec), tt.NonOptional().Field(5).Type); err != nil {
	return err
	}
	if err := fieldsTarget1.FinishField(keyTarget12, fieldTarget13); err != nil {
	return err
	}
	}
	keyTarget14, fieldTarget15, err := fieldsTarget1.StartField("Parallelism")
	if err != vdl.ErrFieldNoExist && err != nil {
	return err
	}
	if err != vdl.ErrFieldNoExist {
	if err := fieldTarget15.FromUint(uint64(m.Parallelism), tt.NonOptional().Field(6).Type); err != nil {
	return err
	}
	if err := fieldsTarget1.FinishField(keyTarget14, fieldTarget15); 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, fmt.Errorf("field %s not in struct v.io/x/ref/services/ben.Run", name)
	}
	}
	func (t *RunTarget) FinishField(_, _ vdl.Target) error {
	return nil
	}
	func (t *RunTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
	}

	// Create zero values for each type.
	var (
	__VDLZeroCpu = Cpu{}
	__VDLZeroOs = Os{}
	__VDLZeroScenario = Scenario{}
	__VDLZeroSourceCode = SourceCode("")
	__VDLZeroRun = Run{}
	)

	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{}{}
	}

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

	return struct{}{}
	}