A-Tune/api/profile/profile.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: profile.proto

package profile

import (
	context "context"
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	grpc "google.golang.org/grpc"
	math "math"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package

type TuningMessageStatus int32

const (
	TuningMessage_JobInit          TuningMessageStatus = 0
	TuningMessage_JobRestart       TuningMessageStatus = 1
	TuningMessage_BenchMark        TuningMessageStatus = 2
	TuningMessage_Restore          TuningMessageStatus = 3
	TuningMessage_Ending           TuningMessageStatus = 4
	TuningMessage_Display          TuningMessageStatus = 5
	TuningMessage_SyncConfig       TuningMessageStatus = 6
	TuningMessage_Detail           TuningMessageStatus = 7
	TuningMessage_Threshold        TuningMessageStatus = 8
	TuningMessage_JobCreate        TuningMessageStatus = 9
	TuningMessage_GetInitialConfig TuningMessageStatus = 10
	TuningMessage_GetHistoryPath   TuningMessageStatus = 11
)

var TuningMessageStatus_name = map[int32]string{
	0:  "JobInit",
	1:  "JobRestart",
	2:  "BenchMark",
	3:  "Restore",
	4:  "Ending",
	5:  "Display",
	6:  "SyncConfig",
	7:  "Detail",
	8:  "Threshold",
	9:  "JobCreate",
	10: "GetInitialConfig",
	11: "GetHistoryPath",
}

var TuningMessageStatus_value = map[string]int32{
	"JobInit":          0,
	"JobRestart":       1,
	"BenchMark":        2,
	"Restore":          3,
	"Ending":           4,
	"Display":          5,
	"SyncConfig":       6,
	"Detail":           7,
	"Threshold":        8,
	"JobCreate":        9,
	"GetInitialConfig": 10,
	"GetHistoryPath": 11,
}

func (x TuningMessageStatus) String() string {
	return proto.EnumName(TuningMessageStatus_name, int32(x))
}

func (TuningMessageStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_744bf7a47b381504, []int{10, 0}
}

type ListMessage struct {
	WorkloadType         string   `protobuf:"bytes,1,opt,name=WorkloadType,proto3" json:"WorkloadType,omitempty"`
	ProfileNames         string   `protobuf:"bytes,2,opt,name=ProfileNames,proto3" json:"ProfileNames,omitempty"`
	Active               string   `protobuf:"bytes,3,opt,name=Active,proto3" json:"Active,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ListMessage) Reset()         { *m = ListMessage{} }
func (m *ListMessage) String() string { return proto.CompactTextString(m) }
func (*ListMessage) ProtoMessage()    {}
func (*ListMessage) Descriptor() ([]byte, []int) {
	return fileDescriptor_744bf7a47b381504, []int{0}
}

func (m *ListMessage) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ListMessage.Unmarshal(m, b)
}
func (m *ListMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ListMessage.Marshal(b, m, deterministic)
}
func (m *ListMessage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListMessage.Merge(m, src)
}
func (m *ListMessage) XXX_Size() int {
	return xxx_messageInfo_ListMessage.Size(m)
}
func (m *ListMessage) XXX_DiscardUnknown() {
	xxx_messageInfo_ListMessage.DiscardUnknown(m)
}

var xxx_messageInfo_ListMessage proto.InternalMessageInfo

func (m *ListMessage) GetWorkloadType() string {
	if m != nil {
		return m.WorkloadType
	}
	return ""
}

func (m *ListMessage) GetProfileNames() string {
	if m != nil {
		return m.ProfileNames
	}
	return ""
}

func (m *ListMessage) GetActive() string {
	if m != nil {
		return m.Active
	}
	return ""
}

type ProfileInfo struct {
	Name                 string   `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"`
	Content              []byte   `protobuf:"bytes,2,opt,name=Content,proto3" json:"Content,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ProfileInfo) Reset()         { *m = ProfileInfo{} }
func (m *ProfileInfo) String() string { return proto.CompactTextString(m) }
func (*ProfileInfo) ProtoMessage()    {}
func (*ProfileInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_744bf7a47b381504, []int{1}
}

func (m *ProfileInfo) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ProfileInfo.Unmarshal(m, b)
}
func (m *ProfileInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ProfileInfo.Marshal(b, m, deterministic)
}
func (m *ProfileInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ProfileInfo.Merge(m, src)
}
func (m *ProfileInfo) XXX_Size() int {
	return xxx_messageInfo_ProfileInfo.Size(m)
}
func (m *ProfileInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_ProfileInfo.DiscardUnknown(m)
}

var xxx_messageInfo_ProfileInfo proto.InternalMessageInfo

func (m *ProfileInfo) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *ProfileInfo) GetContent() []byte {
	if m != nil {
		return m.Content
	}
	return nil
}

type AnalysisMessage struct {
	Name                 string   `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"`
	Model                string   `protobuf:"bytes,2,opt,name=Model,proto3" json:"Model,omitempty"`
	Characterization     bool     `protobuf:"varint,3,opt,name=Characterization,proto3" json:"Characterization,omitempty"`
	Bottleneck           bool     `protobuf:"varint,4,opt,name=Bottleneck,proto3" json:"Bottleneck,omitempty"`
	Times                string   `protobuf:"bytes,5,opt,name=Time,proto3" json:"Time,omitempty"`
	Flag                 string   `protobuf:"bytes,6,opt,name=Flag,proto3" json:"Flag,omitempty"`
	Id                   string   `protobuf:"bytes,7,opt,name=Id,proto3" json:"Id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *AnalysisMessage) Reset()         { *m = AnalysisMessage{} }
func (m *AnalysisMessage) String() string { return proto.CompactTextString(m) }
func (*AnalysisMessage) ProtoMessage()    {}
func (*AnalysisMessage) Descriptor() ([]byte, []int) {
	return fileDescriptor_744bf7a47b381504, []int{2}
}

func (m *AnalysisMessage) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_AnalysisMessage.Unmarshal(m, b)
}
func (m *AnalysisMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_AnalysisMessage.Marshal(b, m, deterministic)
}
func (m *AnalysisMessage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AnalysisMessage.Merge(m, src)
}
func (m *AnalysisMessage) XXX_Size() int {
	return xxx_messageInfo_AnalysisMessage.Size(m)
}
func (m *AnalysisMessage) XXX_DiscardUnknown() {
	xxx_messageInfo_AnalysisMessage.DiscardUnknown(m)
}

var xxx_messageInfo_AnalysisMessage proto.InternalMessageInfo

func (m *AnalysisMessage) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *AnalysisMessage) GetModel() string {
	if m != nil {
		return m.Model
	}
	return ""
}

func (m *AnalysisMessage) GetCharacterization() bool {
	if m != nil {
		return m.Characterization
	}
	return false
}

func (m *AnalysisMessage) GetBottleneck() bool {
	if m != nil {
		return m.Bottleneck
	}
	return false
}

func (m *AnalysisMessage) GetTime() string {
	if m != nil {
		return m.Times
	}
	return ""
}

func (m *AnalysisMessage) GetFlag() string {
	if m != nil {
		return m.Flag
	}
	return ""
}

func (m *AnalysisMessage) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

type Ack struct {
	Status               string   `protobuf:"bytes,1,opt,name=Status,proto3" json:"Status,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Ack) Reset()         { *m = Ack{} }
func (m *Ack) String() string { return proto.CompactTextString(m) }
func (*Ack) ProtoMessage()    {}
func (*Ack) Descriptor() ([]byte, []int) {
	return fileDescriptor_744bf7a47b381504, []int{3}
}

func (m *Ack) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Ack.Unmarshal(m, b)
}
func (m *Ack) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Ack.Marshal(b, m, deterministic)
}
func (m *Ack) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Ack.Merge(m, src)
}
func (m *Ack) XXX_Size() int {
	return xxx_messageInfo_Ack.Size(m)
}
func (m *Ack) XXX_DiscardUnknown() {
	xxx_messageInfo_Ack.DiscardUnknown(m)
}

var xxx_messageInfo_Ack proto.InternalMessageInfo

func (m *Ack) GetStatus() string {
	if m != nil {
		return m.Status
	}
	return ""
}

