C4.5: Programs for Machine Learning (書評)

Most high-performance software transactional memories (STM) use optimistic invisible reads. Consequently, a transaction might have an inconsistent view of the objects it accesses unless the consistency of the view is validated whenever the view changes. Although all STMs usually detect inconsistencies at commit time, a transaction might never reach this point because an inconsistent view can provoke arbitrary behavior in the application (e.g., enter an infinite loop). In this paper, we formally introduce a lazy snapshot algorithm that verifies at each object access that the view observed by a transaction is consistent. Validating previously accessed objects is not necessary for that, however, it can be used on-demand to prolong the view's validity. We demonstrate both formally and by measurements that the performance of our approach is quite competitive by comparing other STMs with an STM that uses our algorithm.

https://doc.rero.ch/record/18139/files/Riegel_Torvald_-_A_Lazy_Snapshot_Algorithm_with_Eager_Validation_20100430.pdf

A Lazy Snapshot Algorithm with Eager Validation

Invited Talk.- Erlang - Software for a Concurrent World.- Types.- Gradual Typing for Objects.- Generic Universe Types.- Declarative Object Identity Using Relation Types.- Runtime Implementation.- Object-Relative Addressing: Compressed Pointers in 64-Bit Java Virtual Machines.- Generational Real-Time Garbage Collection.- AS-GC: An Efficient Generational Garbage Collector for Java Application Servers.- Empirical Studies.- Exception Handling: A Field Study in Java and .NET.- On the Impact of Aspectual Decompositions on Design Stability: An Empirical Study.- Dahl-Nygaard Prize Invited Talk.- An Accidental Simula User.- Programs and Predicates.- Validity Invariants and Effects.- Non-null References by Default in Java: Alleviating the Nullity Annotation Burden.- Efficiently Generating Structurally Complex Inputs with Thousands of Objects.- Language Design.- Matching Objects with Patterns.- DirectFlow: A Domain-Specific Language for Information-Flow Systems.- A Relational Model of Object Collaborations and Its Use in Reasoning About Relationships.- Inheritance and Derivation.- JavaGI: Generalized Interfaces for Java.- Metaprogramming with Traits.- Morphing: Safely Shaping a Class in the Image of Others.- A Higher Abstraction Level Using First-Class Inheritance Relations.- Dahl-Nygaard Prize Invited Talk.- Assuring Object-Oriented Architecture.- Aspects.- MAO: Ownership and Effects for More Effective Reasoning About Aspects.- Joinpoint Inference from Behavioral Specification to Implementation.- A Machine Model for Aspect-Oriented Programming.- A Staged Static Program Analysis to Improve the Performance of Runtime Monitoring.- Language About Language.- Tracking Linear and Affine Resources with Java(X).- Attribute Grammar-Based Language Extensions for Java.- Metamodel Adaptation and Model Co-adaptation.

ECOOP 2007 - object-oriented programming : 21st European Conference, Berlin, Germany, July 30 - August 3, 2007 : proceedings

In this paper, we present the most extensive comparison of synchronization techniques. We evaluate 5 different synchronization techniques through a series of 31 data structure algorithms from the recent literature on 3 multicore platforms from Intel, Sun Microsystems and AMD. To this end, we developed in C/C++ and Java a new micro-benchmark suite, called Synchrobench, hence helping the community evaluate new data structures and synchronization techniques. The main conclusion of this evaluation is threefold: (i) although compare-and-swap helps achieving the best performance on multicores, doing so correctly is hard; (ii) optimistic locking offers varying performance results while transactional memory offers more consistent results; and (iii) copy-on-write and read-copy-update suffer more from contention than any other technique but could be combined with others to derive efficient algorithms.

More than you ever wanted to know about synchronization: synchrobench, measuring the impact of the synchronization on concurrent algorithms

We present a technique to make applications resilient to failures. This technique is intended to maintain a faulty application functional in the field while the developers work on permanent and radical fixes. We target field failures in applications built on reusable components. In particular, the technique exploits the intrinsic redundancy of those components by identifying workarounds consisting of alternative uses of the faulty components that avoid the failure. The technique is currently implemented for Java applications but makes little or no assumptions about the nature of the application, and works without interrupting the execution flow of the application and without restarting its components. We demonstrate and evaluate this technique on four mid-size applications and two popular libraries of reusable components affected by real and seeded faults. In these cases the technique is effective, maintaining the application fully functional with between 19% and 48% of the failure-causing faults, depending on the application. The experiments also show that the technique incurs an acceptable runtime overhead in all cases.

