[llvm-commits] [www-pubs] r98803 - /www-pubs/trunk/2010-03-ASPLOS-SpeculativeParallelization.html

[Owen Anderson]

Author: resistor
Date: Thu Mar 18 01:09:51 2010
New Revision: 98803

URL: http://llvm.org/viewvc/llvm-project?rev=98803&view=rev
Log:
Copy and paste fail. :-(

Modified:
    www-pubs/trunk/2010-03-ASPLOS-SpeculativeParallelization.html

Modified: www-pubs/trunk/2010-03-ASPLOS-SpeculativeParallelization.html
URL: http://llvm.org/viewvc/llvm-project/www-pubs/trunk/2010-03-ASPLOS-SpeculativeParallelization.html?rev=98803&r1=98802&r2=98803&view=diff
==============================================================================
--- www-pubs/trunk/2010-03-ASPLOS-SpeculativeParallelization.html (original)
+++ www-pubs/trunk/2010-03-ASPLOS-SpeculativeParallelization.html Thu Mar 18 01:09:51 2010
@@ -16,9 +16,7 @@
 
 <h2>Abstract:</h2>
 <blockquote>
-<p>The behavior of a multithreaded program does not depend only on its inputs. Scheduling, memory reordering, timing, and low-level hardware effects all introduce nondeterminism in the execution of multithreaded programs. This severely complicates many tasks, including debugging, testing, and automatic replication. In this work, we avoid these complications by eliminating their root cause: we develop a compiler and runtime system that runs arbitrary multithreaded C/C++ POSIX Threads programs deterministically.</p>
-
-<p>A trivial non-performant approach to providing determinism is simply deterministically serializing execution. Instead, we present a compiler and runtime infrastructure that ensures determinism but resorts to serialization rarely, for handling interthread communication and synchronization. We develop two basic approaches, both of which are largely dynamic with performance improved by some static compiler optimizations. First, an ownership-based approach detects interthread communication via an evolving table that tracks ownership of memory regions by threads. Second, a buffering approach uses versioned memory and employs a deterministic commit protocol to make changes visible to other threads. While buffering has larger single-threaded overhead than ownership, it tends to scale better (serializing less often). A hybrid system sometimes performs and scales better than either approach individually.</p>
+<p>With the right techniques, multicore architectures may be able to continue the exponential performance trend that elevated the performance of applications of all types for decades. While many scientific programs can be parallelized without speculative techniques, speculative parallelism appears to be the key to continuing this trend for general-purpose applications. Recently-proposed code parallelization techniques, such as those by Bridges et al. and by Thies et al., demonstrate scalable performance on multiple cores by using speculation to divide code into atomic units (transactions) that span multiple threads in order to expose data parallelism. Unfortunately, most software and hardware Thread-Level Speculation (TLS) memory systems and transactional memories are not sufficient because they only support single-threaded atomic units. Multi-threaded Transactions (MTXs) address this problem, but they require expensive hardware support as currently proposed in the literatur
 e. This paper proposes a Software MTX (SMTX) system that captures the applicability and performance of hardware MTX, but on existing multicore machines. The SMTX system yields a harmonic mean speedup of 13.36x on native hardware with four 6-core processors (24 cores in total) running speculatively parallelized applications.</p>
 </blockquote>
 
 <h2>Published:</h2>