Stefan-Marr.de | Research

Research

Some thoughts about my current research as a PhD student.

My Publications

[2012,inproceedings] bibtex

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.

@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.}, 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)}, interhash = {f6aa985b183f15b014127ac282ce73d5}, intrahash = {442f0063842536e3628d10a4244620b6}, keywords = {CaseStudy Concurrency ExperienceReport Interpreters MeMyPublication Modularity Parallelism VMs myown}, month = {March}, note = {(to appear)}, publisher = {ACM}, series = {MISS'12}, timestamp = {2012-01-24T12:25:07.000+0100}, title = {Modularity and Conventions for Maintainable Concurrent Language Implementations: A Review of Our Experiences and Practices}, year = 2012 }
[2012,inproceedings] bibtex

J. De Koster, S. Marr, and T. D’Hondt, "Synchronization Views for Event-loop Actors," in Proceedings of PPoPP’12, 2012.

@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}, author = {De Koster, Joeri and Marr, Stefan and D'Hondt, Theo}, biburl = {http://www.bibsonomy.org/bibtex/2fe71bc6cb277972cdab0e9dac06d64e1/gron}, booktitle = {Proceedings of PPoPP'12}, interhash = {e727f9c6a21c1e3b6370fbf9db8b7e35}, intrahash = {fe71bc6cb277972cdab0e9dac06d64e1}, keywords = {ActPigoo Actors Concurrency MeMyPublication Parallelism ReaderWriter Synchronization Views myown}, timestamp = {2011-12-24T13:31:50.000+0100}, title = {Synchronization Views for Event-loop Actors}, url = {http://www.stefan-marr.de/downloads/ppopp12-dekoster-synchronization-views-for-event-loop-actors.pdf}, year = 2012 }
[2011,article] bibtex

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.

@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}, timestamp = {2011-10-14T15:47:10.000+0200}, title = {CSOM/PL: A Virtual Machine Product Line}, url = {http://www.jot.fm/contents/issue_2011_01/article12.html}, volume = 10, year = 2011 }
[2011,inproceedings] bibtex

S. Marr, M. D. 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, p. 5.

@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.}, added-at = {2011-09-27T23:44:38.000+0200}, author = {Marr, Stefan and Wael, Mattias De 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}, interhash = {a4cd5f8252cc120bc766688434d535fa}, intrahash = {f67c508d81780a9a7e987cb4f5bdaeda}, keywords = {Concurrency Encapsulation ManyCore MeMyPublication MultiCore PositionPaper Scheduling Survey VMIL VMs myown}, month = {October}, note = {(to appear)}, pages = 5, publisher = {ACM}, timestamp = {2011-09-27T23:44:38.000+0200}, title = {Which Problems Does a Multi-Language Virtual Machine Need to Solve in the Multicore/Manycore Era?}, year = 2011 }
[2011,techreport] bibtex

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.

@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 beneﬁcial, as it improves understandability, maintainability, and conﬁgurability 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 }, }, 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 = {2011-07-27T17:59:15.000+0200}, title = {CSOM/PL: A Virtual Machine Product Line}, url = {http://www.hpi.uni-potsdam.de/fileadmin/hpi/source/Technische_Berichte/HPI_48_CSOM_PL_A_Virtual_Machine_Product_Line.pdf}, year = 2011 }
[2010,presentation] bibtex

Van Cutsem, Tom and Marr, Stefan and De Meuter, Wolfgang, A Language-oriented Approach to Teaching ConcurrencySPLASH’10, Reno, Nevada, USA: , 2010.

@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, timestamp = {2010-11-07T14:16:16.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 }
[2010,inproceedings] bibtex

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.

@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}, publisher = {ACM}, timestamp = {2010-11-01T02:12:16.000+0100}, title = {Encapsulation And Locality: A Foundation for Concurrency Support in Multi-Language Virtual Machines?}, type = {Doctoral Symposium}, url = {http://portal.acm.org/citation.cfm?id=1869542.1869583&coll=GUIDE&dl=GUIDE&type=series&idx=SERIES318&part=series&WantType=Proceedings&title=OOPSLA%2FSPLASH&CFID=108019712&CFTOKEN=65617454}, year = 2010 }
[2010,inproceedings] bibtex

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.

@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}, pages = {239--240}, timestamp = {2010-11-01T02:08:40.000+0100}, title = {Many-Core Virtual Machines: Decoupling Abstract from Concrete Concurrency}, year = 2010 }
[2010,inproceedings] bibtex

