Free allocator software for linux

nedmalloc an alternative malloc implementation written in C for multiple threads without lock contention based on dlmalloc v2.8.3.
It is more or less a newer implementation of ptmalloc2, the standard allocator in Linux (which is based on dlmalloc v2.7.0) but also contains a per-thread cache for maximum CPU scalability. It comes under the Boost software license which permits commercial usage.
It is more than 125 times faster than the standard Win32 memory allocator, 4-10 times faster than the standard FreeBSD memory allocator and up to twice as fast as ptmalloc2, the standard Linux memory allocator. It can sustain between 7.3m and 8.2m malloc & free pair operations per second on a 2200Mhz AMD Athlon64 machine.
It scales with extra CPUs far better than either the standard Win32 memory allocator or ptmalloc2 and can cause significantly less memory bloating than ptmalloc2. nedmalloc project avoids processor serialisation (locking) entirely when the requested memory size is in the thread cache.
Enhancements:
- This is an interim release from SVN as there have been many critical bugs fixed as nedmalloc was deployed on very high end architectures.
- Further speed ups and scalability improvements also made.
- However, this release is marked "alpha" since the usual thorough release testing has not been performed.

AdaControl is a free (GMGPL) tool that detects the use of various kinds of constructs in Ada programs. AdaControls first goal is to control proper usage of style or programming rules, but it can also be used as a powerful tool to search for use (or non-use) of various forms of programming styles or design patterns. Searched elements range from very simple, like the occurrence of certaine entities, declarations, or statements, to very sophisticated, like verifying that certain programming patterns are being obeyed..
Which elements or constructs are searched is defined by a set of rules; the following table gives a short summary of rules currently checked by AdaControl. The number in parentheses after the rule name gives the number of subrules, if any. Considering all possible rules and subrules, this makes 216 tests that can be performed currently by AdaControl!
- Abnormal_Function_Return Controls a design pattern that ensures that a function always returns a result .
- Allocators Controls ocurrences of allocators, either all of them, or those targeting specified types.
- Array_Declarations (x2) Controls several metrics in array declarations.
- Barrier_Expressions Controls elements allowed in the expression of protected entries barriers
- Case_Statement (x4) Controls several metrics in case statements.
- Control_Characters Controls occurrences of control characters (like tabs) in the source.
- Declarations (x75) Controls occurrences of certain Ada declarations.
- Default_Parameter Controls subprogram calls and generic instantiations that use (or not) the default value for a given parameter.
- Directly_Accessed_Globals Controls a design pattern that ensures that all global variables are accessed only through dedicated subprograms.
- Entities Controls occurrences of any Ada entity.
- Entity_Inside_Exception Controls occurrences of entities inside exception handlers.
- Exception_Propagation (x4) Controls that certain subprograms (or tasks) cannot propagate exceptions, or that no elaboration can propagate exceptions.
- Expressions (x9) Controls usage of certain forms of expressions
- Global_References Controls unsynchronized accesses to global variables.
- Header_Comments (x2) Controls the presence of comments at the start of each module.
- If_For_Case Controls if statements that could be replaced by case statements.
- Instantiations Controls generic instantiations, either all of them, or those that use specified entities.
- Insufficient_Parameters Controls the use of positional parameters in calls where the value does not provide sufficient information.
- Local_Hiding Controls occurrences of local identifiers that hide an identical outer one.
- Local_Instantiation Controls instantiations in local scopes.
- Max_Blank_Lines Controls the occurrence of more than a specified number of consecutive empty lines.
- Max_Call_Depth Controls the maximum depth of subprogram calls.
- Max_Line_Length Controls maximal length of source lines.
- Max_Nesting Controls scopes nested more deeply than a given limit.
- Max_Parameters (x6) Controls the maximum numbers of parameters in callable entities (procedures, functions and entries)
- Max_Statement_Nesting (x5) Controls composite statements nested more deeply than a given limit.
- Movable_Accept_Statements Controls statements that could be moved outside an accept statement.
- Naming_Convention Controls the form of allowed (or forbidden) names in declarations.
- No_Safe_Initialization Controls a design pattern that ensures that any variable is initialized before being used.
- Non_Static (x3) Controls non static expressions in index or discriminant constraints, or in instantiations.
- Not_Elaboration_Calls Controls subprogram calls performed from places outside package elaboration code.
- Other_Dependencies Controls semantic dependencies to other units than those indicated
- Parameter_Aliasing Controls subprograms and entry calls where a variable is provided to more than one [in] out parameter.
- Potentially_Blocking_Operations Controls the use of potentially blocking operations from within protected operations.
- Pragmas Controls the use of specific pragmas.
- Real_Operators Controls occurrences of = or /= operators on real types.
- Reduceable_Scope Controls declarations that could be move to more deeply nested scopes.
- Representation_Clauses Controls occurrences of representation clauses.
- Return_Type Controls the use of certain kinds of types as return types of functions.
- Side_Effect_Parameters Controls subprogram calls and generic instantiations that call functions with side effect, thus creating a dependance to the order of evaluation.
- Silent_Exceptions Controls exception handlers that do not reraise exceptions nor call indicated subprograms.
- Simplifiable_Expressions (x4) Controls occurrences of various forms of expressions that could be simplified.
- Special_Comments Controls the presence of certain string patterns in comments.
- Statements (x42) Controls occurrences of Ada statements.
- Style (x12) Controls various forms of constructs generally recommended in style rules.
- Terminating_Tasks Controls a design pattern that ensures that tasks never terminate.
- Uncheckable (x3) Controls constructs that are not statically checkable by other rules
- Unnecessary_Use_Clause Controls use clauses on packages, where no element of the package is referred to within the scope of the use clause.
- Unsafe_Paired_Calls Controls a design pattern that ensures that certain calls are allways paired (like P/V procedures).
- Unsafe_Unchecked_Conversion Controls instantiations of Unchecked_Conversion between types of different or unspecified sizes.
- Usage (x5) Controls usage of objects under certain conditions (in package specifications, read, written modified...).
- Use_Clauses Controls occurrences of use clauses, except for indicated packages.
- With_Clauses (x3) Controls proper usage of with clauses.
Enhancements:
- This release adds rules to check that header comments match a given pattern.
- It has indication of possible false positives and false negatives due to non-statically analyzable constructs.
- There is a fine definition of constructs allowed in entry barriers (including the one of the Ravenscar profile).
- There is better integration into GPS, and much more.

