To solve this problem, different solutions have been proposed. However, many sequential programs cannot be easily parallelized due to the presence of dependences. With the availability of chip multiprocessor (CMP) and simultaneous multithreading (SMT) machines, extracting thread level parallelism from a sequential program has become crucial for improving performance. Evaluation using real-world FSMs with diverse characteristics shows that BoostFSM can raise the average speedup from 3.1× and 15.4× of the existing speculative and enumerative parallelization schemes, respectively, to 25.8× on a 64-core machine. Finally, this work integrates different schemes of FSM parallelization into a framework-BoostFSM, which automatically selects the best based on the relevant properties of the FSM. This is a generalized speculation model that allows speculated states to be validated speculatively. Second, for speculative parallelization, this work introduces higher-order speculation to avoid the serial reprocessing during validations. In this way, path fusion can reduce multiple FSM execution paths into a single path, minimizing the overhead of path maintenance. Inspired by the classic NFA to DFA conversion, it maps a vector of states in the original FSM to a new (fused) state. First, for enumerative parallelization, it proposes path fusion. This work addresses the above scalability challenges with two novel techniques. Either way, the FSM parallelization scalability is seriously compromised. For those exhibiting unfavorable properties, the former suffers from the overhead of maintaining multiple execution paths, while the latter is bottlenecked by the serial reprocessing among the misspeculation cases. However, the efficiency of both parallelization schemes highly depends on the properties of the FSM and its inputs. Existing solutions leverage enumerative or speculative parallelization to break the dependences. However, FSM execution is known to be "embarrassingly sequential"due to the state dependences among transitions. On our dataset of 12 CGC and 8 real-world applications, our hybrid approach cuts down the warnings up to 21% over vanilla static analysis, while reporting 19 out of 20 bugs in total.įinite-state machine (FSM) is a fundamental computation model used by many applications. Finally, we show the usefulness of our approach by reducing the false positives emitted by a static vulnerability detector that consumes the improved points-to and taint information. We also tackle the challenge of combining static and dynamic analyses, which operate in two different analysis domains, in order to make the interleaving possible. In this paper, we present a novel technique called hybrid pruning, where we inject the information collected from a program’s dynamic trace, which is accurate by its very nature, into a static pointer or taint analysis system to enhance its precision. Scaling these analyses to real-world codebases written in memory-unsafe languages while retaining precision under the constraint of practical time and resource budgets is an open problem. Unfortunately, these techniques frequently sacrifice precision in favor of scalability by over-approximating program behaviors. Pointer and taint analyses are the building blocks for several other static analysis techniques. We discuss the possible uses of speculative optimization and demonstrate the effectiveness of our prototype system by examples of unsafe semantic optimization and a general system for fast memory-safety checking, which is able to reduce the checking time by factors between 2 and 7 for large sequential code on a 8-CPU system. Our system permits both explicit and implicit end markers for speculatively optimized code regions as well as extensions that allow the use of multiple tracks and user defined correctness checking. The programming interface closely affects the run-time support. The core of the run-time system is a novel concurrent algorithm that balances exploitable parallelism and available processors when the fast track is too slow or too fast. It lets a programmer or a profiling tool mark fast-track code regions and uses a run-time system to manage the parallel execution of the speculative process and its checking processes and ensures the correct display of program outputs. We present the interface design and system implementation for Fast Track. It speculatively runs optimized code to improve performance and then checks the correctness of the speculative code by running the original program on multiple processors. Fast track is a software speculation system that enables unsafe optimization of sequential code.
0 Comments
Leave a Reply. |
AuthorWrite something about yourself. No need to be fancy, just an overview. ArchivesCategories |