S. Marr, S. Verhaegen, B. D. Fraine, T. D’Hondt, and W. D. 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.

@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 Fraine, Bruno De and D'Hondt, Theo and Meuter, Wolfgang De}, 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 Award Acceptance Rate: 19,1% (58/304)}, pages = {130-137}, publisher = {IEEE Computer Society}, timestamp = {2010-09-22T15:13:52.000+0200}, title = {Insertion Tree Phasers: Efficient and Scalable Barrier Synchronization for Fine-grained Parallelism}, url = {http://www.computer.org/portal/web/csdl/doi/10.1109/HPCC.2010.30}, year = 2010 }
[2010,inproceedings] bibtex

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.

@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.}, 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}, pages = {18--22}, publisher = {ACM Press}, timestamp = {2010-07-06T13:06:37.000+0200}, title = {The SOM Family: Virtual Machines for Teaching and Research}, url = {http://portal.acm.org/citation.cfm?id=1822098}, year = 2010 }
[2010,inproceedings] bibtex

S. Marr, M. Haupt, S. Timbermont, B. Adams, T. D’Hondt, P. Costanza, and W. D. 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.

@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 Meuter, Wolfgang De}, biburl = {http://www.bibsonomy.org/bibtex/288f7f1a18d61f2db356e0658d392215c/gron}, booktitle = {Second International Workshop on Programming Languages Approaches to Concurrency and Communication-cEntric Software}, interhash = {951ffceb7deb0e7a0880a89ac3df470b}, intrahash = {88f7f1a18d61f2db356e0658d392215c}, keywords = {MeMyPublication myown}, month = {February}, pages = {63-77}, series = {Electronic Proceedings in Theoretical Computer Science}, timestamp = {2010-03-03T13:20:01.000+0100}, title = {Virtual Machine Support for Many-Core Architectures: Decoupling Abstract From Concrete Concurrency Models}, url = {http://dx.doi.org/10.4204/EPTCS.17.6}, volume = 17, year = 2010 }
[2009,inproceedings] bibtex

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.

@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}, 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}, publisher = {ACM}, timestamp = {2010-02-07T23:21:28.000+0100}, title = {Intermediate Language Design of High-level Language Virtual Machines: Towards Comprehensive Concurrency Support}, url = {http://doi.acm.org/10.1145/1711506.1711509}, year = 2009 }
[2009,inproceedings] bibtex

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.

@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 = {http://doi.acm.org/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}, publisher = {ACM}, timestamp = {2009-08-23T10:55:42.000+0200}, title = {Towards an Actor-based Concurrent Machine Model}, url = {http://portal.acm.org/citation.cfm?doid=1565824.1565825}, year = 2009 }
[2008,mastersthesis] bibtex

S. Marr, "Modularisierung Virtueller Maschinen," Master’s Dissertation , Potsdam, Germany, 2008.

@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}, school = {Hasso Plattner Institute}, timestamp = {2009-04-12T23:57:52.000+0200}, title = {Modularisierung Virtueller Maschinen}, year = 2008 }

Research Related Posts

Recently Read

[2011,inproceedings] bibtex

S. Sidiroglou-Douskos, S. Misailovic, H. Hoffmann, and M. Rinard, "Managing Performance vs. Accuracy Trade-offs With Loop Perforation," in Proceedings of the 19th ACM SIGSOFT symposium and the 13th European conference on Foundations of software engineering, New York, NY, USA, 2011, pp. 124-134.