type AckCheck struct {
	Name                 string   `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"`
	Status               string   `protobuf:"bytes,2,opt,name=Status,proto3" json:"Status,omitempty"`
	Description          string   `protobuf:"bytes,3,opt,name=Description,proto3" json:"Description,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *AckCheck) Reset()         { *m = AckCheck{} }
func (m *AckCheck) String() string { return proto.CompactTextString(m) }
func (*AckCheck) ProtoMessage()    {}
func (*AckCheck) Descriptor() ([]byte, []int) {
	return fileDescriptor_744bf7a47b381504, []int{4}
}

func (m *AckCheck) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_AckCheck.Unmarshal(m, b)
}
func (m *AckCheck) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_AckCheck.Marshal(b, m, deterministic)
}
func (m *AckCheck) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AckCheck.Merge(m, src)
}
func (m *AckCheck) XXX_Size() int {
	return xxx_messageInfo_AckCheck.Size(m)
}
func (m *AckCheck) XXX_DiscardUnknown() {
	xxx_messageInfo_AckCheck.DiscardUnknown(m)
}

var xxx_messageInfo_AckCheck proto.InternalMessageInfo

func (m *AckCheck) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *AckCheck) GetStatus() string {
	if m != nil {
		return m.Status
	}
	return ""
}

func (m *AckCheck) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type ProfileLog struct {
	Id                   int64    `protobuf:"varint,1,opt,name=Id,proto3" json:"Id,omitempty"`
	ProfileId            string   `protobuf:"bytes,2,opt,name=ProfileId,proto3" json:"ProfileId,omitempty"`
	Timestamp            string   `protobuf:"bytes,3,opt,name=Timestamp,proto3" json:"Timestamp,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ProfileLog) Reset()         { *m = ProfileLog{} }
func (m *ProfileLog) String() string { return proto.CompactTextString(m) }
func (*ProfileLog) ProtoMessage()    {}
func (*ProfileLog) Descriptor() ([]byte, []int) {
	return fileDescriptor_744bf7a47b381504, []int{5}
}

func (m *ProfileLog) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ProfileLog.Unmarshal(m, b)
}
func (m *ProfileLog) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ProfileLog.Marshal(b, m, deterministic)
}
func (m *ProfileLog) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ProfileLog.Merge(m, src)
}
func (m *ProfileLog) XXX_Size() int {
	return xxx_messageInfo_ProfileLog.Size(m)
}
func (m *ProfileLog) XXX_DiscardUnknown() {
	xxx_messageInfo_ProfileLog.DiscardUnknown(m)
}

var xxx_messageInfo_ProfileLog proto.InternalMessageInfo

func (m *ProfileLog) GetId() int64 {
	if m != nil {
		return m.Id
	}
	return 0
}

func (m *ProfileLog) GetProfileId() string {
	if m != nil {
		return m.ProfileId
	}
	return ""
}

func (m *ProfileLog) GetTimestamp() string {
	if m != nil {
		return m.Timestamp
	}
	return ""
}

type CollectFlag struct {
	Interval             int64    `protobuf:"varint,1,opt,name=Interval,proto3" json:"Interval,omitempty"`
	Duration             int64    `protobuf:"varint,2,opt,name=Duration,proto3" json:"Duration,omitempty"`
	Workload             string   `protobuf:"bytes,3,opt,name=Workload,proto3" json:"Workload,omitempty"`
	OutputDir            string   `protobuf:"bytes,4,opt,name=OutputDir,proto3" json:"OutputDir,omitempty"`
	Block                string   `protobuf:"bytes,5,opt,name=Block,proto3" json:"Block,omitempty"`
	Network              string   `protobuf:"bytes,6,opt,name=Network,proto3" json:"Network,omitempty"`
	Type                 string   `protobuf:"bytes,7,opt,name=Type,proto3" json:"Type,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CollectFlag) Reset()         { *m = CollectFlag{} }
func (m *CollectFlag) String() string { return proto.CompactTextString(m) }
func (*CollectFlag) ProtoMessage()    {}
func (*CollectFlag) Descriptor() ([]byte, []int) {
	return fileDescriptor_744bf7a47b381504, []int{6}
}

func (m *CollectFlag) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CollectFlag.Unmarshal(m, b)
}
func (m *CollectFlag) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CollectFlag.Marshal(b, m, deterministic)
}
func (m *CollectFlag) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CollectFlag.Merge(m, src)
}
func (m *CollectFlag) XXX_Size() int {
	return xxx_messageInfo_CollectFlag.Size(m)
}
func (m *CollectFlag) XXX_DiscardUnknown() {
	xxx_messageInfo_CollectFlag.DiscardUnknown(m)
}

var xxx_messageInfo_CollectFlag proto.InternalMessageInfo

func (m *CollectFlag) GetInterval() int64 {
	if m != nil {
		return m.Interval
	}
	return 0
}

func (m *CollectFlag) GetDuration() int64 {
	if m != nil {
		return m.Duration
	}
	return 0
}

func (m *CollectFlag) GetWorkload() string {
	if m != nil {
		return m.Workload
	}
	return ""
}

func (m *CollectFlag) GetOutputDir() string {
	if m != nil {
		return m.OutputDir
	}
	return ""
}

func (m *CollectFlag) GetBlock() string {
	if m != nil {
		return m.Block
	}
	return ""
}

func (m *CollectFlag) GetNetwork() string {
	if m != nil {
		return m.Network
	}
	return ""
}

func (m *CollectFlag) GetType() string {
	if m != nil {
		return m.Type
	}
	return ""
}

type TrainMessage struct {
	DataPath             string   `protobuf:"bytes,1,opt,name=DataPath,proto3" json:"DataPath,omitempty"`
	ModelName            string   `protobuf:"bytes,2,opt,name=ModelName,proto3" json:"ModelName,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TrainMessage) Reset()         { *m = TrainMessage{} }
func (m *TrainMessage) String() string { return proto.CompactTextString(m) }
func (*TrainMessage) ProtoMessage()    {}
func (*TrainMessage) Descriptor() ([]byte, []int) {
	return fileDescriptor_744bf7a47b381504, []int{7}
}

func (m *TrainMessage) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TrainMessage.Unmarshal(m, b)
}
func (m *TrainMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TrainMessage.Marshal(b, m, deterministic)
}
func (m *TrainMessage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TrainMessage.Merge(m, src)
}
func (m *TrainMessage) XXX_Size() int {
	return xxx_messageInfo_TrainMessage.Size(m)
}
func (m *TrainMessage) XXX_DiscardUnknown() {
	xxx_messageInfo_TrainMessage.DiscardUnknown(m)
}

var xxx_messageInfo_TrainMessage proto.InternalMessageInfo

func (m *TrainMessage) GetDataPath() string {
	if m != nil {
		return m.DataPath
	}
	return ""
}

func (m *TrainMessage) GetModelName() string {
	if m != nil {
		return m.ModelName
	}
	return ""
}

type DefineMessage struct {
	ServiceType          string   `protobuf:"bytes,1,opt,name=ServiceType,proto3" json:"ServiceType,omitempty"`
	ApplicationName      string   `protobuf:"bytes,2,opt,name=ApplicationName,proto3" json:"ApplicationName,omitempty"`
	ScenarioName         string   `protobuf:"bytes,3,opt,name=ScenarioName,proto3" json:"ScenarioName,omitempty"`
	Content              []byte   `protobuf:"bytes,4,opt,name=Content,proto3" json:"Content,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DefineMessage) Reset()         { *m = DefineMessage{} }
func (m *DefineMessage) String() string { return proto.CompactTextString(m) }
func (*DefineMessage) ProtoMessage()    {}
func (*DefineMessage) Descriptor() ([]byte, []int) {
	return fileDescriptor_744bf7a47b381504, []int{8}
}

func (m *DefineMessage) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DefineMessage.Unmarshal(m, b)
}
func (m *DefineMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DefineMessage.Marshal(b, m, deterministic)
}
func (m *DefineMessage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DefineMessage.Merge(m, src)
}
func (m *DefineMessage) XXX_Size() int {
	return xxx_messageInfo_DefineMessage.Size(m)
}
func (m *DefineMessage) XXX_DiscardUnknown() {
	xxx_messageInfo_DefineMessage.DiscardUnknown(m)
}

var xxx_messageInfo_DefineMessage proto.InternalMessageInfo

func (m *DefineMessage) GetServiceType() string {
	if m != nil {
		return m.ServiceType
	}
	return ""
}

func (m *DefineMessage) GetApplicationName() string {
	if m != nil {
		return m.ApplicationName
	}
	return ""
}

func (m *DefineMessage) GetScenarioName() string {
	if m != nil {
		return m.ScenarioName
	}
	return ""
}

func (m *DefineMessage) GetContent() []byte {
	if m != nil {
		return m.Content
	}
	return nil
}

type ScheduleMessage struct {
	App                  string   `protobuf:"bytes,1,opt,name=App,proto3" json:"App,omitempty"`
	Type                 string   `protobuf:"bytes,2,opt,name=Type,proto3" json:"Type,omitempty"`
	Strategy             string   `protobuf:"bytes,3,opt,name=Strategy,proto3" json:"Strategy,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ScheduleMessage) Reset()         { *m = ScheduleMessage{} }
func (m *ScheduleMessage) String() string { return proto.CompactTextString(m) }
func (*ScheduleMessage) ProtoMessage()    {}
func (*ScheduleMessage) Descriptor() ([]byte, []int) {
	return fileDescriptor_744bf7a47b381504, []int{9}
}

func (m *ScheduleMessage) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ScheduleMessage.Unmarshal(m, b)
}
func (m *ScheduleMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ScheduleMessage.Marshal(b, m, deterministic)
}
func (m *ScheduleMessage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ScheduleMessage.Merge(m, src)
}
func (m *ScheduleMessage) XXX_Size() int {
	return xxx_messageInfo_ScheduleMessage.Size(m)
}
func (m *ScheduleMessage) XXX_DiscardUnknown() {
	xxx_messageInfo_ScheduleMessage.DiscardUnknown(m)
}

