Free devel carnivore software for linux

Devel::Carnivore is a Perl module to spy on your hashes (and objects).

SYNOPSIS

use Devel::Carnivore;

sub new_attribute {
my %self : Watch("myName") = ();

bless %self, shift;
}

sub new_functional {
my $self = {};
watch $self, "myName";
bless $self
}

sub new_blessed {
my $self = {};
bless $self;
watch $self, "myName";
return $self;
}

sub new_scalar_attribute {
my $self : Watch("myName") = {};
bless $self
}

This module allows you to debug your hashes and, in particular, your objects based on hashes without using the perl debugger. There are several good reasons to do this. Among them:

1) Youre too stupid to use the perl debugger (This is true for me)

2) Youre building web applications and the perl debugger doesnt work very well in that environment

Obviously, this module does not provide you with a complete debugger. All it does is helping you keep track of the state changes which occur to your objects.

Output

By default all output is written to STDERR. You may change this behavior by assigning a valid output filehandle to $Devel::Carnivore::OUT.

Everytime the hash which is being watched by this module is assigned to, a message like this is created: > ProgLang: "cool" changed from "Java" to "Perl" at devel.pl line 30

So what does this tell you?

You have a Perl file named devel.pl. On line 30 your code changed the value of the key "cool" from "Java" to "Perl". In order, to identify this hash you optionally named it "ProgLang".

Devel::Monitor is a Perl module that can monitor your variables/objects for memory leaks.

You have memory leaks, and you want to remove it... You can use this tool to help you find which variables/objects that are not destroyed when they should be, and thereafter, you can visualise exactly where is the circular reference for some specific variables/objects.

WHAT IT CANT DO

Even if your modules are memory leak free, it doesnt mean that external modules that you are using dont have it. So, before running your application on mod_perl, you should be sure that EVERY modules are ok. (In particular those perl extensions calling C++ code)

SYNOPSIS

use Devel::Monitor qw(:all);

#-----------------------------------------------------------------------------
# Monitor scalars, arrays, hashes, references, constants
#-----------------------------------------------------------------------------
my ($a,$b) = (Foo::Bar->new(), Foo::Bar->new());
my ($c, @d, %e);
use constant F => [1,2];
monitor(name for a => $a,
name for b => $b,
name for c => $c,
name for d => @d,
name for e => %e,
name for F => &F); #NOTE : Dont add parentheses to the end of the constant (&F())

#-----------------------------------------------------------------------------
# Print circular references
#-----------------------------------------------------------------------------
# NOTE : You cannot use print_circular_ref on a monitored/tied variable
# (See "We cannot use tied objects references because it reuse memory space" doc)
print_circular_ref($a);
print_circular_ref($b);
print_circular_ref($c);
print_circular_ref(@d);
print_circular_ref(%e);
print_circular_ref(&F); #NOTE : Dont add parentheses to the end of the constant (&F())

USAGE : monitor

Example with a circular reference
+----------------------+
| Code |
+----------------------+
{
my @a;
monitor(a => @a);
$a[0] = @a; #Add a circular reference
print STDERR "Leaving scopen";
}
print STDERR "Scope leftn";

+----------------------+
| Output |
+----------------------+
MONITOR ARRAY a
Leaving scope
Scope left
DESTROY ARRAY a

+----------------------+
| Meaning |
+----------------------+
The line "DESTROY ARRAY a" should be between scope prints.
@a were deleted on program exit.

Example without a circular reference

+----------------------+
| Code |
+----------------------+
{
my @a;
monitor(a => @a);
print STDERR "Leaving scopen";
}
print STDERR "Scope leftn";

+----------------------+
| Output |
+----------------------+
MONITOR ARRAY a
Leaving scope
DESTROY ARRAY a
Scope left

+----------------------+
| Meaning |
+----------------------+
Everything is ok

Now that you know there is a circular reference, you can track it down using the print_circular_ref method

