As the popularity of GPU in embedded systems keeps increasing, there is a growing demand for performance models for rapid estimation and tuning. One major challenge of developing a GPU performance model is the balance between accuracy and speed. The analytical model and the architectural model, two prevailing performance models, both have their weaknesses. The analytical model is fast to execute and simple to implement but usually suffers from low simulation accuracy. On the other hand, the cycle-level architectural model can offer high accuracy, but often at the expense of the execution time.

The emerging hardware support for thread-level speculation opens new opportunities to parallelize sequential programs beyond the traditional limits. By speculating that many data dependences are unlikely during runtime, consecutive iterations of a sequential loop can be executed speculatively in parallel. Runtime parallelism is obtained when the speculation is correct. To take full advantage of this new execution model, a program needs to be programmed or compiled in such a way that it exhibits high degree of speculative thread-level parallelism. We propose a comprehensive cost-driven compilation framework to perform speculative parallelization. Based on a misspeculation cost model, the compiler aggressively transforms loops into optimal speculative parallel loops and selects only those loops whose speculative parallel execution is likely to improve program

Conservative parallel simulation protocols are such that each logical process (LP) in the simulation execute events only when it is certain that there will not be any time-order causality violation. In these conservative protocols, time-bound information for an LP is computed from the other LPs. We propose a variant form of conservative parallel simulation protocol in which the time-bound for an LP is computed from the existing events in the system. In a conservative protocol such as the Chandy-Misra-Bryant (CMB) protocol, it can be difficult for LP/sub i/ to guarantee different time-bounds to its next LPs. The time-bounds to some LPs may be more restrictive than necessary. If the time-bounds are provided by the entities (events) going through the system (as in our proposed algorithm), an event E at LP/sub i/ can independently supply different time-bounds only to those LPs which may receive events generated by E. We describe the algorithm, outline a proof of its correctness and discuss its possible strengths and weaknesses.