[Starlingx-discuss] [feedback] Ways to measure the memory footprint by STX

[Victor Rodriguez]

Hi team

One of the areas we care about in the performance subteam is the footprint.
Footprint could be very broad, from CPU/Memory//HD and more.

The one topic we are focused on right now is the memory footprint. The
basic definition of memory footprint is the amount of memory (RAM +
SWAP) software uses when running. However, it is not only referred to
the amount of process the text (code) section takes on the virtual
memory but also the memory for dynamic data. The program may also
reserve memory for additional functions that are called in when
needed.

I would like to start the thread about recommended ways the community
might be interested in reading the footprint.

Few ideas could be:

On master:

Centos 7.6 + k8 + OpenStack running  (as containers) + SW needed to make it run
Agains
STX w/ OpenStack up and running + STX flocks

On Client:
Centos 7.6 + K8 client side
Agains
STX + STX flocks

Get the delta of memory used with
$ free -h
( or any other most used command)

Another metric might be to measure the memory of the STX flock
services running. At this point, there is a nice point to consider.

Linux is equipped with virtual memory management and has ways to
provide metrics that show how much memory is being used by a process.
The Linux tools most commonly used are the VSZ (Virtual Memory Size)
and RSS (Resident Set Size).

The VSZ describes the entire virtual memory size of the process
regardless of whether or not pages are being loaded in physical
memory. This metric is not a realistic indicator to measure memory
consumption since it includes pages that are not actually consumed.
RSS is an indicator that shows the memory consumption when the process
is running by itself without sharing anything with other processes.
Since all current programs have shared libraries, RSS overestimates
the amount of memory consumed by the process.

Proportional set size (PSS), provides a better perspective of the
memory in use. The proportional set size of a process indicates the
pages a process has in memory, but each page is divided by the number
of processes sharing it. Imagine a process with 1000 pages all to
itself and 1000 pages shared with one other process. The PSS of the
process is 1500. PSS gives a more realistic indicator of memory
consumption compared to RSS and VSZ. It works especially well when
considering the memory consumption of an entire system and not each
process individually.

The proportional set size is given by the kernel on the
/proc/<PID>/smaps files as:

    Pss: <size> kB

Another point to track might be how much memory do we need due to
OpenStack. After the open stack runs, the amount of memory might
increase, Does anybody has an idea how much?

There is a great PR under development by Erich to use Prometheus
https://github.com/starlingx-staging/tools-contrib/pull/9
Prometheus is a great tool for daily track the memory consumed (and
other metrics). It will be nice to have it up and running, it will
help us a lot, however in my opinion we will need for the base target
in order to get the difference we add in terms in memory

Any feedback more than welcome

Thanks

Victor Rodriguez