var xxx_messageInfo_ScheduleMessage proto.InternalMessageInfo

func (m *ScheduleMessage) GetApp() string {
	if m != nil {
		return m.App
	}
	return ""
}

func (m *ScheduleMessage) GetType() string {
	if m != nil {
		return m.Type
	}
	return ""
}

func (m *ScheduleMessage) GetStrategy() string {
	if m != nil {
		return m.Strategy
	}
	return ""
}

type TuningMessage struct {
	Name                 string              `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Engine               string              `protobuf:"bytes,2,opt,name=engine,proto3" json:"engine,omitempty"`
	Content              []byte              `protobuf:"bytes,3,opt,name=content,proto3" json:"content,omitempty"`
	State                TuningMessageStatus `protobuf:"varint,4,opt,name=state,proto3,enum=profile.TuningMessageStatus" json:"state,omitempty"`
	RandomStarts         int32               `protobuf:"varint,5,opt,name=RandomStarts,proto3" json:"RandomStarts,omitempty"`
	FeatureFilterEngine  string              `protobuf:"bytes,6,opt,name=FeatureFilterEngine,proto3" json:"FeatureFilterEngine,omitempty"`
	FeatureFilterCycle   int32               `protobuf:"varint,7,opt,name=FeatureFilterCycle,proto3" json:"FeatureFilterCycle,omitempty"`
	FeatureFilterIters   int32               `protobuf:"varint,8,opt,name=FeatureFilterIters,proto3" json:"FeatureFilterIters,omitempty"`
	Restart              bool                `protobuf:"varint,9,opt,name=Restart,proto3" json:"Restart,omitempty"`
	FeatureFilter        bool                `protobuf:"varint,10,opt,name=FeatureFilter,proto3" json:"FeatureFilter,omitempty"`
	TuningLog            *TuningHistory      `protobuf:"bytes,11,opt,name=TuningLog,proto3" json:"TuningLog,omitempty"`
	SplitCount           int32               `protobuf:"varint,12,opt,name=SplitCount,proto3" json:"SplitCount,omitempty"`
	FeatureFilterCount   int32               `protobuf:"varint,13,opt,name=FeatureFilterCount,proto3" json:"FeatureFilterCount,omitempty"`
	EvalFluctuation      float64             `protobuf:"fixed64,14,opt,name=EvalFluctuation,proto3" json:"EvalFluctuation,omitempty"`
	FeatureSelector      string              `protobuf:"bytes,15,opt,name=FeatureSelector,proto3" json:"FeatureSelector,omitempty"`
	InitialConfig        string              `protobuf:"bytes,16,opt,name=InitialConfig,proto3" json:"InitialConfig,omitempty"`
	HistoryPath          []string            `protobuf:"bytes,17,opt,name=HistoryPath,proto3" json:"HistoryPath,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

func (m *TuningMessage) Reset()         { *m = TuningMessage{} }
func (m *TuningMessage) String() string { return proto.CompactTextString(m) }
func (*TuningMessage) ProtoMessage()    {}
func (*TuningMessage) Descriptor() ([]byte, []int) {
	return fileDescriptor_744bf7a47b381504, []int{10}
}

func (m *TuningMessage) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TuningMessage.Unmarshal(m, b)
}
func (m *TuningMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TuningMessage.Marshal(b, m, deterministic)
}
func (m *TuningMessage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TuningMessage.Merge(m, src)
}
func (m *TuningMessage) XXX_Size() int {
	return xxx_messageInfo_TuningMessage.Size(m)
}
func (m *TuningMessage) XXX_DiscardUnknown() {
	xxx_messageInfo_TuningMessage.DiscardUnknown(m)
}

var xxx_messageInfo_TuningMessage proto.InternalMessageInfo

func (m *TuningMessage) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *TuningMessage) GetEngine() string {
	if m != nil {
		return m.Engine
	}
	return ""
}

func (m *TuningMessage) GetContent() []byte {
	if m != nil {
		return m.Content
	}
	return nil
}

func (m *TuningMessage) GetState() TuningMessageStatus {
	if m != nil {
		return m.State
	}
	return TuningMessage_JobInit
}

func (m *TuningMessage) GetRandomStarts() int32 {
	if m != nil {
		return m.RandomStarts
	}
	return 0
}

func (m *TuningMessage) GetHistoryPath() []string {
	if m != nil {
		return m.HistoryPath
	}
	return nil
}

func (m *TuningMessage) GetFeatureFilterEngine() string {
	if m != nil {
		return m.FeatureFilterEngine
	}
	return ""
}

func (m *TuningMessage) GetFeatureFilterCycle() int32 {
	if m != nil {
		return m.FeatureFilterCycle
	}
	return 0
}

func (m *TuningMessage) GetFeatureFilterIters() int32 {
	if m != nil {
		return m.FeatureFilterIters
	}
	return 0
}

func (m *TuningMessage) GetRestart() bool {
	if m != nil {
		return m.Restart
	}
	return false
}

func (m *TuningMessage) GetFeatureFilter() bool {
	if m != nil {
		return m.FeatureFilter
	}
	return false
}

func (m *TuningMessage) GetTuningLog() *TuningHistory {
	if m != nil {
		return m.TuningLog
	}
	return nil
}

func (m *TuningMessage) GetSplitCount() int32 {
	if m != nil {
		return m.SplitCount
	}
	return 0
}


func (m *TuningMessage) GetFeatureFilterCount() int32 {
	if m != nil {
		return m.FeatureFilterCount
	}
	return 0
}

func (m *TuningMessage) GetEvalFluctuation() float64 {
	if m != nil {
		return m.EvalFluctuation
	}
	return 0
}

func (m *TuningMessage) GetFeatureSelector() string {
	if m != nil {
		return m.FeatureSelector
	}
	return ""
}

func (m *TuningMessage) GetInitialConfig() string {
	if m != nil {
		return m.InitialConfig
	}
	return ""
}

