The Perl Toolchain Summit 2025 Needs You: You can help 🙏 Learn more

 / 
Memory-Process-0.06
River stage zero No dependents
/ Memory::Process

NAME


            

              
              
Memory::Process - Perl class to determine actual memory usage.

SYNOPSIS


            

              
              
use Memory::Process;
my $m = Memory::Process->new(%params);
$m->dump;
$m->record($message, $pid);
my @report = $m->report;
my $report = $m->report;
$m->reset;
$m->state;

METHODS

new


            

              
              
my $m = Memory::Process->new(%params);

Constructor.

Returns instance of object.

dump


            

              
              
$m->dump;

Print report to STDERR.

Returns return value of print().

record


            

              
              
$m->record($message, $pid);

Set record. If message not set, use ''.

Returns undef.

report


            

              
              
my @report = $m->report;
my $report = $m->report;

Get report.

In scalar context returns string with report. In array context returns array of report lines. First line is title.

reset


            

              
              
$m->reset;

Reset records.

Returns undef.

state


            

              
              
$m->state;

Get internal state.

Each state item consists from:


            

              
              
- timestamp (in seconds since epoch)
- message (from record())
- virtual memory size (in kB)
- resident set size (in kB)
- shared memory size (in kB)
- text size (in kB)
- data and stack size (in kB)

Returns reference to array with state items.

EXAMPLE1


            

              
              
use strict;
use warnings;
use Memory::Process;
# Object.
my $m = Memory::Process->new;
# Example process.
$m->record("Before my big method");
my $var = ('foo' x 100);
sleep 1;
$m->record("After my big method");
sleep 1;
$m->record("End");
# Print report.
print $m->report."\n";
# Output like:
#   time    vsz (  diff)    rss (  diff) shared (  diff)   code (  diff)   data (  diff)
#      1  19120 (     0)   2464 (     0)   1824 (     0)      8 (     0)   1056 (     0) After my big method
#      2  19120 (     0)   2464 (     0)   1824 (     0)      8 (     0)   1056 (     0) End

EXAMPLE2


            

              
              
use strict;
use warnings;
use Data::Printer;
use Memory::Process;
# Object.
my $m = Memory::Process->new;
# Example process.
$m->record("Before my big method");
my $var = ('foo' x 100);
sleep 1;
$m->record("After my big method");
sleep 1;
$m->record("End");
# Print report.
my $state_ar = $m->state;
# Dump out.
p $state_ar;
# Output like:
# \ [
#     [0] [
#         [0] 1445941214,
#         [1] "Before my big method",
#         [2] 33712,
#         [3] 7956,
#         [4] 3876,
#         [5] 8,
#         [6] 4564
#     ],
#     [1] [
#         [0] 1445941215,
#         [1] "After my big method",
#         [2] 33712,
#         [3] 7956,
#         [4] 3876,
#         [5] 8,
#         [6] 4564
#     ],
#     [2] [
#         [0] 1445941216,
#         [1] "End",
#         [2] 33712,
#         [3] 7956,
#         [4] 3876,
#         [5] 8,
#         [6] 4564
#     ]
# ]

DEPENDENCIES

Memory::Usage, Readonly.

SEE ALSO

Memory::Stats

Memory Usage Consumption of your process

Memory::Usage

Tools to determine actual memory usage

REPOSITORY

https://github.com/michal-josef-spacek/Memory-Process

AUTHOR

Michal Josef Špaček mailto:skim@cpan.org

http://skim.cz/

LICENSE AND COPYRIGHT

© 2014-2023 Michal Josef Špaček

BSD 2-Clause License

VERSION

0.06