Ports Search

DMUCS is a system that allows a group of users to share a compilation farm. Each compilation request from each user will be sent to the fastest available machine, every time. The system has these fine qualities: * Supports multiple users compiling simultaneously, and scales well to handle the new loads. * Supports multiple operating systems in the compilation farm. * Uses all processors of a multi-processor compilation host. * Makes best use of compilation hosts with widely differing CPU speeds. * Guarantees that a compilation host will not be overloaded by compilations. * Takes into account the load on a host caused by non-compilation tasks. * Supports the dynamic addition and removal of hosts to the compilation farm. * Works with distcc, which need not be altered in any way.

The KoreLogic Expression Language Library is a C library that provides a simple expression language that can be embedded in other programs. This library does not implement a full programming language, but rather a simpler expression language called KL-EL that is designed to provide arithmetic and logic operations useful in situations where embedding a full programming language would be overkill. KL-EL expressions have access to a full set of arithmetic and logic operations, and they can access functions and variables exported from the embedding program. Unlike most other languages of its kind, KL-EL is statically and strongly typed, which helps ensure that expressions are valid before they are executed. The embedding API is designed to be easy to use, and the library itself is designed to be very small.

lockfree-malloc is a scalable drop-in replacement for malloc/free. * It's thread-friendly. It supports a practically-unlimited number of concurrent threads, without locking or performance degradation. * It's efficient, especially in a multi-threaded environment. Compared to a stock libc allocator, we see a significant performance boost. * It does NOT fragment or leak memory, unlike a stock libc allocator. * It wastes less memory. For small objects (less than 8kb in size), the overhead is around 0 bytes. (!) * It is designed from the ground-up for 64-bit architectures. * It is elegant. The whole codebase is only around 800 lines of fairly clean C++. (!) * It fully stand-alone; it does not rely on pthreads or libc at runtime.

The m17n library provides following facilities to handle multilingual text. * M-text: A data structure for a multilingual text. It is basically a string but with attributes called text property, and is designed to substitute for the C string. It is the most important object of the m17n library. * Functions for creating and processing M-texts. * Functions for converting M-texts from/to strings encoded in various existing formats. * A huge character space, which contains all the Unicode characters and more non-Unicode characters. * Chartable: A data structure that contains per-character information efficiently. * Functions for inputting and displaying M-text on a window system. The documentation is available through devel/m17n-docs.

ShowTable.pm, is a Perl 5 module which defines subroutines to print arrays of data in a nicely formatted listing, using one of four possible formats: simple table, boxed table, list style, and HTML-formatting (for World-Wide-Web output). See the documentation on ShowTable.pm for details on the formatting. The program "showtable" reads data in a variety of formats from a file or STDIN, optimally columnizes the data, and then feeds the array of data to the ShowTable module for display. Showtable can parse its own output as input (except for HTML). Individual or ranges of columns may be selected for display, either by name or by index. In other words, showtable is a data formatting program. Using the '-html' option, showtable can accept ASCII tabular data and format it appropriately for display through a Web-browser.

String eval is often used for dynamic code generation. For instance, Moose uses it heavily, to generate inlined versions of accessors and constructors, which speeds code up at runtime by a significant amount. String eval is not without its issues however - it's difficult to control the scope it's used in (which determines which variables are in scope inside the eval), and it can be quite slow, especially if doing a large number of evals. This module attempts to solve both of those problems. It provides an eval_closure function, which evals a string in a clean environment, other than a fixed list of specified variables. It also caches the result of the eval, so that doing repeated evals of the same source, even with a different environment, will be much faster (but note that the description is part of the string to be evaled, so it must also be the same (or non-existent) if caching is to work properly).

This class implements a simple state machine pattern, allowing you to quickly build rules-based state machines in Perl. As a simple implementation of a powerful concept, it differs slightly from an ideal DFA model in that it does not enforce a single possible switch from one state to another. Rather, it short circuits the evaluation of the rules for such switches, so that the first rule to return a true value will trigger its switch and no other switch rules will be checked. (But see the strict attribute and parameter to new().) It differs from an NFA model in that it offers no back-tracking. But in truth, you can use it to build a state machine that adheres to either model--hence the more generic FSA moniker.

Pit is a command-line project manager that integrates with Git. Basic Pit entities are projects, tasks, and notes. One project can have multiple tasks, and a task can have multiple notes. Each entity has a number of attributes. For example, project has name and status, task has name, status, priority, date, and time, and within note there is message body. All attributes except name and message body are optional and can be omitted. The attributes have no semantic meaning, and do not have a pre-defined set of values. For example, depending on the particular need, the time attribute could be used as projected time in weeks, hours spent on the task, or days left to finish the task. Pit tries to maintain a notion of "current" project, task, or note. When you create new project, it automatically becomes current. If you do not specify project number when creating a task, the new task will be associated with the current project.

This module is meant to be the definitive implementation of iterators, as popularized by Mark Jason Dominus's lectures and recent book (Higher Order Perl, Morgan Kauffman, 2005). An "iterator" is an object, represented as a code block that generates the "next value" of a sequence, and generally implemented as a closure. When you need a value to operate on, you pull it from the iterator. If it depends on other iterators, it pulls values from them when it needs to. Iterators can be chained together (see Iterator::Util for functions that help you do just that), queuing up work to be done but not actually doing it until a value is needed at the front end of the chain. At that time, one data value is pulled through the chain. Iterator.pm provides a class that simplifies creation and use of these iterator objects. Other Iterator:: modules (see "SEE ALSO") provide many general-purpose and special-purpose iterator functions.

There's a whole bunch of class builders out there. In fact, creating a class builder seems to be something of a rite of passage (this is my fifth, at least). Unfortunately, most of the time I want a class builder I'm in a hurry and sketching out lots of fairly simple data classes with fairly simple structure, mostly just read-only accessors, and that's about it. Often this is for code that won't end up on CPAN, so adding a small dependency doesn't matter much. I just want to be able to define these classes FAST. By which I mean LESS typing than writing them by hand, not more. And I don't need all those weird complex features that bloat out the code and take over the whole way I build modules. And so, I present yet another member of the Tiny family of modules, Object::Tiny.