type TuningHistory struct {
	BaseEval             string   `protobuf:"bytes,1,opt,name=BaseEval,proto3" json:"BaseEval,omitempty"`
	MinEval              string   `protobuf:"bytes,2,opt,name=MinEval,proto3" json:"MinEval,omitempty"`
	SumEval              string   `protobuf:"bytes,3,opt,name=SumEval,proto3" json:"SumEval,omitempty"`
	TotalTime            int64    `protobuf:"varint,4,opt,name=TotalTime,proto3" json:"TotalTime,omitempty"`
	Starts               int32    `protobuf:"varint,5,opt,name=Starts,proto3" json:"Starts,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TuningHistory) Reset()         { *m = TuningHistory{} }
func (m *TuningHistory) String() string { return proto.CompactTextString(m) }
func (*TuningHistory) ProtoMessage()    {}
func (*TuningHistory) Descriptor() ([]byte, []int) {
	return fileDescriptor_744bf7a47b381504, []int{11}
}

func (m *TuningHistory) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TuningHistory.Unmarshal(m, b)
}
func (m *TuningHistory) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TuningHistory.Marshal(b, m, deterministic)
}
func (m *TuningHistory) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TuningHistory.Merge(m, src)
}
func (m *TuningHistory) XXX_Size() int {
	return xxx_messageInfo_TuningHistory.Size(m)
}
func (m *TuningHistory) XXX_DiscardUnknown() {
	xxx_messageInfo_TuningHistory.DiscardUnknown(m)
}

var xxx_messageInfo_TuningHistory proto.InternalMessageInfo

func (m *TuningHistory) GetBaseEval() string {
	if m != nil {
		return m.BaseEval
	}
	return ""
}

func (m *TuningHistory) GetMinEval() string {
	if m != nil {
		return m.MinEval
	}
	return ""
}

func (m *TuningHistory) GetSumEval() string {
	if m != nil {
		return m.SumEval
	}
	return ""
}

func (m *TuningHistory) GetTotalTime() int64 {
	if m != nil {
		return m.TotalTime
	}
	return 0
}

func (m *TuningHistory) GetStarts() int32 {
	if m != nil {
		return m.Starts
	}
	return 0
}
type DetectMessage struct {
	AppName              string   `protobuf:"bytes,1,opt,name=AppName,proto3" json:"AppName,omitempty"`
	DetectPath           string   `protobuf:"bytes,2,opt,name=DetectPath,proto3" json:"DetectPath,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DetectMessage) Reset()         { *m = DetectMessage{} }
func (m *DetectMessage) String() string { return proto.CompactTextString(m) }
func (*DetectMessage) ProtoMessage()    {}
func (*DetectMessage) Descriptor() ([]byte, []int) {
	return fileDescriptor_744bf7a47b381504, []int{12}
}

func (m *DetectMessage) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DetectMessage.Unmarshal(m, b)
}
func (m *DetectMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DetectMessage.Marshal(b, m, deterministic)
}
func (m *DetectMessage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DetectMessage.Merge(m, src)
}
func (m *DetectMessage) XXX_Size() int {
	return xxx_messageInfo_DetectMessage.Size(m)
}
func (m *DetectMessage) XXX_DiscardUnknown() {
	xxx_messageInfo_DetectMessage.DiscardUnknown(m)
}

var xxx_messageInfo_DetectMessage proto.InternalMessageInfo

func (m *DetectMessage) GetAppName() string {
	if m != nil {
		return m.AppName
	}
	return ""
}

func (m *DetectMessage) GetDetectPath() string {
	if m != nil {
		return m.DetectPath
	}
	return ""
}

func init() {
	proto.RegisterEnum("profile.TuningMessageStatus", TuningMessageStatus_name, TuningMessageStatus_value)
	proto.RegisterType((*ListMessage)(nil), "profile.ListMessage")
	proto.RegisterType((*ProfileInfo)(nil), "profile.ProfileInfo")
	proto.RegisterType((*AnalysisMessage)(nil), "profile.AnalysisMessage")
	proto.RegisterType((*Ack)(nil), "profile.Ack")
	proto.RegisterType((*AckCheck)(nil), "profile.AckCheck")
	proto.RegisterType((*ProfileLog)(nil), "profile.ProfileLog")
	proto.RegisterType((*CollectFlag)(nil), "profile.CollectFlag")
	proto.RegisterType((*TrainMessage)(nil), "profile.TrainMessage")
	proto.RegisterType((*DefineMessage)(nil), "profile.DefineMessage")
	proto.RegisterType((*ScheduleMessage)(nil), "profile.ScheduleMessage")
	proto.RegisterType((*TuningMessage)(nil), "profile.TuningMessage")
	proto.RegisterType((*TuningHistory)(nil), "profile.TuningHistory")
	proto.RegisterType((*DetectMessage)(nil), "profile.DetectMessage")
}

func init() { proto.RegisterFile("profile.proto", fileDescriptor_744bf7a47b381504) }

