usb 2.0 application programming interfac 3.0

Application Programming Interface Monitor description
Monitors a running application for application programming interface (API) calls. This tool monitors an application that is running for all API calls that a process is making.

APIMon counts and times the API calls. It also has the option to monitor page faults that are caused by the monitored application and to report them by API call.

ApiMon monitors a running application for application programming interface (API) calls. ApiMon counts and times all API calls. It can also, optionally, monitor page faults caused by the monitored application and report them by API call.

You can use ApiMon as a performance monitor to help tune your application. The data can be used to determine where the hot spots are in your application, by examining the APIs with the largest times and/or counts.

You can also look at which APIs are used by the application, taking a special look at calls that cause ring transitions to kernel mode or client/server transitions. Ring (or kernel-mode) transitions occur when user-mode processes use APIs to switch their threads from user to kernel mode. Large numbers of these calls can be culprits for the cause of a slow application.

ApiMon can generate two types of reports: a report containing all API calls showing their counts and times, and a report showing a trace of all APIs as they occurred in time.

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.

Whats New in This Release:

· The API was extended to decouple abstraction layers from hardware support and to provide initial support for different types of performance counters.

Application Enhancer (APE) is a system used in our and third-party products that helps them to enhance and redefine various applications behavior running on your system.

What exactly is Application Enhancer? It is a combination of a Framework (a collection of commonly used code that can be re-used across different Application Enhancer modules) and a system daemon (faceless background application).

Application Enhancer performs its task by loading plugins (Application Enhancer modules, or APEs for short) containing executable code into the running applications.

Once loaded, the APE module performs the needed modifications (such as redefining the minimize window action, or customizing the standard Apple menu) on the launched application memory space, never touching any files on disk, utilizing set of functions defined in the Application Enhancer framework.

To help the APE modules to be loaded into newly launched applications, the Application Enhancer daemon (aped) is used.

Can Application Enhancer or its modules crash your system? Due to the nature of the method, Application Enhancer or its modules potentially can crash individual applications if there is a bug in the module or in the application being modified (sometimes APE modules expose "hidden" bugs in the applications).

If you suspect Application Enhancer or its modules cause crashes, you can always temporarily disable the Application Enhancer system.

There are a number of technologies incorporated into our products that attempt to make sure your applications are safe: Haxie CrashGuard makes sure the application is not modified if it has recently crashed;

APE Check makes sure no damaged APE modules are loaded; moreover, all of our products are going through a tedious beta testing process to make sure it runs as expected.

However, even if an individual application crashes, this cannot bring down the whole system due to the fact it has the protected memory and the Application Enhancer operates in user memory space, which means it cannot affect the system itself or processes belonging to other users (in this regard, Kernel Extensions (kext) are much more dangerous as they operate on the lowest possible level and have access to all memory and processes; because of that, Kernel Extensions can cause "kernel panics", while Application Enhancer cannot, as they dont have access to the kernel memory space).

Does Application Enhancer slow down the system? Due to the fact that more code has to be loaded at the application launch time, Application Enhancer can increase the application launch time (usually in the range of 40-60 ms per Application Enhancer module loaded on a modern Mac).

Once loaded, most Application Enhancer modules stay latent and will not hog your processor. We are constantly working on improving the situation, so please make sure you always run the latest versions of our products.

The technology behind Application Enhancer system has been in research and development for more than 2 years now, and many of our products are using it.

Here are some key features of "Application Enhancer":

· Provides capabilities to use Application Enhancer modules.
· Completely free of charge.


Whats New in This Release:

· .Fixed a bug with corrupt Application Enhancers directory causing Application Enhancers preference pane to fail to load.
· Did some optimizations for the Mac OS X 10.4.9 update.

Support: All Current DMX-8 Mixers under Windows XP w/USB 2.0.

It is highly recommended to always use the most recent driver version available.
Do not forget to check with our site as often as possible in order to stay updated on the latest drivers, software and games.

Try to set a system restore point before installing a device driver. This will help if you installed a wrong driver. Problems can arise when your hardware device is too old or not supported any longer.

The Horde Application Framework is written in PHP, and provides the common tools a Web application requires: classes for dealing with preferences, compression, browser detection, connection tracking, MIME, and more.

The Horde Framework does not provide any significant end user functionality and it provides a base for other applications and tools for developers. You will probably want to install some of the available Horde applications, such as IMP (a webmail client), or Kronolith (a calendar).

Whats New in This Release:

· This is a security release that fixes a cross site scripting vulnerability and improves protection against phishing attempts.

Goetz s Programming Kit description
A programming kit that works in JavaScript to allow you to easily write programs Goetzs Programming Kit application was designed to be a programming kit that works in JavaScript to allow you to easily write programs. Its easy enough for a child to use, and versatile enough for an adult.

You can display information on the screen or even print on the printer. I have made a collection of tools to allow you to effortlessly get information from a person at the computer, or display information to the person at the computer.

Without these tools, it would be a little difficult to do so. There is also a users guide to writing JavaScript commands. This will show how to use the tools, and go beyond the tools Ive included, to build bigger and better programs. JavaScript is a very easy programming language to learn. It has simplified lots of tasks of other languages.

Requirements:

· You will need to have JavaScript enabled for the programs to work
· Netscape or IE 4 or greater

Application As Service description
Application As Service - run applications as Windows services Application as Service is an advanced system tool which lets you run any application as Windows 2000/XP/2003 Service.

You can easily configure Application as Service using its intuitive GUI interface or command line configurator directly from your software.

Application as Service features very low CPU usage, custom environment variables, monitoring and detailed logging as well as many other features.

You can use

Application as Service software to: Launch any application as Windows 2000/XP/2003 service at system boot, before user logon; Automatically start applications before and after service; Run your application without the need of a user session; Run executable: 16 bit (Dos, Windows, OS/2), 32 bit, batch files, scripts (VBScript, JScript) as a service;

Achieve higher fault tolerance with your software reporting private errors to the event log and automatically restarting on errors; Auto restart application after application termination; Redirect STDIN and STDOUT to file for console application; Specify application priority;

Allow multiple processes to run within the same service; Standard input/output automatic redirection to files.

Here are some key features of "Application As Service":

· Easily run applications as services
· Run application before users login into their systems
· Run application before service startup and after service shutdown
· Auto restart application after application termination
· Redirect STDIN and STDOUT to file for console application
· Create service dependendencies
· Much more


Limitations:

· 14 days trial.

This guide provides with the software, documentation, examples and VB6 source code for the integration of hand-held USB and keyboard emulation barcode scanners.

Using these guidelines, hand held scanners may be easily integrated with existing or custom applications as input, automation and verification devices. Documentation is provided in the ReadMe.html file.