Free programming interface 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.

PATH is a very different programming language than what you are probably used to if youre an average programmer. If youve programmed in the language Brainf*ck, youll recognize the memory cell architecture. Also, Befunge programmers will recognize the two-dimensional way that PATH programs are laid out.

PATH programs are laid out on a two-dimensional grid. It follows a path of instructions on the program grid, turning 90 degrees when instructed to (hence the name). A character recognized by the interpreter is called an instruction symbol.

To show you what a PATH program actually looks like, heres a simple program that coincidentally spells out the word "PATH" in large ASCII art letters. (You may recognize it from the PATH program homepage, and its also included with the interpreter.) All it does is make the console beep. Ill explain it in detail later, once you know what all the instruction symbols do.

The interpreter starts at the first "$" symbol it finds and starts heading right. Every time it encounters a valid instruction symbol, it executes it. When it encounters certain special symbols, it may turn in another direction.

The interpreter keeps going until it reaches a "#" symbol. If it encounters a character that is not a valid instruction symbol, it ignores it and skips over it.

AJAX is all the rage these days, and for a good reason. With AJAX, you can create web applications with nearly the same functionality as your desktop programs. Super AJAX Programming Seed project is a tight script that illustrates a simple use of AJAX technology using PHP, HTML and JavaScript.
Main features:
- Super AJAX Programming Seed is easy to install. Just upload the files to your server and youre good to go.
- Super simple code makes it easy to start using AJAX in your own applications.
- Comes with a working exaple of AJAX so you can get started right away.
- Use Super AJAX Programming Seed as a starter for your own technology, or offer it as an example on your own web site of AJAX in action.

AFNIX is a multi-threaded functional programming language with dynamic symbol bindings that support the object oriented paradigm. AFNIX programming language features a state of the art runtime engine that supports both 32 and 64 bits platforms.
AFNIX is distributed with several clients and a rich set of libraries that are designed to be platform independent. For a short description, you can look at the contents or for a short introduction, you can look at the tutorial.
A flexible license has been designed for both individuals and corporations. Everybody is encouraged to use, distribute and/or modify the AFNIX engine for any purpose. You can register on our mailing list. We issue news once a month. Your email address is covered by our strict privacy policy.
AFNIX is a powerful engine associated with a rich set of libraries. The interpreter is written in C++. Its modular architecture makes the installation and maintenance an easy task.
AFNIX has a rich syntax which make the functional programming a pleasant activity. AFNIX is ready for use on various UNIX platforms. A rich documentation is also provided as a guide and reference material.
Enhancements:
- This is a minor release that fixes the build process with GCC 4.2.

OGDI is the Open Geographic Datastore Interface. OGDI is an application programming interface (API) that uses a standardized access methods to work in conjunction with GIS software packages (the application) and various geospatial data products.
OGDI uses a client/server architecture to facilitate the dissemination of geospatial data products over any TCP/IP network, and a driver-oriented approach to facilitate access to several geospatial data products/formats.
Enhancements:
- This release fixes some significant bugs in the VRF (VPF) driver.

General Graphics User Interface is an effort to produce a common graphical user interface for any command-line program.

It uses a wizard-like input front end to collect the information needed. It then calls the desired program automatically with all the necessary options.

The user is able to point&click on various options and select them in a convenient way. In order to create a new user-interface, a user doesnt need to know a programming language, since there is a graphical editor for new GGUI "scripts".

The Blue Programming Language project is a unique bytecode-compiled language that implements the most effective capabilities of many popular programming languages in a clear and concise syntax. Plugin modules are easy to develop and can add functions, types, and even programming paradigms to the language without interfering with the syntax.
Blue is still early in its early development stage so very little optimization has been done, and its functionality grows every day. The following introduction is by no means a comprehensive description of blues capabilities.
Main features:
- Free (GPLd)
- A cross-platform programming language
- A dynamic language with a simple and consistant syntax
- Bytecode compiled
- Garbage collected
- Incredibly easy to expand with native functionality
Installation:
- Download the source
- Extract the archive. "tar -xvzf blue1.0.tar.gz"
- cd into the extracted directory. "cd blue"
- Execute make. "make"
- su to root. "su root"
- Execute make install 1. "make install"
- Execute make test. "make test"
Replace "make install" command with "make install INSTALL_DIR="/different/dir" to install to an alternate location.
Enhancements:
- This update contains a compiler bugfix, many more tests, and a function call optimization.

The Squirrel programming language is a high level imperative/OO programming language, designed to be a powerful scripting tool that fits in the size, memory bandwidth, and real-time requirements of applications like games. Although Squirrel offers a wide range of features like:
- Open Source zlib/libpng licence
- dynamic typing
- delegation
- higher order functions
- generators
- cooperative threads(coroutines)
- tail recursion
- exception handling
- automatic memory management (CPU bursts free; mixed approach ref counting/GC)
- both compiler and virtual machine fit together in about 6k lines of C++ code.
- optional 16bits characters strings
Squirrel is inspired by languages like Python,Javascript and expecially Lua(The API is very similar and the table code is based on the Lua one).
squirrels syntax is similar to C/C++/Java etc... but the language has a very dynamic nature like python/Lua etc...
local array=[1,2,3,{a=10,b="string"}];
foreach (i,val in array)
{
::print("the type of val is"+typeof val);
}
Entity<<less