cpuutil

Documentation

Overview

Package cpuutil handles Flatbuffer based processing of CPU (kernel) utilization information. This information is calculated using the difference between two CPU (kernel) stats snapshots, /proc/stat, and represented as a percentage. The time elapsed between the two snapshots is stored in the TimeDelta field. Instead of returning a Go struct, it returns the data as Flatbuffer serialized bytes. For convenience, a function to deserialize the Flatbuffer serialized bytes into a cpuutil.CPUUtil struct is provided.

Note: the package name is cpuutil and not the final element of the import path (flat).

Index

• func Deserialize(p []byte) *util.CPUUtil
• func Get() (p []byte, err error)
• func NewTicker(d time.Duration) (joe.Tocker, error)
• func Serialize(u *util.CPUUtil) (p []byte, err error)
• type Profiler
  • func NewProfiler() (prof *Profiler, err error)
  • func (prof *Profiler) Get() (p []byte, err error)
  • func (prof *Profiler) Serialize(u *util.CPUUtil) []byte
• type Ticker
  • func (t *Ticker) Close()
  • func (t *Ticker) Run()

Functions

func Deserialize

func Deserialize(p []byte) *util.CPUUtil

Deserialize takes some Flatbuffer serialized bytes and deserializes them as cpuutil.CPUUtil.

func Get

func Get() (p []byte, err error)

Get returns the current cpu utilization as Flatbuffer serialized bytes using the package's global Profiler. The Profiler is instantiated lazily. If the profiler doesn't already exist, the first usage information will not be useful due to minimal time elapsing between the initial and second snapshots used for usage calculations; the results of the first call should be discarded.

func NewTicker

func NewTicker(d time.Duration) (joe.Tocker, error)

NewTicker returns a new Ticker containing a Data channel that delivers the data at intervals and an error channel that delivers any errors encountered. Stop the ticker to signal the ticker to stop running. Stopping the ticker does not close the Data channel; call Close to close both the ticker and the data channel.

func Serialize

func Serialize(u *util.CPUUtil) (p []byte, err error)

Serialize the CPU Utilization using the package global Profiler.

Types

type Profiler

type Profiler struct {
	*util.Profiler
	*fb.Builder
}

Profiler is used to process the /proc/stats file and calculate utilization information, returning the data as Flatbuffer serialized bytes.

func NewProfiler

func NewProfiler() (prof *Profiler, err error)

Initializes and returns a cpu utilization profiler that uses FlatBuffers.

func (*Profiler) Get

func (prof *Profiler) Get() (p []byte, err error)

Get returns the cpu utilization as Flatbuffer serialized bytes. Utilization calculations requires two snapshots. This func gets the current snapshot of /proc/stat and calculates the utilization using the difference between the current snapshot and the prior one. The current snapshot is stored and for use as the prior snapshot on the next Get call. If ongoing utilitzation information is desired, the Ticker should be used; it's better suited for ongoing utilization information.

func (*Profiler) Serialize

func (prof *Profiler) Serialize(u *util.CPUUtil) []byte

Serialize cpu utilization using Flatbuffers.

type Ticker

type Ticker struct {
	*joe.Ticker
	Data chan []byte
	*Profiler
}

Ticker delivers the system's CPU utilization information at intervals.

func (*Ticker) Close

func (t *Ticker) Close()

Close closes the ticker resources.

func (*Ticker) Run

func (t *Ticker) Run()

Run runs the ticker.