Optimize Linux Application Performance
Click here to download Linux OK (Linux Optimization Kit) Datasheet
Here are some of the features that Mapusoft’s Linux OK provides for optimizing Linux:
User applications in Linux OK have a higher reliability because applications are launched as a separate thread in user space. Applications can be broken into smaller modules (or processes). The resources within a process can be freely accessed by other processes, provided they are created with system scope. Real-time features are provided in the user space. Processes are identified by the operating system as programs that execute in memory or on the hard drive. They are assigned a process ID or a numerical identifier so that Cross-OS may keep track of the programs currently executing and of their associated priority levels. Such an approach ensures a higher reliability (predictability) than Linux is capable of providing on its own.
Recovery from fatal errors:
A fatal error or fatal exception error is an error that causes an application to abort and may therefore return the user to the operating system. Sometimes, fatal errors will crash the underlying operating systems while loosing the data that the application was processing. This behavior is not acceptable in real-time mission critical systems. Using Mapusoft’s Linux OK allows applications to recover from fatal software errors through a soft reset by rolling the stack back to the start of the application.
Linux OK provides several options for Linux users to achieve higher performance. Linux OK, in addition to providing an abstraction through the OS Abstractor framework, was built to provide additional performance for embedded applications. For Linux, this means you don’t need to keep and maintain multiple versions of your application in order to keep track of the changes in the POSIX API. Linux OK allows you to easily incorporate new APIs into your application, thereby eliminating the need for multiple copies of your application code.
The Linux OK Memory Allocation framework eliminates dynamic memory allocation by pre-allocating memory during the operating system initialization. It also ensures that the application will not use more memory than the allocated amount to prevent the system from running out of memory and impacting other applications. The Linux OK design minimizes the occurrences of task switching and user/kernel mode switching to improve your application’s run-time performance.
The Linux OK framework offers Tiered Memory Pools. When the user requests a segment of memory, a partition is pulled from the best matching pool, based on the block size that was requested.
Linux OK also offers Shared Memory Pools. Providing a memory pool in shared memory is a major issue, especially in operating systems that use virtual memory. The problem is that when the pool is mapped into another process, there is no guarantee that the memory addresses will match. This means that the linked list nodes can’t be used directly as with the local pools. Instead, the partitions will be accessed array style. When a partition is allocated, a combination of the array index, pool ID and the tier the partition came from will be returned as an ID.
Multiple optimization switches are available for increased performance. Optimization switches can eliminate the need to switch between kernel and user mode, adding mission critical features and limit memory allocation settings.
Optimization and Profiling
Linux OK also provides API optimization, which is a way to get additional performance by optimizing the most used functions in your application. Additional optimization can be achieved with a Profiling feature. Profiling the application can pinpoint areas within the application that are performing poorly and adjust them to improve system performance.
Linux OK allows users to use OS Abstractor Interface APIs within and across processes, combine applications written with different OS APIs and run on one or many operating systems (e.g. VxWorks and Linux). Linux OK also allows you to use native API’s in your applications. The library is designed to be fully portable with other commercial or proprietary operating systems. It is independent of target hardware and development tools.
Clear Separation of Hardware/Software Layers:
With Linux OK, changes can be made to the low-level code without impacting the application. Unfortunately most software designs don’t provide this separation, which protects the original application code.
Easy to Learn Interface:
One of the most under-estimated tasks in a software project is the ramp-up time developers must go through to become productive on a new operating system. The cost of learning a new operating system is significant. Linux OK offers an easy-to-learn interface that can be re-used across projects, improving your team’s learning curve and increasing their productivity.
Related links :
White Paper : OS Changer: Protect your Software Investment
White Paper : OS Abstractor : Develop once to deploy on multiple platforms