var fileDescriptor_744bf7a47b381504 = []byte{
	// 1070 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x56, 0xcb, 0x6e, 0xe3, 0x36,
	0x17, 0x8e, 0xed, 0xf8, 0x76, 0xec, 0x24, 0xfa, 0xf9, 0x4f, 0x03, 0x21, 0xe8, 0x14, 0x81, 0xd0,
	0x45, 0xd0, 0x45, 0x10, 0x64, 0x8a, 0x5e, 0x10, 0xcc, 0x14, 0x8e, 0x93, 0xb4, 0x0e, 0x92, 0xe9,
	0x40, 0xce, 0xa0, 0xb3, 0x65, 0x24, 0x46, 0x26, 0x4c, 0x93, 0x02, 0x45, 0xa7, 0x70, 0x9f, 0xa3,
	0x5d, 0xf4, 0x6d, 0xba, 0xe9, 0xe3, 0xf4, 0x1d, 0x0a, 0x5e, 0x74, 0x71, 0x46, 0x2e, 0xda, 0xec,
	0xf4, 0x7d, 0xe7, 0xc2, 0xc3, 0xc3, 0x8f, 0x3c, 0x82, 0x9d, 0x54, 0x8a, 0x07, 0xca, 0xc8, 0x71,
	0x2a, 0x85, 0x12, 0xa8, 0xeb, 0x60, 0xb0, 0x80, 0xc1, 0x0d, 0xcd, 0xd4, 0x2d, 0xc9, 0x32, 0x9c,
	0x10, 0x14, 0xc0, 0xf0, 0x27, 0x21, 0xe7, 0x4c, 0xe0, 0xf8, 0x6e, 0x95, 0x12, 0xbf, 0x71, 0xd8,
	0x38, 0xea, 0x87, 0x6b, 0x9c, 0xf6, 0x79, 0x67, 0xa3, 0xdf, 0xe2, 0x05, 0xc9, 0xfc, 0xa6, 0xf5,
	0xa9, 0x72, 0x68, 0x1f, 0x3a, 0xa3, 0x48, 0xd1, 0x47, 0xe2, 0xb7, 0x8c, 0xd5, 0xa1, 0xe0, 0x0c,
	0x06, 0xce, 0x6f, 0xc2, 0x1f, 0x04, 0x42, 0xb0, 0xad, 0xfd, 0xdd, 0x32, 0xe6, 0x1b, 0xf9, 0xd0,
	0x1d, 0x0b, 0xae, 0x08, 0x57, 0x26, 0xf3, 0x30, 0xcc, 0x61, 0x90, 0xc0, 0xde, 0x88, 0x63, 0xb6,
	0xca, 0x68, 0x96, 0xd7, 0x5b, 0x97, 0xe0, 0x05, 0xb4, 0x6f, 0x45, 0x4c, 0x98, 0x2b, 0xcc, 0x02,
	0xf4, 0x05, 0x78, 0xe3, 0x19, 0x96, 0x38, 0x52, 0x44, 0xd2, 0x5f, 0xb0, 0xa2, 0x82, 0x9b, 0xda,
	0x7a, 0xe1, 0x47, 0x7c, 0xf0, 0x12, 0x5a, 0xa3, 0x68, 0xae, 0x37, 0x31, 0x55, 0x58, 0x2d, 0x33,
	0x97, 0xde, 0xa1, 0xe0, 0x03, 0xf4, 0x46, 0xd1, 0x7c, 0x3c, 0x23, 0xd1, 0xbc, 0xb6, 0x80, 0x32,
	0xae, 0x59, 0x8d, 0x43, 0x87, 0x30, 0xb8, 0x20, 0x59, 0x24, 0x69, 0x5a, 0xac, 0xde, 0x0f, 0xab,
	0x54, 0xf0, 0x01, 0xc0, 0xb5, 0xe7, 0x46, 0x24, 0x68, 0x17, 0x9a, 0x93, 0xd8, 0x64, 0x6e, 0x85,
	0xcd, 0x49, 0x8c, 0x3e, 0x85, 0x7e, 0xde, 0xbc, 0xd8, 0xa5, 0x2e, 0x09, 0x6d, 0xbd, 0xa3, 0x0b,
	0x92, 0x29, 0xbc, 0x48, 0x5d, 0xee, 0x92, 0x08, 0xfe, 0x6c, 0xc0, 0x60, 0x2c, 0x18, 0x23, 0x91,
	0xba, 0x62, 0x38, 0x41, 0x07, 0xd0, 0x9b, 0x70, 0x45, 0xe4, 0x23, 0x66, 0x6e, 0x85, 0x02, 0x6b,
	0xdb, 0xc5, 0x52, 0xda, 0x16, 0x35, 0xad, 0x2d, 0xc7, 0xda, 0x96, 0x8b, 0xc1, 0x2d, 0x52, 0x60,
	0xf4, 0x19, 0xc0, 0x8f, 0x4b, 0x95, 0x2e, 0xd5, 0x3b, 0xac, 0x66, 0xfe, 0xb6, 0xb1, 0x56, 0x18,
	0x7d, 0x30, 0xe7, 0x4c, 0x44, 0x73, 0xbf, 0x6d, 0x0f, 0xc6, 0x00, 0x7d, 0xde, 0x6f, 0x89, 0xfa,
	0x59, 0xc8, 0xb9, 0xdf, 0x31, 0x7c, 0x0e, 0x75, 0x6f, 0x8d, 0x08, 0xbb, 0xb6, 0xb7, 0xfa, 0x3b,
	0xb8, 0x86, 0xe1, 0x9d, 0xc4, 0x94, 0xe7, 0x02, 0xd0, 0xb5, 0x62, 0x85, 0xcd, 0x8a, 0xf6, 0x0c,
	0x0a, 0xfc, 0xa4, 0x9e, 0xe6, 0xd3, 0x7a, 0x82, 0xdf, 0x1b, 0xb0, 0x73, 0x41, 0x1e, 0x28, 0x27,
	0x79, 0xb6, 0x43, 0x18, 0x4c, 0x89, 0x7c, 0xa4, 0x11, 0xa9, 0xa8, 0xbf, 0x4a, 0xa1, 0x23, 0xd8,
	0x1b, 0xa5, 0x29, 0xa3, 0x91, 0x69, 0x87, 0x39, 0x7a, 0x9b, 0xf8, 0x29, 0xad, 0xaf, 0xc9, 0x34,
	0x22, 0x1c, 0x4b, 0x2a, 0x8c, 0x9b, 0xed, 0xd6, 0x1a, 0x57, 0xd5, 0xfa, 0xf6, 0xba, 0xd6, 0xa7,
	0xb0, 0x37, 0x8d, 0x66, 0x24, 0x5e, 0xb2, 0xa2, 0x38, 0x0f, 0x5a, 0xa3, 0x34, 0x75, 0x45, 0xe9,
	0xcf, 0xa2, 0x41, 0xcd, 0xb2, 0x41, 0xba, 0x21, 0x53, 0x25, 0xb1, 0x22, 0xc9, 0x2a, 0x3f, 0xa0,
	0x1c, 0x07, 0x7f, 0x6d, 0xc3, 0xce, 0xdd, 0x92, 0x53, 0x9e, 0x54, 0xee, 0x0f, 0xaf, 0xc8, 0x97,
	0x3b, 0xf9, 0x12, 0x9e, 0x50, 0x9e, 0xe7, 0x75, 0x48, 0x17, 0x1b, 0xb9, 0x62, 0x5b, 0xb6, 0x58,
	0x07, 0xd1, 0x2b, 0x68, 0x67, 0x0a, 0x2b, 0x62, 0x36, 0xb1, 0x7b, 0xfa, 0xf2, 0x38, 0x7f, 0x6c,
	0xd6, 0x16, 0x3b, 0xce, 0xcc, 0x35, 0x08, 0xad, 0xaf, 0xee, 0x4f, 0x88, 0x79, 0x2c, 0x16, 0x53,
	0x85, 0xa5, 0xca, 0x8c, 0x28, 0xda, 0xe1, 0x1a, 0x87, 0x4e, 0xe0, 0xff, 0x57, 0x04, 0xab, 0xa5,
	0x24, 0x57, 0x94, 0x29, 0x22, 0x2f, 0x6d, 0x5d, 0x56, 0x27, 0x75, 0x26, 0x74, 0x0c, 0x68, 0x8d,
	0x1e, 0xaf, 0x22, 0x66, 0x15, 0xd4, 0x0e, 0x6b, 0x2c, 0x1f, 0xf9, 0x4f, 0x14, 0x91, 0x99, 0xdf,
	0xab, 0xf1, 0x37, 0x16, 0xdd, 0x84, 0x50, 0x5f, 0x29, 0xa9, 0xfc, 0xbe, 0x79, 0x3d, 0x72, 0x88,
	0x3e, 0x87, 0x9d, 0x35, 0x7f, 0x1f, 0x8c, 0x7d, 0x9d, 0x44, 0x5f, 0x42, 0xdf, 0x36, 0xe5, 0x46,
	0x24, 0xfe, 0xe0, 0xb0, 0x71, 0x34, 0x38, 0xdd, 0x7f, 0xd2, 0xae, 0x1f, 0x68, 0xa6, 0x84, 0x5c,
	0x85, 0xa5, 0xa3, 0x56, 0xf2, 0x34, 0x65, 0x54, 0x8d, 0xc5, 0x92, 0x2b, 0x7f, 0x68, 0xaa, 0xab,
	0x30, 0xc1, 0xaf, 0x0d, 0xe8, 0xd8, 0xee, 0xa2, 0x01, 0x74, 0xaf, 0xc5, 0xfd, 0x84, 0x53, 0xe5,
	0x6d, 0xa1, 0x5d, 0x80, 0x6b, 0x71, 0xef, 0x2a, 0xf4, 0x1a, 0x68, 0x07, 0xfa, 0xe7, 0x84, 0x47,
	0xb3, 0x5b, 0x2c, 0xe7, 0x5e, 0x53, 0xfb, 0x6a, 0x9b, 0x90, 0xc4, 0x6b, 0x21, 0x80, 0xce, 0x25,
	0x8f, 0x29, 0x4f, 0xbc, 0x6d, 0x6d, 0xb8, 0xa0, 0x59, 0xca, 0xf0, 0xca, 0x6b, 0xeb, 0x24, 0xd3,
	0x15, 0x8f, 0xc6, 0x82, 0x3f, 0xd0, 0xc4, 0xeb, 0x68, 0xc7, 0x0b, 0xa2, 0x30, 0x65, 0x5e, 0x57,
	0x27, 0xbc, 0x9b, 0x49, 0x92, 0xcd, 0x04, 0x8b, 0xbd, 0x9e, 0x86, 0xd7, 0xe2, 0x7e, 0x2c, 0x09,
	0x56, 0xc4, 0xeb, 0x07, 0xbf, 0x35, 0x72, 0xbd, 0xb9, 0x3d, 0x69, 0x75, 0x9e, 0xe3, 0x8c, 0x5c,
	0xe6, 0xcf, 0x4e, 0x3f, 0x2c, 0xb0, 0x6e, 0xed, 0x2d, 0xe5, 0xc6, 0x64, 0x85, 0x97, 0x43, 0x6d,
	0x99, 0x2e, 0x17, 0xc6, 0x62, 0x25, 0x9d, 0x43, 0xf3, 0xe8, 0x09, 0x85, 0x99, 0x7e, 0xe8, 0x8c,
	0xfa, 0x5a, 0x61, 0x49, 0xb8, 0x87, 0xb8, 0x14, 0x97, 0x43, 0xa7, 0x7f, 0x74, 0x8b, 0x77, 0xf6,
	0x36, 0x91, 0xe8, 0x2b, 0xe8, 0x3a, 0x84, 0x5e, 0x14, 0x67, 0x51, 0x19, 0x53, 0x07, 0xff, 0x2b,
	0xd8, 0xfc, 0xdd, 0x0f, 0xb6, 0x4e, 0x1a, 0xe8, 0x3b, 0x3d, 0x52, 0x48, 0x34, 0xd7, 0xcd, 0x7e,
	0x56, 0x82, 0x33, 0xe8, 0xe5, 0x03, 0x0d, 0xf9, 0xa5, 0xcb, 0xfa, 0x8c, 0xdb, 0x14, 0xfc, 0x06,
	0x3a, 0xb6, 0xb7, 0x68, 0xbf, 0xfe, 0xbe, 0x1d, 0x6c, 0xe0, 0x83, 0xad, 0xa3, 0x86, 0x89, 0x1f,
	0xea, 0xc9, 0x5f, 0xbc, 0xde, 0xf5, 0x95, 0x97, 0x6c, 0xe5, 0x37, 0xc1, 0xac, 0xff, 0x1a, 0x76,
	0xdf, 0xa7, 0x89, 0xc4, 0x31, 0x79, 0xd6, 0xde, 0x5f, 0xc3, 0x40, 0x9b, 0xff, 0x39, 0xb6, 0x96,
	0x35, 0xe1, 0x23, 0x40, 0x26, 0x97, 0xfd, 0xaf, 0x78, 0x56, 0x05, 0x6f, 0x60, 0xcf, 0x79, 0x85,
	0x82, 0xb1, 0x7b, 0x1c, 0xcd, 0xff, 0x5b, 0xfc, 0xb7, 0x00, 0x6e, 0xa2, 0xea, 0xc1, 0x58, 0x86,
	0x56, 0xc6, 0xec, 0xa6, 0xd0, 0x6f, 0xa0, 0x67, 0xa6, 0x98, 0x3e, 0xbd, 0x4f, 0xca, 0x53, 0xaa,
	0x0c, 0xb6, 0x4d, 0x91, 0x27, 0xfa, 0xf2, 0xe9, 0x91, 0x55, 0x39, 0xf5, 0xb5, 0x19, 0x76, 0x30,
	0xac, 0x06, 0x06, 0x5b, 0xe8, 0x58, 0x47, 0x30, 0xa2, 0x36, 0x75, 0xa7, 0xc6, 0xff, 0x7d, 0x1a,
	0xe3, 0x7f, 0xed, 0x7f, 0x06, 0xbd, 0x7c, 0x52, 0x55, 0x44, 0xfc, 0x64, 0x78, 0x6d, 0xda, 0xce,
	0xd7, 0xd0, 0xfb, 0x9e, 0x70, 0x22, 0x37, 0x2f, 0x57, 0x1f, 0x78, 0xdf, 0x31, 0xff, 0xb1, 0xaf,
	0xfe, 0x0e, 0x00, 0x00, 0xff, 0xff, 0x7f, 0xa9, 0x73, 0x55, 0xd8, 0x0a, 0x00, 0x00,
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// ProfileMgrClient is the client API for ProfileMgr service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ProfileMgrClient interface {
	Profile(ctx context.Context, in *ProfileInfo, opts ...grpc.CallOption) (ProfileMgr_ProfileClient, error)
	CheckInitProfile(ctx context.Context, in *ProfileInfo, opts ...grpc.CallOption) (ProfileMgr_CheckInitProfileClient, error)
	Analysis(ctx context.Context, in *AnalysisMessage, opts ...grpc.CallOption) (ProfileMgr_AnalysisClient, error)
	Tuning(ctx context.Context, opts ...grpc.CallOption) (ProfileMgr_TuningClient, error)
	ListWorkload(ctx context.Context, in *ProfileInfo, opts ...grpc.CallOption) (ProfileMgr_ListWorkloadClient, error)
	UpgradeProfile(ctx context.Context, in *ProfileInfo, opts ...grpc.CallOption) (ProfileMgr_UpgradeProfileClient, error)
	InfoProfile(ctx context.Context, in *ProfileInfo, opts ...grpc.CallOption) (ProfileMgr_InfoProfileClient, error)
	CheckActiveProfile(ctx context.Context, in *ProfileInfo, opts ...grpc.CallOption) (ProfileMgr_CheckActiveProfileClient, error)
	ProfileRollback(ctx context.Context, in *ProfileInfo, opts ...grpc.CallOption) (ProfileMgr_ProfileRollbackClient, error)
	Collection(ctx context.Context, in *CollectFlag, opts ...grpc.CallOption) (ProfileMgr_CollectionClient, error)
	Training(ctx context.Context, in *TrainMessage, opts ...grpc.CallOption) (ProfileMgr_TrainingClient, error)
	Define(ctx context.Context, in *DefineMessage, opts ...grpc.CallOption) (*Ack, error)
	Delete(ctx context.Context, in *ProfileInfo, opts ...grpc.CallOption) (*Ack, error)
	Update(ctx context.Context, in *ProfileInfo, opts ...grpc.CallOption) (*Ack, error)
	Schedule(ctx context.Context, in *ScheduleMessage, opts ...grpc.CallOption) (ProfileMgr_ScheduleClient, error)
	Generate(ctx context.Context, in *ProfileInfo, opts ...grpc.CallOption) (ProfileMgr_GenerateClient, error)
	Detecting(ctx context.Context, in *DetectMessage, opts ...grpc.CallOption) (ProfileMgr_DetectingClient, error)
}