Devel::Profile is a Perl module to tell me why my perl program runs so slowly.

SYNOPSIS

perl -d:Profile program.pl
less prof.out

The Devel::Profile package is a Perl code profiler. This will collect information on the execution time of a Perl script and of the subs in that script. This information can be used to determine which subroutines are using the most time and which subroutines are being called most often.
To profile a Perl script, run the perl interpreter with the -d debugging switch. The profiler uses the debugging hooks. So to profile script test.pl the following command should be used:

perl -d:Profile test.pl

When the script terminates (or periodicly while running, see ENVIRONMENT) the profiler will dump the profile information to a file called prof.out. This file is human-readable, no additional tool is required to read it.

Note: Statistics are kept per sub, not per line.

Devel::Backtrace is a Perl module for object-oriented backtrace.

SYNOPSIS

my $backtrace = Devel::Backtrace->new;

print $backtrace; # use automatic stringification

print $backtrace->point(0)->line;

METHODS

Devel::Backtrace->new([$start])

Constructs a new Devel::Backtrace which is filled with all the information caller($i) provides, where $i starts from $start. If no argument is given, $start defaults to 0.

If $start is 1 (or higher), the backtrace wont contain the information that (and where) Devel::Backtrace::new() was called.

$backtrace->point($i)

Returns the ith tracepoint as a Devel::Backtrace::Point object (see its documentation for how to access every bit of information).

Note that the following code snippet will print the information of caller($start+$i):

print Devel::Backtrace->new($start)->point($i)

$backtrace->points()

Returns a list of all tracepoints.

$backtrace->skipme([$package])

This method deletes all leading tracepoints that contain information about calls within $package. Afterwards the $backtrace will look as though it had been created with a higher value of $start.

If the optional parameter $package is not given, it defaults to the calling package.

The effect is similar to what the Carp module does.

This module ships with an example "skipme.pl" that demonstrates how to use this method.

$backtrace->to_string()

Returns a string that contains one line for each tracepoint. It will contain the information from Devel::Backtrace::Points to_string() method. To get more information, use the to_long_string() method.

Note that you dont have to call to_string() if you print a Devel::Backtrace object or otherwise treat it as a string, as the stringification operator is overloaded.

$backtrace->to_long_string()

Returns a very long string that contains several lines for each trace point. The result will contain every available bit of information. See "to_long_string" in Devel::Backtrace::Point for an example of what the result looks like.

Devel::RingBuffer is a Perl module with shared memory ring buffers for Perl scripts diagnosis/debug.

SYNOPSIS

#
# create ringbuffer
#
use Devel::RingBuffer;
use Devel::RingBuffer::TieInt;

my $ringbuf = Devel::RingBuffer->new(
File => somefile.trace,
Rings => 20,
Slots => 20,
SlotSize => 300,
MessageSize => 256,
GlobalSize => 24 * 1024,
StopOnCreate => 0,
TraceOnCreate => 1) || die "Cant create a ring buffer.";

my $ring = $ringbuf->allocate();

Provides shared memory structures (using memory mapped files via IPC::Mmap) to be used by diagnostic and debugger applications for Perl scripts (see Devel::STrace). Using XS/C code to maximize performance, creates a set of ringbuffers with a configurable number of slots.

Each slot includes a field for a linenumber, a timestamp, and a fully qualified subroutine name. Each ring buffer also includes additional headers and fields to support diagnostic interfaces, e.g., watched expressions, command/reponse interfaces to the monitored applications, etc.

Devel::TrackObjects is a Perl module to track use of objects.

SYNOPSIS

cmdline

perl -MDevel::TrackObjects=/^IO::/ server.pl

inside

use Devel::TrackObjects qr/^IO::/;
use Devel::TrackObjects -verbose;
use IO::Socket;
...
my $sock = IO::Socket::INET->new...
...

Devel::TrackObjects->show_tracked;

