ElectricAccelerator — Software build acceleration
ElectricAccelerator® is a software build tool that breaks the "build bottleneck" by accurately executing parallel builds across scalable clusters of standard hardware to reduce build times by as much as 20x.
To do this, ElectricAccelerator leverages patented technology that identifies and monitors job dependencies so you get fast and accurate builds. It plugs seamlessly into existing build infrastructures, without modifying existing build scripts and tools to distribute the work of the build to a cluster of servers. ElectricAccelerator supports Make, Visual Studio and Ant build environments.
Read how ElectricAccelerator helped Intuit implement Continuous Integration.
Faster, more accurate builds:
- Reduce Development Costs Customers have reported savings of as much as $2 million per year by eliminating manual scripting, redeploying staff to more strategic tasks, and reducing broken builds
- Improve Software Quality Faster builds mean more frequent builds, allowing teams to discover and remedy errors earlier
- Speed Time to Market Teams have literally shaved days or weeks from development cycles with faster builds
- Boost Developer Productivity Developers spend less time waiting for builds to complete and even do full preflight builds and tests prior to checking in changes
Watch a Flash demo of ElectricAccelerator.
How does ElectricAccelerator accomplish this?
Speeds Your Builds and Improves Throughput
Instead of running a build sequentially on a single machine, ElectricAccelerator distributes pieces of the build to run in parallel on a cluster of servers. ElectricAccelerator's unmatched dependency management system allows vastly greater scalability than previous attempts at parallel builds, delivering improvements of up to 20x over a sequential build, with no changes to existing build scripts or tools. Fast, reliable builds are critical to agile development techniques such as Continuous Integration.
ElectricAccelerator's Cluster Manager provides visibility into build results, status, and resource utilization.
Click to view »
The ElectricInsight build optimization tool provides a graphic representation of an ElectricAccelerator build.
Click to view »Virtually Eliminates Broken Builds
Over the years, many do-it-yourself parallel build approaches have been tried. However, each suffers from the same fundamental flaw: as the level of parallelism is increased, they generate incorrect or broken builds. ElectricAccelerator's patented automatic conflict detection and correction technology determines exactly which files were used to build every object file, library or executable, such that when build steps are run out of order, it automatically re-runs them in the correct order. ElectricAccelerator produces a correct build, even when scaling to hundreds of nodes in the cluster.
ElectricAccelerator's eDepend feature captures complete dependency information automatically and efficiently, with no human intervention. As a result, ElectricAccelerator provides accurate and reliable incremental builds and eliminates the need for frequent full builds for small changes. With ElectricAccelerator, developers can now trust an incremental build to recompile correctly — every time.
Visualizes the Build Structure for Rapid Error Detection and Performance Tuning
ElectricInsight®, an add-on to the ElectricAccelerator build tool, provides unprecedented visibility into the "black box" of software builds. ElectricInsight mines the information produced by Electric Make to provide an easy-to-understand, graphical representation of the build structure for performance analysis.
For information on pricing and evaluating Electric Cloud build tools, please contact an Electric Cloud sales representative.
Features and Benefits
| Speed Your Builds and Improve Throughput | ||||
 |