type profileMgrClient struct {
	cc *grpc.ClientConn
}

func NewProfileMgrClient(cc *grpc.ClientConn) ProfileMgrClient {
	return &profileMgrClient{cc}
}

func (c *profileMgrClient) Profile(ctx context.Context, in *ProfileInfo, opts ...grpc.CallOption) (ProfileMgr_ProfileClient, error) {
	stream, err := c.cc.NewStream(ctx, &_ProfileMgr_serviceDesc.Streams[0], "/profile.ProfileMgr/Profile", opts...)
	if err != nil {
		return nil, err
	}
	x := &profileMgrProfileClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type ProfileMgr_ProfileClient interface {
	Recv() (*AckCheck, error)
	grpc.ClientStream
}

type profileMgrProfileClient struct {
	grpc.ClientStream
}

func (x *profileMgrProfileClient) Recv() (*AckCheck, error) {
	m := new(AckCheck)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *profileMgrClient) CheckInitProfile(ctx context.Context, in *ProfileInfo, opts ...grpc.CallOption) (ProfileMgr_CheckInitProfileClient, error) {
	stream, err := c.cc.NewStream(ctx, &_ProfileMgr_serviceDesc.Streams[1], "/profile.ProfileMgr/CheckInitProfile", opts...)
	if err != nil {
		return nil, err
	}
	x := &profileMgrCheckInitProfileClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type ProfileMgr_CheckInitProfileClient interface {
	Recv() (*AckCheck, error)
	grpc.ClientStream
}

type profileMgrCheckInitProfileClient struct {
	grpc.ClientStream
}

func (x *profileMgrCheckInitProfileClient) Recv() (*AckCheck, error) {
	m := new(AckCheck)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *profileMgrClient) Analysis(ctx context.Context, in *AnalysisMessage, opts ...grpc.CallOption) (ProfileMgr_AnalysisClient, error) {
	stream, err := c.cc.NewStream(ctx, &_ProfileMgr_serviceDesc.Streams[2], "/profile.ProfileMgr/Analysis", opts...)
	if err != nil {
		return nil, err
	}
	x := &profileMgrAnalysisClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type ProfileMgr_AnalysisClient interface {
	Recv() (*AckCheck, error)
	grpc.ClientStream
}

type profileMgrAnalysisClient struct {
	grpc.ClientStream
}

func (x *profileMgrAnalysisClient) Recv() (*AckCheck, error) {
	m := new(AckCheck)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *profileMgrClient) Tuning(ctx context.Context, opts ...grpc.CallOption) (ProfileMgr_TuningClient, error) {
	stream, err := c.cc.NewStream(ctx, &_ProfileMgr_serviceDesc.Streams[3], "/profile.ProfileMgr/Tuning", opts...)
	if err != nil {
		return nil, err
	}
	x := &profileMgrTuningClient{stream}
	return x, nil
}

type ProfileMgr_TuningClient interface {
	Send(*TuningMessage) error
	Recv() (*TuningMessage, error)
	grpc.ClientStream
}

type profileMgrTuningClient struct {
	grpc.ClientStream
}

func (x *profileMgrTuningClient) Send(m *TuningMessage) error {
	return x.ClientStream.SendMsg(m)
}

func (x *profileMgrTuningClient) Recv() (*TuningMessage, error) {
	m := new(TuningMessage)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *profileMgrClient) ListWorkload(ctx context.Context, in *ProfileInfo, opts ...grpc.CallOption) (ProfileMgr_ListWorkloadClient, error) {
	stream, err := c.cc.NewStream(ctx, &_ProfileMgr_serviceDesc.Streams[4], "/profile.ProfileMgr/ListWorkload", opts...)
	if err != nil {
		return nil, err
	}
	x := &profileMgrListWorkloadClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type ProfileMgr_ListWorkloadClient interface {
	Recv() (*ListMessage, error)
	grpc.ClientStream
}

type profileMgrListWorkloadClient struct {
	grpc.ClientStream
}

func (x *profileMgrListWorkloadClient) Recv() (*ListMessage, error) {
	m := new(ListMessage)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *profileMgrClient) UpgradeProfile(ctx context.Context, in *ProfileInfo, opts ...grpc.CallOption) (ProfileMgr_UpgradeProfileClient, error) {
	stream, err := c.cc.NewStream(ctx, &_ProfileMgr_serviceDesc.Streams[5], "/profile.ProfileMgr/UpgradeProfile", opts...)
	if err != nil {
		return nil, err
	}
	x := &profileMgrUpgradeProfileClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type ProfileMgr_UpgradeProfileClient interface {
	Recv() (*AckCheck, error)
	grpc.ClientStream
}

type profileMgrUpgradeProfileClient struct {
	grpc.ClientStream
}

func (x *profileMgrUpgradeProfileClient) Recv() (*AckCheck, error) {
	m := new(AckCheck)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *profileMgrClient) InfoProfile(ctx context.Context, in *ProfileInfo, opts ...grpc.CallOption) (ProfileMgr_InfoProfileClient, error) {
	stream, err := c.cc.NewStream(ctx, &_ProfileMgr_serviceDesc.Streams[6], "/profile.ProfileMgr/InfoProfile", opts...)
	if err != nil {
		return nil, err
	}
	x := &profileMgrInfoProfileClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type ProfileMgr_InfoProfileClient interface {
	Recv() (*ProfileInfo, error)
	grpc.ClientStream
}

type profileMgrInfoProfileClient struct {
	grpc.ClientStream
}

func (x *profileMgrInfoProfileClient) Recv() (*ProfileInfo, error) {
	m := new(ProfileInfo)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *profileMgrClient) CheckActiveProfile(ctx context.Context, in *ProfileInfo, opts ...grpc.CallOption) (ProfileMgr_CheckActiveProfileClient, error) {
	stream, err := c.cc.NewStream(ctx, &_ProfileMgr_serviceDesc.Streams[7], "/profile.ProfileMgr/CheckActiveProfile", opts...)
	if err != nil {
		return nil, err
	}
	x := &profileMgrCheckActiveProfileClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type ProfileMgr_CheckActiveProfileClient interface {
	Recv() (*AckCheck, error)
	grpc.ClientStream
}

type profileMgrCheckActiveProfileClient struct {
	grpc.ClientStream
}

func (x *profileMgrCheckActiveProfileClient) Recv() (*AckCheck, error) {
	m := new(AckCheck)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *profileMgrClient) ProfileRollback(ctx context.Context, in *ProfileInfo, opts ...grpc.CallOption) (ProfileMgr_ProfileRollbackClient, error) {
	stream, err := c.cc.NewStream(ctx, &_ProfileMgr_serviceDesc.Streams[8], "/profile.ProfileMgr/ProfileRollback", opts...)
	if err != nil {
		return nil, err
	}
	x := &profileMgrProfileRollbackClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type ProfileMgr_ProfileRollbackClient interface {
	Recv() (*AckCheck, error)
	grpc.ClientStream
}

type profileMgrProfileRollbackClient struct {
	grpc.ClientStream
}

func (x *profileMgrProfileRollbackClient) Recv() (*AckCheck, error) {
	m := new(AckCheck)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *profileMgrClient) Collection(ctx context.Context, in *CollectFlag, opts ...grpc.CallOption) (ProfileMgr_CollectionClient, error) {
	stream, err := c.cc.NewStream(ctx, &_ProfileMgr_serviceDesc.Streams[9], "/profile.ProfileMgr/Collection", opts...)
	if err != nil {
		return nil, err
	}
	x := &profileMgrCollectionClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type ProfileMgr_CollectionClient interface {
	Recv() (*AckCheck, error)
	grpc.ClientStream
}

type profileMgrCollectionClient struct {
	grpc.ClientStream
}

func (x *profileMgrCollectionClient) Recv() (*AckCheck, error) {
	m := new(AckCheck)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *profileMgrClient) Training(ctx context.Context, in *TrainMessage, opts ...grpc.CallOption) (ProfileMgr_TrainingClient, error) {
	stream, err := c.cc.NewStream(ctx, &_ProfileMgr_serviceDesc.Streams[10], "/profile.ProfileMgr/Training", opts...)
	if err != nil {
		return nil, err
	}
	x := &profileMgrTrainingClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type ProfileMgr_TrainingClient interface {
	Recv() (*AckCheck, error)
	grpc.ClientStream
}

type profileMgrTrainingClient struct {
	grpc.ClientStream
}

func (x *profileMgrTrainingClient) Recv() (*AckCheck, error) {
	m := new(AckCheck)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *profileMgrClient) Define(ctx context.Context, in *DefineMessage, opts ...grpc.CallOption) (*Ack, error) {
	out := new(Ack)
	err := c.cc.Invoke(ctx, "/profile.ProfileMgr/Define", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *profileMgrClient) Delete(ctx context.Context, in *ProfileInfo, opts ...grpc.CallOption) (*Ack, error) {
	out := new(Ack)
	err := c.cc.Invoke(ctx, "/profile.ProfileMgr/Delete", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *profileMgrClient) Update(ctx context.Context, in *ProfileInfo, opts ...grpc.CallOption) (*Ack, error) {
	out := new(Ack)
	err := c.cc.Invoke(ctx, "/profile.ProfileMgr/Update", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *profileMgrClient) Schedule(ctx context.Context, in *ScheduleMessage, opts ...grpc.CallOption) (ProfileMgr_ScheduleClient, error) {
	stream, err := c.cc.NewStream(ctx, &_ProfileMgr_serviceDesc.Streams[11], "/profile.ProfileMgr/Schedule", opts...)
	if err != nil {
		return nil, err
	}
	x := &profileMgrScheduleClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type ProfileMgr_ScheduleClient interface {
	Recv() (*AckCheck, error)
	grpc.ClientStream
}

type profileMgrScheduleClient struct {
	grpc.ClientStream
}

func (x *profileMgrScheduleClient) Recv() (*AckCheck, error) {
	m := new(AckCheck)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *profileMgrClient) Generate(ctx context.Context, in *ProfileInfo, opts ...grpc.CallOption) (ProfileMgr_GenerateClient, error) {
	stream, err := c.cc.NewStream(ctx, &_ProfileMgr_serviceDesc.Streams[12], "/profile.ProfileMgr/Generate", opts...)
	if err != nil {
		return nil, err
	}
	x := &profileMgrGenerateClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type ProfileMgr_GenerateClient interface {
	Recv() (*AckCheck, error)
	grpc.ClientStream
}

type profileMgrGenerateClient struct {
	grpc.ClientStream
}

func (x *profileMgrGenerateClient) Recv() (*AckCheck, error) {
	m := new(AckCheck)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *profileMgrClient) Detecting(ctx context.Context, in *DetectMessage, opts ...grpc.CallOption) (ProfileMgr_DetectingClient, error) {
	stream, err := c.cc.NewStream(ctx, &_ProfileMgr_serviceDesc.Streams[13], "/profile.ProfileMgr/Detecting", opts...)
	if err != nil {
		return nil, err
	}
	x := &profileMgrDetectingClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type ProfileMgr_DetectingClient interface {
	Recv() (*AckCheck, error)
	grpc.ClientStream
}

type profileMgrDetectingClient struct {
	grpc.ClientStream
}

func (x *profileMgrDetectingClient) Recv() (*AckCheck, error) {
	m := new(AckCheck)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

// ProfileMgrServer is the server API for ProfileMgr service.
type ProfileMgrServer interface {
	Profile(*ProfileInfo, ProfileMgr_ProfileServer) error
	CheckInitProfile(*ProfileInfo, ProfileMgr_CheckInitProfileServer) error
	Analysis(*AnalysisMessage, ProfileMgr_AnalysisServer) error
	Tuning(ProfileMgr_TuningServer) error
	ListWorkload(*ProfileInfo, ProfileMgr_ListWorkloadServer) error
	UpgradeProfile(*ProfileInfo, ProfileMgr_UpgradeProfileServer) error
	InfoProfile(*ProfileInfo, ProfileMgr_InfoProfileServer) error
	CheckActiveProfile(*ProfileInfo, ProfileMgr_CheckActiveProfileServer) error
	ProfileRollback(*ProfileInfo, ProfileMgr_ProfileRollbackServer) error
	Collection(*CollectFlag, ProfileMgr_CollectionServer) error
	Training(*TrainMessage, ProfileMgr_TrainingServer) error
	Define(context.Context, *DefineMessage) (*Ack, error)
	Delete(context.Context, *ProfileInfo) (*Ack, error)
	Update(context.Context, *ProfileInfo) (*Ack, error)
	Schedule(*ScheduleMessage, ProfileMgr_ScheduleServer) error
	Generate(*ProfileInfo, ProfileMgr_GenerateServer) error
	Detecting(*DetectMessage, ProfileMgr_DetectingServer) error
}

func RegisterProfileMgrServer(s *grpc.Server, srv ProfileMgrServer) {
	s.RegisterService(&_ProfileMgr_serviceDesc, srv)
}

func _ProfileMgr_Profile_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ProfileInfo)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ProfileMgrServer).Profile(m, &profileMgrProfileServer{stream})
}

type ProfileMgr_ProfileServer interface {
	Send(*AckCheck) error
	grpc.ServerStream
}

type profileMgrProfileServer struct {
	grpc.ServerStream
}

func (x *profileMgrProfileServer) Send(m *AckCheck) error {
	return x.ServerStream.SendMsg(m)
}

func _ProfileMgr_CheckInitProfile_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ProfileInfo)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ProfileMgrServer).CheckInitProfile(m, &profileMgrCheckInitProfileServer{stream})
}

type ProfileMgr_CheckInitProfileServer interface {
	Send(*AckCheck) error
	grpc.ServerStream
}

type profileMgrCheckInitProfileServer struct {
	grpc.ServerStream
}

func (x *profileMgrCheckInitProfileServer) Send(m *AckCheck) error {
	return x.ServerStream.SendMsg(m)
}

func _ProfileMgr_Analysis_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(AnalysisMessage)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ProfileMgrServer).Analysis(m, &profileMgrAnalysisServer{stream})
}

type ProfileMgr_AnalysisServer interface {
	Send(*AckCheck) error
	grpc.ServerStream
}

type profileMgrAnalysisServer struct {
	grpc.ServerStream
}

func (x *profileMgrAnalysisServer) Send(m *AckCheck) error {
	return x.ServerStream.SendMsg(m)
}

func _ProfileMgr_Tuning_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(ProfileMgrServer).Tuning(&profileMgrTuningServer{stream})
}

type ProfileMgr_TuningServer interface {
	Send(*TuningMessage) error
	Recv() (*TuningMessage, error)
	grpc.ServerStream
}

type profileMgrTuningServer struct {
	grpc.ServerStream
}

func (x *profileMgrTuningServer) Send(m *TuningMessage) error {
	return x.ServerStream.SendMsg(m)
}

func (x *profileMgrTuningServer) Recv() (*TuningMessage, error) {
	m := new(TuningMessage)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _ProfileMgr_ListWorkload_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ProfileInfo)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ProfileMgrServer).ListWorkload(m, &profileMgrListWorkloadServer{stream})
}

type ProfileMgr_ListWorkloadServer interface {
	Send(*ListMessage) error
	grpc.ServerStream
}

type profileMgrListWorkloadServer struct {
	grpc.ServerStream
}

func (x *profileMgrListWorkloadServer) Send(m *ListMessage) error {
	return x.ServerStream.SendMsg(m)
}

func _ProfileMgr_UpgradeProfile_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ProfileInfo)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ProfileMgrServer).UpgradeProfile(m, &profileMgrUpgradeProfileServer{stream})
}

type ProfileMgr_UpgradeProfileServer interface {
	Send(*AckCheck) error
	grpc.ServerStream
}

type profileMgrUpgradeProfileServer struct {
	grpc.ServerStream
}

func (x *profileMgrUpgradeProfileServer) Send(m *AckCheck) error {
	return x.ServerStream.SendMsg(m)
}

func _ProfileMgr_InfoProfile_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ProfileInfo)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ProfileMgrServer).InfoProfile(m, &profileMgrInfoProfileServer{stream})
}