Devel::TrackObjects redefines bless and thus tracks the creation of objectsi by putting weak references to the object into a list. It can be specified which classes to track.

At the end of the program it will print out infos about the still existing objects (probably leaking). The same info can be print out during the run using show_tracked.

IMPORTANT

The Module must be loaded as early as possible, because it cannot redefine bless in already loaded modules. See import how to load it so that it redefines bless.

METHODS

The following class methods are defined.

import ( COND|OPTIONS )

Called from use.

COND is a list of conditions. A condition is either a regex used as a match for a classname, a string used to match the class with exactly this name or a reference to a subroutine, which gets called to decide if the class should get tracked (must return TRUE).

Special is if the condition is /regex/. In this case it will be compiled as a regex. This is used, because on the perl cmdline one cannot enter compiled regex.
If the item is a string starting with "-" it will be interpreted as an option. Valid options are:

-verbose

Output from show_tracked will be more verbose, e.g it will use show_tracked_detailed instead of show_tracked_compact.

-noend

Dont show remaining tracked objects at END.

-debug

Will switch an internal debugging.

If conditions are given it will redefine CORE::GLOBAL::bless unless it was already redefined by this module.

That means you do not pay a performance penalty if you just include the module, only if conditions are given it will redefine bless.

show_tracked ( [ PREFIX ] )

If -verbose was set in import it will call show_tracked_detailed, otherwise show_tracked_compact.

This method will be called at END unless -noend was specified in import.

show_tracked_compact ( [ PREFIX ] )

Will create a hash containing all tracked classes and the current object count for the class.

If the caller wants to get something in return it will return a reference to this hash, otherwise it will print out the information in a single line to STDERR starting with "LEAK$PREFIX".

show_tracked_detailed ( [ PREFIX ] )

If the caller wants something in return it will give it a reference to an array containing array-refs with [ REF,FILE,LINE ], where REF is the weak reference to the object, FILE and LINE the file name and line number, where the object was blessed.

If the calling context is void it will print these information to STDERR. The first line will start with "LEAK$PREFIX", the next ones with "--" and the last one again with "LEAK$PREFIX".

Devel::Pointer is a Perl module that can fiddle around with pointers.

SYNOPSIS

use Devel::Pointer;
$a = address_of($b); # a = &b;
$b = deref($a); # b = *a;

$a = unsmash_sv(0+$scalar_ref);
@a = unsmash_av(0+$array_ref);
%a = unsmash_hv(0+$hash_ref);
&a = unsmash_cv(0+$code_ref);
# OK, you cant do that, but you get the idea

$c = deref(-1); # *(-1), and the resulting segfault.

The primary purpose of this is to turn a smashed reference address back into a value. Once a reference is treated as a numeric value, you cant dereference it normally; although with this module, you can.

Be careful, though, to avoid dereferencing things that dont want to be dereferenced.

Devel::Command::NewF is a Perl module with the extended f command for the debugger.

SYNOPSIS

# In .perldb (or perldb.ini on Windows)
use Devel::Command;

# Devel::Command::NewF loaded automatically

perl -de0
Patching with Devel::Command::DBSub::DB_5_8_5

Loading DB routines from perl5db.pl version 1.27
Editor support available.

Enter h or `h h for help, or `man perldebug for more help.

main::(-e:1): 0
DB< 1 > fx Test::More
Loaded Test::More
auto(-1) DB< 2 > f /home/y/lib/perl5/5.8/i386-freebsd-thread-multi/Test/More.pm
1 package Test::More;
2
3: use 5.004;
4
5: use strict;
6
7
8 # Cant use Carp because it might cause use_ok() to accidentally succeed 9 # even though the module being used forgot to use Carp. Yes, this
10 # actually happened.
DB< 3 >

This module extends the debuggers f command so that you can simply enter the standard module name to switch the debugger to it:

DB< 1 > fx My::Module

This would look for My::Module in %INC; if it was not found, we would attempt to use the module. If this also fails, we give up, with an error message.