Research

Projects

My Publications

2016

  • S. Marr, E. Gonzalez Boix, and H. Mössenböck, "Towards Meta-Level Engineering and Tooling for Complex Concurrent Systems," in Proceedings of the 9th Arbeitstagung Programmiersprachen, 2016, pp. 91-95. bibtex (pdf) Go to document
    @inproceedings{Marr:2016:MetaConc, abstract = {With the widespread use of multicore processors, software becomes more and more diverse in its use of parallel computing resources. To address all application requirements, each with the appropriate abstraction, developers mix and match various concurrency abstractions made available to them via libraries and frameworks. Unfortunately, today's tools such as debuggers and profilers do not support the diversity of these abstractions. Instead of enabling developers to reason about the high-level programming concepts, they used to express their programs, the tools work only on the library's implementation level. While this is a common problem also for other libraries and frameworks, the complexity of concurrency exacerbates the issue further, and reasoning on the higher levels of the concurrency abstractions is essential to manage the associated complexity. In this position paper, we identify open research issues and propose to build tools based on a common meta-level interface to enable developers to reasons about their programs based on the high-level concepts they used to implement them.},
      added-at = {2016-01-25T13:07:14.000+0100},
      author = {Marr, Stefan and Gonzalez Boix, Elisa and Mössenböck, Hanspeter},
      biburl = {http://www.bibsonomy.org/bibtex/25094e9d82c7c0313586b5618ef39d2c8/gron},
      booktitle = {Proceedings of the 9th Arbeitstagung Programmiersprachen},
      day = 25, interhash = {b0599561ea7514193ff3fa9a93eec376},
      intrahash = {5094e9d82c7c0313586b5618ef39d2c8},
      issn = {1613-0073},
      keywords = {Abstraction Concepts Concurrency HighLevel MeMyPublication MetaEngineering MetaLevel MetaProgramming Parallelism Profiling Representation Tooling myown},
      location = {Vienna, Austria},
      month = {February},
      pages = {91--95},
      pdf = {http://stefan-marr.de/downloads/atps-marr-et-al-towards-meta-level-engineering-and-tooling-for-complex-concurrent-systems.pdf},
      publisher = {CEUR-WS},
      series = {ATPS'16},
      timestamp = {2016-03-28T18:17:18.000+0200},
      title = {Towards Meta-Level Engineering and Tooling for Complex Concurrent Systems},
      type = {Position Paper},
      url = {http://stefan-marr.de/papers/atps-marr-et-al-towards-meta-level-engineering-and-tooling-for-complex-concurrent-systems/},
      volume = 1559, year = 2016 }
  • J. De Koster, S. Marr, T. Van Cutsem, and T. D’Hondt, "Domains: Sharing State in the Communicating Event-Loop Actor Model," Computer Languages, Systems & Structures, p. 39, 2016. bibtex (pdf) (doi)
    @article{DeKoster2016, abstract = {The actor model is a message-passing concurrency model that avoids deadlocks and low-level data races by construction. This facilitates concurrent programming, especially in the context of complex interactive applications where modularity, security and fault-tolerance are required. The tradeoff is that the actor model sacrifices expressiveness and safety guarantees with respect to parallel access to shared state. In this paper we present domains as a set of novel language abstractions for safely encapsulating and sharing state within the actor model. We introduce four types of domains, namely immutable, isolated, observable and shared domains that each are tailored to a certain access pattern on that shared state. The domains are characterized with an operational semantics. For each we discuss how the actor model's safety guarantees are upheld even in the presence of conceptually shared state. Furthermore, the proposed language abstractions are evaluated with a case study in Scala comparing them to other synchonisation mechanisms to demonstrate their benefits in deadlock freedom, parallel reads, and enforced isolation. },
      added-at = {2016-01-21T20:55:54.000+0100},
      author = {De Koster, Joeri and Marr, Stefan and Van Cutsem, Tom and D'Hondt, Theo},
      biburl = {http://www.bibsonomy.org/bibtex/2803c9a32cf26e5784defb9c5fb24e11c/gron},
      description = {Domains: Sharing state in the communicating event-loop actor model},
      doi = {10.1016/j.cl.2016.01.003},
      interhash = {3adbb692105fd701eebdc50807bb2c44},
      intrahash = {803c9a32cf26e5784defb9c5fb24e11c},
      issn = {1477-8424},
      journal = {Computer Languages, Systems & Structures },
      keywords = {Actors Concurrency Domains EventLoops Interpreter MeMyPublication Parallelism Shacl myown},
      pages = 39, pdf = {http://stefan-marr.de/downloads/comlan-de-koster-et-al-domains-sharing-state-in-the-communicating-event-loop-actor-model.pdf},
      timestamp = {2016-02-18T10:39:07.000+0100},
      title = {Domains: Sharing State in the Communicating Event-Loop Actor Model},
      year = 2016 }

2015

  • M. De Wael, S. Marr, B. De Fraine, T. Van Cutsem, and W. De Meuter, "Partitioned Global Address Space Languages," ACM Computing Surveys, vol. 47, iss. 4, p. 62:1-62:27, 2015. bibtex (pdf) (doi) Go to document
    @article{PGASSurvey, abstract = {The Partitioned Global Address Space (PGAS) model is a parallel programming model that aims to improve programmer productivity while at the same time aiming for high performance. The main premise of PGAS is that a globally shared address space improves productivity, but that a distinction between local and remote data accesses is required to allow performance optimizations and to support scalability on large-scale parallel architectures. To this end, PGAS preserves the global address space while embracing awareness of non-uniform communication costs. Today, about a dozen languages exist that adhere to the PGAS model. This survey proposes a definition and a taxonomy along four axes: how parallelism is introduced, how the address space is partitioned, how data is distributed among the partitions and finally how data is accessed across partitions. Our taxonomy reveals that today's PGAS languages focus on distributing regular data and distinguish only between local and remote data access cost, whereas the distribution of irregular data and the adoption of richer data access cost models remain open challenges.},
      added-at = {2015-01-26T12:02:26.000+0100},
      articleno = {62},
      author = {De Wael, Mattias and Marr, Stefan and De Fraine, Bruno and Van Cutsem, Tom and De Meuter, Wolfgang},
      biburl = {http://www.bibsonomy.org/bibtex/26f4cfd566380f590de88b6606e8f14b2/gron},
      doi = {10.1145/2716320},
      impactfactor2014 = {3.373},
      impactfactor5y2014 = {5.949},
      interhash = {e0e73b5f03d2594bbf77e7b648bac11e},
      intrahash = {6f4cfd566380f590de88b6606e8f14b2},
      issn = {0360-0300},
      journal = {ACM Computing Surveys},
      keywords = {Concurrency GlobalAddressSpace HPC LanguageDesign MeMyPublication MessagePassing PGAS Parallelism Performance SharedMemory myown},
      month = {June},
      number = 4, numpages = {27},
      pages = {62:1--62:27},
      pdf = {http://stefan-marr.de/downloads/acm-csur-de-wael-et-al-partitioned-global-address-space-languages.pdf},
      publisher = {ACM},
      timestamp = {2015-11-14T22:31:41.000+0100},
      title = {Partitioned Global Address Space Languages},
      url = {http://stefan-marr.de/papers/acm-csur-de-wael-et-al-partitioned-global-address-space-languages/},
      volume = 47, year = 2015 }
  • S. Marr, C. Seaton, and S. Ducasse, "Zero-Overhead Metaprogramming: Reflection and Metaobject Protocols Fast and without Compromises," in Proceedings of the 36th ACM SIGPLAN Conference on Programming Language Design and Implementation, 2015, pp. 545-554. bibtex (pdf) (doi)
    @inproceedings{ZeroOverhead, abstract = {Runtime metaprogramming enables many useful applications and is often a convenient solution to solve problems in a generic way, which makes it widely used in frameworks, middleware, and domain-specific languages. However, powerful metaobject protocols are rarely supported and even common concepts such as reflective method invocation or dynamic proxies are not optimized. Solutions proposed in literature either restrict the metaprogramming capabilities or require application or library developers to apply performance improving techniques. For overhead-free runtime metaprogramming, we demonstrate that dispatch chains, a generalized form of polymorphic inline caches common to self-optimizing interpreters, are a simple optimization at the language-implementation level. Our evaluation with self-optimizing interpreters shows that unrestricted metaobject protocols can be realized for the first time without runtime overhead, and that this optimization is applicable for just-in-time compilation of interpreters based on meta-tracing as well as partial evaluation. In this context, we also demonstrate that optimizing common reflective operations can lead to significant performance improvements for existing applications.},
      added-at = {2015-03-31T15:15:51.000+0200},
      author = {Marr, Stefan and Seaton, Chris and Ducasse, Stéphane},
      biburl = {http://www.bibsonomy.org/bibtex/284be3e9de039beab1ddee5414f9bec3c/gron},
      booktitle = {Proceedings of the 36th ACM SIGPLAN Conference on Programming Language Design and Implementation},
      doi = {10.1145/2737924.2737963},
      interhash = {c212198ae76c6205f6cdbf31185dcc1c},
      intrahash = {84be3e9de039beab1ddee5414f9bec3c},
      isbn = {978-1-4503-3468-6},
      keywords = {DispatchChains MeMyPublication MetaProgramming Overhead Performance RPython Truffle myown},
      note = {(acceptance rate 19%)},
      numpages = {10},
      pages = {545--554},
      pdf = {http://stefan-marr.de/downloads/pldi15-marr-et-al-zero-overhead-metaprogramming.pdf},
      publisher = {ACM},
      series = {PLDI '15},
      timestamp = {2015-07-13T13:46:28.000+0200},
      title = {Zero-Overhead Metaprogramming: Reflection and Metaobject Protocols Fast and without Compromises},
      year = 2015 }
  • S. Marr, T. Renaux, L. Hoste, and W. De Meuter, "Parallel Gesture Recognition with Soft Real-Time Guarantees," Science of Computer Programming, vol. 98, Part 2, pp. 159-183, 2015. bibtex (pdf) (doi) Go to document
    @article{marr2014parallel, abstract = {Using imperative programming to process event streams, such as those generated by multi-touch devices and 3D cameras, has significant engineering drawbacks. Declarative approaches solve common problems but so far, they have not been able to scale on multicore systems while providing guaranteed response times. We propose PARTE, a parallel scalable complex event processing engine that allows for a declarative definition of event patterns and provides soft real-time guarantees for their recognition. The proposed approach extends the classical Rete algorithm and maps event matching onto a graph of actor nodes. Using a tiered event matching model, PARTE provides upper bounds on the detection latency by relying on a combination of non-blocking message passing between Rete nodes and safe memory management techniques. The performance evaluation shows the scalability of our approach on up to 64 cores. Moreover, it indicates that PARTE's design choices lead to more predictable performance compared to a PARTE variant without soft real-time guarantees. Finally, the evaluation indicates further that gesture recognition can benefit from the exposed parallelism with superlinear speedups.},
      added-at = {2014-02-13T16:19:23.000+0100},
      author = {Marr, Stefan and Renaux, Thierry and Hoste, Lode and De Meuter, Wolfgang},
      biburl = {http://www.bibsonomy.org/bibtex/22d7459399733edbfdc8c1ff5ba8c1e3b/gron},
      doi = {10.1016/j.scico.2014.02.012},
      impactfactor2014 = {0.715},
      impactfactor5year2014 = {0.837},
      interhash = {e427ac910ad10a3b4f055fe6eee0822e},
      intrahash = {2d7459399733edbfdc8c1ff5ba8c1e3b},
      issn = {0167-6423},
      journal = {Science of Computer Programming},
      keywords = {Clips MeMyPublication PARTE RealTime Rete RulesEngine VM myown},
      pages = {159--183},
      pdf = {http://stefan-marr.de/downloads/scp14-marr-et-al-parallel-gesture-recognition-with-soft-real-time-guarantees.pdf},
      timestamp = {2015-11-14T22:43:00.000+0100},
      title = {Parallel Gesture Recognition with Soft Real-Time Guarantees},
      url = {http://stefan-marr.de/downloads/scp14-marr-et-al-parallel-gesture-recognition-with-soft-real-time-guarantees.pdf},
      volume = {98, Part 2},
      year = 2015 }
  • S. Marr and S. Ducasse, "Tracing vs. Partial Evaluation: Comparing Meta-Compilation Approaches for Self-Optimizing Interpreters," in Proceedings of the 2015 ACM International Conference on Object Oriented Programming Systems Languages \& Applications, 2015, pp. 821-839. bibtex (pdf) (doi) Go to document
    @inproceedings{Marr:2015:MTPE, abstract = {Tracing and partial evaluation have been proposed as meta-compilation techniques for interpreters to make just-in-time compilation language-independent. They promise that programs executing on simple interpreters can reach performance of the same order of magnitude as if they would be executed on state-of-the-art virtual machines with highly optimizing just-in-time compilers built for a specific language. Tracing and partial evaluation approach this meta-compilation from two ends of a spectrum, resulting in different sets of tradeoffs. This study investigates both approaches in the context of self-optimizing interpreters, a technique for building fast abstract-syntax-tree interpreters. Based on RPython for tracing and Truffle for partial evaluation, we assess the two approaches by comparing the impact of various optimizations on the performance of an interpreter for SOM, an object-oriented dynamically-typed language. The goal is to determine whether either approach yields clear performance or engineering benefits. We find that tracing and partial evaluation both reach roughly the same level of performance. SOM based on meta-tracing is on average 3x slower than Java, while SOM based on partial evaluation is on average 2.3x slower than Java. With respect to the engineering, tracing has however significant benefits, because it requires language implementers to apply fewer optimizations to reach the same level of performance.},
      acceptancerate = {0.25},
      acmid = {2660194},
      added-at = {2015-08-19T14:32:13.000+0200},
      author = {Marr, Stefan and Ducasse, Stéphane},
      biburl = {http://www.bibsonomy.org/bibtex/27ca631f0fc852e48f2285e1a8d4cdfa0/gron},
      booktitle = {Proceedings of the 2015 ACM International Conference on Object Oriented Programming Systems Languages \& Applications},
      doi = {10.1145/2660193.2660194},
      interhash = {626a639666ea884d5b1a8dc121e8457a},
      intrahash = {7ca631f0fc852e48f2285e1a8d4cdfa0},
      isbn = {978-1-4503-2585-1},
      keywords = {Compiler Interpreter JITCompilation MeMyPublication MetaTracing Optimization PartialEvaluation RPython SelfOptimizing Tracing Truffle myown},
      numpages = {19},
      pages = {821--839},
      pdf = {http://stefan-marr.de/downloads/oopsla15-marr-ducasse-meta-tracing-vs-partial-evaluation.pdf},
      publisher = {ACM},
      series = {OOPSLA '15},
      timestamp = {2015-11-27T21:05:51.000+0100},
      title = {Tracing vs. Partial Evaluation: Comparing Meta-Compilation Approaches for Self-Optimizing Interpreters},
      url = {http://stefan-marr.de/papers/oopsla-marr-ducasse-meta-tracing-vs-partial-evaluation/},
      year = 2015 }
  • J. De Koster, S. Marr, T. D’Hondt, and T. Van Cutsem, "Domains: safe sharing among actors," Science of Computer Programming, vol. 98, Part 2, pp. 140-158, 2015. bibtex (pdf) (doi)
    @article{DeKoster2014, abstract = {The actor model is a concurrency model that avoids issues such as deadlocks and data races by construction, and thus facilitates concurrent programming. While it has mainly been used for expressing distributed computations, it is equally useful for modeling concurrent computations in a single shared memory machine. In component based software, the actor model lends itself to divide the components naturally over different actors and use message-passing concurrency for the interaction between these components. The tradeoff is that the actor model sacrifices expressiveness and efficiency with respect to parallel access to shared state. This paper gives an overview of the disadvantages of the actor model when trying to express shared state and then formulates an extension of the actor model to solve these issues. Our solution proposes domains and synchronization views to solve the issues without compromising on the semantic properties of the actor model. Thus, the resulting concurrency model maintains deadlock-freedom and avoids low-level data races.},
      added-at = {2014-02-25T10:02:24.000+0100},
      author = {De Koster, Joeri and Marr, Stefan and D'Hondt, Theo and Van Cutsem, Tom},
      biburl = {http://www.bibsonomy.org/bibtex/2a229fb5407e13cc4a9897df3a3b39ee8/gron},
      doi = {10.1016/j.scico.2014.02.008},
      impactfactor2014 = {0.715},
      impactfactor5year2014 = {0.837},
      interhash = {50ad0d471e74b756b23455837579b53d},
      intrahash = {a229fb5407e13cc4a9897df3a3b39ee8},
      issn = {0167-6423},
      journal = {Science of Computer Programming },
      keywords = {Actors Domains MeMyPublication Synchronization Views myown},
      month = {February},
      pages = {140--158},
      pdf = {http://stefan-marr.de/downloads/scp14-de-koster-et-al-domains-safe-sharing-among-actors.pdf},
      timestamp = {2015-11-14T22:41:03.000+0100},
      title = {Domains: safe sharing among actors },
      volume = {98, Part 2},
      year = 2015 }
  • M. De Wael, S. Marr, J. De Koster, J. B. Sartor, and W. De Meuter, "Just-in-Time Data Structures," in Proceedings of the 2015 ACM International Symposium on New Ideas, New Paradigms, and Reflections on Programming \& Software, 2015. bibtex (pdf) (doi) Go to document
    @inproceedings{DeWael:15:JitData, abstract = {Today, software engineering practices focus on finding the single right data representation (i.e., data structure) for a program. The right data representation, however, might not exist: relying on a single representation of the data for the lifetime of the program can be suboptimal in terms of performance. We explore the idea of developing data structures for which changing the data representation is an intrinsic property. To this end we introduce Just-in-Time Data Structures, which enable representation changes at runtime, based on declarative input from a performance expert programmer. Just-in-Time Data Structures are an attempt to shift the focus from finding the ``right’’ data structure to finding the right sequence of data representations. We present JitDS-Java, an extension to the Java language, to develop Just-in-Time Data Structures. Further, we show two example programs that benefit from changing the representation at runtime.},
      added-at = {2015-09-25T12:10:59.000+0200},
      author = {De Wael, Mattias and Marr, Stefan and De Koster, Joeri and Sartor, Jennifer B. and De Meuter, Wolfgang},
      biburl = {http://www.bibsonomy.org/bibtex/2889bbc4c57b61960cdfb2a93147bce23/gron},
      booktitle = {Proceedings of the 2015 ACM International Symposium on New Ideas, New Paradigms, and Reflections on Programming \& Software},
      doi = {10.1145/2814228.2814231},
      interhash = {ca767ff263c76e39ba25305e658771f5},
      intrahash = {889bbc4c57b61960cdfb2a93147bce23},
      keywords = {Algorithms DataStructures DynamicReclassification MeMyPublication Optimizations Performance myown},
      month = {October},
      pdf = {http://stefan-marr.de/downloads/onward15-de-wael-et-al-just-in-time-data-structures.pdf},
      publisher = {ACM},
      series = {Onward! '15},
      timestamp = {2015-09-25T12:10:59.000+0200},
      title = {Just-in-Time Data Structures},
      url = {http://soft.vub.ac.be/~madewael/jitds/},
      year = 2015 }
  • G. Chari, D. Garbervetsky, S. Marr, and S. Ducasse, "Towards Fully Reflective Environments," in Proceedings of the 2015 ACM International Symposium on New Ideas, New Paradigms, and Reflections on Programming \& Software, 2015. bibtex (pdf) (doi)
    @inproceedings{Chari:15:Mate, abstract = {Modern development environments promote live programming (LP) mechanisms because it enhances the development experience by providing instantaneous feed- back and interaction with live objects. LP is typically supported with advanced reflective techniques within dynamic languages. These languages run on top of Virtual Machines (VMs) that are built in a static manner so that most of their components are bound at compile time. As a consequence, VM developers are forced to work using the traditional edit-compile-run cycle, even when they are designing LP-supporting environments. In this paper we explore the idea of bringing LP techniques to the VM domain for improving their observability, evolution and adaptability at run-time. We define the notion of fully reflective execution environments (EEs), systems that provide reflection not only at the application level but also at the level of the VM. We characterize such systems, propose a design, and present Mate v1, a prototypical implementation. Based on our prototype, we analyze the feasibility and applicability of incorporating reflective capabilities into different parts of EEs. Furthermore, the evaluation demonstrates the opportunities such reflective capabilities provide for unanticipated dynamic adaptation scenarios, benefiting thus, a wider range of users.},
      added-at = {2015-09-25T11:54:01.000+0200},
      author = {Chari, Guido and Garbervetsky, Diego and Marr, Stefan and Ducasse, Stéphane},
      biburl = {http://www.bibsonomy.org/bibtex/257686db3a8a1b49c6f802d72ccd3f26b/gron},
      booktitle = {Proceedings of the 2015 ACM International Symposium on New Ideas, New Paradigms, and Reflections on Programming \& Software},
      doi = {10.1145/2814228.2814241},
      interhash = {360e220beb08b9d61c893249074dd412},
      intrahash = {57686db3a8a1b49c6f802d72ccd3f26b},
      keywords = {DynamicAdaptation LiveProgramming MOP Mate MeMyPublication MetaObjectProtocols Reflection VirtualMachines myown},
      month = {October},
      pdf = {http://stefan-marr.de/downloads/onward15-chari-et-al-towards-fully-reflective-environments.pdf},
      publisher = {ACM},
      series = {Onward! '15},
      timestamp = {2015-09-25T14:17:16.000+0200},
      title = {Towards Fully Reflective Environments},
      year = 2015 }
  • M. Vandercammen, J. Nicolay, S. Marr, J. De Koster, T. D’Hondt, and C. De Roover, "A Formal Foundation for Trace-Based JIT Compilers," in Proceedings of the 13th International Workshop on Dynamic Analysis, Pittsburgh, PA, USA, 2015, pp. 25-30. bibtex (pdf) (doi)
    @inproceedings{Vandercammen:15:WODA, abstract = {Trace-based JIT compilers identify frequently executed program paths at run-time and subsequently record, compile and optimize their execution. In order to improve the performance of the generated machine instructions, JIT compilers heavily rely on dynamic analysis of the code. Existing work treats the components of a JIT compiler as a monolithic whole, tied to particular execution semantics. We propose a formal framework that facilitates the design and implementation of a tracing JIT compiler and its accompanying dynamic analyses by decoupling the tracing, optimization, and interpretation processes. This results in a framework that is more configurable and extensible than existing formal tracing models. We formalize the tracer and interpreter as two abstract state machines that communicate through a minimal, well-defined interface. Developing a tracing JIT compiler becomes possible for arbitrary interpreters that implement this interface. The abstract machines also provide the necessary hooks to plug in custom analyses and optimizations.},
      added-at = {2015-09-25T11:22:54.000+0200},
      address = {Pittsburgh, PA, USA},
      author = {Vandercammen, Maarten and Nicolay, Jens and Marr, Stefan and De Koster, Joeri and D'Hondt, Theo and De Roover, Coen},
      biburl = {http://www.bibsonomy.org/bibtex/23184db3b6ac1ff499bdcb1b0d356e359/gron},
      booktitle = {Proceedings of the 13th International Workshop on Dynamic Analysis},
      doi = {10.1145/2823363.2823369},
      interhash = {28d42ec8ccafdeee3a41395c56db4eb8},
      intrahash = {3184db3b6ac1ff499bdcb1b0d356e359},
      keywords = {Compilation DynamicAnalysis JIT MeMyPublication OperationalSemantics Tracing myown},
      month = {October},
      numpages = {6},
      pages = {25--30},
      pdf = {stefan-marr.de/downloads/woda15-vandercammen-et-al-a-formal-foundation-for-trace-based-jit-compilers.pdf},
      publisher = {ACM},
      series = {WODA '15},
      timestamp = {2015-10-13T23:24:33.000+0200},
      title = {A Formal Foundation for Trace-Based JIT Compilers},
      year = 2015 }
  • Marr, Stefan and Mössenböck, Hanspeter, Optimizing Communicating Event-Loop Languages with Truffle, 2015. bibtex (pdf) Go to document
    @presentation{OptCELWithTruffle, abstract = {Communicating Event-Loop Languages similar to E and AmbientTalk are recently gaining more traction as a subset of actor languages. With the rise of JavaScript, E’s notion of vats and non-blocking communication based on promises entered the mainstream. For implementations, the combination of dynamic typing, asynchronous message sending, and promise resolution pose new optimization challenges. This paper discusses these challenges and presents initial experiments for a Newspeak implementation based on the Truffle framework. Our implementation is on average 1.65x slower than Java on a set of 14 benchmarks. Initial optimizations improve the performance of asynchronous messages and reduce the cost of encapsulation on microbenchmarks by about 2x. Parallel actor benchmarks further show that the system scales based on the workload characteristics. Thus, we conclude that Truffle is a promising platform also for communicating event-loop languages.},
      added-at = {2015-09-25T10:47:48.000+0200},
      author = {Marr, Stefan and Mössenböck, Hanspeter},
      biburl = {http://www.bibsonomy.org/bibtex/29f9881cc5d059f4916d4805e780b5e00/gron},
      booktitle = {Presentation at 5th International Workshop on Programming based on Actors, Agents, and Decentralized Control},
      day = 26, interhash = {0a0937a8e45344c88cbe6fb1ad8c42fa},
      intrahash = {9f9881cc5d059f4916d4805e780b5e00},
      keywords = {Actors Caching CommunicatingEventLoops Compiler Concurrency MeMyPublication Message Optimization PIC Sending Truffle myown},
      location = {Pittsburgh, PA, USA},
      month = {October},
      pdf = {http://stefan-marr.de/downloads/agere15-agere-marr-moessenboeck-optimizing-communicating-event-loop-languages-with-truffle.pdf},
      series = {AGERE '15},
      timestamp = {2015-09-25T11:39:02.000+0200},
      title = {Optimizing Communicating Event-Loop Languages with Truffle},
      type = {Work-in-Progress-Paper},
      url = {http://stefan-marr.de/papers/agere-marr-moessenboeck-optimizing-communicating-event-loop-languages-with-truffle/},
      year = 2015 }

2014

  • S. Marr, T. Pape, and W. De Meuter, "Are We There Yet? Simple Language Implementation Techniques for the 21st Century," IEEE Software, vol. 31, iss. 5, pp. 60-67, 2014. bibtex (pdf) (doi) Go to document
    @article{marr2014there, abstract = {Research on language implementation techniques has regained importance with the rise of domain-specific languages (DSLs). Although DSLs can help manage a domain’s complexity, building highly optimizing compilers or virtual machines is rarely affordable. So, performance remains an issue. Ideally, you would implement a simple interpreter and still be able to achieve acceptable performance. RPython and Truffle are implementation techniques based on simple interpreters; they promise to perform at the same order of magnitude as highly optimizing virtual machines. This case study compares the two techniques to identify their similarities, weaknesses, and areas for further research.},
      added-at = {2014-07-16T16:25:23.000+0200},
      author = {Marr, Stefan and Pape, Tobias and De Meuter, Wolfgang},
      biburl = {http://www.bibsonomy.org/bibtex/2c5e0f03749a6e4b18d92461f5a015821/gron},
      day = 15, doi = {10.1109/MS.2014.98},
      impactfactor2014 = {1.053},
      impactfactor5y2014 = {1.397},
      interhash = {cf1741034f10e8abf2bfe2a9e30ebbc5},
      intrahash = {c5e0f03749a6e4b18d92461f5a015821},
      issn = {0740-7459},
      journal = {IEEE Software},
      keywords = {Compilers ComputerProgramming DSL Interpreter Interpreters LanguageImplementation MeMyPublication Performance ProgrammingLanguages RPython SOM SelfOptimizing Smalltalk SoftwareEngineering Truffle VirtualMachines myown},
      month = {September},
      number = 5, numpages = {8},
      pages = {60--67},
      pdf = {http://stefan-marr.de/downloads/ieee-soft-marr-et-al-are-we-there-yet.pdf},
      timestamp = {2015-11-14T22:32:59.000+0100},
      title = {Are We There Yet? Simple Language Implementation Techniques for the 21st Century},
      url = {http://stefan-marr.de/papers/ieee-soft-marr-et-al-are-we-there-yet/},
      volume = 31, year = 2014 }
  • J. Swalens, S. Marr, J. De Koster, and T. Van Cutsem, "Towards Composable Concurrency Abstractions," in Proceedings of the Workshop on Programming Language Approaches to Concurrency and communication-cEntric Software (PLACES), 2014, pp. 54-60. bibtex (pdf) (doi) Go to document
    @inproceedings{swalens2014towards, abstract = {In the past decades, many different programming models for managing concurrency in applications have been proposed, such as the actor model, Communicating Sequential Processes, and Software Transactional Memory. The ubiquity of multi-core processors has made harnessing concurrency even more important. We observe that modern languages, such as Scala, Clojure, or F\#, provide not one, but \emph{multiple} concurrency models that help developers manage concurrency. Large end-user applications are rarely built using just a single concurrency model. Programmers need to manage a responsive UI, deal with file or network I/O, asynchronous workflows, and shared resources. Different concurrency models facilitate different requirements. This raises the issue of how these concurrency models interact, and whether they are \emph{composable}. After all, combining different concurrency models may lead to subtle bugs or inconsistencies. In this paper, we perform an in-depth study of the concurrency abstractions provided by the Clojure language. We study all pairwise combinations of the abstractions, noting which ones compose without issues, and which do not. We make an attempt to abstract from the specifics of Clojure, identifying the general properties of concurrency models that facilitate or hinder composition.},
      added-at = {2014-02-17T12:48:39.000+0100},
      author = {Swalens, Janwillem and Marr, Stefan and De Koster, Joeri and Van Cutsem, Tom},
      biburl = {http://www.bibsonomy.org/bibtex/28858476277e853211d32fca6e2abfe2e/gron},
      booktitle = {Proceedings of the Workshop on Programming Language Approaches to Concurrency and communication-cEntric Software (PLACES)},
      doi = {10.4204/EPTCS.155.8},
      interhash = {2f7580427b696dba54a55639ea954133},
      intrahash = {8858476277e853211d32fca6e2abfe2e},
      journal = {EPTCS},
      keywords = {Actors Atoms CSP Clojure Concurrency MeMyPublication Programming STM Transactions VM myown},
      month = {April},
      pages = {54--60},
      pdf = {http://arxiv.org/pdf/1406.3485},
      series = {PLACES '14},
      timestamp = {2015-02-20T17:44:47.000+0100},
      title = {Towards Composable Concurrency Abstractions},
      url = {http://arxiv.org/abs/1406.3485},
      volume = 155, year = 2014 }
  • M. De Wael, S. Marr, and T. Van Cutsem, "Fork/Join Parallelism in the Wild: Documenting Patterns and Anti-Patterns in Java Programs using the Fork/Join Framework," in Proceedings of the 2014 International Conference on Principles and Practices of Programming on the Java Platform: Virtual Machines, Languages, and Tools, 2014, pp. 39-50. bibtex (pdf) (doi) Go to document
    @inproceedings{dewael2014forkjoin, abstract = {Now that multicore processors are commonplace, developing parallel software has escaped the confines of high-performance computing and enters the mainstream. The Fork/Join framework, for instance, is part of the standard Java platform since version 7. Fork/Join is a high-level parallel programming model advocated to make parallelizing recursive divide-and-conquer algorithms particularly easy. While, in theory, Fork/Join is a simple and effective technique to expose parallelism in applications, it has not been investigated before whether and how the technique is applied in practice. We therefore performed an empirical study on a corpus of 120 open source Java projects that use the framework for roughly 362 different tasks. On the one hand, we confirm the frequent use of four best-practice patterns (Sequential Cutoff, Linked Subtasks, Leaf Tasks, and avoiding unnecessary forking) in actual projects. On the other hand, we also discovered three recurring anti-patterns that potentially limit parallel performance: sub-optimal use of Java collections when splitting tasks into subtasks as well as when merging the results of subtasks, and finally the inappropriate sharing of resources between tasks. We document these anti-patterns and study their impact on performance.},
      acceptancerate = {0.39},
      added-at = {2014-07-15T21:10:12.000+0200},
      author = {De Wael, Mattias and Marr, Stefan and Van Cutsem, Tom},
      biburl = {http://www.bibsonomy.org/bibtex/22f24495a3090c2527290e57d045313a0/gron},
      booktitle = {Proceedings of the 2014 International Conference on Principles and Practices of Programming on the Java Platform: Virtual Machines, Languages, and Tools},
      doi = {10.1145/2647508.2647511},
      interhash = {6a67e3d8a05209a4aa4bc3b18dd49699},
      intrahash = {2f24495a3090c2527290e57d045313a0},
      isbn = {978-1-4503-2926-2},
      keywords = {AntiPatterns EmpiricalStudy ForkJoin Java MeMyPublication OpenSource Patterns myown},
      month = {September},
      note = {(acceptance rate 39%)},
      numpages = {12},
      pages = {39--50},
      pdf = {http://stefan-marr.de/downloads/pppj14-dewael-et-al-forkjoin-parallelism-in-the-wild.pdf},
      series = {PPPJ '14},
      timestamp = {2015-11-14T23:07:25.000+0100},
      title = {Fork/Join Parallelism in the Wild: Documenting Patterns and Anti-Patterns in Java Programs using the Fork/Join Framework},
      url = {http://stefan-marr.de/downloads/pppj14-dewael-et-al-forkjoin-parallelism-in-the-wild.pdf},
      year = 2014 }

2013

  • J. Swalens, T. Renaux, L. Hoste, S. Marr, and W. De Meuter, "Cloud PARTE: Elastic Complex Event Processing based on Mobile Actors," in Proceedings of AGERE! 2013, 3rd International Workshop on Programming based on Actors, Agents, and Decentralized Control, 2013, pp. 3-12. bibtex (pdf) Go to document
    @inproceedings{Swalens2013cloud, abstract = {Traffic monitoring or crowd management systems produce large amounts of data in the form of events that need to be processed to detect relevant incidents. Rule-based pattern recognition is a promising approach for these applications, however, increasing amounts of data as well as large and complex rule sets demand for more and more processing power and memory. In order to scale such applications, a rule-based pattern detection system needs to be distributable over multiple machines. Today's approaches are however focused on static distribution of rules or do not support reasoning over the full set of events. We propose Cloud PARTE, a complex event detection system that implements the Rete algorithm on top of mobile actors. These actors can migrate between machines to respond to changes in the work load distribution. Cloud PARTE is an extension of PARTE and offers the first rule engine specifically tailored for continuous complex event detection that is able to benefit from elastic systems as provided by cloud computing platforms. It supports fully automatic load balancing and supports online rules with access to the entire event pool.},
      added-at = {2013-10-24T13:34:28.000+0200},
      author = {Swalens, Janwillem and Renaux, Thierry and Hoste, Lode and Marr, Stefan and De Meuter, Wolfgang},
      biburl = {http://www.bibsonomy.org/bibtex/23f1a2b2371c1e151b759ce43b0005e69/gron},
      booktitle = {Proceedings of AGERE! 2013, 3rd International Workshop on Programming based on Actors, Agents, and Decentralized Control},
      interhash = {7fc89cd94011a7d61fece752a317db98},
      intrahash = {3f1a2b2371c1e151b759ce43b0005e69},
      keywords = {BigData Cloud Distribution Elasicity Inference LoadBalancing MeMyPublication Rete TrafficMonitoring myown},
      month = {October},
      pages = {3--12},
      pdf = {http://soft.vub.ac.be/~smarr/downloads/agere13-swalens-et-al-cloud-parte-elastic-complex-event-processing-based-on-mobile-actors.pdf},
      publisher = {ACM},
      series = {AGERE! '13},
      timestamp = {2015-02-20T17:39:57.000+0100},
      title = {Cloud PARTE: Elastic Complex Event Processing based on Mobile Actors},
      url = {http://soft.vub.ac.be/~smarr/downloads/agere13-swalens-et-al-cloud-parte-elastic-complex-event-processing-based-on-mobile-actors.pdf},
      year = 2013 }
  • J. De Koster, S. Marr, T. D’Hondt, and T. Van Cutsem, "Tanks: Multiple reader, single writer actors," in Proceedings of AGERE! 2013, 3rd International Workshop on Programming based on Actors, Agents, and Decentralized Control, 2013. bibtex (pdf) Go to document
    @inproceedings{dekoster2013tanks, abstract = {In the past, the Actor Model has mainly been explored in a distributed context. However, more and more application developers are also starting to use it to program shared-memory multicore machines because of the safety guarantees it provides. It avoids issues such as deadlocks and race conditions by construction, and thus facilitates concurrent programming. The tradeoff is that the Actor Model sacrifices expressiveness with respect to accessing shared state because actors are fully isolated from each other (a.k.a. "shared-nothing parallelism"). There is a need for more high level synchronization mechanisms that integrate with the actor model without sacrificing the safety and liveness guarantees it provides. This paper introduces a variation on the communicating event-loops actor model called the Tank model. A tank is an actor that can expose part of its state as a shared read-only resource. The model ensures that any other actor will always observe a consistent version of that state, even in the face of concurrent updates of the actor that owns that state.},
      added-at = {2013-10-24T17:29:58.000+0200},
      author = {De Koster, Joeri and Marr, Stefan and D'Hondt, Theo and Van Cutsem, Tom},
      biburl = {http://www.bibsonomy.org/bibtex/27263458a77c11ab88ae282ab71fc7327/gron},
      booktitle = {Proceedings of AGERE! 2013, 3rd International Workshop on Programming based on Actors, Agents, and Decentralized Control},
      interhash = {c1db1b07f46be7b49019a847b90ae145},
      intrahash = {7263458a77c11ab88ae282ab71fc7327},
      keywords = {Actors Concurrency ConcurrentReads Consistency Encapsulation EventLoops Isolation MeMyPublication myown},
      pdf = {http://soft.vub.ac.be/~smarr/downloads/agere13-de-koster-et-al-tanks-multiple-reader-single-writer-actors.pdf},
      timestamp = {2015-02-20T17:40:36.000+0100},
      title = {Tanks: Multiple reader, single writer actors},
      url = {http://soft.vub.ac.be/~smarr/downloads/agere13-de-koster-et-al-tanks-multiple-reader-single-writer-actors.pdf},
      year = 2013 }
  • S. Marr, "Supporting Concurrency Abstractions in High-level Language Virtual Machines," PhD Thesis , Pleinlaan 2, B-1050 Brussels, Belgium, 2013. bibtex (pdf) Go to document
    @phdthesis{marr2013phd, abstract = {During the past decade, software developers widely adopted JVM and CLI as multi-language virtual machines (VMs). At the same time, the multicore revolution burdened developers with increasing complexity. Language implementers devised a wide range of concurrent and parallel programming concepts to address this complexity but struggle to build these concepts on top of common multi-language VMs. Missing support in these VMs leads to tradeoffs between implementation simplicity, correctly implemented language semantics, and performance guarantees. Departing from the traditional distinction between concurrency and parallelism, this dissertation finds that parallel programming concepts benefit from performance-related VM support, while concurrent programming concepts benefit from VM support that guarantees correct semantics in the presence of reflection, mutable state, and interaction with other languages and libraries. Focusing on these concurrent programming concepts, this dissertation finds that a VM needs to provide mechanisms for managed state, managed execution, ownership, and controlled enforcement. Based on these requirements, this dissertation proposes an ownership-based metaobject protocol (OMOP) to build novel multi-language VMs with proper concurrent programming support. This dissertation demonstrates the OMOP's benefits by building concurrent programming concepts such as agents, software transactional memory, actors, active objects, and communicating sequential processes on top of the OMOP. The performance evaluation shows that OMOP-based implementations of concurrent programming concepts can reach performance on par with that of their conventionally implemented counterparts if the OMOP is supported by the VM. To conclude, the OMOP proposed in this dissertation provides a unifying and minimal substrate to support concurrent programming on top of multi-language VMs. The OMOP enables language implementers to correctly implement language semantics, while simultaneously enabling VMs to provide efficient implementations.},
      added-at = {2013-01-15T23:27:17.000+0100},
      address = {Pleinlaan 2, B-1050 Brussels, Belgium},
      author = {Marr, Stefan},
      biburl = {http://www.bibsonomy.org/bibtex/23ffcd10c078075ce8acfd048c6ebb397/gron},
      interhash = {2a637e553d371aa60c7da444baefb1d1},
      intrahash = {3ffcd10c078075ce8acfd048c6ebb397},
      isbn = {978-90-5718-256-3},
      keywords = {Concurrency Domains MOP MeMyPublication MetaObjectProtocol OMOP Ownership VMs VirtualMachine myown},
      month = {January},
      pdf = {http://www.stefan-marr.de/downloads/marr-phd-2013-supporting-concurrency-abstractions-in-high-level-language-virtual-machines.pdf},
      publisher = {VUBPress},
      school = {Software Languages Lab, Vrije Universiteit Brussel},
      timestamp = {2013-02-16T18:16:51.000+0100},
      title = {Supporting Concurrency Abstractions in High-level Language Virtual Machines},
      url = {http://www.stefan-marr.de/2013/01/supporting-concurrency-abstractions-in-high-level-language-virtual-machines/},
      year = 2013 }

2012

  • J. De Koster, S. Marr, and T. D’Hondt, "Synchronization Views for Event-loop Actors," in Proceedings of the 17th ACM SIGPLAN symposium on Principles and Practice of Parallel Programming, New York, NY, USA, 2012, pp. 317-318. bibtex (pdf) (doi) Go to document
    @inproceedings{SyncViewsPoster, abstract = {The actor model has already proven itself as an interesting concurrency model that avoids issues such as deadlocks and race conditions by construction, and thus facilitates concurrent programming. The tradeoff is that it sacrifices expressiveness and efficiency especially with respect to data parallelism. However, many standard solutions to computationally expensive problems employ data parallel algorithms for better performance on parallel systems. We identified three problems that inhibit the use of data-parallel algorithms within the actor model. Firstly, one of the main properties of the actor model, the fact that no data is shared, is one of the most severe performance bottlenecks. Especially the fact that shared state can not be read truly in parallel. Secondly, the actor model on its own does not provide a mechanism to specify extra synchronization conditions on batches of messages which leads to event-level data-races. And lastly, programmers are forced to write code in a continuation-passing style (CPS) to handle typical request-response situations. However, CPS breaks the sequential flow of the code and is often hard to understand, which increases complexity and lowers maintainability. We proposes \emph{synchronization views} to solve these three issues without compromising the semantic properties of the actor model. Thus, the resulting concurrency model maintains deadlock-freedom, avoids low-level race conditions, and keeps the semantics of macro-step execution.},
      added-at = {2011-12-24T13:31:50.000+0100},
      address = {New York, NY, USA},
      author = {De Koster, Joeri and Marr, Stefan and D'Hondt, Theo},
      biburl = {http://www.bibsonomy.org/bibtex/222ee75102212d0b030d513d742e45fdc/gron},
      booktitle = {Proceedings of the 17th ACM SIGPLAN symposium on Principles and Practice of Parallel Programming},
      description = {http://doi.acm.org/10.1145/2145816.2145873},
      doi = {10.1145/2145816.2145873},
      interhash = {e727f9c6a21c1e3b6370fbf9db8b7e35},
      intrahash = {22ee75102212d0b030d513d742e45fdc},
      keywords = {ActPigoo Actors Concurrency MeMyPublication Parallelism ReaderWriter Synchronization Views myown},
      month = {February},
      note = {(Poster)},
      pages = {317--318},
      pdf = {http://soft.vub.ac.be/~smarr/downloads/ppopp12-dekoster-synchronization-views-for-event-loop-actors.pdf},
      publisher = {ACM},
      series = {PPoPP '12},
      timestamp = {2013-02-16T19:42:28.000+0100},
      title = {Synchronization Views for Event-loop Actors},
      url = {http://www.stefan-marr.de/2011/12/synchronization-views-for-event-loop-actors/},
      year = 2012 }
  • S. Marr, J. Nicolay, T. Van Cutsem, and T. D’Hondt, "Modularity and Conventions for Maintainable Concurrent Language Implementations: A Review of Our Experiences and Practices," in Proceedings of the 2nd Workshop on Modularity In Systems Software (MISS’2012), 2012. bibtex (pdf) (doi) Go to document
    @inproceedings{MISS2012, abstract = {In this paper, we review what we have learned from implementing languages for parallel and concurrent programming, and investigate the role of modularity. To identify the approaches used to facilitate correctness and maintainability, we ask the following questions: What guides modularization? Are informal approaches used to facilitate correctness? Are concurrency concerns modularized? And, where is language support lacking most? Our subjects are AmbientTalk, SLIP, and the RoarVM. All three evolved over the years, enabling us to look back at specific experiments to understand the impact of concurrency on modularity. We conclude from our review that concurrency concerns are one of the strongest drivers for the definition of module boundaries. It helps when languages offer sophisticated modularization constructs. However, with respect to concurrency, other language features like single-assignment are of greater importance. Furthermore, tooling that enables remodularization taking concurrency invariants into account would be of great value.},
      acmid = {2162031},
      added-at = {2012-01-24T12:25:07.000+0100},
      author = {Marr, Stefan and Nicolay, Jens and Van Cutsem, Tom and D'Hondt, Theo},
      biburl = {http://www.bibsonomy.org/bibtex/2442f0063842536e3628d10a4244620b6/gron},
      booktitle = {Proceedings of the 2nd Workshop on Modularity In Systems Software (MISS'2012)},
      doi = {10.1145/2162024.2162031},
      interhash = {f6aa985b183f15b014127ac282ce73d5},
      intrahash = {442f0063842536e3628d10a4244620b6},
      isbn = {978-1-4503-1217-2},
      keywords = {CaseStudy Concurrency ExperienceReport Interpreters MeMyPublication Modularity Parallelism VMs myown},
      location = {Potsdam, Germany},
      month = {March},
      numpages = {6},
      pdf = {http://www.stefan-marr.de/downloads/miss12-smarr-et-al-modularity-and-conventions-for-maintainable-concurrent-language-implementations.pdf},
      publisher = {ACM},
      series = {MISS'12},
      timestamp = {2013-02-16T19:43:22.000+0100},
      title = {Modularity and Conventions for Maintainable Concurrent Language Implementations: A Review of Our Experiences and Practices},
      url = {http://www.stefan-marr.de/2012/01/modularity-and-conventions-for-maintainable-concurrent-language-implementations-a-review-of-our-experiences-and-practices/},
      year = 2012 }
  • S. Marr and T. D’Hondt, "Identifying A Unifying Mechanism for the Implementation of Concurrency Abstractions on Multi-Language Virtual Machines," in Objects, Models, Components, Patterns, 50th International Conference, TOOLS 2012, Berlin / Heidelberg, 2012, pp. 171-186. bibtex (pdf) (doi) Go to document
    @inproceedings{MOP_TOOLS, abstract = {Supporting all known abstractions for concurrent and parallel programming in a virtual machines (VM) is a futile undertaking, but it is required to give programmers appropriate tools and performance. Instead of supporting all abstractions directly, VMs need a unifying mechanism similar to \texttt{INVOKEDYNAMIC} for JVMs. Our survey of parallel and concurrent programming concepts identifies concurrency abstractions as the ones benefiting most from support in a VM. Currently, their semantics is often weakened, reducing their engineering benefits. They require a mechanism to define flexible language guarantees. Based on this survey, we define an ownership-based meta-object protocol as candidate for VM support. We demonstrate its expressiveness by implementing actor semantics, software transactional memory, agents, CSP, and active objects. While the performance of our prototype confirms the need for VM support, it also shows that the chosen mechanism is appropriate to express a wide range of concurrency abstractions in a unified way.},
      acceptancerate = {0.31},
      added-at = {2012-03-09T11:39:29.000+0100},
      address = {Berlin / Heidelberg},
      author = {Marr, Stefan and D'Hondt, Theo},
      biburl = {http://www.bibsonomy.org/bibtex/2534230490269cbc736c0c6c510686b3b/gron},
      booktitle = {Objects, Models, Components, Patterns, 50th International Conference, TOOLS 2012},
      doi = {10.1007/978-3-642-30561-0_13},
      interhash = {e95335bd7d37bc29f2bb45e9ad362572},
      intrahash = {534230490269cbc736c0c6c510686b3b},
      isbn = {978-3-642-30560-3},
      keywords = {Abstraction Concurrency LanguageSupport MeMyPublication Parallelism VirtualMachine myown},
      month = may, note = {(acceptance rate 31%)},
      pages = {171-186},
      pdf = {http://www.stefan-marr.de/downloads/tools12-smarr-dhondt-identifying-a-unifying-mechanism-for-the-implementation-of-concurrency-abstractions-on-multi-language-virtual-machines.pdf},
      publisher = {Springer},
      series = {Lecture Notes in Computer Science},
      timestamp = {2015-11-14T23:10:13.000+0100},
      title = {Identifying A Unifying Mechanism for the Implementation of Concurrency Abstractions on Multi-Language Virtual Machines},
      url = {http://www.stefan-marr.de/2012/03/identifying-a-unifying-mechanism-for-the-implementation-of-concurrency-abstractions-on-multi-language-virtual-machines/},
      volume = 7304, year = 2012 }
  • T. Renaux, L. Hoste, S. Marr, and W. De Meuter, "Parallel Gesture Recognition with Soft Real-Time Guarantees," in Proceedings of the 2nd edition on Programming Systems, Languages and Applications based on Actors, Agents, and Decentralized Control Abstractions, 2012, pp. 35-46. bibtex (pdf) (doi) Go to document
    @inproceedings{renaux2012parte, abstract = {Applying imperative programming techniques to process event streams, like those generated by multi-touch devices and 3D cameras, has significant engineering drawbacks. Declarative approaches solve these problems but have not been able to scale on multicore systems while providing guaranteed response times.

    We propose PARTE, a parallel scalable complex event processing engine which allows a declarative definition of event patterns and provides soft real-time guarantees for their recognition. It extends the state-saving Rete algorithm and maps the event matching onto a graph of actor nodes. Using a tiered event matching model, PARTEprovides upper bounds on the detection latency. Based on the domain-specific constraints, PARTE's design relies on a combination of 1) lock-free data structures; 2) safe memory management techniques; and 3) message passing between Rete nodes. In our benchmarks, we measured scalability up to 8 cores, outperforming highly optimized sequential implementations.},
      acmid = {2414646},
      added-at = {2012-09-30T21:36:43.000+0200},
      author = {Renaux, Thierry and Hoste, Lode and Marr, Stefan and De Meuter, Wolfgang},
      biburl = {http://www.bibsonomy.org/bibtex/2c1c4eb8dd3e5c14161c2fe9bab8a865b/gron},
      booktitle = {Proceedings of the 2nd edition on Programming Systems, Languages and Applications based on Actors, Agents, and Decentralized Control Abstractions},
      doi = {10.1145/2414639.2414646},
      interhash = {97c79f5ee7d0e355dcb0ebb862fd5bd5},
      intrahash = {c1c4eb8dd3e5c14161c2fe9bab8a865b},
      isbn = {978-1-4503-1630-9},
      keywords = {MeMyPublication actors dataflow guarantees myown realtime rete},
      location = {Tucson, Arizona, USA},
      month = {October},
      numpages = {12},
      pages = {35--46},
      pdf = {http://www.stefan-marr.de/downloads/agere12-parallel-gesture-recognition-with-soft-real-time-guarantees.pdf},
      series = {SPLASH '12 Workshops},
      timestamp = {2013-02-16T19:45:16.000+0100},
      title = {Parallel Gesture Recognition with Soft Real-Time Guarantees},
      url = {http://www.stefan-marr.de/2013/01/parallel-gesture-recognition-with-soft-real-time-guarantees/},
      year = 2012 }

2011

  • M. Haupt, S. Marr, and R. Hirschfeld, "CSOM/PL: A Virtual Machine Product Line*," Hasso Plattner Institute, Am Neuen Palais 10, 14469 Potsdam, 48, 2011. bibtex (pdf) Go to document
    @techreport{CSOMPL_TR, abstract = {CSOM/PL is a software product line (SPL) derived from applying multi-dimensional separation of concerns (MDSOC) techniques to the domain of high-level language virtual machine (VM) implementations. For CSOM/PL, we modularised CSOM, a Smalltalk VM implemented in C, using VMADL (virtual machine architecture description language). Several features of the original CSOM were encapsulated in VMADL modules and composed in various combinations. In an evaluation of our approach, we show that applying MDSOC and SPL principles to a domain as complex as that of VMs is not only feasible but beneficial, as it improves understandability, maintainability, and configurability of VM implementations without harming performance.},
      added-at = {2011-07-27T17:59:15.000+0200},
      address = {Am Neuen Palais 10, 14469 Potsdam},
      author = {Haupt, Michael and Marr, Stefan and Hirschfeld, Robert},
      biburl = {http://www.bibsonomy.org/bibtex/26ce830821a88a512aa679299a493dc8d/gron},
      day = 18, description = {issn = { 1613-5652 },
      isbn = { 978-3-86956-134-9 },
      pdf = {http://www.hpi.uni-potsdam.de/fileadmin/hpi/source/Technische_Berichte/HPI_48_CSOM_PL_A_Virtual_Machine_Product_Line.pdf}},
      institution = {Hasso Plattner Institute },
      interhash = {b739ed923a0c65e0a687575c5ae724b3},
      intrahash = {6ce830821a88a512aa679299a493dc8d},
      keywords = {AOP Architecture ArchitectureLanguage CSOM MasterThesis MeMyPublication Modularization Productline VirtualMachine aspect-oriented myown services},
      month = {April},
      number = 48, pages = 26, publisher = {Universitätsverlag Potsdam},
      timestamp = {2014-05-13T17:14:56.000+0200},
      title = {CSOM/PL: A Virtual Machine Product Line*},
      url = {http://www.amazon.de/CSOM-PL-virtual-machine-product/dp/3869561343},
      year = 2011 }
  • S. Marr, M. De Wael, M. Haupt, and T. D’Hondt, "Which Problems Does a Multi-Language Virtual Machine Need to Solve in the Multicore/Manycore Era?," in Proceedings of the 5th Workshop on Virtual Machines and Intermediate Languages, 2011, pp. 341-348. bibtex (pdf) (doi) Go to document
    @inproceedings{VMIL11, abstract = {While parallel programming for very regular problems has been used in the scientific community by non-computer-scientists successfully for a few decades now, concurrent programming and solving irregular problems remains hard. Furthermore, we shift from few expert system programmers mastering concurrency for a constrained set of problems to mainstream application developers being required to master concurrency for a wide variety of problems. Consequently, high-level language virtual machine (VM) research faces interesting questions. What are processor design changes that have an impact on the abstractions provided by VMs to provide platform independence? How can application programmers' diverse needs be facilitated to solve concurrent programming problems? We argue that VMs will need to be ready for a wide range of different concurrency models that allow solving concurrency problems with appropriate abstractions. Furthermore, they need to abstract from heterogeneous processor architectures, varying performance characteristics, need to account for memory access cost and inter-core communication mechanisms but should only expose the minimal useful set of notions like locality, explicit communication, and adaptable scheduling to maintain their abstracting nature. Eventually, language designers need to be enabled to guarantee properties like encapsulation, scheduling guarantees, and immutability also when an interaction between different problem-specific concurrency abstractions is required.},
      acmid = {2095104},
      added-at = {2011-09-27T23:44:38.000+0200},
      author = {Marr, Stefan and De Wael, Mattias and Haupt, Michael and D'Hondt, Theo},
      biburl = {http://www.bibsonomy.org/bibtex/2f67c508d81780a9a7e987cb4f5bdaeda/gron},
      booktitle = {Proceedings of the 5th Workshop on Virtual Machines and Intermediate Languages},
      doi = {10.1145/2095050.2095104},
      interhash = {a4cd5f8252cc120bc766688434d535fa},
      intrahash = {f67c508d81780a9a7e987cb4f5bdaeda},
      isbn = {978-1-4503-1183-0},
      keywords = {Concurrency Encapsulation ManyCore MeMyPublication MultiCore PositionPaper Scheduling Survey VMIL VMs myown},
      location = {Portland, Oregon, USA},
      month = {October},
      numpages = {8},
      pages = {341--348},
      pdf = {http://www.stefan-marr.de/downloads/vmil11-smarr-et-al-which-problems-does-a-multi-language-virtual-machine-need-to-solve-in-the-multicore-manycore-era.pdf},
      publisher = {ACM},
      series = {VMIL '11},
      timestamp = {2013-02-16T19:41:36.000+0100},
      title = {Which Problems Does a Multi-Language Virtual Machine Need to Solve in the Multicore/Manycore Era?},
      url = {http://www.stefan-marr.de/2011/09/which-problems-does-a-multi-language-virtual-machine-need-to-solve-in-the-multicoremanycore-era/},
      year = 2011 }
  • Marr, Stefan and Ungar, David and D’Hondt, Theo, Evolving A Virtual Machine to Execute Applications Fully in Parallel: Approaching the Multi- and Manycore Challenge with a Simplified Design, 2011. bibtex
    @unpublished{marr2011evolving, added-at = {2012-07-17T14:33:14.000+0200},
      author = {Marr, Stefan and Ungar, David and D'Hondt, Theo},
      biburl = {http://www.bibsonomy.org/bibtex/211636c2dbca224016e63efe65e8c6cfc/gron},
      interhash = {959d45151e16ba1939e8e5ef03dca641},
      intrahash = {11636c2dbca224016e63efe65e8c6cfc},
      keywords = {MeMyPublication Unpublished myown},
      month = may, note = {(unpublished)},
      timestamp = {2013-02-16T18:13:40.000+0100},
      title = {Evolving A Virtual Machine to Execute Applications Fully in Parallel: Approaching the Multi- and Manycore Challenge with a Simplified Design},
      year = 2011 }
  • M. Haupt, S. Marr, and R. Hirschfeld, "CSOM/PL: A Virtual Machine Product Line," Journal of Object Technology, vol. 10, iss. 12, pp. 1-30, 2011. bibtex (pdf) (doi) Go to document
    @article{CSOMPL_JOT, abstract = {CSOM/PL is a software product line (SPL) derived from applying multi-dimensional separation of concerns (MDSOC) techniques to the domain of high-level language virtual machine (VM) implementations. For CSOM/PL, we modularised CSOM, a Smalltalk VM implemented in C, using VMADL (virtual machine architecture description language). Several features of the original CSOM were encapsulated in VMADL modules and composed in various combinations. In an evaluation of our approach, we show that applying MDSOC and SPL principles to a domain as complex as that of VMs is not only feasible but beneficial, as it improves understandability, maintainability, and configurability of VM implementations without harming performance. },
      added-at = {2011-10-14T15:47:10.000+0200},
      author = {Haupt, Michael and Marr, Stefan and Hirschfeld, Robert},
      biburl = {http://www.bibsonomy.org/bibtex/2410111b6472d242e566afe4d27c3b7de/gron},
      doi = {10.5381/jot.2011.10.1.a12},
      interhash = {b739ed923a0c65e0a687575c5ae724b3},
      intrahash = {410111b6472d242e566afe4d27c3b7de},
      issn = {1660-1769},
      journal = {Journal of Object Technology},
      keywords = {AOP CSOM FOP Interpreters MeMyPublication Modularization VirtualMachine myown},
      number = 12, pages = {1-30},
      pdf = {http://www.stefan-marr.de/downloads/jot11-mhaupt-csompl-a-virtual-machine-product-line.pdf},
      timestamp = {2013-02-16T19:40:24.000+0100},
      title = {CSOM/PL: A Virtual Machine Product Line},
      url = {http://www.stefan-marr.de/2011/12/csompl-a-virtual-machine-product-line/},
      volume = 10, year = 2011 }

2010

  • M. Haupt, R. Hirschfeld, T. Pape, G. Gabrysiak, S. Marr, A. Bergmann, A. Heise, M. Kleine, and R. Krahn, "The SOM Family: Virtual Machines for Teaching and Research," in Proceedings of the 15th Annual Conference on Innovation and Technology in Computer Science Education (ITiCSE), 2010, pp. 18-22. bibtex (pdf) (doi) Go to document
    @inproceedings{SOMFamily, abstract = {This paper introduces the SOM (Simple Object Machine) family of virtual machine (VM) implementations. Starting from a Java-based implementation, several ports of the VM to different programming languages have been developed and put to successful use in teaching at both undergraduate and graduate levels since 2006. Moreover, the VMs have been used in various research projects. We document the rationale behind each of the SOM VMs and results that have been achieved in teaching and research.},
      acceptancerate = {0.51},
      added-at = {2010-07-06T13:06:37.000+0200},
      author = {Haupt, Michael and Hirschfeld, Robert and Pape, Tobias and Gabrysiak, Gregor and Marr, Stefan and Bergmann, Arne and Heise, Arvid and Kleine, Matthias and Krahn, Robert},
      biburl = {http://www.bibsonomy.org/bibtex/271f674a8a2bc44dd50dbe7ac9b4be344/gron},
      booktitle = {Proceedings of the 15th Annual Conference on Innovation and Technology in Computer Science Education (ITiCSE)},
      day = {26--30},
      doi = {10.1145/1822090.1822098},
      interhash = {60d5f63bfbb8aad1fddc8fedff16c905},
      intrahash = {71f674a8a2bc44dd50dbe7ac9b4be344},
      isbn = {978-1-60558-729-5},
      keywords = {CSOM MeMyPublication SOM Teaching VM myown},
      location = {Bilkent, Ankara, Turkey},
      month = {June},
      note = {(acceptance rate 51%)},
      pages = {18--22},
      pdf = {http://www.hpi.uni-potsdam.de/hirschfeld/publications/media/HauptHirschfeldPapeGabrysiakMarrBergmannHeiseKleineKrahn_2010_TheSomFamily_AcmDL.pdf},
      publisher = {ACM Press},
      timestamp = {2015-11-14T23:24:30.000+0100},
      title = {The SOM Family: Virtual Machines for Teaching and Research},
      url = {http://www.hpi.uni-potsdam.de/hirschfeld/publications/media/HauptHirschfeldPapeGabrysiakMarrBergmannHeiseKleineKrahn_2010_TheSomFamily_AcmDL.pdf},
      year = 2010 }
  • S. Marr, M. Haupt, S. Timbermont, B. Adams, T. D’Hondt, P. Costanza, and W. De Meuter, "Virtual Machine Support for Many-Core Architectures: Decoupling Abstract From Concrete Concurrency Models," in Second International Workshop on Programming Languages Approaches to Concurrency and Communication-cEntric Software, York, UK, 2010, pp. 63-77. bibtex (pdf) (doi) Go to document
    @inproceedings{places09, abstract = {The upcoming many-core architectures require software developers to exploit concurrency to utilize available computational power. Today's high-level language virtual machines (VMs), which are a cornerstone of software development, do not provide sufficient abstraction for concurrency concepts. We analyze concrete and abstract concurrency models and identify the challenges they impose for VMs. To provide sufficient concurrency support in VMs, we propose to integrate concurrency operations into VM instruction sets. Since there will always be VMs optimized for special purposes, our goal is to develop a methodology to design instruction sets with concurrency support. Therefore, we also propose a list of trade-offs that have to be investigated to advise the design of such instruction sets. As a first experiment, we implemented one instruction set extension for shared memory and one for non-shared memory concurrency. From our experimental results, we derived a list of requirements for a full-grown experimental environment for further research.},
      added-at = {2010-03-03T13:20:01.000+0100},
      address = {York, UK},
      author = {Marr, Stefan and Haupt, Michael and Timbermont, Stijn and Adams, Bram and D'Hondt, Theo and Costanza, Pascal and De Meuter, Wolfgang},
      biburl = {http://www.bibsonomy.org/bibtex/288f7f1a18d61f2db356e0658d392215c/gron},
      booktitle = {Second International Workshop on Programming Languages Approaches to Concurrency and Communication-cEntric Software},
      doi = {10.4204/EPTCS.17.6},
      interhash = {951ffceb7deb0e7a0880a89ac3df470b},
      intrahash = {88f7f1a18d61f2db356e0658d392215c},
      keywords = {MeMyPublication myown},
      month = {February},
      pages = {63-77},
      pdf = {http://arxiv.org/pdf/1002.0939v1},
      series = {Electronic Proceedings in Theoretical Computer Science},
      timestamp = {2013-02-16T19:31:08.000+0100},
      title = {Virtual Machine Support for Many-Core Architectures: Decoupling Abstract From Concrete Concurrency Models},
      url = {http://www.stefan-marr.de/2010/02/virtual-machine-support-for-many-core-architectures-decoupling-abstract-from-concrete-concurrency-models/},
      volume = 17, year = 2010 }
  • S. Marr, "Encapsulation And Locality: A Foundation for Concurrency Support in Multi-Language Virtual Machines?," in SPLASH ’10: Proceedings of the ACM International Conference Companion on Object Oriented Programming Systems Languages and Applications Companion, New York, NY, USA, 2010, pp. 221-222. bibtex (pdf) (doi) Go to document
    @inproceedings{SplashDocSymp2010, abstract = {We propose to search for common abstractions for different concurrency models to enable high-level language virtual machines to support a wide range of different concurrency models. This would enable domain-specific solutions for the concurrency problem. Furthermore, advanced knowledge about concurrency in the VM model will most likely lead to better implementation opportunities on top of the different upcoming many-core architectures. The idea is to investigate the concepts of encapsulation and locality to this end. Thus, we are going to experiment with different language abstractions for concurrency on top of a virtual machine, which supports encapsulation and locality, to see how language designers could benefit, and how virtual machines could optimize programs using these concepts.},
      added-at = {2010-11-01T02:12:16.000+0100},
      address = {New York, NY, USA},
      author = {Marr, Stefan},
      biburl = {http://www.bibsonomy.org/bibtex/2ffe71139af84c53ef5f448d4137bc943/gron},
      booktitle = {SPLASH '10: Proceedings of the ACM International Conference Companion on Object Oriented Programming Systems Languages and Applications Companion},
      day = {17-21},
      doi = {10.1145/1869542.1869583},
      interhash = {0a2db296019a5c54a8711b76dd6fd06e},
      intrahash = {ffe71139af84c53ef5f448d4137bc943},
      isbn = {978-1-4503-0240-1},
      keywords = {Abstraction Concurrency ManyCore MeMyPublication Proposal VM myown},
      location = {Reno/Tahoe, Nevada, USA},
      month = {October},
      pages = {221--222},
      pdf = {http://www.stefan-marr.de/downloads/docsymp-smarr.pdf},
      publisher = {ACM},
      timestamp = {2013-02-16T19:36:44.000+0100},
      title = {Encapsulation And Locality: A Foundation for Concurrency Support in Multi-Language Virtual Machines?},
      type = {Doctoral Symposium},
      url = {http://www.stefan-marr.de/2010/07/doctoral-symposium-at-splash-2010/},
      year = 2010 }
  • S. Marr, S. Verhaegen, B. De Fraine, T. D’Hondt, and W. De Meuter, "Insertion Tree Phasers: Efficient and Scalable Barrier Synchronization for Fine-grained Parallelism," in Proceedings of the 12th IEEE International Conference on High Performance Computing and Communications, 2010, pp. 130-137. bibtex (pdf) (doi) Go to document
    @inproceedings{InsertionTreePhasers, abstract = {This paper presents an algorithm and a data structure for scalable dynamic synchronization in fine-grained parallelism. The algorithm supports the full generality of phasers with dynamic, two-phase, and point-to-point synchronization. It retains the scalability of classical tree barriers, but provides unbounded dynamicity by employing a tailor-made insertion tree data structure. It is the first completely documented implementation strategy for a scalable phaser synchronization construct. Our evaluation shows that it can be used as a drop-in replacement for classic barriers without harming performance, despite its additional complexity and potential for performance optimizations. Furthermore, our approach overcomes performance and scalability limitations which have been present in other phaser proposals.},
      added-at = {2010-09-22T15:13:52.000+0200},
      author = {Marr, Stefan and Verhaegen, Stijn and De Fraine, Bruno and D'Hondt, Theo and De Meuter, Wolfgang},
      biburl = {http://www.bibsonomy.org/bibtex/2e0e488ee39b6fcbeedb6f7d221df958a/gron},
      booktitle = {Proceedings of the 12th IEEE International Conference on High Performance Computing and Communications},
      doi = {10.1109/HPCC.2010.30},
      interhash = {db46bfb816422a5055237a1b387e3dfe},
      intrahash = {e0e488ee39b6fcbeedb6f7d221df958a},
      isbn = {978-0-7695-4214-0},
      keywords = {Barrier MeMyPublication Phasers X10 algorithm benchmarks clocks evaluation habanero insertionTree myown tree},
      month = {September},
      note = {Best Student Paper AwardAcceptance Rate: 19,1% (58/304)},
      pages = {130-137},
      pdf = {http://www.stefan-marr.de/downloads/hpcc2010-marr-etal-insertion-tree-phasers.pdf},
      publisher = {IEEE Computer Society},
      timestamp = {2014-01-17T14:42:47.000+0100},
      title = {Insertion Tree Phasers: Efficient and Scalable Barrier Synchronization for Fine-grained Parallelism},
      url = {http://www.stefan-marr.de/2010/07/insertion-tree-phasers-efficient-and-scalable-barrier-synchronization-for-fine-grained-parallelism/},
      year = 2010 }
  • Van Cutsem, Tom and Marr, Stefan and De Meuter, Wolfgang, A Language-oriented Approach to Teaching ConcurrencySPLASH’10, Reno, Nevada, USA: , 2010. bibtex (pdf) Go to document
    @presentation{MulticoreProgramming, abstract = {This paper argues in favour of a language-oriented approach to teach the principles of concurrency to graduate students. Over the past years, the popularity of programming lan- guages that promote a functional programming style has steadily grown. We want to promote the use of such lan- guages as the appropriate basic tools to deal with the “mul- ticore revolution”. We describe some of these programming languages and highlight two of them: Erlang and Clojure. We use these languages in a new graduate-level course that we will teach starting next academic year. Our goal is not to convince the reader that Erlang and Clojure are the best possible choices among this pool of candidate languages. Rather, our goal is to promote a functional programming style to tackle concurrency issues, and to teach this style in a programming language that makes it easy, straightforward and convenient to use that style. We do not want to get bogged down in a discussion on the usefulness or importance of learning new programming languages. For a good summary of the diverse advantages of studying new programming languages, we refer to a recent white paper by the ACM SIGPLAN education board [6].},
      added-at = {2010-11-07T14:16:16.000+0100},
      address = {SPLASH'10, Reno, Nevada, USA},
      author = {{Van Cutsem},
      Tom and Marr, Stefan and {De Meuter},
      Wolfgang},
      biburl = {http://www.bibsonomy.org/bibtex/2d34bf3515af0d293bdc98e727d4ef2a5/gron},
      booktitle = {Workshop on Curricula for Concurrency and Parallelism},
      day = 17, interhash = {766ec8b17c02daf69cccbf74ac981032},
      intrahash = {d34bf3515af0d293bdc98e727d4ef2a5},
      keywords = {MeMyPublication clojure concurrency course erlang immutability myown parallelism teaching},
      month = {October},
      pages = 3, pdf = {http://soft.vub.ac.be/Publications/2010/vub-tr-soft-10-12.pdf},
      timestamp = {2013-02-16T19:38:15.000+0100},
      title = {A Language-oriented Approach to Teaching Concurrency},
      url = {http://soft.vub.ac.be/Publications/2010/vub-tr-soft-10-12.pdf},
      year = 2010 }
  • S. Marr and T. D’Hondt, "Many-Core Virtual Machines: Decoupling Abstract from Concrete Concurrency," in SPLASH ’10: Proceedings of the ACM International Conference Companion on Object Oriented Programming Systems Languages and Applications Companion, 2010, pp. 239-240. bibtex (pdf) (doi) Go to document
    @inproceedings{SplashPoster2010, abstract = {We propose to search for common abstractions for concurrency models to enable multi-language virtual machines to support a wide range of them. This would enable domain-specific solutions for concurrency problems. Furthermore, such an abstraction could improve portability of virtual machines to the vastly different upcoming many-core architectures.},
      added-at = {2010-11-01T02:08:40.000+0100},
      author = {Marr, Stefan and D'Hondt, Theo},
      biburl = {http://www.bibsonomy.org/bibtex/2479a17625b9786f51c8f7e8f24595fda/gron},
      booktitle = {SPLASH '10: Proceedings of the ACM International Conference Companion on Object Oriented Programming Systems Languages and Applications Companion},
      doi = {10.1145/1869542.1869593},
      interhash = {dd6e347dcdbd2585fd2fb1b279369252},
      intrahash = {479a17625b9786f51c8f7e8f24595fda},
      isbn = {978-1-4503-0240-1},
      keywords = {ManyCore MeMyPublication MultiCore Poster SPLASH machines myown virtual},
      location = {Reno/Tahoe, Nevada, USA},
      month = {October},
      note = {(Poster)},
      pages = {239--240},
      pdf = {http://www.stefan-marr.de/downloads/docsymp-smarr.pdf},
      timestamp = {2013-02-16T19:35:27.000+0100},
      title = {Many-Core Virtual Machines: Decoupling Abstract from Concrete Concurrency},
      url = {http://www.stefan-marr.de/2010/08/poster-at-splash10/},
      year = 2010 }

2009

  • H. Schippers, T. V. Cutsem, S. Marr, M. Haupt, and R. Hirschfeld, "Towards an Actor-based Concurrent Machine Model," in Proceedings of the Fourth Workshop on the Implementation, Compilation, Optimization of Object-Oriented Languages, Programs and Systems (ICOOOLPS), New York, NY, USA, 2009, pp. 4-9. bibtex (pdf) (doi) Go to document
    @inproceedings{TowardsACMM, abstract = {In this position paper we propose to extend an existing delegation-based machine model with concurrency primitives. The original machine model which is built on the concepts of objects, messages, and delegation, provides support for languages enabling multi-dimensional separation of concerns (MDSOC). We propose to extend this model with an actor-based concurrency model, allowing for both true parallelism as well as lightweight concurrency primitives such as coroutines. In order to demonstrate its expressiveness, we informally describe how three high-level languages supporting different concurrency models can be mapped onto our extended machine model. We also provide an outlook on the extended model's potential to support concurrency-related MDSOC features.},
      added-at = {2009-08-23T10:55:42.000+0200},
      address = {New York, NY, USA},
      author = {Schippers, Hans and Cutsem, Tom Van and Marr, Stefan and Haupt, Michael and Hirschfeld, Robert},
      biburl = {http://www.bibsonomy.org/bibtex/2f62f875aa5558a336acf130919b225dc/gron},
      booktitle = {Proceedings of the Fourth Workshop on the Implementation, Compilation, Optimization of Object-Oriented Languages, Programs and Systems (ICOOOLPS)},
      day = 6, doi = {10.1145/1565824.1565825},
      interhash = {6b2514a55e250ff8f88ac54a52b71323},
      intrahash = {f62f875aa5558a336acf130919b225dc},
      isbn = {978-1-60558-541-3},
      keywords = {Actors Concurrency Io Java MDSOC MachineModel MeMyPublication Salsa VM myown},
      location = {Genova, Italy},
      month = {July},
      pages = {4--9},
      pdf = {http://www.stefan-marr.de/downloads/icooolps09-schippers.pdf},
      publisher = {ACM},
      timestamp = {2013-02-16T19:20:14.000+0100},
      title = {Towards an Actor-based Concurrent Machine Model},
      url = {http://www.stefan-marr.de/2010/02/towards-an-actor-based-concurrent-machine-model/},
      year = 2009 }
  • S. Marr, M. Haupt, and T. D’Hondt, "Intermediate Language Design of High-level Language Virtual Machines: Towards Comprehensive Concurrency Support," in Proceedings of the 3rd Workshop on Virtual Machines and Intermediate Languages, New York, NY, USA, 2009, p. 3:1-3:2. bibtex (pdf) (doi) Go to document
    @inproceedings{VMIL09, abstract = {Today's major high-level language virtual machines (VMs) are becoming successful in being multi-language execution platforms, hosting a wide range of languages. With the transition from few-core to many-core processors, we argue that VMs will also have to abstract from concrete concurrency models at the hardware level, to be able to support a wide range of abstract concurrency models on a language level. To overcome the lack of sufficient abstractions for concurrency concepts in VMs, we proposed earlier to extend VM intermediate languages by special concurrency constructs. As a first step towards this goal, we try to fill a gap in the current literature and survey the intermediate language design of VMs. Our goal is to identify currently used techniques and principles as well as to gain an overview over the available concurrency related features in intermediate languages. Another aspect of interest is the influence of the particular target language, for which the VM is originally intended, on the intermediate language.},
      added-at = {2010-02-07T23:21:28.000+0100},
      address = {New York, NY, USA},
      author = {Marr, Stefan and Haupt, Michael and D'Hondt, Theo},
      biburl = {http://www.bibsonomy.org/bibtex/24cadae2ab990d54d761d2233f8a21505/gron},
      booktitle = {Proceedings of the 3rd Workshop on Virtual Machines and Intermediate Languages},
      doi = {10.1145/1711506.1711509},
      interhash = {2b7468ff600c441ea322f28dfdac938e},
      intrahash = {4cadae2ab990d54d761d2233f8a21505},
      isbn = {978-1-60558-874-2},
      keywords = {Bytecode Concurrency Design InstructionSet IntermediateLanguage Language Machines MeMyPublication Survey Virtual myown},
      month = {October},
      note = {(extended abstract)},
      pages = {3:1--3:2},
      pdf = {http://www.stefan-marr.de/downloads/vmil09-smarr.pdf},
      publisher = {ACM},
      timestamp = {2013-02-16T19:29:13.000+0100},
      title = {Intermediate Language Design of High-level Language Virtual Machines: Towards Comprehensive Concurrency Support},
      url = {http://www.stefan-marr.de/2010/02/intermediate-language-design-of-high-level-language-virtual-machines-towards-comprehensive-concurrency-support/},
      year = 2009 }

2008

  • S. Marr, "Modularisierung Virtueller Maschinen," Master’s Dissertation , Potsdam, Germany, 2008. bibtex (pdf) Go to document
    @mastersthesis{MAThesis, added-at = {2009-04-12T23:57:52.000+0200},
      address = {Potsdam, Germany},
      author = {Marr, Stefan},
      biburl = {http://www.bibsonomy.org/bibtex/2b55cd84fb04798e86e1ed74d902e2755/gron},
      interhash = {5e1e1e699ff09e4ff0e9a15937aad116},
      intrahash = {b55cd84fb04798e86e1ed74d902e2755},
      keywords = {Me:MastersThesis MeMyPublication myown},
      month = {September},
      pdf = {http://soft.vub.ac.be/downloads/Masterarbeit-Modularisierung-virtueller-Maschinen.pdf},
      school = {Hasso Plattner Institute},
      timestamp = {2013-02-16T19:18:37.000+0100},
      title = {Modularisierung Virtueller Maschinen},
      url = {http://www.stefan-marr.de/2008/10/i-am-done-eventually/},
      year = 2008 }

Academic Services

Research Related Posts

Recently Read

  • G. L. Steele Jr. and J. Tristan, "Adding Approximate Counters," in Proceedings of the 21st ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, 2016, p. 15:1-15:12. bibtex (doi)
    @inproceedings{Steele:2016:AAC, abstract = {We describe a general framework for adding the values of two approximate counters to produce a new approximate counter value whose expected estimated value is equal to the sum of the expected estimated values of the given approximate counters. (To the best of our knowledge, this is the first published description of any algorithm for adding two approximate counters.) We then work out implementation details for five different kinds of approximate counter and provide optimized pseudocode. For three of them, we present proofs that the variance of a counter value produced by adding two counter values in this way is bounded, and in fact is no worse, or not much worse, than the variance of the value of a single counter to which the same total number of increment operations have been applied. Addition of approximate counters is useful in massively parallel divide-and-conquer algorithms that use a distributed representation for large arrays of counters. We describe two machine-learning algorithms for topic modeling that use millions of integer counters, and confirm that replacing the integer counters with approximate counters is effective, speeding up a GPU-based implementation by over 65% and a CPU-based by nearly 50%, as well as reducing memory requirements, without degrading their statistical effectiveness.},
      acmid = {2851147},
      added-at = {2016-05-02T10:52:21.000+0200},
      articleno = {15},
      author = {{Steele, Jr.},
      Guy L. and Tristan, Jean-Baptiste},
      biburl = {http://www.bibsonomy.org/bibtex/24f3494c6b49b96b4d1560de42a7bf252/gron},
      booktitle = {Proceedings of the 21st ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming},
      description = {Adding approximate counters},
      doi = {10.1145/2851141.2851147},
      interhash = {2808a208722a9a01801b41b9df29d453},
      intrahash = {4f3494c6b49b96b4d1560de42a7bf252},
      isbn = {978-1-4503-4092-2},
      keywords = {Approximation Concurrent Counter PPoPP Parallel Statistical Uncertainty},
      location = {Barcelona, Spain},
      numpages = {12},
      pages = {15:1--15:12},
      publisher = {ACM},
      series = {PPoPP '16},
      timestamp = {2016-05-02T10:52:21.000+0200},
      title = {Adding Approximate Counters},
      year = 2016 }
  • G. Wagner, P. Larsen, S. Brunthaler, and M. Franz, "Thinking Inside the Box: Compartmentalized Garbage Collection," ACM Trans. Program. Lang. Syst., vol. 38, iss. 3, p. 9:1-9:37, 2016. bibtex (doi) Go to document
    @article{Wagner:2016:TIB, abstract = {The web browser is the “new desktop.” Not only do many users spend most of their time using the browser, the browser has also become host to rich and dynamic applications that were previously tailored to each individual operating system. The lingua franca of web scripting, JavaScript, was pivotal in this development. Imagine that all desktop applications allocated memory from a single heap managed by the operating system. To reclaim memory upon application shutdown, all processes would then be garbage collected—not just the one being quit. While operating systems improved upon this approach long ago, this was how browsers managed memory until recently. This article explores compartmentalized memory management, an approach tailored specifically to web browsers. The idea is to partition the JavaScript heap into compartments and allocate objects to compartments based on their origin. All objects in the same compartment reference each other direct, whereas cross-origin references go through wrapper objects. We carefully evaluate our techniques using Mozilla’s Firefox browser—which now ships with our enhancements—and demonstrate the benefits of collecting each compartment independently. This simultaneously improves runtime performance (up to 36%) and reduces garbage collection pause times (up to 75%) as well as the memory footprint of the browser. In addition, enforcing the same-origin security policy becomes simple and efficient with compartments.},
      acmid = {2866576},
      added-at = {2016-04-12T17:33:34.000+0200},
      address = {New York, NY, USA},
      articleno = {9},
      author = {Wagner, Gregor and Larsen, Per and Brunthaler, Stefan and Franz, Michael},
      biburl = {http://www.bibsonomy.org/bibtex/27183befdc8628c8eea9c7f176b834ec4/gron},
      description = {Thinking Inside the Box},
      doi = {10.1145/2866576},
      interhash = {80f19df4453cf9d9ae2c486553a2e92c},
      intrahash = {7183befdc8628c8eea9c7f176b834ec4},
      issn = {0164-0925},
      issue_date = {April 2016},
      journal = {ACM Trans. Program. Lang. Syst.},
      keywords = {Compartments Firefox GC Memory Optimization SpiderMonkey},
      month = apr, number = 3, numpages = {37},
      pages = {9:1--9:37},
      publisher = {ACM},
      timestamp = {2016-04-12T17:33:34.000+0200},
      title = {Thinking Inside the Box: Compartmentalized Garbage Collection},
      url = {http://doi.acm.org/10.1145/2866576},
      volume = 38, year = 2016 }
  • T. Pape, T. Felgentreff, R. Hirschfeld, A. Gulenko, and C. F. Bolz, "Language-independent Storage Strategies for tracing-JIT-based Virtual Machines," in Proceedings of the 11th Symposium on Dynamic Languages, 2015, pp. 104-113. bibtex (doi)
    @inproceedings{Pape:2015:LSS, abstract = {Storage strategies have been proposed as a run-time optimization for the PyPy Python implementation and have shown promising results for optimizing execution speed and memory requirements. However, it remained unclear whether the approach works equally well in other dynamic languages. Furthermore, while PyPy is based on RPython, a language to write VMs with reusable components such as a tracing just-in-time compiler and garbage collection, the strategies design itself was not generalized to be reusable across languages implemented using that same toolchain. In this paper, we present a general design and implementation for storage strategies and show how they can be reused across different RPython-based languages. We evaluate the performance of our implementation for RSqueak, an RPython-based VM for Squeak/Smalltalk and show that storage strategies may indeed offer performance benefits for certain workloads in other dynamic programming languages.We furthermore evaluate the generality of our implementation by applying it to Topaz, a Ruby VM, and Pycket, a Racket implementation.},
      acmid = {2816716},
      added-at = {2016-03-23T14:56:33.000+0100},
      author = {Pape, Tobias and Felgentreff, Tim and Hirschfeld, Robert and Gulenko, Anton and Bolz, Carl Friedrich},
      biburl = {http://www.bibsonomy.org/bibtex/215ef1b7f3946e7338034119b251c7e61/gron},
      booktitle = {Proceedings of the 11th Symposium on Dynamic Languages},
      description = {Language-independent storage strategies for tracing-JIT-based virtual machines},
      doi = {10.1145/2816707.2816716},
      interhash = {677dd34c2cd720af6db7f93b2916dcd1},
      intrahash = {15ef1b7f3946e7338034119b251c7e61},
      isbn = {978-1-4503-3690-1},
      keywords = {Collections PyPy Strategies},
      location = {Pittsburgh, PA, USA},
      numpages = {10},
      pages = {104--113},
      publisher = {ACM},
      series = {DLS 2015},
      timestamp = {2016-03-23T14:56:33.000+0100},
      title = {Language-independent Storage Strategies for tracing-JIT-based Virtual Machines},
      year = 2015 }
  • F. Morandat, B. Hill, L. Osvald, and J. Vitek, "Evaluating the Design of the R Language: Objects and Functions for Data Analysis," in Proceedings of the 26th European Conference on Object-Oriented Programming, Berlin, Heidelberg, 2012, pp. 104-131. bibtex (doi)
    @inproceedings{Morandat:2012:EDR, abstract = {R is a dynamic language for statistical computing that combines lazy functional features and object-oriented programming. This rather unlikely linguistic cocktail would probably never have been prepared by computer scientists, yet the language has become surprisingly popular. With millions of lines of R code available in repositories, we have an opportunity to evaluate the fundamental choices underlying the R language design. Using a combination of static and dynamic program analysis we assess the success of different language features.},
      added-at = {2016-03-21T13:51:12.000+0100},
      address = {Berlin, Heidelberg},
      author = {Morandat, Flor{\'e}al and Hill, Brandon and Osvald, Leo and Vitek, Jan},
      biburl = {http://www.bibsonomy.org/bibtex/2e4e655aada3b72025288c43d8168486a/gron},
      booktitle = {Proceedings of the 26th European Conference on Object-Oriented Programming},
      description = {Evaluating the design of the R language},
      doi = {10.1007/978-3-642-31057-7_6},
      interhash = {07efa1b61cccba5e5f0fe92640eaa226},
      intrahash = {e4e655aada3b72025288c43d8168486a},
      isbn = {978-3-642-31056-0},
      keywords = {R Semantics},
      location = {Beijing, China},
      numpages = {28},
      pages = {104--131},
      publisher = {Springer-Verlag},
      series = {ECOOP'12},
      timestamp = {2016-03-21T13:51:12.000+0100},
      title = {Evaluating the Design of the R Language: Objects and Functions for Data Analysis},
      year = 2012 }
  • B. Daloze, C. Seaton, D. Bonetta, and H. Mössenböck, "Techniques and Applications for Guest-Language Safepoints," in Proceedings of the 10th International Workshop on Implementation, Compilation, Optimization of Object-Oriented Languages, Programs and Systems, 2015. bibtex
    @inproceedings{Daloze:2015:GLS, abstract = {Safepoints are a virtual machine mechanism that allows one thread to suspend other threads in a known state so that runtime actions can be performed without interruption and with data structures in a consistent state. Many virtual machines use safepoints as a mechanism to provide services such as stop-the-world garbage collection, debugging, and modification to running code such as installing or replacing classes. Languages implemented on these virtual machines may have access to these services, but not directly to the safepoint mechanism itself. We show that safepoints have many useful applications for the implementation of guest languages running on a virtual machine. We describe an API for using safepoints in languages that were implemented under the Truffle language implementation framework on the Java Virtual Machine and show several applications of the API to implement useful guest-language functionality. We present an efficient implementation of this API, when running in combination with the Graal dynamic compiler. We also demonstrate that our safepoints cause zero overhead with respect to peak performance and statistically insignificant overhead with respect to compilation time. We compare this to other techniques that could be used to implement the same functionality and demonstrate the large overhead that they incur.},
      added-at = {2016-03-21T12:08:59.000+0100},
      author = {Daloze, Benoit and Seaton, Chris and Bonetta, Daniele and Mössenböck, Hanspeter},
      biburl = {http://www.bibsonomy.org/bibtex/22c2f00f786ca71f479707adc7a91387e/gron},
      booktitle = {Proceedings of the 10th International Workshop on Implementation, Compilation, Optimization of Object-Oriented Languages, Programs and Systems},
      interhash = {3fee006434cfddb3ba67784499e5bea8},
      intrahash = {2c2f00f786ca71f479707adc7a91387e},
      keywords = {Concurrency JVM Safepoints Truffle},
      location = {Prague, Czech Republic},
      numpages = {10},
      series = {ICOOOLPS '15},
      timestamp = {2016-03-21T12:08:59.000+0100},
      title = {Techniques and Applications for Guest-Language Safepoints},
      year = 2015 }
more…