type ProfileMgr_InfoProfileServer interface {
	Send(*ProfileInfo) error
	grpc.ServerStream
}

type profileMgrInfoProfileServer struct {
	grpc.ServerStream
}

func (x *profileMgrInfoProfileServer) Send(m *ProfileInfo) error {
	return x.ServerStream.SendMsg(m)
}

func _ProfileMgr_CheckActiveProfile_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ProfileInfo)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ProfileMgrServer).CheckActiveProfile(m, &profileMgrCheckActiveProfileServer{stream})
}

type ProfileMgr_CheckActiveProfileServer interface {
	Send(*AckCheck) error
	grpc.ServerStream
}

type profileMgrCheckActiveProfileServer struct {
	grpc.ServerStream
}

func (x *profileMgrCheckActiveProfileServer) Send(m *AckCheck) error {
	return x.ServerStream.SendMsg(m)
}

func _ProfileMgr_ProfileRollback_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ProfileInfo)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ProfileMgrServer).ProfileRollback(m, &profileMgrProfileRollbackServer{stream})
}

type ProfileMgr_ProfileRollbackServer interface {
	Send(*AckCheck) error
	grpc.ServerStream
}

type profileMgrProfileRollbackServer struct {
	grpc.ServerStream
}

func (x *profileMgrProfileRollbackServer) Send(m *AckCheck) error {
	return x.ServerStream.SendMsg(m)
}

