| // Code generated by protoc-gen-gogo. |
| // source: github.com/containerd/cgroups/metrics.proto |
| // DO NOT EDIT! |
| |
| /* |
| Package cgroups is a generated protocol buffer package. |
| |
| It is generated from these files: |
| github.com/containerd/cgroups/metrics.proto |
| |
| It has these top-level messages: |
| Metrics |
| HugetlbStat |
| PidsStat |
| CPUStat |
| CPUUsage |
| Throttle |
| MemoryStat |
| MemoryEntry |
| BlkIOStat |
| BlkIOEntry |
| RdmaStat |
| RdmaEntry |
| */ |
| package cgroups |
| |
| import proto "github.com/gogo/protobuf/proto" |
| import fmt "fmt" |
| import math "math" |
| import _ "github.com/gogo/protobuf/gogoproto" |
| |
| import strings "strings" |
| import reflect "reflect" |
| |
| import io "io" |
| |
| // Reference imports to suppress errors if they are not otherwise used. |
| var _ = proto.Marshal |
| var _ = fmt.Errorf |
| var _ = math.Inf |
| |
| // This is a compile-time assertion to ensure that this generated file |
| // is compatible with the proto package it is being compiled against. |
| // A compilation error at this line likely means your copy of the |
| // proto package needs to be updated. |
| const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package |
| |
| type Metrics struct { |
| Hugetlb []*HugetlbStat `protobuf:"bytes,1,rep,name=hugetlb" json:"hugetlb,omitempty"` |
| Pids *PidsStat `protobuf:"bytes,2,opt,name=pids" json:"pids,omitempty"` |
| CPU *CPUStat `protobuf:"bytes,3,opt,name=cpu" json:"cpu,omitempty"` |
| Memory *MemoryStat `protobuf:"bytes,4,opt,name=memory" json:"memory,omitempty"` |
| Blkio *BlkIOStat `protobuf:"bytes,5,opt,name=blkio" json:"blkio,omitempty"` |
| Rdma *RdmaStat `protobuf:"bytes,6,opt,name=rdma" json:"rdma,omitempty"` |
| } |
| |
| func (m *Metrics) Reset() { *m = Metrics{} } |
| func (*Metrics) ProtoMessage() {} |
| func (*Metrics) Descriptor() ([]byte, []int) { return fileDescriptorMetrics, []int{0} } |
| |
| type HugetlbStat struct { |
| Usage uint64 `protobuf:"varint,1,opt,name=usage,proto3" json:"usage,omitempty"` |
| Max uint64 `protobuf:"varint,2,opt,name=max,proto3" json:"max,omitempty"` |
| Failcnt uint64 `protobuf:"varint,3,opt,name=failcnt,proto3" json:"failcnt,omitempty"` |
| Pagesize string `protobuf:"bytes,4,opt,name=pagesize,proto3" json:"pagesize,omitempty"` |
| } |
| |
| func (m *HugetlbStat) Reset() { *m = HugetlbStat{} } |
| func (*HugetlbStat) ProtoMessage() {} |
| func (*HugetlbStat) Descriptor() ([]byte, []int) { return fileDescriptorMetrics, []int{1} } |
| |
| type PidsStat struct { |
| Current uint64 `protobuf:"varint,1,opt,name=current,proto3" json:"current,omitempty"` |
| Limit uint64 `protobuf:"varint,2,opt,name=limit,proto3" json:"limit,omitempty"` |
| } |
| |
| func (m *PidsStat) Reset() { *m = PidsStat{} } |
| func (*PidsStat) ProtoMessage() {} |
| func (*PidsStat) Descriptor() ([]byte, []int) { return fileDescriptorMetrics, []int{2} } |
| |
| type CPUStat struct { |
| Usage *CPUUsage `protobuf:"bytes,1,opt,name=usage" json:"usage,omitempty"` |
| Throttling *Throttle `protobuf:"bytes,2,opt,name=throttling" json:"throttling,omitempty"` |
| } |
| |
| func (m *CPUStat) Reset() { *m = CPUStat{} } |
| func (*CPUStat) ProtoMessage() {} |
| func (*CPUStat) Descriptor() ([]byte, []int) { return fileDescriptorMetrics, []int{3} } |
| |
| type CPUUsage struct { |
| // values in nanoseconds |
| Total uint64 `protobuf:"varint,1,opt,name=total,proto3" json:"total,omitempty"` |
| Kernel uint64 `protobuf:"varint,2,opt,name=kernel,proto3" json:"kernel,omitempty"` |
| User uint64 `protobuf:"varint,3,opt,name=user,proto3" json:"user,omitempty"` |
| PerCPU []uint64 `protobuf:"varint,4,rep,packed,name=per_cpu,json=perCpu" json:"per_cpu,omitempty"` |
| } |
| |
| func (m *CPUUsage) Reset() { *m = CPUUsage{} } |
| func (*CPUUsage) ProtoMessage() {} |
| func (*CPUUsage) Descriptor() ([]byte, []int) { return fileDescriptorMetrics, []int{4} } |
| |
| type Throttle struct { |
| Periods uint64 `protobuf:"varint,1,opt,name=periods,proto3" json:"periods,omitempty"` |
| ThrottledPeriods uint64 `protobuf:"varint,2,opt,name=throttled_periods,json=throttledPeriods,proto3" json:"throttled_periods,omitempty"` |
| ThrottledTime uint64 `protobuf:"varint,3,opt,name=throttled_time,json=throttledTime,proto3" json:"throttled_time,omitempty"` |
| } |
| |
| func (m *Throttle) Reset() { *m = Throttle{} } |
| func (*Throttle) ProtoMessage() {} |
| func (*Throttle) Descriptor() ([]byte, []int) { return fileDescriptorMetrics, []int{5} } |
| |
| type MemoryStat struct { |
| Cache uint64 `protobuf:"varint,1,opt,name=cache,proto3" json:"cache,omitempty"` |
| RSS uint64 `protobuf:"varint,2,opt,name=rss,proto3" json:"rss,omitempty"` |
| RSSHuge uint64 `protobuf:"varint,3,opt,name=rss_huge,json=rssHuge,proto3" json:"rss_huge,omitempty"` |
| MappedFile uint64 `protobuf:"varint,4,opt,name=mapped_file,json=mappedFile,proto3" json:"mapped_file,omitempty"` |
| Dirty uint64 `protobuf:"varint,5,opt,name=dirty,proto3" json:"dirty,omitempty"` |
| Writeback uint64 `protobuf:"varint,6,opt,name=writeback,proto3" json:"writeback,omitempty"` |
| PgPgIn uint64 `protobuf:"varint,7,opt,name=pg_pg_in,json=pgPgIn,proto3" json:"pg_pg_in,omitempty"` |
| PgPgOut uint64 `protobuf:"varint,8,opt,name=pg_pg_out,json=pgPgOut,proto3" json:"pg_pg_out,omitempty"` |
| PgFault uint64 `protobuf:"varint,9,opt,name=pg_fault,json=pgFault,proto3" json:"pg_fault,omitempty"` |
| PgMajFault uint64 `protobuf:"varint,10,opt,name=pg_maj_fault,json=pgMajFault,proto3" json:"pg_maj_fault,omitempty"` |
| InactiveAnon uint64 `protobuf:"varint,11,opt,name=inactive_anon,json=inactiveAnon,proto3" json:"inactive_anon,omitempty"` |
| ActiveAnon uint64 `protobuf:"varint,12,opt,name=active_anon,json=activeAnon,proto3" json:"active_anon,omitempty"` |
| InactiveFile uint64 `protobuf:"varint,13,opt,name=inactive_file,json=inactiveFile,proto3" json:"inactive_file,omitempty"` |
| ActiveFile uint64 `protobuf:"varint,14,opt,name=active_file,json=activeFile,proto3" json:"active_file,omitempty"` |
| Unevictable uint64 `protobuf:"varint,15,opt,name=unevictable,proto3" json:"unevictable,omitempty"` |
| HierarchicalMemoryLimit uint64 `protobuf:"varint,16,opt,name=hierarchical_memory_limit,json=hierarchicalMemoryLimit,proto3" json:"hierarchical_memory_limit,omitempty"` |
| HierarchicalSwapLimit uint64 `protobuf:"varint,17,opt,name=hierarchical_swap_limit,json=hierarchicalSwapLimit,proto3" json:"hierarchical_swap_limit,omitempty"` |
| TotalCache uint64 `protobuf:"varint,18,opt,name=total_cache,json=totalCache,proto3" json:"total_cache,omitempty"` |
| TotalRSS uint64 `protobuf:"varint,19,opt,name=total_rss,json=totalRss,proto3" json:"total_rss,omitempty"` |
| TotalRSSHuge uint64 `protobuf:"varint,20,opt,name=total_rss_huge,json=totalRssHuge,proto3" json:"total_rss_huge,omitempty"` |
| TotalMappedFile uint64 `protobuf:"varint,21,opt,name=total_mapped_file,json=totalMappedFile,proto3" json:"total_mapped_file,omitempty"` |
| TotalDirty uint64 `protobuf:"varint,22,opt,name=total_dirty,json=totalDirty,proto3" json:"total_dirty,omitempty"` |
| TotalWriteback uint64 `protobuf:"varint,23,opt,name=total_writeback,json=totalWriteback,proto3" json:"total_writeback,omitempty"` |
| TotalPgPgIn uint64 `protobuf:"varint,24,opt,name=total_pg_pg_in,json=totalPgPgIn,proto3" json:"total_pg_pg_in,omitempty"` |
| TotalPgPgOut uint64 `protobuf:"varint,25,opt,name=total_pg_pg_out,json=totalPgPgOut,proto3" json:"total_pg_pg_out,omitempty"` |
| TotalPgFault uint64 `protobuf:"varint,26,opt,name=total_pg_fault,json=totalPgFault,proto3" json:"total_pg_fault,omitempty"` |
| TotalPgMajFault uint64 `protobuf:"varint,27,opt,name=total_pg_maj_fault,json=totalPgMajFault,proto3" json:"total_pg_maj_fault,omitempty"` |
| TotalInactiveAnon uint64 `protobuf:"varint,28,opt,name=total_inactive_anon,json=totalInactiveAnon,proto3" json:"total_inactive_anon,omitempty"` |
| TotalActiveAnon uint64 `protobuf:"varint,29,opt,name=total_active_anon,json=totalActiveAnon,proto3" json:"total_active_anon,omitempty"` |
| TotalInactiveFile uint64 `protobuf:"varint,30,opt,name=total_inactive_file,json=totalInactiveFile,proto3" json:"total_inactive_file,omitempty"` |
| TotalActiveFile uint64 `protobuf:"varint,31,opt,name=total_active_file,json=totalActiveFile,proto3" json:"total_active_file,omitempty"` |
| TotalUnevictable uint64 `protobuf:"varint,32,opt,name=total_unevictable,json=totalUnevictable,proto3" json:"total_unevictable,omitempty"` |
| Usage *MemoryEntry `protobuf:"bytes,33,opt,name=usage" json:"usage,omitempty"` |
| Swap *MemoryEntry `protobuf:"bytes,34,opt,name=swap" json:"swap,omitempty"` |
| Kernel *MemoryEntry `protobuf:"bytes,35,opt,name=kernel" json:"kernel,omitempty"` |
| KernelTCP *MemoryEntry `protobuf:"bytes,36,opt,name=kernel_tcp,json=kernelTcp" json:"kernel_tcp,omitempty"` |
| } |
| |
| func (m *MemoryStat) Reset() { *m = MemoryStat{} } |
| func (*MemoryStat) ProtoMessage() {} |
| func (*MemoryStat) Descriptor() ([]byte, []int) { return fileDescriptorMetrics, []int{6} } |
| |
| type MemoryEntry struct { |
| Limit uint64 `protobuf:"varint,1,opt,name=limit,proto3" json:"limit,omitempty"` |
| Usage uint64 `protobuf:"varint,2,opt,name=usage,proto3" json:"usage,omitempty"` |
| Max uint64 `protobuf:"varint,3,opt,name=max,proto3" json:"max,omitempty"` |
| Failcnt uint64 `protobuf:"varint,4,opt,name=failcnt,proto3" json:"failcnt,omitempty"` |
| } |
| |
| func (m *MemoryEntry) Reset() { *m = MemoryEntry{} } |
| func (*MemoryEntry) ProtoMessage() {} |
| func (*MemoryEntry) Descriptor() ([]byte, []int) { return fileDescriptorMetrics, []int{7} } |
| |
| type BlkIOStat struct { |
| IoServiceBytesRecursive []*BlkIOEntry `protobuf:"bytes,1,rep,name=io_service_bytes_recursive,json=ioServiceBytesRecursive" json:"io_service_bytes_recursive,omitempty"` |
| IoServicedRecursive []*BlkIOEntry `protobuf:"bytes,2,rep,name=io_serviced_recursive,json=ioServicedRecursive" json:"io_serviced_recursive,omitempty"` |
| IoQueuedRecursive []*BlkIOEntry `protobuf:"bytes,3,rep,name=io_queued_recursive,json=ioQueuedRecursive" json:"io_queued_recursive,omitempty"` |
| IoServiceTimeRecursive []*BlkIOEntry `protobuf:"bytes,4,rep,name=io_service_time_recursive,json=ioServiceTimeRecursive" json:"io_service_time_recursive,omitempty"` |
| IoWaitTimeRecursive []*BlkIOEntry `protobuf:"bytes,5,rep,name=io_wait_time_recursive,json=ioWaitTimeRecursive" json:"io_wait_time_recursive,omitempty"` |
| IoMergedRecursive []*BlkIOEntry `protobuf:"bytes,6,rep,name=io_merged_recursive,json=ioMergedRecursive" json:"io_merged_recursive,omitempty"` |
| IoTimeRecursive []*BlkIOEntry `protobuf:"bytes,7,rep,name=io_time_recursive,json=ioTimeRecursive" json:"io_time_recursive,omitempty"` |
| SectorsRecursive []*BlkIOEntry `protobuf:"bytes,8,rep,name=sectors_recursive,json=sectorsRecursive" json:"sectors_recursive,omitempty"` |
| } |
| |
| func (m *BlkIOStat) Reset() { *m = BlkIOStat{} } |
| func (*BlkIOStat) ProtoMessage() {} |
| func (*BlkIOStat) Descriptor() ([]byte, []int) { return fileDescriptorMetrics, []int{8} } |
| |
| type BlkIOEntry struct { |
| Op string `protobuf:"bytes,1,opt,name=op,proto3" json:"op,omitempty"` |
| Device string `protobuf:"bytes,2,opt,name=device,proto3" json:"device,omitempty"` |
| Major uint64 `protobuf:"varint,3,opt,name=major,proto3" json:"major,omitempty"` |
| Minor uint64 `protobuf:"varint,4,opt,name=minor,proto3" json:"minor,omitempty"` |
| Value uint64 `protobuf:"varint,5,opt,name=value,proto3" json:"value,omitempty"` |
| } |
| |
| func (m *BlkIOEntry) Reset() { *m = BlkIOEntry{} } |
| func (*BlkIOEntry) ProtoMessage() {} |
| func (*BlkIOEntry) Descriptor() ([]byte, []int) { return fileDescriptorMetrics, []int{9} } |
| |
| type RdmaStat struct { |
| Current []*RdmaEntry `protobuf:"bytes,1,rep,name=current" json:"current,omitempty"` |
| Limit []*RdmaEntry `protobuf:"bytes,2,rep,name=limit" json:"limit,omitempty"` |
| } |
| |
| func (m *RdmaStat) Reset() { *m = RdmaStat{} } |
| func (*RdmaStat) ProtoMessage() {} |
| func (*RdmaStat) Descriptor() ([]byte, []int) { return fileDescriptorMetrics, []int{10} } |
| |
| type RdmaEntry struct { |
| Device string `protobuf:"bytes,1,opt,name=device,proto3" json:"device,omitempty"` |
| HcaHandles uint32 `protobuf:"varint,2,opt,name=hca_handles,json=hcaHandles,proto3" json:"hca_handles,omitempty"` |
| HcaObjects uint32 `protobuf:"varint,3,opt,name=hca_objects,json=hcaObjects,proto3" json:"hca_objects,omitempty"` |
| } |
| |
| func (m *RdmaEntry) Reset() { *m = RdmaEntry{} } |
| func (*RdmaEntry) ProtoMessage() {} |
| func (*RdmaEntry) Descriptor() ([]byte, []int) { return fileDescriptorMetrics, []int{11} } |
| |
| func init() { |
| proto.RegisterType((*Metrics)(nil), "io.containerd.cgroups.v1.Metrics") |
| proto.RegisterType((*HugetlbStat)(nil), "io.containerd.cgroups.v1.HugetlbStat") |
| proto.RegisterType((*PidsStat)(nil), "io.containerd.cgroups.v1.PidsStat") |
| proto.RegisterType((*CPUStat)(nil), "io.containerd.cgroups.v1.CPUStat") |
| proto.RegisterType((*CPUUsage)(nil), "io.containerd.cgroups.v1.CPUUsage") |
| proto.RegisterType((*Throttle)(nil), "io.containerd.cgroups.v1.Throttle") |
| proto.RegisterType((*MemoryStat)(nil), "io.containerd.cgroups.v1.MemoryStat") |
| proto.RegisterType((*MemoryEntry)(nil), "io.containerd.cgroups.v1.MemoryEntry") |
| proto.RegisterType((*BlkIOStat)(nil), "io.containerd.cgroups.v1.BlkIOStat") |
| proto.RegisterType((*BlkIOEntry)(nil), "io.containerd.cgroups.v1.BlkIOEntry") |
| proto.RegisterType((*RdmaStat)(nil), "io.containerd.cgroups.v1.RdmaStat") |
| proto.RegisterType((*RdmaEntry)(nil), "io.containerd.cgroups.v1.RdmaEntry") |
| } |
| func (m *Metrics) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalTo(dAtA) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *Metrics) MarshalTo(dAtA []byte) (int, error) { |
| var i int |
| _ = i |
| var l int |
| _ = l |
| if len(m.Hugetlb) > 0 { |
| for _, msg := range m.Hugetlb { |
| dAtA[i] = 0xa |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(msg.Size())) |
| n, err := msg.MarshalTo(dAtA[i:]) |
| if err != nil { |
| return 0, err |
| } |
| i += n |
| } |
| } |
| if m.Pids != nil { |
| dAtA[i] = 0x12 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.Pids.Size())) |
| n1, err := m.Pids.MarshalTo(dAtA[i:]) |
| if err != nil { |
| return 0, err |
| } |
| i += n1 |
| } |
| if m.CPU != nil { |
| dAtA[i] = 0x1a |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.CPU.Size())) |
| n2, err := m.CPU.MarshalTo(dAtA[i:]) |
| if err != nil { |
| return 0, err |
| } |
| i += n2 |
| } |
| if m.Memory != nil { |
| dAtA[i] = 0x22 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.Memory.Size())) |
| n3, err := m.Memory.MarshalTo(dAtA[i:]) |
| if err != nil { |
| return 0, err |
| } |
| i += n3 |
| } |
| if m.Blkio != nil { |
| dAtA[i] = 0x2a |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.Blkio.Size())) |
| n4, err := m.Blkio.MarshalTo(dAtA[i:]) |
| if err != nil { |
| return 0, err |
| } |
| i += n4 |
| } |
| if m.Rdma != nil { |
| dAtA[i] = 0x32 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.Rdma.Size())) |
| n5, err := m.Rdma.MarshalTo(dAtA[i:]) |
| if err != nil { |
| return 0, err |
| } |
| i += n5 |
| } |
| return i, nil |
| } |
| |
| func (m *HugetlbStat) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalTo(dAtA) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *HugetlbStat) MarshalTo(dAtA []byte) (int, error) { |
| var i int |
| _ = i |
| var l int |
| _ = l |
| if m.Usage != 0 { |
| dAtA[i] = 0x8 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.Usage)) |
| } |
| if m.Max != 0 { |
| dAtA[i] = 0x10 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.Max)) |
| } |
| if m.Failcnt != 0 { |
| dAtA[i] = 0x18 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.Failcnt)) |
| } |
| if len(m.Pagesize) > 0 { |
| dAtA[i] = 0x22 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(len(m.Pagesize))) |
| i += copy(dAtA[i:], m.Pagesize) |
| } |
| return i, nil |
| } |
| |
| func (m *PidsStat) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalTo(dAtA) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *PidsStat) MarshalTo(dAtA []byte) (int, error) { |
| var i int |
| _ = i |
| var l int |
| _ = l |
| if m.Current != 0 { |
| dAtA[i] = 0x8 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.Current)) |
| } |
| if m.Limit != 0 { |
| dAtA[i] = 0x10 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.Limit)) |
| } |
| return i, nil |
| } |
| |
| func (m *CPUStat) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalTo(dAtA) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *CPUStat) MarshalTo(dAtA []byte) (int, error) { |
| var i int |
| _ = i |
| var l int |
| _ = l |
| if m.Usage != nil { |
| dAtA[i] = 0xa |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.Usage.Size())) |
| n5, err := m.Usage.MarshalTo(dAtA[i:]) |
| if err != nil { |
| return 0, err |
| } |
| i += n5 |
| } |
| if m.Throttling != nil { |
| dAtA[i] = 0x12 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.Throttling.Size())) |
| n6, err := m.Throttling.MarshalTo(dAtA[i:]) |
| if err != nil { |
| return 0, err |
| } |
| i += n6 |
| } |
| return i, nil |
| } |
| |
| func (m *CPUUsage) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalTo(dAtA) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *CPUUsage) MarshalTo(dAtA []byte) (int, error) { |
| var i int |
| _ = i |
| var l int |
| _ = l |
| if m.Total != 0 { |
| dAtA[i] = 0x8 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.Total)) |
| } |
| if m.Kernel != 0 { |
| dAtA[i] = 0x10 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.Kernel)) |
| } |
| if m.User != 0 { |
| dAtA[i] = 0x18 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.User)) |
| } |
| if len(m.PerCPU) > 0 { |
| dAtA8 := make([]byte, len(m.PerCPU)*10) |
| var j7 int |
| for _, num := range m.PerCPU { |
| for num >= 1<<7 { |
| dAtA8[j7] = uint8(uint64(num)&0x7f | 0x80) |
| num >>= 7 |
| j7++ |
| } |
| dAtA8[j7] = uint8(num) |
| j7++ |
| } |
| dAtA[i] = 0x22 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(j7)) |
| i += copy(dAtA[i:], dAtA8[:j7]) |
| } |
| return i, nil |
| } |
| |
| func (m *Throttle) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalTo(dAtA) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *Throttle) MarshalTo(dAtA []byte) (int, error) { |
| var i int |
| _ = i |
| var l int |
| _ = l |
| if m.Periods != 0 { |
| dAtA[i] = 0x8 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.Periods)) |
| } |
| if m.ThrottledPeriods != 0 { |
| dAtA[i] = 0x10 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.ThrottledPeriods)) |
| } |
| if m.ThrottledTime != 0 { |
| dAtA[i] = 0x18 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.ThrottledTime)) |
| } |
| return i, nil |
| } |
| |
| func (m *MemoryStat) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalTo(dAtA) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *MemoryStat) MarshalTo(dAtA []byte) (int, error) { |
| var i int |
| _ = i |
| var l int |
| _ = l |
| if m.Cache != 0 { |
| dAtA[i] = 0x8 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.Cache)) |
| } |
| if m.RSS != 0 { |
| dAtA[i] = 0x10 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.RSS)) |
| } |
| if m.RSSHuge != 0 { |
| dAtA[i] = 0x18 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.RSSHuge)) |
| } |
| if m.MappedFile != 0 { |
| dAtA[i] = 0x20 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.MappedFile)) |
| } |
| if m.Dirty != 0 { |
| dAtA[i] = 0x28 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.Dirty)) |
| } |
| if m.Writeback != 0 { |
| dAtA[i] = 0x30 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.Writeback)) |
| } |
| if m.PgPgIn != 0 { |
| dAtA[i] = 0x38 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.PgPgIn)) |
| } |
| if m.PgPgOut != 0 { |
| dAtA[i] = 0x40 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.PgPgOut)) |
| } |
| if m.PgFault != 0 { |
| dAtA[i] = 0x48 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.PgFault)) |
| } |
| if m.PgMajFault != 0 { |
| dAtA[i] = 0x50 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.PgMajFault)) |
| } |
| if m.InactiveAnon != 0 { |
| dAtA[i] = 0x58 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.InactiveAnon)) |
| } |
| if m.ActiveAnon != 0 { |
| dAtA[i] = 0x60 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.ActiveAnon)) |
| } |
| if m.InactiveFile != 0 { |
| dAtA[i] = 0x68 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.InactiveFile)) |
| } |
| if m.ActiveFile != 0 { |
| dAtA[i] = 0x70 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.ActiveFile)) |
| } |
| if m.Unevictable != 0 { |
| dAtA[i] = 0x78 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.Unevictable)) |
| } |
| if m.HierarchicalMemoryLimit != 0 { |
| dAtA[i] = 0x80 |
| i++ |
| dAtA[i] = 0x1 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.HierarchicalMemoryLimit)) |
| } |
| if m.HierarchicalSwapLimit != 0 { |
| dAtA[i] = 0x88 |
| i++ |
| dAtA[i] = 0x1 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.HierarchicalSwapLimit)) |
| } |
| if m.TotalCache != 0 { |
| dAtA[i] = 0x90 |
| i++ |
| dAtA[i] = 0x1 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.TotalCache)) |
| } |
| if m.TotalRSS != 0 { |
| dAtA[i] = 0x98 |
| i++ |
| dAtA[i] = 0x1 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.TotalRSS)) |
| } |
| if m.TotalRSSHuge != 0 { |
| dAtA[i] = 0xa0 |
| i++ |
| dAtA[i] = 0x1 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.TotalRSSHuge)) |
| } |
| if m.TotalMappedFile != 0 { |
| dAtA[i] = 0xa8 |
| i++ |
| dAtA[i] = 0x1 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.TotalMappedFile)) |
| } |
| if m.TotalDirty != 0 { |
| dAtA[i] = 0xb0 |
| i++ |
| dAtA[i] = 0x1 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.TotalDirty)) |
| } |
| if m.TotalWriteback != 0 { |
| dAtA[i] = 0xb8 |
| i++ |
| dAtA[i] = 0x1 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.TotalWriteback)) |
| } |
| if m.TotalPgPgIn != 0 { |
| dAtA[i] = 0xc0 |
| i++ |
| dAtA[i] = 0x1 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.TotalPgPgIn)) |
| } |
| if m.TotalPgPgOut != 0 { |
| dAtA[i] = 0xc8 |
| i++ |
| dAtA[i] = 0x1 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.TotalPgPgOut)) |
| } |
| if m.TotalPgFault != 0 { |
| dAtA[i] = 0xd0 |
| i++ |
| dAtA[i] = 0x1 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.TotalPgFault)) |
| } |
| if m.TotalPgMajFault != 0 { |
| dAtA[i] = 0xd8 |
| i++ |
| dAtA[i] = 0x1 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.TotalPgMajFault)) |
| } |
| if m.TotalInactiveAnon != 0 { |
| dAtA[i] = 0xe0 |
| i++ |
| dAtA[i] = 0x1 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.TotalInactiveAnon)) |
| } |
| if m.TotalActiveAnon != 0 { |
| dAtA[i] = 0xe8 |
| i++ |
| dAtA[i] = 0x1 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.TotalActiveAnon)) |
| } |
| if m.TotalInactiveFile != 0 { |
| dAtA[i] = 0xf0 |
| i++ |
| dAtA[i] = 0x1 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.TotalInactiveFile)) |
| } |
| if m.TotalActiveFile != 0 { |
| dAtA[i] = 0xf8 |
| i++ |
| dAtA[i] = 0x1 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.TotalActiveFile)) |
| } |
| if m.TotalUnevictable != 0 { |
| dAtA[i] = 0x80 |
| i++ |
| dAtA[i] = 0x2 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.TotalUnevictable)) |
| } |
| if m.Usage != nil { |
| dAtA[i] = 0x8a |
| i++ |
| dAtA[i] = 0x2 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.Usage.Size())) |
| n9, err := m.Usage.MarshalTo(dAtA[i:]) |
| if err != nil { |
| return 0, err |
| } |
| i += n9 |
| } |
| if m.Swap != nil { |
| dAtA[i] = 0x92 |
| i++ |
| dAtA[i] = 0x2 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.Swap.Size())) |
| n10, err := m.Swap.MarshalTo(dAtA[i:]) |
| if err != nil { |
| return 0, err |
| } |
| i += n10 |
| } |
| if m.Kernel != nil { |
| dAtA[i] = 0x9a |
| i++ |
| dAtA[i] = 0x2 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.Kernel.Size())) |
| n11, err := m.Kernel.MarshalTo(dAtA[i:]) |
| if err != nil { |
| return 0, err |
| } |
| i += n11 |
| } |
| if m.KernelTCP != nil { |
| dAtA[i] = 0xa2 |
| i++ |
| dAtA[i] = 0x2 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.KernelTCP.Size())) |
| n12, err := m.KernelTCP.MarshalTo(dAtA[i:]) |
| if err != nil { |
| return 0, err |
| } |
| i += n12 |
| } |
| return i, nil |
| } |
| |
| func (m *MemoryEntry) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalTo(dAtA) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *MemoryEntry) MarshalTo(dAtA []byte) (int, error) { |
| var i int |
| _ = i |
| var l int |
| _ = l |
| |
| if m.Limit != 0 { |
| dAtA[i] = 0x8 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.Limit)) |
| } |
| if m.Usage != 0 { |
| dAtA[i] = 0x10 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.Usage)) |
| } |
| if m.Max != 0 { |
| dAtA[i] = 0x18 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.Max)) |
| } |
| if m.Failcnt != 0 { |
| dAtA[i] = 0x20 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.Failcnt)) |
| } |
| return i, nil |
| } |
| |
| func (m *BlkIOStat) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalTo(dAtA) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *BlkIOStat) MarshalTo(dAtA []byte) (int, error) { |
| var i int |
| _ = i |
| var l int |
| _ = l |
| if len(m.IoServiceBytesRecursive) > 0 { |
| for _, msg := range m.IoServiceBytesRecursive { |
| dAtA[i] = 0xa |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(msg.Size())) |
| n, err := msg.MarshalTo(dAtA[i:]) |
| if err != nil { |
| return 0, err |
| } |
| i += n |
| } |
| } |
| if len(m.IoServicedRecursive) > 0 { |
| for _, msg := range m.IoServicedRecursive { |
| dAtA[i] = 0x12 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(msg.Size())) |
| n, err := msg.MarshalTo(dAtA[i:]) |
| if err != nil { |
| return 0, err |
| } |
| i += n |
| } |
| } |
| if len(m.IoQueuedRecursive) > 0 { |
| for _, msg := range m.IoQueuedRecursive { |
| dAtA[i] = 0x1a |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(msg.Size())) |
| n, err := msg.MarshalTo(dAtA[i:]) |
| if err != nil { |
| return 0, err |
| } |
| i += n |
| } |
| } |
| if len(m.IoServiceTimeRecursive) > 0 { |
| for _, msg := range m.IoServiceTimeRecursive { |
| dAtA[i] = 0x22 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(msg.Size())) |
| n, err := msg.MarshalTo(dAtA[i:]) |
| if err != nil { |
| return 0, err |
| } |
| i += n |
| } |
| } |
| if len(m.IoWaitTimeRecursive) > 0 { |
| for _, msg := range m.IoWaitTimeRecursive { |
| dAtA[i] = 0x2a |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(msg.Size())) |
| n, err := msg.MarshalTo(dAtA[i:]) |
| if err != nil { |
| return 0, err |
| } |
| i += n |
| } |
| } |
| if len(m.IoMergedRecursive) > 0 { |
| for _, msg := range m.IoMergedRecursive { |
| dAtA[i] = 0x32 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(msg.Size())) |
| n, err := msg.MarshalTo(dAtA[i:]) |
| if err != nil { |
| return 0, err |
| } |
| i += n |
| } |
| } |
| if len(m.IoTimeRecursive) > 0 { |
| for _, msg := range m.IoTimeRecursive { |
| dAtA[i] = 0x3a |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(msg.Size())) |
| n, err := msg.MarshalTo(dAtA[i:]) |
| if err != nil { |
| return 0, err |
| } |
| i += n |
| } |
| } |
| if len(m.SectorsRecursive) > 0 { |
| for _, msg := range m.SectorsRecursive { |
| dAtA[i] = 0x42 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(msg.Size())) |
| n, err := msg.MarshalTo(dAtA[i:]) |
| if err != nil { |
| return 0, err |
| } |
| i += n |
| } |
| } |
| return i, nil |
| } |
| |
| func (m *BlkIOEntry) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalTo(dAtA) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *BlkIOEntry) MarshalTo(dAtA []byte) (int, error) { |
| var i int |
| _ = i |
| var l int |
| _ = l |
| if len(m.Op) > 0 { |
| dAtA[i] = 0xa |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(len(m.Op))) |
| i += copy(dAtA[i:], m.Op) |
| } |
| if len(m.Device) > 0 { |
| dAtA[i] = 0x12 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(len(m.Device))) |
| i += copy(dAtA[i:], m.Device) |
| } |
| if m.Major != 0 { |
| dAtA[i] = 0x18 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.Major)) |
| } |
| if m.Minor != 0 { |
| dAtA[i] = 0x20 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.Minor)) |
| } |
| if m.Value != 0 { |
| dAtA[i] = 0x28 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.Value)) |
| } |
| return i, nil |
| } |
| |
| func (m *RdmaStat) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalTo(dAtA) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *RdmaStat) MarshalTo(dAtA []byte) (int, error) { |
| var i int |
| _ = i |
| var l int |
| _ = l |
| if len(m.Current) > 0 { |
| for _, msg := range m.Current { |
| dAtA[i] = 0xa |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(msg.Size())) |
| n, err := msg.MarshalTo(dAtA[i:]) |
| if err != nil { |
| return 0, err |
| } |
| i += n |
| } |
| } |
| if len(m.Limit) > 0 { |
| for _, msg := range m.Limit { |
| dAtA[i] = 0x12 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(msg.Size())) |
| n, err := msg.MarshalTo(dAtA[i:]) |
| if err != nil { |
| return 0, err |
| } |
| i += n |
| } |
| } |
| return i, nil |
| } |
| |
| func (m *RdmaEntry) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalTo(dAtA) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *RdmaEntry) MarshalTo(dAtA []byte) (int, error) { |
| var i int |
| _ = i |
| var l int |
| _ = l |
| if len(m.Device) > 0 { |
| dAtA[i] = 0xa |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(len(m.Device))) |
| i += copy(dAtA[i:], m.Device) |
| } |
| if m.HcaHandles != 0 { |
| dAtA[i] = 0x10 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.HcaHandles)) |
| } |
| if m.HcaObjects != 0 { |
| dAtA[i] = 0x18 |
| i++ |
| i = encodeVarintMetrics(dAtA, i, uint64(m.HcaObjects)) |
| } |
| return i, nil |
| } |
| |
| func encodeFixed64Metrics(dAtA []byte, offset int, v uint64) int { |
| dAtA[offset] = uint8(v) |
| dAtA[offset+1] = uint8(v >> 8) |
| dAtA[offset+2] = uint8(v >> 16) |
| dAtA[offset+3] = uint8(v >> 24) |
| dAtA[offset+4] = uint8(v >> 32) |
| dAtA[offset+5] = uint8(v >> 40) |
| dAtA[offset+6] = uint8(v >> 48) |
| dAtA[offset+7] = uint8(v >> 56) |
| return offset + 8 |
| } |
| func encodeFixed32Metrics(dAtA []byte, offset int, v uint32) int { |
| dAtA[offset] = uint8(v) |
| dAtA[offset+1] = uint8(v >> 8) |
| dAtA[offset+2] = uint8(v >> 16) |
| dAtA[offset+3] = uint8(v >> 24) |
| return offset + 4 |
| } |
| func encodeVarintMetrics(dAtA []byte, offset int, v uint64) int { |
| for v >= 1<<7 { |
| dAtA[offset] = uint8(v&0x7f | 0x80) |
| v >>= 7 |
| offset++ |
| } |
| dAtA[offset] = uint8(v) |
| return offset + 1 |
| } |
| func (m *Metrics) Size() (n int) { |
| var l int |
| _ = l |
| if len(m.Hugetlb) > 0 { |
| for _, e := range m.Hugetlb { |
| l = e.Size() |
| n += 1 + l + sovMetrics(uint64(l)) |
| } |
| } |
| if m.Pids != nil { |
| l = m.Pids.Size() |
| n += 1 + l + sovMetrics(uint64(l)) |
| } |
| if m.CPU != nil { |
| l = m.CPU.Size() |
| n += 1 + l + sovMetrics(uint64(l)) |
| } |
| if m.Memory != nil { |
| l = m.Memory.Size() |
| n += 1 + l + sovMetrics(uint64(l)) |
| } |
| if m.Blkio != nil { |
| l = m.Blkio.Size() |
| n += 1 + l + sovMetrics(uint64(l)) |
| } |
| if m.Rdma != nil { |
| l = m.Rdma.Size() |
| n += 1 + l + sovMetrics(uint64(l)) |
| } |
| return n |
| } |
| |
| func (m *HugetlbStat) Size() (n int) { |
| var l int |
| _ = l |
| if m.Usage != 0 { |
| n += 1 + sovMetrics(uint64(m.Usage)) |
| } |
| if m.Max != 0 { |
| n += 1 + sovMetrics(uint64(m.Max)) |
| } |
| if m.Failcnt != 0 { |
| n += 1 + sovMetrics(uint64(m.Failcnt)) |
| } |
| l = len(m.Pagesize) |
| if l > 0 { |
| n += 1 + l + sovMetrics(uint64(l)) |
| } |
| return n |
| } |
| |
| func (m *PidsStat) Size() (n int) { |
| var l int |
| _ = l |
| if m.Current != 0 { |
| n += 1 + sovMetrics(uint64(m.Current)) |
| } |
| if m.Limit != 0 { |
| n += 1 + sovMetrics(uint64(m.Limit)) |
| } |
| return n |
| } |
| |
| func (m *CPUStat) Size() (n int) { |
| var l int |
| _ = l |
| if m.Usage != nil { |
| l = m.Usage.Size() |
| n += 1 + l + sovMetrics(uint64(l)) |
| } |
| if m.Throttling != nil { |
| l = m.Throttling.Size() |
| n += 1 + l + sovMetrics(uint64(l)) |
| } |
| return n |
| } |
| |
| func (m *CPUUsage) Size() (n int) { |
| var l int |
| _ = l |
| if m.Total != 0 { |
| n += 1 + sovMetrics(uint64(m.Total)) |
| } |
| if m.Kernel != 0 { |
| n += 1 + sovMetrics(uint64(m.Kernel)) |
| } |
| if m.User != 0 { |
| n += 1 + sovMetrics(uint64(m.User)) |
| } |
| if len(m.PerCPU) > 0 { |
| l = 0 |
| for _, e := range m.PerCPU { |
| l += sovMetrics(uint64(e)) |
| } |
| n += 1 + sovMetrics(uint64(l)) + l |
| } |
| return n |
| } |
| |
| func (m *Throttle) Size() (n int) { |
| var l int |
| _ = l |
| if m.Periods != 0 { |
| n += 1 + sovMetrics(uint64(m.Periods)) |
| } |
| if m.ThrottledPeriods != 0 { |
| n += 1 + sovMetrics(uint64(m.ThrottledPeriods)) |
| } |
| if m.ThrottledTime != 0 { |
| n += 1 + sovMetrics(uint64(m.ThrottledTime)) |
| } |
| return n |
| } |
| |
| func (m *MemoryStat) Size() (n int) { |
| var l int |
| _ = l |
| if m.Cache != 0 { |
| n += 1 + sovMetrics(uint64(m.Cache)) |
| } |
| if m.RSS != 0 { |
| n += 1 + sovMetrics(uint64(m.RSS)) |
| } |
| if m.RSSHuge != 0 { |
| n += 1 + sovMetrics(uint64(m.RSSHuge)) |
| } |
| if m.MappedFile != 0 { |
| n += 1 + sovMetrics(uint64(m.MappedFile)) |
| } |
| if m.Dirty != 0 { |
| n += 1 + sovMetrics(uint64(m.Dirty)) |
| } |
| if m.Writeback != 0 { |
| n += 1 + sovMetrics(uint64(m.Writeback)) |
| } |
| if m.PgPgIn != 0 { |
| n += 1 + sovMetrics(uint64(m.PgPgIn)) |
| } |
| if m.PgPgOut != 0 { |
| n += 1 + sovMetrics(uint64(m.PgPgOut)) |
| } |
| if m.PgFault != 0 { |
| n += 1 + sovMetrics(uint64(m.PgFault)) |
| } |
| if m.PgMajFault != 0 { |
| n += 1 + sovMetrics(uint64(m.PgMajFault)) |
| } |
| if m.InactiveAnon != 0 { |
| n += 1 + sovMetrics(uint64(m.InactiveAnon)) |
| } |
| if m.ActiveAnon != 0 { |
| n += 1 + sovMetrics(uint64(m.ActiveAnon)) |
| } |
| if m.InactiveFile != 0 { |
| n += 1 + sovMetrics(uint64(m.InactiveFile)) |
| } |
| if m.ActiveFile != 0 { |
| n += 1 + sovMetrics(uint64(m.ActiveFile)) |
| } |
| if m.Unevictable != 0 { |
| n += 1 + sovMetrics(uint64(m.Unevictable)) |
| } |
| if m.HierarchicalMemoryLimit != 0 { |
| n += 2 + sovMetrics(uint64(m.HierarchicalMemoryLimit)) |
| } |
| if m.HierarchicalSwapLimit != 0 { |
| n += 2 + sovMetrics(uint64(m.HierarchicalSwapLimit)) |
| } |
| if m.TotalCache != 0 { |
| n += 2 + sovMetrics(uint64(m.TotalCache)) |
| } |
| if m.TotalRSS != 0 { |
| n += 2 + sovMetrics(uint64(m.TotalRSS)) |
| } |
| if m.TotalRSSHuge != 0 { |
| n += 2 + sovMetrics(uint64(m.TotalRSSHuge)) |
| } |
| if m.TotalMappedFile != 0 { |
| n += 2 + sovMetrics(uint64(m.TotalMappedFile)) |
| } |
| if m.TotalDirty != 0 { |
| n += 2 + sovMetrics(uint64(m.TotalDirty)) |
| } |
| if m.TotalWriteback != 0 { |
| n += 2 + sovMetrics(uint64(m.TotalWriteback)) |
| } |
| if m.TotalPgPgIn != 0 { |
| n += 2 + sovMetrics(uint64(m.TotalPgPgIn)) |
| } |
| if m.TotalPgPgOut != 0 { |
| n += 2 + sovMetrics(uint64(m.TotalPgPgOut)) |
| } |
| if m.TotalPgFault != 0 { |
| n += 2 + sovMetrics(uint64(m.TotalPgFault)) |
| } |
| if m.TotalPgMajFault != 0 { |
| n += 2 + sovMetrics(uint64(m.TotalPgMajFault)) |
| } |
| if m.TotalInactiveAnon != 0 { |
| n += 2 + sovMetrics(uint64(m.TotalInactiveAnon)) |
| } |
| if m.TotalActiveAnon != 0 { |
| n += 2 + sovMetrics(uint64(m.TotalActiveAnon)) |
| } |
| if m.TotalInactiveFile != 0 { |
| n += 2 + sovMetrics(uint64(m.TotalInactiveFile)) |
| } |
| if m.TotalActiveFile != 0 { |
| n += 2 + sovMetrics(uint64(m.TotalActiveFile)) |
| } |
| if m.TotalUnevictable != 0 { |
| n += 2 + sovMetrics(uint64(m.TotalUnevictable)) |
| } |
| if m.Usage != nil { |
| l = m.Usage.Size() |
| n += 2 + l + sovMetrics(uint64(l)) |
| } |
| if m.Swap != nil { |
| l = m.Swap.Size() |
| n += 2 + l + sovMetrics(uint64(l)) |
| } |
| if m.Kernel != nil { |
| l = m.Kernel.Size() |
| n += 2 + l + sovMetrics(uint64(l)) |
| } |
| if m.KernelTCP != nil { |
| l = m.KernelTCP.Size() |
| n += 2 + l + sovMetrics(uint64(l)) |
| } |
| return n |
| } |
| |
| func (m *MemoryEntry) Size() (n int) { |
| var l int |
| _ = l |
| if m.Limit != 0 { |
| n += 1 + sovMetrics(uint64(m.Limit)) |
| } |
| if m.Usage != 0 { |
| n += 1 + sovMetrics(uint64(m.Usage)) |
| } |
| if m.Max != 0 { |
| n += 1 + sovMetrics(uint64(m.Max)) |
| } |
| if m.Failcnt != 0 { |
| n += 1 + sovMetrics(uint64(m.Failcnt)) |
| } |
| return n |
| } |
| |
| func (m *BlkIOStat) Size() (n int) { |
| var l int |
| _ = l |
| if len(m.IoServiceBytesRecursive) > 0 { |
| for _, e := range m.IoServiceBytesRecursive { |
| l = e.Size() |
| n += 1 + l + sovMetrics(uint64(l)) |
| } |
| } |
| if len(m.IoServicedRecursive) > 0 { |
| for _, e := range m.IoServicedRecursive { |
| l = e.Size() |
| n += 1 + l + sovMetrics(uint64(l)) |
| } |
| } |
| if len(m.IoQueuedRecursive) > 0 { |
| for _, e := range m.IoQueuedRecursive { |
| l = e.Size() |
| n += 1 + l + sovMetrics(uint64(l)) |
| } |
| } |
| if len(m.IoServiceTimeRecursive) > 0 { |
| for _, e := range m.IoServiceTimeRecursive { |
| l = e.Size() |
| n += 1 + l + sovMetrics(uint64(l)) |
| } |
| } |
| if len(m.IoWaitTimeRecursive) > 0 { |
| for _, e := range m.IoWaitTimeRecursive { |
| l = e.Size() |
| n += 1 + l + sovMetrics(uint64(l)) |
| } |
| } |
| if len(m.IoMergedRecursive) > 0 { |
| for _, e := range m.IoMergedRecursive { |
| l = e.Size() |
| n += 1 + l + sovMetrics(uint64(l)) |
| } |
| } |
| if len(m.IoTimeRecursive) > 0 { |
| for _, e := range m.IoTimeRecursive { |
| l = e.Size() |
| n += 1 + l + sovMetrics(uint64(l)) |
| } |
| } |
| if len(m.SectorsRecursive) > 0 { |
| for _, e := range m.SectorsRecursive { |
| l = e.Size() |
| n += 1 + l + sovMetrics(uint64(l)) |
| } |
| } |
| return n |
| } |
| |
| func (m *BlkIOEntry) Size() (n int) { |
| var l int |
| _ = l |
| l = len(m.Op) |
| if l > 0 { |
| n += 1 + l + sovMetrics(uint64(l)) |
| } |
| l = len(m.Device) |
| if l > 0 { |
| n += 1 + l + sovMetrics(uint64(l)) |
| } |
| if m.Major != 0 { |
| n += 1 + sovMetrics(uint64(m.Major)) |
| } |
| if m.Minor != 0 { |
| n += 1 + sovMetrics(uint64(m.Minor)) |
| } |
| if m.Value != 0 { |
| n += 1 + sovMetrics(uint64(m.Value)) |
| } |
| return n |
| } |
| |
| func (m *RdmaStat) Size() (n int) { |
| var l int |
| _ = l |
| if len(m.Current) > 0 { |
| for _, e := range m.Current { |
| l = e.Size() |
| n += 1 + l + sovMetrics(uint64(l)) |
| } |
| } |
| if len(m.Limit) > 0 { |
| for _, e := range m.Limit { |
| l = e.Size() |
| n += 1 + l + sovMetrics(uint64(l)) |
| } |
| } |
| return n |
| } |
| |
| func (m *RdmaEntry) Size() (n int) { |
| var l int |
| _ = l |
| l = len(m.Device) |
| if l > 0 { |
| n += 1 + l + sovMetrics(uint64(l)) |
| } |
| if m.HcaHandles != 0 { |
| n += 1 + sovMetrics(uint64(m.HcaHandles)) |
| } |
| if m.HcaObjects != 0 { |
| n += 1 + sovMetrics(uint64(m.HcaObjects)) |
| } |
| return n |
| } |
| |
| func sovMetrics(x uint64) (n int) { |
| for { |
| n++ |
| x >>= 7 |
| if x == 0 { |
| break |
| } |
| } |
| return n |
| } |
| func sozMetrics(x uint64) (n int) { |
| return sovMetrics(uint64((x << 1) ^ uint64((int64(x) >> 63)))) |
| } |
| func (this *Metrics) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&Metrics{`, |
| `Hugetlb:` + strings.Replace(fmt.Sprintf("%v", this.Hugetlb), "HugetlbStat", "HugetlbStat", 1) + `,`, |
| `Pids:` + strings.Replace(fmt.Sprintf("%v", this.Pids), "PidsStat", "PidsStat", 1) + `,`, |
| `CPU:` + strings.Replace(fmt.Sprintf("%v", this.CPU), "CPUStat", "CPUStat", 1) + `,`, |
| `Memory:` + strings.Replace(fmt.Sprintf("%v", this.Memory), "MemoryStat", "MemoryStat", 1) + `,`, |
| `Blkio:` + strings.Replace(fmt.Sprintf("%v", this.Blkio), "BlkIOStat", "BlkIOStat", 1) + `,`, |
| `Rdma:` + strings.Replace(fmt.Sprintf("%v", this.Rdma), "RdmaStat", "RdmaStat", 1) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *HugetlbStat) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&HugetlbStat{`, |
| `Usage:` + fmt.Sprintf("%v", this.Usage) + `,`, |
| `Max:` + fmt.Sprintf("%v", this.Max) + `,`, |
| `Failcnt:` + fmt.Sprintf("%v", this.Failcnt) + `,`, |
| `Pagesize:` + fmt.Sprintf("%v", this.Pagesize) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *PidsStat) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&PidsStat{`, |
| `Current:` + fmt.Sprintf("%v", this.Current) + `,`, |
| `Limit:` + fmt.Sprintf("%v", this.Limit) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *CPUStat) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&CPUStat{`, |
| `Usage:` + strings.Replace(fmt.Sprintf("%v", this.Usage), "CPUUsage", "CPUUsage", 1) + `,`, |
| `Throttling:` + strings.Replace(fmt.Sprintf("%v", this.Throttling), "Throttle", "Throttle", 1) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *CPUUsage) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&CPUUsage{`, |
| `Total:` + fmt.Sprintf("%v", this.Total) + `,`, |
| `Kernel:` + fmt.Sprintf("%v", this.Kernel) + `,`, |
| `User:` + fmt.Sprintf("%v", this.User) + `,`, |
| `PerCPU:` + fmt.Sprintf("%v", this.PerCPU) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *Throttle) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&Throttle{`, |
| `Periods:` + fmt.Sprintf("%v", this.Periods) + `,`, |
| `ThrottledPeriods:` + fmt.Sprintf("%v", this.ThrottledPeriods) + `,`, |
| `ThrottledTime:` + fmt.Sprintf("%v", this.ThrottledTime) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *MemoryStat) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&MemoryStat{`, |
| `Cache:` + fmt.Sprintf("%v", this.Cache) + `,`, |
| `RSS:` + fmt.Sprintf("%v", this.RSS) + `,`, |
| `RSSHuge:` + fmt.Sprintf("%v", this.RSSHuge) + `,`, |
| `MappedFile:` + fmt.Sprintf("%v", this.MappedFile) + `,`, |
| `Dirty:` + fmt.Sprintf("%v", this.Dirty) + `,`, |
| `Writeback:` + fmt.Sprintf("%v", this.Writeback) + `,`, |
| `PgPgIn:` + fmt.Sprintf("%v", this.PgPgIn) + `,`, |
| `PgPgOut:` + fmt.Sprintf("%v", this.PgPgOut) + `,`, |
| `PgFault:` + fmt.Sprintf("%v", this.PgFault) + `,`, |
| `PgMajFault:` + fmt.Sprintf("%v", this.PgMajFault) + `,`, |
| `InactiveAnon:` + fmt.Sprintf("%v", this.InactiveAnon) + `,`, |
| `ActiveAnon:` + fmt.Sprintf("%v", this.ActiveAnon) + `,`, |
| `InactiveFile:` + fmt.Sprintf("%v", this.InactiveFile) + `,`, |
| `ActiveFile:` + fmt.Sprintf("%v", this.ActiveFile) + `,`, |
| `Unevictable:` + fmt.Sprintf("%v", this.Unevictable) + `,`, |
| `HierarchicalMemoryLimit:` + fmt.Sprintf("%v", this.HierarchicalMemoryLimit) + `,`, |
| `HierarchicalSwapLimit:` + fmt.Sprintf("%v", this.HierarchicalSwapLimit) + `,`, |
| `TotalCache:` + fmt.Sprintf("%v", this.TotalCache) + `,`, |
| `TotalRSS:` + fmt.Sprintf("%v", this.TotalRSS) + `,`, |
| `TotalRSSHuge:` + fmt.Sprintf("%v", this.TotalRSSHuge) + `,`, |
| `TotalMappedFile:` + fmt.Sprintf("%v", this.TotalMappedFile) + `,`, |
| `TotalDirty:` + fmt.Sprintf("%v", this.TotalDirty) + `,`, |
| `TotalWriteback:` + fmt.Sprintf("%v", this.TotalWriteback) + `,`, |
| `TotalPgPgIn:` + fmt.Sprintf("%v", this.TotalPgPgIn) + `,`, |
| `TotalPgPgOut:` + fmt.Sprintf("%v", this.TotalPgPgOut) + `,`, |
| `TotalPgFault:` + fmt.Sprintf("%v", this.TotalPgFault) + `,`, |
| `TotalPgMajFault:` + fmt.Sprintf("%v", this.TotalPgMajFault) + `,`, |
| `TotalInactiveAnon:` + fmt.Sprintf("%v", this.TotalInactiveAnon) + `,`, |
| `TotalActiveAnon:` + fmt.Sprintf("%v", this.TotalActiveAnon) + `,`, |
| `TotalInactiveFile:` + fmt.Sprintf("%v", this.TotalInactiveFile) + `,`, |
| `TotalActiveFile:` + fmt.Sprintf("%v", this.TotalActiveFile) + `,`, |
| `TotalUnevictable:` + fmt.Sprintf("%v", this.TotalUnevictable) + `,`, |
| `Usage:` + strings.Replace(fmt.Sprintf("%v", this.Usage), "MemoryEntry", "MemoryEntry", 1) + `,`, |
| `Swap:` + strings.Replace(fmt.Sprintf("%v", this.Swap), "MemoryEntry", "MemoryEntry", 1) + `,`, |
| `Kernel:` + strings.Replace(fmt.Sprintf("%v", this.Kernel), "MemoryEntry", "MemoryEntry", 1) + `,`, |
| `KernelTCP:` + strings.Replace(fmt.Sprintf("%v", this.KernelTCP), "MemoryEntry", "MemoryEntry", 1) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *MemoryEntry) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&MemoryEntry{`, |
| `Limit:` + fmt.Sprintf("%v", this.Limit) + `,`, |
| `Usage:` + fmt.Sprintf("%v", this.Usage) + `,`, |
| `Max:` + fmt.Sprintf("%v", this.Max) + `,`, |
| `Failcnt:` + fmt.Sprintf("%v", this.Failcnt) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *BlkIOStat) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&BlkIOStat{`, |
| `IoServiceBytesRecursive:` + strings.Replace(fmt.Sprintf("%v", this.IoServiceBytesRecursive), "BlkIOEntry", "BlkIOEntry", 1) + `,`, |
| `IoServicedRecursive:` + strings.Replace(fmt.Sprintf("%v", this.IoServicedRecursive), "BlkIOEntry", "BlkIOEntry", 1) + `,`, |
| `IoQueuedRecursive:` + strings.Replace(fmt.Sprintf("%v", this.IoQueuedRecursive), "BlkIOEntry", "BlkIOEntry", 1) + `,`, |
| `IoServiceTimeRecursive:` + strings.Replace(fmt.Sprintf("%v", this.IoServiceTimeRecursive), "BlkIOEntry", "BlkIOEntry", 1) + `,`, |
| `IoWaitTimeRecursive:` + strings.Replace(fmt.Sprintf("%v", this.IoWaitTimeRecursive), "BlkIOEntry", "BlkIOEntry", 1) + `,`, |
| `IoMergedRecursive:` + strings.Replace(fmt.Sprintf("%v", this.IoMergedRecursive), "BlkIOEntry", "BlkIOEntry", 1) + `,`, |
| `IoTimeRecursive:` + strings.Replace(fmt.Sprintf("%v", this.IoTimeRecursive), "BlkIOEntry", "BlkIOEntry", 1) + `,`, |
| `SectorsRecursive:` + strings.Replace(fmt.Sprintf("%v", this.SectorsRecursive), "BlkIOEntry", "BlkIOEntry", 1) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *BlkIOEntry) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&BlkIOEntry{`, |
| `Op:` + fmt.Sprintf("%v", this.Op) + `,`, |
| `Device:` + fmt.Sprintf("%v", this.Device) + `,`, |
| `Major:` + fmt.Sprintf("%v", this.Major) + `,`, |
| `Minor:` + fmt.Sprintf("%v", this.Minor) + `,`, |
| `Value:` + fmt.Sprintf("%v", this.Value) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *RdmaStat) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&RdmaStat{`, |
| `Current:` + strings.Replace(fmt.Sprintf("%v", this.Current), "RdmaEntry", "RdmaEntry", 1) + `,`, |
| `Limit:` + strings.Replace(fmt.Sprintf("%v", this.Limit), "RdmaEntry", "RdmaEntry", 1) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *RdmaEntry) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&RdmaEntry{`, |
| `Device:` + fmt.Sprintf("%v", this.Device) + `,`, |
| `HcaHandles:` + fmt.Sprintf("%v", this.HcaHandles) + `,`, |
| `HcaObjects:` + fmt.Sprintf("%v", this.HcaObjects) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func valueToStringMetrics(v interface{}) string { |
| rv := reflect.ValueOf(v) |
| if rv.IsNil() { |
| return "nil" |
| } |
| pv := reflect.Indirect(rv).Interface() |
| return fmt.Sprintf("*%v", pv) |
| } |
| func (m *Metrics) Unmarshal(dAtA []byte) error { |
| l := len(dAtA) |
| iNdEx := 0 |
| |
| for iNdEx < l { |
| preIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| wireType := int(wire & 0x7) |
| if wireType == 4 { |
| return fmt.Errorf("proto: Metrics: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: Metrics: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Hugetlb", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= (int(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthMetrics |
| } |
| postIndex := iNdEx + msglen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Hugetlb = append(m.Hugetlb, &HugetlbStat{}) |
| if err := m.Hugetlb[len(m.Hugetlb)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Pids", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= (int(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthMetrics |
| } |
| postIndex := iNdEx + msglen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.Pids == nil { |
| m.Pids = &PidsStat{} |
| } |
| if err := m.Pids.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 3: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field CPU", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= (int(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthMetrics |
| } |
| postIndex := iNdEx + msglen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.CPU == nil { |
| m.CPU = &CPUStat{} |
| } |
| if err := m.CPU.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 4: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Memory", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= (int(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthMetrics |
| } |
| postIndex := iNdEx + msglen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.Memory == nil { |
| m.Memory = &MemoryStat{} |
| } |
| if err := m.Memory.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 5: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Blkio", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= (int(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthMetrics |
| } |
| postIndex := iNdEx + msglen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.Blkio == nil { |
| m.Blkio = &BlkIOStat{} |
| } |
| if err := m.Blkio.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 6: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Rdma", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= (int(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthMetrics |
| } |
| postIndex := iNdEx + msglen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.Rdma == nil { |
| m.Rdma = &RdmaStat{} |
| } |
| if err := m.Rdma.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipMetrics(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthMetrics |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *HugetlbStat) Unmarshal(dAtA []byte) error { |
| l := len(dAtA) |
| iNdEx := 0 |
| for iNdEx < l { |
| preIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| wireType := int(wire & 0x7) |
| if wireType == 4 { |
| return fmt.Errorf("proto: HugetlbStat: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: HugetlbStat: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Usage", wireType) |
| } |
| m.Usage = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Usage |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 2: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Max", wireType) |
| } |
| m.Max = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Max |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 3: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Failcnt", wireType) |
| } |
| m.Failcnt = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Failcnt |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 4: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Pagesize", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthMetrics |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Pagesize = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipMetrics(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthMetrics |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *PidsStat) Unmarshal(dAtA []byte) error { |
| l := len(dAtA) |
| iNdEx := 0 |
| for iNdEx < l { |
| preIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| wireType := int(wire & 0x7) |
| if wireType == 4 { |
| return fmt.Errorf("proto: PidsStat: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: PidsStat: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Current", wireType) |
| } |
| m.Current = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Current |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 2: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType) |
| } |
| m.Limit = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Limit |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| default: |
| iNdEx = preIndex |
| skippy, err := skipMetrics(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthMetrics |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *CPUStat) Unmarshal(dAtA []byte) error { |
| l := len(dAtA) |
| iNdEx := 0 |
| for iNdEx < l { |
| preIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| wireType := int(wire & 0x7) |
| if wireType == 4 { |
| return fmt.Errorf("proto: CPUStat: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: CPUStat: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Usage", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= (int(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthMetrics |
| } |
| postIndex := iNdEx + msglen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.Usage == nil { |
| m.Usage = &CPUUsage{} |
| } |
| if err := m.Usage.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Throttling", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= (int(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthMetrics |
| } |
| postIndex := iNdEx + msglen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.Throttling == nil { |
| m.Throttling = &Throttle{} |
| } |
| if err := m.Throttling.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipMetrics(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthMetrics |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *CPUUsage) Unmarshal(dAtA []byte) error { |
| l := len(dAtA) |
| iNdEx := 0 |
| for iNdEx < l { |
| preIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| wireType := int(wire & 0x7) |
| if wireType == 4 { |
| return fmt.Errorf("proto: CPUUsage: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: CPUUsage: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Total", wireType) |
| } |
| m.Total = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Total |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 2: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Kernel", wireType) |
| } |
| m.Kernel = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Kernel |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 3: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field User", wireType) |
| } |
| m.User = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.User |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 4: |
| if wireType == 0 { |
| var v uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| v |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| m.PerCPU = append(m.PerCPU, v) |
| } else if wireType == 2 { |
| var packedLen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| packedLen |= (int(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if packedLen < 0 { |
| return ErrInvalidLengthMetrics |
| } |
| postIndex := iNdEx + packedLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| for iNdEx < postIndex { |
| var v uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| v |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| m.PerCPU = append(m.PerCPU, v) |
| } |
| } else { |
| return fmt.Errorf("proto: wrong wireType = %d for field PerCPU", wireType) |
| } |
| default: |
| iNdEx = preIndex |
| skippy, err := skipMetrics(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthMetrics |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *Throttle) Unmarshal(dAtA []byte) error { |
| l := len(dAtA) |
| iNdEx := 0 |
| for iNdEx < l { |
| preIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| wireType := int(wire & 0x7) |
| if wireType == 4 { |
| return fmt.Errorf("proto: Throttle: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: Throttle: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Periods", wireType) |
| } |
| m.Periods = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Periods |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 2: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field ThrottledPeriods", wireType) |
| } |
| m.ThrottledPeriods = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.ThrottledPeriods |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 3: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field ThrottledTime", wireType) |
| } |
| m.ThrottledTime = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.ThrottledTime |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| default: |
| iNdEx = preIndex |
| skippy, err := skipMetrics(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthMetrics |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *MemoryStat) Unmarshal(dAtA []byte) error { |
| l := len(dAtA) |
| iNdEx := 0 |
| for iNdEx < l { |
| preIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| wireType := int(wire & 0x7) |
| if wireType == 4 { |
| return fmt.Errorf("proto: MemoryStat: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: MemoryStat: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Cache", wireType) |
| } |
| m.Cache = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Cache |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 2: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field RSS", wireType) |
| } |
| m.RSS = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.RSS |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 3: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field RSSHuge", wireType) |
| } |
| m.RSSHuge = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.RSSHuge |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 4: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field MappedFile", wireType) |
| } |
| m.MappedFile = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.MappedFile |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 5: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Dirty", wireType) |
| } |
| m.Dirty = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Dirty |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 6: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Writeback", wireType) |
| } |
| m.Writeback = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Writeback |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 7: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field PgPgIn", wireType) |
| } |
| m.PgPgIn = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.PgPgIn |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 8: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field PgPgOut", wireType) |
| } |
| m.PgPgOut = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.PgPgOut |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 9: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field PgFault", wireType) |
| } |
| m.PgFault = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.PgFault |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 10: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field PgMajFault", wireType) |
| } |
| m.PgMajFault = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.PgMajFault |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 11: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field InactiveAnon", wireType) |
| } |
| m.InactiveAnon = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.InactiveAnon |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 12: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field ActiveAnon", wireType) |
| } |
| m.ActiveAnon = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.ActiveAnon |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 13: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field InactiveFile", wireType) |
| } |
| m.InactiveFile = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.InactiveFile |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 14: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field ActiveFile", wireType) |
| } |
| m.ActiveFile = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.ActiveFile |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 15: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Unevictable", wireType) |
| } |
| m.Unevictable = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Unevictable |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 16: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field HierarchicalMemoryLimit", wireType) |
| } |
| m.HierarchicalMemoryLimit = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.HierarchicalMemoryLimit |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 17: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field HierarchicalSwapLimit", wireType) |
| } |
| m.HierarchicalSwapLimit = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.HierarchicalSwapLimit |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 18: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field TotalCache", wireType) |
| } |
| m.TotalCache = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.TotalCache |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 19: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field TotalRSS", wireType) |
| } |
| m.TotalRSS = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.TotalRSS |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 20: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field TotalRSSHuge", wireType) |
| } |
| m.TotalRSSHuge = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.TotalRSSHuge |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 21: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field TotalMappedFile", wireType) |
| } |
| m.TotalMappedFile = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.TotalMappedFile |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 22: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field TotalDirty", wireType) |
| } |
| m.TotalDirty = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.TotalDirty |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 23: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field TotalWriteback", wireType) |
| } |
| m.TotalWriteback = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.TotalWriteback |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 24: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field TotalPgPgIn", wireType) |
| } |
| m.TotalPgPgIn = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.TotalPgPgIn |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 25: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field TotalPgPgOut", wireType) |
| } |
| m.TotalPgPgOut = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.TotalPgPgOut |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 26: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field TotalPgFault", wireType) |
| } |
| m.TotalPgFault = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.TotalPgFault |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 27: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field TotalPgMajFault", wireType) |
| } |
| m.TotalPgMajFault = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.TotalPgMajFault |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 28: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field TotalInactiveAnon", wireType) |
| } |
| m.TotalInactiveAnon = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.TotalInactiveAnon |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 29: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field TotalActiveAnon", wireType) |
| } |
| m.TotalActiveAnon = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.TotalActiveAnon |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 30: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field TotalInactiveFile", wireType) |
| } |
| m.TotalInactiveFile = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.TotalInactiveFile |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 31: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field TotalActiveFile", wireType) |
| } |
| m.TotalActiveFile = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.TotalActiveFile |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 32: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field TotalUnevictable", wireType) |
| } |
| m.TotalUnevictable = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.TotalUnevictable |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 33: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Usage", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= (int(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthMetrics |
| } |
| postIndex := iNdEx + msglen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.Usage == nil { |
| m.Usage = &MemoryEntry{} |
| } |
| if err := m.Usage.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 34: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Swap", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= (int(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthMetrics |
| } |
| postIndex := iNdEx + msglen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.Swap == nil { |
| m.Swap = &MemoryEntry{} |
| } |
| if err := m.Swap.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 35: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Kernel", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= (int(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthMetrics |
| } |
| postIndex := iNdEx + msglen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.Kernel == nil { |
| m.Kernel = &MemoryEntry{} |
| } |
| if err := m.Kernel.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 36: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field KernelTCP", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= (int(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthMetrics |
| } |
| postIndex := iNdEx + msglen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.KernelTCP == nil { |
| m.KernelTCP = &MemoryEntry{} |
| } |
| if err := m.KernelTCP.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipMetrics(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthMetrics |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *MemoryEntry) Unmarshal(dAtA []byte) error { |
| l := len(dAtA) |
| iNdEx := 0 |
| for iNdEx < l { |
| preIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| wireType := int(wire & 0x7) |
| if wireType == 4 { |
| return fmt.Errorf("proto: MemoryEntry: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: MemoryEntry: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType) |
| } |
| m.Limit = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Limit |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 2: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Usage", wireType) |
| } |
| m.Usage = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Usage |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 3: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Max", wireType) |
| } |
| m.Max = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Max |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 4: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Failcnt", wireType) |
| } |
| m.Failcnt = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Failcnt |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| default: |
| iNdEx = preIndex |
| skippy, err := skipMetrics(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthMetrics |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *BlkIOStat) Unmarshal(dAtA []byte) error { |
| l := len(dAtA) |
| iNdEx := 0 |
| for iNdEx < l { |
| preIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| wireType := int(wire & 0x7) |
| if wireType == 4 { |
| return fmt.Errorf("proto: BlkIOStat: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: BlkIOStat: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field IoServiceBytesRecursive", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= (int(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthMetrics |
| } |
| postIndex := iNdEx + msglen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.IoServiceBytesRecursive = append(m.IoServiceBytesRecursive, &BlkIOEntry{}) |
| if err := m.IoServiceBytesRecursive[len(m.IoServiceBytesRecursive)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field IoServicedRecursive", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= (int(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthMetrics |
| } |
| postIndex := iNdEx + msglen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.IoServicedRecursive = append(m.IoServicedRecursive, &BlkIOEntry{}) |
| if err := m.IoServicedRecursive[len(m.IoServicedRecursive)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 3: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field IoQueuedRecursive", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= (int(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthMetrics |
| } |
| postIndex := iNdEx + msglen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.IoQueuedRecursive = append(m.IoQueuedRecursive, &BlkIOEntry{}) |
| if err := m.IoQueuedRecursive[len(m.IoQueuedRecursive)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 4: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field IoServiceTimeRecursive", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= (int(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthMetrics |
| } |
| postIndex := iNdEx + msglen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.IoServiceTimeRecursive = append(m.IoServiceTimeRecursive, &BlkIOEntry{}) |
| if err := m.IoServiceTimeRecursive[len(m.IoServiceTimeRecursive)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 5: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field IoWaitTimeRecursive", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= (int(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthMetrics |
| } |
| postIndex := iNdEx + msglen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.IoWaitTimeRecursive = append(m.IoWaitTimeRecursive, &BlkIOEntry{}) |
| if err := m.IoWaitTimeRecursive[len(m.IoWaitTimeRecursive)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 6: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field IoMergedRecursive", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= (int(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthMetrics |
| } |
| postIndex := iNdEx + msglen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.IoMergedRecursive = append(m.IoMergedRecursive, &BlkIOEntry{}) |
| if err := m.IoMergedRecursive[len(m.IoMergedRecursive)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 7: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field IoTimeRecursive", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= (int(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthMetrics |
| } |
| postIndex := iNdEx + msglen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.IoTimeRecursive = append(m.IoTimeRecursive, &BlkIOEntry{}) |
| if err := m.IoTimeRecursive[len(m.IoTimeRecursive)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 8: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field SectorsRecursive", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= (int(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthMetrics |
| } |
| postIndex := iNdEx + msglen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.SectorsRecursive = append(m.SectorsRecursive, &BlkIOEntry{}) |
| if err := m.SectorsRecursive[len(m.SectorsRecursive)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipMetrics(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthMetrics |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *BlkIOEntry) Unmarshal(dAtA []byte) error { |
| l := len(dAtA) |
| iNdEx := 0 |
| for iNdEx < l { |
| preIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| wireType := int(wire & 0x7) |
| if wireType == 4 { |
| return fmt.Errorf("proto: BlkIOEntry: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: BlkIOEntry: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Op", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthMetrics |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Op = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Device", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthMetrics |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Device = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 3: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Major", wireType) |
| } |
| m.Major = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Major |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 4: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Minor", wireType) |
| } |
| m.Minor = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Minor |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 5: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) |
| } |
| m.Value = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Value |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| default: |
| iNdEx = preIndex |
| skippy, err := skipMetrics(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthMetrics |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *RdmaStat) Unmarshal(dAtA []byte) error { |
| l := len(dAtA) |
| iNdEx := 0 |
| for iNdEx < l { |
| preIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| wireType := int(wire & 0x7) |
| if wireType == 4 { |
| return fmt.Errorf("proto: RdmaStat: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: RdmaStat: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Current", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= (int(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthMetrics |
| } |
| postIndex := iNdEx + msglen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Current = append(m.Current, &RdmaEntry{}) |
| if err := m.Current[len(m.Current)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= (int(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthMetrics |
| } |
| postIndex := iNdEx + msglen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Limit = append(m.Limit, &RdmaEntry{}) |
| if err := m.Limit[len(m.Limit)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipMetrics(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthMetrics |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *RdmaEntry) Unmarshal(dAtA []byte) error { |
| l := len(dAtA) |
| iNdEx := 0 |
| for iNdEx < l { |
| preIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| wireType := int(wire & 0x7) |
| if wireType == 4 { |
| return fmt.Errorf("proto: RdmaEntry: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: RdmaEntry: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Device", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthMetrics |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Device = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 2: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field HcaHandles", wireType) |
| } |
| m.HcaHandles = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.HcaHandles |= (uint32(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 3: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field HcaObjects", wireType) |
| } |
| m.HcaObjects = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.HcaObjects |= (uint32(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| default: |
| iNdEx = preIndex |
| skippy, err := skipMetrics(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthMetrics |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| |
| func skipMetrics(dAtA []byte) (n int, err error) { |
| l := len(dAtA) |
| iNdEx := 0 |
| for iNdEx < l { |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return 0, ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return 0, io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| wireType := int(wire & 0x7) |
| switch wireType { |
| case 0: |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return 0, ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return 0, io.ErrUnexpectedEOF |
| } |
| iNdEx++ |
| if dAtA[iNdEx-1] < 0x80 { |
| break |
| } |
| } |
| return iNdEx, nil |
| case 1: |
| iNdEx += 8 |
| return iNdEx, nil |
| case 2: |
| var length int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return 0, ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return 0, io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| length |= (int(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| iNdEx += length |
| if length < 0 { |
| return 0, ErrInvalidLengthMetrics |
| } |
| return iNdEx, nil |
| case 3: |
| for { |
| var innerWire uint64 |
| var start int = iNdEx |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return 0, ErrIntOverflowMetrics |
| } |
| if iNdEx >= l { |
| return 0, io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| innerWire |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| innerWireType := int(innerWire & 0x7) |
| if innerWireType == 4 { |
| break |
| } |
| next, err := skipMetrics(dAtA[start:]) |
| if err != nil { |
| return 0, err |
| } |
| iNdEx = start + next |
| } |
| return iNdEx, nil |
| case 4: |
| return iNdEx, nil |
| case 5: |
| iNdEx += 4 |
| return iNdEx, nil |
| default: |
| return 0, fmt.Errorf("proto: illegal wireType %d", wireType) |
| } |
| } |
| panic("unreachable") |
| } |
| |
| var ( |
| ErrInvalidLengthMetrics = fmt.Errorf("proto: negative length found during unmarshaling") |
| ErrIntOverflowMetrics = fmt.Errorf("proto: integer overflow") |
| ) |
| |
| func init() { proto.RegisterFile("github.com/containerd/cgroups/metrics.proto", fileDescriptorMetrics) } |
| |
| var fileDescriptorMetrics = []byte{ |
| // 1325 bytes of a gzipped FileDescriptorProto |
| 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x57, 0x4d, 0x6f, 0x1b, 0xb7, |
| 0x16, 0x8d, 0xac, 0xb1, 0x3e, 0xae, 0x6c, 0xc7, 0xa6, 0x13, 0x67, 0xec, 0x97, 0x27, 0x29, 0xb2, |
| 0xfd, 0x9e, 0x5b, 0x03, 0x32, 0x9a, 0x02, 0x41, 0x93, 0xa6, 0x28, 0x22, 0xb7, 0x41, 0x83, 0xd6, |
| 0x88, 0x32, 0xb2, 0x91, 0x76, 0x35, 0x18, 0x8d, 0x98, 0x31, 0xe3, 0xd1, 0x70, 0xc2, 0xe1, 0xc8, |
| 0x71, 0x57, 0xdd, 0xf5, 0x37, 0xf5, 0x1f, 0x64, 0xd9, 0x4d, 0x81, 0x76, 0x63, 0x34, 0xfa, 0x25, |
| 0x05, 0x2f, 0xe7, 0x4b, 0x49, 0xdc, 0x40, 0xbb, 0xb9, 0xbc, 0xe7, 0x1c, 0x5e, 0x5e, 0x1e, 0x8a, |
| 0x14, 0xec, 0x7b, 0x4c, 0x9e, 0xc6, 0xc3, 0xae, 0xcb, 0xc7, 0x07, 0x2e, 0x0f, 0xa4, 0xc3, 0x02, |
| 0x2a, 0x46, 0x07, 0xae, 0x27, 0x78, 0x1c, 0x46, 0x07, 0x63, 0x2a, 0x05, 0x73, 0xa3, 0x6e, 0x28, |
| 0xb8, 0xe4, 0xc4, 0x64, 0xbc, 0x9b, 0x83, 0xba, 0x09, 0xa8, 0x3b, 0xf9, 0x6c, 0xeb, 0x86, 0xc7, |
| 0x3d, 0x8e, 0xa0, 0x03, 0xf5, 0xa5, 0xf1, 0x9d, 0xdf, 0x16, 0xa0, 0x7a, 0xa4, 0x15, 0xc8, 0xd7, |
| 0x50, 0x3d, 0x8d, 0x3d, 0x2a, 0xfd, 0xa1, 0x59, 0x6a, 0x97, 0xf7, 0x1a, 0x77, 0x77, 0xbb, 0x57, |
| 0xa9, 0x75, 0xbf, 0xd3, 0xc0, 0x81, 0x74, 0xa4, 0x95, 0xb2, 0xc8, 0x3d, 0x30, 0x42, 0x36, 0x8a, |
| 0xcc, 0x85, 0x76, 0x69, 0xaf, 0x71, 0xb7, 0x73, 0x35, 0xbb, 0xcf, 0x46, 0x11, 0x52, 0x11, 0x4f, |
| 0x1e, 0x42, 0xd9, 0x0d, 0x63, 0xb3, 0x8c, 0xb4, 0x3b, 0x57, 0xd3, 0x0e, 0xfb, 0x27, 0x8a, 0xd5, |
| 0xab, 0x4e, 0x2f, 0x5b, 0xe5, 0xc3, 0xfe, 0x89, 0xa5, 0x68, 0xe4, 0x21, 0x54, 0xc6, 0x74, 0xcc, |
| 0xc5, 0x85, 0x69, 0xa0, 0xc0, 0xce, 0xd5, 0x02, 0x47, 0x88, 0xc3, 0x99, 0x13, 0x0e, 0xb9, 0x0f, |
| 0x8b, 0x43, 0xff, 0x8c, 0x71, 0x73, 0x11, 0xc9, 0xdb, 0x57, 0x93, 0x7b, 0xfe, 0xd9, 0x93, 0xa7, |
| 0xc8, 0xd5, 0x8c, 0xce, 0x19, 0x34, 0x0a, 0x6d, 0x20, 0x37, 0x60, 0x31, 0x8e, 0x1c, 0x8f, 0x9a, |
| 0xa5, 0x76, 0x69, 0xcf, 0xb0, 0x74, 0x40, 0x56, 0xa1, 0x3c, 0x76, 0x5e, 0x63, 0x4b, 0x0c, 0x4b, |
| 0x7d, 0x12, 0x13, 0xaa, 0x2f, 0x1c, 0xe6, 0xbb, 0x81, 0xc4, 0x15, 0x1b, 0x56, 0x1a, 0x92, 0x2d, |
| 0xa8, 0x85, 0x8e, 0x47, 0x23, 0xf6, 0x33, 0xc5, 0xb5, 0xd4, 0xad, 0x2c, 0xee, 0x3c, 0x80, 0x5a, |
| 0xda, 0x35, 0xa5, 0xe0, 0xc6, 0x42, 0xd0, 0x40, 0x26, 0x73, 0xa5, 0xa1, 0xaa, 0xc1, 0x67, 0x63, |
| 0x26, 0x93, 0xf9, 0x74, 0xd0, 0xf9, 0xb5, 0x04, 0xd5, 0xa4, 0x77, 0xe4, 0x8b, 0x62, 0x95, 0xff, |
| 0xba, 0x49, 0x87, 0xfd, 0x93, 0x13, 0x85, 0x4c, 0x57, 0xd2, 0x03, 0x90, 0xa7, 0x82, 0x4b, 0xe9, |
| 0xb3, 0xc0, 0xfb, 0xf8, 0x1e, 0x1f, 0x6b, 0x2c, 0xb5, 0x0a, 0xac, 0xce, 0x2b, 0xa8, 0xa5, 0xb2, |
| 0xaa, 0x56, 0xc9, 0xa5, 0xe3, 0xa7, 0xfd, 0xc2, 0x80, 0x6c, 0x40, 0xe5, 0x8c, 0x8a, 0x80, 0xfa, |
| 0xc9, 0x12, 0x92, 0x88, 0x10, 0x30, 0xe2, 0x88, 0x8a, 0xa4, 0x65, 0xf8, 0x4d, 0xb6, 0xa1, 0x1a, |
| 0x52, 0x61, 0x2b, 0xef, 0x18, 0xed, 0xf2, 0x9e, 0xd1, 0x83, 0xe9, 0x65, 0xab, 0xd2, 0xa7, 0x42, |
| 0x79, 0xa3, 0x12, 0x52, 0x71, 0x18, 0xc6, 0x9d, 0xd7, 0x50, 0x4b, 0x4b, 0x51, 0x8d, 0x0b, 0xa9, |
| 0x60, 0x7c, 0x14, 0xa5, 0x8d, 0x4b, 0x42, 0xb2, 0x0f, 0x6b, 0x49, 0x99, 0x74, 0x64, 0xa7, 0x18, |
| 0x5d, 0xc1, 0x6a, 0x96, 0xe8, 0x27, 0xe0, 0x5d, 0x58, 0xc9, 0xc1, 0x92, 0x8d, 0x69, 0x52, 0xd5, |
| 0x72, 0x36, 0x7a, 0xcc, 0xc6, 0xb4, 0xf3, 0x57, 0x03, 0x20, 0x77, 0x9c, 0x5a, 0xaf, 0xeb, 0xb8, |
| 0xa7, 0x99, 0x3f, 0x30, 0x20, 0x9b, 0x50, 0x16, 0x51, 0x32, 0x95, 0x36, 0xb6, 0x35, 0x18, 0x58, |
| 0x6a, 0x8c, 0xfc, 0x0f, 0x6a, 0x22, 0x8a, 0x6c, 0x75, 0xba, 0xf4, 0x04, 0xbd, 0xc6, 0xf4, 0xb2, |
| 0x55, 0xb5, 0x06, 0x03, 0x65, 0x3b, 0xab, 0x2a, 0xa2, 0x48, 0x7d, 0x90, 0x16, 0x34, 0xc6, 0x4e, |
| 0x18, 0xd2, 0x91, 0xfd, 0x82, 0xf9, 0xda, 0x39, 0x86, 0x05, 0x7a, 0xe8, 0x31, 0xf3, 0xb1, 0xd3, |
| 0x23, 0x26, 0xe4, 0x05, 0x7a, 0xdc, 0xb0, 0x74, 0x40, 0x6e, 0x43, 0xfd, 0x5c, 0x30, 0x49, 0x87, |
| 0x8e, 0x7b, 0x66, 0x56, 0x30, 0x93, 0x0f, 0x10, 0x13, 0x6a, 0xa1, 0x67, 0x87, 0x9e, 0xcd, 0x02, |
| 0xb3, 0xaa, 0x77, 0x22, 0xf4, 0xfa, 0xde, 0x93, 0x80, 0x6c, 0x41, 0x5d, 0x67, 0x78, 0x2c, 0xcd, |
| 0x5a, 0xd2, 0x46, 0xaf, 0xef, 0x3d, 0x8d, 0x25, 0xd9, 0x44, 0xd6, 0x0b, 0x27, 0xf6, 0xa5, 0x59, |
| 0x4f, 0x53, 0x8f, 0x55, 0x48, 0xda, 0xb0, 0x14, 0x7a, 0xf6, 0xd8, 0x79, 0x99, 0xa4, 0x41, 0x97, |
| 0x19, 0x7a, 0x47, 0xce, 0x4b, 0x8d, 0xd8, 0x86, 0x65, 0x16, 0x38, 0xae, 0x64, 0x13, 0x6a, 0x3b, |
| 0x01, 0x0f, 0xcc, 0x06, 0x42, 0x96, 0xd2, 0xc1, 0x47, 0x01, 0x0f, 0xd4, 0x62, 0x8b, 0x90, 0x25, |
| 0xad, 0x52, 0x00, 0x14, 0x55, 0xb0, 0x1f, 0xcb, 0xb3, 0x2a, 0xd8, 0x91, 0x5c, 0x05, 0x21, 0x2b, |
| 0x45, 0x15, 0x04, 0xb4, 0xa1, 0x11, 0x07, 0x74, 0xc2, 0x5c, 0xe9, 0x0c, 0x7d, 0x6a, 0x5e, 0x47, |
| 0x40, 0x71, 0x88, 0x3c, 0x80, 0xcd, 0x53, 0x46, 0x85, 0x23, 0xdc, 0x53, 0xe6, 0x3a, 0xbe, 0xad, |
| 0x7f, 0x4f, 0x6c, 0x7d, 0xfc, 0x56, 0x11, 0x7f, 0xab, 0x08, 0xd0, 0x4e, 0xf8, 0x41, 0xa5, 0xc9, |
| 0x3d, 0x98, 0x49, 0xd9, 0xd1, 0xb9, 0x13, 0x26, 0xcc, 0x35, 0x64, 0xde, 0x2c, 0xa6, 0x07, 0xe7, |
| 0x4e, 0xa8, 0x79, 0x2d, 0x68, 0xe0, 0x29, 0xb1, 0xb5, 0x91, 0x88, 0x2e, 0x1b, 0x87, 0x0e, 0xd1, |
| 0x4d, 0x9f, 0x40, 0x5d, 0x03, 0x94, 0xa7, 0xd6, 0xd1, 0x33, 0x4b, 0xd3, 0xcb, 0x56, 0xed, 0x58, |
| 0x0d, 0x2a, 0x63, 0xd5, 0x30, 0x6d, 0x45, 0x11, 0xb9, 0x07, 0x2b, 0x19, 0x54, 0x7b, 0xec, 0x06, |
| 0xe2, 0x57, 0xa7, 0x97, 0xad, 0xa5, 0x14, 0x8f, 0x46, 0x5b, 0x4a, 0x39, 0xe8, 0xb6, 0x4f, 0x61, |
| 0x4d, 0xf3, 0x8a, 0x9e, 0xbb, 0x89, 0x95, 0x5c, 0xc7, 0xc4, 0x51, 0x6e, 0xbc, 0xac, 0x5e, 0x6d, |
| 0xbf, 0x8d, 0x42, 0xbd, 0xdf, 0xa0, 0x07, 0xff, 0x0f, 0x9a, 0x63, 0xe7, 0x4e, 0xbc, 0x85, 0x20, |
| 0x5d, 0xdb, 0xf3, 0xcc, 0x8e, 0xdb, 0x69, 0xb5, 0x99, 0x29, 0x4d, 0xbd, 0x25, 0x38, 0xda, 0xd7, |
| 0xce, 0xdc, 0x4d, 0xd5, 0x72, 0x7f, 0x6e, 0xea, 0xcd, 0xcf, 0x50, 0xca, 0xa4, 0x3b, 0x05, 0x2d, |
| 0xed, 0xc5, 0xad, 0x19, 0x94, 0x76, 0xe3, 0x3e, 0x90, 0x0c, 0x95, 0xbb, 0xf6, 0x3f, 0x85, 0x85, |
| 0xf6, 0x73, 0xeb, 0x76, 0x61, 0x5d, 0x83, 0x67, 0x0d, 0x7c, 0x1b, 0xd1, 0xba, 0x5f, 0x4f, 0x8a, |
| 0x2e, 0xce, 0x9a, 0x58, 0x44, 0xff, 0xb7, 0xa0, 0xfd, 0x28, 0xc7, 0xbe, 0xaf, 0x8d, 0x2d, 0x6f, |
| 0x7e, 0x40, 0x1b, 0x9b, 0xfe, 0xae, 0x36, 0xa2, 0x5b, 0xef, 0x69, 0x23, 0x76, 0x3f, 0xc5, 0x16, |
| 0xcd, 0xde, 0x4e, 0x7e, 0xf6, 0x54, 0xe2, 0xa4, 0xe0, 0xf8, 0x2f, 0xd3, 0xab, 0xe3, 0x0e, 0xfe, |
| 0xf6, 0xef, 0x7e, 0xec, 0x9e, 0xfd, 0x36, 0x90, 0xe2, 0x22, 0xbd, 0x3d, 0xee, 0x83, 0xa1, 0x5c, |
| 0x6e, 0x76, 0xe6, 0xe1, 0x22, 0x85, 0x7c, 0x95, 0x5d, 0x09, 0xdb, 0xf3, 0x90, 0xd3, 0x9b, 0x63, |
| 0x00, 0xa0, 0xbf, 0x6c, 0xe9, 0x86, 0xe6, 0xce, 0x1c, 0x12, 0xbd, 0xe5, 0xe9, 0x65, 0xab, 0xfe, |
| 0x3d, 0x92, 0x8f, 0x0f, 0xfb, 0x56, 0x5d, 0xeb, 0x1c, 0xbb, 0x61, 0x87, 0x42, 0xa3, 0x00, 0xcc, |
| 0xef, 0xdd, 0x52, 0xe1, 0xde, 0xcd, 0x5f, 0x04, 0x0b, 0x1f, 0x78, 0x11, 0x94, 0x3f, 0xf8, 0x22, |
| 0x30, 0x66, 0x5e, 0x04, 0x9d, 0x3f, 0x16, 0xa1, 0x9e, 0xbd, 0x3b, 0x88, 0x03, 0x5b, 0x8c, 0xdb, |
| 0x11, 0x15, 0x13, 0xe6, 0x52, 0x7b, 0x78, 0x21, 0x69, 0x64, 0x0b, 0xea, 0xc6, 0x22, 0x62, 0x13, |
| 0x9a, 0xbc, 0xd9, 0x76, 0x3e, 0xf2, 0x80, 0xd1, 0xbd, 0xb9, 0xc5, 0xf8, 0x40, 0xcb, 0xf4, 0x94, |
| 0x8a, 0x95, 0x8a, 0x90, 0x1f, 0xe1, 0x66, 0x3e, 0xc5, 0xa8, 0xa0, 0xbe, 0x30, 0x87, 0xfa, 0x7a, |
| 0xa6, 0x3e, 0xca, 0x95, 0x8f, 0x61, 0x9d, 0x71, 0xfb, 0x55, 0x4c, 0xe3, 0x19, 0xdd, 0xf2, 0x1c, |
| 0xba, 0x6b, 0x8c, 0x3f, 0x43, 0x7e, 0xae, 0x6a, 0xc3, 0x66, 0xa1, 0x25, 0xea, 0x2e, 0x2e, 0x68, |
| 0x1b, 0x73, 0x68, 0x6f, 0x64, 0x35, 0xab, 0xbb, 0x3b, 0x9f, 0xe0, 0x27, 0xd8, 0x60, 0xdc, 0x3e, |
| 0x77, 0x98, 0x7c, 0x57, 0x7d, 0x71, 0xbe, 0x8e, 0x3c, 0x77, 0x98, 0x9c, 0x95, 0xd6, 0x1d, 0x19, |
| 0x53, 0xe1, 0xcd, 0x74, 0xa4, 0x32, 0x5f, 0x47, 0x8e, 0x90, 0x9f, 0xab, 0xf6, 0x61, 0x8d, 0xf1, |
| 0x77, 0x6b, 0xad, 0xce, 0xa1, 0x79, 0x9d, 0xf1, 0xd9, 0x3a, 0x9f, 0xc1, 0x5a, 0x44, 0x5d, 0xc9, |
| 0x45, 0xd1, 0x6d, 0xb5, 0x39, 0x14, 0x57, 0x13, 0x7a, 0x26, 0xd9, 0x99, 0x00, 0xe4, 0x79, 0xb2, |
| 0x02, 0x0b, 0x3c, 0xc4, 0xa3, 0x53, 0xb7, 0x16, 0x78, 0xa8, 0xde, 0x80, 0x23, 0xf5, 0xb3, 0xa3, |
| 0x0f, 0x4e, 0xdd, 0x4a, 0x22, 0x75, 0x9e, 0xc6, 0xce, 0x4b, 0x9e, 0x3e, 0x02, 0x75, 0x80, 0xa3, |
| 0x2c, 0xe0, 0x22, 0x39, 0x3b, 0x3a, 0x50, 0xa3, 0x13, 0xc7, 0x8f, 0x69, 0xfa, 0xe6, 0xc1, 0xa0, |
| 0x67, 0xbe, 0x79, 0xdb, 0xbc, 0xf6, 0xe7, 0xdb, 0xe6, 0xb5, 0x5f, 0xa6, 0xcd, 0xd2, 0x9b, 0x69, |
| 0xb3, 0xf4, 0xfb, 0xb4, 0x59, 0xfa, 0x7b, 0xda, 0x2c, 0x0d, 0x2b, 0xf8, 0x7f, 0xe8, 0xf3, 0x7f, |
| 0x02, 0x00, 0x00, 0xff, 0xff, 0xb2, 0x21, 0x0b, 0xcd, 0x6e, 0x0d, 0x00, 0x00, |
| } |