Free conditional discharge software for linux

PAPI aims to provide the tool designer and application engineer with a consistent interface and methodology for use of the performance counter hardware found in most major microprocessors.
PAPI enables software engineers to see, in near real time, the relation between software performance and processor events.
The Performance API (PAPI) project specifies a standard application programming interface (API) for accessing hardware performance counters available on most modern microprocessors.
These counters exist as a small set of registers that count Events, occurrences of specific signals related to the processors function. Monitoring these events facilitates correlation between the structure of source/object code and the efficiency of the mapping of that code to the underlying architecture.
This correlation has a variety of uses in performance analysis including hand tuning, compiler optimization, debugging, benchmarking, monitoring and performance modeling. In addition, it is hoped that this information will prove useful in the development of new compilation technology as well as in steering architectural development towards alleviating commonly occurring bottlenecks in high performance computing.
PAPI provides two interfaces to the underlying counter hardware; a simple, high level interface for the acquisition of simple measurements and a fully programmable, low level interface directed towards users with more sophisticated needs.
The low level PAPI interface deals with hardware events in groups called EventSets. EventSets reflect how the counters are most frequently used, such as taking simultaneous measurements of different hardware events and relating them to one another.
For example, relating cycles to memory references or flops to level 1 cache misses can indicate poor locality and memory management. In addition, EventSets allow a highly efficient implementation which translates to more detailed and accurate measurements.
EventSets are fully programmable and have features such as guaranteed thread safety, writing of counter values, multiplexing and notification on threshold crossing, as well as processor specific features. The high level interface simply provides the ability to start, stop and read specific events, one at a time.
PAPI provides portability across different platforms. It uses the same routines with similar argument lists to control and access the counters for every architecture. As part of PAPI, we have predefined a set of events that we feel represents the lowest common denominator of every good counter implementation.
Our intent is that the same source code will count similar and possibly comparable events when run on different platforms. If the programmer chooses to use this set of standardized events, then the source code need not be changed and only a fresh compilation and link is necessary. However, should the developer wish to access machine specific events, the low level API provides access to all available events and counting modes.
If an event or feature does not exist on the current platform, PAPI returns an appropriate error code. This significantly reduces the porting effort of code using PAPI because the semantics of each call to PAPI remains the same, just the argument lists need updating. In addition to the standard set, each PAPI implementation supports all native events through the ability to directly accept platform specific counter numbers. Definitions for most, if not all of these, are included as conditional macros in the header file. In this way, PAPI avoids having inefficient code to translate all events for all platforms into a uniform representation and back again.
This translation is only done for the relatively few events defined in the standardized set. Some processors like those in the POWER series have counter groups. They enable access to specific groups of counters, instead of individual events. This presents a serious portability problem, thus PAPI abstracts hardware counters from their groups with a packed naming scheme. Each counter control value or event is made up of the counter group number and the number of the specific counter in that group.
PAPI can be divided into two layers of software. The upper layer consists of the API and machine independent support functions. The lower layer defines and exports a machine independent interface to machine dependent functions and data structures. These functions access the substrate, which may consist of the operating system, a kernel extension or assembly functions to directly access the processors registers.
PAPI tries to use the most efficient and flexible of the three, depending on what is available. Naturally, the functionality of the upper layers heavily depends on that provided by the substrate. In cases where the substrates do not provide highly desirable features, PAPI attempts to emulate them as described below.
PAPI makes sure the underlying operating system or library guards against overflow of counter values.
Each counter can potentially be incremented multiple times in a single clock cycle. This combined with increasing clock speeds and the small precision of some of the physical counters means that overflow is likely to occur.
One of the more advanced features of PAPI is to provide a portable implementation of asynchronous notification when counters exceed a user specified value.
This functionality provides the basis for PAPIs SVR4 compatible profiling calls, that generate an accurate histogram of performance interrupts based on hardware metrics, not on time. Such functionality provides the basis for all line level performance analysis software, from the antiquated days of AT&Ts prof to SGIs SpeedShop. Thus for any architecture with even the most rudimentary access to hardware performance counters, PAPI provides the foundation for a truly portable, source level, performance analysis tool based on real processor statistics.
Enhancements:
- The API was extended to decouple abstraction layers from hardware support and to provide initial support for different types of performance counters.

Graph::Flowchart is a Perl module that can generate easily flowcharts as Graph::Easy objects.

SYNOPSIS

use Graph::Flowchart;

my $flow = Graph::Flowchart->new();

print $flow->as_ascii();

This module lets you easily create flowcharts as Graph::Easy objects. This means you can output your flowchart as HTML, ASCII, Boxart (unicode drawing) or SVG.

Classes

The nodes constructed by the various add_* methods will set the subclass of the node according to the following list:

start

The start block.

end

The end block, created by finish().

block

Orindary code blocks, f.i. from $b = 9;.

if, for, while, until

Blocks for the various constructs for conditional and loop constructs.

sub

For sub routine declarations.

use

For use, no and require statements.

goto, break, return, next, last, continue

Blocks for the various constructs for jumps/returns.

true, false, goto, call, return, break, next, continue

Classes for edges of the true and false if-branches, and for goto, as well as sub routine calls.

Each class will get some default attributes, like if constructs having a diamond-shape.

You can override the graph appearance most easily by changing the (sub)-class attributes:

my $chart = Graph::Flowchart->new();

$chart->add_block($a = 9;);
$chart->add_if_then($a == 9;, $b = 1;);
$chart->finish();

my $graph = $chart->as_graph();