func _ProfileMgr_Collection_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(CollectFlag)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ProfileMgrServer).Collection(m, &profileMgrCollectionServer{stream})
}

type ProfileMgr_CollectionServer interface {
	Send(*AckCheck) error
	grpc.ServerStream
}

type profileMgrCollectionServer struct {
	grpc.ServerStream
}

func (x *profileMgrCollectionServer) Send(m *AckCheck) error {
	return x.ServerStream.SendMsg(m)
}

func _ProfileMgr_Training_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(TrainMessage)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ProfileMgrServer).Training(m, &profileMgrTrainingServer{stream})
}

type ProfileMgr_TrainingServer interface {
	Send(*AckCheck) error
	grpc.ServerStream
}

type profileMgrTrainingServer struct {
	grpc.ServerStream
}

func (x *profileMgrTrainingServer) Send(m *AckCheck) error {
	return x.ServerStream.SendMsg(m)
}

func _ProfileMgr_Detecting_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(DetectMessage)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ProfileMgrServer).Detecting(m, &profileMgrDetectingServer{stream})
}

type ProfileMgr_DetectingServer interface {
	Send(*AckCheck) error
	grpc.ServerStream
}

type profileMgrDetectingServer struct {
	grpc.ServerStream
}

func (x *profileMgrDetectingServer) Send(m *AckCheck) error {
	return x.ServerStream.SendMsg(m)
}

func _ProfileMgr_Define_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DefineMessage)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ProfileMgrServer).Define(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/profile.ProfileMgr/Define",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ProfileMgrServer).Define(ctx, req.(*DefineMessage))
	}
	return interceptor(ctx, in, info, handler)
}

func _ProfileMgr_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ProfileInfo)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ProfileMgrServer).Delete(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/profile.ProfileMgr/Delete",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ProfileMgrServer).Delete(ctx, req.(*ProfileInfo))
	}
	return interceptor(ctx, in, info, handler)
}

func _ProfileMgr_Update_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ProfileInfo)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ProfileMgrServer).Update(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/profile.ProfileMgr/Update",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ProfileMgrServer).Update(ctx, req.(*ProfileInfo))
	}
	return interceptor(ctx, in, info, handler)
}

func _ProfileMgr_Schedule_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ScheduleMessage)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ProfileMgrServer).Schedule(m, &profileMgrScheduleServer{stream})
}

type ProfileMgr_ScheduleServer interface {
	Send(*AckCheck) error
	grpc.ServerStream
}

type profileMgrScheduleServer struct {
	grpc.ServerStream
}

func (x *profileMgrScheduleServer) Send(m *AckCheck) error {
	return x.ServerStream.SendMsg(m)
}

func _ProfileMgr_Generate_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ProfileInfo)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ProfileMgrServer).Generate(m, &profileMgrGenerateServer{stream})
}

type ProfileMgr_GenerateServer interface {
	Send(*AckCheck) error
	grpc.ServerStream
}

type profileMgrGenerateServer struct {
	grpc.ServerStream
}

func (x *profileMgrGenerateServer) Send(m *AckCheck) error {
	return x.ServerStream.SendMsg(m)
}

var _ProfileMgr_serviceDesc = grpc.ServiceDesc{
	ServiceName: "profile.ProfileMgr",
	HandlerType: (*ProfileMgrServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Define",
			Handler:    _ProfileMgr_Define_Handler,
		},
		{
			MethodName: "Delete",
			Handler:    _ProfileMgr_Delete_Handler,
		},
		{
			MethodName: "Update",
			Handler:    _ProfileMgr_Update_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "Profile",
			Handler:       _ProfileMgr_Profile_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "CheckInitProfile",
			Handler:       _ProfileMgr_CheckInitProfile_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Analysis",
			Handler:       _ProfileMgr_Analysis_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Tuning",
			Handler:       _ProfileMgr_Tuning_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "ListWorkload",
			Handler:       _ProfileMgr_ListWorkload_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "UpgradeProfile",
			Handler:       _ProfileMgr_UpgradeProfile_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "InfoProfile",
			Handler:       _ProfileMgr_InfoProfile_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "CheckActiveProfile",
			Handler:       _ProfileMgr_CheckActiveProfile_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ProfileRollback",
			Handler:       _ProfileMgr_ProfileRollback_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Collection",
			Handler:       _ProfileMgr_Collection_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Training",
			Handler:       _ProfileMgr_Training_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Schedule",
			Handler:       _ProfileMgr_Schedule_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Generate",
			Handler:       _ProfileMgr_Generate_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Detecting",
			Handler:       _ProfileMgr_Detecting_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "profile.proto",
}