libkdtree++ is a C++ template container implementation of k-dimensional space sorting, using a kd-tree.
Usage:
A simple example program is provided in the ./examples directory
(/usr/share/doc/libkdtree++-dev/examples on Debian).
The library supports pkg-config. Thus, to compile with the library,
include < kdtree++/kdtree.hpp >
and append the output of `pkg-config libkdtree++ --cflags` to your $CPPFLAGS.
Each call to erase() and insert() unbalances the tree. It is possible that nodes will not be found while the tree is unbalanced.
You rebalance the tree by calling optimize(), and you should call it before you need to search the tree (this includes erase(value) calls, which search the tree).
It is ok to call insert(value) many times and optimize() at the end, but every erase() call should be followed with optimize().
Main features:
- sports an unlimited number of dimensions (in theory)
- can store any data structure, provided the data structure provides operator[0 - k-1] to access the individual dimensional components (arrays, std::vector already do) and a std::less implementation for the type of dimensional components
- has support for custom allocators
- implements iterators
- provides standard find as well as range queries
- has amortised O(lg n) time (O(n lg n) worst case) on most operations (insert/erase/find optimised) and worst-case O(n) space.
- provides a means to rebalance and thus optimise the tree.
- exists in its own namespace
- uses STL coding style, basing a lot of the code on stl_tree.h

Apache Portable Runtime (APR) project mission is to create and maintain software libraries that provide a predictable and consistent interface to underlying platform-specific implementations.
The primary goal is to provide an API to which software developers may code and be assured of predictable if not identical behaviour regardless of the platform on which their software is built, relieving them of the need to code special-case conditions to work around or take advantage of platform-specific deficiencies or features.
Main features:
- Atomic operations
- Dynamic Shared Object loading
- File I/O
- Locks (mutexes, condition variables, etc)
- Memory management (high performance allocators)
- Memory-mapped files
- Multicast Sockets
- Network I/O
- Shared memory
- Thread and Process management
- Various data structures (tables, hashes, priority queues, etc)
Enhancements:
- Various bugs were fixed.
- The API compatible with version 1.2.7.

The libmba package is a collection of mostly independent C modules potentially useful to any project. There are the usual ADTs including a linkedlist, hashmap, pool, stack, and varray, a flexible memory allocator, CSV parser, path canonicalization routine, I18N text abstraction, configuration file module, portable semaphores, condition variables and more.

The code is designed so that individual modules can be integrated into existing codebases rather than requiring the user to commit to the entire library. The code has no typedefs, few comments, and extensive man pages and HTML documentation.

lispreader is a small library for reading expressions in Lisp syntax. It has originally been written to facilitate simple exchange of structured data between processes but its main purpose is now to provide a framework for reading configuration files.
To simplify interpretation of the data read, lispreader also provides functions for simple matching of expressions against patterns.
lispreader is also used in at least one application to read and write data files. Lisp syntax is very suitable for doing this, especially if the data is organized hierachically.
Version restrictions:
lispreader is not a Lisp system in that it cannot, by itself, interpret Lisp expressions. It only provides a subset of the features of libraries like Guile of librep (namely the reading of expressions) and does thus not compete directly with those.
If all you need is a simple way to read Lisp expressions without interpreting them with Lisp semantics, you will probably be satisfied with lispreader.
Enhancements:
- #?(number) pattern
- lisp_free can handly arbitrarily nested lists without recursion.
- Memory allocation can now be controlled with the allocator interface.
- An allocator is included which is very fast and low-overhead, but only allows freeing all data at once.
- A new memory mapping Lisp stream type is implemented, which about doubles parsing speed.

deimos project consists of some platform independent libraries.

The deimos project provides some platform independent libraries which contain a reference memory allocator (garbage collector planned), virtual filesystem (Unix sockets, HTTP, etc), configfile management, and a clean build system (easy makefiles).

These libs are used by DDS (Digital Disco System - mp3 player), vmOberon (oberon virtual machine), and ODMS (open document management system).

deimos has some simpl programming principles:

- dont make the packages not too big. one package for each job.

- simplicity. clear interfaces. each package has an front- and an back-interface. better think twice before starting to program anything.

- high abstraction. i.e the core libs are the one and only stuff which has to care about system specifics.

currently these packages are available:

- core:

current implementations: linux + glibc (may work on other unices too, but not tested)

provides:
* simple and clear build system (have a look the makefiles)
* Memory Manager (reference counting, type checking, ...)
* Virtual Filesystem (currently supports: local unix, http)
* ConfigFile (manages config files, goes over the VFS)

- template

an very simple template for writing applications with the deimos make system.

- examples

some applications demonstrating how to use the deimos (mostly core).

- oberon

the oberon subsystem. provides an virtual machine an kernel modules