Now $graph is a Graph::Easy object and you can manipulate the class attributes like so:

$graph->set_attribute(node.if, fill, red);
$graph->set_attribute(edge.true, color, green);
print $graph->as_html_file();

This will color all conditional blocks red, and edges that represent the true branch green.

XINA provides a Web database and content management system.
For Web database functions such as membership databases, job posting databases, and client databases, as well as simple or complex content management functions, it has the functionality to be a complete Web site solution.
It is weighed heavily in the direction of creating strong relational database management facilities in an integrated package that also includes authentication and authorization, Web logging, messaging, content and information management, data analysis, and import/export facilities.
Main features:
- 1) Basic Web database
- a. table creation
- b. table deletion
- c. table editing (structure)
- d. table report design
- e. calendar output for dates
- f. simple, multi-table, and advanced search
- g. record entry, deletion and editing
- h. use pre-designed forms for data entry
- i. create multi-page form applications with conditional movement and confirmation pages
- j. entry form generation dynamically by database structure
- k. relational database: lookups for form generation, linked tables, detail tables
- l. two types of value lists for menus, radio buttons and checkboxes, dynamic (based on table records) or static (defined in configuration).
- 2) Authentication and authorization
- a. password protected back-end interface
- b. password protect whole site if wanted
- c. authenticated data access and editing (a link will bring up the users data automatically)
- d. Different user types (superuser,editor,user)
- e. access to specific applications (like table editing) determined by authorization
- f. Access to specific tables also controlled by authorization
- 3) Document management features
- a. fields for holding files
- b. upload files from input form
- c. search contents of linked files (even binary files such as .doc,.xls or .pdf)
- 4) Web content management features
- a. sections and subsections that can be added and deleted at will
- b. dynamic navigation bar on side and cookie crumbs
- c. news article format
- d. discussions off of articles
- e. articles can be discussable or not
- f. full page format - like a basic web page
- g. full index mode
- h. link web content articles to database records
- i. Wiki mode for pages is an option
- 5) Logging
- a. actions (login, entry,edit) can be logged
- 6) Messaging
- a. actions (login, entry,edit) can be linked to e-mail message to a specified recipient
- 7) Style features
- a. Template driven (create HTML templates that are called by all XINA programs)
- b. All web content and database output generated with configurable stylesheets
- 8) Interoperability features
- a. easy table data import and export (delimited format)

4tH is a Forth compiler with a little difference. Instead of the standard Forth engine it features a conventional compiler.
4tH is a very small compiler that can create bytecode, C-embeddable bytecode, standalone executables, but also works fine as a scripting language. It supports over 85% of the ANS Forth CORE wordset and features conditional compilation, pipes, files, assertions, forward declarations, recursion, include files, etc.
It comes with an RPN calculator, line editor, compiler, decompiler, C-source generators, and a virtual machine.
Enhancements:
- More CORE words and most of the DOUBLE wordset are supported.
- Output buffers can be flushed.
- An experimental multitasking environment was added.

FancyLauncher is basically a program launcher with many customizable features. The snapshot shows how it looks like with the default configuration. The rxvt button is focused and the associated tooltip is displayed.
The license is GPL. This is the new version of the former E-FancyLauncher, written for enlightenment as an epplet. For people migrating to FancyLauncher the utility EF2F is provided to translate the E-FancyLauncher configuration file to the FancyLauncher configuration file. If you use it, you should have a look at the default configuration and the plugins directory to see the new features.
The configuration directory is located in your home directory and is named .FancyLauncher. There you will find the configuration file config and you should copy the plugins with the command cp -r /usr/local/FancyLauncher/plugins ~/.FancyLauncher/.
The configuration file works by definitions.
- common defines common options that are inherited by all the buttons. These options can be redefined.
- button defines a button launcher.
- digital_clock defines a digital clock.
Enhancements:
- Suggestions: adding dir asked by dmitry kirsanov and appending files by Marc A. Tamsky,
- pretty printing of played time asked by Chris Bidmead, and printing of songs length asked by Draco Paladin.
- Added +file to add files or directories.
- Added -file to remove files or directories.
- Added color printing (use more or less -Rf to view HELP).
- Added an emacs transcriber from Chris Bidmead.
- Added print, a general printing function (deprecates all other printing commands).
- Fixed memory leaks.
- Renamed sample scripts with the .sh suffix.
- Added conditional print (eq,neq).
- Added uniq command to remove duplicates from the playlist.
- Added the sample script playlist2html.sh to demonstrate the print command.
- Added clear to clear the playlist.

TinyButStrong is a template class for PHP that allows you to generate HTML pages using a database like PostgreSQL, MySQL, SQLite in native, and any other databases.
It is possible to design templates using any visual HTML editor (like Dreamweaver or FrontPage).
It features simple block management, useful display formats, conditional displaying for blocks and locators, a cache system, and the ability to include other HTML pages and execute associated scripts.
Main features:
- an connect to any database type (in native: MySql, SQLite, PostgreSQL),
- easy date-time and numeric formats,
- blocks with alternated display,
- multi-columns display,
- conditional display,
- event functions,
- file inclusion and other scripts execution,
- cache system.
Enhancements:
- This is a major version.
- The source is optimized, it is smaller, and it merges faster.
- There are 5 bugs fixed and 7 new features.
- It includes Onload Var fields that can be automatically merged when the template is loaded.
- There are new formats for time without leading zeros.
- The parameter ope can support several operations.
- There are special Var fields to merge PHP constants and to display TBS detailed information.