mirror of https://github.com/milvus-io/milvus.git
Implement calculate vectors distance in server (#6219)
* calc distance stage 3 Signed-off-by: yhmo <yihua.mo@zilliz.com> * calc distance stage 5 Signed-off-by: yhmo <yihua.mo@zilliz.com> * calc distance stage 6 Signed-off-by: yhmo <yihua.mo@zilliz.com> * code style Signed-off-by: yhmo <yihua.mo@zilliz.com> * typo Signed-off-by: yhmo <yihua.mo@zilliz.com> * typo Signed-off-by: yhmo <yihua.mo@zilliz.com> * typo Signed-off-by: yhmo <yihua.mo@zilliz.com>pull/6260/head
groot
GitHub
parent
3524d87f9b
commit
a364d7303b
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
|
|
@ -387,6 +387,10 @@ func (s *Server) Query(ctx context.Context, request *milvuspb.QueryRequest) (*mi
|
|||
return s.proxy.Query(ctx, request)
|
||||
}
|
||||
|
||||
func (s *Server) CalcDistance(ctx context.Context, request *milvuspb.CalcDistanceRequest) (*milvuspb.CalcDistanceResults, error) {
|
||||
return s.proxy.CalcDistance(ctx, request)
|
||||
}
|
||||
|
||||
func (s *Server) GetDdChannel(ctx context.Context, request *internalpb.GetDdChannelRequest) (*milvuspb.StringResponse, error) {
|
||||
return s.proxy.GetDdChannel(ctx, request)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -35,6 +35,7 @@ service MilvusService {
|
|||
rpc Retrieve(RetrieveRequest) returns (RetrieveResults) {}
|
||||
rpc Flush(FlushRequest) returns (FlushResponse) {}
|
||||
rpc Query(QueryRequest) returns (QueryResults) {}
|
||||
rpc CalcDistance(CalcDistanceRequest) returns (CalcDistanceResults) {}
|
||||
|
||||
rpc GetPersistentSegmentInfo(GetPersistentSegmentInfoRequest) returns (GetPersistentSegmentInfoResponse) {}
|
||||
rpc GetQuerySegmentInfo(GetQuerySegmentInfoRequest) returns (GetQuerySegmentInfoResponse) {}
|
||||
|
|
@ -389,6 +390,36 @@ message QueryResults {
|
|||
repeated schema.FieldData fields_data = 2;
|
||||
}
|
||||
|
||||
message VectorIDs {
|
||||
string collection_name = 1;
|
||||
string field_name = 2;
|
||||
schema.IDs id_array = 3;
|
||||
repeated string partition_names = 4;
|
||||
}
|
||||
|
||||
message VectorsArray {
|
||||
oneof array {
|
||||
VectorIDs id_array = 1; // vector ids
|
||||
schema.VectorField data_array = 2; // vectors data
|
||||
}
|
||||
}
|
||||
|
||||
message CalcDistanceRequest {
|
||||
common.MsgBase base = 1;
|
||||
VectorsArray op_left = 2; // vectors on the left of operator
|
||||
VectorsArray op_right = 3; // vectors on the right of operator
|
||||
repeated common.KeyValuePair params = 4; // "metric":"L2"/"IP"/"HAMMIN"/"TANIMOTO"
|
||||
}
|
||||
|
||||
message CalcDistanceResults {
|
||||
common.Status status = 1;
|
||||
// num(op_left)*num(op_right) distance values, "HAMMIN" return integer distance
|
||||
oneof array {
|
||||
schema.IntArray int_dist = 2;
|
||||
schema.FloatArray float_dist = 3;
|
||||
}
|
||||
}
|
||||
|
||||
message PersistentSegmentInfo {
|
||||
int64 segmentID = 1;
|
||||
int64 collectionID = 2;
|
||||
|
|
|
|||
|
|
@ -3058,6 +3058,302 @@ func (m *QueryResults) GetFieldsData() []*schemapb.FieldData {
|
|||
return nil
|
||||
}
|
||||
|
||||
type VectorIDs struct {
|
||||
CollectionName string `protobuf:"bytes,1,opt,name=collection_name,json=collectionName,proto3" json:"collection_name,omitempty"`
|
||||
FieldName string `protobuf:"bytes,2,opt,name=field_name,json=fieldName,proto3" json:"field_name,omitempty"`
|
||||
IdArray *schemapb.IDs `protobuf:"bytes,3,opt,name=id_array,json=idArray,proto3" json:"id_array,omitempty"`
|
||||
PartitionNames []string `protobuf:"bytes,4,rep,name=partition_names,json=partitionNames,proto3" json:"partition_names,omitempty"`
|
||||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||||
XXX_unrecognized []byte `json:"-"`
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
func (m *VectorIDs) Reset() { *m = VectorIDs{} }
|
||||
func (m *VectorIDs) String() string { return proto.CompactTextString(m) }
|
||||
func (*VectorIDs) ProtoMessage() {}
|
||||
func (*VectorIDs) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_02345ba45cc0e303, []int{48}
|
||||
}
|
||||
|
||||
func (m *VectorIDs) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_VectorIDs.Unmarshal(m, b)
|
||||
}
|
||||
func (m *VectorIDs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||||
return xxx_messageInfo_VectorIDs.Marshal(b, m, deterministic)
|
||||
}
|
||||
func (m *VectorIDs) XXX_Merge(src proto.Message) {
|
||||
xxx_messageInfo_VectorIDs.Merge(m, src)
|
||||
}
|
||||
func (m *VectorIDs) XXX_Size() int {
|
||||
return xxx_messageInfo_VectorIDs.Size(m)
|
||||
}
|
||||
func (m *VectorIDs) XXX_DiscardUnknown() {
|
||||
xxx_messageInfo_VectorIDs.DiscardUnknown(m)
|
||||
}
|
||||
|
||||
var xxx_messageInfo_VectorIDs proto.InternalMessageInfo
|
||||
|
||||
func (m *VectorIDs) GetCollectionName() string {
|
||||
if m != nil {
|
||||
return m.CollectionName
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
func (m *VectorIDs) GetFieldName() string {
|
||||
if m != nil {
|
||||
return m.FieldName
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
func (m *VectorIDs) GetIdArray() *schemapb.IDs {
|
||||
if m != nil {
|
||||
return m.IdArray
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *VectorIDs) GetPartitionNames() []string {
|
||||
if m != nil {
|
||||
return m.PartitionNames
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
type VectorsArray struct {
|
||||
// Types that are valid to be assigned to Array:
|
||||
// *VectorsArray_IdArray
|
||||
// *VectorsArray_DataArray
|
||||
Array isVectorsArray_Array `protobuf_oneof:"array"`
|
||||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||||
XXX_unrecognized []byte `json:"-"`
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
func (m *VectorsArray) Reset() { *m = VectorsArray{} }
|
||||
func (m *VectorsArray) String() string { return proto.CompactTextString(m) }
|
||||
func (*VectorsArray) ProtoMessage() {}
|
||||
func (*VectorsArray) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_02345ba45cc0e303, []int{49}
|
||||
}
|
||||
|
||||
func (m *VectorsArray) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_VectorsArray.Unmarshal(m, b)
|
||||
}
|
||||
func (m *VectorsArray) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||||
return xxx_messageInfo_VectorsArray.Marshal(b, m, deterministic)
|
||||
}
|
||||
func (m *VectorsArray) XXX_Merge(src proto.Message) {
|
||||
xxx_messageInfo_VectorsArray.Merge(m, src)
|
||||
}
|
||||
func (m *VectorsArray) XXX_Size() int {
|
||||
return xxx_messageInfo_VectorsArray.Size(m)
|
||||
}
|
||||
func (m *VectorsArray) XXX_DiscardUnknown() {
|
||||
xxx_messageInfo_VectorsArray.DiscardUnknown(m)
|
||||
}
|
||||
|
||||
var xxx_messageInfo_VectorsArray proto.InternalMessageInfo
|
||||
|
||||
type isVectorsArray_Array interface {
|
||||
isVectorsArray_Array()
|
||||
}
|
||||
|
||||
type VectorsArray_IdArray struct {
|
||||
IdArray *VectorIDs `protobuf:"bytes,1,opt,name=id_array,json=idArray,proto3,oneof"`
|
||||
}
|
||||
|
||||
type VectorsArray_DataArray struct {
|
||||
DataArray *schemapb.VectorField `protobuf:"bytes,2,opt,name=data_array,json=dataArray,proto3,oneof"`
|
||||
}
|
||||
|
||||
func (*VectorsArray_IdArray) isVectorsArray_Array() {}
|
||||
|
||||
func (*VectorsArray_DataArray) isVectorsArray_Array() {}
|
||||
|
||||
func (m *VectorsArray) GetArray() isVectorsArray_Array {
|
||||
if m != nil {
|
||||
return m.Array
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *VectorsArray) GetIdArray() *VectorIDs {
|
||||
if x, ok := m.GetArray().(*VectorsArray_IdArray); ok {
|
||||
return x.IdArray
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *VectorsArray) GetDataArray() *schemapb.VectorField {
|
||||
if x, ok := m.GetArray().(*VectorsArray_DataArray); ok {
|
||||
return x.DataArray
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// XXX_OneofWrappers is for the internal use of the proto package.
|
||||
func (*VectorsArray) XXX_OneofWrappers() []interface{} {
|
||||
return []interface{}{
|
||||
(*VectorsArray_IdArray)(nil),
|
||||
(*VectorsArray_DataArray)(nil),
|
||||
}
|
||||
}
|
||||
|
||||
type CalcDistanceRequest struct {
|
||||
Base *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
|
||||
OpLeft *VectorsArray `protobuf:"bytes,2,opt,name=op_left,json=opLeft,proto3" json:"op_left,omitempty"`
|
||||
OpRight *VectorsArray `protobuf:"bytes,3,opt,name=op_right,json=opRight,proto3" json:"op_right,omitempty"`
|
||||
Params []*commonpb.KeyValuePair `protobuf:"bytes,4,rep,name=params,proto3" json:"params,omitempty"`
|
||||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||||
XXX_unrecognized []byte `json:"-"`
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
func (m *CalcDistanceRequest) Reset() { *m = CalcDistanceRequest{} }
|
||||
func (m *CalcDistanceRequest) String() string { return proto.CompactTextString(m) }
|
||||
func (*CalcDistanceRequest) ProtoMessage() {}
|
||||
func (*CalcDistanceRequest) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_02345ba45cc0e303, []int{50}
|
||||
}
|
||||
|
||||
func (m *CalcDistanceRequest) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_CalcDistanceRequest.Unmarshal(m, b)
|
||||
}
|
||||
func (m *CalcDistanceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||||
return xxx_messageInfo_CalcDistanceRequest.Marshal(b, m, deterministic)
|
||||
}
|
||||
func (m *CalcDistanceRequest) XXX_Merge(src proto.Message) {
|
||||
xxx_messageInfo_CalcDistanceRequest.Merge(m, src)
|
||||
}
|
||||
func (m *CalcDistanceRequest) XXX_Size() int {
|
||||
return xxx_messageInfo_CalcDistanceRequest.Size(m)
|
||||
}
|
||||
func (m *CalcDistanceRequest) XXX_DiscardUnknown() {
|
||||
xxx_messageInfo_CalcDistanceRequest.DiscardUnknown(m)
|
||||
}
|
||||
|
||||
var xxx_messageInfo_CalcDistanceRequest proto.InternalMessageInfo
|
||||
|
||||
func (m *CalcDistanceRequest) GetBase() *commonpb.MsgBase {
|
||||
if m != nil {
|
||||
return m.Base
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *CalcDistanceRequest) GetOpLeft() *VectorsArray {
|
||||
if m != nil {
|
||||
return m.OpLeft
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *CalcDistanceRequest) GetOpRight() *VectorsArray {
|
||||
if m != nil {
|
||||
return m.OpRight
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *CalcDistanceRequest) GetParams() []*commonpb.KeyValuePair {
|
||||
if m != nil {
|
||||
return m.Params
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
type CalcDistanceResults struct {
|
||||
Status *commonpb.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
|
||||
// num(op_left)*num(op_right) distance values, "HAMMIN" return integer distance
|
||||
//
|
||||
// Types that are valid to be assigned to Array:
|
||||
// *CalcDistanceResults_IntDist
|
||||
// *CalcDistanceResults_FloatDist
|
||||
Array isCalcDistanceResults_Array `protobuf_oneof:"array"`
|
||||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||||
XXX_unrecognized []byte `json:"-"`
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
func (m *CalcDistanceResults) Reset() { *m = CalcDistanceResults{} }
|
||||
func (m *CalcDistanceResults) String() string { return proto.CompactTextString(m) }
|
||||
func (*CalcDistanceResults) ProtoMessage() {}
|
||||
func (*CalcDistanceResults) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_02345ba45cc0e303, []int{51}
|
||||
}
|
||||
|
||||
func (m *CalcDistanceResults) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_CalcDistanceResults.Unmarshal(m, b)
|
||||
}
|
||||
func (m *CalcDistanceResults) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||||
return xxx_messageInfo_CalcDistanceResults.Marshal(b, m, deterministic)
|
||||
}
|
||||
func (m *CalcDistanceResults) XXX_Merge(src proto.Message) {
|
||||
xxx_messageInfo_CalcDistanceResults.Merge(m, src)
|
||||
}
|
||||
func (m *CalcDistanceResults) XXX_Size() int {
|
||||
return xxx_messageInfo_CalcDistanceResults.Size(m)
|
||||
}
|
||||
func (m *CalcDistanceResults) XXX_DiscardUnknown() {
|
||||
xxx_messageInfo_CalcDistanceResults.DiscardUnknown(m)
|
||||
}
|
||||
|
||||
var xxx_messageInfo_CalcDistanceResults proto.InternalMessageInfo
|
||||
|
||||
func (m *CalcDistanceResults) GetStatus() *commonpb.Status {
|
||||
if m != nil {
|
||||
return m.Status
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
type isCalcDistanceResults_Array interface {
|
||||
isCalcDistanceResults_Array()
|
||||
}
|
||||
|
||||
type CalcDistanceResults_IntDist struct {
|
||||
IntDist *schemapb.IntArray `protobuf:"bytes,2,opt,name=int_dist,json=intDist,proto3,oneof"`
|
||||
}
|
||||
|
||||
type CalcDistanceResults_FloatDist struct {
|
||||
FloatDist *schemapb.FloatArray `protobuf:"bytes,3,opt,name=float_dist,json=floatDist,proto3,oneof"`
|
||||
}
|
||||
|
||||
func (*CalcDistanceResults_IntDist) isCalcDistanceResults_Array() {}
|
||||
|
||||
func (*CalcDistanceResults_FloatDist) isCalcDistanceResults_Array() {}
|
||||
|
||||
func (m *CalcDistanceResults) GetArray() isCalcDistanceResults_Array {
|
||||
if m != nil {
|
||||
return m.Array
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *CalcDistanceResults) GetIntDist() *schemapb.IntArray {
|
||||
if x, ok := m.GetArray().(*CalcDistanceResults_IntDist); ok {
|
||||
return x.IntDist
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *CalcDistanceResults) GetFloatDist() *schemapb.FloatArray {
|
||||
if x, ok := m.GetArray().(*CalcDistanceResults_FloatDist); ok {
|
||||
return x.FloatDist
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// XXX_OneofWrappers is for the internal use of the proto package.
|
||||
func (*CalcDistanceResults) XXX_OneofWrappers() []interface{} {
|
||||
return []interface{}{
|
||||
(*CalcDistanceResults_IntDist)(nil),
|
||||
(*CalcDistanceResults_FloatDist)(nil),
|
||||
}
|
||||
}
|
||||
|
||||
type PersistentSegmentInfo struct {
|
||||
SegmentID int64 `protobuf:"varint,1,opt,name=segmentID,proto3" json:"segmentID,omitempty"`
|
||||
CollectionID int64 `protobuf:"varint,2,opt,name=collectionID,proto3" json:"collectionID,omitempty"`
|
||||
|
|
@ -3073,7 +3369,7 @@ func (m *PersistentSegmentInfo) Reset() { *m = PersistentSegmentInfo{} }
|
|||
func (m *PersistentSegmentInfo) String() string { return proto.CompactTextString(m) }
|
||||
func (*PersistentSegmentInfo) ProtoMessage() {}
|
||||
func (*PersistentSegmentInfo) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_02345ba45cc0e303, []int{48}
|
||||
return fileDescriptor_02345ba45cc0e303, []int{52}
|
||||
}
|
||||
|
||||
func (m *PersistentSegmentInfo) XXX_Unmarshal(b []byte) error {
|
||||
|
|
@ -3142,7 +3438,7 @@ func (m *GetPersistentSegmentInfoRequest) Reset() { *m = GetPersistentSe
|
|||
func (m *GetPersistentSegmentInfoRequest) String() string { return proto.CompactTextString(m) }
|
||||
func (*GetPersistentSegmentInfoRequest) ProtoMessage() {}
|
||||
func (*GetPersistentSegmentInfoRequest) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_02345ba45cc0e303, []int{49}
|
||||
return fileDescriptor_02345ba45cc0e303, []int{53}
|
||||
}
|
||||
|
||||
func (m *GetPersistentSegmentInfoRequest) XXX_Unmarshal(b []byte) error {
|
||||
|
|
@ -3196,7 +3492,7 @@ func (m *GetPersistentSegmentInfoResponse) Reset() { *m = GetPersistentS
|
|||
func (m *GetPersistentSegmentInfoResponse) String() string { return proto.CompactTextString(m) }
|
||||
func (*GetPersistentSegmentInfoResponse) ProtoMessage() {}
|
||||
func (*GetPersistentSegmentInfoResponse) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_02345ba45cc0e303, []int{50}
|
||||
return fileDescriptor_02345ba45cc0e303, []int{54}
|
||||
}
|
||||
|
||||
func (m *GetPersistentSegmentInfoResponse) XXX_Unmarshal(b []byte) error {
|
||||
|
|
@ -3248,7 +3544,7 @@ func (m *QuerySegmentInfo) Reset() { *m = QuerySegmentInfo{} }
|
|||
func (m *QuerySegmentInfo) String() string { return proto.CompactTextString(m) }
|
||||
func (*QuerySegmentInfo) ProtoMessage() {}
|
||||
func (*QuerySegmentInfo) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_02345ba45cc0e303, []int{51}
|
||||
return fileDescriptor_02345ba45cc0e303, []int{55}
|
||||
}
|
||||
|
||||
func (m *QuerySegmentInfo) XXX_Unmarshal(b []byte) error {
|
||||
|
|
@ -3331,7 +3627,7 @@ func (m *GetQuerySegmentInfoRequest) Reset() { *m = GetQuerySegmentInfoR
|
|||
func (m *GetQuerySegmentInfoRequest) String() string { return proto.CompactTextString(m) }
|
||||
func (*GetQuerySegmentInfoRequest) ProtoMessage() {}
|
||||
func (*GetQuerySegmentInfoRequest) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_02345ba45cc0e303, []int{52}
|
||||
return fileDescriptor_02345ba45cc0e303, []int{56}
|
||||
}
|
||||
|
||||
func (m *GetQuerySegmentInfoRequest) XXX_Unmarshal(b []byte) error {
|
||||
|
|
@ -3385,7 +3681,7 @@ func (m *GetQuerySegmentInfoResponse) Reset() { *m = GetQuerySegmentInfo
|
|||
func (m *GetQuerySegmentInfoResponse) String() string { return proto.CompactTextString(m) }
|
||||
func (*GetQuerySegmentInfoResponse) ProtoMessage() {}
|
||||
func (*GetQuerySegmentInfoResponse) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_02345ba45cc0e303, []int{53}
|
||||
return fileDescriptor_02345ba45cc0e303, []int{57}
|
||||
}
|
||||
|
||||
func (m *GetQuerySegmentInfoResponse) XXX_Unmarshal(b []byte) error {
|
||||
|
|
@ -3431,7 +3727,7 @@ func (m *DummyRequest) Reset() { *m = DummyRequest{} }
|
|||
func (m *DummyRequest) String() string { return proto.CompactTextString(m) }
|
||||
func (*DummyRequest) ProtoMessage() {}
|
||||
func (*DummyRequest) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_02345ba45cc0e303, []int{54}
|
||||
return fileDescriptor_02345ba45cc0e303, []int{58}
|
||||
}
|
||||
|
||||
func (m *DummyRequest) XXX_Unmarshal(b []byte) error {
|
||||
|
|
@ -3470,7 +3766,7 @@ func (m *DummyResponse) Reset() { *m = DummyResponse{} }
|
|||
func (m *DummyResponse) String() string { return proto.CompactTextString(m) }
|
||||
func (*DummyResponse) ProtoMessage() {}
|
||||
func (*DummyResponse) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_02345ba45cc0e303, []int{55}
|
||||
return fileDescriptor_02345ba45cc0e303, []int{59}
|
||||
}
|
||||
|
||||
func (m *DummyResponse) XXX_Unmarshal(b []byte) error {
|
||||
|
|
@ -3508,7 +3804,7 @@ func (m *RegisterLinkRequest) Reset() { *m = RegisterLinkRequest{} }
|
|||
func (m *RegisterLinkRequest) String() string { return proto.CompactTextString(m) }
|
||||
func (*RegisterLinkRequest) ProtoMessage() {}
|
||||
func (*RegisterLinkRequest) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_02345ba45cc0e303, []int{56}
|
||||
return fileDescriptor_02345ba45cc0e303, []int{60}
|
||||
}
|
||||
|
||||
func (m *RegisterLinkRequest) XXX_Unmarshal(b []byte) error {
|
||||
|
|
@ -3541,7 +3837,7 @@ func (m *RegisterLinkResponse) Reset() { *m = RegisterLinkResponse{} }
|
|||
func (m *RegisterLinkResponse) String() string { return proto.CompactTextString(m) }
|
||||
func (*RegisterLinkResponse) ProtoMessage() {}
|
||||
func (*RegisterLinkResponse) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_02345ba45cc0e303, []int{57}
|
||||
return fileDescriptor_02345ba45cc0e303, []int{61}
|
||||
}
|
||||
|
||||
func (m *RegisterLinkResponse) XXX_Unmarshal(b []byte) error {
|
||||
|
|
@ -3628,6 +3924,10 @@ func init() {
|
|||
proto.RegisterMapType((map[string]*schemapb.LongArray)(nil), "milvus.proto.milvus.FlushResponse.CollSegIDsEntry")
|
||||
proto.RegisterType((*QueryRequest)(nil), "milvus.proto.milvus.QueryRequest")
|
||||
proto.RegisterType((*QueryResults)(nil), "milvus.proto.milvus.QueryResults")
|
||||
proto.RegisterType((*VectorIDs)(nil), "milvus.proto.milvus.VectorIDs")
|
||||
proto.RegisterType((*VectorsArray)(nil), "milvus.proto.milvus.VectorsArray")
|
||||
proto.RegisterType((*CalcDistanceRequest)(nil), "milvus.proto.milvus.CalcDistanceRequest")
|
||||
proto.RegisterType((*CalcDistanceResults)(nil), "milvus.proto.milvus.CalcDistanceResults")
|
||||
proto.RegisterType((*PersistentSegmentInfo)(nil), "milvus.proto.milvus.PersistentSegmentInfo")
|
||||
proto.RegisterType((*GetPersistentSegmentInfoRequest)(nil), "milvus.proto.milvus.GetPersistentSegmentInfoRequest")
|
||||
proto.RegisterType((*GetPersistentSegmentInfoResponse)(nil), "milvus.proto.milvus.GetPersistentSegmentInfoResponse")
|
||||
|
|
@ -3643,173 +3943,187 @@ func init() {
|
|||
func init() { proto.RegisterFile("milvus.proto", fileDescriptor_02345ba45cc0e303) }
|
||||
|
||||
var fileDescriptor_02345ba45cc0e303 = []byte{
|
||||
// 2643 bytes of a gzipped FileDescriptorProto
|
||||
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x3a, 0xcd, 0x6f, 0xdc, 0xc6,
|
||||
0xf5, 0x9a, 0x5d, 0xed, 0xd7, 0x5b, 0xae, 0xb4, 0x19, 0x7d, 0x6d, 0xd6, 0x1f, 0x91, 0x98, 0xf8,
|
||||
0x17, 0x59, 0x76, 0xa4, 0x44, 0xb6, 0x7f, 0x49, 0x3f, 0x53, 0xdb, 0xaa, 0x6d, 0xc1, 0x1f, 0x55,
|
||||
0xb8, 0x6e, 0xd0, 0x34, 0x30, 0x16, 0xd4, 0x72, 0xbc, 0x4b, 0x88, 0x4b, 0x6e, 0x39, 0xa4, 0xe4,
|
||||
0xf5, 0xa9, 0x80, 0xd3, 0x02, 0x45, 0x5b, 0x07, 0x45, 0x83, 0x02, 0xed, 0xa1, 0x28, 0x5a, 0xe4,
|
||||
0xd0, 0x53, 0x5b, 0xa4, 0x40, 0x81, 0x9e, 0x7a, 0xc8, 0xa1, 0x87, 0x02, 0x2d, 0x7a, 0xed, 0xb5,
|
||||
0x3d, 0xe6, 0x7f, 0x28, 0x38, 0x43, 0x72, 0x49, 0x6a, 0xb8, 0x5a, 0x79, 0xe3, 0x4a, 0xba, 0x91,
|
||||
0x6f, 0xde, 0x9b, 0x79, 0xdf, 0xf3, 0xe6, 0xcd, 0x80, 0xd4, 0xd5, 0x8d, 0x5d, 0x97, 0xae, 0xf6,
|
||||
0x6c, 0xcb, 0xb1, 0xf0, 0x4c, 0xf4, 0x6f, 0x95, 0xff, 0xd4, 0xa5, 0x96, 0xd5, 0xed, 0x5a, 0x26,
|
||||
0x07, 0xd6, 0x25, 0xda, 0xea, 0x90, 0xae, 0xca, 0xff, 0xe4, 0x4f, 0x11, 0x2c, 0x5c, 0xb7, 0x89,
|
||||
0xea, 0x90, 0xeb, 0x96, 0x61, 0x90, 0x96, 0xa3, 0x5b, 0xa6, 0x42, 0xbe, 0xe3, 0x12, 0xea, 0xe0,
|
||||
0xd7, 0x61, 0x72, 0x5b, 0xa5, 0xa4, 0x86, 0x16, 0xd1, 0x72, 0x79, 0xfd, 0xf4, 0x6a, 0x6c, 0x6e,
|
||||
0x7f, 0xce, 0xbb, 0xb4, 0x7d, 0x4d, 0xa5, 0x44, 0x61, 0x98, 0x78, 0x01, 0x0a, 0xda, 0x76, 0xd3,
|
||||
0x54, 0xbb, 0xa4, 0x96, 0x59, 0x44, 0xcb, 0x25, 0x25, 0xaf, 0x6d, 0xdf, 0x53, 0xbb, 0x04, 0xbf,
|
||||
0x0a, 0xd3, 0xad, 0x70, 0x7e, 0x8e, 0x90, 0x65, 0x08, 0x53, 0x03, 0x30, 0x43, 0x9c, 0x87, 0x3c,
|
||||
0xe7, 0xaf, 0x36, 0xb9, 0x88, 0x96, 0x25, 0xc5, 0xff, 0xc3, 0x67, 0x00, 0x68, 0x47, 0xb5, 0x35,
|
||||
0xda, 0x34, 0xdd, 0x6e, 0x2d, 0xb7, 0x88, 0x96, 0x73, 0x4a, 0x89, 0x43, 0xee, 0xb9, 0x5d, 0xf9,
|
||||
0x87, 0x08, 0xe6, 0x36, 0x6c, 0xab, 0x77, 0x2c, 0x84, 0x90, 0x7f, 0x8b, 0x60, 0xf6, 0x96, 0x4a,
|
||||
0x8f, 0x87, 0x46, 0xcf, 0x00, 0x38, 0x7a, 0x97, 0x34, 0xa9, 0xa3, 0x76, 0x7b, 0x4c, 0xab, 0x93,
|
||||
0x4a, 0xc9, 0x83, 0x34, 0x3c, 0x80, 0xfc, 0x1e, 0x48, 0xd7, 0x2c, 0xcb, 0x50, 0x08, 0xed, 0x59,
|
||||
0x26, 0x25, 0xf8, 0x12, 0xe4, 0xa9, 0xa3, 0x3a, 0x2e, 0xf5, 0x99, 0x3c, 0x25, 0x64, 0xb2, 0xc1,
|
||||
0x50, 0x14, 0x1f, 0x15, 0xcf, 0x42, 0x6e, 0x57, 0x35, 0x5c, 0xce, 0x63, 0x51, 0xe1, 0x3f, 0xf2,
|
||||
0xfb, 0x30, 0xd5, 0x70, 0x6c, 0xdd, 0x6c, 0x7f, 0x8e, 0x93, 0x97, 0x82, 0xc9, 0xff, 0x89, 0xe0,
|
||||
0xc5, 0x0d, 0x42, 0x5b, 0xb6, 0xbe, 0x7d, 0x4c, 0x5c, 0x57, 0x06, 0x69, 0x00, 0xd9, 0xdc, 0x60,
|
||||
0xaa, 0xce, 0x2a, 0x31, 0x58, 0xc2, 0x18, 0xb9, 0xa4, 0x31, 0x7e, 0x99, 0x81, 0xba, 0x48, 0xa8,
|
||||
0x71, 0xd4, 0xf7, 0x95, 0x30, 0xa2, 0x32, 0x8c, 0xe8, 0x5c, 0x9c, 0xc8, 0xcf, 0x06, 0x83, 0xd5,
|
||||
0x1a, 0x0c, 0x10, 0x06, 0x5e, 0x52, 0xaa, 0xac, 0x40, 0xaa, 0x75, 0x98, 0xdb, 0xd5, 0x6d, 0xc7,
|
||||
0x55, 0x8d, 0x66, 0xab, 0xa3, 0x9a, 0x26, 0x31, 0x98, 0x9e, 0x68, 0x6d, 0x72, 0x31, 0xbb, 0x5c,
|
||||
0x52, 0x66, 0xfc, 0xc1, 0xeb, 0x7c, 0xcc, 0x53, 0x16, 0xc5, 0x97, 0x61, 0xbe, 0xd7, 0xe9, 0x53,
|
||||
0xbd, 0xb5, 0x8f, 0x28, 0xc7, 0x88, 0x66, 0x83, 0xd1, 0x28, 0x15, 0x8b, 0xf3, 0x3b, 0x96, 0xaa,
|
||||
0x1d, 0x8f, 0x38, 0x7f, 0x8a, 0xa0, 0xa6, 0x10, 0x83, 0xa8, 0xf4, 0x78, 0xb8, 0xa0, 0xfc, 0x11,
|
||||
0x82, 0xb3, 0x37, 0x89, 0x13, 0x31, 0xa6, 0xa3, 0x3a, 0x3a, 0x75, 0xf4, 0x16, 0x3d, 0x4a, 0xb6,
|
||||
0x3e, 0x44, 0xf0, 0x52, 0x2a, 0x5b, 0xe3, 0xf8, 0xf6, 0x9b, 0x90, 0xf3, 0xbe, 0x68, 0x2d, 0xb3,
|
||||
0x98, 0x5d, 0x2e, 0xaf, 0x2f, 0x09, 0x69, 0x6e, 0x93, 0xfe, 0xbb, 0x5e, 0xca, 0xd8, 0x52, 0x75,
|
||||
0x5b, 0xe1, 0xf8, 0xf2, 0x5f, 0x10, 0xcc, 0x37, 0x3a, 0xd6, 0xde, 0x80, 0xa5, 0xe7, 0xa1, 0xa0,
|
||||
0x78, 0xb4, 0x67, 0x13, 0xd1, 0x8e, 0xbf, 0x0c, 0x93, 0x4e, 0xbf, 0x47, 0x58, 0xa2, 0x98, 0x5a,
|
||||
0x5f, 0x5e, 0x15, 0xec, 0xdd, 0xab, 0x09, 0x26, 0xef, 0xf7, 0x7b, 0x44, 0x61, 0x54, 0xf2, 0xaf,
|
||||
0x10, 0x2c, 0xec, 0x13, 0x61, 0x1c, 0x65, 0x9e, 0x87, 0x6a, 0xc2, 0x9c, 0x5c, 0xaf, 0x25, 0x65,
|
||||
0x3a, 0x6e, 0x4f, 0x8a, 0xcf, 0x41, 0xc4, 0xc4, 0x4d, 0x5d, 0xa3, 0xb5, 0xec, 0x62, 0x76, 0x39,
|
||||
0xab, 0x54, 0x22, 0x69, 0x41, 0xa3, 0xf2, 0x27, 0x08, 0xe6, 0x79, 0x71, 0xb1, 0xa5, 0xda, 0x8e,
|
||||
0x7e, 0xd4, 0x09, 0xfa, 0x1c, 0x4c, 0xf5, 0x02, 0x3e, 0x38, 0xde, 0x24, 0xc3, 0xab, 0x84, 0x50,
|
||||
0xe6, 0xad, 0x7f, 0x40, 0x30, 0xeb, 0xd5, 0x12, 0x27, 0x89, 0xe7, 0xdf, 0x23, 0x98, 0xb9, 0xa5,
|
||||
0xd2, 0x93, 0xc4, 0xf2, 0x1f, 0xfd, 0x54, 0x1e, 0xf2, 0x7c, 0x94, 0x29, 0xca, 0x43, 0x8c, 0x33,
|
||||
0x1d, 0x6c, 0x5e, 0x53, 0x31, 0xae, 0xa9, 0xfc, 0xa7, 0x41, 0xce, 0x3f, 0x61, 0x9c, 0xff, 0x19,
|
||||
0xc1, 0x99, 0x9b, 0xc4, 0x09, 0xb9, 0x3e, 0x16, 0x7b, 0xc3, 0xa8, 0xde, 0xf2, 0x94, 0xef, 0x6c,
|
||||
0x42, 0xe6, 0x8f, 0x64, 0x07, 0xf9, 0x1d, 0x82, 0x39, 0x2f, 0xfd, 0x1e, 0x0f, 0x27, 0x18, 0xa1,
|
||||
0xf6, 0x94, 0x7f, 0xe1, 0xef, 0x79, 0x51, 0x8e, 0xc7, 0x51, 0x9d, 0xc0, 0xf1, 0x32, 0x22, 0xc7,
|
||||
0xf3, 0x98, 0x0b, 0x21, 0x9b, 0x1b, 0xc1, 0x5e, 0x11, 0x83, 0xc9, 0x3f, 0x42, 0x30, 0x1f, 0x54,
|
||||
0xbe, 0x0d, 0xd2, 0xee, 0x12, 0xd3, 0x79, 0x76, 0x7d, 0x26, 0xb5, 0x91, 0x11, 0xd4, 0xac, 0xa7,
|
||||
0xa1, 0x44, 0xf9, 0x3a, 0x61, 0x51, 0x3b, 0x00, 0xc8, 0x1f, 0x23, 0x58, 0xd8, 0xc7, 0xce, 0x38,
|
||||
0xca, 0xaa, 0x41, 0x41, 0x37, 0x35, 0xf2, 0x28, 0xe4, 0x26, 0xf8, 0xf5, 0x46, 0xb6, 0x5d, 0xdd,
|
||||
0xd0, 0x42, 0x36, 0x82, 0x5f, 0xbc, 0x04, 0x12, 0x31, 0xd5, 0x6d, 0x83, 0x34, 0x19, 0x2e, 0x33,
|
||||
0x6a, 0x51, 0x29, 0x73, 0xd8, 0xa6, 0x07, 0x92, 0x7f, 0x8c, 0x60, 0xc6, 0xb3, 0xa9, 0xcf, 0x23,
|
||||
0x7d, 0xbe, 0x3a, 0x5b, 0x84, 0x72, 0xc4, 0x68, 0x3e, 0xbb, 0x51, 0x90, 0xbc, 0x03, 0xb3, 0x71,
|
||||
0x76, 0xc6, 0xd1, 0xd9, 0x59, 0x80, 0xd0, 0x22, 0xdc, 0xb7, 0xb2, 0x4a, 0x04, 0x22, 0x7f, 0x86,
|
||||
0x00, 0xf3, 0xf2, 0x82, 0x29, 0xe3, 0x88, 0x0f, 0xd9, 0x0f, 0x75, 0x62, 0x68, 0xd1, 0x0c, 0x56,
|
||||
0x62, 0x10, 0x36, 0xbc, 0x01, 0x12, 0x79, 0xe4, 0xd8, 0x6a, 0xb3, 0xa7, 0xda, 0x6a, 0x97, 0x1f,
|
||||
0x71, 0x46, 0x4a, 0x36, 0x65, 0x46, 0xb6, 0xc5, 0xa8, 0xe4, 0xbf, 0x7a, 0x85, 0x89, 0xef, 0x94,
|
||||
0xc7, 0x5d, 0xe2, 0x33, 0x00, 0xcc, 0x69, 0xf9, 0x70, 0x8e, 0x0f, 0x33, 0x08, 0x4b, 0xe7, 0x1f,
|
||||
0x23, 0xa8, 0x32, 0x11, 0xb8, 0x3c, 0x3d, 0x6f, 0xda, 0x04, 0x0d, 0x4a, 0xd0, 0x0c, 0x09, 0xa1,
|
||||
0x2f, 0x40, 0xde, 0x57, 0x6c, 0x76, 0x54, 0xc5, 0xfa, 0x04, 0x07, 0x88, 0x21, 0xff, 0x1a, 0xc1,
|
||||
0x5c, 0x42, 0xe5, 0xe3, 0x78, 0xf4, 0x7d, 0xc0, 0x5c, 0x42, 0x6d, 0x20, 0x76, 0xb0, 0xf5, 0x9c,
|
||||
0x13, 0xd6, 0xff, 0x49, 0x25, 0x29, 0x2f, 0xe8, 0x09, 0x08, 0x95, 0xff, 0x81, 0xe0, 0xf4, 0x4d,
|
||||
0xe2, 0x30, 0xd4, 0x6b, 0x5e, 0xee, 0xd8, 0xb2, 0xad, 0xb6, 0x4d, 0x28, 0x3d, 0xb9, 0xfe, 0xf1,
|
||||
0x33, 0x5e, 0xab, 0x88, 0x44, 0x1a, 0x47, 0xff, 0x4b, 0x20, 0xb1, 0x35, 0x88, 0xd6, 0xb4, 0xad,
|
||||
0x3d, 0xea, 0xfb, 0x51, 0xd9, 0x87, 0x29, 0xd6, 0x1e, 0x73, 0x08, 0xc7, 0x72, 0x54, 0x83, 0x23,
|
||||
0xf8, 0x1b, 0x03, 0x83, 0x78, 0xc3, 0x2c, 0x06, 0x03, 0xc6, 0xbc, 0xc9, 0xc9, 0xc9, 0xd5, 0xf1,
|
||||
0x13, 0x04, 0x73, 0x09, 0x51, 0xc6, 0xd1, 0xed, 0x15, 0x5e, 0x49, 0x71, 0x61, 0xa6, 0xd6, 0x5f,
|
||||
0x12, 0xd2, 0x44, 0x16, 0xe3, 0xd8, 0xf2, 0xa7, 0x08, 0xaa, 0xde, 0x69, 0xeb, 0x84, 0x27, 0xb4,
|
||||
0xdf, 0x64, 0xa0, 0xb2, 0x69, 0x52, 0x62, 0x3b, 0xc7, 0xbf, 0x98, 0xc6, 0x6f, 0x43, 0x99, 0x09,
|
||||
0x46, 0x9b, 0x9a, 0xea, 0xa8, 0xfe, 0x6e, 0x74, 0x56, 0xd8, 0x17, 0xbc, 0xe1, 0xe1, 0x6d, 0xa8,
|
||||
0x8e, 0xaa, 0x70, 0xed, 0x50, 0xef, 0x1b, 0x9f, 0x82, 0x52, 0x47, 0xa5, 0x9d, 0xe6, 0x0e, 0xe9,
|
||||
0xd3, 0x5a, 0x7e, 0x31, 0xbb, 0x5c, 0x51, 0x8a, 0x1e, 0xe0, 0x36, 0xe9, 0x53, 0xfc, 0x22, 0x14,
|
||||
0x4d, 0xb7, 0xcb, 0xe3, 0xa7, 0xb0, 0x88, 0x96, 0x2b, 0x4a, 0xc1, 0x74, 0xbb, 0x2c, 0x7a, 0xfe,
|
||||
0x96, 0x81, 0xa9, 0xbb, 0xae, 0x57, 0xba, 0xb3, 0xae, 0xa6, 0x6b, 0x38, 0xcf, 0xe6, 0x6b, 0x2b,
|
||||
0x90, 0xe5, 0x25, 0x81, 0x47, 0x51, 0x13, 0x32, 0xbe, 0xb9, 0x41, 0x15, 0x0f, 0x89, 0xdd, 0x1c,
|
||||
0xb8, 0xad, 0x96, 0x5f, 0x43, 0x65, 0x19, 0xb3, 0x25, 0x0f, 0xc2, 0x3c, 0xce, 0x13, 0x85, 0xd8,
|
||||
0x76, 0x58, 0x61, 0x31, 0x51, 0x88, 0x6d, 0xf3, 0x41, 0x19, 0x24, 0xb5, 0xb5, 0x63, 0x5a, 0x7b,
|
||||
0x06, 0xd1, 0xda, 0x44, 0x63, 0x66, 0x2f, 0x2a, 0x31, 0x18, 0x77, 0x0c, 0xcf, 0xf0, 0xcd, 0x96,
|
||||
0xe9, 0xd4, 0xf2, 0x3c, 0x61, 0x70, 0xc8, 0x75, 0xd3, 0xf1, 0x86, 0x35, 0x62, 0x10, 0x87, 0xb0,
|
||||
0xe1, 0x02, 0x1f, 0xe6, 0x10, 0x7f, 0xd8, 0xed, 0x85, 0xd4, 0x45, 0x3e, 0xcc, 0x21, 0xde, 0xf0,
|
||||
0x69, 0x60, 0xfd, 0x22, 0xde, 0x40, 0x2a, 0x0d, 0x1a, 0x48, 0x0c, 0x20, 0xef, 0x42, 0x75, 0xcb,
|
||||
0x50, 0x5b, 0xa4, 0x63, 0x19, 0x1a, 0xb1, 0xd9, 0xe6, 0x86, 0xab, 0x90, 0x75, 0xd4, 0xb6, 0xbf,
|
||||
0x7b, 0x7a, 0x9f, 0xf8, 0x2d, 0xbf, 0xcd, 0xc4, 0xe3, 0xf2, 0x15, 0xe1, 0x36, 0x13, 0x99, 0x66,
|
||||
0xd0, 0x62, 0xc2, 0xf3, 0x90, 0x67, 0xcd, 0x76, 0xbe, 0xaf, 0x4a, 0x8a, 0xff, 0x27, 0x3f, 0x88,
|
||||
0xad, 0x7b, 0xd3, 0xb6, 0xdc, 0x1e, 0xde, 0x04, 0xa9, 0x37, 0x80, 0x79, 0xd6, 0x4c, 0xdf, 0xd4,
|
||||
0x92, 0x4c, 0x2b, 0x31, 0x52, 0xf9, 0xb3, 0x2c, 0x54, 0x1a, 0x44, 0xb5, 0x5b, 0x9d, 0x93, 0x70,
|
||||
0xae, 0xf6, 0x34, 0xae, 0x51, 0xc3, 0x4f, 0x09, 0xde, 0x27, 0xbe, 0x00, 0x2f, 0x44, 0x04, 0x6a,
|
||||
0xb6, 0x3d, 0x05, 0x31, 0xcf, 0x90, 0x94, 0x6a, 0x2f, 0xa9, 0xb8, 0x37, 0xa1, 0xa8, 0x51, 0xa3,
|
||||
0xc9, 0x4c, 0x54, 0x60, 0x26, 0x12, 0xcb, 0xb7, 0x41, 0x0d, 0x66, 0x9a, 0x82, 0xc6, 0x3f, 0xf0,
|
||||
0xcb, 0x50, 0xb1, 0x5c, 0xa7, 0xe7, 0x3a, 0x4d, 0x1e, 0x99, 0xb5, 0x22, 0x63, 0x4f, 0xe2, 0x40,
|
||||
0x16, 0xb8, 0x14, 0xdf, 0x80, 0x0a, 0x65, 0xaa, 0x0c, 0x4a, 0xcf, 0xd2, 0xa8, 0x15, 0x92, 0xc4,
|
||||
0xe9, 0x78, 0xed, 0x89, 0xcf, 0x43, 0xd5, 0xb1, 0xd5, 0x5d, 0x62, 0x34, 0x07, 0xfe, 0x08, 0xcc,
|
||||
0x1f, 0xa7, 0x39, 0xfc, 0x7e, 0x00, 0xc6, 0x6b, 0x30, 0xd3, 0x76, 0x55, 0x5b, 0x35, 0x1d, 0x42,
|
||||
0x22, 0xd8, 0x65, 0x86, 0x8d, 0xc3, 0xa1, 0x90, 0x40, 0xfe, 0x57, 0x06, 0xa6, 0x15, 0xe2, 0xd8,
|
||||
0x3a, 0xd9, 0x25, 0x27, 0xc2, 0xe2, 0x2b, 0x90, 0xd5, 0x35, 0xca, 0x2c, 0x3e, 0x34, 0xfd, 0xe8,
|
||||
0x1a, 0xdd, 0x6f, 0xa5, 0xbc, 0xc0, 0x4a, 0x22, 0xed, 0x16, 0x0e, 0xa5, 0xdd, 0x62, 0xaa, 0x76,
|
||||
0x3f, 0x41, 0x51, 0xed, 0x7a, 0x39, 0x97, 0x3e, 0x73, 0xd2, 0xf5, 0xa4, 0xce, 0x8c, 0x22, 0x75,
|
||||
0x62, 0x87, 0xc9, 0x1e, 0x76, 0x87, 0x91, 0x6f, 0xc3, 0xe4, 0x2d, 0xdd, 0x61, 0xc1, 0xe5, 0x65,
|
||||
0x7a, 0xc4, 0x0e, 0x7f, 0x2c, 0x9f, 0xbf, 0x08, 0x45, 0xdb, 0xda, 0xe3, 0xf3, 0x66, 0x58, 0x5a,
|
||||
0x2a, 0xd8, 0xd6, 0x1e, 0xdb, 0x96, 0xd8, 0xe5, 0xb1, 0x65, 0xfb, 0xf9, 0x2a, 0xa3, 0xf8, 0x7f,
|
||||
0xf2, 0xf7, 0xd0, 0x20, 0xa1, 0x8c, 0xa1, 0x80, 0xb7, 0xa1, 0x60, 0x73, 0xfa, 0xa1, 0x57, 0x69,
|
||||
0xd1, 0x95, 0x98, 0x5c, 0x01, 0x95, 0xfc, 0x01, 0x02, 0xe9, 0x86, 0xe1, 0xd2, 0xe7, 0x91, 0xd7,
|
||||
0x44, 0xdd, 0xfb, 0xac, 0xb0, 0x7b, 0x2f, 0xff, 0x24, 0x03, 0x15, 0x9f, 0x8d, 0x71, 0x0a, 0xbe,
|
||||
0x54, 0x56, 0x1a, 0x50, 0xf6, 0x96, 0x6c, 0x52, 0xd2, 0x0e, 0xda, 0x3d, 0xe5, 0xf5, 0x75, 0xe1,
|
||||
0x4e, 0x10, 0x63, 0x83, 0x5d, 0x42, 0x36, 0x18, 0xd1, 0xd7, 0x4d, 0xc7, 0xee, 0x2b, 0xd0, 0x0a,
|
||||
0x01, 0xf5, 0x07, 0x30, 0x9d, 0x18, 0xf6, 0x7c, 0x63, 0x87, 0xf4, 0x83, 0xad, 0x6e, 0x87, 0xf4,
|
||||
0xf1, 0xe5, 0xe8, 0x55, 0x71, 0x9a, 0xc3, 0xdd, 0xb1, 0xcc, 0xf6, 0x55, 0xdb, 0x56, 0xfb, 0xfe,
|
||||
0x55, 0xf2, 0x17, 0x33, 0x6f, 0x21, 0xf9, 0xdf, 0x08, 0xa4, 0x77, 0x5c, 0x62, 0xf7, 0x8f, 0x32,
|
||||
0x01, 0x61, 0x98, 0x24, 0x8f, 0x7a, 0xb6, 0x5f, 0xb4, 0xb1, 0xef, 0xfd, 0xf9, 0x23, 0x27, 0xc8,
|
||||
0x1f, 0x82, 0xcc, 0x95, 0x17, 0xf6, 0x80, 0x3f, 0x18, 0x88, 0x39, 0x56, 0x20, 0xc4, 0xa2, 0x3b,
|
||||
0x73, 0xe8, 0xe8, 0xfe, 0x3b, 0x82, 0xb9, 0x2d, 0x62, 0x53, 0x9d, 0x3a, 0xc4, 0x74, 0xfc, 0x6e,
|
||||
0xd1, 0xa6, 0xf9, 0xd0, 0x8a, 0xb7, 0xe5, 0x50, 0xa2, 0x2d, 0xf7, 0xf9, 0x34, 0xa9, 0x62, 0x05,
|
||||
0x2a, 0x6f, 0x94, 0x06, 0x05, 0x6a, 0xd0, 0x0e, 0xe6, 0x05, 0xfe, 0x54, 0xca, 0x36, 0xe9, 0xf3,
|
||||
0x1b, 0x3b, 0xc6, 0xfc, 0x94, 0x5f, 0x71, 0x0a, 0x85, 0x7a, 0x76, 0x97, 0x9a, 0x07, 0xdf, 0x87,
|
||||
0x12, 0x1e, 0xf5, 0x7f, 0x90, 0x70, 0x9d, 0x94, 0x8b, 0xd7, 0x9f, 0x23, 0x58, 0x4c, 0xe7, 0x6a,
|
||||
0x9c, 0xe0, 0xff, 0x1a, 0xe4, 0x74, 0xf3, 0xa1, 0x15, 0x34, 0x2f, 0x56, 0xc4, 0x75, 0x9e, 0x70,
|
||||
0x5d, 0x4e, 0x28, 0xff, 0x07, 0x41, 0x95, 0xb9, 0xe2, 0x11, 0x98, 0xbf, 0x4b, 0xba, 0x4d, 0xaa,
|
||||
0x3f, 0x26, 0x81, 0xf9, 0xbb, 0xa4, 0xdb, 0xd0, 0x1f, 0x93, 0x98, 0x67, 0xe4, 0xe2, 0x9e, 0x11,
|
||||
0x3f, 0xff, 0xe5, 0x87, 0x34, 0xa7, 0x0a, 0xb1, 0xe6, 0x94, 0xfc, 0x14, 0x41, 0xfd, 0x26, 0x71,
|
||||
0x92, 0xa2, 0x1e, 0x9d, 0x53, 0x7c, 0x88, 0xe0, 0x94, 0x90, 0xa1, 0x71, 0xfc, 0xe1, 0x4b, 0x71,
|
||||
0x7f, 0x10, 0xd7, 0xfd, 0xfb, 0x96, 0xf4, 0x5d, 0xe1, 0x0d, 0x90, 0x36, 0xdc, 0x6e, 0x37, 0xcc,
|
||||
0xbd, 0x4b, 0x20, 0xd9, 0xfc, 0x93, 0x97, 0xc5, 0x3c, 0xc3, 0x97, 0x7d, 0x98, 0x57, 0xfc, 0xca,
|
||||
0x17, 0xa0, 0xe2, 0x93, 0xf8, 0x5c, 0xd7, 0xa1, 0x68, 0xfb, 0xdf, 0x3e, 0x7e, 0xf8, 0x2f, 0xcf,
|
||||
0xc1, 0x8c, 0x42, 0xda, 0x9e, 0x27, 0xda, 0x77, 0x74, 0x73, 0xc7, 0x5f, 0x46, 0x7e, 0x82, 0x60,
|
||||
0x36, 0x0e, 0xf7, 0xe7, 0xfa, 0x7f, 0x28, 0xa8, 0x9a, 0x66, 0x13, 0x4a, 0x87, 0x9a, 0xe5, 0x2a,
|
||||
0xc7, 0x51, 0x02, 0xe4, 0x88, 0xe6, 0x32, 0x23, 0x6b, 0x6e, 0xe5, 0x22, 0xef, 0xe0, 0x27, 0x2e,
|
||||
0xf9, 0x71, 0x01, 0xb2, 0x57, 0x0d, 0xa3, 0x3a, 0x81, 0x25, 0x28, 0x6e, 0x9a, 0x77, 0x49, 0xd7,
|
||||
0xb2, 0xfb, 0x55, 0xb4, 0xf2, 0x55, 0x98, 0x4e, 0x9c, 0xd5, 0x70, 0x11, 0x26, 0xef, 0x59, 0x26,
|
||||
0xa9, 0x4e, 0xe0, 0x2a, 0x48, 0xd7, 0x74, 0x53, 0xb5, 0xfb, 0xef, 0x92, 0x96, 0x63, 0xd9, 0x55,
|
||||
0x0d, 0x4f, 0x43, 0xf9, 0x86, 0x61, 0xa9, 0x8e, 0x0f, 0x20, 0xeb, 0x1f, 0x2d, 0x40, 0xe5, 0x2e,
|
||||
0x63, 0xaa, 0x41, 0xec, 0x5d, 0xbd, 0x45, 0x70, 0x13, 0xaa, 0xc9, 0x07, 0x80, 0xf8, 0xa2, 0xd0,
|
||||
0x7c, 0x29, 0xef, 0x04, 0xeb, 0xc3, 0xc4, 0x94, 0x27, 0xf0, 0xfb, 0x30, 0x15, 0x7f, 0x9a, 0x87,
|
||||
0xc5, 0xd9, 0x42, 0xf8, 0x7e, 0xef, 0xa0, 0xc9, 0x9b, 0x50, 0x89, 0xbd, 0xb4, 0xc3, 0xe7, 0x85,
|
||||
0x73, 0x8b, 0x5e, 0xe3, 0xd5, 0x97, 0x84, 0xa8, 0xd1, 0xd7, 0x70, 0x9c, 0xfb, 0xf8, 0x83, 0xa3,
|
||||
0x14, 0xee, 0x85, 0xaf, 0x92, 0x0e, 0xe2, 0x5e, 0x85, 0x17, 0xf6, 0xbd, 0x1f, 0xc2, 0xaf, 0x09,
|
||||
0xe7, 0x4f, 0x7b, 0x67, 0x74, 0xd0, 0x12, 0x7b, 0x80, 0xf7, 0xbf, 0x28, 0xc3, 0xab, 0x62, 0x0b,
|
||||
0xa4, 0xbd, 0xa7, 0xab, 0xaf, 0x8d, 0x8c, 0x1f, 0x2a, 0xee, 0xfb, 0x08, 0x16, 0x52, 0x1e, 0xfd,
|
||||
0xe0, 0x4b, 0xc2, 0xe9, 0x86, 0xbf, 0x5c, 0xaa, 0x5f, 0x3e, 0x1c, 0x51, 0xc8, 0x88, 0x09, 0xd3,
|
||||
0x89, 0x00, 0xc3, 0x17, 0x46, 0x79, 0x6b, 0x13, 0xac, 0x7b, 0x71, 0x34, 0xe4, 0x70, 0x3d, 0xaf,
|
||||
0x52, 0x8d, 0x3f, 0x7a, 0x49, 0x59, 0x4f, 0xfc, 0x34, 0xe6, 0x20, 0x83, 0xbe, 0x07, 0x95, 0xd8,
|
||||
0xeb, 0x94, 0x14, 0x8f, 0x17, 0xbd, 0x60, 0x39, 0x68, 0xea, 0x07, 0x20, 0x45, 0x1f, 0x91, 0xe0,
|
||||
0xe5, 0xb4, 0x58, 0xda, 0x37, 0xf1, 0x61, 0x42, 0x69, 0x70, 0xff, 0x3c, 0x24, 0x94, 0xf6, 0x5d,
|
||||
0xab, 0x8f, 0x1e, 0x4a, 0x91, 0xf9, 0x87, 0x86, 0xd2, 0xa1, 0x97, 0x78, 0x82, 0x60, 0x5e, 0xfc,
|
||||
0x06, 0x01, 0xaf, 0xa7, 0xf9, 0x66, 0xfa, 0x6b, 0x8b, 0xfa, 0xa5, 0x43, 0xd1, 0x84, 0x5a, 0xdc,
|
||||
0x81, 0xa9, 0xf8, 0x2d, 0x7e, 0x8a, 0x16, 0x85, 0x8f, 0x13, 0xea, 0x17, 0x46, 0xc2, 0x0d, 0x17,
|
||||
0xfb, 0x26, 0x94, 0x23, 0x37, 0xac, 0xf8, 0xd5, 0x21, 0x7e, 0x1c, 0x6d, 0xe0, 0x1f, 0xa4, 0xc9,
|
||||
0x0e, 0x54, 0x62, 0xb7, 0x6a, 0x69, 0x3e, 0x2c, 0xb8, 0xec, 0xac, 0xaf, 0x8c, 0x82, 0x1a, 0x0a,
|
||||
0xd0, 0x81, 0x4a, 0xec, 0x8e, 0x23, 0x65, 0x25, 0xd1, 0x95, 0x4e, 0xca, 0x4a, 0xc2, 0x2b, 0x13,
|
||||
0x79, 0x02, 0x7f, 0x37, 0x72, 0x9d, 0x12, 0xbb, 0xb2, 0xc2, 0x6f, 0x0c, 0x9d, 0x47, 0x74, 0x63,
|
||||
0x57, 0x5f, 0x3f, 0x0c, 0x49, 0xc8, 0xc2, 0x3b, 0x50, 0x0a, 0xaf, 0x52, 0xf0, 0xb9, 0xd4, 0xb4,
|
||||
0x70, 0x18, 0x4b, 0x35, 0x20, 0xcf, 0xaf, 0x35, 0xb0, 0x9c, 0x72, 0x3f, 0x19, 0xb9, 0xf3, 0xa8,
|
||||
0xbf, 0x2c, 0xc4, 0x89, 0x77, 0xfc, 0xe5, 0x09, 0xac, 0x40, 0x9e, 0x37, 0x49, 0x52, 0x26, 0x8d,
|
||||
0x35, 0x7f, 0xeb, 0xc3, 0x71, 0x78, 0x67, 0x65, 0x02, 0x7f, 0x0b, 0x8a, 0x41, 0x97, 0x0b, 0xbf,
|
||||
0x92, 0x12, 0xf6, 0xb1, 0x16, 0x63, 0xfd, 0x20, 0xac, 0x60, 0xe6, 0x2d, 0xc8, 0xb1, 0x36, 0x05,
|
||||
0x5e, 0x1a, 0xd6, 0xc2, 0x18, 0xc6, 0x6b, 0xac, 0xcb, 0x21, 0x4f, 0xe0, 0x6f, 0x40, 0x8e, 0x95,
|
||||
0xc2, 0x29, 0x33, 0x46, 0xfb, 0x10, 0xf5, 0xa1, 0x28, 0x01, 0x8b, 0x3f, 0x40, 0x50, 0x4b, 0x3b,
|
||||
0xe7, 0xe1, 0xd4, 0x7d, 0x73, 0xd8, 0x61, 0xb5, 0x7e, 0xe5, 0x90, 0x54, 0xa1, 0x70, 0x8f, 0x61,
|
||||
0x46, 0x70, 0xba, 0xc0, 0x6b, 0x69, 0xf3, 0xa5, 0x1c, 0x8c, 0xea, 0xaf, 0x8f, 0x4e, 0x10, 0xae,
|
||||
0xbd, 0x05, 0x39, 0x76, 0x2a, 0x48, 0x51, 0x6c, 0xf4, 0x90, 0x91, 0x62, 0xaa, 0xd8, 0xa1, 0x42,
|
||||
0x9e, 0xc0, 0x04, 0xa4, 0xe8, 0x11, 0x21, 0x65, 0x4b, 0x14, 0x9c, 0x2e, 0xea, 0xe7, 0x47, 0xc0,
|
||||
0x0c, 0x96, 0x59, 0x77, 0x41, 0xda, 0xb2, 0xad, 0x47, 0xfd, 0xa0, 0x28, 0xff, 0xdf, 0x2c, 0x7b,
|
||||
0xed, 0xca, 0xb7, 0x2f, 0xb5, 0x75, 0xa7, 0xe3, 0x6e, 0x7b, 0x71, 0xbf, 0xc6, 0x71, 0x5f, 0xd3,
|
||||
0x2d, 0xff, 0x6b, 0x4d, 0x37, 0x1d, 0x62, 0x9b, 0xaa, 0xb1, 0xc6, 0xe6, 0xf2, 0xa1, 0xbd, 0xed,
|
||||
0xed, 0x3c, 0xfb, 0xbf, 0xf4, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x10, 0x05, 0x53, 0xed, 0x7c,
|
||||
0x34, 0x00, 0x00,
|
||||
// 2868 bytes of a gzipped FileDescriptorProto
|
||||
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x3a, 0xcd, 0x6f, 0x24, 0x47,
|
||||
0xf5, 0xae, 0x19, 0xcf, 0xd7, 0x9b, 0x1e, 0x7b, 0x52, 0x5e, 0x7b, 0x27, 0x93, 0xdd, 0xc4, 0xdb,
|
||||
0xc9, 0xfe, 0xe2, 0xdd, 0x4d, 0x76, 0x13, 0x6f, 0xf2, 0x4b, 0x48, 0x02, 0xc9, 0xee, 0x9a, 0xec,
|
||||
0x5a, 0xd9, 0x0d, 0x4e, 0x3b, 0x44, 0x84, 0x28, 0x1a, 0xb5, 0xa7, 0xcb, 0x33, 0x2d, 0xf7, 0x74,
|
||||
0x0f, 0x5d, 0x35, 0xf6, 0x4e, 0x4e, 0x48, 0x09, 0x48, 0x08, 0x48, 0x84, 0x40, 0x20, 0x38, 0x20,
|
||||
0x04, 0xca, 0x81, 0x13, 0x44, 0x41, 0x42, 0xe2, 0xc4, 0x21, 0x07, 0x0e, 0x48, 0x7c, 0x5c, 0xb9,
|
||||
0xc2, 0x31, 0xff, 0x00, 0xe2, 0x80, 0xaa, 0xaa, 0xbb, 0xa7, 0xbb, 0x5d, 0x3d, 0x1e, 0xef, 0x24,
|
||||
0xd8, 0xbe, 0x75, 0xbf, 0x7a, 0xaf, 0xea, 0x7d, 0xd5, 0xab, 0x57, 0xaf, 0x1e, 0x68, 0x3d, 0xdb,
|
||||
0xd9, 0x1d, 0xd0, 0xcb, 0x7d, 0xdf, 0x63, 0x1e, 0x5e, 0x88, 0xff, 0x5d, 0x96, 0x3f, 0x4d, 0xad,
|
||||
0xed, 0xf5, 0x7a, 0x9e, 0x2b, 0x81, 0x4d, 0x8d, 0xb6, 0xbb, 0xa4, 0x67, 0xca, 0x3f, 0xfd, 0x13,
|
||||
0x04, 0xa7, 0x6f, 0xf8, 0xc4, 0x64, 0xe4, 0x86, 0xe7, 0x38, 0xa4, 0xcd, 0x6c, 0xcf, 0x35, 0xc8,
|
||||
0x37, 0x06, 0x84, 0x32, 0xfc, 0x04, 0xcc, 0x6e, 0x99, 0x94, 0x34, 0xd0, 0x32, 0x5a, 0xa9, 0xae,
|
||||
0x9e, 0xb9, 0x9c, 0x98, 0x3b, 0x98, 0xf3, 0x0e, 0xed, 0x5c, 0x37, 0x29, 0x31, 0x04, 0x26, 0x3e,
|
||||
0x0d, 0x25, 0x6b, 0xab, 0xe5, 0x9a, 0x3d, 0xd2, 0xc8, 0x2d, 0xa3, 0x95, 0x8a, 0x51, 0xb4, 0xb6,
|
||||
0x5e, 0x35, 0x7b, 0x04, 0x3f, 0x0a, 0xf3, 0xed, 0x68, 0x7e, 0x89, 0x90, 0x17, 0x08, 0x73, 0x23,
|
||||
0xb0, 0x40, 0x5c, 0x82, 0xa2, 0xe4, 0xaf, 0x31, 0xbb, 0x8c, 0x56, 0x34, 0x23, 0xf8, 0xc3, 0x67,
|
||||
0x01, 0x68, 0xd7, 0xf4, 0x2d, 0xda, 0x72, 0x07, 0xbd, 0x46, 0x61, 0x19, 0xad, 0x14, 0x8c, 0x8a,
|
||||
0x84, 0xbc, 0x3a, 0xe8, 0xe9, 0xdf, 0x45, 0xb0, 0xb8, 0xe6, 0x7b, 0xfd, 0x63, 0x21, 0x84, 0xfe,
|
||||
0x6b, 0x04, 0xa7, 0x6e, 0x99, 0xf4, 0x78, 0x68, 0xf4, 0x2c, 0x00, 0xb3, 0x7b, 0xa4, 0x45, 0x99,
|
||||
0xd9, 0xeb, 0x0b, 0xad, 0xce, 0x1a, 0x15, 0x0e, 0xd9, 0xe4, 0x00, 0xfd, 0x4d, 0xd0, 0xae, 0x7b,
|
||||
0x9e, 0x63, 0x10, 0xda, 0xf7, 0x5c, 0x4a, 0xf0, 0x55, 0x28, 0x52, 0x66, 0xb2, 0x01, 0x0d, 0x98,
|
||||
0x7c, 0x40, 0xc9, 0xe4, 0xa6, 0x40, 0x31, 0x02, 0x54, 0x7c, 0x0a, 0x0a, 0xbb, 0xa6, 0x33, 0x90,
|
||||
0x3c, 0x96, 0x0d, 0xf9, 0xa3, 0xbf, 0x05, 0x73, 0x9b, 0xcc, 0xb7, 0xdd, 0xce, 0x67, 0x38, 0x79,
|
||||
0x25, 0x9c, 0xfc, 0xef, 0x08, 0xee, 0x5f, 0x23, 0xb4, 0xed, 0xdb, 0x5b, 0xc7, 0xc4, 0x75, 0x75,
|
||||
0xd0, 0x46, 0x90, 0xf5, 0x35, 0xa1, 0xea, 0xbc, 0x91, 0x80, 0xa5, 0x8c, 0x51, 0x48, 0x1b, 0xe3,
|
||||
0xe7, 0x39, 0x68, 0xaa, 0x84, 0x9a, 0x46, 0x7d, 0x5f, 0x8c, 0x76, 0x54, 0x4e, 0x10, 0x9d, 0x4f,
|
||||
0x12, 0x05, 0xd1, 0x60, 0xb4, 0xda, 0xa6, 0x00, 0x44, 0x1b, 0x2f, 0x2d, 0x55, 0x5e, 0x21, 0xd5,
|
||||
0x2a, 0x2c, 0xee, 0xda, 0x3e, 0x1b, 0x98, 0x4e, 0xab, 0xdd, 0x35, 0x5d, 0x97, 0x38, 0x42, 0x4f,
|
||||
0xb4, 0x31, 0xbb, 0x9c, 0x5f, 0xa9, 0x18, 0x0b, 0xc1, 0xe0, 0x0d, 0x39, 0xc6, 0x95, 0x45, 0xf1,
|
||||
0x53, 0xb0, 0xd4, 0xef, 0x0e, 0xa9, 0xdd, 0xde, 0x47, 0x54, 0x10, 0x44, 0xa7, 0xc2, 0xd1, 0x38,
|
||||
0x95, 0xd8, 0xe7, 0xb7, 0x3d, 0xd3, 0x3a, 0x1e, 0xfb, 0xfc, 0x7d, 0x04, 0x0d, 0x83, 0x38, 0xc4,
|
||||
0xa4, 0xc7, 0xc3, 0x05, 0xf5, 0x1f, 0x21, 0x78, 0xf0, 0x26, 0x61, 0x31, 0x63, 0x32, 0x93, 0xd9,
|
||||
0x94, 0xd9, 0x6d, 0x7a, 0x94, 0x6c, 0x7d, 0x80, 0xe0, 0xa1, 0x4c, 0xb6, 0xa6, 0xf1, 0xed, 0x67,
|
||||
0xa0, 0xc0, 0xbf, 0x68, 0x23, 0xb7, 0x9c, 0x5f, 0xa9, 0xae, 0x9e, 0x53, 0xd2, 0xbc, 0x42, 0x86,
|
||||
0x6f, 0xf0, 0x90, 0xb1, 0x61, 0xda, 0xbe, 0x21, 0xf1, 0xf5, 0x3f, 0x22, 0x58, 0xda, 0xec, 0x7a,
|
||||
0x7b, 0x23, 0x96, 0x3e, 0x0f, 0x05, 0x25, 0x77, 0x7b, 0x3e, 0xb5, 0xdb, 0xf1, 0x0b, 0x30, 0xcb,
|
||||
0x86, 0x7d, 0x22, 0x02, 0xc5, 0xdc, 0xea, 0xca, 0x65, 0xc5, 0xd9, 0x7d, 0x39, 0xc5, 0xe4, 0xeb,
|
||||
0xc3, 0x3e, 0x31, 0x04, 0x95, 0xfe, 0x0b, 0x04, 0xa7, 0xf7, 0x89, 0x30, 0x8d, 0x32, 0x2f, 0x40,
|
||||
0x3d, 0x65, 0x4e, 0xa9, 0xd7, 0x8a, 0x31, 0x9f, 0xb4, 0x27, 0xc5, 0xe7, 0x21, 0x66, 0xe2, 0x96,
|
||||
0x6d, 0xd1, 0x46, 0x7e, 0x39, 0xbf, 0x92, 0x37, 0x6a, 0xb1, 0xb0, 0x60, 0x51, 0xfd, 0x63, 0x04,
|
||||
0x4b, 0x32, 0xb9, 0xd8, 0x30, 0x7d, 0x66, 0x1f, 0x75, 0x80, 0x3e, 0x0f, 0x73, 0xfd, 0x90, 0x0f,
|
||||
0x89, 0x37, 0x2b, 0xf0, 0x6a, 0x11, 0x54, 0x78, 0xeb, 0x47, 0x08, 0x4e, 0xf1, 0x5c, 0xe2, 0x24,
|
||||
0xf1, 0xfc, 0x5b, 0x04, 0x0b, 0xb7, 0x4c, 0x7a, 0x92, 0x58, 0xfe, 0x5d, 0x10, 0xca, 0x23, 0x9e,
|
||||
0x8f, 0x32, 0x44, 0x71, 0xc4, 0x24, 0xd3, 0xe1, 0xe1, 0x35, 0x97, 0xe0, 0x9a, 0xea, 0xbf, 0x1f,
|
||||
0xc5, 0xfc, 0x13, 0xc6, 0xf9, 0x1f, 0x10, 0x9c, 0xbd, 0x49, 0x58, 0xc4, 0xf5, 0xb1, 0x38, 0x1b,
|
||||
0x26, 0xf5, 0x96, 0xf7, 0xe5, 0xc9, 0xa6, 0x64, 0xfe, 0x48, 0x4e, 0x90, 0xdf, 0x20, 0x58, 0xe4,
|
||||
0xe1, 0xf7, 0x78, 0x38, 0xc1, 0x04, 0xb9, 0xa7, 0xfe, 0xb3, 0xe0, 0xcc, 0x8b, 0x73, 0x3c, 0x8d,
|
||||
0xea, 0x14, 0x8e, 0x97, 0x53, 0x39, 0x1e, 0x67, 0x2e, 0x82, 0xac, 0xaf, 0x85, 0x67, 0x45, 0x02,
|
||||
0xa6, 0x7f, 0x0f, 0xc1, 0x52, 0x98, 0xf9, 0x6e, 0x92, 0x4e, 0x8f, 0xb8, 0xec, 0xde, 0xf5, 0x99,
|
||||
0xd6, 0x46, 0x4e, 0x91, 0xb3, 0x9e, 0x81, 0x0a, 0x95, 0xeb, 0x44, 0x49, 0xed, 0x08, 0xa0, 0x7f,
|
||||
0x88, 0xe0, 0xf4, 0x3e, 0x76, 0xa6, 0x51, 0x56, 0x03, 0x4a, 0xb6, 0x6b, 0x91, 0xbb, 0x11, 0x37,
|
||||
0xe1, 0x2f, 0x1f, 0xd9, 0x1a, 0xd8, 0x8e, 0x15, 0xb1, 0x11, 0xfe, 0xe2, 0x73, 0xa0, 0x11, 0xd7,
|
||||
0xdc, 0x72, 0x48, 0x4b, 0xe0, 0x0a, 0xa3, 0x96, 0x8d, 0xaa, 0x84, 0xad, 0x73, 0x90, 0xfe, 0x7d,
|
||||
0x04, 0x0b, 0xdc, 0xa6, 0x01, 0x8f, 0xf4, 0xf3, 0xd5, 0xd9, 0x32, 0x54, 0x63, 0x46, 0x0b, 0xd8,
|
||||
0x8d, 0x83, 0xf4, 0x1d, 0x38, 0x95, 0x64, 0x67, 0x1a, 0x9d, 0x3d, 0x08, 0x10, 0x59, 0x44, 0xfa,
|
||||
0x56, 0xde, 0x88, 0x41, 0xf4, 0x4f, 0x11, 0x60, 0x99, 0x5e, 0x08, 0x65, 0x1c, 0xf1, 0x25, 0x7b,
|
||||
0xdb, 0x26, 0x8e, 0x15, 0x8f, 0x60, 0x15, 0x01, 0x11, 0xc3, 0x6b, 0xa0, 0x91, 0xbb, 0xcc, 0x37,
|
||||
0x5b, 0x7d, 0xd3, 0x37, 0x7b, 0xf2, 0x8a, 0x33, 0x51, 0xb0, 0xa9, 0x0a, 0xb2, 0x0d, 0x41, 0xa5,
|
||||
0xff, 0x89, 0x27, 0x26, 0x81, 0x53, 0x1e, 0x77, 0x89, 0xcf, 0x02, 0x08, 0xa7, 0x95, 0xc3, 0x05,
|
||||
0x39, 0x2c, 0x20, 0x22, 0x9c, 0x7f, 0x88, 0xa0, 0x2e, 0x44, 0x90, 0xf2, 0xf4, 0xf9, 0xb4, 0x29,
|
||||
0x1a, 0x94, 0xa2, 0x19, 0xb3, 0x85, 0xbe, 0x00, 0xc5, 0x40, 0xb1, 0xf9, 0x49, 0x15, 0x1b, 0x10,
|
||||
0x1c, 0x20, 0x86, 0xfe, 0x4b, 0x04, 0x8b, 0x29, 0x95, 0x4f, 0xe3, 0xd1, 0xaf, 0x03, 0x96, 0x12,
|
||||
0x5a, 0x23, 0xb1, 0xc3, 0xa3, 0xe7, 0xbc, 0x32, 0xff, 0x4f, 0x2b, 0xc9, 0xb8, 0xcf, 0x4e, 0x41,
|
||||
0xa8, 0xfe, 0x57, 0x04, 0x67, 0x6e, 0x12, 0x26, 0x50, 0xaf, 0xf3, 0xd8, 0xb1, 0xe1, 0x7b, 0x1d,
|
||||
0x9f, 0x50, 0x7a, 0x72, 0xfd, 0xe3, 0xc7, 0x32, 0x57, 0x51, 0x89, 0x34, 0x8d, 0xfe, 0xcf, 0x81,
|
||||
0x26, 0xd6, 0x20, 0x56, 0xcb, 0xf7, 0xf6, 0x68, 0xe0, 0x47, 0xd5, 0x00, 0x66, 0x78, 0x7b, 0xc2,
|
||||
0x21, 0x98, 0xc7, 0x4c, 0x47, 0x22, 0x04, 0x07, 0x83, 0x80, 0xf0, 0x61, 0xb1, 0x07, 0x43, 0xc6,
|
||||
0xf8, 0xe4, 0xe4, 0xe4, 0xea, 0xf8, 0x5d, 0x04, 0x8b, 0x29, 0x51, 0xa6, 0xd1, 0xed, 0xd3, 0x32,
|
||||
0x93, 0x92, 0xc2, 0xcc, 0xad, 0x3e, 0xa4, 0xa4, 0x89, 0x2d, 0x26, 0xb1, 0xf5, 0x4f, 0x10, 0xd4,
|
||||
0xf9, 0x6d, 0xeb, 0x84, 0x07, 0xb4, 0x5f, 0xe5, 0xa0, 0xb6, 0xee, 0x52, 0xe2, 0xb3, 0xe3, 0x9f,
|
||||
0x4c, 0xe3, 0x17, 0xa1, 0x2a, 0x04, 0xa3, 0x2d, 0xcb, 0x64, 0x66, 0x70, 0x1a, 0x3d, 0xa8, 0xac,
|
||||
0x0b, 0xbe, 0xcc, 0xf1, 0xd6, 0x4c, 0x66, 0x1a, 0x52, 0x3b, 0x94, 0x7f, 0xe3, 0x07, 0xa0, 0xd2,
|
||||
0x35, 0x69, 0xb7, 0xb5, 0x43, 0x86, 0xb4, 0x51, 0x5c, 0xce, 0xaf, 0xd4, 0x8c, 0x32, 0x07, 0xbc,
|
||||
0x42, 0x86, 0x14, 0xdf, 0x0f, 0x65, 0x77, 0xd0, 0x93, 0xfb, 0xa7, 0xb4, 0x8c, 0x56, 0x6a, 0x46,
|
||||
0xc9, 0x1d, 0xf4, 0xc4, 0xee, 0xf9, 0x73, 0x0e, 0xe6, 0xee, 0x0c, 0x78, 0xea, 0x2e, 0xaa, 0x9a,
|
||||
0x03, 0x87, 0xdd, 0x9b, 0xaf, 0x5d, 0x84, 0xbc, 0x4c, 0x09, 0x38, 0x45, 0x43, 0xc9, 0xf8, 0xfa,
|
||||
0x1a, 0x35, 0x38, 0x92, 0x78, 0x39, 0x18, 0xb4, 0xdb, 0x41, 0x0e, 0x95, 0x17, 0xcc, 0x56, 0x38,
|
||||
0x44, 0x78, 0x1c, 0x17, 0x85, 0xf8, 0x7e, 0x94, 0x61, 0x09, 0x51, 0x88, 0xef, 0xcb, 0x41, 0x1d,
|
||||
0x34, 0xb3, 0xbd, 0xe3, 0x7a, 0x7b, 0x0e, 0xb1, 0x3a, 0xc4, 0x12, 0x66, 0x2f, 0x1b, 0x09, 0x98,
|
||||
0x74, 0x0c, 0x6e, 0xf8, 0x56, 0xdb, 0x65, 0x8d, 0xa2, 0x0c, 0x18, 0x12, 0x72, 0xc3, 0x65, 0x7c,
|
||||
0xd8, 0x22, 0x0e, 0x61, 0x44, 0x0c, 0x97, 0xe4, 0xb0, 0x84, 0x04, 0xc3, 0x83, 0x7e, 0x44, 0x5d,
|
||||
0x96, 0xc3, 0x12, 0xc2, 0x87, 0xcf, 0x80, 0xa8, 0x17, 0xc9, 0x02, 0x52, 0x65, 0x54, 0x40, 0x12,
|
||||
0x00, 0x7d, 0x17, 0xea, 0x1b, 0x8e, 0xd9, 0x26, 0x5d, 0xcf, 0xb1, 0x88, 0x2f, 0x0e, 0x37, 0x5c,
|
||||
0x87, 0x3c, 0x33, 0x3b, 0xc1, 0xe9, 0xc9, 0x3f, 0xf1, 0xb3, 0x41, 0x99, 0x49, 0xee, 0xcb, 0x47,
|
||||
0x94, 0xc7, 0x4c, 0x6c, 0x9a, 0x51, 0x89, 0x09, 0x2f, 0x41, 0x51, 0x14, 0xdb, 0xe5, 0xb9, 0xaa,
|
||||
0x19, 0xc1, 0x9f, 0xfe, 0x76, 0x62, 0xdd, 0x9b, 0xbe, 0x37, 0xe8, 0xe3, 0x75, 0xd0, 0xfa, 0x23,
|
||||
0x18, 0xb7, 0x66, 0xf6, 0xa1, 0x96, 0x66, 0xda, 0x48, 0x90, 0xea, 0x9f, 0xe6, 0xa1, 0xb6, 0x49,
|
||||
0x4c, 0xbf, 0xdd, 0x3d, 0x09, 0xf7, 0x6a, 0xae, 0x71, 0x8b, 0x3a, 0x41, 0x48, 0xe0, 0x9f, 0xf8,
|
||||
0x12, 0xdc, 0x17, 0x13, 0xa8, 0xd5, 0xe1, 0x0a, 0x12, 0x9e, 0xa1, 0x19, 0xf5, 0x7e, 0x5a, 0x71,
|
||||
0xcf, 0x40, 0xd9, 0xa2, 0x4e, 0x4b, 0x98, 0xa8, 0x24, 0x4c, 0xa4, 0x96, 0x6f, 0x8d, 0x3a, 0xc2,
|
||||
0x34, 0x25, 0x4b, 0x7e, 0xe0, 0x87, 0xa1, 0xe6, 0x0d, 0x58, 0x7f, 0xc0, 0x5a, 0x72, 0x67, 0x36,
|
||||
0xca, 0x82, 0x3d, 0x4d, 0x02, 0xc5, 0xc6, 0xa5, 0xf8, 0x65, 0xa8, 0x51, 0xa1, 0xca, 0x30, 0xf5,
|
||||
0xac, 0x4c, 0x9a, 0x21, 0x69, 0x92, 0x4e, 0xe6, 0x9e, 0xf8, 0x02, 0xd4, 0x99, 0x6f, 0xee, 0x12,
|
||||
0xa7, 0x35, 0xf2, 0x47, 0x10, 0xfe, 0x38, 0x2f, 0xe1, 0xaf, 0x87, 0x60, 0x7c, 0x05, 0x16, 0x3a,
|
||||
0x03, 0xd3, 0x37, 0x5d, 0x46, 0x48, 0x0c, 0xbb, 0x2a, 0xb0, 0x71, 0x34, 0x14, 0x11, 0xe8, 0xff,
|
||||
0xc8, 0xc1, 0xbc, 0x41, 0x98, 0x6f, 0x93, 0x5d, 0x72, 0x22, 0x2c, 0x7e, 0x11, 0xf2, 0xb6, 0x45,
|
||||
0x85, 0xc5, 0xc7, 0x86, 0x1f, 0xdb, 0xa2, 0xfb, 0xad, 0x54, 0x54, 0x58, 0x49, 0xa5, 0xdd, 0xd2,
|
||||
0xa1, 0xb4, 0x5b, 0xce, 0xd4, 0xee, 0xc7, 0x28, 0xae, 0x5d, 0x1e, 0x73, 0xe9, 0x3d, 0x07, 0x5d,
|
||||
0x2e, 0x75, 0x6e, 0x12, 0xa9, 0x53, 0x27, 0x4c, 0xfe, 0xb0, 0x27, 0x8c, 0xfe, 0x0a, 0xcc, 0xde,
|
||||
0xb2, 0x99, 0xd8, 0x5c, 0x3c, 0xd2, 0x23, 0x71, 0xf9, 0x13, 0xf1, 0xfc, 0x7e, 0x28, 0xfb, 0xde,
|
||||
0x9e, 0x9c, 0x37, 0x27, 0xc2, 0x52, 0xc9, 0xf7, 0xf6, 0xc4, 0xb1, 0x24, 0x1e, 0x8f, 0x3d, 0x3f,
|
||||
0x88, 0x57, 0x39, 0x23, 0xf8, 0xd3, 0xbf, 0x85, 0x46, 0x01, 0x65, 0x0a, 0x05, 0xbc, 0x08, 0x25,
|
||||
0x5f, 0xd2, 0x8f, 0x7d, 0x4a, 0x8b, 0xaf, 0x24, 0xe4, 0x0a, 0xa9, 0xf4, 0xf7, 0x10, 0x68, 0x2f,
|
||||
0x3b, 0x03, 0xfa, 0x79, 0xc4, 0x35, 0x55, 0xf5, 0x3e, 0xaf, 0xac, 0xde, 0xeb, 0x3f, 0xc8, 0x41,
|
||||
0x2d, 0x60, 0x63, 0x9a, 0x84, 0x2f, 0x93, 0x95, 0x4d, 0xa8, 0xf2, 0x25, 0x5b, 0x94, 0x74, 0xc2,
|
||||
0x72, 0x4f, 0x75, 0x75, 0x55, 0x79, 0x12, 0x24, 0xd8, 0x10, 0x8f, 0x90, 0x9b, 0x82, 0xe8, 0xcb,
|
||||
0x2e, 0xf3, 0x87, 0x06, 0xb4, 0x23, 0x40, 0xf3, 0x6d, 0x98, 0x4f, 0x0d, 0x73, 0xdf, 0xd8, 0x21,
|
||||
0xc3, 0xf0, 0xa8, 0xdb, 0x21, 0x43, 0xfc, 0x54, 0xfc, 0xa9, 0x38, 0xcb, 0xe1, 0x6e, 0x7b, 0x6e,
|
||||
0xe7, 0x9a, 0xef, 0x9b, 0xc3, 0xe0, 0x29, 0xf9, 0xb9, 0xdc, 0xb3, 0x48, 0xff, 0x27, 0x02, 0xed,
|
||||
0xb5, 0x01, 0xf1, 0x87, 0x47, 0x19, 0x80, 0x30, 0xcc, 0x92, 0xbb, 0x7d, 0x3f, 0x48, 0xda, 0xc4,
|
||||
0xf7, 0xfe, 0xf8, 0x51, 0x50, 0xc4, 0x0f, 0x45, 0xe4, 0x2a, 0x2a, 0x6b, 0xc0, 0xef, 0x8d, 0xc4,
|
||||
0x9c, 0x6a, 0x23, 0x24, 0x76, 0x77, 0xee, 0xd0, 0xbb, 0xfb, 0x23, 0x04, 0x95, 0x37, 0x48, 0x9b,
|
||||
0x79, 0x3e, 0xdf, 0xd1, 0x0a, 0xfd, 0xa0, 0x09, 0x52, 0xf4, 0x5c, 0x3a, 0x45, 0xbf, 0x0a, 0x65,
|
||||
0xdb, 0x6a, 0x99, 0xdc, 0xb4, 0x42, 0xc1, 0xe3, 0xa2, 0x54, 0xc9, 0xb6, 0x84, 0x0f, 0x4c, 0x5e,
|
||||
0x3e, 0xff, 0x09, 0x02, 0x4d, 0xf2, 0x4c, 0x25, 0xe5, 0xf3, 0xb1, 0xe5, 0x90, 0xca, 0xdf, 0x82,
|
||||
0x9f, 0x48, 0xd0, 0x5b, 0x33, 0xa3, 0x65, 0xaf, 0x01, 0x70, 0xdd, 0x05, 0xe4, 0xd2, 0x5d, 0x97,
|
||||
0x95, 0xdc, 0x4a, 0x72, 0xa1, 0xc7, 0x5b, 0x33, 0x46, 0x85, 0x53, 0x89, 0x29, 0xae, 0x97, 0xa0,
|
||||
0x20, 0xa8, 0xf5, 0xff, 0x20, 0x58, 0xb8, 0x61, 0x3a, 0xed, 0x35, 0x9b, 0x32, 0xd3, 0x6d, 0x4f,
|
||||
0x71, 0x86, 0x3e, 0x07, 0x25, 0xaf, 0xdf, 0x72, 0xc8, 0x36, 0x0b, 0x58, 0x3a, 0x37, 0x46, 0x22,
|
||||
0xa9, 0x06, 0xa3, 0xe8, 0xf5, 0x6f, 0x93, 0x6d, 0x86, 0x5f, 0x80, 0xb2, 0xd7, 0x6f, 0xf9, 0x76,
|
||||
0xa7, 0xcb, 0x02, 0xed, 0x4f, 0x40, 0x5c, 0xf2, 0xfa, 0x06, 0xa7, 0x88, 0x95, 0x70, 0x66, 0x0f,
|
||||
0x59, 0xc2, 0xd1, 0xff, 0xb6, 0x4f, 0xfc, 0x29, 0x5c, 0xfb, 0x39, 0x28, 0xdb, 0x2e, 0x6b, 0x59,
|
||||
0x36, 0x0d, 0x55, 0x70, 0x56, 0xed, 0x43, 0x2e, 0x13, 0x12, 0x08, 0x9b, 0xba, 0x8c, 0xaf, 0x8d,
|
||||
0x5f, 0x02, 0xd8, 0x76, 0x3c, 0x33, 0xa0, 0x96, 0x3a, 0x78, 0x48, 0xbd, 0x2b, 0x38, 0x5a, 0x48,
|
||||
0x5f, 0x11, 0x44, 0x7c, 0x86, 0x91, 0x49, 0xff, 0x82, 0x60, 0x71, 0x83, 0xf8, 0xd4, 0xa6, 0x8c,
|
||||
0xb8, 0x2c, 0x28, 0xa7, 0xae, 0xbb, 0xdb, 0x5e, 0xb2, 0x6e, 0x8d, 0x52, 0x75, 0xeb, 0xcf, 0xa6,
|
||||
0x8a, 0x9b, 0xb8, 0xc1, 0xc9, 0x97, 0x84, 0xf0, 0x06, 0x17, 0xbe, 0x97, 0xc8, 0x1b, 0xf0, 0x5c,
|
||||
0x86, 0x99, 0x02, 0x7e, 0x13, 0xf7, 0xfc, 0x1f, 0xca, 0x1e, 0x00, 0xa5, 0x50, 0xf7, 0xee, 0xb0,
|
||||
0x4b, 0x10, 0x04, 0xd9, 0x54, 0xc8, 0xfd, 0x3f, 0x48, 0xc5, 0x8e, 0x8c, 0xce, 0x84, 0x9f, 0x22,
|
||||
0x58, 0xce, 0xe6, 0x6a, 0x9a, 0xd3, 0xf1, 0x25, 0x28, 0xd8, 0xee, 0xb6, 0x17, 0x56, 0xf7, 0x2e,
|
||||
0xaa, 0x2f, 0x42, 0xca, 0x75, 0x25, 0xa1, 0xfe, 0x2f, 0x04, 0x75, 0x11, 0xab, 0x8f, 0xc0, 0xfc,
|
||||
0x3d, 0xd2, 0x6b, 0x51, 0xfb, 0x1d, 0x12, 0x9a, 0xbf, 0x47, 0x7a, 0x9b, 0xf6, 0x3b, 0x24, 0xe1,
|
||||
0x19, 0x85, 0xa4, 0x67, 0x24, 0x0b, 0x24, 0xc5, 0x31, 0xd5, 0xdb, 0x52, 0xa2, 0x7a, 0xab, 0xbf,
|
||||
0x8f, 0xa0, 0x79, 0x93, 0xb0, 0xb4, 0xa8, 0x47, 0xe7, 0x14, 0x1f, 0x20, 0x78, 0x40, 0xc9, 0xd0,
|
||||
0x34, 0xfe, 0xf0, 0x7c, 0xd2, 0x1f, 0xd4, 0x17, 0xe3, 0x7d, 0x4b, 0x06, 0xae, 0xf0, 0x24, 0x68,
|
||||
0x6b, 0x83, 0x5e, 0x2f, 0x4a, 0x4e, 0xce, 0x81, 0xe6, 0xcb, 0x4f, 0x79, 0x6f, 0x94, 0xc7, 0x65,
|
||||
0x35, 0x80, 0xf1, 0xdb, 0xa1, 0x7e, 0x09, 0x6a, 0x01, 0x49, 0xc0, 0x75, 0x13, 0xca, 0x7e, 0xf0,
|
||||
0x1d, 0xe0, 0x47, 0xff, 0xfa, 0x22, 0x2c, 0x18, 0xa4, 0xc3, 0x3d, 0xd1, 0xbf, 0x6d, 0xbb, 0x3b,
|
||||
0xc1, 0x32, 0xfa, 0xbb, 0x08, 0x4e, 0x25, 0xe1, 0xc1, 0x5c, 0xff, 0x0f, 0x25, 0xd3, 0xb2, 0x7c,
|
||||
0x42, 0xe9, 0x58, 0xb3, 0x5c, 0x93, 0x38, 0x46, 0x88, 0x1c, 0xd3, 0x5c, 0x6e, 0x62, 0xcd, 0x5d,
|
||||
0x7c, 0x4c, 0x3e, 0x71, 0xa5, 0xba, 0x60, 0x70, 0x09, 0xf2, 0xd7, 0x1c, 0xa7, 0x3e, 0x83, 0x35,
|
||||
0x28, 0xaf, 0xbb, 0x77, 0x48, 0xcf, 0xf3, 0x87, 0x75, 0x74, 0xf1, 0x4b, 0x30, 0x9f, 0x2a, 0x66,
|
||||
0xe0, 0x32, 0xcc, 0xbe, 0xea, 0xb9, 0xa4, 0x3e, 0x83, 0xeb, 0xa0, 0x5d, 0xb7, 0x5d, 0xd3, 0x1f,
|
||||
0xca, 0x43, 0xa8, 0x6e, 0xe1, 0x79, 0xa8, 0x8a, 0x60, 0x1c, 0x00, 0xc8, 0xea, 0xbf, 0x4f, 0x43,
|
||||
0xed, 0x8e, 0x60, 0x6a, 0x93, 0xf8, 0xbb, 0x76, 0x9b, 0xe0, 0x16, 0xd4, 0xd3, 0x1d, 0xb2, 0xf8,
|
||||
0x31, 0xa5, 0xf9, 0x32, 0x1a, 0x69, 0x9b, 0xe3, 0xc4, 0xd4, 0x67, 0xf0, 0x5b, 0x30, 0x97, 0xec,
|
||||
0x5d, 0xc5, 0xea, 0x68, 0xa1, 0x6c, 0x70, 0x3d, 0x68, 0xf2, 0x16, 0xd4, 0x12, 0xad, 0xa8, 0xf8,
|
||||
0x82, 0x72, 0x6e, 0x55, 0xbb, 0x6a, 0x53, 0x7d, 0x80, 0xc7, 0xdb, 0x45, 0x25, 0xf7, 0xc9, 0x8e,
|
||||
0xbc, 0x0c, 0xee, 0x95, 0x6d, 0x7b, 0x07, 0x71, 0x6f, 0xc2, 0x7d, 0xfb, 0x1a, 0xec, 0xf0, 0xe3,
|
||||
0xca, 0xf9, 0xb3, 0x1a, 0xf1, 0x0e, 0x5a, 0x62, 0x0f, 0xf0, 0xfe, 0x96, 0x4b, 0x7c, 0x59, 0x6d,
|
||||
0x81, 0xac, 0x86, 0xd3, 0xe6, 0x95, 0x89, 0xf1, 0x23, 0xc5, 0x7d, 0x1b, 0xc1, 0xe9, 0x8c, 0xae,
|
||||
0x38, 0x7c, 0x55, 0x39, 0xdd, 0xf8, 0xd6, 0xbe, 0xe6, 0x53, 0x87, 0x23, 0x8a, 0x18, 0x71, 0x61,
|
||||
0x3e, 0xb5, 0xc1, 0xf0, 0xa5, 0x49, 0x9a, 0xd1, 0xc2, 0x75, 0x1f, 0x9b, 0x0c, 0x39, 0x5a, 0x8f,
|
||||
0x5f, 0xe5, 0x92, 0x5d, 0x61, 0x19, 0xeb, 0xa9, 0x7b, 0xc7, 0x0e, 0x32, 0xe8, 0x9b, 0x50, 0x4b,
|
||||
0xb4, 0x6f, 0x65, 0x78, 0xbc, 0xaa, 0xc5, 0xeb, 0xa0, 0xa9, 0xdf, 0x06, 0x2d, 0xde, 0x65, 0x85,
|
||||
0x57, 0xb2, 0xf6, 0xd2, 0xbe, 0x89, 0x0f, 0xb3, 0x95, 0x46, 0x0d, 0x1a, 0x63, 0xb6, 0xd2, 0xbe,
|
||||
0xbe, 0x93, 0xc9, 0xb7, 0x52, 0x6c, 0xfe, 0xb1, 0x5b, 0xe9, 0xd0, 0x4b, 0xbc, 0x8b, 0x60, 0x49,
|
||||
0xdd, 0xa4, 0x83, 0x57, 0xb3, 0x7c, 0x33, 0xbb, 0x1d, 0xa9, 0x79, 0xf5, 0x50, 0x34, 0x91, 0x16,
|
||||
0x77, 0x60, 0x2e, 0xd9, 0xe6, 0x92, 0xa1, 0x45, 0x65, 0xf7, 0x4e, 0xf3, 0xd2, 0x44, 0xb8, 0xd1,
|
||||
0x62, 0x5f, 0x85, 0x6a, 0xac, 0x05, 0x01, 0x3f, 0x3a, 0xc6, 0x8f, 0xe3, 0x2f, 0x5c, 0x07, 0x69,
|
||||
0xb2, 0x0b, 0xb5, 0xc4, 0xb3, 0x73, 0x96, 0x0f, 0x2b, 0xba, 0x01, 0x9a, 0x17, 0x27, 0x41, 0x8d,
|
||||
0x04, 0xe8, 0x42, 0x2d, 0xf1, 0x08, 0x98, 0xb1, 0x92, 0xea, 0xcd, 0x33, 0x63, 0x25, 0xe5, 0x9b,
|
||||
0xa2, 0x3e, 0x83, 0xbf, 0x19, 0x7b, 0x6f, 0x4c, 0xbc, 0xe9, 0xe2, 0x27, 0xc7, 0xce, 0xa3, 0x7a,
|
||||
0xd2, 0x6e, 0xae, 0x1e, 0x86, 0x24, 0x62, 0xe1, 0x35, 0xa8, 0x44, 0x6f, 0x8d, 0xf8, 0x7c, 0x66,
|
||||
0x58, 0x38, 0x8c, 0xa5, 0x36, 0xa1, 0x28, 0xdf, 0xfd, 0xb0, 0x9e, 0xf1, 0x80, 0x1f, 0x7b, 0x14,
|
||||
0x6c, 0x3e, 0xac, 0xc4, 0x49, 0x3e, 0x89, 0xe9, 0x33, 0xd8, 0x80, 0xa2, 0xac, 0x22, 0x66, 0x4c,
|
||||
0x9a, 0x78, 0x1d, 0x69, 0x8e, 0xc7, 0x91, 0xa5, 0xc7, 0x19, 0xfc, 0x35, 0x28, 0x87, 0x65, 0x60,
|
||||
0xfc, 0x48, 0xc6, 0xb6, 0x4f, 0xd4, 0xe0, 0x9b, 0x07, 0x61, 0x85, 0x33, 0x6f, 0x40, 0x41, 0xd4,
|
||||
0xf1, 0xf0, 0xb9, 0x71, 0x35, 0xbe, 0x71, 0xbc, 0x26, 0xca, 0x80, 0xfa, 0x0c, 0xfe, 0x0a, 0x14,
|
||||
0x44, 0x2a, 0x9c, 0x31, 0x63, 0xbc, 0x50, 0xd7, 0x1c, 0x8b, 0x12, 0xb2, 0x68, 0x81, 0x16, 0x2f,
|
||||
0x11, 0x64, 0x04, 0x6e, 0x45, 0x11, 0xa5, 0x39, 0x09, 0x66, 0xb8, 0xca, 0x77, 0x10, 0x34, 0xb2,
|
||||
0x6e, 0x93, 0x38, 0xf3, 0x74, 0x1e, 0x77, 0x25, 0x6e, 0x3e, 0x7d, 0x48, 0xaa, 0x48, 0x85, 0xef,
|
||||
0xc0, 0x82, 0xe2, 0x0e, 0x83, 0xaf, 0x64, 0xcd, 0x97, 0x71, 0xfd, 0x6a, 0x3e, 0x31, 0x39, 0x41,
|
||||
0xb4, 0xf6, 0x06, 0x14, 0xc4, 0xdd, 0x23, 0xc3, 0x7c, 0xf1, 0xab, 0x4c, 0x86, 0x43, 0x24, 0xae,
|
||||
0x2e, 0xfa, 0x0c, 0x26, 0xa0, 0xc5, 0x2f, 0x22, 0x19, 0xf6, 0x53, 0xdc, 0x61, 0x9a, 0x17, 0x26,
|
||||
0xc0, 0x0c, 0x97, 0x59, 0x1d, 0x80, 0xb6, 0xe1, 0x7b, 0x77, 0x87, 0x61, 0xea, 0xff, 0xbf, 0x59,
|
||||
0xf6, 0xfa, 0xd3, 0x5f, 0xbf, 0xda, 0xb1, 0x59, 0x77, 0xb0, 0xc5, 0xa3, 0xcb, 0x15, 0x89, 0xfb,
|
||||
0xb8, 0xed, 0x05, 0x5f, 0x57, 0x6c, 0x97, 0x11, 0xdf, 0x35, 0x9d, 0x2b, 0x62, 0xae, 0x00, 0xda,
|
||||
0xdf, 0xda, 0x2a, 0x8a, 0xff, 0xab, 0xff, 0x0d, 0x00, 0x00, 0xff, 0xff, 0x57, 0x0f, 0x08, 0x41,
|
||||
0x03, 0x38, 0x00, 0x00,
|
||||
}
|
||||
|
||||
// Reference imports to suppress errors if they are not otherwise used.
|
||||
|
|
@ -3849,6 +4163,7 @@ type MilvusServiceClient interface {
|
|||
Retrieve(ctx context.Context, in *RetrieveRequest, opts ...grpc.CallOption) (*RetrieveResults, error)
|
||||
Flush(ctx context.Context, in *FlushRequest, opts ...grpc.CallOption) (*FlushResponse, error)
|
||||
Query(ctx context.Context, in *QueryRequest, opts ...grpc.CallOption) (*QueryResults, error)
|
||||
CalcDistance(ctx context.Context, in *CalcDistanceRequest, opts ...grpc.CallOption) (*CalcDistanceResults, error)
|
||||
GetPersistentSegmentInfo(ctx context.Context, in *GetPersistentSegmentInfoRequest, opts ...grpc.CallOption) (*GetPersistentSegmentInfoResponse, error)
|
||||
GetQuerySegmentInfo(ctx context.Context, in *GetQuerySegmentInfoRequest, opts ...grpc.CallOption) (*GetQuerySegmentInfoResponse, error)
|
||||
Dummy(ctx context.Context, in *DummyRequest, opts ...grpc.CallOption) (*DummyResponse, error)
|
||||
|
|
@ -4089,6 +4404,15 @@ func (c *milvusServiceClient) Query(ctx context.Context, in *QueryRequest, opts
|
|||
return out, nil
|
||||
}
|
||||
|
||||
func (c *milvusServiceClient) CalcDistance(ctx context.Context, in *CalcDistanceRequest, opts ...grpc.CallOption) (*CalcDistanceResults, error) {
|
||||
out := new(CalcDistanceResults)
|
||||
err := c.cc.Invoke(ctx, "/milvus.proto.milvus.MilvusService/CalcDistance", in, out, opts...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func (c *milvusServiceClient) GetPersistentSegmentInfo(ctx context.Context, in *GetPersistentSegmentInfoRequest, opts ...grpc.CallOption) (*GetPersistentSegmentInfoResponse, error) {
|
||||
out := new(GetPersistentSegmentInfoResponse)
|
||||
err := c.cc.Invoke(ctx, "/milvus.proto.milvus.MilvusService/GetPersistentSegmentInfo", in, out, opts...)
|
||||
|
|
@ -4152,6 +4476,7 @@ type MilvusServiceServer interface {
|
|||
Retrieve(context.Context, *RetrieveRequest) (*RetrieveResults, error)
|
||||
Flush(context.Context, *FlushRequest) (*FlushResponse, error)
|
||||
Query(context.Context, *QueryRequest) (*QueryResults, error)
|
||||
CalcDistance(context.Context, *CalcDistanceRequest) (*CalcDistanceResults, error)
|
||||
GetPersistentSegmentInfo(context.Context, *GetPersistentSegmentInfoRequest) (*GetPersistentSegmentInfoResponse, error)
|
||||
GetQuerySegmentInfo(context.Context, *GetQuerySegmentInfoRequest) (*GetQuerySegmentInfoResponse, error)
|
||||
Dummy(context.Context, *DummyRequest) (*DummyResponse, error)
|
||||
|
|
@ -4238,6 +4563,9 @@ func (*UnimplementedMilvusServiceServer) Flush(ctx context.Context, req *FlushRe
|
|||
func (*UnimplementedMilvusServiceServer) Query(ctx context.Context, req *QueryRequest) (*QueryResults, error) {
|
||||
return nil, status.Errorf(codes.Unimplemented, "method Query not implemented")
|
||||
}
|
||||
func (*UnimplementedMilvusServiceServer) CalcDistance(ctx context.Context, req *CalcDistanceRequest) (*CalcDistanceResults, error) {
|
||||
return nil, status.Errorf(codes.Unimplemented, "method CalcDistance not implemented")
|
||||
}
|
||||
func (*UnimplementedMilvusServiceServer) GetPersistentSegmentInfo(ctx context.Context, req *GetPersistentSegmentInfoRequest) (*GetPersistentSegmentInfoResponse, error) {
|
||||
return nil, status.Errorf(codes.Unimplemented, "method GetPersistentSegmentInfo not implemented")
|
||||
}
|
||||
|
|
@ -4705,6 +5033,24 @@ func _MilvusService_Query_Handler(srv interface{}, ctx context.Context, dec func
|
|||
return interceptor(ctx, in, info, handler)
|
||||
}
|
||||
|
||||
func _MilvusService_CalcDistance_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||||
in := new(CalcDistanceRequest)
|
||||
if err := dec(in); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if interceptor == nil {
|
||||
return srv.(MilvusServiceServer).CalcDistance(ctx, in)
|
||||
}
|
||||
info := &grpc.UnaryServerInfo{
|
||||
Server: srv,
|
||||
FullMethod: "/milvus.proto.milvus.MilvusService/CalcDistance",
|
||||
}
|
||||
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
||||
return srv.(MilvusServiceServer).CalcDistance(ctx, req.(*CalcDistanceRequest))
|
||||
}
|
||||
return interceptor(ctx, in, info, handler)
|
||||
}
|
||||
|
||||
func _MilvusService_GetPersistentSegmentInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||||
in := new(GetPersistentSegmentInfoRequest)
|
||||
if err := dec(in); err != nil {
|
||||
|
|
@ -4881,6 +5227,10 @@ var _MilvusService_serviceDesc = grpc.ServiceDesc{
|
|||
MethodName: "Query",
|
||||
Handler: _MilvusService_Query_Handler,
|
||||
},
|
||||
{
|
||||
MethodName: "CalcDistance",
|
||||
Handler: _MilvusService_CalcDistance_Handler,
|
||||
},
|
||||
{
|
||||
MethodName: "GetPersistentSegmentInfo",
|
||||
Handler: _MilvusService_GetPersistentSegmentInfo_Handler,
|
||||
|
|
|
|||
|
|
@ -30,6 +30,7 @@ import (
|
|||
"github.com/milvus-io/milvus/internal/proto/proxypb"
|
||||
"github.com/milvus-io/milvus/internal/proto/querypb"
|
||||
"github.com/milvus-io/milvus/internal/proto/schemapb"
|
||||
"github.com/milvus-io/milvus/internal/util/distance"
|
||||
"github.com/milvus-io/milvus/internal/util/typeutil"
|
||||
)
|
||||
|
||||
|
|
@ -1573,6 +1574,147 @@ func (node *Proxy) Query(ctx context.Context, request *milvuspb.QueryRequest) (*
|
|||
|
||||
}
|
||||
|
||||
func (node *Proxy) CalcDistance(ctx context.Context, request *milvuspb.CalcDistanceRequest) (*milvuspb.CalcDistanceResults, error) {
|
||||
param, _ := GetAttrByKeyFromRepeatedKV("metric", request.GetParams())
|
||||
metric, err := distance.ValidateMetricType(param)
|
||||
if err != nil {
|
||||
return &milvuspb.CalcDistanceResults{
|
||||
Status: &commonpb.Status{
|
||||
ErrorCode: commonpb.ErrorCode_UnexpectedError,
|
||||
Reason: err.Error(),
|
||||
},
|
||||
}, nil
|
||||
}
|
||||
|
||||
retrieveTask := func(ids *milvuspb.VectorIDs) (*milvuspb.RetrieveResults, error) {
|
||||
outputFields := []string{ids.FieldName}
|
||||
retrieveRequest := &milvuspb.RetrieveRequest{
|
||||
DbName: "",
|
||||
CollectionName: ids.CollectionName,
|
||||
PartitionNames: ids.PartitionNames,
|
||||
Ids: ids.IdArray,
|
||||
OutputFields: outputFields,
|
||||
}
|
||||
|
||||
return node.Retrieve(ctx, retrieveRequest)
|
||||
}
|
||||
|
||||
vectorsLeft := request.GetOpLeft().GetDataArray()
|
||||
opLeft := request.GetOpLeft().GetIdArray()
|
||||
if opLeft != nil {
|
||||
result, err := retrieveTask(opLeft)
|
||||
if err != nil {
|
||||
return &milvuspb.CalcDistanceResults{
|
||||
Status: &commonpb.Status{
|
||||
ErrorCode: commonpb.ErrorCode_UnexpectedError,
|
||||
Reason: err.Error(),
|
||||
},
|
||||
}, nil
|
||||
}
|
||||
|
||||
for _, fieldData := range result.FieldsData {
|
||||
if fieldData.FieldName == opLeft.FieldName {
|
||||
vectorsLeft = fieldData.GetVectors()
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
vectorsRight := request.GetOpRight().GetDataArray()
|
||||
opRight := request.GetOpRight().GetIdArray()
|
||||
if opRight != nil {
|
||||
result, err := retrieveTask(opRight)
|
||||
if err != nil {
|
||||
return &milvuspb.CalcDistanceResults{
|
||||
Status: &commonpb.Status{
|
||||
ErrorCode: commonpb.ErrorCode_UnexpectedError,
|
||||
Reason: err.Error(),
|
||||
},
|
||||
}, nil
|
||||
}
|
||||
|
||||
for _, fieldData := range result.FieldsData {
|
||||
if fieldData.FieldName == opRight.FieldName {
|
||||
vectorsRight = fieldData.GetVectors()
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if vectorsLeft.Dim == vectorsRight.Dim && vectorsLeft.GetFloatVector() != nil && vectorsRight.GetFloatVector() != nil {
|
||||
distances, err := distance.CalcFloatDistance(vectorsLeft.Dim, vectorsLeft.GetFloatVector().Data, vectorsRight.GetFloatVector().Data, metric)
|
||||
if err != nil {
|
||||
return &milvuspb.CalcDistanceResults{
|
||||
Status: &commonpb.Status{
|
||||
ErrorCode: commonpb.ErrorCode_UnexpectedError,
|
||||
Reason: err.Error(),
|
||||
},
|
||||
}, nil
|
||||
}
|
||||
|
||||
return &milvuspb.CalcDistanceResults{
|
||||
Status: &commonpb.Status{ErrorCode: commonpb.ErrorCode_Success, Reason: ""},
|
||||
Array: &milvuspb.CalcDistanceResults_FloatDist{
|
||||
FloatDist: &schemapb.FloatArray{
|
||||
Data: distances,
|
||||
},
|
||||
},
|
||||
}, nil
|
||||
}
|
||||
|
||||
if vectorsLeft.Dim == vectorsRight.Dim && vectorsLeft.GetBinaryVector() != nil && vectorsRight.GetBinaryVector() != nil {
|
||||
hammin, err := distance.CalcHamminDistance(vectorsLeft.Dim, vectorsLeft.GetBinaryVector(), vectorsRight.GetBinaryVector())
|
||||
if err != nil {
|
||||
return &milvuspb.CalcDistanceResults{
|
||||
Status: &commonpb.Status{
|
||||
ErrorCode: commonpb.ErrorCode_UnexpectedError,
|
||||
Reason: err.Error(),
|
||||
},
|
||||
}, nil
|
||||
}
|
||||
|
||||
if metric == distance.HAMMING {
|
||||
return &milvuspb.CalcDistanceResults{
|
||||
Status: &commonpb.Status{ErrorCode: commonpb.ErrorCode_Success, Reason: ""},
|
||||
Array: &milvuspb.CalcDistanceResults_IntDist{
|
||||
IntDist: &schemapb.IntArray{
|
||||
Data: hammin,
|
||||
},
|
||||
},
|
||||
}, nil
|
||||
}
|
||||
|
||||
if metric == distance.TANIMOTO {
|
||||
tanimoto, err := distance.CalcTanimotoCoefficient(vectorsLeft.Dim, hammin)
|
||||
if err != nil {
|
||||
return &milvuspb.CalcDistanceResults{
|
||||
Status: &commonpb.Status{
|
||||
ErrorCode: commonpb.ErrorCode_UnexpectedError,
|
||||
Reason: err.Error(),
|
||||
},
|
||||
}, nil
|
||||
}
|
||||
|
||||
return &milvuspb.CalcDistanceResults{
|
||||
Status: &commonpb.Status{ErrorCode: commonpb.ErrorCode_Success, Reason: ""},
|
||||
Array: &milvuspb.CalcDistanceResults_FloatDist{
|
||||
FloatDist: &schemapb.FloatArray{
|
||||
Data: tanimoto,
|
||||
},
|
||||
},
|
||||
}, nil
|
||||
}
|
||||
}
|
||||
|
||||
err = errors.New("Unexpected error")
|
||||
return &milvuspb.CalcDistanceResults{
|
||||
Status: &commonpb.Status{
|
||||
ErrorCode: commonpb.ErrorCode_UnexpectedError,
|
||||
Reason: err.Error(),
|
||||
},
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (node *Proxy) GetDdChannel(ctx context.Context, request *internalpb.GetDdChannelRequest) (*milvuspb.StringResponse, error) {
|
||||
panic("implement me")
|
||||
}
|
||||
|
|
|
|||
|
|
@ -0,0 +1,250 @@
|
|||
// Copyright (C) 2019-2020 Zilliz. All rights reserved.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance
|
||||
// with the License. You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software distributed under the License
|
||||
// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
|
||||
// or implied. See the License for the specific language governing permissions and limitations under the License.
|
||||
|
||||
package distance
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"strings"
|
||||
"sync"
|
||||
)
|
||||
|
||||
const (
|
||||
L2 = "L2"
|
||||
IP = "IP"
|
||||
HAMMING = "HAMMIN"
|
||||
TANIMOTO = "TANIMOTO"
|
||||
)
|
||||
|
||||
func ValidateMetricType(metric string) (string, error) {
|
||||
if metric == "" {
|
||||
err := errors.New("Metric type is empty")
|
||||
return "", err
|
||||
}
|
||||
|
||||
m := strings.ToUpper(metric)
|
||||
if m == L2 || m == IP || m == HAMMING || m == TANIMOTO {
|
||||
return m, nil
|
||||
}
|
||||
|
||||
err := errors.New("Invalid metric type")
|
||||
return metric, err
|
||||
}
|
||||
|
||||
func ValidateFloatArrayLength(dim int64, length int) error {
|
||||
if length == 0 || int64(length)%dim != 0 {
|
||||
err := errors.New("Invalid float vector length")
|
||||
return err
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func CalcL2(dim int64, left []float32, lIndex int64, right []float32, rIndex int64) float32 {
|
||||
var sum float32 = 0.0
|
||||
lFrom := lIndex * dim
|
||||
rFrom := rIndex * dim
|
||||
for i := int64(0); i < dim; i++ {
|
||||
gap := left[lFrom+i] - right[rFrom+i]
|
||||
sum += gap * gap
|
||||
}
|
||||
|
||||
return sum
|
||||
}
|
||||
|
||||
func CalcIP(dim int64, left []float32, lIndex int64, right []float32, rIndex int64) float32 {
|
||||
var sum float32 = 0.0
|
||||
lFrom := lIndex * dim
|
||||
rFrom := rIndex * dim
|
||||
for i := int64(0); i < dim; i++ {
|
||||
sum += left[lFrom+i] * right[rFrom+i]
|
||||
}
|
||||
|
||||
return sum
|
||||
}
|
||||
|
||||
func CalcFFBatch(dim int64, left []float32, lIndex int64, right []float32, metric string, result *[]float32) {
|
||||
rightNum := int64(len(right)) / dim
|
||||
for i := int64(0); i < rightNum; i++ {
|
||||
var distance float32 = -1.0
|
||||
if metric == L2 {
|
||||
distance = CalcL2(dim, left, lIndex, right, i)
|
||||
} else if metric == IP {
|
||||
distance = CalcIP(dim, left, lIndex, right, i)
|
||||
}
|
||||
(*result)[lIndex*rightNum+i] = distance
|
||||
}
|
||||
}
|
||||
|
||||
func CalcFloatDistance(dim int64, left []float32, right []float32, metric string) ([]float32, error) {
|
||||
if dim <= 0 {
|
||||
err := errors.New("Invalid dimension")
|
||||
return nil, err
|
||||
}
|
||||
|
||||
metricUpper := strings.ToUpper(metric)
|
||||
if metricUpper != L2 && metricUpper != IP {
|
||||
err := errors.New("Invalid metric type")
|
||||
return nil, err
|
||||
}
|
||||
|
||||
err := ValidateFloatArrayLength(dim, len(left))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
err = ValidateFloatArrayLength(dim, len(right))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
leftNum := int64(len(left)) / dim
|
||||
rightNum := int64(len(right)) / dim
|
||||
|
||||
distArray := make([]float32, leftNum*rightNum)
|
||||
|
||||
var waitGroup sync.WaitGroup
|
||||
CalcWorker := func(index int64) {
|
||||
CalcFFBatch(dim, left, index, right, metricUpper, &distArray)
|
||||
waitGroup.Done()
|
||||
}
|
||||
for i := int64(0); i < leftNum; i++ {
|
||||
waitGroup.Add(1)
|
||||
go CalcWorker(i)
|
||||
}
|
||||
waitGroup.Wait()
|
||||
|
||||
return distArray, nil
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
func SingleBitLen(dim int64) int64 {
|
||||
if dim%8 == 0 {
|
||||
return dim
|
||||
}
|
||||
|
||||
return dim + 8 - dim%8
|
||||
}
|
||||
|
||||
func VectorCount(dim int64, length int) int64 {
|
||||
singleBitLen := SingleBitLen(dim)
|
||||
return int64(length*8) / singleBitLen
|
||||
}
|
||||
|
||||
func ValidateBinaryArrayLength(dim int64, length int) error {
|
||||
singleBitLen := SingleBitLen(dim)
|
||||
totalBitLen := int64(length * 8)
|
||||
if length == 0 || totalBitLen%singleBitLen != 0 {
|
||||
err := errors.New("Invalid binary vector length")
|
||||
return err
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// Count 1 of uint8
|
||||
// For 00000010, return 1
|
||||
// Fro 11111111, return 8
|
||||
func CountOne(n uint8) int32 {
|
||||
count := int32(0)
|
||||
for n != 0 {
|
||||
count++
|
||||
n = n & (n - 1)
|
||||
}
|
||||
return count
|
||||
}
|
||||
|
||||
// HAMMIN distance
|
||||
func CalcHammin(dim int64, left []byte, lIndex int64, right []byte, rIndex int64) int32 {
|
||||
singleBitLen := SingleBitLen(dim)
|
||||
numBytes := singleBitLen / 8
|
||||
lFrom := lIndex * numBytes
|
||||
rFrom := rIndex * numBytes
|
||||
|
||||
var hammin int32 = 0
|
||||
for i := int64(0); i < numBytes; i++ {
|
||||
var xor uint8 = left[lFrom+i] ^ right[rFrom+i]
|
||||
|
||||
// The dimension "dim" may not be an integer multiple of 8
|
||||
// For example:
|
||||
// dim = 11, each vector has 2 uint8 value
|
||||
// the second uint8, only need to calculate 3 bits, the other 5 bits will be set to 0
|
||||
if i == numBytes-1 && numBytes*8 > dim {
|
||||
offset := numBytes*8 - dim
|
||||
xor = xor & (255 << offset)
|
||||
}
|
||||
|
||||
hammin += CountOne(xor)
|
||||
}
|
||||
|
||||
return hammin
|
||||
}
|
||||
|
||||
func CalcHamminBatch(dim int64, left []byte, lIndex int64, right []byte, result *[]int32) {
|
||||
rightNum := VectorCount(dim, len(right))
|
||||
|
||||
for i := int64(0); i < rightNum; i++ {
|
||||
hammin := CalcHammin(dim, left, lIndex, right, i)
|
||||
(*result)[lIndex*rightNum+i] = hammin
|
||||
}
|
||||
}
|
||||
|
||||
func CalcHamminDistance(dim int64, left []byte, right []byte) ([]int32, error) {
|
||||
if dim <= 0 {
|
||||
err := errors.New("Invalid dimension")
|
||||
return nil, err
|
||||
}
|
||||
|
||||
err := ValidateBinaryArrayLength(dim, len(left))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
err = ValidateBinaryArrayLength(dim, len(right))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
leftNum := VectorCount(dim, len(left))
|
||||
rightNum := VectorCount(dim, len(right))
|
||||
distArray := make([]int32, leftNum*rightNum)
|
||||
|
||||
var waitGroup sync.WaitGroup
|
||||
CalcWorker := func(index int64) {
|
||||
CalcHamminBatch(dim, left, index, right, &distArray)
|
||||
waitGroup.Done()
|
||||
}
|
||||
for i := int64(0); i < leftNum; i++ {
|
||||
waitGroup.Add(1)
|
||||
go CalcWorker(i)
|
||||
}
|
||||
waitGroup.Wait()
|
||||
|
||||
return distArray, nil
|
||||
}
|
||||
|
||||
func CalcTanimotoCoefficient(dim int64, hammin []int32) ([]float32, error) {
|
||||
if dim <= 0 || len(hammin) == 0 {
|
||||
err := errors.New("Invalid input for tanimoto")
|
||||
return nil, err
|
||||
}
|
||||
|
||||
array := make([]float32, len(hammin))
|
||||
for i := 0; i < len(hammin); i++ {
|
||||
if hammin[i] >= int32(dim)*2 {
|
||||
err := errors.New("Invalid hammin for tanimoto")
|
||||
return nil, err
|
||||
}
|
||||
array[i] = float32(hammin[i] / (int32(dim)*2 - hammin[i]))
|
||||
}
|
||||
|
||||
return array, nil
|
||||
}
|
||||
|
|
@ -0,0 +1,258 @@
|
|||
// Copyright (C) 2019-2020 Zilliz. All rights reserved.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance
|
||||
// with the License. You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software distributed under the License
|
||||
// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
|
||||
// or implied. See the License for the specific language governing permissions and limitations under the License.
|
||||
|
||||
package distance
|
||||
|
||||
import (
|
||||
"math"
|
||||
"math/rand"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/stretchr/testify/assert"
|
||||
)
|
||||
|
||||
const PRECISION = 1e-6
|
||||
|
||||
func TestValidateMetricType(t *testing.T) {
|
||||
invalidMetric := []string{"", "aaa"}
|
||||
for _, str := range invalidMetric {
|
||||
_, err := ValidateMetricType(str)
|
||||
assert.Error(t, err)
|
||||
}
|
||||
|
||||
validMetric := []string{"L2", "ip", "Hammin", "Tanimoto"}
|
||||
for _, str := range validMetric {
|
||||
metric, err := ValidateMetricType(str)
|
||||
assert.Nil(t, err)
|
||||
assert.True(t, metric == L2 || metric == IP || metric == HAMMING || metric == TANIMOTO)
|
||||
}
|
||||
}
|
||||
|
||||
func TestValidateFloatArrayLength(t *testing.T) {
|
||||
err := ValidateFloatArrayLength(3, 12)
|
||||
assert.Nil(t, err)
|
||||
|
||||
err = ValidateFloatArrayLength(5, 11)
|
||||
assert.Error(t, err)
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
func CreateFloatArray(n int64, dim int64) []float32 {
|
||||
rand.Seed(time.Now().UnixNano())
|
||||
num := n * dim
|
||||
array := make([]float32, num)
|
||||
for i := int64(0); i < num; i++ {
|
||||
array[i] = rand.Float32()
|
||||
}
|
||||
|
||||
return array
|
||||
}
|
||||
|
||||
func DistanceL2(left []float32, right []float32) float32 {
|
||||
if len(left) != len(right) {
|
||||
panic("array dimension not equal")
|
||||
}
|
||||
var sum float32 = 0.0
|
||||
for i := 0; i < len(left); i++ {
|
||||
gap := left[i] - right[i]
|
||||
sum += gap * gap
|
||||
}
|
||||
|
||||
return sum
|
||||
}
|
||||
|
||||
func DistanceIP(left []float32, right []float32) float32 {
|
||||
if len(left) != len(right) {
|
||||
panic("array dimension not equal")
|
||||
}
|
||||
var sum float32 = 0.0
|
||||
for i := 0; i < len(left); i++ {
|
||||
sum += left[i] * right[i]
|
||||
}
|
||||
|
||||
return sum
|
||||
}
|
||||
|
||||
func TestCalcL2(t *testing.T) {
|
||||
var dim int64 = 128
|
||||
var leftNum int64 = 1
|
||||
var rightNum int64 = 1
|
||||
|
||||
left := CreateFloatArray(leftNum, dim)
|
||||
right := CreateFloatArray(rightNum, dim)
|
||||
|
||||
sum := DistanceL2(left, right)
|
||||
|
||||
distance := CalcL2(dim, left, 0, right, 0)
|
||||
assert.Less(t, math.Abs(float64(sum-distance)), PRECISION)
|
||||
|
||||
distance = CalcL2(dim, left, 0, left, 0)
|
||||
assert.Less(t, float64(distance), PRECISION)
|
||||
}
|
||||
|
||||
func TestCalcIP(t *testing.T) {
|
||||
var dim int64 = 128
|
||||
var leftNum int64 = 1
|
||||
var rightNum int64 = 1
|
||||
|
||||
left := CreateFloatArray(leftNum, dim)
|
||||
right := CreateFloatArray(rightNum, dim)
|
||||
|
||||
sum := DistanceIP(left, right)
|
||||
|
||||
distance := CalcIP(dim, left, 0, right, 0)
|
||||
assert.Less(t, math.Abs(float64(sum-distance)), PRECISION)
|
||||
}
|
||||
|
||||
func TestCalcFloatDistance(t *testing.T) {
|
||||
var dim int64 = 128
|
||||
var leftNum int64 = 10
|
||||
var rightNum int64 = 5
|
||||
|
||||
left := CreateFloatArray(leftNum, dim)
|
||||
right := CreateFloatArray(rightNum, dim)
|
||||
|
||||
_, err := CalcFloatDistance(dim, left, right, "HAMMIN")
|
||||
assert.Error(t, err)
|
||||
|
||||
_, err = CalcFloatDistance(3, left, right, "L2")
|
||||
assert.Error(t, err)
|
||||
|
||||
_, err = CalcFloatDistance(dim, left, right, "HAMMIN")
|
||||
assert.Error(t, err)
|
||||
|
||||
_, err = CalcFloatDistance(0, left, right, "L2")
|
||||
assert.Error(t, err)
|
||||
|
||||
distances, err := CalcFloatDistance(dim, left, right, "L2")
|
||||
assert.Nil(t, err)
|
||||
|
||||
for i := int64(0); i < leftNum; i++ {
|
||||
for j := int64(0); j < rightNum; j++ {
|
||||
v1 := left[i*dim : (i+1)*dim]
|
||||
v2 := right[j*dim : (j+1)*dim]
|
||||
sum := DistanceL2(v1, v2)
|
||||
assert.Less(t, math.Abs(float64(sum-distances[i*rightNum+j])), PRECISION)
|
||||
}
|
||||
}
|
||||
|
||||
distances, err = CalcFloatDistance(dim, left, right, "IP")
|
||||
assert.Nil(t, err)
|
||||
|
||||
for i := int64(0); i < leftNum; i++ {
|
||||
for j := int64(0); j < rightNum; j++ {
|
||||
v1 := left[i*dim : (i+1)*dim]
|
||||
v2 := right[j*dim : (j+1)*dim]
|
||||
sum := DistanceIP(v1, v2)
|
||||
assert.Less(t, math.Abs(float64(sum-distances[i*rightNum+j])), PRECISION)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
func CreateBinaryArray(n int64, dim int64) []byte {
|
||||
rand.Seed(time.Now().UnixNano())
|
||||
num := n * dim / 8
|
||||
if num*8 < n*dim {
|
||||
num = num + 1
|
||||
}
|
||||
array := make([]byte, num)
|
||||
for i := int64(0); i < num; i++ {
|
||||
n := rand.Intn(256)
|
||||
array[i] = uint8(n)
|
||||
}
|
||||
|
||||
return array
|
||||
}
|
||||
|
||||
func TestSingleBitLen(t *testing.T) {
|
||||
n := SingleBitLen(125)
|
||||
assert.Equal(t, n, int64(128))
|
||||
|
||||
n = SingleBitLen(133)
|
||||
assert.Equal(t, n, int64(136))
|
||||
}
|
||||
|
||||
func TestVectorCount(t *testing.T) {
|
||||
n := VectorCount(15, 20)
|
||||
assert.Equal(t, n, int64(10))
|
||||
|
||||
n = VectorCount(8, 3)
|
||||
assert.Equal(t, n, int64(3))
|
||||
}
|
||||
|
||||
func TestValidateBinaryArrayLength(t *testing.T) {
|
||||
err := ValidateBinaryArrayLength(21, 12)
|
||||
assert.Nil(t, err)
|
||||
|
||||
err = ValidateBinaryArrayLength(21, 11)
|
||||
assert.Error(t, err)
|
||||
}
|
||||
|
||||
func TestCountOne(t *testing.T) {
|
||||
n := CountOne(6)
|
||||
assert.Equal(t, n, int32(2))
|
||||
|
||||
n = CountOne(0)
|
||||
assert.Equal(t, n, int32(0))
|
||||
|
||||
n = CountOne(255)
|
||||
assert.Equal(t, n, int32(8))
|
||||
}
|
||||
|
||||
func TestCalcHammin(t *testing.T) {
|
||||
var dim int64 = 22
|
||||
// v1 = 00000010 00000110 00001000
|
||||
v1 := make([]uint8, 3)
|
||||
v1[0] = 2
|
||||
v1[1] = 6
|
||||
v1[2] = 8
|
||||
// v2 = 00000001 00000111 00011011
|
||||
v2 := make([]uint8, 3)
|
||||
v2[0] = 1
|
||||
v2[1] = 7
|
||||
v2[2] = 27
|
||||
n := CalcHammin(dim, v1, 0, v2, 0)
|
||||
assert.Equal(t, n, int32(4))
|
||||
|
||||
hammin := make([]int32, 1)
|
||||
hammin[0] = n
|
||||
tanimoto, err := CalcTanimotoCoefficient(dim, hammin)
|
||||
assert.Nil(t, err)
|
||||
assert.Less(t, math.Abs(float64(tanimoto[0]-float32(n/(int32(dim)*2-n)))), float64(PRECISION))
|
||||
}
|
||||
|
||||
func TestCalcHamminDistance(t *testing.T) {
|
||||
var dim int64 = 125
|
||||
var leftNum int64 = 2
|
||||
|
||||
left := CreateBinaryArray(leftNum, dim)
|
||||
|
||||
_, e := CalcHamminDistance(0, left, left)
|
||||
assert.Error(t, e)
|
||||
|
||||
distances, err := CalcHamminDistance(dim, left, left)
|
||||
assert.Nil(t, err)
|
||||
|
||||
n := CalcHammin(dim, left, 0, left, 0)
|
||||
assert.Equal(t, n, int32(0))
|
||||
|
||||
n = CalcHammin(dim, left, 1, left, 1)
|
||||
assert.Equal(t, n, int32(0))
|
||||
|
||||
n = CalcHammin(dim, left, 0, left, 1)
|
||||
assert.Equal(t, n, distances[1])
|
||||
|
||||
n = CalcHammin(dim, left, 1, left, 0)
|
||||
assert.Equal(t, n, distances[2])
|
||||
}
|
||||
Loading…
Reference in New Issue