|
|
||
| Supports GNU Make, Nmake, Visual Studio, Ant | |
|
|
Virtually no change to scripts or the way developers work |
| Automatic performance improvement and minimal maintenance | |
|
|
Electric Make® updates dependency information after every build, so that even as files evolve, performance is automatically maintained |
| Compiler- and SCM agnostic | |
|
|
Works with any compiler or configuration management system |
| Grid integrations | |
|
|
Integrated with Platform LSF grid engine to leverage the power of grid computing for software builds and eliminate the need for standalone build labs |
| Static analysis compatible | |
|
|
Works with the Klocwork Insight static analysis tool |
| Virtually Eliminate Broken Builds | ||||
| Dynamic dependency discovery and management | |
|
|
Patented technology delivers as much as 20x faster builds over home-grown or commercial build management tools |
| Accurate incremental builds | |
|
|
Captures complete dependency information with no human intervention for reliable incremental builds |
| Network performance optimization | |
|
|
On-the-fly compression and agent caching ensure that the LAN isn’t a bottleneck and ElectricAccelerator can even be used on ordinary developer desktops |
| Tools from the build machine mirrored dynamically to the cluster | |
|
|
Simplifies the administration load of supporting multiple tool configurations |
| Failover support | |
|
|
Ensures consistent performance should a node in the cluster fail |
| No down time for system administration | |
|
|
No need to take the entire cluster down for scheduled maintenance or upgrades |
Product Details
ElectricAccelerator Architecture
ElectricAccelerator takes advantage of the abundant parallelism available in software builds and capitalizes on multi-core servers and fast networks. It includes several patented features to exploit high levels of concurrency.
Electric Make
Electric Make® distributes build jobs in parallel to a cluster of nodes to automatically execute a build faster than with a sequential build. Electric Make is compatible with GNU Make, Microsoft NMAKE, Symbian's Make variant, Ant, and Visual Studio.
Cluster Manager
The Cluster Manager manages the repository of build information and allocates the nodes used by Electric Make; it has the ability to scale to several hundreds of agents running dozens of simultaneous builds without affecting build performance. It provides web-based access to reports, build status, build results and build configurations. A command-line interface to the Cluster Manager is also provided.
ElectricAccelerator is also integrated with the Platform LSF grid computing solution to harness the power of grid computing to accelerate software build tasks.
Electric File System
The Electric Agent and the Electric File System run on the nodes in the cluster. Together they manage the execution of the build jobs sent from Electric Make, with the Electric File System tracking every file access during build execution to provide perfect build dependency information.
Patented Technology
Automatic Conflict Detection and Correction
Other parallel build approaches all suffer the same fundamental flaw: as the level of parallelism is increased, they generate incorrect or broken builds. The central issue is that the dependency information is incomplete. With incomplete dependencies, it's possible that build steps can be executed in the wrong order.ElectricAccelerator solves this problem with its patented automatic conflict detection and correction technology. The tool determines the true dependencies at run-time by monitoring all of the files used during the build process. ElectricAccelerator knows exactly which files were used to build every object file, library or executable.
Determining Actual File Dependencies
The first step in achieving high levels of concurrency in ElectricAccelerator is provided by the Electric File System (EFS). EFS is a lightweight caching file system that runs on each of the nodes and provides perfect information about actual file dependencies. This information allows it to detect out-of-order execution of jobs. After a job has completed, Electric Make uses its file dependency information to determine whether or not the job ran too soon. If it ran too soon, then Electric Make ignores those results and automatically re-runs the job to produce the correct results.
Increasing and Maintaining Performance
In addition to dramatically speeding up builds the first time it is run, Electric Make has the ability to use information from its initial run to further increase the performance of subsequent runs of the same build. To improve performance on subsequent builds, Electric Make saves the missing dependency information, including cross-makefile dependencies between recursive Makes. Electric Make updates the missing dependency information after every build, so that even as files evolve, performance is automatically maintained. Other approaches to parallel builds require a large on-going investment in file maintenance; Electric Make virtually eliminates this task.
Hierarchical Builds
For Make-based builds, ElectricAccelerator has an unprecedented ability to correctly handle hierarchical builds. Almost all software projects contain multiple modules, each with its own Makefile. The Makefiles are structured hierarchically, with top-level Makefiles invoking lower-level Makefiles recursively, so that the entire project can be built at once starting with the topmost Makefile. Large projects routinely contain hundreds or even thousands of Makefiles.
ElectricAccelerator addresses hierarchy problems by coalescing all of the nested Makes into one large build handled by the original Electric Make invocation. When a recursive Electric Make is invoked on a node, information about the nested build is passed back to the original Electric Make. Electric Make's internal data structures are designed to accommodate multiple build environments, each characterized by a Makefile, working directory, command-line arguments, and environment variables. Coalescing the Makefiles allows out-of-order build conflicts to be detected between Makefiles. Other Make-based programs simply can't detect or correct out-of-order build steps that exist in different Makefiles. They will generate an incorrect or broken build.
Technical Specifications
Unlike other build tools, ElectricAccelerator® doesn't require any process changes or expensive integration projects to allow team members to take advantage of more efficient builds. To a user, Electric Make appears identical to other versions of Make. It produces results identical to GNU Make and Microsoft NMAKE (even the log files are identical) and works seamlessly with Symbian's Make variant, Ant, and Visual Studio. The use of a cluster for the builds is invisible to the ElectricAccelerator user, except that the builds run much faster.
Because Electric Make is a compatible replacement for existing build utilities, it works with:
And Electric Make generates identical log file output, and provides the same command-line options as GNU Make and Microsoft NMAKE, so it will work seamlessly with wrapper scripts (e.g. Perl scripts) that invoke Make and process Make output.
ElectricAccelerator is also integrated with the Platform LSF grid computing solution to leverage grid resources to run massively parallel builds.
