User:Louietoo/sandbox

Parallocity
From Wikipedia, the free encyclopedia

Parallocity, Inc. is a prvately held independent software vendor based in Sunnyvale, California backed by venture capital firm Accel Partners. Parallocity's Zeus Virtual Machine (ZVM) Dynamic Analysis Framework enables the rapid development and deployment of error-free software by automating single-pass detection of hard-to-find defects while providing comprehensive analytics for C/C++ code. ZVM forms the core of Parallocity's two products, ZVM-U for User Space Applications and Kernel-MD for Kernel Loadable Modules (KLMs) and device drivers. Both ZVM-U and Kernel-MD:


 * Detect concurrency violations, including data races, dead locks, and stalls, as well as memory errors and memory leaks
 * Function on all major 32 & 64 bit processor architectures including x86, PowerPC, ARM, and MIPS
 * Scale from small to large code bases for both unit and regression testing
 * Provide intelligent, hierarchical, and cumulative code coverage reports with Differential View to see coverage statistics for the lines of code being added to, modified in, or deleted from an existing code base

Technology
Dynamic analysis tools can be categorized into two types according to the code being analyzed: binary or source code. While ZVM analyzes a program’s source code, the majority of dynamic tools analyze binary code. Binary analysis is useful when the program's source code is not available. However, binary tools cannot analyze the program's underlying constructs to make intelligent decisions about where to add instrumentation for optimal performance. As a result, instrumented programs become substantially larger and require significantly more system memory to function properly at runtime than the same programs without instrumentation. Moreover, the instrumented programs run twenty to one-hundred times slower, which can lead to thread schedule changes during program execution. As a result, most such tools cannot be used for the accurate detection of concurrency violations.

Parallocity's ZVM Framework analyzes the language constructs in program source code then intelligently adds instrumentation to key data structures to monitor memory accesses and lock synchronization, counters to generate code analytics, and functions to analyze the data it collects. This enables ZVM to track and analyze individual statements and variables to detect concurrency violations, memory errors, and memory leaks with deterministic precision – but without the memory bloat or performance impact related to binary tools.

Parallocity has leveraged extensive research in the fields of parallel processing, compiler technology, and the language constructs of C and C++ to develop high performance algorithms and heuristics that make ZVM thread schedule agnostic and timing independent. Once in place, ZVM becomes a high performance event processing system that monitors all accesses to global and heap data and related lock/synchronization constructs. ZVM then analyzes unsynchronized accesses to find correlations among individual threads to identify actual and potential dataraces, deadlocks, stalls, and other insidious concurrency defects.

This approach minimizes the impact of the instrumentation on program performance and memory footprint at runtime. Programs instrumented with ZVM-U and Kernel-MD typically run just two to five times slower than the same programs without instrumentation. In terms of ZVM’s impact on a program’s size, with all features enabled the binary image typically grows by a factor of three while required system memory typically increases by just twenty percent. By achieving this level of performance, Parallocity’s products can scale from unit testing by individual developers on select modules to full regression testing of programs with ten million lines of code or more.

In addition to detecting concurrency violations, ZVM detects invalid heap, stack, and global memory accesses and invalid reads and writes. Reports detailing these memory errors include the module name, file name, line number, thread, variable, object details, error description, and stack trace. This level of detail enables the developer to quickly find and fix the root cause of the error. Since a majority of critical security issues are caused by heap and stack-based overflows that hackers exploit to change program flow or execution, using ZVM to find and fix such errors is an important step toward mitigating product liability risk and lowering future support costs.

As with memory error back tracing, Parallocity’s point-of-leak information saves significant debugging time. When a block of memory leaks, that leak is associated with the point in the code where the memory was allocated. It is also associated with the point where the last reference to the allocated memory was lost. Therefore, ZVM provides back trace details relevant to both the point of allocation and the stack trace at the point of leak to enable rapid remediation.

For performance optimization, users can capture memory allocation snapshots during program execution. They can then analyze multiple time-sequenced snapshots to observe memory allocation patterns that reveal the amount of memory being used by any given module. By combining this information with detailed feedback on the code being executed, like the number of times specific functions are being exercised, developers gain important insight to guide their tuning efforts.

Because they perform source code analysis, ZVM-U and Kernel-MD are processor agnostic. As such they are the only dynamic analysis tools in the industry that operate on 32 and 64 bit, single and multicore CPUs based on the x86, PowerPC, ARM, and MIPS architectures.