Skip to content

Commit f8a0dd5

Browse files
sambhav-jain-16sambhav-jain-16
committed
feat: add ability to get individual controller stats
Signed-off-by: Sambhav Jain <[email protected]>
1 parent e0c56cb commit f8a0dd5

File tree

5 files changed

+337
-0
lines changed

5 files changed

+337
-0
lines changed

‎cgroups.go‎

Lines changed: 21 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -44,6 +44,27 @@ type Manager interface {
4444
// GetStats returns cgroups statistics.
4545
GetStats() (*Stats, error)
4646

47+
// GetCpuStats returns cgroups cpu statistics
48+
GetCpuStats() (*Stats, error)
49+
50+
// GetMemoryStats returns cgroups memory statistics
51+
GetMemoryStats() (*Stats, error)
52+
53+
// GetPidsStats returns cgroups pids statistics
54+
GetPidsStats() (*Stats, error)
55+
56+
// GetIoStats returns cgroups io statistics
57+
GetIoStats() (*Stats, error)
58+
59+
// GetHugetlbStats returns cgroups hugetlb statistics
60+
GetHugetlbStats() (*Stats, error)
61+
62+
// GetRdmaStats returns cgroups rdma statistics
63+
GetRdmaStats() (*Stats, error)
64+
65+
// GetMiscStats returns cgroups misc statistics
66+
GetMiscStats() (*Stats, error)
67+
4768
// Freeze sets the freezer cgroup to the specified state.
4869
Freeze(state FreezerState) error
4970

‎fs/fs.go‎

Lines changed: 105 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -196,6 +196,111 @@ func (m *Manager) GetStats() (*cgroups.Stats, error) {
196196
return stats, nil
197197
}
198198

199+
func (m *Manager) GetCpuStats() (*cgroups.Stats, error) {
200+
m.mu.Lock()
201+
defer m.mu.Unlock()
202+
stats := cgroups.NewStats()
203+
204+
cpuGroup := &CpuGroup{}
205+
if path := m.paths["cpu"]; path != "" {
206+
if err := cpuGroup.GetStats(path, stats); err != nil {
207+
return nil, err
208+
}
209+
}
210+
211+
cpuacctGroup := &CpuacctGroup{}
212+
if path := m.paths["cpuacct"]; path != "" {
213+
if err := cpuacctGroup.GetStats(path, stats); err != nil {
214+
return nil, err
215+
}
216+
}
217+
218+
return stats, nil
219+
}
220+
221+
func (m *Manager) GetMemoryStats() (*cgroups.Stats, error) {
222+
m.mu.Lock()
223+
defer m.mu.Unlock()
224+
stats := cgroups.NewStats()
225+
226+
memoryGroup := &MemoryGroup{}
227+
if path := m.paths["memory"]; path != "" {
228+
if err := memoryGroup.GetStats(path, stats); err != nil {
229+
return nil, err
230+
}
231+
}
232+
233+
return stats, nil
234+
}
235+
236+
func (m *Manager) GetPidsStats() (*cgroups.Stats, error) {
237+
m.mu.Lock()
238+
defer m.mu.Unlock()
239+
stats := cgroups.NewStats()
240+
241+
pidsGroup := &PidsGroup{}
242+
if path := m.paths["pids"]; path != "" {
243+
if err := pidsGroup.GetStats(path, stats); err != nil {
244+
return nil, err
245+
}
246+
}
247+
248+
return stats, nil
249+
}
250+
251+
func (m *Manager) GetIoStats() (*cgroups.Stats, error) {
252+
m.mu.Lock()
253+
defer m.mu.Unlock()
254+
stats := cgroups.NewStats()
255+
256+
blkioGroup := &BlkioGroup{}
257+
if path := m.paths["blkio"]; path != "" {
258+
if err := blkioGroup.GetStats(path, stats); err != nil {
259+
return nil, err
260+
}
261+
}
262+
263+
return stats, nil
264+
}
265+
266+
func (m *Manager) GetHugetlbStats() (*cgroups.Stats, error) {
267+
m.mu.Lock()
268+
defer m.mu.Unlock()
269+
stats := cgroups.NewStats()
270+
271+
hugetlbGroup := &HugetlbGroup{}
272+
if path := m.paths["hugetlb"]; path != "" {
273+
if err := hugetlbGroup.GetStats(path, stats); err != nil {
274+
return nil, err
275+
}
276+
}
277+
278+
return stats, nil
279+
}
280+
281+
func (m *Manager) GetRdmaStats() (*cgroups.Stats, error) {
282+
m.mu.Lock()
283+
defer m.mu.Unlock()
284+
stats := cgroups.NewStats()
285+
286+
rdmaGroup := &RdmaGroup{}
287+
if path := m.paths["rdma"]; path != "" {
288+
if err := rdmaGroup.GetStats(path, stats); err != nil {
289+
return nil, err
290+
}
291+
}
292+
293+
return stats, nil
294+
}
295+
296+
func (m *Manager) GetMiscStats() (*cgroups.Stats, error) {
297+
m.mu.Lock()
298+
defer m.mu.Unlock()
299+
stats := cgroups.NewStats()
300+
301+
return stats, nil
302+
}
303+
199304
func (m *Manager) Set(r *cgroups.Resources) error {
200305
if r == nil {
201306
return nil

‎fs2/fs2.go‎

Lines changed: 78 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -155,6 +155,84 @@ func (m *Manager) GetStats() (*cgroups.Stats, error) {
155155
return st, nil
156156
}
157157

158+
func (m *Manager) GetCpuStats() (*cgroups.Stats, error) {
159+
st := cgroups.NewStats()
160+
161+
if err := statCpu(m.dirPath, st); err != nil && !os.IsNotExist(err) {
162+
return st, err
163+
}
164+
165+
var err error
166+
if st.CpuStats.PSI, err = statPSI(m.dirPath, "cpu.pressure"); err != nil {
167+
return st, err
168+
}
169+
170+
return st, nil
171+
}
172+
173+
func (m *Manager) GetMemoryStats() (*cgroups.Stats, error) {
174+
st := cgroups.NewStats()
175+
176+
if err := statMemory(m.dirPath, st); err != nil && !os.IsNotExist(err) {
177+
return st, err
178+
}
179+
180+
var err error
181+
if st.MemoryStats.PSI, err = statPSI(m.dirPath, "memory.pressure"); err != nil {
182+
return st, err
183+
}
184+
185+
return st, nil
186+
}
187+
188+
func (m *Manager) GetPidsStats() (*cgroups.Stats, error) {
189+
st := cgroups.NewStats()
190+
err := statPids(m.dirPath, st)
191+
return st, err
192+
}
193+
194+
func (m *Manager) GetIoStats() (*cgroups.Stats, error) {
195+
st := cgroups.NewStats()
196+
197+
if err := statIo(m.dirPath, st); err != nil && !os.IsNotExist(err) {
198+
return st, err
199+
}
200+
201+
var err error
202+
if st.BlkioStats.PSI, err = statPSI(m.dirPath, "io.pressure"); err != nil {
203+
return st, err
204+
}
205+
206+
return st, nil
207+
}
208+
209+
func (m *Manager) GetHugetlbStats() (*cgroups.Stats, error) {
210+
st := cgroups.NewStats()
211+
err := statHugeTlb(m.dirPath, st)
212+
if err != nil && !os.IsNotExist(err) {
213+
return st, err
214+
}
215+
return st, nil
216+
}
217+
218+
func (m *Manager) GetRdmaStats() (*cgroups.Stats, error) {
219+
st := cgroups.NewStats()
220+
err := fscommon.RdmaGetStats(m.dirPath, st)
221+
if err != nil && !os.IsNotExist(err) {
222+
return st, err
223+
}
224+
return st, nil
225+
}
226+
227+
func (m *Manager) GetMiscStats() (*cgroups.Stats, error) {
228+
st := cgroups.NewStats()
229+
err := statMisc(m.dirPath, st)
230+
if err != nil && !os.IsNotExist(err) {
231+
return st, err
232+
}
233+
return st, nil
234+
}
235+
158236
func (m *Manager) Freeze(state cgroups.FreezerState) error {
159237
if m.config.Resources == nil {
160238
return errors.New("cannot toggle freezer: cgroups not configured for container")

‎systemd/v1.go‎

Lines changed: 105 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -355,6 +355,111 @@ func (m *LegacyManager) GetStats() (*cgroups.Stats, error) {
355355
return stats, nil
356356
}
357357

358+
func (m *LegacyManager) GetCpuStats() (*cgroups.Stats, error) {
359+
m.mu.Lock()
360+
defer m.mu.Unlock()
361+
stats := cgroups.NewStats()
362+
363+
cpuGroup := &fs.CpuGroup{}
364+
if path := m.paths["cpu"]; path != "" {
365+
if err := cpuGroup.GetStats(path, stats); err != nil {
366+
return nil, err
367+
}
368+
}
369+
370+
cpuacctGroup := &fs.CpuacctGroup{}
371+
if path := m.paths["cpuacct"]; path != "" {
372+
if err := cpuacctGroup.GetStats(path, stats); err != nil {
373+
return nil, err
374+
}
375+
}
376+
377+
return stats, nil
378+
}
379+
380+
func (m *LegacyManager) GetMemoryStats() (*cgroups.Stats, error) {
381+
m.mu.Lock()
382+
defer m.mu.Unlock()
383+
stats := cgroups.NewStats()
384+
385+
memoryGroup := &fs.MemoryGroup{}
386+
if path := m.paths["memory"]; path != "" {
387+
if err := memoryGroup.GetStats(path, stats); err != nil {
388+
return nil, err
389+
}
390+
}
391+
392+
return stats, nil
393+
}
394+
395+
func (m *LegacyManager) GetPidsStats() (*cgroups.Stats, error) {
396+
m.mu.Lock()
397+
defer m.mu.Unlock()
398+
stats := cgroups.NewStats()
399+
400+
pidsGroup := &fs.PidsGroup{}
401+
if path := m.paths["pids"]; path != "" {
402+
if err := pidsGroup.GetStats(path, stats); err != nil {
403+
return nil, err
404+
}
405+
}
406+
407+
return stats, nil
408+
}
409+
410+
func (m *LegacyManager) GetIoStats() (*cgroups.Stats, error) {
411+
m.mu.Lock()
412+
defer m.mu.Unlock()
413+
stats := cgroups.NewStats()
414+
415+
blkioGroup := &fs.BlkioGroup{}
416+
if path := m.paths["blkio"]; path != "" {
417+
if err := blkioGroup.GetStats(path, stats); err != nil {
418+
return nil, err
419+
}
420+
}
421+
422+
return stats, nil
423+
}
424+
425+
func (m *LegacyManager) GetHugetlbStats() (*cgroups.Stats, error) {
426+
m.mu.Lock()
427+
defer m.mu.Unlock()
428+
stats := cgroups.NewStats()
429+
430+
hugetlbGroup := &fs.HugetlbGroup{}
431+
if path := m.paths["hugetlb"]; path != "" {
432+
if err := hugetlbGroup.GetStats(path, stats); err != nil {
433+
return nil, err
434+
}
435+
}
436+
437+
return stats, nil
438+
}
439+
440+
func (m *LegacyManager) GetRdmaStats() (*cgroups.Stats, error) {
441+
m.mu.Lock()
442+
defer m.mu.Unlock()
443+
stats := cgroups.NewStats()
444+
445+
rdmaGroup := &fs.RdmaGroup{}
446+
if path := m.paths["rdma"]; path != "" {
447+
if err := rdmaGroup.GetStats(path, stats); err != nil {
448+
return nil, err
449+
}
450+
}
451+
452+
return stats, nil
453+
}
454+
455+
func (m *LegacyManager) GetMiscStats() (*cgroups.Stats, error) {
456+
m.mu.Lock()
457+
defer m.mu.Unlock()
458+
stats := cgroups.NewStats()
459+
460+
return stats, nil
461+
}
462+
358463
func (m *LegacyManager) Set(r *cgroups.Resources) error {
359464
if r == nil {
360465
return nil

‎systemd/v2.go‎

Lines changed: 28 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -497,6 +497,34 @@ func (m *UnifiedManager) GetStats() (*cgroups.Stats, error) {
497497
return m.fsMgr.GetStats()
498498
}
499499

500+
func (m *UnifiedManager) GetCpuStats() (*cgroups.Stats, error) {
501+
return m.fsMgr.GetCpuStats()
502+
}
503+
504+
func (m *UnifiedManager) GetMemoryStats() (*cgroups.Stats, error) {
505+
return m.fsMgr.GetMemoryStats()
506+
}
507+
508+
func (m *UnifiedManager) GetPidsStats() (*cgroups.Stats, error) {
509+
return m.fsMgr.GetPidsStats()
510+
}
511+
512+
func (m *UnifiedManager) GetIoStats() (*cgroups.Stats, error) {
513+
return m.fsMgr.GetIoStats()
514+
}
515+
516+
func (m *UnifiedManager) GetHugetlbStats() (*cgroups.Stats, error) {
517+
return m.fsMgr.GetHugetlbStats()
518+
}
519+
520+
func (m *UnifiedManager) GetRdmaStats() (*cgroups.Stats, error) {
521+
return m.fsMgr.GetRdmaStats()
522+
}
523+
524+
func (m *UnifiedManager) GetMiscStats() (*cgroups.Stats, error) {
525+
return m.fsMgr.GetMiscStats()
526+
}
527+
500528
func (m *UnifiedManager) Set(r *cgroups.Resources) error {
501529
if r == nil {
502530
return nil

0 commit comments

Comments
 (0)