The Hoard memory allocator is a fast, scalable, and memory-efficient
memory allocator for shared-memory multiprocessors.
Multithreaded programs that perform dynamic memory allocation do not
scale because the heap is a bottleneck. When multiple threads
simultaneously allocate or deallocate memory from the heap, they will
be serialized while waiting for the heap lock. Programs making
intensive use of the heap actually slow down as the number of
processors increases. (Note: If you make a lot of use of the STL, you
may not know it, but you are making a lot of use of the heap.)
Hoard is a fast allocator that solves this problem. In addition, it
has very reasonable bounds on memory consumption.
Config::IniFiles provides a way to have readable configuration files
outside your Perl script. The configuration can be safely reloaded upon
receipt of a signal. Configurations can be imported (inherited,
stacked,...), sections can be grouped, and settings can be accessed from
a tied hash.
USAGE
Get a new Config::IniFiles object with the *new* method:
$cfg = Config::IniFiles->new( -file => "/path/configfile.ini" );
$cfg = new Config::IniFiles -file => "/path/configfile.ini";
Optional named parameters may be specified after the configuration file
name. See the *new* in the METHODS section, below.
INI files consist of a number of sections, each preceded with the
section name in square brackets. Parameters are specified in each section
as Name=Value. Any spaces around the equals sign will be ignored, and the
value extends to the end of the line.
A perl module that is designed to provide easy to use settings
files for your project. You subclass the basic Config::Setting
class in one of your own modules, and then provide an interface to
your code using it. When set up, you can then override the settings
on a per-host basis, or even using an environment variable.
By default a win.ini style of configuration is used, but this can
be overridden and an XML based configuration is also included. The
access mechanism can also be overridden, the setting don't have to
come from a file, but (maybe) from a web site. You'll have to write
your own there, though.
The module Data::Flow provides its services via objects. The objects
may be obtained by the usual
$request = new Data::Flow $recipes;
paradigm. The argument $recipes is a hash reference, which provides the
rules for request processing. The objects support two methods, set() and
get(). The first one is used to provide input data for processing, the
second one to obtain the output.
The unit of requested information is a field. The method set() takes a
pair field => value, the method get() takes one argument: the field.
Every object is created without any fields filled, but it knows how to
construct fields basing on other fields or some global into. This
knowledge is provided in the argument $recipe of the new() function.
This is a reference to a hash, keyed by fields. The values of this hash
are hash references themselves, which describe how to acquire the field
which is the corresponding key of the initial hash.
File::ShareDir::PAR provides the same functionality as File::ShareDir but tries
hard to be compatible with PAR packaged applications.
The problem is, that the concept of having a distribution or module specific
share directory becomes a little hazy when you're loading everything from
a single file. PAR uses an @INC hook to intercept any attempt to load a module.
File::ShareDir uses the directory structure that is typically found in the
directories that are listed in @INC for storing the shared data. In a PAR
enviroment, this is not necessarily possible.
WARNING:
This module contains highly experimental code. If you want to load
modules from .par files using PAR and then access their shared directory
using File::ShareDir, you probably have no choice but to use it.
Media::Type::Simple gives a simple functions for obtaining common file
extensions from media types, and from obtaining media types from file
extensions.
It is also relaxed with respect to having multiple media types associated with a
file extension, or multiple extensions associated with a media type, and it
includes media types for encodings such as gzip. It is defined this way in the
default data, but this does not meet your needs, then you can have it use a
system file (e.g. /etc/mime.types) or custom data.
By default, there is a functional interface, although you can also use an
object-oriented inteface. (Different objects will not share the same data.)
INTRODUCTION --- WHAT IS NOWEB, ANYWAY?
noweb is a literate-programming tool like FunnelWEB or nuweb, only
simpler. A noweb file contains program source code interleaved with
documentation. When noweb is invoked, it writes the program source
code to the output files mentioned in the noweb file, and it writes
a TeX file for typeset documentation.
noweb is designed to meet the needs of literate programmers while
remaining as simple as possible. Its primary advantages are
simplicity, extensibility, and language-independence. noweb works
``out of the box'' with any programming language, and supports TeX,
latex, and HTML (Mosaic) back ends. A back end to support full
hypertext or indexing takes about 250 lines; a simpler one can be
written in 40 lines of awk. The primary sacrifice relative to WEB
is that code is not prettyprinted.
If you're brand new to literate programming, check out the FAQ for
the USENET newsgroup comp.programming.literate. There are also some
resources available through the noweb home page:
If you've ever tried to use Test::NoWarnings to confirm there are no warnings
generated by your tests, combined with the convenience of done_testing to not
have to declare a test count, you'll have discovered that these two features do
not play well together, as the test count will be calculated before the warnings
test is run, resulting in a TAP error. (See examples/test_nowarnings.pl in this
distribution for a demonstration.)
This module is intended to be used as a drop-in replacement for
Test::NoWarnings: it also adds an extra test, but runs this test before
done_testing calculates the test count, rather than after. It does this by
hooking into done_testing as well as via an END block. You can declare a plan,
or not, and things will still Just Work.
Pinba is a statistics server for PHP using MySQL as a read-only
interface.
It accumulates and processes data sent over UDP by multiple PHP
processes and displays statistics in a nice human-readable form of
simple "reports", also providing a read-only interface to the raw
data to enable generation of more sophisticated reports.
With the Pinba extension, users can also measure particular parts
of the code using timers with arbitrary tags.
Pinba is not a debugging tool in the common sense, since you're not
supposed to do debugging on production servers, but its main goal
is to help developers to locate bottlenecks in realtime and direct
their attention to the code that really needs it.
Pinba is a statistics server for PHP using MySQL as a read-only
interface.
It accumulates and processes data sent over UDP by multiple PHP
processes and displays statistics in a nice human-readable form of
simple "reports", also providing a read-only interface to the raw
data to enable generation of more sophisticated reports.
With the Pinba extension, users can also measure particular parts
of the code using timers with arbitrary tags.
Pinba is not a debugging tool in the common sense, since you're not
supposed to do debugging on production servers, but its main goal
is to help developers to locate bottlenecks in realtime and direct
their attention to the code that really needs it.