The workshop discusses the Java Memory Model, the issues of visibilty and reordering, the use of volatile and atomic variable, the implementation of immutable types based on the memory model''s initialization safety garantee, and provides an introduction to the techniques of lock-free programming.
Description: The increasing availability of multicore processors requires that essentially all Java applications must be multi-threaded in order to take advantage of those applications'' cpu power. The transition from a single-core architecture to a multi- core or multi-cpu platform occasionally reveals bugs in the program: applications that worked properly and reliably in a single-core context suddenly and inexplicably exhibit errors in a multi-core context. Often this is due to the substantially more aggressive caching techniques used on the processor level in combination with misconceptions regarding the Java Memory Model on the programmer''s side. In order to avoid such misconeptions, the workshop discusses the Java Memory Model comprehensively and in depth. Java develeopers do not only need a proper understanding of the Java Memory Model. In addition, the elimination or at least reduction of sychronization is becoming increasingly important in a multi-core and multi-processor world. Using a multi-cpu platform users expect that an application should scale, that is, its performance should increase with the number of available cpus. This highly desirable effect does not occur automatically, but has to be built into the application. Sequential, i.e., non-parallel, parts of the program must be drastically reduced in order to utilize the multiple cpus effectively. There are several technique for reduction of sequential processing, among them the elimination of lock-based sychronization, but also the use of atomic operations and programming techniques such as lock-free programming. The workshop discusses the Java Memory Model, the issues of visibilty and reordering, the use of volatile and atomic variable, the implementation of immutable types based on the memory model''s initialization safety garantee, and provides an introduction to the techniques of lock-free programming. Since this is a workshop, participants will have opportunity to practice and apply the newly gained knowledge in hands- on labs. We will review code, spot bugs and fix them. In addition, we will use atomic variables to eleminate lock- based synchronisation. For the practice part, participants are asked to bring their notebooks.
Topics: Java memory model Visibility, atomicity, reordering Garantees for volatile Double-checked locking Initialisation safety of final fields Safe object sharing Atomic variables Lock-free programming
Audience: Java developers who develop multi-thread software and want to prepare their programs for use on multi-cpu platforms. Java developers with an interest in performance optimizations. Java developers with an interest in concurrent programming in general who want to brush up their knowledge.
Abstract: The tutorial gives an overview of language extensions, additions to the core Java libraries, and relevant changes in the JVM that were released with Java 7. Among the new features are automatic resource management (ARM), improved exception handling ("multi-catch"), closures (Project Lambda), concurrency updates (Fork- Join / Parallel Arrays), type annotations for defect prevention (JSR 308), a revised file API (NIO2), modularity support (Project Jigsaw), and a new garbage collector ("G1"). Some of the features have been controversally debated in the Java community for years. The tutorial will explain what the ado is about.
Note: Since Java 7 has not yet been released (release is scheduled for September 2010) and due to the fact that Oracle tends to operate behind closed doors it is still unknown what exactly will be part of Java 7. Accordingly the above abstract might be subject to change.
by Dietmar Kühl
C++Ox provides several new featues which help with the use and implementation of generic components. Although the flagship feature (concepts) was withdrawn other still remain and this presentation describes some of the new features applicable in the generic area. In particular it coverss lambda functions, the new function declaration syntax, automatically deduced types, variadic templates, and initializer lists.
Writing code applicable in more than a specific situation requires the use of some form of genericity, especially in statically typed languages. When the actual types are known only at run-time, the use of virtual functions is the way to go. However, in many situations the actually involved types are known statically and using them directly makes generic components typically both easier to use and faster. The support for static polymorphism in C++2003 is lacking some features making it often quite hard to implement generic components as well as making their use unnecessary hard. In the upcoming C++0x several of the problems are addressed. This presentation will demonstrate the use of these features as they apply both to users as well as implementers of generic components. It will only discuss features already implemented in publically available compilers (in particular in gcc), i.e. this won't be a presentation about C++ language features hopefully appearing some time in the features but it will show how the language can be used right away. Although the main focus will be core language features, the presentation will use library components new in C++Ox where applicable.
by Dirk Haun
Everyone agrees that Continuous Integration (CI) is a good idea. A more interesting question is to see how well CI setups scale.
In this talk, we will be looking into some edge cases, such as:
We will be exploring these and similar issues and will discuss solutions and alternative options. Additional input from the audience is very much welcome to get a better overview of the state of CI in nontrivial real-life setups.
12th–16th April 2011