services/pprof/pprof.vdl.go - release.go.v23 - 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: pprof

 // Package pprof defines an interface for accessing runtime profiling data in
 // the format expected by the pprof visualization tool.  For more information
 // about pprof, see http://code.google.com/p/google-perftools/.
 package pprof

 import (
 	"io"
 	"v.io/v23"
 	"v.io/v23/context"
 	"v.io/v23/rpc"
 	"v.io/v23/security/access"
 	"v.io/v23/vdl"
 )

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

 //////////////////////////////////////////////////
 // Interface definitions

 // PProfClientMethods is the client interface
 // containing PProf methods.
 type PProfClientMethods interface {
 	// CmdLine returns the command-line arguments of the server, including
 	// the name of the executable.
 	CmdLine(*context.T, ...rpc.CallOpt) ([]string, error)
 	// Profiles returns the list of available profiles.
 	Profiles(*context.T, ...rpc.CallOpt) ([]string, error)
 	// Profile streams the requested profile. The debug parameter enables
 	// additional output. Passing debug=0 includes only the hexadecimal
 	// addresses that pprof needs. Passing debug=1 adds comments translating
 	// addresses to function names and line numbers, so that a programmer
 	// can read the profile without tools.
 	Profile(_ *context.T, name string, debug int32, _ ...rpc.CallOpt) (PProfProfileClientCall, error)
 	// CpuProfile enables CPU profiling for the requested duration and
 	// streams the profile data.
 	CpuProfile(_ *context.T, seconds int32, _ ...rpc.CallOpt) (PProfCpuProfileClientCall, error)
 	// Symbol looks up the program counters and returns their respective
 	// function names.
 	Symbol(_ *context.T, programCounters []uint64, _ ...rpc.CallOpt) ([]string, error)
 }

 // PProfClientStub adds universal methods to PProfClientMethods.
 type PProfClientStub interface {
 	PProfClientMethods
 	rpc.UniversalServiceMethods
 }

 // PProfClient returns a client stub for PProf.
 func PProfClient(name string) PProfClientStub {
 	return implPProfClientStub{name}
 }

 type implPProfClientStub struct {
 	name string
 }

 func (c implPProfClientStub) CmdLine(ctx *context.T, opts ...rpc.CallOpt) (o0 []string, err error) {
 	err = v23.GetClient(ctx).Call(ctx, c.name, "CmdLine", nil, []interface{}{&o0}, opts...)
 	return
 }

 func (c implPProfClientStub) Profiles(ctx *context.T, opts ...rpc.CallOpt) (o0 []string, err error) {
 	err = v23.GetClient(ctx).Call(ctx, c.name, "Profiles", nil, []interface{}{&o0}, opts...)
 	return
 }

 func (c implPProfClientStub) Profile(ctx *context.T, i0 string, i1 int32, opts ...rpc.CallOpt) (ocall PProfProfileClientCall, err error) {
 	var call rpc.ClientCall
 	if call, err = v23.GetClient(ctx).StartCall(ctx, c.name, "Profile", []interface{}{i0, i1}, opts...); err != nil {
 		return
 	}
 	ocall = &implPProfProfileClientCall{ClientCall: call}
 	return
 }

 func (c implPProfClientStub) CpuProfile(ctx *context.T, i0 int32, opts ...rpc.CallOpt) (ocall PProfCpuProfileClientCall, err error) {
 	var call rpc.ClientCall
 	if call, err = v23.GetClient(ctx).StartCall(ctx, c.name, "CpuProfile", []interface{}{i0}, opts...); err != nil {
 		return
 	}
 	ocall = &implPProfCpuProfileClientCall{ClientCall: call}
 	return
 }

 func (c implPProfClientStub) Symbol(ctx *context.T, i0 []uint64, opts ...rpc.CallOpt) (o0 []string, err error) {
 	err = v23.GetClient(ctx).Call(ctx, c.name, "Symbol", []interface{}{i0}, []interface{}{&o0}, opts...)
 	return
 }

 // PProfProfileClientStream is the client stream for PProf.Profile.
 type PProfProfileClientStream interface {
 	// RecvStream returns the receiver side of the PProf.Profile client stream.
 	RecvStream() interface {
 		// Advance stages an item so that it may be retrieved via Value.  Returns
 		// true iff there is an item to retrieve.  Advance must be called before
 		// Value is called.  May block if an item is not available.
 		Advance() bool
 		// Value returns the item that was staged by Advance.  May panic if Advance
 		// returned false or was not called.  Never blocks.
 		Value() []byte
 		// Err returns any error encountered by Advance.  Never blocks.
 		Err() error
 	}
 }

 // PProfProfileClientCall represents the call returned from PProf.Profile.
 type PProfProfileClientCall interface {
 	PProfProfileClientStream
 	// Finish blocks until the server is done, and returns the positional return
 	// values for call.
 	//
 	// Finish returns immediately if the call has been canceled; depending on the
 	// timing the output could either be an error signaling cancelation, or the
 	// valid positional return values from the server.
 	//
 	// Calling Finish is mandatory for releasing stream resources, unless the call
 	// has been canceled or any of the other methods return an error.  Finish should
 	// be called at most once.
 	Finish() error
 }

 type implPProfProfileClientCall struct {
 	rpc.ClientCall
 	valRecv []byte
 	errRecv error
 }

 func (c *implPProfProfileClientCall) RecvStream() interface {
 	Advance() bool
 	Value() []byte
 	Err() error
 } {
 	return implPProfProfileClientCallRecv{c}
 }

 type implPProfProfileClientCallRecv struct {
 	c *implPProfProfileClientCall
 }

 func (c implPProfProfileClientCallRecv) Advance() bool {
 	c.c.errRecv = c.c.Recv(&c.c.valRecv)
 	return c.c.errRecv == nil
 }
 func (c implPProfProfileClientCallRecv) Value() []byte {
 	return c.c.valRecv
 }
 func (c implPProfProfileClientCallRecv) Err() error {
 	if c.c.errRecv == io.EOF {
 		return nil
 	}
 	return c.c.errRecv
 }
 func (c *implPProfProfileClientCall) Finish() (err error) {
 	err = c.ClientCall.Finish()
 	return
 }

 // PProfCpuProfileClientStream is the client stream for PProf.CpuProfile.
 type PProfCpuProfileClientStream interface {
 	// RecvStream returns the receiver side of the PProf.CpuProfile client stream.
 	RecvStream() interface {
 		// Advance stages an item so that it may be retrieved via Value.  Returns
 		// true iff there is an item to retrieve.  Advance must be called before
 		// Value is called.  May block if an item is not available.
 		Advance() bool
 		// Value returns the item that was staged by Advance.  May panic if Advance
 		// returned false or was not called.  Never blocks.
 		Value() []byte
 		// Err returns any error encountered by Advance.  Never blocks.
 		Err() error
 	}
 }

 // PProfCpuProfileClientCall represents the call returned from PProf.CpuProfile.
 type PProfCpuProfileClientCall interface {
 	PProfCpuProfileClientStream
 	// Finish blocks until the server is done, and returns the positional return
 	// values for call.
 	//
 	// Finish returns immediately if the call has been canceled; depending on the
 	// timing the output could either be an error signaling cancelation, or the
 	// valid positional return values from the server.
 	//
 	// Calling Finish is mandatory for releasing stream resources, unless the call
 	// has been canceled or any of the other methods return an error.  Finish should
 	// be called at most once.
 	Finish() error
 }

 type implPProfCpuProfileClientCall struct {
 	rpc.ClientCall
 	valRecv []byte
 	errRecv error
 }

 func (c *implPProfCpuProfileClientCall) RecvStream() interface {
 	Advance() bool
 	Value() []byte
 	Err() error
 } {
 	return implPProfCpuProfileClientCallRecv{c}
 }

 type implPProfCpuProfileClientCallRecv struct {
 	c *implPProfCpuProfileClientCall
 }

 func (c implPProfCpuProfileClientCallRecv) Advance() bool {
 	c.c.errRecv = c.c.Recv(&c.c.valRecv)
 	return c.c.errRecv == nil
 }
 func (c implPProfCpuProfileClientCallRecv) Value() []byte {
 	return c.c.valRecv
 }
 func (c implPProfCpuProfileClientCallRecv) Err() error {
 	if c.c.errRecv == io.EOF {
 		return nil
 	}
 	return c.c.errRecv
 }
 func (c *implPProfCpuProfileClientCall) Finish() (err error) {
 	err = c.ClientCall.Finish()
 	return
 }

 // PProfServerMethods is the interface a server writer
 // implements for PProf.
 type PProfServerMethods interface {
 	// CmdLine returns the command-line arguments of the server, including
 	// the name of the executable.
 	CmdLine(*context.T, rpc.ServerCall) ([]string, error)
 	// Profiles returns the list of available profiles.
 	Profiles(*context.T, rpc.ServerCall) ([]string, error)
 	// Profile streams the requested profile. The debug parameter enables
 	// additional output. Passing debug=0 includes only the hexadecimal
 	// addresses that pprof needs. Passing debug=1 adds comments translating
 	// addresses to function names and line numbers, so that a programmer
 	// can read the profile without tools.
 	Profile(_ *context.T, _ PProfProfileServerCall, name string, debug int32) error
 	// CpuProfile enables CPU profiling for the requested duration and
 	// streams the profile data.
 	CpuProfile(_ *context.T, _ PProfCpuProfileServerCall, seconds int32) error
 	// Symbol looks up the program counters and returns their respective
 	// function names.
 	Symbol(_ *context.T, _ rpc.ServerCall, programCounters []uint64) ([]string, error)
 }

 // PProfServerStubMethods is the server interface containing
 // PProf methods, as expected by rpc.Server.
 // The only difference between this interface and PProfServerMethods
 // is the streaming methods.
 type PProfServerStubMethods interface {
 	// CmdLine returns the command-line arguments of the server, including
 	// the name of the executable.
 	CmdLine(*context.T, rpc.ServerCall) ([]string, error)
 	// Profiles returns the list of available profiles.
 	Profiles(*context.T, rpc.ServerCall) ([]string, error)
 	// Profile streams the requested profile. The debug parameter enables
 	// additional output. Passing debug=0 includes only the hexadecimal
 	// addresses that pprof needs. Passing debug=1 adds comments translating
 	// addresses to function names and line numbers, so that a programmer
 	// can read the profile without tools.
 	Profile(_ *context.T, _ *PProfProfileServerCallStub, name string, debug int32) error
 	// CpuProfile enables CPU profiling for the requested duration and
 	// streams the profile data.
 	CpuProfile(_ *context.T, _ *PProfCpuProfileServerCallStub, seconds int32) error
 	// Symbol looks up the program counters and returns their respective
 	// function names.
 	Symbol(_ *context.T, _ rpc.ServerCall, programCounters []uint64) ([]string, error)
 }

 // PProfServerStub adds universal methods to PProfServerStubMethods.
 type PProfServerStub interface {
 	PProfServerStubMethods
 	// Describe the PProf interfaces.
 	Describe__() []rpc.InterfaceDesc
 }

 // PProfServer returns a server stub for PProf.
 // It converts an implementation of PProfServerMethods into
 // an object that may be used by rpc.Server.
 func PProfServer(impl PProfServerMethods) PProfServerStub {
 	stub := implPProfServerStub{
 		impl: impl,
 	}
 	// Initialize GlobState; always check the stub itself first, to handle the
 	// case where the user has the Glob method defined in their VDL source.
 	if gs := rpc.NewGlobState(stub); gs != nil {
 		stub.gs = gs
 	} else if gs := rpc.NewGlobState(impl); gs != nil {
 		stub.gs = gs
 	}
 	return stub
 }

 type implPProfServerStub struct {
 	impl PProfServerMethods
 	gs   *rpc.GlobState
 }

 func (s implPProfServerStub) CmdLine(ctx *context.T, call rpc.ServerCall) ([]string, error) {
 	return s.impl.CmdLine(ctx, call)
 }

 func (s implPProfServerStub) Profiles(ctx *context.T, call rpc.ServerCall) ([]string, error) {
 	return s.impl.Profiles(ctx, call)
 }

 func (s implPProfServerStub) Profile(ctx *context.T, call *PProfProfileServerCallStub, i0 string, i1 int32) error {
 	return s.impl.Profile(ctx, call, i0, i1)
 }

 func (s implPProfServerStub) CpuProfile(ctx *context.T, call *PProfCpuProfileServerCallStub, i0 int32) error {
 	return s.impl.CpuProfile(ctx, call, i0)
 }

 func (s implPProfServerStub) Symbol(ctx *context.T, call rpc.ServerCall, i0 []uint64) ([]string, error) {
 	return s.impl.Symbol(ctx, call, i0)
 }

 func (s implPProfServerStub) Globber() *rpc.GlobState {
 	return s.gs
 }

 func (s implPProfServerStub) Describe__() []rpc.InterfaceDesc {
 	return []rpc.InterfaceDesc{PProfDesc}
 }

 // PProfDesc describes the PProf interface.
 var PProfDesc rpc.InterfaceDesc = descPProf

 // descPProf hides the desc to keep godoc clean.
 var descPProf = rpc.InterfaceDesc{
 	Name:    "PProf",
 	PkgPath: "v.io/v23/services/pprof",
 	Methods: []rpc.MethodDesc{
 		{
 			Name: "CmdLine",
 			Doc:  "// CmdLine returns the command-line arguments of the server, including\n// the name of the executable.",
 			OutArgs: []rpc.ArgDesc{
 				{"", ``}, // []string
 			},
 			Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Debug"))},
 		},
 		{
 			Name: "Profiles",
 			Doc:  "// Profiles returns the list of available profiles.",
 			OutArgs: []rpc.ArgDesc{
 				{"", ``}, // []string
 			},
 			Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Debug"))},
 		},
 		{
 			Name: "Profile",
 			Doc:  "// Profile streams the requested profile. The debug parameter enables\n// additional output. Passing debug=0 includes only the hexadecimal\n// addresses that pprof needs. Passing debug=1 adds comments translating\n// addresses to function names and line numbers, so that a programmer\n// can read the profile without tools.",
 			InArgs: []rpc.ArgDesc{
 				{"name", ``},  // string
 				{"debug", ``}, // int32
 			},
 			Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Debug"))},
 		},
 		{
 			Name: "CpuProfile",
 			Doc:  "// CpuProfile enables CPU profiling for the requested duration and\n// streams the profile data.",
 			InArgs: []rpc.ArgDesc{
 				{"seconds", ``}, // int32
 			},
 			Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Debug"))},
 		},
 		{
 			Name: "Symbol",
 			Doc:  "// Symbol looks up the program counters and returns their respective\n// function names.",
 			InArgs: []rpc.ArgDesc{
 				{"programCounters", ``}, // []uint64
 			},
 			OutArgs: []rpc.ArgDesc{
 				{"", ``}, // []string
 			},
 			Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Debug"))},
 		},
 	},
 }

 // PProfProfileServerStream is the server stream for PProf.Profile.
 type PProfProfileServerStream interface {
 	// SendStream returns the send side of the PProf.Profile server stream.
 	SendStream() interface {
 		// Send places the item onto the output stream.  Returns errors encountered
 		// while sending.  Blocks if there is no buffer space; will unblock when
 		// buffer space is available.
 		Send(item []byte) error
 	}
 }

 // PProfProfileServerCall represents the context passed to PProf.Profile.
 type PProfProfileServerCall interface {
 	rpc.ServerCall
 	PProfProfileServerStream
 }

 // PProfProfileServerCallStub is a wrapper that converts rpc.StreamServerCall into
 // a typesafe stub that implements PProfProfileServerCall.
 type PProfProfileServerCallStub struct {
 	rpc.StreamServerCall
 }

 // Init initializes PProfProfileServerCallStub from rpc.StreamServerCall.
 func (s *PProfProfileServerCallStub) Init(call rpc.StreamServerCall) {
 	s.StreamServerCall = call
 }

 // SendStream returns the send side of the PProf.Profile server stream.
 func (s *PProfProfileServerCallStub) SendStream() interface {
 	Send(item []byte) error
 } {
 	return implPProfProfileServerCallSend{s}
 }

 type implPProfProfileServerCallSend struct {
 	s *PProfProfileServerCallStub
 }

 func (s implPProfProfileServerCallSend) Send(item []byte) error {
 	return s.s.Send(item)
 }

 // PProfCpuProfileServerStream is the server stream for PProf.CpuProfile.
 type PProfCpuProfileServerStream interface {
 	// SendStream returns the send side of the PProf.CpuProfile server stream.
 	SendStream() interface {
 		// Send places the item onto the output stream.  Returns errors encountered
 		// while sending.  Blocks if there is no buffer space; will unblock when
 		// buffer space is available.
 		Send(item []byte) error
 	}
 }

 // PProfCpuProfileServerCall represents the context passed to PProf.CpuProfile.
 type PProfCpuProfileServerCall interface {
 	rpc.ServerCall
 	PProfCpuProfileServerStream
 }

 // PProfCpuProfileServerCallStub is a wrapper that converts rpc.StreamServerCall into
 // a typesafe stub that implements PProfCpuProfileServerCall.
 type PProfCpuProfileServerCallStub struct {
 	rpc.StreamServerCall
 }

 // Init initializes PProfCpuProfileServerCallStub from rpc.StreamServerCall.
 func (s *PProfCpuProfileServerCallStub) Init(call rpc.StreamServerCall) {
 	s.StreamServerCall = call
 }

 // SendStream returns the send side of the PProf.CpuProfile server stream.
 func (s *PProfCpuProfileServerCallStub) SendStream() interface {
 	Send(item []byte) error
 } {
 	return implPProfCpuProfileServerCallSend{s}
 }

 type implPProfCpuProfileServerCallSend struct {
 	s *PProfCpuProfileServerCallStub
 }

 func (s implPProfCpuProfileServerCallSend) Send(item []byte) error {
 	return s.s.Send(item)
 }

 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

 	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: pprof

	// Package pprof defines an interface for accessing runtime profiling data in
	// the format expected by the pprof visualization tool. For more information
	// about pprof, see http://code.google.com/p/google-perftools/.
	package pprof

	import (
	"io"
	"v.io/v23"
	"v.io/v23/context"
	"v.io/v23/rpc"
	"v.io/v23/security/access"
	"v.io/v23/vdl"
	)

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

	//////////////////////////////////////////////////
	// Interface definitions

	// PProfClientMethods is the client interface
	// containing PProf methods.
	type PProfClientMethods interface {
	// CmdLine returns the command-line arguments of the server, including
	// the name of the executable.
	CmdLine(*context.T, ...rpc.CallOpt) ([]string, error)
	// Profiles returns the list of available profiles.
	Profiles(*context.T, ...rpc.CallOpt) ([]string, error)
	// Profile streams the requested profile. The debug parameter enables
	// additional output. Passing debug=0 includes only the hexadecimal
	// addresses that pprof needs. Passing debug=1 adds comments translating
	// addresses to function names and line numbers, so that a programmer
	// can read the profile without tools.
	Profile(_ *context.T, name string, debug int32, _ ...rpc.CallOpt) (PProfProfileClientCall, error)
	// CpuProfile enables CPU profiling for the requested duration and
	// streams the profile data.
	CpuProfile(_ *context.T, seconds int32, _ ...rpc.CallOpt) (PProfCpuProfileClientCall, error)
	// Symbol looks up the program counters and returns their respective
	// function names.
	Symbol(_ *context.T, programCounters []uint64, _ ...rpc.CallOpt) ([]string, error)
	}

	// PProfClientStub adds universal methods to PProfClientMethods.
	type PProfClientStub interface {
	PProfClientMethods
	rpc.UniversalServiceMethods
	}

	// PProfClient returns a client stub for PProf.
	func PProfClient(name string) PProfClientStub {
	return implPProfClientStub{name}
	}

	type implPProfClientStub struct {
	name string
	}

	func (c implPProfClientStub) CmdLine(ctx *context.T, opts ...rpc.CallOpt) (o0 []string, err error) {
	err = v23.GetClient(ctx).Call(ctx, c.name, "CmdLine", nil, []interface{}{&o0}, opts...)
	return
	}

	func (c implPProfClientStub) Profiles(ctx *context.T, opts ...rpc.CallOpt) (o0 []string, err error) {
	err = v23.GetClient(ctx).Call(ctx, c.name, "Profiles", nil, []interface{}{&o0}, opts...)
	return
	}

	func (c implPProfClientStub) Profile(ctx *context.T, i0 string, i1 int32, opts ...rpc.CallOpt) (ocall PProfProfileClientCall, err error) {
	var call rpc.ClientCall
	if call, err = v23.GetClient(ctx).StartCall(ctx, c.name, "Profile", []interface{}{i0, i1}, opts...); err != nil {
	return
	}
	ocall = &implPProfProfileClientCall{ClientCall: call}
	return
	}

	func (c implPProfClientStub) CpuProfile(ctx *context.T, i0 int32, opts ...rpc.CallOpt) (ocall PProfCpuProfileClientCall, err error) {
	var call rpc.ClientCall
	if call, err = v23.GetClient(ctx).StartCall(ctx, c.name, "CpuProfile", []interface{}{i0}, opts...); err != nil {
	return
	}
	ocall = &implPProfCpuProfileClientCall{ClientCall: call}
	return
	}

	func (c implPProfClientStub) Symbol(ctx *context.T, i0 []uint64, opts ...rpc.CallOpt) (o0 []string, err error) {
	err = v23.GetClient(ctx).Call(ctx, c.name, "Symbol", []interface{}{i0}, []interface{}{&o0}, opts...)
	return
	}

	// PProfProfileClientStream is the client stream for PProf.Profile.
	type PProfProfileClientStream interface {
	// RecvStream returns the receiver side of the PProf.Profile client stream.
	RecvStream() interface {
	// Advance stages an item so that it may be retrieved via Value. Returns
	// true iff there is an item to retrieve. Advance must be called before
	// Value is called. May block if an item is not available.
	Advance() bool
	// Value returns the item that was staged by Advance. May panic if Advance
	// returned false or was not called. Never blocks.
	Value() []byte
	// Err returns any error encountered by Advance. Never blocks.
	Err() error
	}
	}

	// PProfProfileClientCall represents the call returned from PProf.Profile.
	type PProfProfileClientCall interface {
	PProfProfileClientStream
	// Finish blocks until the server is done, and returns the positional return
	// values for call.
	//
	// Finish returns immediately if the call has been canceled; depending on the
	// timing the output could either be an error signaling cancelation, or the
	// valid positional return values from the server.
	//
	// Calling Finish is mandatory for releasing stream resources, unless the call
	// has been canceled or any of the other methods return an error. Finish should
	// be called at most once.
	Finish() error
	}

	type implPProfProfileClientCall struct {
	rpc.ClientCall
	valRecv []byte
	errRecv error
	}

	func (c *implPProfProfileClientCall) RecvStream() interface {
	Advance() bool
	Value() []byte
	Err() error
	} {
	return implPProfProfileClientCallRecv{c}
	}

	type implPProfProfileClientCallRecv struct {
	c *implPProfProfileClientCall
	}

	func (c implPProfProfileClientCallRecv) Advance() bool {
	c.c.errRecv = c.c.Recv(&c.c.valRecv)
	return c.c.errRecv == nil
	}
	func (c implPProfProfileClientCallRecv) Value() []byte {
	return c.c.valRecv
	}
	func (c implPProfProfileClientCallRecv) Err() error {
	if c.c.errRecv == io.EOF {
	return nil
	}
	return c.c.errRecv
	}
	func (c *implPProfProfileClientCall) Finish() (err error) {
	err = c.ClientCall.Finish()
	return
	}

	// PProfCpuProfileClientStream is the client stream for PProf.CpuProfile.
	type PProfCpuProfileClientStream interface {
	// RecvStream returns the receiver side of the PProf.CpuProfile client stream.
	RecvStream() interface {
	// Advance stages an item so that it may be retrieved via Value. Returns
	// true iff there is an item to retrieve. Advance must be called before
	// Value is called. May block if an item is not available.
	Advance() bool
	// Value returns the item that was staged by Advance. May panic if Advance
	// returned false or was not called. Never blocks.
	Value() []byte
	// Err returns any error encountered by Advance. Never blocks.
	Err() error
	}
	}

	// PProfCpuProfileClientCall represents the call returned from PProf.CpuProfile.
	type PProfCpuProfileClientCall interface {
	PProfCpuProfileClientStream
	// Finish blocks until the server is done, and returns the positional return
	// values for call.
	//
	// Finish returns immediately if the call has been canceled; depending on the
	// timing the output could either be an error signaling cancelation, or the
	// valid positional return values from the server.
	//
	// Calling Finish is mandatory for releasing stream resources, unless the call
	// has been canceled or any of the other methods return an error. Finish should
	// be called at most once.
	Finish() error
	}

	type implPProfCpuProfileClientCall struct {
	rpc.ClientCall
	valRecv []byte
	errRecv error
	}

	func (c *implPProfCpuProfileClientCall) RecvStream() interface {
	Advance() bool
	Value() []byte
	Err() error
	} {
	return implPProfCpuProfileClientCallRecv{c}
	}

	type implPProfCpuProfileClientCallRecv struct {
	c *implPProfCpuProfileClientCall
	}

	func (c implPProfCpuProfileClientCallRecv) Advance() bool {
	c.c.errRecv = c.c.Recv(&c.c.valRecv)
	return c.c.errRecv == nil
	}
	func (c implPProfCpuProfileClientCallRecv) Value() []byte {
	return c.c.valRecv
	}
	func (c implPProfCpuProfileClientCallRecv) Err() error {
	if c.c.errRecv == io.EOF {
	return nil
	}
	return c.c.errRecv
	}
	func (c *implPProfCpuProfileClientCall) Finish() (err error) {
	err = c.ClientCall.Finish()
	return
	}

	// PProfServerMethods is the interface a server writer
	// implements for PProf.
	type PProfServerMethods interface {
	// CmdLine returns the command-line arguments of the server, including
	// the name of the executable.
	CmdLine(*context.T, rpc.ServerCall) ([]string, error)
	// Profiles returns the list of available profiles.
	Profiles(*context.T, rpc.ServerCall) ([]string, error)
	// Profile streams the requested profile. The debug parameter enables
	// additional output. Passing debug=0 includes only the hexadecimal
	// addresses that pprof needs. Passing debug=1 adds comments translating
	// addresses to function names and line numbers, so that a programmer
	// can read the profile without tools.
	Profile(_ *context.T, _ PProfProfileServerCall, name string, debug int32) error
	// CpuProfile enables CPU profiling for the requested duration and
	// streams the profile data.
	CpuProfile(_ *context.T, _ PProfCpuProfileServerCall, seconds int32) error
	// Symbol looks up the program counters and returns their respective
	// function names.
	Symbol(_ *context.T, _ rpc.ServerCall, programCounters []uint64) ([]string, error)
	}

	// PProfServerStubMethods is the server interface containing
	// PProf methods, as expected by rpc.Server.
	// The only difference between this interface and PProfServerMethods
	// is the streaming methods.
	type PProfServerStubMethods interface {
	// CmdLine returns the command-line arguments of the server, including
	// the name of the executable.
	CmdLine(*context.T, rpc.ServerCall) ([]string, error)
	// Profiles returns the list of available profiles.
	Profiles(*context.T, rpc.ServerCall) ([]string, error)
	// Profile streams the requested profile. The debug parameter enables
	// additional output. Passing debug=0 includes only the hexadecimal
	// addresses that pprof needs. Passing debug=1 adds comments translating
	// addresses to function names and line numbers, so that a programmer
	// can read the profile without tools.
	Profile(_ context.T, _ PProfProfileServerCallStub, name string, debug int32) error
	// CpuProfile enables CPU profiling for the requested duration and
	// streams the profile data.
	CpuProfile(_ context.T, _ PProfCpuProfileServerCallStub, seconds int32) error
	// Symbol looks up the program counters and returns their respective
	// function names.
	Symbol(_ *context.T, _ rpc.ServerCall, programCounters []uint64) ([]string, error)
	}

	// PProfServerStub adds universal methods to PProfServerStubMethods.
	type PProfServerStub interface {
	PProfServerStubMethods
	// Describe the PProf interfaces.
	Describe__() []rpc.InterfaceDesc
	}

	// PProfServer returns a server stub for PProf.
	// It converts an implementation of PProfServerMethods into
	// an object that may be used by rpc.Server.
	func PProfServer(impl PProfServerMethods) PProfServerStub {
	stub := implPProfServerStub{
	impl: impl,
	}
	// Initialize GlobState; always check the stub itself first, to handle the
	// case where the user has the Glob method defined in their VDL source.
	if gs := rpc.NewGlobState(stub); gs != nil {
	stub.gs = gs
	} else if gs := rpc.NewGlobState(impl); gs != nil {
	stub.gs = gs
	}
	return stub
	}

	type implPProfServerStub struct {
	impl PProfServerMethods
	gs *rpc.GlobState
	}

	func (s implPProfServerStub) CmdLine(ctx *context.T, call rpc.ServerCall) ([]string, error) {
	return s.impl.CmdLine(ctx, call)
	}

	func (s implPProfServerStub) Profiles(ctx *context.T, call rpc.ServerCall) ([]string, error) {
	return s.impl.Profiles(ctx, call)
	}

	func (s implPProfServerStub) Profile(ctx context.T, call PProfProfileServerCallStub, i0 string, i1 int32) error {
	return s.impl.Profile(ctx, call, i0, i1)
	}

	func (s implPProfServerStub) CpuProfile(ctx context.T, call PProfCpuProfileServerCallStub, i0 int32) error {
	return s.impl.CpuProfile(ctx, call, i0)
	}

	func (s implPProfServerStub) Symbol(ctx *context.T, call rpc.ServerCall, i0 []uint64) ([]string, error) {
	return s.impl.Symbol(ctx, call, i0)
	}

	func (s implPProfServerStub) Globber() *rpc.GlobState {
	return s.gs
	}

	func (s implPProfServerStub) Describe__() []rpc.InterfaceDesc {
	return []rpc.InterfaceDesc{PProfDesc}
	}

	// PProfDesc describes the PProf interface.
	var PProfDesc rpc.InterfaceDesc = descPProf

	// descPProf hides the desc to keep godoc clean.
	var descPProf = rpc.InterfaceDesc{
	Name: "PProf",
	PkgPath: "v.io/v23/services/pprof",
	Methods: []rpc.MethodDesc{
	{
	Name: "CmdLine",
	Doc: "// CmdLine returns the command-line arguments of the server, including\n// the name of the executable.",
	OutArgs: []rpc.ArgDesc{
	{"", ``}, // []string
	},
	Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Debug"))},
	},
	{
	Name: "Profiles",
	Doc: "// Profiles returns the list of available profiles.",
	OutArgs: []rpc.ArgDesc{
	{"", ``}, // []string
	},
	Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Debug"))},
	},
	{
	Name: "Profile",
	Doc: "// Profile streams the requested profile. The debug parameter enables\n// additional output. Passing debug=0 includes only the hexadecimal\n// addresses that pprof needs. Passing debug=1 adds comments translating\n// addresses to function names and line numbers, so that a programmer\n// can read the profile without tools.",
	InArgs: []rpc.ArgDesc{
	{"name", ``}, // string
	{"debug", ``}, // int32
	},
	Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Debug"))},
	},
	{
	Name: "CpuProfile",
	Doc: "// CpuProfile enables CPU profiling for the requested duration and\n// streams the profile data.",
	InArgs: []rpc.ArgDesc{
	{"seconds", ``}, // int32
	},
	Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Debug"))},
	},
	{
	Name: "Symbol",
	Doc: "// Symbol looks up the program counters and returns their respective\n// function names.",
	InArgs: []rpc.ArgDesc{
	{"programCounters", ``}, // []uint64
	},
	OutArgs: []rpc.ArgDesc{
	{"", ``}, // []string
	},
	Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Debug"))},
	},
	},
	}

	// PProfProfileServerStream is the server stream for PProf.Profile.
	type PProfProfileServerStream interface {
	// SendStream returns the send side of the PProf.Profile server stream.
	SendStream() interface {
	// Send places the item onto the output stream. Returns errors encountered
	// while sending. Blocks if there is no buffer space; will unblock when
	// buffer space is available.
	Send(item []byte) error
	}
	}

	// PProfProfileServerCall represents the context passed to PProf.Profile.
	type PProfProfileServerCall interface {
	rpc.ServerCall
	PProfProfileServerStream
	}

	// PProfProfileServerCallStub is a wrapper that converts rpc.StreamServerCall into
	// a typesafe stub that implements PProfProfileServerCall.
	type PProfProfileServerCallStub struct {
	rpc.StreamServerCall
	}

	// Init initializes PProfProfileServerCallStub from rpc.StreamServerCall.
	func (s *PProfProfileServerCallStub) Init(call rpc.StreamServerCall) {
	s.StreamServerCall = call
	}

	// SendStream returns the send side of the PProf.Profile server stream.
	func (s *PProfProfileServerCallStub) SendStream() interface {
	Send(item []byte) error
	} {
	return implPProfProfileServerCallSend{s}
	}

	type implPProfProfileServerCallSend struct {
	s *PProfProfileServerCallStub
	}

	func (s implPProfProfileServerCallSend) Send(item []byte) error {
	return s.s.Send(item)
	}

	// PProfCpuProfileServerStream is the server stream for PProf.CpuProfile.
	type PProfCpuProfileServerStream interface {
	// SendStream returns the send side of the PProf.CpuProfile server stream.
	SendStream() interface {
	// Send places the item onto the output stream. Returns errors encountered
	// while sending. Blocks if there is no buffer space; will unblock when
	// buffer space is available.
	Send(item []byte) error
	}
	}

	// PProfCpuProfileServerCall represents the context passed to PProf.CpuProfile.
	type PProfCpuProfileServerCall interface {
	rpc.ServerCall
	PProfCpuProfileServerStream
	}

	// PProfCpuProfileServerCallStub is a wrapper that converts rpc.StreamServerCall into
	// a typesafe stub that implements PProfCpuProfileServerCall.
	type PProfCpuProfileServerCallStub struct {
	rpc.StreamServerCall
	}

	// Init initializes PProfCpuProfileServerCallStub from rpc.StreamServerCall.
	func (s *PProfCpuProfileServerCallStub) Init(call rpc.StreamServerCall) {
	s.StreamServerCall = call
	}

	// SendStream returns the send side of the PProf.CpuProfile server stream.
	func (s *PProfCpuProfileServerCallStub) SendStream() interface {
	Send(item []byte) error
	} {
	return implPProfCpuProfileServerCallSend{s}
	}

	type implPProfCpuProfileServerCallSend struct {
	s *PProfCpuProfileServerCallStub
	}

	func (s implPProfCpuProfileServerCallSend) Send(item []byte) error {
	return s.s.Send(item)
	}

	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

	return struct{}{}
	}