/pdf/automatic-recovery-from-runtime-failures-3juoeclayc.pdf

Automatic recovery from runtime failures

In this paper we investigate the issue of automatically identifying the "natural" degree of parallelism of an application using software transactional memory (STM), i.e., the workload-specific multiprogramming level that maximizes application's performance. We discuss the importance of adapting the concurrency level in two different scenarios, a shared-memory and a distributed STM infrastructure. We propose and evaluate two alternative self-tuning methodologies, explicitly tailored for the considered scenarios. In shared-memory STM, we show that lightweight, black-box approaches relying solely on on-line exploration can be extremely effective. For distributed STMs , we introduce a novel hybrid approach that combines model-driven performance forecasting techniques and on-line exploration in order to take the best of the two techniques, namely enhancing robustness despite model's inaccuracies, and maximizing convergence speed towards optimum solutions.

/pdf/identifying-the-optimal-level-of-parallelism-in-hfkzq7s5r5.pdf

Identifying the optimal level of parallelism in transactional memory applications

In this paper we investigate the issue of automatically identifying the "natural" degree of parallelism of an application using software transactional memory STM, i.e., the workload-specific multiprogramming level that maximizes application's performance. We discuss the importance of adapting the concurrency level to the workload in two different scenarios, a shared-memory and a distributed STM infrastructure. We propose and evaluate two alternative self-tuning methodologies, explicitly tailored for the considered scenarios. In shared-memory STM, we show that lightweight, black-box approaches relying solely on on-line exploration can be extremely effective. For distributed STMs, we introduce a novel hybrid approach that combines model-driven performance forecasting techniques and on-line exploration in order to take the best of the two techniques, namely enhancing robustness despite model's inaccuracies, and maximizing convergence speed towards optimum solutions.

/pdf/identifying-the-optimal-level-of-parallelism-in-5g8kj47igu.pdf

Identifying the Optimal Level of Parallelism in Transactional Memory Applications

Transactional memory (TM) systems receive as an input a stream of events also known as a workload , reschedule it with respect to several constraints, and output a consistent history. In multicore architectures, the transactional code executed by a processor is a stream of events whose interruption would waste processor cycles. In this paper, we formalize the notion of TM workload into classes of input patterns, whose acceptance helps understanding the performance of a given TM.

/pdf/toward-a-theory-of-input-acceptance-for-transactional-1k3yd3fpus.pdf

Toward a Theory of Input Acceptance for Transactional Memories

We present the Input Acceptance of Transactional Memory (TM). Despite the large interest for performance of TMs, no existing research work has investigated the impact of solving a conflict that does not need to be solved. Traditional solutions for a TM to be correct is to delay or abort a transaction as soon as it presents a risk to violate consistency. Both alternatives are costly and should be avoided if consistency is actually preserved. To address this problem, we introduce the input acceptance of a TM as its ability to commit transactions, we upper-bound the input acceptance of existing TMs and propose a new TM with higher input acceptance.

/pdf/on-the-input-acceptance-of-transactional-memory-88frz71bg4.pdf

On the input acceptance of transactional memory

In concurrent programs raising an exception in one thread does not prevent others from operating on an inconsistent shared state. Instead, exceptions should ideally be handled in coordination by all the threads that are affected by their cause.In this paper, we propose a Java language extension for coordinated exception handling where a named abox (atomic box) is used to demarcate a region of code that must execute atomically and in isolation. Upon an exception raised inside an abox, threads executing in dependent aboxes, roll back their changes, and execute their recovery handler in coordination. We provide a dedicated compiler framework, CXH, to evaluate experimentally our atomic box construct. Our evaluation indicates that, in addition to enabling recovery, an atomic box executes a reasonably small region of code twice as fast as when using a failbox, the existing coordination alternative that has no recovery support.

Derin Harmanci

Papers

Identifying the optimal level of parallelism in transactional memory applications

Identifying the Optimal Level of Parallelism in Transactional Memory Applications

Toward a Theory of Input Acceptance for Transactional Memories

On the input acceptance of transactional memory

Atomic boxes: coordinated exception handling with transactional memory