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.07