Powered by
2017 ACM SIGPLAN International Conference on Systems, Programming, Languages, and Applications: Software for Humanity (SPLASH Companion 2017),
October 22–27, 2017,
Vancouver, BC, Canada
Doctoral Symposium
How to Make Tasks Faster: Revealing the Complex Interactions of Tasks in the Memory System
Germán Ceballos
(Uppsala University, Sweden)
New programming models have been introduced to aid the programmer dealing with the complexity of large-scale systems, simplifying the coding process and making applications more scalable regardless. Task-based programming is one example that became popular recently.
At the same time, understanding performance of multicore systems is crucial for getting faster execution times and to optimize efficiency, but it is becoming harder due to the increased complexity of hardware architectures, and the interplay between the scheduling of tasks and caches.
In this work, we develop models to understand how scheduling affects the performance of tasks due to memory behavior in the task-based context, and for that, we study cache sharing both in temporal and spatial ways. In temporal cache sharing, the effect of data reused over time by the tasks executed is modeled to predict different scenarios resulting in a tool called StatTask. In spatial cache sharing, the effect of tasks fighting for the cache at a given point in time through their execution is quantified and used to model their behavior on arbitrary cache sizes. We also present a new methodology called TaskInsight that can explain performance differences across different schedules for the same application. Finally, we explain how these methods set up a unique and solid platform to reveal insight into how to improve the performance of the execution of large-scale task-based applications.
@InProceedings{SPLASH Companion17p1,
author = {Germán Ceballos},
title = {How to Make Tasks Faster: Revealing the Complex Interactions of Tasks in the Memory System},
booktitle = {Proc.\ SPLASH Companion},
publisher = {ACM},
pages = {1--3},
doi = {},
year = {2017},
}
Combining Visual and Textual Languages for Dyslexia
Luis F. González
(Universidad Politécnica de Madrid, Spain; Politecnico Colombiano Jaime Isaza Cadavid, Colombia)
This paper describes the research of a Software, Systems and Computing
PhD thesis conducted at the Universidad Politécnica de
Madrid.
The aim of this research is threefold: i) design a model to promote
interaction between programmers with and without dyslexia during
software development as part of a team, ii) overcome the obstacles
facing dyslexic programmers when they are writing a program,
and iii) increase software development performance and efficiency
levels when one of the programmers has symptoms of dyslexia.
@InProceedings{SPLASH Companion17p4,
author = {Luis F. González},
title = {Combining Visual and Textual Languages for Dyslexia},
booktitle = {Proc.\ SPLASH Companion},
publisher = {ACM},
pages = {4--6},
doi = {},
year = {2017},
}
Genetic Improvement in Code Interpreters and Compilers
Oliver Krauss
(JKU Linz, Austria; University of Applied Sciences Upper Austria at Hagenberg, Austria)
Modern compilers provide code optimizations before and during run-time, thus moving required domain knowledge about the compilation process away from the developer and speeding up resulting software. These optimizations are often based on formal proof, or alternatively have recovery paths as backup. Genetic improvement (GI), a field of science utilizing genetic programming, a stochastic optimization technique, has been previously utilized to fix bugs in software and improve non-functional software requirements.
This work proposes to research the applicability of GI in an offline phase directly at the interpreter or compiler level. The primary goal is to reformulate existing source code in such a way that existing optimizations can be applied in order to increase performance even further and requiring even less domain knowledge from the developer about a programming language and/or compiler. From these reformulations, patterns can be identified that allow code restructuring without the overhead GI poses.
@InProceedings{SPLASH Companion17p7,
author = {Oliver Krauss},
title = {Genetic Improvement in Code Interpreters and Compilers},
booktitle = {Proc.\ SPLASH Companion},
publisher = {ACM},
pages = {7--9},
doi = {},
year = {2017},
}
Simulation-Based Code Duplication for Enhancing Compiler Optimizations
David Leopoldseder
(JKU Linz, Austria)
The scope of compiler optimizations is often limited by control flow, which prohibits optimizations across basic block boundaries.
Code duplication can solve this problem by extending basic block sizes, thus enabling subsequent optimizations.
However, duplicating code for every optimization opportunity may lead to excessive code growth.
Therefore, a holistic approach is required that is capable of finding optimization opportunities and classifying their impact.
This paper presents a novel approach to determine which code should be duplicated in order to improve peak performance.
The approach analyzes duplication candidates for subsequent optimizations opportunities.
It does so by simulating a duplication and analyzing its impact on other optimizations.
This allows a compiler to weight up multiple success metrics in order to choose those duplications with the maximum optimization potential.
We further show how to map code duplication opportunities to an optimization cost model that allows us to maximize performance while minimizing code size increase.
@InProceedings{SPLASH Companion17p10,
author = {David Leopoldseder},
title = {Simulation-Based Code Duplication for Enhancing Compiler Optimizations},
booktitle = {Proc.\ SPLASH Companion},
publisher = {ACM},
pages = {10--12},
doi = {},
year = {2017},
}
Advanced Debugging Techniques to Identify Concurrency Bugs in Actor-based Programs
Carmen Torres Lopez
(Vrije Universiteit Brussel, Belgium)
Actor-based programs are not exempt from concurrency bugs. Inspiring contributions for debugging actor-based programs have been developed, however there is no approach that reliably identifies the root cause of complex concurrency bugs.
Solving this problem can result in a reduction of the debugging time that programmers spend when developing concurrent applications.
I propose a debugging approach based on the combination of offline debugging techniques that aim to help developers in the process of finding the root cause of concurrency bugs.
I plan to evaluate this proposal through user studies and performance evaluation.
@InProceedings{SPLASH Companion17p13,
author = {Carmen Torres Lopez},
title = {Advanced Debugging Techniques to Identify Concurrency Bugs in Actor-based Programs},
booktitle = {Proc.\ SPLASH Companion},
publisher = {ACM},
pages = {13--15},
doi = {},
year = {2017},
}
proc time: 1.13