@inproceedings{Sidiroglou-Douskos:2011:MPV:2025113.2025133, abstract = {Many modern computations (such as video and audio encoders, Monte Carlo simulations, and machine learning algorithms) are designed to trade off accuracy in return for increased performance. To date, such computations typically use ad-hoc, domain-specific techniques developed specifically for the computation at hand. Loop perforation provides a general technique to trade accuracy for performance by transforming loops to execute a subset of their iterations. A criticality testing phase filters out critical loops (whose perforation produces unacceptable behavior) to identify tunable loops (whose perforation produces more efficient and still acceptably accurate computations). A perforation space exploration algorithm perforates combinations of tunable loops to find Pareto-optimal perforation policies. Our results indicate that, for a range of applications, this approach typically delivers performance increases of over a factor of two (and up to a factor of seven) while changing the result that the application produces by less than 10%.}, acmid = {2025133}, added-at = {2012-01-30T17:41:50.000+0100}, address = {New York, NY, USA}, author = {Sidiroglou-Douskos, Stelios and Misailovic, Sasa and Hoffmann, Henry and Rinard, Martin}, biburl = {http://www.bibsonomy.org/bibtex/22d6df7f7fdf8a343604dfe8307fb4a4f/gron}, booktitle = {Proceedings of the 19th ACM SIGSOFT symposium and the 13th European conference on Foundations of software engineering}, description = {Managing performance vs. accuracy trade-offs with loop perforation}, doi = {10.1145/2025113.2025133}, interhash = {10d3dce72c5a609db140762f08f7ab88}, intrahash = {2d6df7f7fdf8a343604dfe8307fb4a4f}, isbn = {978-1-4503-0443-6}, keywords = {approximate holes loop non-deterministic}, location = {Szeged, Hungary}, numpages = {11}, pages = {124--134}, publisher = {ACM}, series = {ESEC/FSE '11}, timestamp = {2012-01-30T17:41:50.000+0100}, title = {Managing Performance vs. Accuracy Trade-offs With Loop Perforation}, url = {http://doi.acm.org/10.1145/2025113.2025133}, year = 2011 }
[2008,inproceedings] bibtex

X. Liu, Z. Guo, X. Wang, F. Chen, X. Lian, J. Tang, M. Wu, F. M. Kaashoek, and Z. Zhang, "D3S: debugging deployed distributed systems," in Proceedings of the 5th USENIX Symposium on Networked Systems Design and Implementation, Berkeley, CA, USA, 2008, pp. 423-437.

@inproceedings{Liu:2008:DSD:1387589.1387619, abstract = {Testing large-scale distributed systems is a challenge, because some errors manifest themselves only after a distributed sequence of events that involves machine and network failures. D³S is a checker that allows developers to specify predicates on distributed properties of a deployed system, and that checks these predicates while the system is running. When D³S finds a problem it produces the sequence of state changes that led to the problem, allowing developers to quickly find the root cause.
Developers write predicates in a simple and sequential programming style, while D³S checks these predicates in a distributed and parallel manner to allow checking to be scalable to large systems and fault tolerant. By using binary instrumentation, D³S works transparently with legacy systems and can change predicates to be checked at runtime. An evaluation with 5 deployed systems shows that D³S can detect non-trivial correctness and performance bugs at runtime and with low performance overhead (less than 8%).}, acmid = {1387619}, added-at = {2012-01-30T13:02:26.000+0100}, address = {Berkeley, CA, USA}, author = {Liu, Xuezheng and Guo, Zhenyu and Wang, Xi and Chen, Feibo and Lian, Xiaochen and Tang, Jian and Wu, Ming and Kaashoek, M. Frans and Zhang, Zheng}, biburl = {http://www.bibsonomy.org/bibtex/2b3b3e951f098753990e15e8fb40107f3/gron}, booktitle = {Proceedings of the 5th USENIX Symposium on Networked Systems Design and Implementation}, description = {D3S}, interhash = {bda13f274f7eb3e05d878021c75e67e4}, intrahash = {b3b3e951f098753990e15e8fb40107f3}, isbn = {111-999-5555-22-1}, keywords = {debugging distributed}, location = {San Francisco, California}, numpages = {15}, pages = {423--437}, publisher = {USENIX Association}, series = {NSDI'08}, timestamp = {2012-01-30T13:02:26.000+0100}, title = {D3S: debugging deployed distributed systems}, url = {http://dl.acm.org/citation.cfm?id=1387589.1387619}, year = 2008 }
[2006,inproceedings] bibtex

D. Geels, G. Altekar, S. Shenker, and I. Stoica, "Replay debugging for distributed applications," in Proceedings of the annual conference on USENIX ’06 Annual Technical Conference, Berkeley, CA, USA, 2006, pp. 289-300.

@inproceedings{Geels:2006:RDD:1267359.1267386, abstract = {We have developed a new replay debugging tool, liblog, for distributed C/C++ applications. It logs the execution of deployed application processes and replays them deterministically, faithfully reproducing race conditions and non-deterministic failures, enabling careful offline analysis. To our knowledge, liblog is the first replay tool to address the requirements of large distributed systems: lightweight support for long-running programs, consistent replay of arbitrary subsets of application nodes, and operation in a mixed environment of logging and nonlogging processes. In addition, it requires no special hardware or kernel patches, supports unmodified application executables, and integrates GDB into the replay mechanism for simultaneous source-level debugging of multiple processes.
This paper presents liblog's design, an evaluation of its runtime overhead, and a discussion of our experience with the tool to date.}, acmid = {1267386}, added-at = {2012-01-30T13:00:31.000+0100}, address = {Berkeley, CA, USA}, author = {Geels, Dennis and Altekar, Gautam and Shenker, Scott and Stoica, Ion}, biburl = {http://www.bibsonomy.org/bibtex/21f66b48964f0af0aa727edd8a1ea0481/gron}, booktitle = {Proceedings of the annual conference on USENIX '06 Annual Technical Conference}, description = {Replay debugging for distributed applications}, interhash = {4976f0069cbf161f185748da1af6b4b8}, intrahash = {1f66b48964f0af0aa727edd8a1ea0481}, keywords = {debugging distributed}, location = {Boston, MA}, numpages = {1}, pages = {289--300}, publisher = {USENIX Association}, timestamp = {2012-01-30T13:00:31.000+0100}, title = {Replay debugging for distributed applications}, url = {http://dl.acm.org/citation.cfm?id=1267359.1267386}, year = 2006 }
[2012,inproceedings] bibtex

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.

@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.}, 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)}, interhash = {f6aa985b183f15b014127ac282ce73d5}, intrahash = {442f0063842536e3628d10a4244620b6}, keywords = {CaseStudy Concurrency ExperienceReport Interpreters MeMyPublication Modularity Parallelism VMs myown}, month = {March}, note = {(to appear)}, publisher = {ACM}, series = {MISS'12}, timestamp = {2012-01-24T12:25:07.000+0100}, title = {Modularity and Conventions for Maintainable Concurrent Language Implementations: A Review of Our Experiences and Practices}, year = 2012 }
[2011,article] bibtex

A. Sampson, W. Dietl, E. Fortuna, D. Gnanapragasam, L. Ceze, and D. Grossman, "EnerJ: Approximate Data Types for Safe and General Low-Power Computation," SIGPLAN Not., vol. 46, pp. 164-174, 2011.

@article{Sampson:2011:EAD:1993316.1993518, acmid = {1993518}, added-at = {2012-01-23T16:17:34.000+0100}, address = {New York, NY, USA}, author = {Sampson, Adrian and Dietl, Werner and Fortuna, Emily and Gnanapragasam, Danushen and Ceze, Luis and Grossman, Dan}, biburl = {http://www.bibsonomy.org/bibtex/2b8a7c7aac46054bf2172e51ccea0bf21/gron}, description = {EnerJ}, doi = {10.1145/1993316.1993518}, interhash = {5e3ab347463aea9a26f2218c54da58e2}, intrahash = {b8a7c7aac46054bf2172e51ccea0bf21}, issn = {0362-1340}, issue = {6}, issue_date = {June 2011}, journal = {SIGPLAN Not.}, keywords = {TypeSystem efficiency energy java low non-deterministic power}, month = {June}, numpages = {11}, pages = {164--174}, publisher = {ACM}, timestamp = {2012-01-23T16:17:34.000+0100}, title = {EnerJ: Approximate Data Types for Safe and General Low-Power Computation}, url = {http://doi.acm.org/10.1145/1993316.1993518}, volume = 46, year = 2011 }
[2011,inproceedings] bibtex

J. Triplett, P. E. McKenney, and J. Walpole, "Resizable, Scalable, Concurrent Hash Tables via Relativistic Programming," in Proceedings of the 2011 USENIX conference on USENIX annual technical conference, Berkeley, CA, USA, 2011, p. 11.

@inproceedings{Triplett:2011:RSC:2002181.2002192, abstract = {We present algorithms for shrinking and expanding a hash table while allowing concurrent, wait-free, linearly scalable lookups. These resize algorithms allow Read-Copy Update (RCU) hash tables to maintain constant-time performance as the number of entries grows, and reclaim memory as the number of entries decreases, without delaying or disrupting readers. We call the resulting data structure a relativistic hash table. Benchmarks of relativistic hash tables in the Linux kernel show that lookup scalability during resize improves 125x over reader-writer locking, and 56% over Linux's current state of the art. Relativistic hash lookups experience no performance degradation during a resize. Applying this algorithm to memcached removes a scalability limit for get requests, allowing memcached to scale linearly and service up to 46% more requests per second.
Relativistic hash tables demonstrate the promise of a new concurrent programming methodology known as relativistic programming. Relativistic programming makes novel use of existing RCU synchronization primitives, namely the wait-for-readers operation that waits for unfinished readers to complete. This operation, conventionally used to handle reclamation, here allows ordering of updates without read-side synchronization or memory barriers.}, acmid = {2002192}, added-at = {2012-01-23T15:32:09.000+0100}, address = {Berkeley, CA, USA}, author = {Triplett, Josh and McKenney, Paul E. and Walpole, Jonathan}, biburl = {http://www.bibsonomy.org/bibtex/22901f41af59c26c028beab65c179d593/gron}, booktitle = {Proceedings of the 2011 USENIX conference on USENIX annual technical conference}, description = {Resizable, scalable, concurrent hash tables via relativistic programming}, interhash = {e3865bed6dcb48bdc77e154a1efb39f6}, intrahash = {2901f41af59c26c028beab65c179d593}, keywords = {hash non-deterministic relativistic table}, location = {Portland, OR}, numpages = {1}, pages = 11, publisher = {USENIX Association}, series = {USENIXATC'11}, timestamp = {2012-01-23T15:32:09.000+0100}, title = {Resizable, Scalable, Concurrent Hash Tables via Relativistic Programming}, url = {http://dl.acm.org/citation.cfm?id=2002181.2002192}, year = 2011 }

more…

Research

My Publications

Research Related Posts

Recently Read

Recent Posts

Twitter @smarr

Stefan Marr, PhD Student

Archive

Previous Posts

Modularity and Conventions for Maintainable Concurrent Language Implementations: A Review of Our Experiences and Practices

CSOM/PL: A Virtual Machine Product Line

Synchronization Views for Event-loop Actors