!121 fix display of tuning command

Merge pull request !121 from lixiaoguang/dev_fix_tuning_display

api/profile/profile.pb.go

@@ -628,7 +628,8 @@ type TuningMessage struct {
 	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"`
-	TuningLog            *TuningHistory      `protobuf:"bytes,10,opt,name=TuningLog,proto3" json:"TuningLog,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"`
 	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
 	XXX_unrecognized     []byte              `json:"-"`
 	XXX_sizecache        int32               `json:"-"`
@@ -722,6 +723,13 @@ func (m *TuningMessage) GetRestart() bool {
 	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
@@ -811,71 +819,72 @@ func init() {
 func init() { proto.RegisterFile("profile.proto", fileDescriptor_744bf7a47b381504) }
 
 var fileDescriptor_744bf7a47b381504 = []byte{
-	// 1013 bytes of a gzipped FileDescriptorProto
+	// 1026 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x56, 0x4b, 0x6f, 0xe3, 0x36,
-	0x10, 0x8e, 0xdf, 0xf2, 0x38, 0x0f, 0x95, 0xdd, 0x06, 0x42, 0xd0, 0x2d, 0x02, 0x9d, 0x72, 0x0a,
-	0x82, 0x6c, 0xd1, 0x07, 0x82, 0xdd, 0xc2, 0x71, 0x92, 0xd6, 0x41, 0xb2, 0x5d, 0xc8, 0x59, 0x74,
-	0xaf, 0x8c, 0xc4, 0xc8, 0x84, 0x19, 0x52, 0xa0, 0xe8, 0x14, 0x6e, 0x2f, 0xbd, 0xf4, 0x3f, 0xb4,
-	0x3f, 0xa8, 0xff, 0xab, 0xe0, 0x43, 0xb2, 0xec, 0xca, 0xc5, 0x6e, 0x6e, 0xfa, 0xe6, 0xc5, 0xe1,
-	0x37, 0xc3, 0x19, 0xc1, 0x4e, 0x26, 0xc5, 0x03, 0x65, 0xe4, 0x38, 0x93, 0x42, 0x09, 0xd4, 0x73,
-	0x30, 0x7c, 0x84, 0xc1, 0x0d, 0xcd, 0xd5, 0x2d, 0xc9, 0x73, 0x9c, 0x12, 0x14, 0xc2, 0xf6, 0x2f,
-	0x42, 0xce, 0x98, 0xc0, 0xc9, 0xdd, 0x22, 0x23, 0x41, 0xe3, 0xb0, 0x71, 0xd4, 0x8f, 0x56, 0x64,
-	0xda, 0xe6, 0x9d, 0xf5, 0x7e, 0x8b, 0x1f, 0x49, 0x1e, 0x34, 0xad, 0x4d, 0x55, 0x86, 0xf6, 0xa1,
-	0x3b, 0x8c, 0x15, 0x7d, 0x22, 0x41, 0xcb, 0x68, 0x1d, 0x0a, 0xcf, 0x60, 0xe0, 0xec, 0xc6, 0xfc,
-	0x41, 0x20, 0x04, 0x6d, 0x6d, 0xef, 0x8e, 0x31, 0xdf, 0x28, 0x80, 0xde, 0x48, 0x70, 0x45, 0xb8,
-	0x32, 0x91, 0xb7, 0xa3, 0x02, 0x86, 0x67, 0xb0, 0x37, 0xe4, 0x98, 0x2d, 0x72, 0x9a, 0x17, 0xf9,
-	0xd6, 0x05, 0x78, 0x01, 0x9d, 0x5b, 0x91, 0x10, 0xe6, 0x12, 0xb3, 0x20, 0x7c, 0x09, 0xad, 0x61,
-	0x3c, 0xd3, 0x89, 0x4d, 0x14, 0x56, 0xf3, 0xdc, 0xb9, 0x38, 0x14, 0x7e, 0x00, 0x6f, 0x18, 0xcf,
-	0x46, 0x53, 0x12, 0xcf, 0x6a, 0x83, 0x2e, 0xfd, 0x9a, 0x55, 0x3f, 0x74, 0x08, 0x83, 0x0b, 0x92,
-	0xc7, 0x92, 0x66, 0x8a, 0x0a, 0xee, 0x6e, 0x5b, 0x15, 0x85, 0x1f, 0x00, 0xdc, 0x95, 0x6f, 0x44,
-	0x8a, 0x76, 0xa1, 0x39, 0x4e, 0x4c, 0xe4, 0x56, 0xd4, 0x1c, 0x27, 0xe8, 0x4b, 0xe8, 0x17, 0x84,
-	0x24, 0x2e, 0xf4, 0x52, 0xa0, 0xb5, 0x77, 0xf4, 0x91, 0xe4, 0x0a, 0x3f, 0x66, 0x2e, 0xf6, 0x52,
-	0x10, 0xfe, 0xd3, 0x80, 0xc1, 0x48, 0x30, 0x46, 0x62, 0x75, 0xc5, 0x70, 0x8a, 0x0e, 0xc0, 0x1b,
-	0x73, 0x45, 0xe4, 0x13, 0x66, 0xee, 0x84, 0x12, 0x6b, 0xdd, 0xc5, 0x5c, 0x62, 0x93, 0x64, 0xd3,
-	0xea, 0x0a, 0xac, 0x75, 0x45, 0x81, 0xdd, 0x21, 0x25, 0x46, 0x5f, 0x01, 0xfc, 0x3c, 0x57, 0xd9,
-	0x5c, 0xbd, 0xc3, 0x6a, 0x1a, 0xb4, 0x8d, 0xb6, 0x22, 0xd1, 0x64, 0x9f, 0x33, 0x11, 0xcf, 0x82,
-	0x8e, 0x25, 0xdb, 0x00, 0x5d, 0xc3, 0xb7, 0x44, 0xfd, 0x2a, 0xe4, 0x2c, 0xe8, 0x1a, 0x79, 0x01,
-	0x35, 0xb7, 0xa6, 0xb1, 0x7a, 0x96, 0x5b, 0xfd, 0x1d, 0x5e, 0xc3, 0xf6, 0x9d, 0xc4, 0x94, 0x17,
-	0x45, 0xd5, 0xb9, 0x62, 0x85, 0xcd, 0x89, 0xb6, 0x06, 0x25, 0x5e, 0xcb, 0xa7, 0xb9, 0x9e, 0x4f,
-	0xf8, 0x77, 0x03, 0x76, 0x2e, 0xc8, 0x03, 0xe5, 0xa4, 0x88, 0x76, 0x08, 0x83, 0x09, 0x91, 0x4f,
-	0x34, 0x26, 0x95, 0x8e, 0xae, 0x8a, 0xd0, 0x11, 0xec, 0x0d, 0xb3, 0x8c, 0xd1, 0xd8, 0xd0, 0x61,
-	0x4a, 0x6f, 0x03, 0xaf, 0x8b, 0x75, 0xeb, 0x4f, 0x62, 0xc2, 0xb1, 0xa4, 0xc2, 0x98, 0x59, 0xb6,
-	0x56, 0x64, 0xd5, 0xfe, 0x6d, 0xaf, 0xf6, 0xef, 0x04, 0xf6, 0x26, 0xf1, 0x94, 0x24, 0x73, 0x56,
-	0x26, 0xe7, 0x43, 0x6b, 0x98, 0x65, 0x2e, 0x29, 0xfd, 0x59, 0x12, 0xd4, 0x5c, 0x12, 0xa4, 0x09,
-	0x99, 0x28, 0x89, 0x15, 0x49, 0x17, 0x45, 0x81, 0x0a, 0x1c, 0xfe, 0xd5, 0x86, 0x9d, 0xbb, 0x39,
-	0xa7, 0x3c, 0xad, 0xbc, 0x09, 0x5e, 0x69, 0x5f, 0xee, 0xda, 0x97, 0xf0, 0x94, 0xf2, 0x22, 0xae,
-	0x43, 0x3a, 0xd9, 0xd8, 0x25, 0xdb, 0xb2, 0xc9, 0x3a, 0x88, 0x5e, 0x41, 0x27, 0x57, 0x58, 0x11,
-	0x73, 0x89, 0xdd, 0xd3, 0x97, 0xc7, 0xc5, 0x00, 0x59, 0x39, 0xec, 0x38, 0x37, 0xcf, 0x20, 0xb2,
-	0xb6, 0x9a, 0x9f, 0x08, 0xf3, 0x44, 0x3c, 0x4e, 0x14, 0x96, 0x2a, 0x37, 0x4d, 0xd1, 0x89, 0x56,
-	0x64, 0xe8, 0x04, 0x3e, 0xbf, 0x22, 0x58, 0xcd, 0x25, 0xb9, 0xa2, 0x4c, 0x11, 0x79, 0x69, 0xf3,
-	0xb2, 0x7d, 0x52, 0xa7, 0x42, 0xc7, 0x80, 0x56, 0xc4, 0xa3, 0x45, 0xcc, 0x6c, 0x07, 0x75, 0xa2,
-	0x1a, 0xcd, 0x7f, 0xec, 0xc7, 0x8a, 0xc8, 0x3c, 0xf0, 0x6a, 0xec, 0x8d, 0x46, 0x93, 0x10, 0xe9,
-	0x27, 0x25, 0x55, 0xd0, 0x3f, 0x6c, 0x1c, 0x79, 0x51, 0x01, 0xd1, 0xd7, 0xd0, 0xb7, 0xd7, 0xbd,
-	0x11, 0x69, 0x00, 0x87, 0x8d, 0xa3, 0xc1, 0xe9, 0xfe, 0x1a, 0x11, 0x3f, 0xd1, 0x5c, 0x09, 0xb9,
-	0x88, 0x96, 0x86, 0xe1, 0x9f, 0x0d, 0xe8, 0x5a, 0x5e, 0xd0, 0x00, 0x7a, 0xd7, 0xe2, 0x7e, 0xcc,
-	0xa9, 0xf2, 0xb7, 0xd0, 0x2e, 0xc0, 0xb5, 0xb8, 0x77, 0xb1, 0xfd, 0x06, 0xda, 0x81, 0xfe, 0x39,
-	0xe1, 0xf1, 0xf4, 0x16, 0xcb, 0x99, 0xdf, 0xd4, 0xb6, 0x5a, 0x27, 0x24, 0xf1, 0x5b, 0x08, 0xa0,
-	0x7b, 0xc9, 0x13, 0xca, 0x53, 0xbf, 0xad, 0x15, 0x17, 0x34, 0xcf, 0x18, 0x5e, 0xf8, 0x1d, 0x1d,
-	0x64, 0xb2, 0xe0, 0xf1, 0x48, 0xf0, 0x07, 0x9a, 0xfa, 0x5d, 0x6d, 0x78, 0x41, 0x14, 0xa6, 0xcc,
-	0xef, 0xe9, 0x80, 0x77, 0x53, 0x49, 0xf2, 0xa9, 0x60, 0x89, 0xef, 0x85, 0xbf, 0x17, 0x9d, 0xe1,
-	0x72, 0xd4, 0x7d, 0x74, 0x8e, 0x73, 0x72, 0x59, 0x0c, 0x88, 0x7e, 0x54, 0x62, 0x4d, 0xc2, 0x2d,
-	0xe5, 0x46, 0x65, 0x5b, 0xa4, 0x80, 0x66, 0x08, 0x09, 0x85, 0x99, 0x1e, 0x3c, 0xa6, 0x4b, 0x5a,
-	0xd1, 0x52, 0xe0, 0x06, 0xa3, 0x2e, 0x76, 0xdb, 0x10, 0xec, 0xd0, 0xe9, 0x1f, 0x5e, 0x39, 0xf7,
-	0x6e, 0x53, 0x89, 0xbe, 0x81, 0x9e, 0x43, 0xe8, 0x45, 0xc9, 0x60, 0x65, 0x15, 0x1c, 0x7c, 0x56,
-	0x4a, 0x8b, 0x39, 0x1c, 0x6e, 0x9d, 0x34, 0xd0, 0x0f, 0xe0, 0x1b, 0xa0, 0x29, 0x7c, 0x56, 0x80,
-	0x33, 0xf0, 0x8a, 0xa5, 0x81, 0x82, 0xa5, 0xc9, 0xea, 0x1e, 0xd9, 0xe4, 0xfc, 0x06, 0xba, 0x96,
-	0x41, 0xb4, 0x5f, 0xdf, 0xff, 0x07, 0x1b, 0xe4, 0xe1, 0xd6, 0x51, 0xc3, 0xf8, 0x6f, 0xeb, 0xed,
-	0x5a, 0x4e, 0xd3, 0xfa, 0xcc, 0x97, 0xd2, 0xca, 0x2a, 0x36, 0xe7, 0xbf, 0x86, 0xdd, 0xf7, 0x59,
-	0x2a, 0x71, 0x42, 0x9e, 0x75, 0xf7, 0xd7, 0x30, 0xd0, 0xea, 0xff, 0xf7, 0xad, 0x95, 0x1a, 0xf7,
-	0x21, 0x20, 0x13, 0xcb, 0xee, 0xee, 0x67, 0x65, 0xf0, 0x06, 0xf6, 0x9c, 0x55, 0x24, 0x18, 0xbb,
-	0xc7, 0xf1, 0xec, 0x93, 0xfd, 0x47, 0x53, 0xac, 0x47, 0x9d, 0xa4, 0xbf, 0xd9, 0x6d, 0xf5, 0x49,
-	0xfe, 0xdf, 0x03, 0xb8, 0x0d, 0xb9, 0xea, 0x5a, 0x59, 0x9b, 0x9b, 0x5c, 0xbf, 0x03, 0xcf, 0x6c,
-	0x25, 0x5d, 0xfd, 0x2f, 0x96, 0x55, 0xae, 0x2c, 0xaa, 0x4d, 0x9e, 0x27, 0xfa, 0x49, 0xea, 0x15,
-	0x54, 0xe9, 0x9a, 0x95, 0x9d, 0x74, 0xb0, 0x5d, 0x75, 0x0c, 0xb7, 0xd0, 0xb1, 0xf6, 0x60, 0x44,
-	0x6d, 0x62, 0xb7, 0xc6, 0xfe, 0x7d, 0x96, 0xe0, 0x8f, 0xb6, 0x3f, 0x03, 0xaf, 0xd8, 0x3c, 0x95,
-	0x47, 0xb0, 0xb6, 0x8c, 0x36, 0x5d, 0xe7, 0x5b, 0xf0, 0x7e, 0x24, 0x9c, 0xc8, 0xcd, 0xc7, 0xd5,
-	0x3b, 0xde, 0x77, 0xcd, 0xbf, 0xe6, 0xab, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0xae, 0x33, 0x53,
-	0x6e, 0x7c, 0x0a, 0x00, 0x00,
+	0x10, 0x8e, 0xdf, 0xf6, 0x38, 0x0f, 0x95, 0xdd, 0x06, 0x42, 0xd0, 0x2d, 0x02, 0xa1, 0x87, 0x9c,
+	0x82, 0x20, 0x5b, 0xf4, 0x81, 0x60, 0xb7, 0x70, 0x9c, 0xa4, 0x75, 0x90, 0x6c, 0x17, 0x72, 0x16,
+	0xdd, 0x2b, 0x23, 0x31, 0x32, 0x61, 0x86, 0x14, 0x28, 0x3a, 0x85, 0xdb, 0x4b, 0x2f, 0xfd, 0x11,
+	0xfd, 0x33, 0xbd, 0xf5, 0x7f, 0x15, 0x7c, 0x48, 0x96, 0x5c, 0xb9, 0xe8, 0xe6, 0xe6, 0xef, 0x9b,
+	0x07, 0x47, 0x1f, 0x87, 0x33, 0x86, 0x9d, 0x54, 0x8a, 0x07, 0xca, 0xc8, 0x71, 0x2a, 0x85, 0x12,
+	0xa8, 0xe7, 0x60, 0xf0, 0x08, 0xc3, 0x1b, 0x9a, 0xa9, 0x5b, 0x92, 0x65, 0x38, 0x21, 0x28, 0x80,
+	0xed, 0x9f, 0x85, 0x9c, 0x33, 0x81, 0xe3, 0xbb, 0x65, 0x4a, 0xfc, 0xc6, 0x61, 0xe3, 0x68, 0x10,
+	0x56, 0x38, 0xed, 0xf3, 0xce, 0x46, 0xbf, 0xc5, 0x8f, 0x24, 0xf3, 0x9b, 0xd6, 0xa7, 0xcc, 0xa1,
+	0x7d, 0xe8, 0x8e, 0x22, 0x45, 0x9f, 0x88, 0xdf, 0x32, 0x56, 0x87, 0x82, 0x33, 0x18, 0x3a, 0xbf,
+	0x09, 0x7f, 0x10, 0x08, 0x41, 0x5b, 0xfb, 0xbb, 0x63, 0xcc, 0x6f, 0xe4, 0x43, 0x6f, 0x2c, 0xb8,
+	0x22, 0x5c, 0x99, 0xcc, 0xdb, 0x61, 0x0e, 0x83, 0x33, 0xd8, 0x1b, 0x71, 0xcc, 0x96, 0x19, 0xcd,
+	0xf2, 0x7a, 0xeb, 0x12, 0xbc, 0x80, 0xce, 0xad, 0x88, 0x09, 0x73, 0x85, 0x59, 0x10, 0xbc, 0x84,
+	0xd6, 0x28, 0x9a, 0xeb, 0xc2, 0xa6, 0x0a, 0xab, 0x45, 0xe6, 0x42, 0x1c, 0x0a, 0x3e, 0x40, 0x7f,
+	0x14, 0xcd, 0xc7, 0x33, 0x12, 0xcd, 0x6b, 0x93, 0xae, 0xe2, 0x9a, 0xe5, 0x38, 0x74, 0x08, 0xc3,
+	0x0b, 0x92, 0x45, 0x92, 0xa6, 0x8a, 0x0a, 0xee, 0xbe, 0xb6, 0x4c, 0x05, 0x1f, 0x00, 0xdc, 0x27,
+	0xdf, 0x88, 0x04, 0xed, 0x42, 0x73, 0x12, 0x9b, 0xcc, 0xad, 0xb0, 0x39, 0x89, 0xd1, 0xe7, 0x30,
+	0xc8, 0x05, 0x89, 0x5d, 0xea, 0x15, 0xa1, 0xad, 0x77, 0xf4, 0x91, 0x64, 0x0a, 0x3f, 0xa6, 0x2e,
+	0xf7, 0x8a, 0x08, 0xfe, 0x6e, 0xc0, 0x70, 0x2c, 0x18, 0x23, 0x91, 0xba, 0x62, 0x38, 0x41, 0x07,
+	0xd0, 0x9f, 0x70, 0x45, 0xe4, 0x13, 0x66, 0xee, 0x84, 0x02, 0x6b, 0xdb, 0xc5, 0x42, 0x62, 0x53,
+	0x64, 0xd3, 0xda, 0x72, 0xac, 0x6d, 0xf9, 0x05, 0xbb, 0x43, 0x0a, 0x8c, 0xbe, 0x00, 0xf8, 0x69,
+	0xa1, 0xd2, 0x85, 0x7a, 0x87, 0xd5, 0xcc, 0x6f, 0x1b, 0x6b, 0x89, 0xd1, 0x62, 0x9f, 0x33, 0x11,
+	0xcd, 0xfd, 0x8e, 0x15, 0xdb, 0x00, 0x7d, 0x87, 0x6f, 0x89, 0xfa, 0x45, 0xc8, 0xb9, 0xdf, 0x35,
+	0x7c, 0x0e, 0xb5, 0xb6, 0xa6, 0xb1, 0x7a, 0x56, 0x5b, 0xfd, 0x3b, 0xb8, 0x86, 0xed, 0x3b, 0x89,
+	0x29, 0xcf, 0x2f, 0x55, 0xd7, 0x8a, 0x15, 0x36, 0x27, 0xda, 0x3b, 0x28, 0xf0, 0x5a, 0x3d, 0xcd,
+	0xf5, 0x7a, 0x82, 0x3f, 0x1b, 0xb0, 0x73, 0x41, 0x1e, 0x28, 0x27, 0x79, 0xb6, 0x43, 0x18, 0x4e,
+	0x89, 0x7c, 0xa2, 0x11, 0x29, 0x75, 0x74, 0x99, 0x42, 0x47, 0xb0, 0x37, 0x4a, 0x53, 0x46, 0x23,
+	0x23, 0x87, 0xb9, 0x7a, 0x9b, 0x78, 0x9d, 0xd6, 0xad, 0x3f, 0x8d, 0x08, 0xc7, 0x92, 0x0a, 0xe3,
+	0x66, 0xd5, 0xaa, 0x70, 0xe5, 0xfe, 0x6d, 0x57, 0xfb, 0x77, 0x0a, 0x7b, 0xd3, 0x68, 0x46, 0xe2,
+	0x05, 0x2b, 0x8a, 0xf3, 0xa0, 0x35, 0x4a, 0x53, 0x57, 0x94, 0xfe, 0x59, 0x08, 0xd4, 0x5c, 0x09,
+	0xa4, 0x05, 0x99, 0x2a, 0x89, 0x15, 0x49, 0x96, 0xf9, 0x05, 0xe5, 0x38, 0xf8, 0xab, 0x0d, 0x3b,
+	0x77, 0x0b, 0x4e, 0x79, 0x52, 0x7a, 0x13, 0xbc, 0xd4, 0xbe, 0xdc, 0xb5, 0x2f, 0xe1, 0x09, 0xe5,
+	0x79, 0x5e, 0x87, 0x74, 0xb1, 0x91, 0x2b, 0xb6, 0x65, 0x8b, 0x75, 0x10, 0xbd, 0x82, 0x4e, 0xa6,
+	0xb0, 0x22, 0xe6, 0x23, 0x76, 0x4f, 0x5f, 0x1e, 0xe7, 0x03, 0xa4, 0x72, 0xd8, 0x71, 0x66, 0x9e,
+	0x41, 0x68, 0x7d, 0xb5, 0x3e, 0x21, 0xe6, 0xb1, 0x78, 0x9c, 0x2a, 0x2c, 0x55, 0x66, 0x9a, 0xa2,
+	0x13, 0x56, 0x38, 0x74, 0x02, 0x9f, 0x5e, 0x11, 0xac, 0x16, 0x92, 0x5c, 0x51, 0xa6, 0x88, 0xbc,
+	0xb4, 0x75, 0xd9, 0x3e, 0xa9, 0x33, 0xa1, 0x63, 0x40, 0x15, 0x7a, 0xbc, 0x8c, 0x98, 0xed, 0xa0,
+	0x4e, 0x58, 0x63, 0xf9, 0x97, 0xff, 0x44, 0x11, 0x99, 0xf9, 0xfd, 0x1a, 0x7f, 0x63, 0xd1, 0x22,
+	0x84, 0xfa, 0x49, 0x49, 0xe5, 0x0f, 0x0e, 0x1b, 0x47, 0xfd, 0x30, 0x87, 0xe8, 0x4b, 0xd8, 0xa9,
+	0xf8, 0xfb, 0x60, 0xec, 0x55, 0x12, 0x7d, 0x05, 0x03, 0x2b, 0xca, 0x8d, 0x48, 0xfc, 0xe1, 0x61,
+	0xe3, 0x68, 0x78, 0xba, 0xbf, 0x26, 0xd7, 0x8f, 0x34, 0x53, 0x42, 0x2e, 0xc3, 0x95, 0x63, 0xf0,
+	0x47, 0x03, 0xba, 0x56, 0x3d, 0x34, 0x84, 0xde, 0xb5, 0xb8, 0x9f, 0x70, 0xaa, 0xbc, 0x2d, 0xb4,
+	0x0b, 0x70, 0x2d, 0xee, 0x5d, 0x05, 0x5e, 0x03, 0xed, 0xc0, 0xe0, 0x9c, 0xf0, 0x68, 0x76, 0x8b,
+	0xe5, 0xdc, 0x6b, 0x6a, 0x5f, 0x6d, 0x13, 0x92, 0x78, 0x2d, 0x04, 0xd0, 0xbd, 0xe4, 0x31, 0xe5,
+	0x89, 0xd7, 0xd6, 0x86, 0x0b, 0x9a, 0xa5, 0x0c, 0x2f, 0xbd, 0x8e, 0x4e, 0x32, 0x5d, 0xf2, 0x68,
+	0x2c, 0xf8, 0x03, 0x4d, 0xbc, 0xae, 0x76, 0xbc, 0x20, 0x0a, 0x53, 0xe6, 0xf5, 0x74, 0xc2, 0xbb,
+	0x99, 0x24, 0xd9, 0x4c, 0xb0, 0xd8, 0xeb, 0x07, 0xbf, 0xe5, 0xfd, 0xe3, 0x6a, 0xd4, 0xdd, 0x76,
+	0x8e, 0x33, 0x72, 0x99, 0x8f, 0x91, 0x41, 0x58, 0x60, 0x2d, 0xd5, 0x2d, 0xe5, 0xc6, 0x64, 0x1b,
+	0x29, 0x87, 0x66, 0x54, 0x09, 0x85, 0x99, 0x1e, 0x4f, 0xa6, 0x97, 0x5a, 0xe1, 0x8a, 0x70, 0xe3,
+	0x53, 0xb7, 0x44, 0xdb, 0x5c, 0x83, 0x43, 0xa7, 0xbf, 0xf7, 0x8b, 0xe9, 0x78, 0x9b, 0x48, 0xf4,
+	0x35, 0xf4, 0x1c, 0x42, 0x2f, 0x0a, 0x05, 0x4b, 0x0b, 0xe3, 0xe0, 0x93, 0x82, 0xcd, 0xa7, 0x75,
+	0xb0, 0x75, 0xd2, 0x40, 0xdf, 0x83, 0x67, 0x80, 0x96, 0xf0, 0x59, 0x09, 0xce, 0xa0, 0x9f, 0xaf,
+	0x16, 0xe4, 0xaf, 0x5c, 0xaa, 0xdb, 0x66, 0x53, 0xf0, 0x1b, 0xe8, 0x5a, 0x05, 0xd1, 0x7e, 0xfd,
+	0x2b, 0x39, 0xd8, 0xc0, 0x07, 0x5b, 0x47, 0x0d, 0x13, 0xbf, 0xad, 0x77, 0x70, 0x31, 0x73, 0xeb,
+	0x2b, 0x5f, 0xb1, 0xa5, 0x85, 0x6d, 0xce, 0x7f, 0x0d, 0xbb, 0xef, 0xd3, 0x44, 0xe2, 0x98, 0x3c,
+	0xeb, 0xdb, 0x5f, 0xc3, 0x50, 0x9b, 0xff, 0x3b, 0xb6, 0x96, 0x35, 0xe1, 0x23, 0x40, 0x26, 0x97,
+	0xdd, 0xf0, 0xcf, 0xaa, 0xe0, 0x0d, 0xec, 0x39, 0xaf, 0x50, 0x30, 0x76, 0x8f, 0xa3, 0xf9, 0x47,
+	0xc7, 0x8f, 0x67, 0x58, 0x0f, 0x44, 0x49, 0x7f, 0xb5, 0x3b, 0xed, 0xa3, 0xe2, 0xbf, 0x03, 0x70,
+	0x7b, 0xb4, 0x1a, 0x5a, 0x5a, 0xae, 0x9b, 0x42, 0xbf, 0x85, 0xbe, 0xd9, 0x5d, 0xfa, 0xf6, 0x3f,
+	0x5b, 0xdd, 0x72, 0x69, 0x9d, 0x6d, 0x8a, 0x3c, 0xd1, 0x4f, 0x52, 0x2f, 0xaa, 0x52, 0xd7, 0x54,
+	0x36, 0xd7, 0xc1, 0x76, 0x39, 0x30, 0xd8, 0x42, 0xc7, 0x3a, 0x82, 0x11, 0xb5, 0x49, 0xdd, 0x1a,
+	0xff, 0xf7, 0x69, 0x8c, 0xff, 0xb7, 0xff, 0x19, 0xf4, 0xf3, 0xfd, 0x54, 0x7a, 0x04, 0x6b, 0x2b,
+	0x6b, 0xd3, 0xe7, 0x7c, 0x03, 0xfd, 0x1f, 0x08, 0x27, 0x72, 0xf3, 0x71, 0xf5, 0x81, 0xf7, 0x5d,
+	0xf3, 0x8f, 0xf4, 0xd5, 0x3f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x54, 0xcc, 0x49, 0x50, 0xa2, 0x0a,
+	0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.

api/profile/profile.proto

@@ -117,7 +117,8 @@ message TuningMessage {
     int32 FeatureFilterCycle = 7;
     int32 FeatureFilterIters = 8;
     bool Restart = 9;
-    TuningHistory TuningLog = 10;
+    bool FeatureFilter = 10;
+    TuningHistory TuningLog = 11;
 }
 
 message TuningHistory {

common/project/projet.go

@@ -112,7 +112,7 @@ type RelationShip struct {
 }
 
 // BenchMark method call the benchmark script
-func (y *YamlPrjCli) BenchMark() (string, error) {
+func (y *YamlPrjCli) BenchMark(featureFilter bool) (string, error) {
 	benchStr := make([]string, 0)
 
 	benchOutByte, err := ExecCommand(y.Benchmark)
@@ -146,10 +146,11 @@ func (y *YamlPrjCli) BenchMark() (string, error) {
 		benchStr = append(benchStr, evaluation.Name+"="+out)
 	}
 
-	if sum < y.EvalMin {
-		y.EvalMin = sum
+	if !featureFilter {
+		if sum < y.EvalMin {
+			y.EvalMin = sum
+		}
 	}
-
 	if utils.IsEquals(y.EvalBase, 0.0) {
 		y.EvalBase = sum
 		y.EvalMin = sum

common/tuning/optimizer.go

@@ -204,6 +204,7 @@ DynamicTuned method using bayes algorithm to search the best performance paramet
 func (o *Optimizer) DynamicTuned(ch chan *PB.TuningMessage, stopCh chan int) error {
 	var evalValue string
 	var err error
+	var message string
 	if o.Content != nil {
 		evalValue, err = o.evalParsing(ch)
 		if err != nil {
@@ -257,18 +258,19 @@ func (o *Optimizer) DynamicTuned(ch chan *PB.TuningMessage, stopCh chan int) err
 	o.StartIterTime = time.Now().Format(config.DefaultTimeFormat)
 
 	if o.RespPutIns.Finished {
-		finalEval := strings.Replace(o.FinalEval, "=-", "=", -1)
-		optimizationTerm := fmt.Sprintf("\n The final optimization result is: %s\n"+
-			" The final evaluation value is: %s\n", o.RespPutIns.Param, finalEval)
-		log.Info(optimizationTerm)
-		ch <- &PB.TuningMessage{State: PB.TuningMessage_Display, Content: []byte(optimizationTerm)}
-
 		remainParams := o.filterParams()
-		if o.FeatureFilter {
-			message := fmt.Sprintf(" The selected most important parameters is:\n"+
-				" %s(%d->%d)\n", remainParams,
+		if !o.FeatureFilter {
+			finalEval := strings.Replace(o.FinalEval, "=-", "=", -1)
+			message = fmt.Sprintf("\n The final optimization result is: %s\n"+
+				" The final evaluation value is: %s\n", o.RespPutIns.Param, finalEval)
+			log.Info(message)
+			ch <- &PB.TuningMessage{State: PB.TuningMessage_Display, Content: []byte(message)}
+		} else {
+			message = fmt.Sprintf("\n Parameters reduced from %d to %d.",
 				len(strings.Split(o.RespPutIns.Param, ",")), len(strings.Split(remainParams, ",")))
 			ch <- &PB.TuningMessage{State: PB.TuningMessage_Display, Content: []byte(message)}
+			message = fmt.Sprintf("The selected most important parameters is:\n %s\n", remainParams)
+			ch <- &PB.TuningMessage{State: PB.TuningMessage_Display, Content: []byte(message)}
 		}
 
 		stopCh <- 1
@@ -287,8 +289,9 @@ func (o *Optimizer) DynamicTuned(ch chan *PB.TuningMessage, stopCh chan int) err
 	evalMinSum := fmt.Sprintf("%s=%.2f", project.MIN_BENCHMARK_VALUE, o.MinEvalSum)
 	log.Infof("send back to client to start benchmark")
 	ch <- &PB.TuningMessage{State: PB.TuningMessage_BenchMark,
-		Content:   []byte(o.RespPutIns.Param),
-		TuningLog: &PB.TuningHistory{BaseEval: o.EvalBase, MinEval: evalMinSum, TotalTime: int64(o.TotalTime), Starts: int32(o.Iter)}}
+		Content:       []byte(o.RespPutIns.Param),
+		FeatureFilter: o.FeatureFilter,
+		TuningLog:     &PB.TuningHistory{BaseEval: o.EvalBase, MinEval: evalMinSum, TotalTime: int64(o.TotalTime), Starts: int32(o.Iter)}}
 	return nil
 }
 

modules/client/profile/profile_tuning.go

@@ -104,8 +104,23 @@ func profileTunning(ctx *cli.Context) error {
 		return err
 	}
 	err := runTuningRPC(ctx, func(stream PB.ProfileMgr_TuningClient) error {
+		finished := make(chan bool)
+		errors := make(chan error)
+		var init bool = false
+		go func() {
+			if !ctx.Bool("restart") {
+				fmt.Println("Start to benchmark baseline...")
+				benchmarkByte, err := prj.BenchMark(true)
+				if err != nil {
+					fmt.Println("benchmark result:", benchmarkByte)
+					errors <- err
+				}
+				finished <- true
+				return
+			}
+			finished <- true
+		}()
 		var state PB.TuningMessageStatus = PB.TuningMessage_JobInit
-
 		content := &PB.TuningMessage{
 			Name:                ctx.String("project"),
 			Restart:             ctx.Bool("restart"),
@@ -121,16 +136,6 @@ func profileTunning(ctx *cli.Context) error {
 			return fmt.Errorf("client sends failure, error: %v", err)
 		}
 
-		if prj.FeatureFilterCycle > 0 {
-			fmt.Printf(" Start to benchmark the base performance......\n")
-			benchmarkByte, err := prj.BenchMark()
-			if err != nil {
-				fmt.Println("benchmark result:", benchmarkByte)
-				return err
-			}
-			fmt.Printf(" Base Performance is: %.2f\n", math.Abs(prj.EvalBase))
-		}
-
 		for {
 			reply, err := stream.Recv()
 			if err == io.EOF {
@@ -147,22 +152,38 @@ func profileTunning(ctx *cli.Context) error {
 					return fmt.Errorf("client sends failure, error: %v", err)
 				}
 			case PB.TuningMessage_BenchMark:
+				if !init {
+					select {
+					case err := <-errors:
+						return err
+					case <-finished:
+						break
+					}
+					init = true
+				}
 				if ctx.Bool("restart") {
 					prj.SetHistoryEvalBase(reply.GetTuningLog())
 				}
 				prj.Params = string(reply.GetContent())
-				benchmarkByte, err := prj.BenchMark()
+				benchmarkByte, err := prj.BenchMark(reply.GetFeatureFilter())
 				if err != nil {
 					fmt.Println("benchmark result:", benchmarkByte)
 					return err
 				}
 
 				currentTime := time.Now()
-				fmt.Printf(" Used time: %s, Total Time: %s, Best Performance: %.2f, Performance Improvement Rate: %s%%\n",
-					currentTime.Sub(prj.StartsTime).Round(time.Second).String(),
-					time.Duration(int64(currentTime.Sub(prj.StartsTime).Seconds())+prj.TotalTime)*time.Second,
-					math.Abs(prj.EvalMin), prj.ImproveRateString(prj.EvalMin))
-				if ctx.Bool("detail") {
+				if reply.GetFeatureFilter() {
+					fmt.Printf(" Used time: %s, Total Time: %s, Current Progress......(%d/%d)\n",
+						currentTime.Sub(prj.StartsTime).Round(time.Second).String(),
+						time.Duration(int64(currentTime.Sub(prj.StartsTime).Seconds())+prj.TotalTime)*time.Second,
+						prj.StartIters, prj.FeatureFilterIters)
+				} else {
+					fmt.Printf(" Used time: %s, Total Time: %s, Best Performance: %.2f, Performance Improvement Rate: %s%%\n",
+						currentTime.Sub(prj.StartsTime).Round(time.Second).String(),
+						time.Duration(int64(currentTime.Sub(prj.StartsTime).Seconds())+prj.TotalTime)*time.Second,
+						math.Abs(prj.EvalMin), prj.ImproveRateString(prj.EvalMin))
+				}
+				if ctx.Bool("detail") && !reply.GetFeatureFilter() {
 					fmt.Printf(" The %dth recommand parameters is: %s\n"+
 						" The %dth evaluation value: %s(%s%%)\n", prj.StartIters, prj.Params, prj.StartIters, strings.Replace(benchmarkByte, "-", "", -1), prj.ImproveRateString(prj.EvalCurrent))
 				}