---
name: "Memory::Process"
section: "3pm"
platform: "linux"
package: "perl-memory-process"
version: "0.06-6"
release: "Arch Linux 2026-11-01"
platforms: ["linux"]
url: "https://new.carta.tech/Memory::Process"
---

# Memory::Process(3pm)

## 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