Springer LNCS Proceedings (password will be communicated during the conference)

Aims & Scope

Multicore processors are ubiquitous and every new computer is a truly parallel machine. This is a fundamental change in the history of computing: parallelism becomes available for everyone at low cost. In addition to scientific applications, everyday applications need to be parallel in order to exploit the full hardware potential. Compared to sequential applications, our repertoire of tools and methods for cost-effectively developing reliable and robust parallel applications is spotty. The purpose of this conference is to bring together researchers and practitioners with diverse backgrounds in order to advance the state of the art in software engineering, performance engineering, and tools in all areas of multicore systems.

Where & When

TOOLS 2012

When: May 31-June 1, 2012
Where: Prague, Czech Republic


co-located with the TOOLS Conference Series, May 28, 2012June 1, 2012




This conference aims to provide a forum for researchers and practitioners to tackle the multicore software challenge. We address a broad spectrum of topics from small-scale systems to large-scale parallel systems, from writing new applications to reengineering legacy applications. We also aim to stimulate discussions between academia and industry to get a better understanding of the software engineering problems and how they can be solved. We welcome contributions making connections between software engineering and other fields, which show how improvements in those fields lead to improvements in software engineering. The conference also addresses software engineering researchers who have not worked in multicore before - but who have the knowledge and expertise to address software engineering challenges posed by multicore. We solicit original, previously unpublished papers of current research.

Specific topics of interest include, but are not limited to:

  • Frameworks and libraries for multicore software
  • GPUs: programming and tools, OpenCL, CUDA, compilers, run-time systems
  • Parallel patterns
  • Parallel software architectures
  • Modeling techniques for multicore software
  • Software components and composition
  • Programming models for multicore
  • Software Transactional Memory
  • Testing and debugging of parallel applications
  • Verification techniques for multicore software
  • Software reengineering for parallelism
  • Performance tuning and auto-tuning
  • Development environments and tools for multicore software
  • Tools and techniques for homogeneous/heterogeneous multicore systems
  • Compiler techniques and auto-parallelization on multicore
  • Process models for multicore software development
  • Parallelism in multicore clusters and distributed systems using multicore
  • Energy issues in multicore programming
  • Data management on multicore
  • Software issues at the interface with multicore hardware and operating systems
  • Multicore software issues in scientific computing
  • Multicore software on mobile and embedded devices
  • Experience reports

In addition to full papers, we accept short papers with position statements (4 pages) on any of the above topics.

Paper Submission - Closed

We solicit novel, previously unpublished papers in LNCS style. Full papers are limited to 12 pages, including figures and references. Short papers for position statements are limited to 4 pages. Papers that do not adhere to these guidelines will not be published in the proceedings.

Link to LNCS templates and guidelines.

Papers should be anonymized to ensure a double-blind review (i.e., remove author names, affilitations, and citations that might reveal who the authors are). Upon acceptance, authors will have to provide the source files of the de-anonymized paper and a 'consent to publish' copyright form for Springer.

Each accepted paper and position statement must be presented at the workshop in person by(one of) the author(s). Papers should be submitted in PDF format.

Submit paper here via Springer OCS system
Note: Submitted papers can be update via the link sent in the confirmation email.

If you experience problems with the paper submission system, please contact for assistance. For questions related to the conference please contact msept @


May 31: Prof. Bertrand Meyer, ETH Zurich

Concurrent Programming is Easy

Concurrent programming is supposed to require radically new patterns of thought and to be hard to learn and practice. I want to present the contrarian view that concurrency, however difficult to implement, can be almost as straightforward to use as sequential programming (in its object-oriented incarnation and using contracts). This is the theme of the just started “Concurrency Made Easy” project funded by an ERC Advanced Investigator Grant and based on new developments of the SCOOP model of “simple” concurrent object-oriented programming. The key goal is what we may call “reasonability”: the ability to reason statically about our concurrent programs, the way we do about sequential ones. I will cover a number of examples showing that concurrency can, indeed, be made easy.


June 1: Prof. Lionel Briand, University of Luxembourg

Tackling the Testing and Verification of Multicore and Concurrent Software as a Search Problem

As multicore and therefore concurrent architectures are spreading to an increasing number of applications and industry sectors, it becomes increasingly important to devise rigorous but practical ways to verify and test concurrent systems. Though a great deal of research work has been published on the matter, there is limited support in industry for the practicing engineer. For a change in engineering practice to happen, we need to devise technologies that scale and can be easily tailored to resources available for quality assurance in a given context.

This talk reports on a research program that approaches verification and testing as a search and optimization problem. The techniques presented rely on system models describing the task architecture and performance characteristics. As a strategy to ease adoption in practice, those models rely on standards (e.g., UML/MARTE) or lightweight extensions enabling the use of commercial or open source modeling platforms to support automation.

Once the required information is extracted from models, early verification and testing both consist in identifying scenarios that maximize chances of uncovering concurrency and performance issues, such as deadline misses, starvation, or unacceptable levels of CPU usage. To do so, we either rely on evolutionary computation or constraint optimization, for which effective support already exists. The main challenge is of course to transform each specific problem into a search or constraint optimization problem, in such a way that these technologies can be efficient and scale.


General Chairs

Victor Pankratius
Michael Philippsen
Victor Pankratius
MIT - Massachusetts Institute of Technology, USA, and Karlsruhe Institute of Technology, Germany
Michael Philippsen
University of Erlangen-Nuremberg, Germany

Program Committee

  • Siegfried Benkner (University of Vienna, Austria)
  • Koen de Bosschere (Ghent University, Belgium)
  • John Cavazos (University of Delaware, USA)
  • Brian Demsky (UC Irvine, USA)
  • Danny Dig (University of Illinois UC, USA)
  • Eitan Farchi (IBM Research, Israel)
  • Takahiro Katagiri (University of Tokyo, Japan)
  • Christoph Kessler (Linköping University, Sweden)
  • Doug Lea (State University of New York at Oswego, USA)
  • Raymond Namyst (Univerity of Bordeaux, France)
  • Victor Pankratius (KIT, Germany)
  • Michael Philippsen (University of Erlangen-Nuremberg, Germany)
  • Leonel Sousa (Universidade Técnica de Lisboa, Portugal)
  • Richard Vuduc (GeorgiaTech, USA)

Important Dates

  • Acceptance notification: April 6, 2012
  • Camera-ready paper submission: April 20, 2012
  • Conference: May 31-June 1, 2012



All accepted papers will be published electronically with Springer LNCS.

Proc. of the International Conference on Multicore Software Engineering, Performance, and Tools (MSEPT'12), Victor Pankratius and Michael Philippsen (Eds.), Springer LNCS 7303, May 2012


For questions please contact: msept @

Past Events

The MSEPT conference has grown out of the successful series of IWMSE workshops, previously co-located with the International Conference on Software Engineering (ICSE).



GI   This conference is also supported by the working group Software Engineering for parallel Systems (SEPARS) of the German Computer Science Society (Gesellschaft fuer Informatik e.V.)