Last update:
Wed Sep 27 17:04:36 MDT 2023
Neil Gershenfeld and
David Dalrymple and
Kailiang Chen and
Ara Knaian and
Forrest Green and
Erik D. Demaine and
Scott Greenwald and
Peter Schmidt-Nielsen Reconfigurable asynchronous logic
automata: (RALA) . . . . . . . . . . . . 1--6
Mohamed Faouzi Atig and
Ahmed Bouajjani and
Sebastian Burckhardt and
Madanlal Musuvathi On the verification problem for weak
memory models . . . . . . . . . . . . . 7--18
Eric Koskinen and
Matthew Parkinson and
Maurice Herlihy Coarse-grained transactions . . . . . . 19--30
H. Attiya and
G. Ramalingam and
N. Rinetzky Sequential verification of
serializability . . . . . . . . . . . . 31--42
Patrice Godefroid and
Aditya V. Nori and
Sriram K. Rajamani and
Sai Deep Tetali Compositional may-must program analysis:
unleashing the power of alternation . . 43--56
Swarat Chaudhuri and
Sumit Gulwani and
Roberto Lublinerman Continuity analysis of programs . . . . 57--70
William R. Harris and
Sriram Sankaranarayanan and
Franjo Ivan\vci\'c and
Aarti Gupta Program analysis via satisfiability
modulo path programs . . . . . . . . . . 71--82
Jean-Baptiste Tristan and
Xavier Leroy A simple, verified validator for
software pipelining . . . . . . . . . . 83--92
Adam Chlipala A verified compiler for an impure
functional language . . . . . . . . . . 93--106
Magnus O. Myreen Verified just-in-time compiler on x86 107--118
Tachio Terauchi Dependent types from counterexamples . . 119--130
Patrick Maxim Rondon and
Ming Kawaguchi and
Ranjit Jhala Low-level liquid types . . . . . . . . . 131--144
Max Schäfer and
Oege de Moor Type inference for datalog with complex
type hierarchies . . . . . . . . . . . . 145--156
Thomas A. Henzinger From Boolean to quantitative notions of
correctness . . . . . . . . . . . . . . 157--158
Andrew M. Pitts Nominal system T . . . . . . . . . . . . 159--170
Aquinas Hobor and
Robert Dockins and
Andrew W. Appel A theory of indirection via
approximation . . . . . . . . . . . . . 171--184
Derek Dreyer and
Georg Neis and
Andreas Rossberg and
Lars Birkedal A relational modal logic for
higher-order stateful ADTs . . . . . . . 185--198
Philippe Suter and
Mirco Dotta and
Viktor Kuncak Decision procedures for algebraic data
types with abstractions . . . . . . . . 199--210
Stephen Magill and
Ming-Hsien Tsai and
Peter Lee and
Yih-Kuen Tsay Automatic numeric abstractions for
heap-manipulating programs . . . . . . . 211--222
Steffen Jost and
Kevin Hammond and
Hans-Wolfgang Loidl and
Martin Hofmann Static determination of quantitative
resource usage for higher-order programs 223--236
Gregory Malecha and
Greg Morrisett and
Avraham Shinnar and
Ryan Wisnesky Toward a verified relational database
management system . . . . . . . . . . . 237--248
Andreas Podelski and
Thomas Wies Counterexample-guided focus . . . . . . 249--260
Aleksandar Nanevski and
Viktor Vafeiadis and
Josh Berdine Structuring the verification of
heap-manipulating programs . . . . . . . 261--274
Limin Jia and
Jianzhou Zhao and
Vilhelm Sjöberg and
Stephanie Weirich Dependent types and program equivalence 275--286
DeLesley S. Hutchins Pure subtype systems . . . . . . . . . . 287--298
Simon J. Gay and
Vasco T. Vasconcelos and
António Ravara and
Nils Gesbert and
Alexandre Z. Caldeira Modular session types for distributed
object-oriented programming . . . . . . 299--312
Saurabh Srivastava and
Sumit Gulwani and
Jeffrey S. Foster From program verification to program
synthesis . . . . . . . . . . . . . . . 313--326
Martin Vechev and
Eran Yahav and
Greta Yorsh Abstraction-guided synthesis of
synchronization . . . . . . . . . . . . 327--338
Rastislav Bodik and
Satish Chandra and
Joel Galenson and
Doug Kimelman and
Nicholas Tung and
Shaon Barman and
Casey Rodarmor Programming with angelic nondeterminism 339--352
Michael Greenberg and
Benjamin C. Pierce and
Stephanie Weirich Contracts made manifest . . . . . . . . 353--364
Jeremy G. Siek and
Philip Wadler Threesomes, with and without blame . . . 365--376
Tobias Wrigstad and
Francesco Zappa Nardelli and
Sylvain Lebresne and
Johan Östlund and
Jan Vitek Integrating typed and untyped code in a
scripting language . . . . . . . . . . . 377--388
Ross Tate and
Michael Stepp and
Sorin Lerner Generating compiler optimizations from
proofs . . . . . . . . . . . . . . . . . 389--402
João Dias and
Norman Ramsey Automatically generating instruction
selectors using declarative machine
descriptions . . . . . . . . . . . . . . 403--416
Trevor Jim and
Yitzhak Mandelbaum and
David Walker Semantics and algorithms for
data-dependent grammars . . . . . . . . 417--430
Niklas Broberg and
David Sands Paralocks: role-based information flow
control and beyond . . . . . . . . . . . 431--444
Karthikeyan Bhargavan and
Cédric Fournet and
Andrew D. Gordon Modular verification of security
protocol code by typing . . . . . . . . 445--456
Jean-Phillipe Martin and
Michael Hicks and
Manuel Costa and
Periklis Akritidis and
Miguel Castro Dynamically checking ownership policies
in concurrent C/C++ programs . . . . . . 457--470
Matthias Heizmann and
Jochen Hoenicke and
Andreas Podelski Nested interpolants . . . . . . . . . . 471--482
Andrzej Filinski Monads in action . . . . . . . . . . . . 483--494
Naoki Kobayashi and
Naoshi Tabuchi and
Hiroshi Unno Higher-order multi-parameter tree
transducers and recursion schemes for
program verification . . . . . . . . . . 495--508
Rishiyur S. Nikhil Using GPCE principles for hardware
systems and accelerators: (bridging the
gap to HW design) . . . . . . . . . . . 1--2
James R. Cordy Eating our own dog food: DSLs for
generative and transformational
engineering . . . . . . . . . . . . . . 3--4
Jeremiah James Willcock and
Andrew Lumsdaine and
Daniel J. Quinlan Reusable, generic program analyses and
transformations . . . . . . . . . . . . 5--14
Anya Helene Bagge and
Valentin David and
Magne Haveraaen The axioms strike back: testing with
concepts and axioms in C++ . . . . . . . 15--24
Ronald Garcia and
Andrew Lumsdaine Toward foundations for type-reflective
metaprogramming . . . . . . . . . . . . 25--34
Hossein Sadat-Mohtasham and
H. James Hoover Transactional pointcuts: designation
reification and advice of interrelated
join points . . . . . . . . . . . . . . 35--44
Shumpei Akai and
Shigeru Chiba Extending AspectJ for separating regions 45--54
Yanhong A. Liu and
Michael Gorbovitski and
Scott D. Stoller A language and framework for
invariant-driven transformations . . . . 55--64
Stefan Wehr and
Peter Thiemann JavaGI in the battlefield: practical
experience with generalized interfaces 65--74
Phil McGachey and
Antony L. Hosking and
J. Eliot B. Moss Classifying Java class transformations
for pervasive virtualized access . . . . 75--84
Alex Villazón and
Walter Binder and
Danilo Ansaloni and
Philippe Moret Advanced runtime adaptation for Java . . 85--94
Alex Villazón and
Walter Binder and
Danilo Ansaloni and
Philippe Moret HotWave: creating adaptive tools with
dynamic aspect-oriented programming in
Java . . . . . . . . . . . . . . . . . . 95--98
Florian Heidenreich and
Jendrik Johannes and
Mirko Seifert and
Christian Wende and
Marcel Böhme Generating safe template languages . . . 99--108
Soonho Kong and
Wontae Choi and
Kwangkeun Yi Abstract parsing for two-staged
languages with concatenation . . . . . . 109--116
Srinivas Nedunuri and
William R. Cook Synthesis of fast programs for maximum
segment sum problems . . . . . . . . . . 117--126
Ansgar Radermacher and
Arnaud Cuccuru and
Sebastien Gerard and
François Terrier Generating execution infrastructures for
component-oriented specifications with a
model driven toolchain: a case study for
MARTE's GCM and real-time annotations 127--136
Damien Cassou and
Benjamin Bertran and
Nicolas Loriant and
Charles Consel A generative programming approach to
developing pervasive computing systems 137--146
Jaakko Järvi and
Mat Marcus and
Sean Parent and
John Freeman and
Jacob Smith Algorithms for user interfaces . . . . . 147--156
Christian Kästner and
Sven Apel and
Martin Kuhlemann A model of refactoring physically and
virtually separated features . . . . . . 157--166
Frans Sanen and
Eddy Truyen and
Wouter Joosen Mapping problem-space to solution-space
features: a feature interaction approach 167--176
Martin Kuhlemann and
Don Batory and
Christian Kästner Safe composition of non-monotonic
features . . . . . . . . . . . . . . . . 177--186
Eric A. Brewer Technology for developing regions:
Moore's law is not enough . . . . . . . 1--2
Engin Ipek and
Jeremy Condit and
Edmund B. Nightingale and
Doug Burger and
Thomas Moscibroda Dynamically replicated memory: building
reliable systems from nanoscale
resistive memories . . . . . . . . . . . 3--14
Nevin Kirman and
José F. Martínez A power-efficient all-optical on-chip
interconnect using wavelength-based
oblivious routing . . . . . . . . . . . 15--28
Naveen Neelakantam and
David R. Ditzel and
Craig Zilles A real system evaluation of hardware
atomicity for software speculation . . . 29--38
Tim Harris and
Sa\vsa Tomic and
Adrián Cristal and
Osman Unsal Dynamic filtering: multi-purpose
architecture support for language
runtime systems . . . . . . . . . . . . 39--52
Tom Bergan and
Owen Anderson and
Joseph Devietti and
Luis Ceze and
Dan Grossman CoreDet: a compiler and runtime system
for deterministic multithreaded
execution . . . . . . . . . . . . . . . 53--64
Arun Raman and
Hanjun Kim and
Thomas R. Mason and
Thomas B. Jablin and
David I. August Speculative parallelization using
software multi-threaded transactions . . 65--76
Dongyoon Lee and
Benjamin Wester and
Kaushik Veeraraghavan and
Satish Narayanasamy and
Peter M. Chen and
Jason Flinn Respec: efficient online multiprocessor
replay via speculation and external
determinism . . . . . . . . . . . . . . 77--90
Stijn Eyerman and
Lieven Eeckhout Probabilistic job symbiosis modeling for
SMT processor scheduling . . . . . . . . 91--102
Kai Shen Request behavior variations . . . . . . 103--116
F. Ryan Johnson and
Radu Stoica and
Anastasia Ailamaki and
Todd C. Mowry Decoupling contention management from
scheduling . . . . . . . . . . . . . . . 117--128
Sergey Zhuravlev and
Sergey Blagodurov and
Alexandra Fedorova Addressing shared resource contention in
multicore processors via scheduling . . 129--142
Ding Yuan and
Haohui Mai and
Weiwei Xiong and
Lin Tan and
Yuanyuan Zhou and
Shankar Pasupathy SherLog: error diagnosis by connecting
clues from run-time logs . . . . . . . . 143--154
Dasarath Weeratunge and
Xiangyu Zhang and
Suresh Jagannathan Analyzing multicore dumps to facilitate
concurrency bug reproduction . . . . . . 155--166
Sebastian Burckhardt and
Pravesh Kothari and
Madanlal Musuvathi and
Santosh Nagarakatte A randomized scheduler with
probabilistic guarantees of finding bugs 167--178
Wei Zhang and
Chong Sun and
Shan Lu ConMem: detecting severe concurrency
bugs through an effect-oriented approach 179--192
Francisco Javier Mesa-Martinez and
Ehsan K. Ardestani and
Jose Renau Characterizing processor thermal
behavior . . . . . . . . . . . . . . . . 193--204
Ganesh Venkatesh and
Jack Sampson and
Nathan Goulding and
Saturnino Garcia and
Vladyslav Bryksin and
Jose Lugo-Martinez and
Steven Swanson and
Michael Bedford Taylor Conservation cores: reducing the energy
of mature computations . . . . . . . . . 205--218
Kshitij Sudan and
Niladrish Chatterjee and
David Nellans and
Manu Awasthi and
Rajeev Balasubramonian and
Al Davis Micro-pages: increasing DRAM efficiency
with locality-aware data placement . . . 219--230
Steven Pelley and
David Meisner and
Pooya Zandevakili and
Thomas F. Wenisch and
Jack Underwood Power routing: dynamic power
provisioning in the data center . . . . 231--242
Faraz Ahmad and
T. N. Vijaykumar Joint optimization of idle and cooling
power in data centers while maintaining
response time . . . . . . . . . . . . . 243--256
Michelle L. Goodstein and
Evangelos Vlachos and
Shimin Chen and
Phillip B. Gibbons and
Michael A. Kozuch and
Todd C. Mowry Butterfly analysis: adapting dataflow
analysis to dynamic parallel monitoring 257--270
Evangelos Vlachos and
Michelle L. Goodstein and
Michael A. Kozuch and
Shimin Chen and
Babak Falsafi and
Phillip B. Gibbons and
Todd C. Mowry ParaLog: enabling and accelerating
online parallel monitoring of
multithreaded applications . . . . . . . 271--284
Amir H. Hormati and
Yoonseo Choi and
Mark Woh and
Manjunath Kudlur and
Rodric Rabbah and
Trevor Mudge and
Scott Mahlke MacroSS: macro-SIMDization of streaming
applications . . . . . . . . . . . . . . 285--296
Dong Hyuk Woo and
Hsien-Hsin S. Lee COMPASS: a programmable data prefetcher
using idle GPU shaders . . . . . . . . . 297--310
Daniel Sanchez and
Richard M. Yoo and
Christos Kozyrakis Flexible architectural support for
fine-grain scheduling . . . . . . . . . 311--322
Bogdan F. Romanescu and
Alvin R. Lebeck and
Daniel J. Sorin Specifying and dynamically verifying
address translation-aware memory
consistency . . . . . . . . . . . . . . 323--334
Eiman Ebrahimi and
Chang Joo Lee and
Onur Mutlu and
Yale N. Patt Fairness via source throttling: a
configurable and high-performance
fairness substrate for multi-core memory
systems . . . . . . . . . . . . . . . . 335--346
Isaac Gelado and
Javier Cabezas and
Nacho Navarro and
John E. Stone and
Sanjay Patel and
Wen-mei W. Hwu An asymmetric distributed shared memory
model for heterogeneous parallel systems 347--358
Abhishek Bhattacharjee and
Margaret Martonosi Inter-core cooperative TLB for chip
multiprocessors . . . . . . . . . . . . 359--370
Ruirui Huang and
Daniel Y. Deng and
G. Edward Suh Orthrus: efficient software integrity
protection on multi-cores . . . . . . . 371--384
Shuguang Feng and
Shantanu Gupta and
Amin Ansari and
Scott Mahlke Shoestring: probabilistic soft error
reliability on the cheap . . . . . . . . 385--396
Doe Hyun Yoon and
Mattan Erez Virtualized and flexible ECC for main
memory . . . . . . . . . . . . . . . . . 397--408
Minming Li and
Chun Jason Xue and
Tiantian Liu and
Yingchao Zhao Analysis and approximation for bank
selection instruction minimization on
partitioned memory architecture . . . . 1--8
Robert Pyka and
Felipe Klein and
Peter Marwedel and
Stylianos Mamagkakis Versatile system-level memory-aware
platform description approach for
embedded MPSoCs . . . . . . . . . . . . 9--16
Yongjoo Kim and
Jongeun Lee and
Aviral Shrivastava and
Yunheung Paek Operation and data mapping for CGRAs
with multi-bank memory . . . . . . . . . 17--26
Mohammad H. Foroozannejad and
Matin Hashemi and
Trevor L. Hodges and
Soheil Ghiasi Look into details: the benefits of
fine-grain streaming buffer analysis . . 27--36
Simon Perathoner and
Tobias Rein and
Lothar Thiele and
Kai Lampka and
Jonas Rox Modeling structured event streams in
system level performance analysis . . . 37--46
Jens Brandt and
Klaus Schneider and
Sandeep K. Shukla Translating concurrent action oriented
specifications to synchronous guarded
actions . . . . . . . . . . . . . . . . 47--56
Gwenaël Delaval and
Hervé Marchand and
Eric Rutten Contracts for modular discrete
controller synthesis . . . . . . . . . . 57--66
Marc Schlickling and
Markus Pister Semi-automatic derivation of timing
models for WCET analysis . . . . . . . . 67--76
Ines Viskic and
Lochi Yu and
Daniel Gajski Design exploration and automatic
generation of MPSoC platform TLMs from
Kahn Process Network applications . . . 77--84
Ozcan Ozturk and
Mahmut Kandemir and
Mary J. Irwin and
Sri H. K. Narayanan Compiler directed network-on-chip
reliability enhancement for chip
multiprocessors . . . . . . . . . . . . 85--94
Prasad A. Kulkarni and
Michael R. Jantz and
David B. Whalley Improving both the performance benefits
and speed of optimization phase sequence
searches . . . . . . . . . . . . . . . . 95--104
Weijia Li and
Youtao Zhang An efficient code update scheme for DSP
applications in mobile embedded systems 105--114
John Robert Wernsing and
Greg Stitt Elastic computing: a framework for
transparent, portable, and adaptive
multi-core heterogeneous computing . . . 115--124
Matthias Biehl and
Chen DeJiu and
Martin Törngren Integrating safety analysis into the
model-based development toolchain of
automotive embedded systems . . . . . . 125--132
Sebastian Fischmeister and
Yanmeng Ba Sampling-based program execution
monitoring . . . . . . . . . . . . . . . 133--142
Aviral Shrivastava and
Jongeun Lee and
Reiley Jeyapaul Cache vulnerability equations for
protecting data in embedded processor
caches from soft errors . . . . . . . . 143--152
Sebastian Altmeyer and
Claire Maiza and
Jan Reineke Resilience analysis: tightening the CRPD
bound for set-associative caches . . . . 153--162
Yi Wang and
Duo Liu and
Meng Wang and
Zhiwei Qin and
Zili Shao and
Yong Guan RNFTL: a reuse-aware NAND flash
translation layer for flash memory . . . 163--172
Tilak Agerwala Exascale computing: the challenges and
opportunities in the next decade . . . . 1--2
Mario Méndez-Lojo and
Donald Nguyen and
Dimitrios Prountzos and
Xin Sui and
M. Amber Hassaan and
Milind Kulkarni and
Martin Burtscher and
Keshav Pingali Structure-driven optimizations for
amorphous data-parallel programs . . . . 3--14
Katherine E. Coons and
Sebastian Burckhardt and
Madanlal Musuvathi GAMBIT: effective unit testing for
concurrency libraries . . . . . . . . . 15--24
Jonathan K. Lee and
Jens Palsberg Featherweight X10: a core calculus for
async-finish parallelism . . . . . . . . 25--36
Sandya Mannarswamy and
Dhruva R. Chakrabarti and
Kaushik Rajan and
Sujoy Saraswati Compiler aided selective lock assignment
for improving the performance of
software transactional memory . . . . . 37--46
Christopher J. Rossbach and
Owen S. Hofmann and
Emmett Witchel Is transactional programming actually
easier? . . . . . . . . . . . . . . . . 47--56
Ferad Zyulkyarov and
Tim Harris and
Osman S. Unsal and
Adrían Cristal and
Mateo Valero Debugging programs that use atomic
blocks and transactional memory . . . . 57--66
Luke Dalessandro and
Michael F. Spear and
Michael L. Scott NOrec: streamlining STM by abolishing
ownership records . . . . . . . . . . . 67--78
Walther Maldonado and
Patrick Marlier and
Pascal Felber and
Adi Suissa and
Danny Hendler and
Alexandra Fedorova and
Julia L. Lawall and
Gilles Muller Scheduling support for transactional
memory contention management . . . . . . 79--90
João Barreto and
Aleksandar Dragojevi\'c and
Paulo Ferreira and
Rachid Guerraoui and
Michal Kapalka Leveraging parallel nesting in
transactional memory . . . . . . . . . . 91--100
Josep Torrellas and
Bill Gropp and
Jaime Moreno and
Kunle Olukotun and
Vivek Sarkar Extreme scale computing: challenges and
opportunities . . . . . . . . . . . . . 101--102
Arvind Is hardware innovation over? . . . . . . 103--104
Sara S. Baghsorkhi and
Matthieu Delahaye and
Sanjay J. Patel and
William D. Gropp and
Wen-mei W. Hwu An adaptive performance modeling tool
for GPU architectures . . . . . . . . . 105--114
Jee W. Choi and
Amik Singh and
Richard W. Vuduc Model-driven autotuning of sparse
matrix-vector multiply on GPUs . . . . . 115--126
Yao Zhang and
Jonathan Cohen and
John D. Owens Fast tridiagonal solvers on the GPU . . 127--136
Edans Flavius O. Sandes and
Alba Cristina M. A. de Melo CUDAlign: using GPU to accelerate the
comparison of megabase genomic sequences 137--146
Steven Hofmeyr and
Costin Iancu and
Filip Blagojevi\'c Load balancing on speed . . . . . . . . 147--158
Torsten Hoefler and
Christian Siebert and
Andrew Lumsdaine Scalable communication protocols for
dynamic sparse data exchange . . . . . . 159--168
John W. Romein and
P. Chris Broekema and
Jan David Mol and
Rob V. van Nieuwpoort The LOFAR correlator: implementation and
performance analysis . . . . . . . . . . 169--178
Alexandros Tzannes and
George C. Caragea and
Rajeev Barua and
Uzi Vishkin Lazy binary-splitting: a run-time
adaptive work-stealing scheduler . . . . 179--190
Petar Radojkovi\'c and
Vladimir \vCakarevi\'c and
Javier Verdú and
Alex Pajuelo and
Francisco J. Cazorla and
Mario Nemirovsky and
Mateo Valero Thread to strand binding of parallel
network applications in massive
multi-threaded systems . . . . . . . . . 191--202
Eddy Z. Zhang and
Yunlian Jiang and
Xipeng Shen Does cache sharing on modern CMP matter
to the performance of contemporary
multithreaded programs? . . . . . . . . 203--212
Lixia Liu and
Zhiyuan Li Improving parallelism and locality with
asynchronous algorithms . . . . . . . . 213--222
Anthony M. Castaldo and
R. Clint Whaley Scaling LAPACK panel operations using
parallel cache assignment . . . . . . . 223--232
Dean F. Sutherland and
William L. Scherlis Composable thread coloring . . . . . . . 233--244
Kunal Agrawal and
Charles E. Leiserson and
Jim Sukha Helper locks for fork-join parallel
programming . . . . . . . . . . . . . . 245--256
Nathan G. Bronson and
Jared Casper and
Hassan Chafi and
Kunle Olukotun A practical concurrent binary search
tree . . . . . . . . . . . . . . . . . . 257--268
Nathan R. Tallent and
John M. Mellor-Crummey and
Allan Porterfield Analyzing lock contention in
multithreaded applications . . . . . . . 269--280
Gautam Upadhyaya and
Samuel P. Midkiff and
Vijay S. Pai Using data structure knowledge for
efficient lock generation and strong
atomicity . . . . . . . . . . . . . . . 281--292
Qasim Ali and
Samuel Pratt Midkiff and
Vijay S. Pai Modeling advanced collective
communication algorithms on Cell-based
systems . . . . . . . . . . . . . . . . 293--304
Jidong Zhai and
Wenguang Chen and
Weimin Zheng PHANTOM: predicting performance of
parallel applications on large-scale
parallel machines using a single node 305--314
Farhana Aleen and
Monirul Sharif and
Santosh Pande Input-driven dynamic execution
prediction of streaming applications . . 315--324
Daniel Lupei and
Bogdan Simion and
Don Pinto and
Matthew Misler and
Mihai Burcea and
William Krick and
Cristiana Amza Towards scalable and transparent
parallelization of multiplayer games
using transactional memory support . . . 325--326
Swann Perarnau and
Guillaume Huard KRASH: reproducible CPU load generation
on many cores machines . . . . . . . . . 327--328
Sai Prashanth Muralidhara and
Mahmut Kandemir and
Padma Raghavan Intra-application shared cache
partitioning for multithreaded
applications . . . . . . . . . . . . . . 329--330
Alokika Dash and
Brian Demsky Symbolic prefetching in transactional
distributed shared memory . . . . . . . 331--332
Dhruva R. Chakrabarti New abstractions for effective
performance analysis of STM programs . . 333--334
Chao Zhang and
Chen Ding and
Xiaoming Gu and
Kirk Kelsey and
Tongxin Bai and
Xiaobing Feng Continuous speculative program
parallelization in software . . . . . . 335--336
Vladimir Marjanovic and
Jesús Labarta and
Eduard Ayguadé and
Mateo Valero Effective communication and computation
overlap with hybrid MPI/SMPSs . . . . . 337--338
Daniel Cederman and
Philippas Tsigas Supporting lock-free composition of
concurrent data objects . . . . . . . . 339--340
Yi Guo and
Jisheng Zhao and
Vincent Cave and
Vivek Sarkar SLAW: a scalable locality-aware adaptive
work-stealing scheduler for multi-core
systems . . . . . . . . . . . . . . . . 341--342
Yi Yang and
Ping Xiang and
Jingfei Kong and
Huiyang Zhou An optimizing compiler for GPGPU
programs with input-data sharing . . . . 343--344
Aparna Chandramowlishwaran and
Kathleen Knobe and
Richard Vuduc Applying the concurrent collections
programming model to asynchronous
parallel dense linear algebra . . . . . 345--346
Henry Hoffmann and
Jonathan Eastep and
Marco D. Santambrogio and
Jason E. Miller and
Anant Agarwal Application heartbeats for software
performance and health . . . . . . . . . 347--348
Donald E. Porter and
Emmett Witchel Modeling transactional memory workload
performance . . . . . . . . . . . . . . 349--350
John D. Carter and
William B. Gardner and
Gary Grewal The Pilot library for novice MPI
programmers . . . . . . . . . . . . . . 351--352
Byunghyun Jang and
Perhaad Mistry and
Dana Schaa and
Rodrigo Dominguez and
David Kaeli Data transformations enabling loop
vectorization on multithreaded data
parallel architectures . . . . . . . . . 353--354
Gregory Buehrer and
Srinivasan Parthasarathy and
Shirish Tatikonda A distributed placement service for
graph-structured and tree-structured
data . . . . . . . . . . . . . . . . . . 355--356
Guodong Li and
Ganesh Gopalakrishnan and
Robert M. Kirby and
Dan Quinlan A symbolic verifier for CUDA programs 357--358
Gregor Richards and
Sylvain Lebresne and
Brian Burg and
Jan Vitek An analysis of the dynamic behavior of
JavaScript programs . . . . . . . . . . 1--12
Michael D. Bond and
Graham Z. Baker and
Samuel Z. Guyer Breadcrumbs: efficient context
sensitivity for dynamic bug detection
analyses . . . . . . . . . . . . . . . . 13--24
Olatunji Ruwase and
Shimin Chen and
Phillip B. Gibbons and
Todd C. Mowry Decoupled lifeguards: enabling path
optimizations for dynamic correctness
checking tools . . . . . . . . . . . . . 25--35
Byeongcheol Lee and
Ben Wiedermann and
Martin Hirzel and
Robert Grimm and
Kathryn S. McKinley Jinn: synthesizing dynamic bug detectors
for foreign language interfaces . . . . 36--49
Prakash Prabhu and
Ganesan Ramalingam and
Kapil Vaswani Safe programmable speculative
parallelism . . . . . . . . . . . . . . 50--61
Chen Tian and
Min Feng and
Rajiv Gupta Supporting speculative parallelization
in the presence of dynamic data
structures . . . . . . . . . . . . . . . 62--73
Mahmut Kandemir and
Taylan Yemliha and
SaiPrashanth Muralidhara and
Shekhar Srikantaiah and
Mary Jane Irwin and
Yuanrui Zhnag Cache topology aware computation mapping
for multicores . . . . . . . . . . . . . 74--85
Yi Yang and
Ping Xiang and
Jingfei Kong and
Huiyang Zhou A GPGPU compiler for memory optimization
and parallelism management . . . . . . . 86--97
Susan Eggers 2010 Athena lecture . . . . . . . . . . 98--98
Jean Yang and
Chris Hawblitzel Safe to the last instruction: automated
verification of a type-safe operating
system . . . . . . . . . . . . . . . . . 99--110
Zachary Tatlock and
Sorin Lerner Bringing extensibility to verified
compilers . . . . . . . . . . . . . . . 111--121
Adam Chlipala Ur: statically-typed metaprogramming
with type-level record computation . . . 122--133
Michael Emmi and
Rupak Majumdar and
Roman Manevich Parameterized verification of
transactional memories . . . . . . . . . 134--145
Filip Pizlo and
Lukasz Ziarek and
Petr Maj and
Antony L. Hosking and
Ethan Blanton and
Jan Vitek SCHISM: fragmentation-tolerant real-time
garbage collection . . . . . . . . . . . 146--159
Guoqing Xu and
Atanas Rountev Detecting inefficiently-used containers
to avoid bloat . . . . . . . . . . . . . 160--173
Guoqing Xu and
Nick Mitchell and
Matthew Arnold and
Atanas Rountev and
Edith Schonberg and
Gary Sevitsky Finding low-utility data structures . . 174--186
Todd Mytkowicz and
Amer Diwan and
Matthias Hauswirth and
Peter F. Sweeney Evaluating the accuracy of Java
profilers . . . . . . . . . . . . . . . 187--197
Woongki Baek and
Trishul M. Chilimbi Green: a framework for supporting
energy-conscious programming using
controlled approximation . . . . . . . . 198--209
Kaushik Rajan and
Sriram Rajamani and
Shashank Yaduvanshi GUESSTIMATE: a programming model for
collaborative distributed systems . . . 210--220
Qian Xi and
David Walker A context-free markup language for
semi-structured text . . . . . . . . . . 221--232
Florian Loitsch Printing floating-point numbers quickly
and accurately with integers . . . . . . 233--243
Cormac Flanagan and
Stephen N. Freund Adversarial memory for detecting
destructive races . . . . . . . . . . . 244--254
Michael D. Bond and
Katherine E. Coons and
Kathryn S. McKinley PACER: proportional detection of data
races . . . . . . . . . . . . . . . . . 255--268
Takuya Nakaike and
Maged M. Michael Lock elision for read-only critical
sections in Java . . . . . . . . . . . . 269--278
Swarat Chaudhuri and
Armando Solar-Lezama Smooth interpretation . . . . . . . . . 279--291
Sumit Gulwani and
Florian Zuleger The reachability-bound problem . . . . . 292--304
Matthew Might and
Yannis Smaragdakis and
David Van Horn Resolving and exploiting the $k$-CFA
paradox: illuminating functional vs.
object-oriented program analysis . . . . 305--315
Viktor Kuncak and
Mikaël Mayer and
Ruzica Piskac and
Philippe Suter Complete functional synthesis . . . . . 316--329
Sebastian Burckhardt and
Chris Dern and
Madanlal Musuvathi and
Roy Tan Line-Up: a complete and automatic
linearizability checker . . . . . . . . 330--340
Emina Torlak and
Mandana Vaziri and
Julian Dolby MemSAT: checking axiomatic
specifications of memory models . . . . 341--350
Daniel Marino and
Abhayendra Singh and
Todd Millstein and
Madanlal Musuvathi and
Satish Narayanasamy DRFX: a simple and efficient memory
model for concurrent programming
languages . . . . . . . . . . . . . . . 351--362
Craig Chambers and
Ashish Raniwala and
Frances Perry and
Stephen Adams and
Robert R. Henry and
Robert Bradshaw and
Nathan Weizenbaum FlumeJava: easy, efficient data-parallel
pipelines . . . . . . . . . . . . . . . 363--375
Heidi Pan and
Benjamin Hindman and
Krste Asanovi\'c Composing parallel software efficiently
with Lithe . . . . . . . . . . . . . . . 376--387
Jin Zhou and
Brian Demsky Bamboo: a data-centric, object-oriented
approach to many-core software . . . . . 388--399
Edwin Westbrook and
Mathias Ricken and
Jun Inoue and
Yilong Yao and
Tamer Abdelatif and
Walid Taha Mint: Java multi-stage programming using
weak separability . . . . . . . . . . . 400--411
Juan Chen and
Ravi Chugh and
Nikhil Swamy Type-preserving compilation of
end-to-end verification of security
enforcement . . . . . . . . . . . . . . 412--423
Ross Tate and
Juan Chen and
Chris Hawblitzel Inferable object-oriented typed assembly
language . . . . . . . . . . . . . . . . 424--435
Yit Phang Khoo and
Bor-Yuh Evan Chang and
Jeffrey S. Foster Mixing type checking and symbolic
execution . . . . . . . . . . . . . . . 436--447
Yang Chen and
Yuanjie Huang and
Lieven Eeckhout and
Grigori Fursin and
Liang Peng and
Olivier Temam and
Chengyong Wu Evaluating iterative optimization across
1000 datasets . . . . . . . . . . . . . 448--459
Md Kamruzzaman and
Steven Swanson and
Dean M. Tullsen Software data spreading: leveraging
distributed caches to improve single
thread performance . . . . . . . . . . . 460--470
Jennifer B. Sartor and
Stephen M. Blackburn and
Daniel Frampton and
Martin Hirzel and
Kathryn S. McKinley Z-rays: divide arrays and conquer speed
and flexibility . . . . . . . . . . . . 471--482
Umut A. Acar and
Guy Blelloch and
Ruy Ley-Wild and
Kanat Tangwongsan and
Duru Turkoglu Traceable data types for self-adjusting
computation . . . . . . . . . . . . . . 483--496
Peter M. Chen Transistors to toys: teaching systems to
freshmen . . . . . . . . . . . . . . . . 1--2
Aaron Pohle and
Björn Döbel and
Michael Roitzsch and
Hermann Härtig Capability wrangling made easy:
debugging on a microkernel with \tt
valgrind . . . . . . . . . . . . . . . . 3--12
Jim Chow and
Dominic Lucchetti and
Tal Garfinkel and
Geoffrey Lefebvre and
Ryan Gardner and
Joshua Mason and
Sam Small and
Peter M. Chen Multi-stage replay with Crosscut . . . . 13--24
Yijian Huang and
Haibo Chen and
Binyu Zang Optimizing crash dump in virtualized
environments . . . . . . . . . . . . . . 25--36
Galen C. Hunt Looking beyond a singularity . . . . . . 37--38
Ben L. Titzer and
Thomas Würthinger and
Doug Simon and
Marcelo Cintra Improving compiler-runtime separation
with XIR . . . . . . . . . . . . . . . . 39--50
Nicolas Geoffray and
Gaël Thomas and
Julia Lawall and
Gilles Muller and
Bertil Folliot VMKit: a substrate for managed runtime
environments . . . . . . . . . . . . . . 51--62
Qing Zhang and
John McCullough and
Justin Ma and
Nabil Schear and
Michael Vrable and
Amin Vahdat and
Alex C. Snoeren and
Geoffrey M. Voelker and
Stefan Savage Neon: system support for derived data
management . . . . . . . . . . . . . . . 63--74
Lei Ye and
Gen Lu and
Sushanth Kumar and
Chris Gniady and
John H. Hartman Energy-efficient storage in virtual
machine environments . . . . . . . . . . 75--84
Vahid Kazempour and
Ali Kamali and
Alexandra Fedorova AASH: an asymmetry-aware scheduler for
hypervisors . . . . . . . . . . . . . . 85--96
Min Lee and
A. S. Krishnakumar and
P. Krishnan and
Navjot Singh and
Shalini Yajnik Supporting soft real-time tasks in the
Xen hypervisor . . . . . . . . . . . . . 97--108
Rei Odaira and
Kazunori Ogata and
Kiyokuni Kawachiya and
Tamiya Onodera and
Toshio Nakatani Efficient runtime tracking of allocation
sites in Java . . . . . . . . . . . . . 109--120
Michiaki Tatsubori and
Akihiko Tozawa and
Toyotaro Suzumura and
Scott Trent and
Tamiya Onodera Evaluation of a just-in-time compiler
retrofitted for PHP . . . . . . . . . . 121--132
Manjiri A. Namjoshi and
Prasad A. Kulkarni Novel online profiling for virtual
machines . . . . . . . . . . . . . . . . 133--144
Apala Guha and
Kim hazelwood and
Mary Lou Soffa DBT path selection for holistic memory
efficiency and performance . . . . . . . 145--156
Goh Kondoh and
Hideaki Komatsu Dynamic binary translation specialized
for embedded systems . . . . . . . . . . 157--166
Katherine Barabash and
Erez Petrank Tracing garbage collection on highly
parallel platforms . . . . . . . . . . . 1--10
Fridtjof Siebert Concurrent, parallel, real-time
garbage-collection . . . . . . . . . . . 11--20
Todd A. Anderson Optimizations in a private nursery-based
garbage collector . . . . . . . . . . . 21--30
Santosh Nagarakatte and
Jianzhou Zhao and
Milo M. K. Martin and
Steve Zdancewic CETS: compiler enforced temporal safety
for C . . . . . . . . . . . . . . . . . 31--40
Martin Vechev and
Eran Yahav and
Greta Yorsh PHALANX: parallel checking of expressive
heap assertions . . . . . . . . . . . . 41--50
Peter Sewell Memory, an elusive abstraction . . . . . 51--52
Tomas Petricek and
Don Syme Collecting Hollywood's garbage: avoiding
space-leaks in composite events . . . . 53--62
Chen Tian and
Min Feng and
Rajiv Gupta Speculative parallelization using state
separation and multiple value prediction 63--72
Tomoharu Ugawa and
Hideya Iwasaki and
Taiichi Yuasa Improved replication-based incremental
garbage collection for embedded systems 73--82
Laurence Hellyer and
Richard Jones and
Antony L. Hosking The locality of concurrent write
barriers . . . . . . . . . . . . . . . . 83--92
Qin Zhao and
Derek Bruening and
Saman Amarasinghe Efficient memory shadowing for 64-bit
architectures . . . . . . . . . . . . . 93--102
Jeremy Singer and
Richard E. Jones and
Gavin Brown and
Mikel Luján The economics of garbage collection . . 103--112
Mirza Beg and
Peter van Beek A graph theoretic approach to
cache-conscious placement of data for
direct mapped caches . . . . . . . . . . 113--120
Elvira Albert and
Samir Genaim and
Miguel Gómez-Zamalloa Parametric inference of memory
requirements for garbage collected
languages . . . . . . . . . . . . . . . 121--130
Michael J. C. Gordon ML: metalanguage or object language? . . 1--2
James Chapman and
Pierre-Évariste Dagand and
Conor McBride and
Peter Morris The gentle art of levitation . . . . . . 3--14
Dimitrios Vytiniotis and
Andrew J. Kennedy Functional pearl: every bit counts . . . 15--26
Jérémy Buisson and
Fabien Dagnat ReCaml: execution state as the
cornerstone of reconfigurations . . . . 27--38
Karl Mazurak and
Steve Zdancewic Lolliproc: to concurrency from classical
linear logic via Curry--Howard and
control . . . . . . . . . . . . . . . . 39--50
David Van Horn and
Matthew Might Abstracting abstract machines . . . . . 51--62
Stefan Holdermans and
Jurriaan Hage Polyvariant flow analysis with
higher-ranked polymorphic types and
higher-order effect operators . . . . . 63--74
Matthew Naylor and
Colin Runciman The Reduceron reconfigured . . . . . . . 75--86
David Scott and
Richard Sharp and
Thomas Gazagnaire and
Anil Madhavapeddy Using functional programming within an
industrial product group: perspectives
and perceptions . . . . . . . . . . . . 87--92
Lars Bergstrom and
Mike Rainey and
John Reppy and
Adam Shaw and
Matthew Fluet Lazy tree splitting . . . . . . . . . . 93--104
Gavin M. Bierman and
Andrew D. Gordon and
Catalin Hritcu and
David Langworthy Semantic subtyping with an SMT solver 105--116
Sam Tobin-Hochstadt and
Matthias Felleisen Logical types for untyped languages . . 117--128
Matthias Felleisen TeachScheme!: a checkpoint . . . . . . . 129--130
Karl Crary Higher-order representation of
substructural logics . . . . . . . . . . 131--142
Derek Dreyer and
Georg Neis and
Lars Birkedal The impact of higher-order state and
control effects on local relational
reasoning . . . . . . . . . . . . . . . 143--156
Jason Reed and
Benjamin C. Pierce Distance makes the types grow stronger:
a calculus for differential privacy . . 157--168
Jamie Morgenstern and
Daniel R. Licata Security-typed programming within
dependently typed programming . . . . . 169--180
Janis Voigtländer and
Zhenjiang Hu and
Kazutaka Matsuda and
Meng Wang Combining syntactic and semantic
bidirectionalization . . . . . . . . . . 181--192
Davi M. J. Barbosa and
Julien Cretin and
Nate Foster and
Michael Greenberg and
Benjamin C. Pierce Matching lenses: alignment and view
update . . . . . . . . . . . . . . . . . 193--204
Soichiro Hidaka and
Zhenjiang Hu and
Kazuhiro Inaba and
Hiroyuki Kato and
Kazutaka Matsuda and
Keisuke Nakano Bidirectionalizing graph transformations 205--216
Nicolas Pouillard and
François Pottier A fresh look at programming with names
and binders . . . . . . . . . . . . . . 217--228
Marcus Crestani and
Michael Sperber Experience report: growing programming
languages for beginning students . . . . 229--234
Ryan Culpepper and
Matthias Felleisen Fortifying macros . . . . . . . . . . . 235--246
Guy E. Blelloch Functional parallel algorithms . . . . . 247--248
Gilad Arnold and
Johannes Hölzl and
Ali Sinan Köksal and
Rastislav Bodík and
Mooly Sagiv Specifying and verifying sparse matrix
codes . . . . . . . . . . . . . . . . . 249--260
Gabriele Keller and
Manuel M. T. Chakravarty and
Roman Leshchinskiy and
Simon Peyton Jones and
Ben Lippmeier Regular, shape-polymorphic, parallel
arrays in Haskell . . . . . . . . . . . 261--272
Andrew McCreight and
Tim Chevalier and
Andrew Tolmach A certified framework for compiling and
executing garbage-collected languages 273--284
Nils Anders Danielsson Total parser combinators . . . . . . . . 285--296
Edwin C. Brady and
Kevin Hammond Scrapping your inefficient engine: using
partial evaluation to improve
domain-specific language implementation 297--308
Neil Mitchell Rethinking supercompilation . . . . . . 309--320
Arthur Charguéraud Program verification through
characteristic formulae . . . . . . . . 321--332
Antonis Stampoulis and
Zhong Shao VeriML: typed computation of logical
terms inside a language with effects . . 333--344
Jean-Philippe Bernardy and
Patrik Jansson and
Ross Paterson Parametricity and dependent types . . . 345--356
Sebastian Fischer and
Frank Huch and
Thomas Wilke A play on regular expressions:
functional pearl . . . . . . . . . . . . 357--368
Iustin Pop Experience report: Haskell as a reagent:
results and observations on the use of
Haskell in a Python project . . . . . . 369--374
J. Garrett Morris and
Mark P. Jones Instance chains: type class programming
without overlapping instances . . . . . 375--386
Stephanie Forrest The case for evolvable software . . . . 1--1
Benjamin C. Pierce Art, science, and fear . . . . . . . . . 2--2
Don Syme F#: Taking Succinct, Efficient, Typed
Functional Programming into the
Mainstream . . . . . . . . . . . . . . . 3--3
Kenneth O. Stanley To achieve our highest goals, we must be
willing to abandon them . . . . . . . . 3--3
Michael Roberson and
Chandrasekhar Boyapati Efficient modular glass box software
model checking . . . . . . . . . . . . . 4--21
Stefan Hanenberg An experiment about static and dynamic
type systems: doubts about the positive
impact of static type systems on
development time . . . . . . . . . . . . 22--35
Shachar Itzhaky and
Sumit Gulwani and
Neil Immerman and
Mooly Sagiv A simple inductive synthesis methodology
and its applications . . . . . . . . . . 36--46
Julien Mercadal and
Quentin Enard and
Charles Consel and
Nicolas Loriant A domain-specific approach to
architecturing error handling in
pervasive computing . . . . . . . . . . 47--61
Wei Li and
Charles Zhang and
Songlin Hu G-Finder: routing programming questions
closer to the experts . . . . . . . . . 62--73
Rashina Hoda and
Philippe Kruchten and
James Noble and
Stuart Marshall Agility in context . . . . . . . . . . . 74--88
Joshua Auerbach and
David F. Bacon and
Perry Cheng and
Rodric Rabbah Lime: a Java-compatible and
synthesizable language for heterogeneous
architectures . . . . . . . . . . . . . 89--108
Stephen Kou and
Jens Palsberg From OO to FPGA: fitting round objects
into square hardware? . . . . . . . . . 109--124
Kai Tian and
Yunlian Jiang and
Eddy Z. Zhang and
Xipeng Shen An input-centric paradigm for program
dynamic optimizations . . . . . . . . . 125--139
Benjamin P. Wood and
Adrian Sampson and
Luis Ceze and
Dan Grossman Composable specifications for structured
shared-memory communication . . . . . . 140--159
Yao Shi and
Soyeon Park and
Zuoning Yin and
Shan Lu and
Yuanyuan Zhou and
Wenguang Chen and
Weimin Zheng Do I use the wrong definition?: DeFuse:
definition-use invariants for detecting
concurrency and sequential bugs . . . . 160--174
Mark Gabel and
Junfeng Yang and
Yuan Yu and
Moises Goldszmidt and
Zhendong Su Scalable and systematic detection of
buggy inconsistencies in source code . . 175--190
Kazunori Ogata and
Dai Mikurube and
Kiyokuni Kawachiya and
Scott Trent and
Tamiya Onodera A study of Java's non-Java memory . . . 191--204
Ross McIlroy and
Joe Sventek Hera-JVM: a runtime system for
heterogeneous multi-core architectures 205--222
Michal Wegiel and
Chandra Krintz Cross-language, type-safe, and
transparent object sharing for
co-located managed runtimes . . . . . . 223--240
Guoliang Jin and
Aditya Thakur and
Ben Liblit and
Shan Lu Instrumentation and sampling strategies
for cooperative concurrency bug
isolation . . . . . . . . . . . . . . . 241--255
Christoph Reichenbach and
Neil Immerman and
Yannis Smaragdakis and
Edward E. Aftandilian and
Samuel Z. Guyer What can the GC compute efficiently?: a
language for heap assertions at GC time 256--269
Rahul Purandare and
Matthew B. Dwyer and
Sebastian Elbaum Monitor optimization via
stutter-equivalent loop transformation 270--285
Max Schaefer and
Oege de Moor Specifying and implementing refactorings 286--301
Hoan Anh Nguyen and
Tung Thanh Nguyen and
Gary Wilson, Jr. and
Anh Tuan Nguyen and
Miryung Kim and
Tien N. Nguyen A graph-based approach to API usage
adaptation . . . . . . . . . . . . . . . 302--321
Stephen Kell Component adaptation and assembly using
interface relations . . . . . . . . . . 322--340
Bruno C. d. S. Oliveira and
Adriaan Moors and
Martin Odersky Type classes as objects and implicits 341--360
Benjamin S. Lerner and
Herman Venter and
Dan Grossman Supporting dynamic, third-party code
customizations in JavaScript using
aspects . . . . . . . . . . . . . . . . 361--376
Charlotte Herzeel and
Pascal Costanza Dynamic parallelization of recursive
code: part 1: managing control flow
interactions with the continuator . . . 377--396
Isil Dillig and
Thomas Dillig and
Alex Aiken Symbolic heap abstraction with
demand-driven axiomatization of memory
invariants . . . . . . . . . . . . . . . 397--410
Percy Liang and
Omer Tripp and
Mayur Naik and
Mooly Sagiv A dynamic evaluation of the precision of
static heap abstractions . . . . . . . . 411--427
Mario Méndez-Lojo and
Augustine Mathew and
Keshav Pingali Parallel inclusion-based points-to
analysis . . . . . . . . . . . . . . . . 428--443
Lennart C. L. Kats and
Eelco Visser The Spoofax language workbench: rules
for declarative specification of
languages and IDEs . . . . . . . . . . . 444--463
Marco Servetto and
Elena Zucca MetaFJig: a meta-circular composition
language for Java-like classes . . . . . 464--483
Karl Klose and
Klaus Ostermann Modular logic metaprogramming . . . . . 484--503
Stephan van Staden and
Cristiano Calcagno Reasoning about multiple related
abstractions with MultiStar . . . . . . 504--519
Xin Qi and
Andrew C. Myers Homogeneous family sharing . . . . . . . 520--538
Shigeru Chiba and
Atsushi Igarashi and
Salikh Zakirov Mostly modular compilation of
crosscutting concerns by contextual
predicate dispatch . . . . . . . . . . . 539--554
Casey Klein and
Matthew Flatt and
Robert Bruce Findler Random testing for higher-order,
stateful programs . . . . . . . . . . . 555--566
Jay A. McCarthy The two-state solution: native and
serializable continuations accord . . . 567--582
James Swaine and
Kevin Tew and
Peter Dinda and
Robert Bruce Findler and
Matthew Flatt Back to the futures: incremental
parallelization of existing sequential
runtime systems . . . . . . . . . . . . 583--597
Yoav Zibin and
Alex Potanin and
Paley Li and
Mahmood Ali and
Michael D. Ernst Ownership and immutability in generic
Java . . . . . . . . . . . . . . . . . . 598--617
Nicholas Cameron and
James Noble and
Tobias Wrigstad Tribal ownership . . . . . . . . . . . . 618--633
Nicholas D. Matsakis and
Thomas R. Gross A time-aware type system for data-race
protection and guaranteed initialization 634--651
Gautam Upadhyaya and
Samuel P. Midkiff and
Vijay S. Pai Automatic atomic region identification
in shared memory SPMD programs . . . . . 652--670
Aditya Kulkarni and
Yu David Liu and
Scott F. Smith Task types for pervasive atomicity . . . 671--690
Sebastian Burckhardt and
Alexandro Baldassin and
Daan Leijen Concurrent programming with revisions
and isolation types . . . . . . . . . . 691--707
Michael Bebenita and
Florian Brandner and
Manuel Fahndrich and
Francesco Logozzo and
Wolfram Schulte and
Nikolai Tillmann and
Herman Venter SPUR: a trace-based JIT compiler for CIL 708--725
Puneet Kapur and
Brad Cossette and
Robert J. Walker Refactoring references for library
migration . . . . . . . . . . . . . . . 726--738
Erik Altman and
Matthew Arnold and
Stephen Fink and
Nick Mitchell Performance analysis of idle programs 739--753
Samuel Davis and
Gregor Kiczales Registration-based language abstractions 754--773
Toon Verwaest and
Camillo Bruni and
David Gurtner and
Adrian Lienhard and
Oscar Niestrasz Pinocchio: bringing reflection to life
with first-class interpreters . . . . . 774--789
Hridesh Rajan and
Steven M. Kautz and
Wayne Rowcliffe Concurrency by modularity: design
patterns, a case in point . . . . . . . 790--805
Martin Rinard and
Henry Hoffmann and
Sasa Misailovic and
Stelios Sidiroglou Patterns and statistical analysis for
understanding reduced resource computing 806--821
Andrew Sorensen and
Henry Gardner Programming with time: cyber-physical
programming with impromptu . . . . . . . 822--834
Hassan Chafi and
Zach DeVito and
Adriaan Moors and
Tiark Rompf and
Arvind K. Sujeeth and
Pat Hanrahan and
Martin Odersky and
Kunle Olukotun Language virtualization for
heterogeneous parallel computing . . . . 835--847
Harold Ossher and
Rachel Bellamy and
Ian Simmonds and
David Amid and
Ateret Anaby-Tavor and
Matthew Callery and
Michael Desmond and
Jacqueline de Vries and
Amit Fisher and
Sophia Krasikov Flexible modeling tools for
pre-requirements analysis: conceptual
architecture and research challenges . . 848--864
Tudor Dumitras and
Priya Narasimhan and
Eli Tilevich To upgrade or not to upgrade: impact of
online upgrades across multiple
administrative domains . . . . . . . . . 865--876
Kenneth C. Arnold and
Henry Lieberman Managing ambiguity in programming by
finding unambiguous examples . . . . . . 877--884
Richard P. Gabriel and
Kevin J. Sullivan Better science through art . . . . . . . 885--900
Jenny Quillien and
Dave West Rubber ducks, nightmares, and
unsaturated predicates: proto-scientific
schemata are good for agile . . . . . . 901--917
Lennart C. L. Kats and
Eelco Visser and
Guido Wachsmuth Pure and declarative syntax definition:
paradise lost and regained . . . . . . . 918--932
Stefan Hanenberg Faith, hope, and love: an essay on
software science's neglect of human
factors . . . . . . . . . . . . . . . . 933--946
Paul Adamczyk and
Munawar Hafiz The Tower of Babel did not fail . . . . 947--957
Tillmann Rendel and
Klaus Ostermann Invertible syntax descriptions: unifying
parsing and pretty printing . . . . . . 1--12
Milan Straka The performance of the Haskell
containers package . . . . . . . . . . . 13--24
Maciej Pirog and
Dariusz Biernacki A systematic derivation of the STG
machine verified in Coq . . . . . . . . 25--36
José Pedro Magalhães and
Atze Dijkstra and
Johan Jeuring and
Andres Löh A generic deriving mechanism for Haskell 37--48
John van Groningen and
Thomas van Noort and
Peter Achten and
Pieter Koopman and
Rinus Plasmeijer Exchanging sources between Clean and
Haskell: a double-edged front end for
the Clean compiler . . . . . . . . . . . 49--60
J. Garrett Morris Experience report: using hackage to
inform language design . . . . . . . . . 61--66
Geoffrey Mainland and
Greg Morrisett Nikola: embedding compiled GPU functions
in Haskell . . . . . . . . . . . . . . . 67--78
John Launchbury and
Trevor Elliott Concurrent orchestration in Haskell . . 79--90
Simon Marlow and
Patrick Maier and
Hans-Wolfgang Loidl and
Mustafa K. Aswad and
Phil Trinder Seq no more: better strategies for
parallel Haskell . . . . . . . . . . . . 91--102
Bryan O'Sullivan and
Johan Tibell Scalable I/O event handling for GHC . . 103--108
David A. Terei and
Manuel M. T. Chakravarty An \tt llvm backend for GHC . . . . . . 109--120
Norman Ramsey and
João Dias and
Simon Peyton Jones Hoopl: a modular, reusable library for
dataflow analysis and transformation . . 121--134
Maximilian Bolingbroke and
Simon Peyton Jones Supercompilation by evaluation . . . . . 135--146
Brent A. Yorgey Species and functors and types, oh my! 147--158
Stefan Brunthaler Efficient interpretation using
quickening . . . . . . . . . . . . . . . 1--14
Salikh S. Zakirov and
Shigeru Chiba and
Etsuya Shibayama Optimizing dynamic dispatch with
fine-grained state tracking . . . . . . 15--26
Michael Gorbovitski and
Yanhong A. Liu and
Scott D. Stoller and
Tom Rothamel and
Tuncay K. Tekle Alias analysis for optimization of
dynamic languages . . . . . . . . . . . 27--42
Sviatoslav Pestov and
Daniel Ehrenberg and
Joe Groff Factor: a dynamic stack-based
programming language . . . . . . . . . . 43--58
Tom Van Cutsem and
Mark S. Miller Proxies: design principles for robust
object-oriented intercession APIs . . . 59--72
Laurence Tratt Experiences with an Icon3-like
expression evaluation system . . . . . . 73--80
Eyvind W. Axelsen and
Stein Krogdahl and
Birger Mòller-Pedersen Controlling dynamic module composition
through an extensible meta-level API . . 81--96
T. Stephen Strickland and
Matthias Felleisen Contracts for first-class classes . . . 97--112
Xavier Leroy Verified squared: does critical software
deserve verified tools? . . . . . . . . 1--2
Ondrej Lhoták and
Kwok-Chiang Andrew Chung Points-to analysis with efficient strong
updates . . . . . . . . . . . . . . . . 3--16
Yannis Smaragdakis and
Martin Bravenboer and
Ondrej Lhoták Pick your contexts well: understanding
object-sensitivity . . . . . . . . . . . 17--30
Percy Liang and
Omer Tripp and
Mayur Naik Learning minimal abstractions . . . . . 31--42
Jaroslav \vSevçik and
Viktor Vafeiadis and
Francesco Zappa Nardelli and
Suresh Jagannathan and
Peter Sewell Relaxed-memory concurrency and verified
compilation . . . . . . . . . . . . . . 43--54
Mark Batty and
Scott Owens and
Susmit Sarkar and
Peter Sewell and
Tjark Weber Mathematizing C++ concurrency . . . . . 55--66
Tahina Ramananandro and
Gabriel Dos Reis and
Xavier Leroy Formal verification of object layout for
C++ multiple inheritance . . . . . . . . 67--80
Wontae Choi and
Baris Aktemur and
Kwangkeun Yi and
Makoto Tatsuta Static analysis of multi-staged programs
via unstaging translation . . . . . . . 81--92
Martin D. Schwarz and
Helmut Seidl and
Vesal Vojdani and
Peter Lammich and
Markus Müller-Olm Static analysis of interrupt-driven
programs synchronized via the priority
ceiling protocol . . . . . . . . . . . . 93--104
Patrick Cousot and
Radhia Cousot and
Francesco Logozzo A parametric segmentation functor for
fully automatic and scalable array
content analysis . . . . . . . . . . . . 105--118
Lars Birkedal and
Bernhard Reus and
Jan Schwinghammer and
Kristian Stòvring and
Jacob Thamsborg and
Hongseok Yang Step-indexed Kripke models over
recursive worlds . . . . . . . . . . . . 119--132
Chung-Kil Hur and
Derek Dreyer A Kripke logical relation between ML and
assembly . . . . . . . . . . . . . . . . 133--146
François Pottier A typed store-passing translation for
general references . . . . . . . . . . . 147--158
Dimitrios Prountzos and
Roman Manevich and
Keshav Pingali and
Kathryn S. McKinley A shape analysis for optimizing parallel
graph programs . . . . . . . . . . . . . 159--172
Xavier Rival and
Bor-Yuh Evan Chang Calling context abstraction with shapes 173--186
Isil Dillig and
Thomas Dillig and
Alex Aiken Precise reasoning for programs using
containers . . . . . . . . . . . . . . . 187--200
Amal Ahmed and
Robert Bruce Findler and
Jeremy G. Siek and
Philip Wadler Blame for all . . . . . . . . . . . . . 201--214
Christos Dimoulas and
Robert Bruce Findler and
Cormac Flanagan and
Matthias Felleisen Correct blame for contracts: no more
scapegoating . . . . . . . . . . . . . . 215--226
Stephanie Weirich and
Dimitrios Vytiniotis and
Simon Peyton Jones and
Steve Zdancewic Generative type abstraction and
type-level computation . . . . . . . . . 227--240
Matthew B. MacLaurin The design of Kodu: a tiny visual
programming language for children on the
Xbox 360 . . . . . . . . . . . . . . . . 241--246
Aaron Joseph Turon and
Mitchell Wand A separation logic for refining
concurrent objects . . . . . . . . . . . 247--258
Mike Dodds and
Suresh Jagannathan and
Matthew J. Parkinson Modular reasoning for deterministic
parallelism . . . . . . . . . . . . . . 259--270
Bart Jacobs and
Frank Piessens Expressive modular fine-grained
concurrency specification . . . . . . . 271--282
P. Madhusudan and
Gennaro Parlato The tree width of auxiliary storage . . 283--294
Nikos Tzevelekos Fresh-register automata . . . . . . . . 295--306
Jérôme Leroux Vector addition system reachability
problem: a short self-contained proof 307--316
Sumit Gulwani Automating string processing in
spreadsheets using input-output examples 317--330
Ashutosh Gupta and
Corneliu Popeea and
Andrey Rybalchenko Predicate abstraction and refinement for
verifying multi-threaded programs . . . 331--344
Dan R. Ghica and
Alex Smith Geometry of synthesis III: resource
management through type inference . . . 345--356
Jan Hoffmann and
Klaus Aehlig and
Martin Hofmann Multivariate amortized resource analysis 357--370
Martin Hofmann and
Benjamin Pierce and
Daniel Wagner Symmetric lenses . . . . . . . . . . . . 371--384
Fritz Henglein and
Lasse Nielsen Regular expression containment:
coinductive axiomatization and
computational interpretation . . . . . . 385--398
Byron Cook and
Eric Koskinen Making prophecies with decision
predicates . . . . . . . . . . . . . . . 399--410
Michael Emmi and
Shaz Qadeer and
Zvonimir Rakamari\'c Delay-bounded scheduling . . . . . . . . 411--422
Nishant Sinha and
Chao Wang On interference abstractions . . . . . . 423--434
Pierre-Malo Deniélou and
Nobuko Yoshida Dynamic multirole session types . . . . 435--446
Jesse A. Tov and
Riccardo Pucella Practical affine types . . . . . . . . . 447--458
Jong-hoon (David) An and
Avik Chaudhuri and
Jeffrey S. Foster and
Michael Hicks Dynamic inference of static types for
ruby . . . . . . . . . . . . . . . . . . 459--472
Andrew D. Gordon and
Robert Harper and
John Harrison and
Alan Jeffrey and
Peter Sewell Robin Milner 1934--2010: verification,
languages, and concurrency . . . . . . . 473--474
Anna Bendersky and
Erez Petrank Space overhead bounds for dynamic memory
management with partial compaction . . . 475--486
Hagit Attiya and
Rachid Guerraoui and
Danny Hendler and
Petr Kuznetsov and
Maged M. Michael and
Martin Vechev Laws of order: expensive synchronization
in concurrent algorithms cannot be
eliminated . . . . . . . . . . . . . . . 487--498
Javier Esparza and
Pierre Ganty Complexity of pattern-based verification
for multithreaded programs . . . . . . . 499--510
Tarun Prabhu and
Shreyas Ramalingam and
Matthew Might and
Mary Hall EigenCFA: accelerating flow analysis
with GPUs . . . . . . . . . . . . . . . 511--522
Yuan Feng and
Runyao Duan and
Mingsheng Ying Bisimulation for quantum processes . . . 523--534
Robert L. Bocchino, Jr. and
Stephen Heumann and
Nima Honarmand and
Sarita V. Adve and
Vikram S. Adve and
Adam Welc and
Tatiana Shpeisman Safe nondeterminism in a
deterministic-by-default parallel
language . . . . . . . . . . . . . . . . 535--548
Louis-Noël Pouchet and
Uday Bondhugula and
Cédric Bastoul and
Albert Cohen and
J. Ramanujam and
P. Sadayappan and
Nicolas Vasilache Loop transformations: convexity, pruning
and optimization . . . . . . . . . . . . 549--562
Shu-yu Guo and
Jens Palsberg The essence of compiling with traces . . 563--574
Norman Ramsey and
João Dias Resourceable, retargetable, modular
instruction selection using a
machine-independent, type-based tiling
of low-level intermediate code . . . . . 575--586
C.-H. Luke Ong and
Steven James Ramsay Verifying higher-order functional
programs with pattern-matching algebraic
data types . . . . . . . . . . . . . . . 587--598
Rajeev Alur and
Pavol Cerný Streaming transducers for algorithmic
verification of single-pass
list-processing programs . . . . . . . . 599--610
P. Madhusudan and
Gennaro Parlato and
Xiaokang Qiu Decidable logics combining heap
structures and data . . . . . . . . . . 611--622
Pramod G. Joisha and
Robert S. Schreiber and
Prithviraj Banerjee and
Hans J. Boehm and
Dhruva R. Chakrabarti A technique for the effective and
automatic reuse of classical compiler
optimizations on multithreaded code . . 623--636
Ralf Lämmel The hitchhiker's guide to software
languages . . . . . . . . . . . . . . . 1--2
Martin Erwig A language for software variation
research . . . . . . . . . . . . . . . . 3--12
Dave Clarke and
Michiel Helvensteijn and
Ina Schaefer Abstract delta modeling . . . . . . . . 13--22
Uwe Ryssel and
Joern Ploennigs and
Klaus Kabitzsch Automatic variation-point identification
in function-block-based models . . . . . 23--32
Julio Sincero and
Reinhard Tartler and
Daniel Lohmann and
Wolfgang Schröder-Preikschat Efficient extraction and analysis of
preprocessor-based variability . . . . . 33--42
Arie Middelkoop and
Atze Dijkstra and
S. Doaitse Swierstra Iterative type inference with attribute
grammars . . . . . . . . . . . . . . . . 43--52
Matthias P. Krieger and
Alexander Knapp and
Burkhart Wolff Automatic and efficient simulation of
operation contracts . . . . . . . . . . 53--62
Yuheng Long and
Sean L. Mooney and
Tyler Sondag and
Hridesh Rajan Implicit invocation meets safe, implicit
concurrency . . . . . . . . . . . . . . 63--72
Juan F. Navas and
Jean-Philippe Babau and
Jacques Pulou A component-based run-time evolution
infrastructure for resource-constrained
embedded systems . . . . . . . . . . . . 73--82
Christian Hofer and
Klaus Ostermann Modular domain-specific language
components in Scala . . . . . . . . . . 83--92
Reinhard Wolfinger and
Markus Löberbauer and
Markus Jahn and
Hanspeter Mössenböck Adding genericity to a plug-in framework 93--102
Sandro Schulze and
Sven Apel and
Christian Kästner Code clones in feature-oriented software
product lines . . . . . . . . . . . . . 103--112
Éric Tanter and
Philippe Moret and
Walter Binder and
Danilo Ansaloni Composition of dynamic analysis aspects 113--122
Thomas Würthinger and
Walter Binder and
Danilo Ansaloni and
Philippe Moret and
Hanspeter Mössenböck Applications of enhanced dynamic code
evolution for Java in GUI development
and dynamic aspect-oriented programming 123--126
Tiark Rompf and
Martin Odersky Lightweight modular staging: a pragmatic
approach to runtime code generation and
compiled DSLs . . . . . . . . . . . . . 127--136
Zoltán Porkolab and
Ábel Sinkovics Domain-specific language integration
with compile-time parser generator
library . . . . . . . . . . . . . . . . 137--146
Kevin Atkinson and
Matthew Flatt and
Gary Lindstrom ABI compatibility through a customizable
language . . . . . . . . . . . . . . . . 147--156
Mirko Bordignon and
Ulrik Pagh Schultz and
Kasper Stoy Model-based kinematics generation for
modular mechatronic toolkits . . . . . . 157--166
Weiyu Miao and
Jeremy G. Siek Incremental type-checking for
type-reflective metaprograms . . . . . . 167--176
Neville Grech and
Julian Rathke and
Bernd Fischer JEqualityGen: generating equality and
hashing methods . . . . . . . . . . . . 177--186
James R. Larus The cloud will change everything . . . . 1--2
Ding Yuan and
Jing Zheng and
Soyeon Park and
Yuanyuan Zhou and
Stefan Savage Improving software diagnosability via
log enhancement . . . . . . . . . . . . 3--14
Kaushik Veeraraghavan and
Dongyoon Lee and
Benjamin Wester and
Jessica Ouyang and
Peter M. Chen and
Jason Flinn and
Satish Narayanasamy DoublePlay: parallelizing sequential
logging and replay . . . . . . . . . . . 15--26
Jared Casper and
Tayo Oguntebi and
Sungpack Hong and
Nathan G. Bronson and
Christos Kozyrakis and
Kunle Olukotun Hardware acceleration of transactional
memory on commodity systems . . . . . . 27--38
Luke Dalessandro and
François Carouge and
Sean White and
Yossi Lev and
Mark Moir and
Michael L. Scott and
Michael F. Spear Hybrid NOrec: a case study in the
effectiveness of best effort hardware
transactional memory . . . . . . . . . . 39--52
Abhayendra Singh and
Daniel Marino and
Satish Narayanasamy and
Todd Millstein and
Madan Musuvathi Efficient processor support for DRFx, a
memory model with exceptions . . . . . . 53--66
Joseph Devietti and
Jacob Nelson and
Tom Bergan and
Luis Ceze and
Dan Grossman RCDC: a relaxed consistency
deterministic computer . . . . . . . . . 67--78
Jacob Burnim and
George Necula and
Koushik Sen Specifying and checking semantic
atomicity for multithreaded programs . . 79--90
Haris Volos and
Andres Jaan Tack and
Michael M. Swift Mnemosyne: lightweight persistent memory 91--104
Joel Coburn and
Adrian M. Caulfield and
Ameen Akel and
Laura M. Grupp and
Rajesh K. Gupta and
Ranjit Jhala and
Steven Swanson NV-Heaps: making persistent objects fast
and safe with next-generation,
non-volatile memories . . . . . . . . . 105--118
Adrian Schüpbach and
Andrew Baumann and
Timothy Roscoe and
Simon Peter A declarative language approach to
device configuration . . . . . . . . . . 119--132
Leonid Ryzhyk and
John Keys and
Balachandra Mirla and
Arun Raghunath and
Mona Vij and
Gernot Heiser Improved device driver reliability
through hardware verification reuse . . 133--144
Atif Hashmi and
Andrew Nere and
James Jamal Thomas and
Mikko Lipasti A case for neuromorphic ISAs . . . . . . 145--158
Benjamin Ransford and
Jacob Sorber and
Kevin Fu Mementos: system support for
long-running computation on RFID-scale
devices . . . . . . . . . . . . . . . . 159--170
Emmanouil Koukoumidis and
Dimitrios Lymberopoulos and
Karin Strauss and
Jie Liu and
Doug Burger Pocket cloudlets . . . . . . . . . . . . 171--184
Navin Sharma and
Sean Barker and
David Irwin and
Prashant Shenoy Blink: managing server clusters on
intermittent power . . . . . . . . . . . 185--198
Henry Hoffmann and
Stelios Sidiroglou and
Michael Carbin and
Sasa Misailovic and
Anant Agarwal and
Martin Rinard Dynamic knobs for responsive power-aware
computing . . . . . . . . . . . . . . . 199--212
Song Liu and
Karthik Pattabiraman and
Thomas Moscibroda and
Benjamin G. Zorn Flikker: saving DRAM refresh-power
through critical data partitioning . . . 213--224
Qingyuan Deng and
David Meisner and
Luiz Ramos and
Thomas F. Wenisch and
Ricardo Bianchini MemScale: active low-power modes for
main memory . . . . . . . . . . . . . . 225--238
Qi Gao and
Wenbin Zhang and
Zhezhe Chen and
Mai Zheng and
Feng Qin 2ndStrike: toward manifesting hidden
concurrency typestate bugs . . . . . . . 239--250
Wei Zhang and
Junghee Lim and
Ramya Olichandran and
Joel Scherpelz and
Guoliang Jin and
Shan Lu and
Thomas Reps ConSeq: detecting concurrency bugs
through sequential errors . . . . . . . 251--264
Vitaly Chipounov and
Volodymyr Kuznetsov and
George Candea S2E: a platform for in-vivo multi-path
analysis of software systems . . . . . . 265--278
Owen S. Hofmann and
Alan M. Dunn and
Sangman Kim and
Indrajit Roy and
Emmett Witchel Ensuring operating system kernel
integrity with OSck . . . . . . . . . . 279--290
Donald E. Porter and
Silas Boyd-Wickizer and
Jon Howell and
Reuben Olinsky and
Galen C. Hunt Rethinking the library OS from the top
down . . . . . . . . . . . . . . . . . . 291--304
Nicolas Palix and
Gaël Thomas and
Suman Saha and
Christophe Calv\`es and
Julia Lawall and
Gilles Muller Faults in Linux: ten years later . . . . 305--318
Hadi Esmaeilzadeh and
Ting Cao and
Yang Xi and
Stephen M. Blackburn and
Kathryn S. McKinley Looking back on the language and
hardware revolutions: measured power,
performance, and scaling . . . . . . . . 319--332
Donald Nguyen and
Keshav Pingali Synthesizing concurrent schedulers for
irregular algorithms . . . . . . . . . . 333--344
Giang Hoang and
Robby Bruce Findler and
Russ Joseph Exploring circuit timing-aware language
and compilation . . . . . . . . . . . . 345--356
Sardar M. Farhad and
Yousun Ko and
Bernd Burgstaller and
Bernhard Scholz Orchestration by approximation: mapping
stream programs onto multicore
architectures . . . . . . . . . . . . . 357--368
Eddy Z. Zhang and
Yunlian Jiang and
Ziyu Guo and
Kai Tian and
Xipeng Shen On-the-fly elimination of dynamic
irregularities for GPU computing . . . . 369--380
Amir H. Hormati and
Mehrzad Samadi and
Mark Woh and
Trevor Mudge and
Scott Mahlke Sponge: portable stream programming on
graphics engines . . . . . . . . . . . . 381--392
Md Kamruzzaman and
Steven Swanson and
Dean M. Tullsen Inter-core prefetching for multicore
processors using migrating helper
threads . . . . . . . . . . . . . . . . 393--404
Hiroshige Hayashizaki and
Peng Wu and
Hiroshi Inoue and
Mauricio J. Serrano and
Toshio Nakatani Improving the performance of trace-based
systems by false loop filtering . . . . 405--418
Vasanth Bala and
Evelyn Duesterwald and
Sanjeev Banerjia Dynamo: a transparent dynamic
optimization system . . . . . . . . . . 41--52
Koen Claessen and
John Hughes QuickCheck: a lightweight tool for
random testing of Haskell programs . . . 53--64
Matthew Arnold and
Stephen Fink and
David Grove and
Michael Hind and
Peter F. Sweeney Adaptive optimization in the Jalapeno
JVM . . . . . . . . . . . . . . . . . . 65--83
Samin Ishtiaq and
Peter W. O'Hearn BI as an assertion language for mutable
data structures . . . . . . . . . . . . 84--96
Bruno Virlet and
Xing Zhou and
Jean Pierre Giacalone and
Bob Kuhn and
Maria J. Garzaran and
David Padua Scheduling of stream-based real-time
applications for heterogeneous systems 1--10
Sudipta Chattopadhyay and
Abhik Roychoudhury Static bus schedule aware scratchpad
allocation in multiprocessors . . . . . 11--20
Elvira Albert and
Puri Arenas and
Samir Genaim and
Damiano Zanardini Task-level analysis for a language with
async/finish parallelism . . . . . . . . 21--30
Li-Pin Chang and
Li-Chun Huang A low-cost wear-leveling algorithm for
block-mapping solid-state disks . . . . 31--40
Suman Saha and
Julia Lawall and
Gilles Muller An approach to improving the structure
of error-handling code in the Linux
kernel . . . . . . . . . . . . . . . . . 41--50
Ian Gray and
Neil C. Audsley Targeting complex embedded architectures
by combining the multicore
communications API (\tt mcapi) with
compile-time virtualisation . . . . . . 51--60
Albert Benveniste and
Timothy Bourke and
Beno\^\it Caillaud and
Marc Pouzet Divide and recycle: types and
compilation for a hybrid synchronous
language . . . . . . . . . . . . . . . . 61--70
Abdoulaye Gamatie and
Laure Gonnord Static analysis of synchronous programs
in signal for efficient design of
multi-clocked embedded systems . . . . . 71--80
Nicolas Berthier and
Florence Maraninchi and
Laurent Mounier Synchronous programming of device
drivers for global resource control in
embedded operating systems . . . . . . . 81--90
Man Wang and
Zhiyuan Li and
Feng Li and
Xiaobing Feng and
Saurabh Bagchi and
Yung-Hsiang Lu Dependence-based multi-level tracing and
replay for wireless sensor networks
debugging . . . . . . . . . . . . . . . 91--100
Johnson J. Thomas and
Sebastian Fischmeister and
Deepak Kumar Lowering overhead in sampling-based
execution monitoring and tracing . . . . 101--110
Samaneh Navabpour and
Borzoo Bonakdarpour and
Sebastian Fischmeister Software debugging and testing using the
abstract diagnosis theory . . . . . . . 111--120
Christoph Cullmann Cache persistence analysis: a novel
approachtheory and practice . . . . . . 121--130
Abhik Sarkar and
Frank Mueller and
Harini Ramaprasad Predictable task migration for locked
caches in multi-core systems . . . . . . 131--140
Ernst Althaus and
Sebastian Altmeyer and
Rouven Naujoks Precise and efficient parametric path
analysis . . . . . . . . . . . . . . . . 141--150
Choonki Jang and
Jungwon Kim and
Jaejin Lee and
Hee-Seok Kim and
Dong-Hoon Yoo and
Sukjin Kim and
Hong-Seok Kim and
Soojung Ryu An instruction-scheduling-aware data
partitioning technique for
coarse-grained reconfigurable
architectures . . . . . . . . . . . . . 151--160
Indu Bhagat and
Enric Gibert and
Jesús Sánchez and
Antonio González Global productiveness propagation: a
code optimization technique to
speculatively prune useless narrow
computations . . . . . . . . . . . . . . 161--170
Prakash Prabhu and
Soumyadeep Ghosh and
Yun Zhang and
Nick P. Johnson and
David I. August Commutative set: a language extension
for implicit parallel programming . . . 1--11
Keshav Pingali and
Donald Nguyen and
Milind Kulkarni and
Martin Burtscher and
M. Amber Hassaan and
Rashid Kaleem and
Tsung-Hsien Lee and
Andrew Lenharth and
Roman Manevich and
Mario Méndez-Lojo and
Dimitrios Prountzos and
Xin Sui The tao of parallelism in algorithms . . 12--25
Arun Raman and
Hanjun Kim and
Taewook Oh and
Jae W. Lee and
David I. August Parallelism orchestration using DoPE:
the degree of parallelism executive . . 26--37
Peter Hawkins and
Alex Aiken and
Kathleen Fisher and
Martin Rinard and
Mooly Sagiv Data representation synthesis . . . . . 38--49
Sumit Gulwani and
Vijay Anand Korthikanti and
Ashish Tiwari Synthesizing geometry constructions . . 50--61
Sumit Gulwani and
Susmit Jha and
Ashish Tiwari and
Ramarathnam Venkatesan Synthesis of loop-free programs . . . . 62--73
Igor Böhm and
Tobias J. K. Edler von Koch and
Stephen C. Kyle and
Björn Franke and
Nigel Topham Generalized just-in-time trace
compilation using a parallel task farm
in a dynamic binary translator . . . . . 74--85
Changhee Jung and
Silvius Rus and
Brian P. Railing and
Nathan Clark and
Santosh Pande Brainy: effective selection of data
structures . . . . . . . . . . . . . . . 86--97
Hucheng Zhou and
Wenguang Chen and
Fred Chow An SSA-based algorithm for optimal
speculative code motion under an
execution profile . . . . . . . . . . . 98--108
Xun Li and
Mohit Tiwari and
Jason K. Oberg and
Vineeth Kashyap and
Frederic T. Chong and
Timothy Sherwood and
Ben Hardekopf Caisson: a hardware description language
for secure information flow . . . . . . 109--120
Derek Gordon Murray and
Michael Isard and
Yuan Yu Steno: automatic optimization of
declarative queries . . . . . . . . . . 121--131
Sam Tobin-Hochstadt and
Vincent St-Amour and
Ryan Culpepper and
Matthew Flatt and
Matthias Felleisen Languages as libraries . . . . . . . . . 132--141
Thomas B. Jablin and
Prakash Prabhu and
James A. Jablin and
Nick P. Johnson and
Stephen R. Beard and
David I. August Automatic CPU--GPU communication
management and optimization . . . . . . 142--151
Ashwin Prasad and
Jayvant Anantpur and
R. Govindarajan Automatic compilation of MATLAB programs
for synergistic execution on
heterogeneous processors . . . . . . . . 152--163
Adrian Sampson and
Werner Dietl and
Emily Fortuna and
Danushen Gnanapragasam and
Luis Ceze and
Dan Grossman EnerJ: approximate data types for safe
and general low-power computation . . . 164--174
Susmit Sarkar and
Peter Sewell and
Jade Alglave and
Luc Maranget and
Derek Williams Understanding POWER multiprocessors . . 175--186
Michael Kuperstein and
Martin Vechev and
Eran Yahav Partial-coherence abstractions for
relaxed memory models . . . . . . . . . 187--198
Daniel Marino and
Abhayendra Singh and
Todd Millstein and
Madanlal Musuvathi and
Satish Narayanasamy A case for an SC-preserving compiler . . 199--210
Nels E. Beckman and
Aditya V. Nori Probabilistic, modular and scalable
inference of typestate specifications 211--221
Naoki Kobayashi and
Ryosuke Sato and
Hiroshi Unno Predicate abstraction and CEGAR for
higher-order model checking . . . . . . 222--233
Adam Chlipala Mostly-automated verification of
low-level programs in computational
separation logic . . . . . . . . . . . . 234--245
Kyu Hyung Lee and
Yunhui Zheng and
Nick Sumner and
Xiangyu Zhang Toward generating reducible replay logs 246--257
Patrice Godefroid Higher-order test generation . . . . . . 258--269
Guoqing Xu and
Michael D. Bond and
Feng Qin and
Atanas Rountev LeakChaser: helping programmers narrow
down causes of memory leaks . . . . . . 270--282
Xuejun Yang and
Yang Chen and
Eric Eide and
John Regehr Finding and understanding bugs in C
compilers . . . . . . . . . . . . . . . 283--294
Jean-Baptiste Tristan and
Paul Govereau and
Greg Morrisett Evaluating value-graph translation
validation for LLVM . . . . . . . . . . 295--305
Jaroslav Sevcík Safe optimisations for shared-memory
concurrent programs . . . . . . . . . . 306--316
William R. Harris and
Sumit Gulwani Spreadsheet table transformations from
examples . . . . . . . . . . . . . . . . 317--328
Na Meng and
Miryung Kim and
Kathryn S. McKinley Systematic editing: generating program
transformations from an example . . . . 329--342
Varun Srivastava and
Michael D. Bond and
Kathryn S. McKinley and
Vitaly Shmatikov A security policy oracle: detecting
security holes using multiple API
implementations . . . . . . . . . . . . 343--354
Jason Ansel and
Petr Marchenko and
Ulfar Erlingsson and
Elijah Taylor and
Brad Chen and
Derek L. Schuff and
David Sehr and
Cliff L. Biffle and
Bennet Yee Language-independent sandboxing of
just-in-time compilation and
self-modifying code . . . . . . . . . . 355--366
Qiang Zeng and
Dinghao Wu and
Peng Liu Cruiser: concurrent heap buffer overflow
monitoring using lock-free data
structures . . . . . . . . . . . . . . . 367--377
Brandon Lucia and
Benjamin P. Wood and
Luis Ceze Isolating and understanding concurrency
errors using reconstructed execution
fragments . . . . . . . . . . . . . . . 378--388
Guoliang Jin and
Linhai Song and
Wei Zhang and
Shan Lu and
Ben Liblit Automated atomicity-violation fixing . . 389--400
Jacob Burnim and
Tayfun Elmas and
George Necula and
Koushik Sen NDSeq: runtime checking for
nondeterministic sequential
specifications of parallel correctness 401--414
Dongyun Jin and
Patrick O'Neil Meredith and
Dennis Griffith and
Grigore Rosu Garbage collection for monitoring
parametric properties . . . . . . . . . 415--424
Terence Parr and
Kathleen Fisher LL(*): the foundation of the ANTLR
parser generator . . . . . . . . . . . . 425--436
Manu Jose and
Rupak Majumdar Cause clue clauses: error localization
using maximum satisfiability . . . . . . 437--446
Aditya Budi and
David Lo and
Lingxiao Jiang and
Lucia $ k b $-anonymity: a model for
anonymized behaviour-preserving test and
debugging data . . . . . . . . . . . . . 447--457
Saturnino Garcia and
Donghwan Jeon and
Christopher M. Louie and
Michael Bedford Taylor Kremlin: rethinking and rebooting \tt
gprof for the multicore age . . . . . . 458--469
Shigeyuki Sato and
Hideya Iwasaki Automatic parallelization via matrix
multiplication . . . . . . . . . . . . . 470--479
Abhishek Udupa and
Kaushik Rajan and
William Thies ALTER: exploiting breakable dependences
for parallelization . . . . . . . . . . 480--491
Saurabh Srivastava and
Sumit Gulwani and
Swarat Chaudhuri and
Jeffrey S. Foster Path-based inductive synthesis for
program inversion . . . . . . . . . . . 492--503
Suzette Person and
Guowei Yang and
Neha Rungta and
Sarfraz Khurshid Directed incremental symbolic execution 504--515
Daniele Cono D'Elia and
Camil Demetrescu and
Irene Finocchi Mining hot calling contexts in small
space . . . . . . . . . . . . . . . . . 516--527
Deokhwan Kim and
Martin C. Rinard Verification of semantic commutativity
conditions and inverse operations on
linked data structures . . . . . . . . . 528--541
Milind Kulkarni and
Donald Nguyen and
Dimitrios Prountzos and
Xin Sui and
Keshav Pingali Exploiting the commutativity lattice . . 542--555
Juan Antonio Navarro Pérez and
Andrey Rybalchenko Separation logic $+$ superposition
calculus $=$ heap theorem prover . . . . 556--566
Isil Dillig and
Thomas Dillig and
Alex Aiken and
Mooly Sagiv Precise and compact modular procedure
summaries for heap manipulating programs 567--577
Ahmed Bouajjani and
Cezara Dragoi and
Constantin Enea and
Mihaela Sighireanu On inter-procedural analysis of programs
with lists and data . . . . . . . . . . 578--589
Percy Liang and
Mayur Naik Scaling abstraction refinement via
pruning . . . . . . . . . . . . . . . . 590--601
John Altidor and
Shan Shan Huang and
Yannis Smaragdakis Taming the wildcards: combining
definition- and use-site variance . . . 602--613
Ross Tate and
Alan Leung and
Sorin Lerner Taming wildcards in Java's type system 614--627
Lukasz Ziarek and
KC Sivaramakrishnan and
Suresh Jagannathan Composable asynchronous events . . . . . 628--639
Micah J. Best and
Shane Mottishaw and
Craig Mustard and
Mark Roth and
Alexandra Fedorova and
Andrew Brownsword Synchronization via scheduling:
techniques for efficiently managing
shared state . . . . . . . . . . . . . . 640--652
David F. Bacon Virtualization in the age of
heterogeneous machines . . . . . . . . . 1--2
Jiaqing Du and
Nipun Sehrawat and
Willy Zwaenepoel Performance profiling of virtual
machines . . . . . . . . . . . . . . . . 3--14
Ruslan Nikolaev and
Godmar Back Perfctr-Xen: a framework for performance
counter virtualization . . . . . . . . . 15--26
Qin Zhao and
David Koh and
Syed Raza and
Derek Bruening and
Weng-Fai Wong and
Saman Amarasinghe Dynamic cache contention detection in
multi-threaded applications . . . . . . 27--38
Kun Wang and
Jia Rao and
Cheng-Zhong Xu Rethink the virtual machine template . . 39--50
Emmanuel Cecchet and
Rahul Singh and
Upendra Sharma and
Prashant Shenoy Dolly: virtualization-driven database
provisioning for the cloud . . . . . . . 51--62
Michael Le and
Yuval Tamir ReHype: enabling VM survival across
hypervisor failures . . . . . . . . . . 63--74
Eunbyung Park and
Bernhard Egger and
Jaejin Lee Fast and space-efficient virtual machine
checkpointing . . . . . . . . . . . . . 75--86
Irene Zhang and
Alex Garthwaite and
Yury Baskakov and
Kenneth C. Barr Fast restore of checkpointed memory
using working set estimation . . . . . . 87--98
Kenichi Kourai Fast and correct performance recovery of
operating systems using a virtual
machine monitor . . . . . . . . . . . . 99--110
Petter Svärd and
Benoit Hudzia and
Johan Tordsson and
Erik Elmroth Evaluation of delta compression
techniques for efficient live migration
of large virtual machines . . . . . . . 111--120
Timothy Wood and
K. K. Ramakrishnan and
Prashant Shenoy and
Jacobus van der Merwe CloudNet: dynamic pooling of cloud
resources by live WAN migration of
virtual machines . . . . . . . . . . . . 121--132
Jie Zheng and
Tze Sing Eugene Ng and
Kunwadee Sripanidkulchai Workload-aware live storage migration
for clouds . . . . . . . . . . . . . . . 133--144
Lionel Litty and
David Lie Patch auditing in infrastructure as a
service clouds . . . . . . . . . . . . . 145--156
Mathias Payer and
Thomas R. Gross Fine-grained user-space security through
virtualization . . . . . . . . . . . . . 157--168
John R. Lange and
Kevin Pedretti and
Peter Dinda and
Patrick G. Bridges and
Chang Bae and
Philip Soltero and
Alexander Merritt Minimal-overhead virtualization of a
large scale supercomputer . . . . . . . 169--180
Lei Xia and
Sanjay Kumar and
Xue Yang and
Praveen Gopalakrishnan and
York Liu and
Sebastian Schoenberg and
Xingang Guo Virtual WiFi: bring virtualization from
wired to wireless . . . . . . . . . . . 181--192
John R. Lange and
Peter Dinda SymCall: symbiotic virtualization
through VMM-to-guest upcalls . . . . . . 193--204
Dan Williams and
Hani Jamjoom and
Yew-Huey Liu and
Hakim Weatherspoon Overdriver: handling memory overload in
an oversubscribed cloud . . . . . . . . 205--216
Xiaolin Wang and
Jiarui Zang and
Zhenlin Wang and
Yingwei Luo and
Xiaoming Li Selective hardware/software memory
virtualization . . . . . . . . . . . . . 217--226
Amitabha Roy and
Steven Hand and
Tim Harris Hybrid binary rewriting for memory
access instrumentation . . . . . . . . . 227--238
James R. Larus Programming the cloud . . . . . . . . . 1--2
Muhammad Amber Hassaan and
Martin Burtscher and
Keshav Pingali Ordered vs. unordered: a comparison of
parallelism and work-efficiency in
irregular algorithms . . . . . . . . . . 3--12
Michael Bauer and
John Clark and
Eric Schkufza and
Alex Aiken Programming the memory hierarchy
revisited: supporting irregular
parallelism in Sequoia . . . . . . . . . 13--24
Alin Murarasu and
Josef Weidendorfer and
Gerrit Buse and
Daniel Butnaru and
Dirk Pflüger Compact data structure and scalable
algorithms for the sparse grid technique 25--34
Hassan Chafi and
Arvind K. Sujeeth and
Kevin J. Brown and
HyoukJoong Lee and
Anand R. Atreya and
Kunle Olukotun A domain-specific approach to
heterogeneous parallelism . . . . . . . 35--46
Bryan Catanzaro and
Michael Garland and
Kurt Keutzer Copperhead: compiling an embedded data
parallel language . . . . . . . . . . . 47--56
James Christopher Jenista and
Yong hun Eom and
Brian Charles Demsky OoOJava: software out-of-order execution 57--68
Min Feng and
Rajiv Gupta and
Yi Hu SpiceC: scalable parallelism via
implicit copying and explicit commit . . 69--80
Stas Negara and
Rajesh K. Karmani and
Gul Agha Inferring ownership transfer for
efficient message passing . . . . . . . 81--90
Xiaoya Xiang and
Bin Bao and
Tongxin Bai and
Chen Ding and
Trishul Chilimbi All-window profiling and composable
models of cache sharing . . . . . . . . 91--102
Xiaoning Ding and
Kaibo Wang and
Xiaodong Zhang ULCC: a user-level facility for
optimizing shared cache performance on
multicores . . . . . . . . . . . . . . . 103--112
Xing Wu and
Frank Mueller ScalaExtrap: trace-based communication
extrapolation for SPMD programs . . . . 113--122
Kathryn S. McKinley How's the parallel computing revolution
going? . . . . . . . . . . . . . . . . . 123--124
Rajesh K. Karmani and
P. Madhusudan and
Brandon M. Moore Thread contracts for safe parallelism 125--134
Mai Zheng and
Vignesh T. Ravi and
Feng Qin and
Gagan Agrawal GRace: a low-overhead mechanism for
detecting data races in GPU programs . . 135--146
Jaeheon Yi and
Caitlin Sadowski and
Cormac Flanagan Cooperative reasoning for preemptive
execution . . . . . . . . . . . . . . . 147--156
Mohsen Lesani and
Jens Palsberg Communicating memory transactions . . . 157--168
Victor Luchangco and
Virendra J. Marathe Transaction communicators: enabling
cooperation among concurrent
transactions . . . . . . . . . . . . . . 169--178
Sérgio Miguel Fernandes and
João Cachopo Lock-free and scalable multi-version
software transactional memory . . . . . 179--188
Chen Tian and
Changhui Lin and
Min Feng and
Rajiv Gupta Enhanced speculative parallelization via
incremental recovery . . . . . . . . . . 189--200
Vijay A. Saraswat and
Prabhanjan Kambadur and
Sreedhar Kodali and
David Grove and
Sriram Krishnamoorthy Lifeline-based global load balancing . . 201--212
Zhaoguo Wang and
Ran Liu and
Yufei Chen and
Xi Wu and
Haibo Chen and
Weihua Zhang and
Binyu Zang COREMU: a scalable and portable parallel
full-system emulator . . . . . . . . . . 213--222
Alex Kogan and
Erez Petrank Wait-free queues with multiple enqueuers
and dequeuers . . . . . . . . . . . . . 223--234
Gabriel Tanase and
Antal Buss and
Adam Fidel and
Harshvardhan Harshvardhan and
Ioannis Papadopoulos and
Olga Pearce and
Timmie Smith and
Nathan Thomas and
Xiabing Xu and
Nedal Mourad and
Jeremy Vu and
Mauro Bianco and
Nancy M. Amato and
Lawrence Rauchwerger The STAPL parallel container framework 235--246
Kornilios Kourtis and
Vasileios Karakasis and
Georgios Goumas and
Nectarios Koziris CSX: an extended compression format for
SpMV on shared memory systems . . . . . 247--256
Yuri Dotsenko and
Sara S. Baghsorkhi and
Brandon Lloyd and
Naga K. Govindaraju Auto-tuning of Fast Fourier Transform on
graphics processors . . . . . . . . . . 257--266
Sungpack Hong and
Sang Kyun Kim and
Tayo Oguntebi and
Kunle Olukotun Accelerating CUDA graph algorithms at
maximum warp . . . . . . . . . . . . . . 267--276
Jungwon Kim and
Honggyu Kim and
Joo Hwan Lee and
Jaejin Lee Achieving a single compute device image
in OpenCL for multiple GPUs . . . . . . 277--288
Ramya Prabhakar and
Shekhar Srikantaiah and
Rajat Garg and
Mahmut Kandemir QoS aware storage cache management in
multi-server environments . . . . . . . 289--290
Amitabha Roy and
Steven Hand and
Tim Harris Weak atomicity under the x86 memory
consistency model . . . . . . . . . . . 291--292
Donghwan Jeon and
Saturnino Garcia and
Chris Louie and
Sravanthi Kota Venkata and
Michael Bedford Taylor Kremlin: like \tt gprof, but for
parallelization . . . . . . . . . . . . 293--294
Robert Strzodka and
Mohammed Shaheen and
Dawid Pajak Time skewing made simple . . . . . . . . 295--296
Andre Vincent Pascal Grosset and
Peihong Zhu and
Shusen Liu and
Suresh Venkatasubramanian and
Mary Hall Evaluating graph coloring on GPUs . . . 297--298
Chen Ding Two examples of parallel programming
without concurrency constructs (PP-CC) 299--300
Philippe Stellwag and
Fabian Scheler and
Jakob Krainz and
Wolfgang Schröder-Preikschat A wait-free NCAS library for parallel
applications with timing constraints . . 301--302
Teresa Davies and
Zizhong Chen and
Christer Karlsson and
Hui Liu Algorithm-based recovery for HPL . . . . 303--304
Jeremiah James Willcock and
Torsten Hoefler and
Nicholas Gerard Edmonds and
Andrew Lumsdaine Active Pebbles: a programming model for
highly parallel fine-grained data-driven
computations . . . . . . . . . . . . . . 305--306
Topher Fischer and
Eric Mercer and
Neha Rungta Symbolically modeling concurrent MCAPI
executions . . . . . . . . . . . . . . . 307--308
Stephen F. Siegel and
Timothy K. Zirkel Automatic formal verification of
MPI-based parallel programs . . . . . . 309--310
Alastair F. Donaldson and
Daniel Kroening and
Philipp Ruemmer SCRATCH: a tool for automatic analysis
of DMA races . . . . . . . . . . . . . . 311--312
Matko Botincan and
Mike Dodds and
Alastair F. Donaldson and
Matthew J. Parkinson Automatic safety proofs for asynchronous
memory operations . . . . . . . . . . . 313--314
Andrzej Filinski Towards a comprehensive theory of
monadic effects . . . . . . . . . . . . 1--1
Jeremy Gibbons and
Ralf Hinze Just do it: simple monadic equational
reasoning . . . . . . . . . . . . . . . 2--14
Nikhil Swamy and
Nataliya Guts and
Daan Leijen and
Michael Hicks Lightweight monadic programming in ML 15--27
Emily G. Mitchell Functional programming through deep
time: modeling the first complex
ecosystems on Earth . . . . . . . . . . 28--31
Tom Schrijvers and
Bruno C. d. S. Oliveira Monads, zippers and views: virtualizing
the monad stack . . . . . . . . . . . . 32--44
Neelakantan R. Krishnaswami and
Nick Benton A semantic model for graphical user
interfaces . . . . . . . . . . . . . . . 45--57
Olin Shivers and
Aaron J. Turon Modular rollback through control
logging: a pair of twin functional
pearls . . . . . . . . . . . . . . . . . 58--68
Dimitrios Vardoulakis and
Olin Shivers Pushdown flow analysis of first-class
control . . . . . . . . . . . . . . . . 69--80
Marek Materzok and
Dariusz Biernacki Subtyping delimited continuations . . . 81--93
Giuseppe Castagna and
Zhiwu Xu Set-theoretic foundation of parametric
polymorphism and subtyping . . . . . . . 94--106
Nils Gesbert and
Pierre Genev\`es and
Nabil Laya\"\ida Parametric polymorphism and semantic
subtyping: the logical connection . . . 107--116
Akimasa Morihata and
Kiminori Matsuzaki Balanced trees inhabiting functional
parallel programming . . . . . . . . . . 117--128
Yan Chen and
Joshua Dunfield and
Matthew A. Hammer and
Umut A. Acar Implicit self-adjusting computation for
purely functional programs . . . . . . . 129--141
Makoto Takeyama Programming assurance cases in Agda . . 142--142
Dominique Devriese and
Frank Piessens On the bright side of type classes:
instance arguments in Agda . . . . . . . 143--155
José Pedro Magalhães and
W. Bas de Haas Functional modelling of musical harmony:
an experience report . . . . . . . . . . 156--162
Georges Gonthier and
Beta Ziliani and
Aleksandar Nanevski and
Derek Dreyer How to make ad hoc proof automation less
ad hoc . . . . . . . . . . . . . . . . . 163--175
Tim Disney and
Cormac Flanagan and
Jay McCarthy Temporal higher-order contracts . . . . 176--188
Matthew Might and
David Darais and
Daniel Spiewak Parsing with derivatives: a functional
pearl . . . . . . . . . . . . . . . . . 189--195
Katsuhiro Ueno and
Atsushi Ohori and
Toshiaki Otomo An efficient non-moving garbage
collector for functional languages . . . 196--208
Andy Gill and
Andrew Farmer Deriving an efficient FPGA
implementation of a low density parity
check forward error corrector . . . . . 209--220
Dan R. Ghica and
Alex Smith and
Satnam Singh Geometry of synthesis IV: compiling
affine recursion into static hardware 221--233
Ki Yung Ahn and
Tim Sheard A hierarchy of mendler style recursion
combinators: taming inductive datatypes
with negative occurrences . . . . . . . 234--246
Barry Jay and
Jens Palsberg Typed self-interpretation by pattern
matching . . . . . . . . . . . . . . . . 247--258
Frédéric Chyzak and
Alexis Darrasse Using \tt camlp4 for presenting dynamic
mathematics on the Web: DynaMoW, an
OCaml language extension for the
run-time generation of mathematical
contents and their presentation on the
Web . . . . . . . . . . . . . . . . . . 259--265
Nikhil Swamy and
Juan Chen and
Cédric Fournet and
Pierre-Yves Strub and
Karthikeyan Bhargavan and
Jean Yang Secure distributed programming with
value-dependent types . . . . . . . . . 266--278
Nate Foster and
Rob Harrison and
Michael J. Freedman and
Christopher Monsanto and
Jennifer Rexford and
Alec Story and
David Walker Frenetic: a network programming language 279--291
Kathleen Fisher and
Nate Foster and
David Walker and
Kenny Q. Zhu Forest: a language and toolkit for
programming with filestores . . . . . . 292--306
Atsushi Ohori and
Katsuhiro Ueno Making Standard ML a practical database
programming language . . . . . . . . . . 307--319
Nicolas Pouillard Nameless, painless . . . . . . . . . . . 320--332
Stephanie Weirich and
Brent A. Yorgey and
Tim Sheard Binders unbound . . . . . . . . . . . . 333--345
Andrei Popescu and
Elsa L. Gunter Recursion principles for syntax with
bindings and substitution . . . . . . . 346--358
Ralf Hinze and
Daniel W. H. James Proving the unique fixed-point principle
correct: an adventure with category
theory . . . . . . . . . . . . . . . . . 359--371
Marco Gaboardi and
Luca Paolini and
Mauro Piccolo Linearity and PCF: a semantic insight! 372--384
Shin-Cheng Mu and
Akimasa Morihata Generalising and dualising the third
list-homomorphism theorem: functional
pearl . . . . . . . . . . . . . . . . . 385--391
Meng Wang and
Jeremy Gibbons and
Nicolas Wu Incremental updates for efficient
bidirectional transformations . . . . . 392--403
Alexey Gotsman and
Hongseok Yang Modular verification of preemptive OS
kernels . . . . . . . . . . . . . . . . 404--417
Arthur Charguéraud Characteristic formulae for the
verification of imperative programs . . 418--430
Amal Ahmed and
Matthias Blume An equivalence-preserving CPS
translation via multi-language semantics 431--444
Jacob Thamsborg and
Lars Birkedal A Kripke logical relation for
effect-based program transformations . . 445--456
Ivan Sutherland The sequential prison . . . . . . . . . 1--2
Tongping Liu and
Emery D. Berger SHERIFF: precise detection and automatic
mitigation of false sharing . . . . . . 3--18
Dasarath Weeratunge and
Xiangyu Zhang and
Suresh Jaganathan Accentuating the positive: atomicity
inference and enforcement using correct
executions . . . . . . . . . . . . . . . 19--34
Du Li and
Witawas Srisa-an and
Matthew B. Dwyer SOS: saving time in dynamic race
detection with stationary analysis . . . 35--50
Ohad Shacham and
Nathan Bronson and
Alex Aiken and
Mooly Sagiv and
Martin Vechev and
Eran Yahav Testing atomicity of composed concurrent
operations . . . . . . . . . . . . . . . 51--64
Kuat Yessenov and
Zhilei Xu and
Armando Solar-Lezama Data-driven synthesis for
object-oriented frameworks . . . . . . . 65--82
Yewen Pu and
Rastislav Bodik and
Saurabh Srivastava Synthesis of first-order dynamic
programming algorithms . . . . . . . . . 83--98
Jesse Doherty and
Laurie Hendren and
Soroush Radpour Kind analysis for MATLAB . . . . . . . . 99--118
Asger Feldthaus and
Todd Millstein and
Anders Mòller and
Max Schäfer and
Frank Tip Tool-supported refactoring for
JavaScript . . . . . . . . . . . . . . . 119--138
Lennart C. L. Kats and
Rob Vermaas and
Eelco Visser Integrated language definition testing:
enabling test-driven language
development . . . . . . . . . . . . . . 139--154
Milan Jovic and
Andrea Adamoli and
Matthias Hauswirth Catch me if you can: performance bug
detection in the wild . . . . . . . . . 155--170
Pallavi Joshi and
Haryadi S. Gunawi and
Koushik Sen PREFAIL: a programmable tool for
multiple-failure injection . . . . . . . 171--188
Suresh Thummalapenta and
Tao Xie and
Nikolai Tillmann and
Jonathan de Halleux and
Zhendong Su Synthesizing method sequences for
high-coverage testing . . . . . . . . . 189--206
Omer Tripp and
Greta Yorsh and
John Field and
Mooly Sagiv HAWKEYE: effective discovery of dataflow
impediments to parallelization . . . . . 207--224
Guy Golan-Gueta and
Nathan Bronson and
Alex Aiken and
G. Ramalingam and
Mooly Sagiv and
Eran Yahav Automatic fine-grain locking using shape
properties . . . . . . . . . . . . . . . 225--242
Chuanle Ke and
Lei Liu and
Chao Zhang and
Tongxin Bai and
Bryan Jacobs and
Chen Ding Safe parallel programming using dynamic
dependence hints . . . . . . . . . . . . 243--258
Arun Raman and
Greta Yorsh and
Martin Vechev and
Eran Yahav Sprint: speculative prefetching of
remote data . . . . . . . . . . . . . . 259--274
Edward E. Aftandilian and
Samuel Z. Guyer and
Martin Vechev and
Eran Yahav Asynchronous assertions . . . . . . . . 275--288
Kevin J. Hoffman and
Harrison Metzger and
Patrick Eugster Ribbons: a partially shared memory
programming model . . . . . . . . . . . 289--306
Xi Yang and
Stephen M. Blackburn and
Daniel Frampton and
Jennifer B. Sartor and
Kathryn S. McKinley Why nothing matters: the impact of
zeroing . . . . . . . . . . . . . . . . 307--324
Eva Darulova and
Viktor Kuncak Trustworthy numerical computation in
Scala . . . . . . . . . . . . . . . . . 325--344
Siliang Li and
Gang Tan JET: exception checking in the Java
Native Interface . . . . . . . . . . . . 345--358
Cristina David and
Wei-Ngan Chin Immutable specifications for more
concise and precise verification . . . . 359--374
Amin Shali and
William R. Cook Hybrid partial evaluation . . . . . . . 375--390
Sebastian Erdweg and
Tillmann Rendel and
Christian Kästner and
Klaus Ostermann SugarJ: library-based syntactic language
extensibility . . . . . . . . . . . . . 391--406
Camil Demetrescu and
Irene Finocchi and
Andrea Ribichini Reactive imperative programming with
dataflow constraints . . . . . . . . . . 407--426
Sebastian Burckhardt and
Daan Leijen and
Caitlin Sadowski and
Jaeheon Yi and
Thomas Ball Two for the price of one: a model for
parallel and incremental computation . . 427--444
Kai Tian and
Eddy Zhang and
Xipeng Shen A step towards transparent integration
of input-consciousness into dynamic
program optimizations . . . . . . . . . 445--462
Youngjoon Jo and
Milind Kulkarni Enhancing locality for recursive
traversals of recursive structures . . . 463--482
Michael D. Adams and
Andrew W. Keep and
Jan Midtgaard and
Matthew Might and
Arun Chauhan and
R. Kent Dybvig Flow-sensitive type recovery in
linear-log time . . . . . . . . . . . . 483--498
Umut A. Acar and
Arthur Charguéraud and
Mike Rainey Oracle scheduling: controlling
granularity in implicitly parallel
languages . . . . . . . . . . . . . . . 499--518
Donghwan Jeon and
Saturnino Garcia and
Chris Louie and
Michael Bedford Taylor Kismet: parallel speedup estimates for
serial programs . . . . . . . . . . . . 519--536
Romain E. Cledat and
Tushar Kumar and
Santosh Pande Efficiently speeding up sequential
computation through the n-way
programming model . . . . . . . . . . . 537--554
Hari K. Pyla and
Calvin Ribbens and
Srinidhi Varadarajan Exploiting coarse-grain speculative
parallelism . . . . . . . . . . . . . . 555--574
Aaron J. Turon and
Claudio V. Russo Scalable join patterns . . . . . . . . . 575--594
Benjamin Delaware and
William Cook and
Don Batory Product lines of theorems . . . . . . . 595--608
Lintaro Ina and
Atsushi Igarashi Gradual typing for generics . . . . . . 609--624
Jesse A. Tov and
Riccardo Pucella A theory of substructural types and
control . . . . . . . . . . . . . . . . 625--642
Raymond P. L. Buse and
Caitlin Sadowski and
Westley Weimer Benefits and barriers of user evaluation
in software engineering research . . . . 643--656
Andreas Sewe and
Mira Mezini and
Aibek Sarimbekov and
Walter Binder Da capo con Scala: design and analysis
of a Scala benchmark suite for the Java
Virtual Machine . . . . . . . . . . . . 657--676
Gregor Richards and
Andreas Gal and
Brendan Eich and
Jan Vitek Automated construction of JavaScript
benchmarks . . . . . . . . . . . . . . . 677--694
Zef Hemel and
Eelco Visser Declaratively programming the Mobile Web
with Mobl . . . . . . . . . . . . . . . 695--712
Joshua Sunshine and
Karl Naden and
Sven Stork and
Jonathan Aldrich and
Éric Tanter First-class state change in Plaid . . . 713--732
David H. Lorenz and
Boaz Rosenan Cedalion: a language for language
oriented programming . . . . . . . . . . 733--752
Matthew A. Hammer and
Georg Neis and
Yan Chen and
Umut A. Acar Self-adjusting stack machines . . . . . 753--772
Prasad A. Kulkarni JIT compilation policy for modern
machines . . . . . . . . . . . . . . . . 773--788
Peng Wu and
Hiroshige Hayashizaki and
Hiroshi Inoue and
Toshio Nakatani Reducing trace selection footprint for
large-scale Java applications without
performance loss . . . . . . . . . . . . 789--804
Christian Kästner and
Paolo G. Giarrusso and
Tillmann Rendel and
Sebastian Erdweg and
Klaus Ostermann and
Thorsten Berger Variability-aware parsing in the
presence of lexical macros and
conditional compilation . . . . . . . . 805--824
Thomas Würthinger and
Danilo Ansaloni and
Walter Binder and
Christian Wimmer and
Hanspeter Mössenböck Safe and atomic run-time code evolution
for Java and its application to dynamic
AOP . . . . . . . . . . . . . . . . . . 825--844
Pedro da Rocha Pinto and
Thomas Dinsdale-Young and
Mike Dodds and
Philippa Gardner and
Mark Wheelhouse A simple abstraction for complex
concurrent indexes . . . . . . . . . . . 845--864
Zachary Anderson and
David Gay Composable, nestable, pessimistic atomic
statements . . . . . . . . . . . . . . . 865--884
Roberto Lublinerman and
Jisheng Zhao and
Zoran Budimli\'c and
Swarat Chaudhuri and
Vivek Sarkar Delegated isolation . . . . . . . . . . 885--902
Tim Harris and
Martin Abadi and
Rebecca Isaacs and
Ross McIlroy AC: composable asynchronous IO for
native languages . . . . . . . . . . . . 903--920
Thomas H. Austin and
Tim Disney and
Cormac Flanagan Virtual values for language extension 921--938
Zachary Palmer and
Scott F. Smith Backstage Java: making a difference in
metaprogramming . . . . . . . . . . . . 939--958
Toon Verwaest and
Camillo Bruni and
Mircea Lungu and
Oscar Nierstrasz Flexible object layouts: enabling
lightweight language extensions by
intercepting slot access . . . . . . . . 959--972
Eric Allen and
Justin Hilburn and
Scott Kilpatrick and
Victor Luchangco and
Sukyoung Ryu and
David Chase and
Guy Steele Type checking modular multiple dispatch
with parametric polymorphism and
multiple inheritance . . . . . . . . . . 973--992
Hyeonseung Im and
Keiko Nakata and
Jacques Garrigue and
Sungwoo Park A syntactic type system for recursive
modules . . . . . . . . . . . . . . . . 993--1012
Alexander J. Summers and
Peter Mueller Freedom before commitment: a lightweight
type system for object initialisation 1013--1032
Ravichandhran Madhavan and
Raghavan Komondoor Null dereference verification via
over-approximated weakest pre-conditions
analysis . . . . . . . . . . . . . . . . 1033--1052
Manu Sridharan and
Shay Artzi and
Marco Pistoia and
Salvatore Guarnieri and
Omer Tripp and
Ryan Berg F4F: taint analysis of framework-based
Web applications . . . . . . . . . . . . 1053--1068
Sooel Son and
Kathryn S. McKinley and
Vitaly Shmatikov RoleCast: finding missing security
checks when you do not know what checks
are . . . . . . . . . . . . . . . . . . 1069--1084
Ronald Veldema and
Michæl Philippsen Iterative data-parallel mark&sweep on a
GPU . . . . . . . . . . . . . . . . . . 1--10
Zoltan Majo and
Thomas R. Gross Memory management in NUMA multicore
systems: trapped between cache
contention and interconnect overhead . . 11--20
Simon Marlow and
Simon Peyton Jones Multicore garbage collection with local
heaps . . . . . . . . . . . . . . . . . 21--32
Robin J. Garner and
Stephen M. Blackburn and
Daniel Frampton A comprehensive evaluation of object
scanning techniques . . . . . . . . . . 33--42
Xiaoming Gu and
Chen Ding On the theory and potential of LRU--MRU
collaborative cache management . . . . . 43--54
Yehuda Afek and
Dave Dice and
Adam Morrison Cache index-aware memory allocation . . 55--64
Matthew Hertz and
Stephen Kane and
Elizabeth Keudel and
Tongxin Bai and
Chen Ding and
Xiaoming Gu and
Jonathan E. Bard Waste not, want not: resource-based
garbage collection in a shared
environment . . . . . . . . . . . . . . 65--76
Onur Mutlu Memory systems in the many-core era:
challenges, opportunities, and solution
directions . . . . . . . . . . . . . . . 77--78
Gil Tene and
Balaji Iyengar and
Michael Wolf C4: the continuously concurrent
compacting collector . . . . . . . . . . 79--88
Tomas Kalibera and
Richard Jones Handles revisited: optimising
performance and memory costs in a
real-time collector . . . . . . . . . . 89--98
Martin Aigner and
Andreas Haas and
Christoph M. Kirsch and
Michael Lippautz and
Ana Sokolova and
Stephanie Stroka and
Andreas Unterweger Short-term memory for self-collecting
mutators . . . . . . . . . . . . . . . . 99--108
Jeremy Singer and
George Kovoor and
Gavin Brown and
Mikel Luján Garbage collection auto-tuning for Java
MapReduce on multi-cores . . . . . . . . 109--118
Gregor Wagner and
Andreas Gal and
Christian Wimmer and
Brendan Eich and
Michael Franz Compartmental memory management in a
modern Web browser . . . . . . . . . . . 119--128
Paul Tarau Integrated symbol table, engine and heap
memory management in multi-engine Prolog 129--138
Tomas Petricek and
Alan Mycroft and
Don Syme Extending monads with pattern matching 1--12
George Giorgidze and
Torsten Grust and
Nils Schweinsberg and
Jeroen Weijers Bringing back monad comprehensions . . . 13--22
Maximilian Bolingbroke and
Simon Peyton Jones and
Dimitrios Vytiniotis Termination combinators forever . . . . 23--34
Edwin Westbrook and
Nicolas Frisby and
Paul Brauner Hobbits for Haskell: a library for
higher-order encodings in functional
programming languages . . . . . . . . . 35--46
Thomas Harper A library writer's guide to shortcut
fusion . . . . . . . . . . . . . . . . . 47--58
Ben Lippmeier and
Gabriele Keller Efficient parallel stencil convolution
in Haskell . . . . . . . . . . . . . . . 59--70
Simon Marlow and
Ryan Newton and
Simon Peyton Jones A monad for deterministic parallelism 71--82
Daan Leijen and
Manuel Fahndrich and
Sebastian Burckhardt Prettier concurrency: purely functional
concurrent revisions . . . . . . . . . . 83--94
Deian Stefan and
Alejandro Russo and
John C. Mitchell and
David Mazi\`eres Flexible dynamic information flow
control in Haskell . . . . . . . . . . . 95--106
Jonas Duregård and
Patrik Jansson Embedded parser generators . . . . . . . 107--117
Jeff Epstein and
Andrew P. Black and
Simon Peyton-Jones Towards Haskell in the cloud . . . . . . 118--129
Andrew P. Black and
Peter W. O'Hearn Presentation of the SIGPLAN
distinguished achievement award to Sir
Charles Antony Richard Hoare, FRS,
FREng, FBCS; and interview . . . . . . . 1--2
Tony Hoare Message of thanks: on the receipt of the
2011 ACM SIGPLAN distinguished
achievement award . . . . . . . . . . . 3--6
Stephan van Staden and
Cristiano Calcagno and
Bertrand Meyer Freefinement . . . . . . . . . . . . . . 7--18
Saurabh Joshi and
Shuvendu K. Lahiri and
Akash Lal Underspecified harnesses and interleaved
bugs . . . . . . . . . . . . . . . . . . 19--30
Philippa Anne Gardner and
Sergio Maffeis and
Gareth David Smith Towards a program logic for JavaScript 31--44
Neelakantan R. Krishnaswami and
Nick Benton and
Jan Hoffmann Higher-order functional reactive
programming in bounded space . . . . . . 45--58
Chung-Kil Hur and
Derek Dreyer and
Georg Neis and
Viktor Vafeiadis The marriage of bisimulations and Kripke
logical relations . . . . . . . . . . . 59--72
Roshan P. James and
Amr Sabry Information effects . . . . . . . . . . 73--84
Jean Yang and
Kuat Yessenov and
Armando Solar-Lezama A language for automatically enforcing
privacy policies . . . . . . . . . . . . 85--96
Gilles Barthe and
Boris Köpf and
Federico Olmedo and
Santiago Zanella Béguelin Probabilistic relational reasoning for
differential privacy . . . . . . . . . . 97--110
Phillip Heidegger and
Annette Bieniusa and
Peter Thiemann Access permission contracts for
scripting languages . . . . . . . . . . 111--122
Parthasarathy Madhusudan and
Xiaokang Qiu and
Andrei Stefanescu Recursive proofs for inductive tree
data-structures . . . . . . . . . . . . 123--136
Margus Veanes and
Pieter Hooimeijer and
Benjamin Livshits and
David Molnar and
Nikolaj Bjorner Symbolic finite state transducers:
algorithms and applications . . . . . . 137--150
Ali Sinan Köksal and
Viktor Kuncak and
Philippe Suter Constraints as control . . . . . . . . . 151--164
Thomas H. Austin and
Cormac Flanagan Multiple facets for dynamic information
flow . . . . . . . . . . . . . . . . . . 165--178
Donald Ray and
Jay Ligatti Defining code-injection attacks . . . . 179--190
Samik Basu and
Tevfik Bultan and
Meriem Ouederni Deciding choreography realizability . . 191--202
Ahmed Bouajjani and
Michael Emmi Analysis of recursively parallel
programs . . . . . . . . . . . . . . . . 203--214
Jennifer Rexford Programming languages for programmable
networks . . . . . . . . . . . . . . . . 215--216
Christopher Monsanto and
Nate Foster and
Rob Harrison and
David Walker A compiler and run-time system for
network programming languages . . . . . 217--230
Ravi Chugh and
Patrick M. Rondon and
Ranjit Jhala Nested refinements: a logic for duck
typing . . . . . . . . . . . . . . . . . 231--244
Patrick Cousot and
Radhia Cousot An abstract interpretation framework for
termination . . . . . . . . . . . . . . 245--258
Krystof Hoder and
Laura Kovacs and
Andrei Voronkov Playing in the grey area of proofs . . . 259--272
Antonis Stampoulis and
Zhong Shao Static and user-extensible proof
checking . . . . . . . . . . . . . . . . 273--284
Casey Klein and
John Clements and
Christos Dimoulas and
Carl Eastlund and
Matthias Felleisen and
Matthew Flatt and
Jay A. McCarthy and
Jon Rafkind and
Sam Tobin-Hochstadt and
Robert Bruce Findler Run your research: on the effectiveness
of lightweight mechanization . . . . . . 285--296
Azadeh Farzan and
Zachary Kincaid Verification of parameterized concurrent
programs by modular reasoning about data
and control . . . . . . . . . . . . . . 297--308
Matko Botincan and
Mike Dodds and
Suresh Jagannathan Resource-sensitive synchronization
inference by abduction . . . . . . . . . 309--322
Uday S. Reddy and
John C. Reynolds Syntactic control of interference for
separation logic . . . . . . . . . . . . 323--336
Daniel R. Licata and
Robert Harper Canonicity for $2$-dimensional type
theory . . . . . . . . . . . . . . . . . 337--348
Ohad Kammar and
Gordon D. Plotkin Algebraic foundations for
effect-dependent optimisations . . . . . 349--360
Julien Cretin and
Didier Rémy On the power of coercion abstraction . . 361--372
Mayur Naik and
Hongseok Yang and
Ghila Castelnuovo and
Mooly Sagiv Abstractions from tests . . . . . . . . 373--386
Yannis Smaragdakis and
Jacob Evans and
Caitlin Sadowski and
Jaeheon Yi and
Cormac Flanagan Sound predictive race detection in
polynomial time . . . . . . . . . . . . 387--400
Mikolaj Bojanczyk and
Laurent Braud and
Bartek Klin and
Slawomir Lasota Towards nominal computation . . . . . . 401--412
Andrew Cave and
Brigitte Pientka Programming with binders and indexed
data-types . . . . . . . . . . . . . . . 413--424
J. Strother Moore Meta-level features in an
industrial-strength theorem prover . . . 425--426
Jianzhou Zhao and
Santosh Nagarakatte and
Milo M. K. Martin and
Steve Zdancewic Formalizing the LLVM intermediate
representation for verified program
transformations . . . . . . . . . . . . 427--440
Zeyuan Allen Zhu and
Sasa Misailovic and
Jonathan A. Kelner and
Martin Rinard Randomized accuracy-aware program
transformations for efficient
approximate computations . . . . . . . . 441--454
Hongjin Liang and
Xinyu Feng and
Ming Fu A rely-guarantee-based simulation for
verifying concurrent program
transformations . . . . . . . . . . . . 455--468
Thibaut Balabonski A unified approach to fully lazy sharing 469--480
Aseem Rastogi and
Avik Chaudhuri and
Basil Hosmer The ins and outs of gradual type
inference . . . . . . . . . . . . . . . 481--494
Martin Hofmann and
Benjamin Pierce and
Daniel Wagner Edit lenses . . . . . . . . . . . . . . 495--508
Mark Batty and
Kayvan Memarian and
Scott Owens and
Susmit Sarkar and
Peter Sewell Clarifying and compiling C/C++
concurrency: from C++11 to POWER . . . . 509--520
Tahina Ramananandro and
Gabriel Dos Reis and
Xavier Leroy A mechanized semantics for C++ object
construction and destruction, with
applications to resource management . . 521--532
Chucky Ellison and
Grigore Rosu An executable formal semantics of C with
applications . . . . . . . . . . . . . . 533--544
Sooraj Bhat and
Ashish Agarwal and
Richard Vuduc and
Alexander Gray A type theory for probability density
functions . . . . . . . . . . . . . . . 545--556
Karl Naden and
Robert Bocchino and
Jonathan Aldrich and
Kevin Bierhoff A type system for borrowing permissions 557--570
Pierre-Yves Strub and
Nikhil Swamy and
Cedric Fournet and
Juan Chen Self-certification: bootstrapping
certified typecheckers in F* with Coq 571--584
Theo D'Hondt An interpreter for server-side HOP . . . 1--12
Mason Chang and
Bernd Mathiske and
Edwin Smith and
Avik Chaudhuri and
Andreas Gal and
Michael Bebenita and
Christian Wimmer and
Michael Franz The impact of optional type information
on JIT compilation of dynamically typed
languages . . . . . . . . . . . . . . . 13--24
Andrei Homescu and
Alex Suhan HappyJIT: a tracing JIT compiler for PHP 25--36
Tian Zhao Polymorphic type inference for scripting
languages with object extensions . . . . 37--50
Robert Hirschfeld and
Michael Perscheid and
Michael Haupt Explicit use-case representation in
object-oriented programming languages 51--60
Maxime Chevalier-Boisvert and
Erick Lavoie and
Marc Feeley and
Bruno Dufour Bootstrapping a self-hosted research
virtual machine for JavaScript: an
experience report . . . . . . . . . . . 61--72
Felix S. Klock II and
William D. Clinger Bounded-latency regional garbage
collection . . . . . . . . . . . . . . . 73--84
Kevin Tew and
James Swaine and
Matthew Flatt and
Robert Bruce Findler and
Peter Dinda Places: adding message-passing
parallelism to Racket . . . . . . . . . 85--96
Andreas Stuchlik and
Stefan Hanenberg Static vs. dynamic type systems: an
empirical study about the relationship
between type casts and development time 97--106
Ulrik P. Schultz Multilingual component programming in
Racket . . . . . . . . . . . . . . . . . 1--2
Marko Rosenmüller and
Norbert Siegmund and
Mario Pukall and
Sven Apel Tailoring dynamic software product lines 3--12
Don Batory and
Peter Höfner and
Jongwook Kim Feature interactions, products, and
composition . . . . . . . . . . . . . . 13--22
Márcio Ribeiro and
Felipe Queiroz and
Paulo Borba and
Társis Tolêdo and
Claus Brabrand and
Sérgio Soares On the impact of feature dependencies
when maintaining preprocessor-based
software product lines . . . . . . . . . 23--32
Laís Neves and
Leopoldo Teixeira and
Demóstenes Sena and
Vander Alves and
Uirá Kulezsa and
Paulo Borba Investigating the safe evolution of
software product lines . . . . . . . . . 33--42
Abdelhakim Hannousse and
Rémi Douence and
Gilles Ardourel Static analysis of aspect interaction
and composition in component models . . 43--52
William R. Otte and
Aniruddha Gokhale and
Douglas C. Schmidt and
Johnny Willemsen Infrastructure for component-based DDS
application development . . . . . . . . 53--62
Yulin Li and
Gordon S. Novak, Jr. Generation of geometric programs
specified by diagrams . . . . . . . . . 63--72
Andreas Steck and
Alex Lotz and
Christian Schlegel Model-driven engineering and run-time
model-usage in service robotics . . . . 73--82
Sander Daniël Vermolen and
Guido Wachsmuth and
Eelco Visser Generating database migrations for
evolving Web applications . . . . . . . 83--92
Olivier Danvy Pragmatics for formal semantics . . . . 93--94
Gary J. Shubert Application of model based development
to flexible code generation . . . . . . 95--96
Kenichi Asai Reflection in direct style . . . . . . . 97--106
Nathaniel Nystrom and
Derek White and
Kishen Das Firepile: run-time compilation for GPUs
in Scala . . . . . . . . . . . . . . . . 107--116
Shahram Esmaeilsabzali and
Bernd Fischer and
Joanne M. Atlee Monitoring aspects for the customization
of automatically generated code for
big-step models . . . . . . . . . . . . 117--126
Ricky T. Lindeman and
Lennart C. L. Kats and
Eelco Visser Declaratively defining domain-specific
language debuggers . . . . . . . . . . . 127--136
B. J. Arnoldus and
M. G. J. van den Brand and
A. Serebrenik Less is more: unparser-completeness of
metalanguages for template engines . . . 137--146
Vidar Slåtten and
Frank Alexander Kraemer and
Peter Herrmann Towards automatic generation of formal
specifications to validate and verify
reliable distributed systems: a method
exemplified by an industrial case study 147--156
Stefan Sobernig and
Patrick Gaubatz and
Mark Strembeck and
Uwe Zdun Comparing complexity of API designs: an
exploratory experiment on DSL-based
framework integration . . . . . . . . . 157--166
Sebastian Erdweg and
Lennart C. L. Kats and
Tillmann Rendel and
Christian Kästner and
Klaus Ostermann and
Eelco Visser Growing a language environment with
editor libraries . . . . . . . . . . . . 167--176
John Freeman and
Jaakko Järvi and
Wonseok Kim and
Mat Marcus and
Sean Parent Helping programmers help users . . . . . 177--184
John Launchbury Theorem-based circuit derivation in
Cryptol . . . . . . . . . . . . . . . . 185--186
James R. Larus The cloud will change everything . . . . 1--2
Ding Yuan and
Jing Zheng and
Soyeon Park and
Yuanyuan Zhou and
Stefan Savage Improving software diagnosability via
log enhancement . . . . . . . . . . . . 3--14
Kaushik Veeraraghavan and
Dongyoon Lee and
Benjamin Wester and
Jessica Ouyang and
Peter M. Chen and
Jason Flinn and
Satish Narayanasamy DoublePlay: parallelizing sequential
logging and replay . . . . . . . . . . . 15--26
Jared Casper and
Tayo Oguntebi and
Sungpack Hong and
Nathan G. Bronson and
Christos Kozyrakis and
Kunle Olukotun Hardware acceleration of transactional
memory on commodity systems . . . . . . 27--38
Luke Dalessandro and
François Carouge and
Sean White and
Yossi Lev and
Mark Moir and
Michael L. Scott and
Michael F. Spear Hybrid NOrec: a case study in the
effectiveness of best effort hardware
transactional memory . . . . . . . . . . 39--52
Abhayendra Singh and
Daniel Marino and
Satish Narayanasamy and
Todd Millstein and
Madan Musuvathi Efficient processor support for DRFx, a
memory model with exceptions . . . . . . 53--66
Joseph Devietti and
Jacob Nelson and
Tom Bergan and
Luis Ceze and
Dan Grossman RCDC: a relaxed consistency
deterministic computer . . . . . . . . . 67--78
Jacob Burnim and
George Necula and
Koushik Sen Specifying and checking semantic
atomicity for multithreaded programs . . 79--90
Haris Volos and
Andres Jaan Tack and
Michael M. Swift Mnemosyne: lightweight persistent memory 91--104
Joel Coburn and
Adrian M. Caulfield and
Ameen Akel and
Laura M. Grupp and
Rajesh K. Gupta and
Ranjit Jhala and
Steven Swanson NV-Heaps: making persistent objects fast
and safe with next-generation,
non-volatile memories . . . . . . . . . 105--118
Adrian Schüpbach and
Andrew Baumann and
Timothy Roscoe and
Simon Peter A declarative language approach to
device configuration . . . . . . . . . . 119--132
Leonid Ryzhyk and
John Keys and
Balachandra Mirla and
Arun Raghunath and
Mona Vij and
Gernot Heiser Improved device driver reliability
through hardware verification reuse . . 133--144
Atif Hashmi and
Andrew Nere and
James Jamal Thomas and
Mikko Lipasti A case for neuromorphic ISAs . . . . . . 145--158
Benjamin Ransford and
Jacob Sorber and
Kevin Fu Mementos: system support for
long-running computation on RFID-scale
devices . . . . . . . . . . . . . . . . 159--170
Emmanouil Koukoumidis and
Dimitrios Lymberopoulos and
Karin Strauss and
Jie Liu and
Doug Burger Pocket cloudlets . . . . . . . . . . . . 171--184
Navin Sharma and
Sean Barker and
David Irwin and
Prashant Shenoy Blink: managing server clusters on
intermittent power . . . . . . . . . . . 185--198
Henry Hoffmann and
Stelios Sidiroglou and
Michael Carbin and
Sasa Misailovic and
Anant Agarwal and
Martin Rinard Dynamic knobs for responsive power-aware
computing . . . . . . . . . . . . . . . 199--212
Song Liu and
Karthik Pattabiraman and
Thomas Moscibroda and
Benjamin G. Zorn Flikker: saving DRAM refresh-power
through critical data partitioning . . . 213--224
Qingyuan Deng and
David Meisner and
Luiz Ramos and
Thomas F. Wenisch and
Ricardo Bianchini MemScale: active low-power modes for
main memory . . . . . . . . . . . . . . 225--238
Qi Gao and
Wenbin Zhang and
Zhezhe Chen and
Mai Zheng and
Feng Qin 2ndStrike: toward manifesting hidden
concurrency typestate bugs . . . . . . . 239--250
Wei Zhang and
Junghee Lim and
Ramya Olichandran and
Joel Scherpelz and
Guoliang Jin and
Shan Lu and
Thomas Reps ConSeq: detecting concurrency bugs
through sequential errors . . . . . . . 251--264
Vitaly Chipounov and
Volodymyr Kuznetsov and
George Candea S2E: a platform for in-vivo multi-path
analysis of software systems . . . . . . 265--278
Owen S. Hofmann and
Alan M. Dunn and
Sangman Kim and
Indrajit Roy and
Emmett Witchel Ensuring operating system kernel
integrity with OSck . . . . . . . . . . 279--290
Donald E. Porter and
Silas Boyd-Wickizer and
Jon Howell and
Reuben Olinsky and
Galen C. Hunt Rethinking the library OS from the top
down . . . . . . . . . . . . . . . . . . 291--304
Nicolas Palix and
Gaël Thomas and
Suman Saha and
Christophe Calv\`es and
Julia Lawall and
Gilles Muller Faults in Linux: ten years later . . . . 305--318
Hadi Esmaeilzadeh and
Ting Cao and
Yang Xi and
Stephen M. Blackburn and
Kathryn S. McKinley Looking back on the language and
hardware revolutions: measured power,
performance, and scaling . . . . . . . . 319--332
Donald Nguyen and
Keshav Pingali Synthesizing concurrent schedulers for
irregular algorithms . . . . . . . . . . 333--344
Giang Hoang and
Robby Bruce Findler and
Russ Joseph Exploring circuit timing-aware language
and compilation . . . . . . . . . . . . 345--356
Sardar M. Farhad and
Yousun Ko and
Bernd Burgstaller and
Bernhard Scholz Orchestration by approximation: mapping
stream programs onto multicore
architectures . . . . . . . . . . . . . 357--368
Eddy Z. Zhang and
Yunlian Jiang and
Ziyu Guo and
Kai Tian and
Xipeng Shen On-the-fly elimination of dynamic
irregularities for GPU computing . . . . 369--380
Amir H. Hormati and
Mehrzad Samadi and
Mark Woh and
Trevor Mudge and
Scott Mahlke Sponge: portable stream programming on
graphics engines . . . . . . . . . . . . 381--392
Md Kamruzzaman and
Steven Swanson and
Dean M. Tullsen Inter-core prefetching for multicore
processors using migrating helper
threads . . . . . . . . . . . . . . . . 393--404
Hiroshige Hayashizaki and
Peng Wu and
Hiroshi Inoue and
Mauricio J. Serrano and
Toshio Nakatani Improving the performance of trace-based
systems by false loop filtering . . . . 405--418
Jingling Xue Rethinking Java call stack design for
tiny embedded devices . . . . . . . . . 1--10
Olivier Sallenave and
Roland Ducournau Lightweight generics in embedded systems
through static analysis . . . . . . . . 11--20
Stephen Kyle and
Igor Böhm and
Björn Franke and
Hugh Leather and
Nigel Topham Efficiently parallelizing instruction
set simulation of embedded multi-core
processors using region-based
just-in-time dynamic binary translation 21--30
Yazhi Huang and
Mengying Zhao and
Chun Jason Xue WCET-aware re-scheduling register
allocation for real-time embedded
systems with clustered VLIW architecture 31--40
Qing Wan and
Hui Wu and
Jingling Xue WCET-aware data selection and allocation
for scratchpad memory . . . . . . . . . 41--50
Léonard Gérard and
Adrien Guatto and
Cédric Pasteur and
Marc Pouzet A modular memory optimization for
synchronous data-flow languages:
application to arrays in a Lustre
compiler . . . . . . . . . . . . . . . . 51--60
Alina Sb\^\irlea and
Yi Zou and
Zoran Budimlíc and
Jason Cong and
Vivek Sarkar Mapping a data-flow programming model
onto heterogeneous platforms . . . . . . 61--70
Matin Hashemi and
Mohammad H. Foroozannejad and
Soheil Ghiasi and
Christoph Etzel FORMLESS: scalable utilization of
embedded manycores in streaming
applications . . . . . . . . . . . . . . 71--78
S. M. Farhad and
Yousun Ko and
Bernd Burgstaller and
Bernhard Scholz Profile-guided deployment of stream
programs on multicores . . . . . . . . . 79--88
Zhenman Fang and
Jiaxin Li and
Weihua Zhang and
Yi Li and
Haibo Chen and
Binyu Zang Improving dynamic prediction accuracy
through multi-level phase analysis . . . 89--98
Daya Shanker Khudia and
Griffin Wright and
Scott Mahlke Efficient soft error protection for
commodity embedded microprocessors using
profile information . . . . . . . . . . 99--108
Qingan Li and
Mengying Zhao and
Chun Jason Xue and
Yanxiang He Compiler-assisted preferred caching for
embedded systems with STT--RAM based
hybrid cache . . . . . . . . . . . . . . 109--118
Marcela Zuluaga and
Andreas Krause and
Peter Milder and
Markus Püschel ``Smart'' design space sampling to
predict Pareto-optimal solutions . . . . 119--128
Olivier Bouissou and
Alexandre Chapoutot An operational semantics for Simulink's
simulation engine . . . . . . . . . . . 129--138
Fang Yu and
Shun-Ching Yang and
Farn Wang and
Guan-Cheng Chen and
Che-Chang Chan Symbolic consistency checking of OpenMP
parallel programs . . . . . . . . . . . 139--148
Shay Gal-On and
Markus Levy Creating portable, repeatable, realistic
benchmarks for embedded systems and the
challenges thereof . . . . . . . . . . . 149--152
Tony Hosking Compiling a high-level language for
GPUs: (via language support for
architectures and compilers) . . . . . . 1--12
Mehrzad Samadi and
Amir Hormati and
Mojtaba Mehrara and
Janghaeng Lee and
Scott Mahlke Adaptive input-aware compilation for
graphics engines . . . . . . . . . . . . 13--22
David F. Bacon and
Perry Cheng and
Sunil Shukla And then there were none: a stall-free
real-time garbage collector for
reconfigurable hardware . . . . . . . . 23--34
Bruno C. d. S. Oliveira and
Tom Schrijvers and
Wontae Choi and
Wonchan Lee and
Kwangkeun Yi The implicit calculus: a new foundation
for generic programming . . . . . . . . 35--44
Ming Kawaguchi and
Patrick Rondon and
Alexander Bakst and
Ranjit Jhala Deterministic parallelism via liquid
effects . . . . . . . . . . . . . . . . 45--54
Rachid Guerraoui and
Viktor Kuncak and
Giuliano Losa Speculative linearizability . . . . . . 55--66
Dmitrijs Zaparanuks and
Matthias Hauswirth Algorithmic profiling . . . . . . . . . 67--76
Guoliang Jin and
Linhai Song and
Xiaoming Shi and
Joel Scherpelz and
Shan Lu Understanding and detecting real-world
performance bugs . . . . . . . . . . . . 77--88
Emilio Coppa and
Camil Demetrescu and
Irene Finocchi Input-sensitive profiling . . . . . . . 89--98
Danfeng Zhang and
Aslan Askarov and
Andrew C. Myers Language-based control and mitigation of
timing channels . . . . . . . . . . . . 99--110
Charisee Chiw and
Gordon Kindlmann and
John Reppy and
Lamont Samuels and
Nick Seltzer Diderot: a parallel DSL for image
analysis and visualization . . . . . . . 111--120
Luke Cartey and
Rune Lyngsò and
Oege de Moor Synthesising graphics card programs from
DSLs . . . . . . . . . . . . . . . . . . 121--132
Arun Raman and
Ayal Zaks and
Jae W. Lee and
David I. August Parcae: a system for flexible parallel
execution . . . . . . . . . . . . . . . 133--144
Omer Tripp and
Roman Manevich and
John Field and
Mooly Sagiv JANUS: exploiting parallelism via
hindsight . . . . . . . . . . . . . . . 145--156
Aaron Turon Reagents: expressing and composing
fine-grained concurrency . . . . . . . . 157--168
Michael Carbin and
Deokhwan Kim and
Sasa Misailovic and
Martin C. Rinard Proving acceptability properties of
relaxed nondeterministic approximate
programs . . . . . . . . . . . . . . . . 169--180
Isil Dillig and
Thomas Dillig and
Alex Aiken Automated error diagnosis using
abductive inference . . . . . . . . . . 181--192
Volodymyr Kuznetsov and
Johannes Kinder and
Stefan Bucur and
George Candea Efficient state merging in symbolic
execution . . . . . . . . . . . . . . . 193--204
Jingyue Wu and
Yang Tang and
Gang Hu and
Heming Cui and
Junfeng Yang Sound and precise analysis of parallel
programs through schedule specialization 205--216
Aws Albarghouthi and
Rahul Kumar and
Aditya V. Nori and
Sriram K. Rajamani Parallelizing top-down interprocedural
analyses . . . . . . . . . . . . . . . . 217--228
Hakjoo Oh and
Kihong Heo and
Wonchan Lee and
Woosuk Lee and
Kwangkeun Yi Design and implementation of sparse
global analyses for C-like languages . . 229--238
Brian Hackett and
Shu-yu Guo Fast and precise hybrid type inference
for JavaScript . . . . . . . . . . . . . 239--250
Boris Petrov and
Martin Vechev and
Manu Sridharan and
Julian Dolby Race detection for Web applications . . 251--262
Jeffrey Fischer and
Rupak Majumdar and
Shahram Esmaeilsabzali Engage: a deployment management system 263--274
Daniel Perelman and
Sumit Gulwani and
Thomas Ball and
Dan Grossman Type-directed completion of partial
expressions . . . . . . . . . . . . . . 275--286
Yong hun Eom and
Brian Demsky Self-stabilizing Java . . . . . . . . . 287--298
Yan Chen and
Joshua Dunfield and
Umut A. Acar Type-directed automatic
incrementalization . . . . . . . . . . . 299--310
Susmit Sarkar and
Kayvan Memarian and
Scott Owens and
Mark Batty and
Peter Sewell and
Luc Maranget and
Jade Alglave and
Derek Williams Synchronising C/C++ and POWER . . . . . 311--322
Paul Gazzillo and
Robert Grimm SuperC: parsing all of C by taming the
preprocessor . . . . . . . . . . . . . . 323--334
John Regehr and
Yang Chen and
Pascal Cuoq and
Eric Eide and
Chucky Ellison and
Xuejun Yang Test-case reduction for C compiler bugs 335--346
Jun Liu and
Yuanrui Zhang and
Ohyoung Jang and
Wei Ding and
Mahmut Kandemir A compiler framework for extracting
superword level parallelism . . . . . . 347--358
Nick P. Johnson and
Hanjun Kim and
Prakash Prabhu and
Ayal Zaks and
David I. August Speculative separation for privatization
and reductions . . . . . . . . . . . . . 359--370
Justin Holewinski and
Ragavendar Ramamurthi and
Mahesh Ravishankar and
Naznin Fauzia and
Louis-Noël Pouchet and
Atanas Rountev and
P. Sadayappan Dynamic trace-based analysis of
vectorization potential of applications 371--382
Alan Leung and
Manish Gupta and
Yuvraj Agarwal and
Rajesh Gupta and
Ranjit Jhala and
Sorin Lerner Verifying GPU kernels by test
amplification . . . . . . . . . . . . . 383--394
Greg Morrisett and
Gang Tan and
Joseph Tassarotti and
Jean-Baptiste Tristan and
Edward Gan RockSalt: better, faster, stronger SFI
for the x86 . . . . . . . . . . . . . . 395--404
Sergey Grebenshchikov and
Nuno P. Lopes and
Corneliu Popeea and
Andrey Rybalchenko Synthesizing software verifiers from
proof rules . . . . . . . . . . . . . . 405--416
Peter Hawkins and
Alex Aiken and
Kathleen Fisher and
Martin Rinard and
Mooly Sagiv Concurrent data representation synthesis 417--428
Feng Liu and
Nayden Nedev and
Nedyalko Prisadnikov and
Martin Vechev and
Eran Yahav Dynamic synthesis for relaxed memory
models . . . . . . . . . . . . . . . . . 429--440
Patrice Godefroid and
Ankur Taly Automated synthesis of symbolic
instruction encodings from I/O samples 441--452
Florian Benz and
Andreas Hildebrandt and
Sebastian Hack A dynamic program analysis to find
floating-point accuracy problems . . . . 453--462
Dongyoon Lee and
Peter M. Chen and
Jason Flinn and
Satish Narayanasamy Chimera: hybrid program analysis for
determinism . . . . . . . . . . . . . . 463--474
Marc A. de Kruijf and
Karthikeyan Sankaralingam and
Somesh Jha Static analysis and compiler design for
idempotent processing . . . . . . . . . 475--486
Min Feng and
Rajiv Gupta and
Iulian Neamtiu Effective parallelization of loops in
the presence of I/O operations . . . . . 487--498
Chun Chen Polyhedra scanning revisited . . . . . . 499--508
Cosmin E. Oancea and
Lawrence Rauchwerger Logical inference techniques for loop
parallelization . . . . . . . . . . . . 509--520
Michael Pradel and
Thomas R. Gross Fully automatic and precise detection of
thread safety violations . . . . . . . . 521--530
Raghavan Raman and
Jisheng Zhao and
Vivek Sarkar and
Martin Vechev and
Eran Yahav Scalable and precise dynamic datarace
detection for structured parallelism . . 531--542
Santosh Nagarakatte and
Sebastian Burckhardt and
Milo M. K. Martin and
Madanlal Musuvathi Multicore acceleration of priority-based
schedulers for concurrency bug detection 543--554
Jason Nieh Challenges in building a real, large
private cloud . . . . . . . . . . . . . 1--2
Sajib Kundu and
Raju Rangaswami and
Ajay Gulati and
Ming Zhao and
Kaushik Dutta Modeling virtualized applications using
machine learning techniques . . . . . . 3--14
Hui Lv and
Yaozu Dong and
Jiangang Duan and
Kevin Tian Virtualization challenges: a view from
server consolidation perspective . . . . 15--26
Wei Wang and
Tanima Dey and
Ryan W. Moore and
Mahmut Aktasoglu and
Bruce R. Childers and
Jack W. Davidson and
Mary Jane Irwin and
Mahmut Kandemir and
Mary Lou Soffa REEact: a customizable virtual execution
manager for multicore platforms . . . . 27--38
Zhiqiang Ma and
Zhonghua Sheng and
Lin Gu and
Liufei Wen and
Gong Zhang DVM: towards a datacenter-scale virtual
machine . . . . . . . . . . . . . . . . 39--50
Tingting Yu and
Witawas Srisa-an and
Gregg Rothermel SimTester: a controllable and observable
testing framework for embedded systems 51--62
Yuan Zhang and
Min Yang and
Bo Zhou and
Zhemin Yang and
Weihua Zhang and
Binyu Zang Swift: a register-based JIT compiler for
embedded JVMs . . . . . . . . . . . . . 63--74
Zhiyong Shan and
Xin Wang and
Tzi-cker Chiueh and
Xiaofeng Meng Facilitating inter-application
interactions for OS-level virtualization 75--86
Balazs Gerofi and
Yutaka Ishikawa Enhancing TCP throughput of highly
available virtual machines via
speculative communication . . . . . . . 87--96
Shriram Rajagopalan and
Brendan Cully and
Ryan O'Connor and
Andrew Warfield SecondSite: disaster tolerance as a
service . . . . . . . . . . . . . . . . 97--108
Zhenhao Pan and
Yaozu Dong and
Yu Chen and
Lei Zhang and
Zhijiao Zhang CompSC: live migration with pass-through
devices . . . . . . . . . . . . . . . . 109--120
Vasileios P. Kemerlis and
Georgios Portokalidis and
Kangkook Jee and
Angelos D. Keromytis \tt libdft: practical dynamic data flow
tracking for commodity systems . . . . . 121--132
Derek Bruening and
Qin Zhao and
Saman Amarasinghe Transparent dynamic instrumentation . . 133--144
Geoffrey Lefebvre and
Brendan Cully and
Christopher Head and
Mark Spear and
Norm Hutchinson and
Mike Feeley and
Andrew Warfield Execution mining . . . . . . . . . . . . 145--158
Demos Pavlou and
Enric Gibert and
Fernando Latorre and
Antonio Gonzalez DDGacc: boosting dynamic DDG-based
binary optimizations through specialized
hardware support . . . . . . . . . . . . 159--168
Kazuaki Ishizaki and
Takeshi Ogasawara and
Jose Castanos and
Priya Nagpurkar and
David Edelsohn and
Toshio Nakatani Adding dynamically-typed language
support to a statically-typed language
compiler: performance evaluation,
analysis, and tradeoffs . . . . . . . . 169--180
Yi Lin and
Stephen M. Blackburn and
Daniel Frampton Unpicking the knot: teasing apart
VM/application interdependencies . . . . 181--190
Harvey Tuch and
Cyprien Laplace and
Kenneth C. Barr and
Bi Wu Block storage virtualization with
commodity secure digital cards . . . . . 191--202
Sudeep Ghosh and
Jason Hiser and
Jack W. Davidson Replacement attacks against VM-protected
applications . . . . . . . . . . . . . . 203--214
Mathias Payer and
Thomas R. Gross Protecting applications against TOCTTOU
races by user-space caching of file
metadata . . . . . . . . . . . . . . . . 215--226
Lok-Kwong Yan and
Manjukumar Jayachandra and
Mu Zhang and
Heng Yin V2E: combining hardware virtualization
and software emulation for transparent
and extensible malware analysis . . . . 227--238
Huynh Phung Huynh and
Andrei Hagiescu and
Weng-Fai Wong and
Rick Siow Mong Goh Scalable framework for mapping streaming
applications onto multi-GPU systems . . 1--10
Jaewoong Sim and
Aniruddha Dasgupta and
Hyesoon Kim and
Richard Vuduc A performance analysis framework for
identifying potential benefits in GPGPU
applications . . . . . . . . . . . . . . 11--22
Sara S. Baghsorkhi and
Isaac Gelado and
Matthieu Delahaye and
Wen-mei W. Hwu Efficient performance evaluation of
memory hierarchy for highly
multithreaded graphics processors . . . 23--34
Grey Ballard and
James Demmel and
Nicholas Knight Communication avoiding successive band
reduction . . . . . . . . . . . . . . . 35--44
Paul Sack and
William Gropp Faster topology-aware collective
algorithms through non-minimal
communication . . . . . . . . . . . . . 45--54
Seonggun Kim and
Hwansoo Han Efficient SIMD code generation for
irregular kernels . . . . . . . . . . . 55--64
Roland Leißa and
Sebastian Hack and
Ingo Wald Extending a C-like language for portable
SIMD programming . . . . . . . . . . . . 65--74
Okwan Kwon and
Fahed Jubair and
Rudolf Eigenmann and
Samuel Midkiff A hybrid approach of OpenMP for clusters 75--84
Yong hun Eom and
Stephen Yang and
James C. Jenista and
Brian Demsky DOJ: dynamically parallelizing
object-oriented programs . . . . . . . . 85--96
Daniele Bonetta and
Achille Peternier and
Cesare Pautasso and
Walter Binder S: a scripting language for
high-performance RESTful Web services 97--106
Mario Mendez-Lojo and
Martin Burtscher and
Keshav Pingali A GPU implementation of inclusion-based
points-to analysis . . . . . . . . . . . 107--116
Duane Merrill and
Michael Garland and
Andrew Grimshaw Scalable GPU graph traversal . . . . . . 117--128
Yuan Zu and
Ming Yang and
Zhonghu Xu and
Lin Wang and
Xin Tian and
Kunyang Peng and
Qunfeng Dong GPU-based NFA implementation for memory
efficient high speed regular expression
matching . . . . . . . . . . . . . . . . 129--140
Alex Kogan and
Erez Petrank A methodology for creating fast
wait-free data structures . . . . . . . 141--150
Aleksandar Prokopec and
Nathan Grasso Bronson and
Phil Bagwell and
Martin Odersky Concurrent tries with efficient
non-blocking snapshots . . . . . . . . . 151--160
Tyler Crain and
Vincent Gramoli and
Michel Raynal A speculation-friendly binary search
tree . . . . . . . . . . . . . . . . . . 161--170
Yifeng Chen and
Xiang Cui and
Hong Mei PARRAY: a unifying array representation
for heterogeneous parallelism . . . . . 171--180
Guy E. Blelloch and
Jeremy T. Fineman and
Phillip B. Gibbons and
Julian Shun Internally deterministic parallel
algorithms can be fast . . . . . . . . . 181--192
Charles E. Leiserson and
Tao B. Schardl and
Jim Sukha Deterministic parallel random-number
generation for dynamic-multithreading
platforms . . . . . . . . . . . . . . . 193--204
Sadegh Nobari and
Thanh-Tung Cao and
Panagiotis Karras and
Stéphane Bressan Scalable parallel minimum spanning
forest computation . . . . . . . . . . . 205--214
Guodong Li and
Peng Li and
Geof Sawaya and
Ganesh Gopalakrishnan and
Indradeep Ghosh and
Sreeranga P. Rajan GKLEE: concolic verification and test
generation for GPUs . . . . . . . . . . 215--224
Peng Du and
Aurelien Bouteiller and
George Bosilca and
Thomas Herault and
Jack Dongarra Algorithm-based fault tolerance for
dense matrix factorizations . . . . . . 225--234
Jeremy D. Buhler and
Kunal Agrawal and
Peng Li and
Roger D. Chamberlain Efficient deadlock avoidance for
streaming computation with filtering . . 235--246
David Dice and
Virendra J. Marathe and
Nir Shavit Lock cohorting: a general technique for
designing NUMA locks . . . . . . . . . . 247--256
Panagiota Fatourou and
Nikolaos D. Kallimanis Revisiting the combining synchronization
technique . . . . . . . . . . . . . . . 257--266
Olivier Tardieu and
Haichuan Wang and
Haibo Lin A work-stealing scheduler for X10's task
parallelism with suspension . . . . . . 267--276
Muthu Manikandan Baskaran and
Nicolas Vasilache and
Benoit Meister and
Richard Lethin Automatic communication optimizations
through memory reuse strategies . . . . 277--278
Gu Liu and
Hong An and
Wenting Han and
Xiaoqiang Li and
Tao Sun and
Wei Zhou and
Xuechao Wei and
Xulong Tang FlexBFS: a parallelism-aware
implementation of breadth-first search
on GPU . . . . . . . . . . . . . . . . . 279--280
Michael Andersch and
Chi Ching Chi and
Ben Juurlink Programming parallel embedded and
consumer applications in OpenMP
superscalar . . . . . . . . . . . . . . 281--282
Jianlong Zhong and
Bingsheng He An overview of Medusa: simplified graph
processing on GPUs . . . . . . . . . . . 283--284
Christophe Alias and
Alain Darte and
Alexandru Plesco Optimizing remote accesses for offloaded
kernels: application to high-level
synthesis for FPGA . . . . . . . . . . . 285--286
Jian Tao and
Marek Blazewicz and
Steven R. Brandt Using GPU's to accelerate stencil-based
computation kernels for the development
of large scale scientific applications
on heterogeneous systems . . . . . . . . 287--288
Bryan Marker and
Andy Terrel and
Jack Poulson and
Don Batory and
Robert van de Geijn Mechanizing the expert dense linear
algebra developer . . . . . . . . . . . 289--290
Cedric Nugteren and
Henk Corporaal The boat hull model: adapting the
roofline model to enable performance
prediction for parallel computing . . . 291--292
Min Feng and
Rajiv Gupta and
Laxmi N. Bhuyan Speculative parallelization on GPGPUs 293--294
Alexandra Jimborean and
Philippe Clauss and
Beno\^\it Pradelle and
Luis Mastrangelo and
Vincent Loechner Adapting the polyhedral model as a
framework for efficient speculative
parallelization . . . . . . . . . . . . 295--296
Yifan Gong and
Bingsheng He and
Jianlong Zhong An overview of CMPI: network performance
aware MPI in the cloud . . . . . . . . . 297--298
Jungwon Kim and
Sangmin Seo and
Jun Lee and
Jeongho Nah and
Gangwon Jo and
Jaejin Lee OpenCL as a unified programming model
for heterogeneous CPU/GPU clusters . . . 299--300
George Tzenakis and
Angelos Papatriantafyllou and
John Kesapides and
Polyvios Pratikakis and
Hans Vandierendonck and
Dimitrios S. Nikolopoulos BDDT: block-level dynamic dependence
analysis for deterministic task-based
parallelism . . . . . . . . . . . . . . 301--302
Shoaib Kamil and
Derrick Coetzee and
Scott Beamer and
Henry Cook and
Ekaterina Gonina and
Jonathan Harper and
Jeffrey Morlan and
Armando Fox Portable parallel performance from
sequential, productive, embedded
domain-specific languages . . . . . . . 303--304
Torsten Hoefler and
Timo Schneider Communication-centric optimizations by
dynamically detecting collective
operations . . . . . . . . . . . . . . . 305--306
Donghui Zhang and
Per-Åke Larson LHlf: lock-free linear hashing (poster
paper) . . . . . . . . . . . . . . . . . 307--308
Shahar Timnat and
Anastasia Braginsky and
Alex Kogan and
Erez Petrank Wait-free linked-lists . . . . . . . . . 309--310
Minh Ngoc Dinh and
David Abramson and
Chao Jin and
Andrew Gontarek and
Bob Moench and
Luiz DeRose Scalable parallel debugging with
statistical assertions . . . . . . . . . 311--312
Alexander Malkis and
Anindya Banerjee Verification of software barriers . . . 313--314
Anshul Mittal and
Nikhil Jain and
Thomas George and
Yogish Sabharwal and
Sameer Kumar Collective algorithms for
sub-communicators . . . . . . . . . . . 315--316
Joeri De Koster and
Stefan Marr and
Theo D'Hondt Synchronization views for event-loop
actors . . . . . . . . . . . . . . . . . 317--318
Zviad Metreveli and
Nickolai Zeldovich and
M. Frans Kaashoek CPHASH: a cache-partitioned hash table 319--320
John R. Wernsing and
Greg Stitt RACECAR: a heuristic for automatic
function specialization on multi-core
heterogeneous systems . . . . . . . . . 321--322
Yujie Liu and
Michael Spear A lock-free, array-based priority queue 323--324
Albert Noll and
Thomas R. Gross An infrastructure for dynamic
optimization of parallel programs . . . 325--326
Fredrik Kjolstad and
Torsten Hoefler and
Marc Snir Automatic datatype generation and
optimization . . . . . . . . . . . . . . 327--328
Jacob Burnim and
Tayfun Elmas and
George Necula and
Koushik Sen NDetermin: inferring nondeterministic
sequential specifications for
parallelism correctness . . . . . . . . 329--330
Chang-Seo Park and
Koushik Sen Concurrent breakpoints . . . . . . . . . 331--332
Andrew Stone and
John Dennis and
Michelle Strout Establishing a Miniapp as a
programmability proxy . . . . . . . . . 333--334
Lei Jiang and
Pragneshkumar B. Patel and
George Ostrouchov and
Ferdinand Jamitzky OpenMP-style parallelism in
data-centered multicore computing with R 335--336
Yves Caniou and
Daniel Diaz and
Florian Richoux and
Philippe Codognet and
Salvador Abreu Performance analysis of parallel
constraint-based local search . . . . . 337--338
Peter Thiemann AGDA-curious?: an exploration of
programming with dependent types . . . . 1--2
Gordon Stewart and
Lennart Beringer and
Andrew W. Appel Verified heap theorem prover by
paramodulation . . . . . . . . . . . . . 3--14
Brian Huffman Formal verification of monad
transformers . . . . . . . . . . . . . . 15--16
Joshua Dunfield Elaborating intersection and union types 17--28
Sheng Chen and
Martin Erwig and
Eric Walkingshaw An error-tolerant type system for
variational lambda calculus . . . . . . 29--40
Neelakantan R. Krishnaswami and
Aaron Turon and
Derek Dreyer and
Deepak Garg Superficially substructural types . . . 41--54
Neil Mitchell Shake before building: replacing make
with Haskell . . . . . . . . . . . . . . 55--66
Olaf Chitil Practical typed lazy contracts . . . . . 67--76
Bruno C.d.S. Oliveira and
William R. Cook Functional programming with structured
graphs . . . . . . . . . . . . . . . . . 77--88
Timothy E. Sheard Painless programming combining reduction
and search: design principles for
embedding decision procedures in
high-level languages . . . . . . . . . . 89--102
Pierre-Evariste Dagand and
Conor McBride Transporting functions across ornaments 103--114
Magnus O. Myreen and
Scott Owens Proof-producing synthesis of ML from
higher-order logic . . . . . . . . . . . 115--126
Nils Anders Danielsson Operational semantics using the
partiality monad . . . . . . . . . . . . 127--138
Kunle Olukotun High performance embedded domain
specific languages . . . . . . . . . . . 139--140
Paula G. Severi and
Fer-Jan J. de Vries Pure type systems with corecursion on
streams: from finite to infinitary
normalisation . . . . . . . . . . . . . 141--152
Jörg Endrullis and
Dimitri Hendriks and
Rena Bakhshi On the complexity of equivalence of
specifications of infinite objects . . . 153--164
Hugo Simões and
Pedro Vasconcelos and
Mário Florido and
Steffen Jost and
Kevin Hammond Automatic amortised analysis of dynamic
memory allocation for lazy functional
programs . . . . . . . . . . . . . . . . 165--176
Christopher Earl and
Ilya Sergey and
Matthew Might and
David Van Horn Introspective pushdown analysis of
higher-order programs . . . . . . . . . 177--188
John Launchbury and
Iavor S. Diatchki and
Thomas DuBuisson and
Andy Adams-Moran Efficient lookup-table protocol in
secure multiparty computation . . . . . 189--200
Deian Stefan and
Alejandro Russo and
Pablo Buiras and
Amit Levy and
John C. Mitchell and
David Maziéres Addressing covert termination and timing
channels in concurrent information flow
systems . . . . . . . . . . . . . . . . 201--214
Christian Höner zu Siederdissen Sneaking around concatMap: efficient
combinators for dynamic programming . . 215--226
Noah M. Daniels and
Andrew Gallant and
Norman Ramsey Experience report: Haskell in
computational biology . . . . . . . . . 227--234
Adam Foltzer and
Abhishek Kulkarni and
Rebecca Swords and
Sajith Sasidharan and
Eric Jiang and
Ryan Newton A meta-scheduler for the par-monad:
composable scheduling for the
heterogeneous cloud . . . . . . . . . . 235--246
Lars Bergstrom and
John Reppy Nested data-parallelism on the GPU . . . 247--258
Ben Lippmeier and
Manuel M. T. Chakravarty and
Gabriele Keller and
Roman Leshchinskiy and
Simon Peyton Jones Work efficient higher-order
vectorisation . . . . . . . . . . . . . 259--270
Peter Sewell Tales from the jungle . . . . . . . . . 271--272
Philip Wadler Propositions as sessions . . . . . . . . 273--286
Grégoire Henry and
Michel Mauny and
Emmanuel Chailloux and
Pascal Manoury Typing unmarshalling without marshalling
types . . . . . . . . . . . . . . . . . 287--298
Will Jones and
Tony Field and
Tristan Allwood Deconstraining DSLs . . . . . . . . . . 299--310
Geoffrey Mainland Explicitly heterogeneous metaprogramming
with MetaHaskell . . . . . . . . . . . . 311--322
Emil Axelsson A generic abstract syntax model for
embedded languages . . . . . . . . . . . 323--334
Lee Pike and
Nis Wegmann and
Sebastian Niller and
Alwyn Goodloe Experience report: a do-it-yourself
high-assurance compiler . . . . . . . . 335--340
Dimitrios Vytiniotis and
Simon Peyton Jones and
José Pedro Magalhães Equality proofs and deferred type
errors: a compiler pearl . . . . . . . . 341--352
Robin P. Neatherway and
Steven J. Ramsay and
Chih-Hao Luke Ong A traversal-based algorithm for
higher-order model checking . . . . . . 353--364
Roly Perera and
Umut A. Acar and
James Cheney and
Paul Blain Levy Functional programs that explain their
work . . . . . . . . . . . . . . . . . . 365--376
Kohei Suenaga and
Ryota Fukuda and
Atsushi Igarashi Type-based safe resource deallocation
for shared-memory concurrency . . . . . 1--20
Colin S. Gordon and
Matthew J. Parkinson and
Jared Parsons and
Aleks Bromfield and
Joe Duffy Uniqueness and reference immutability
for safe parallelism . . . . . . . . . . 21--40
Jaswanth Sreeram and
Santosh Pande Safe compiler-driven transaction
checkpointing and recovery . . . . . . . 41--56
Stefan Muller and
Stephen Chong Towards a practical secure concurrent
language . . . . . . . . . . . . . . . . 57--74
Pavel Parízek and
OndYej Lhoták Predicate abstraction of Java programs
with collections . . . . . . . . . . . . 75--94
Todd W. Schiller and
Michael D. Ernst Reducing the barriers to writing
verified specifications . . . . . . . . 95--112
Adam Betts and
Nathan Chong and
Alastair Donaldson and
Shaz Qadeer and
Paul Thomson GPUVerify: a verifier for GPU kernels 113--132
Francesco Logozzo and
Thomas Ball Modular and verified automatic program
repair . . . . . . . . . . . . . . . . . 133--146
Sameer Kulkarni and
John Cavazos Mitigating the compiler optimization
phase-ordering problem using machine
learning . . . . . . . . . . . . . . . . 147--162
Vincent St-Amour and
Sam Tobin-Hochstadt and
Matthias Felleisen Optimization coaching: optimizers learn
to communicate with programmers . . . . 163--178
Hiroshi Inoue and
Hiroshige Hayashizaki and
Peng Wu and
Toshio Nakatani Adaptive multi-level compilation in a
trace-based Java JIT compiler . . . . . 179--194
Jose Castanos and
David Edelsohn and
Kazuaki Ishizaki and
Priya Nagpurkar and
Toshio Nakatani and
Takeshi Ogasawara and
Peng Wu On the benefits and pitfalls of
extending a statically typed language
JIT compiler for dynamic scripting
languages . . . . . . . . . . . . . . . 195--212
Patrick M. Cousot and
Radhia Cousot and
Francesco Logozzo and
Michael Barnett An abstract interpretation framework for
refactoring with application to extract
methods with contracts . . . . . . . . . 213--232
Ying Zhang and
Gang Huang and
Xuanzhe Liu and
Wei Zhang and
Hong Mei and
Shunxiang Yang Refactoring Android Java code for
on-demand computation offloading . . . . 233--248
Christopher M. Hayden and
Edward K. Smith and
Michail Denchev and
Michael Hicks and
Jeffrey S. Foster Kitsune: efficient, general-purpose
dynamic software updating for C . . . . 249--264
Stephen Magill and
Michael Hicks and
Suriya Subramanian and
Kathryn S. McKinley Automating object transformations for
dynamic software updating . . . . . . . 265--280
Jennfer B. Sartor and
Lieven Eeckhout Exploring multi-threaded Java
application performance on multicore
hardware . . . . . . . . . . . . . . . . 281--296
Vivek Kumar and
Daniel Frampton and
Stephen M. Blackburn and
David Grove and
Olivier Tardieu Work-stealing without the baggage . . . 297--314
Sébastien Bocq and
Koen Daenen Molecule: using monadic and streaming
I/O to compose process networks on the
JVM . . . . . . . . . . . . . . . . . . 315--334
Tomas Kalibera and
Matthew Mole and
Richard Jones and
Jan Vitek A black-box approach to understanding
concurrency in DaCapo . . . . . . . . . 335--354
Youngjoon Jo and
Milind Kulkarni Automatically enhancing locality for
tree traversals with traversal splicing 355--374
Dimitrios Prountzos and
Roman Manevich and
Keshav Pingali Elixir: a system for synthesizing
concurrent graph programs . . . . . . . 375--394
Yanhong A. Liu and
Scott D. Stoller and
Bo Lin and
Michael Gorbovitski From clarity to efficiency for
distributed algorithms . . . . . . . . . 395--410
K. Rustan M. Leino and
Aleksandar Milicevic Program extrapolation with Jennisys . . 411--430
Michael Kling and
Sasa Misailovic and
Michael Carbin and
Martin Rinard Bolt: on-demand infinite loop escape in
unmodified binaries . . . . . . . . . . 431--450
Jeff Huang and
Charles Zhang LEAN: simplifying concurrency bug
reproduction via replay-supported
execution reduction . . . . . . . . . . 451--466
Laura Effinger-Dean and
Brandon Lucia and
Luis Ceze and
Dan Grossman and
Hans-J. Boehm IFRit: interference-free regions for
dynamic data-race detection . . . . . . 467--484
Jie Yu and
Satish Narayanasamy and
Cristiano Pereira and
Gilles Pokam Maple: a coverage-driven testing tool
for multithreaded programs . . . . . . . 485--502
Anton Willy Dubrau and
Laurie Jane Hendren Taming MATLAB . . . . . . . . . . . . . 503--522
Junaid Haroon Siddiqui and
Sarfraz Khurshid Scaling symbolic execution using ranged
analysis . . . . . . . . . . . . . . . . 523--536
Sam Tobin-Hochstadt and
David Van Horno Higher-order symbolic execution via
contracts . . . . . . . . . . . . . . . 537--554
Grigore Rosu and
Andrei Stefanescu Checking reachability using matching
logic . . . . . . . . . . . . . . . . . 555--574
Haiping Zhao and
Iain Proctor and
Minghui Yang and
Xin Qi and
Mark Williams and
Qi Gao and
Guilherme Ottoni and
Andrew Paroski and
Scott MacVicar and
Jason Evans and
Stephen Tu The HipHop compiler for PHP . . . . . . 575--586
Ravi Chugh and
David Herman and
Ranjit Jhala Dependent types for JavaScript . . . . . 587--606
Fadi Meawad and
Gregor Richards and
Floréal Morandat and
Jan Vitek Eval begone!: semi-automated removal of
\tt eval from JavaScript programs . . . 607--620
Seonghoon Kang and
Sukyoung Ryu Formal specification of a JavaScript
module system . . . . . . . . . . . . . 621--638
Daniel W. Barowy and
Charlie Curtsinger and
Emery D. Berger and
Andrew McGregor AutoMan: a platform for integrating
human-based and digital computation . . 639--654
Subhajit Datta and
Renuka Sindhgatta and
Bikram Sengupta Talk versus work: characteristics of
developer collaboration on the Jazz
platform . . . . . . . . . . . . . . . . 655--668
Kivanç Muûlu and
Yuriy Brun and
Reid Holmes and
Michael D. Ernst and
David Notkin Speculative analysis of integrated
development environment recommendations 669--682
Clemens Mayer and
Stefan Hanenberg and
Romain Robbes and
Éric Tanter and
Andreas Stefik An empirical study of the influence of
static type systems on the usability of
undocumented software . . . . . . . . . 683--702
Hung-Wei Tseng and
Dean Michael Tullsen Software data-triggered threads . . . . 703--716
Zachary Anderson Efficiently combining parallel software
using fine-grained, language-level,
hierarchical resource management
policies . . . . . . . . . . . . . . . . 717--736
Jeff Huang and
Charles Zhang Execution privatization for
scheduler-oblivious concurrent programs 737--752
Shams M. Imam and
Vivek Sarkar Integrating task parallelism with actors 753--772
Christian Kästner and
Klaus Ostermann and
Sebastian Erdweg A variability-aware module system . . . 773--792
Asumu Takikawa and
T. Stephen Strickland and
Christos Dimoulas and
Sam Tobin-Hochstadt and
Matthias Felleisen Gradual typing for first-class classes 793--810
Olivier Tardieu and
Nathaniel Nystrom and
Igor Peshansky and
Vijay Saraswat Constrained kinds . . . . . . . . . . . 811--830
Michael Cohen and
Haitao Steve Zhu and
Emgin Ezgi Senem and
Yu David Liu Energy types . . . . . . . . . . . . . . 831--850
Bo Wu and
Zhijia Zhao and
Xipeng Shen and
Yunlian Jiang and
Yaoqing Gao and
Raul Silvera Exploiting inter-sequence correlations
for program behavior prediction . . . . 851--866
Giorgio Ausiello and
Camil Demetrescu and
Irene Finocchi and
Donatella Firmani $k$-Calling context profiling . . . . . 867--878
Wei Huang and
Ana Milanova and
Werner Dietl and
Michael D. Ernst Reim & ReImInfer: checking and inference
of reference immutability and method
purity . . . . . . . . . . . . . . . . . 879--896
Tao Bao and
Yunhui Zheng and
Xiangyu Zhang White box sampling in uncertain data
processing enabled by program analysis 897--914
Charles Lucas and
Sebastian Elbaum and
David S. Rosenblum Detecting problematic message sequences
and frequencies in distributed systems 915--926
Zhongxian Gu and
Earl T. Barr and
Drew Schleck and
Zhendong Su Reusing debugging knowledge via
trace-based bug search . . . . . . . . . 927--942
T. Stephen Strickland and
Sam Tobin-Hochstadt and
Robert Bruce Findler and
Matthew Flatt Chaperones and impersonators: run-time
support for reasonable interposition . . 943--962
Yuriy Solodkyy and
Gabriel Dos Reis and
Bjarne Stroustrup Open and efficient type switch for C++ 963--982
Juan M. Tamayo and
Alex Aiken and
Nathan Bronson and
Mooly Sagiv Understanding the behavior of database
operations under program control . . . . 983--996
Alon Mishne and
Sharon Shoham and
Eran Yahav Typestate-based semantic code search
over partial programs . . . . . . . . . 997--1016
Guoqing Xu Finding reusable data structures . . . . 1017--1034
Robert O'Callahan Why is your Web browser using so much
memory? . . . . . . . . . . . . . . . . 1--2
Jin Zhou and
Brian Demsky Memory management for many-core
processors with software configurable
locality policies . . . . . . . . . . . 3--14
Spyros Lyberis and
Polyvios Pratikakis and
Dimitrios S. Nikolopoulos and
Martin Schulz and
Todd Gamblin and
Bronis R. de Supinski The Myrmics memory allocator:
hierarchical, message-passing allocation
for global address spaces . . . . . . . 15--24
Martin Maas and
Philip Reames and
Jeffrey Morlan and
Krste Asanovi\'c and
Anthony D. Joseph and
John Kubiatowicz GPUs as an opportunity for offloading
garbage collection . . . . . . . . . . . 25--36
Xi Yang and
Stephen M. Blackburn and
Daniel Frampton and
Antony L. Hosking Barriers reconsidered, friendlier still! 37--48
KC Sivaramakrishnan and
Lukasz Ziarek and
Suresh Jagannathan Eliminating read barriers through
procrastination and cleanliness . . . . 49--60
Balaji Iyengar and
Edward Gehringer and
Michael Wolf and
Karthikeyan Manivannan Scalable concurrent and parallel mark 61--72
Rifat Shahriyar and
Stephen M. Blackburn and
Daniel Frampton Down for the count? Getting reference
counting back in the ring . . . . . . . 73--84
Balaji Iyengar and
Gil Tene and
Michael Wolf and
Edward Gehringer The Collie: a wait-free compacting
collector . . . . . . . . . . . . . . . 85--96
Andreas Sewe and
Mira Mezini and
Aibek Sarimbekov and
Danilo Ansaloni and
Walter Binder and
Nathan Ricci and
Samuel Z. Guyer \tt New Scala() instanceof Java: a
comparison of the memory behaviour of
Java and Scala programs . . . . . . . . 97--108
Xiaoming Gu and
Chen Ding A generalized theory of collaborative
caching . . . . . . . . . . . . . . . . 109--120
Rupesh Nasre Exploiting the structure of the
constraint graph for efficient points-to
analysis . . . . . . . . . . . . . . . . 121--132
Hiroshi Inoue and
Toshio Nakatani Identifying the sources of cache misses
in Java programs without relying on
hardware counters . . . . . . . . . . . 133--142
Andrew Farmer and
Andy Gill and
Ed Komp and
Neil Sculthorpe The HERMIT in the machine: a plugin for
the interactive transformation of GHC
core language programs . . . . . . . . . 1--12
Michael D. Adams and
Thomas M. DuBuisson Template your boilerplate: using
Template Haskell for efficient generic
programming . . . . . . . . . . . . . . 13--24
Ben Lippmeier and
Manuel Chakravarty and
Gabriele Keller and
Simon Peyton Jones Guiding parallel array fusion with
indexed types . . . . . . . . . . . . . 25--36
Gabriele Keller and
Manuel M. T. Chakravarty and
Roman Leshchinskiy and
Ben Lippmeier and
Simon Peyton Jones Vectorisation avoidance . . . . . . . . 37--48
Johan Jeuring and
Patrik Jansson and
Cláudio Amaral Testing type class laws . . . . . . . . 49--60
Jonas Duregård and
Patrik Jansson and
Meng Wang Feat: functional enumeration of
algebraic types . . . . . . . . . . . . 61--72
Koen Claessen Shrinking and showing functions:
(functional pearl) . . . . . . . . . . . 73--80
Wyatt Allen and
Martin Erwig Surveyor: a DSEL for representing and
analyzing strongly typed surveys . . . . 81--90
Daniel Winograd-Cort and
Paul Hudak Wormholes: introducing effects to FRP 91--104
Brent A. Yorgey Monoids: theme and variations
(functional pearl) . . . . . . . . . . . 105--116
Richard A. Eisenberg and
Stephanie Weirich Dependently typed programming with
singletons . . . . . . . . . . . . . . . 117--130
Wouter Swierstra \tt xmonad in Coq (experience report):
programming a window manager in a proof
assistant . . . . . . . . . . . . . . . 131--136
David Terei and
Simon Marlow and
Simon Peyton Jones and
David Mazi\`eres Safe Haskell . . . . . . . . . . . . . . 137--148
Sebastian Erdweg and
Felix Rieger and
Tillmann Rendel and
Klaus Ostermann Layout-sensitive language extensibility
with SugarHaskell . . . . . . . . . . . 149--160
Radhia Cousot Engineering mathematics: the odd order
theorem proof . . . . . . . . . . . . . 1--2
Steffen Lösch and
Andrew M. Pitts Full abstraction for nominal Scott
domains . . . . . . . . . . . . . . . . 3--14
Ross Tate The sequential semantics of producer
effect systems . . . . . . . . . . . . . 15--26
Andreas Abel and
Brigitte Pientka and
David Thibodeau and
Anton Setzer Copatterns: programming infinite
structures by observations . . . . . . . 27--38
Guy E. Blelloch and
Robert Harber Cache and I/O efficient functional
algorithms . . . . . . . . . . . . . . . 39--50
Amir M. Ben-Amram and
Samir Genaim On the linear ranking problem for
integer linear-constraint loops . . . . 51--62
Richard Mayr and
Lorenzo Clemente Advanced automata minimization . . . . . 63--74
Hiroshi Unno and
Tachio Terauchi and
Naoki Kobayashi Automating relatively complete
verification of higher-order functional
programs . . . . . . . . . . . . . . . . 75--86
Robert Atkey and
Patricia Johann and
Andrew Kennedy Abstraction and invariance for
algebraically indexed types . . . . . . 87--100
Véronique Benzaken and
Giuseppe Castagna and
Kim Nguyen and
Jérôme Siméon Static and dynamic semantics of NoSQL
languages . . . . . . . . . . . . . . . 101--114
Pavol Cerny and
Thomas A. Henzinger and
Arjun Radhakrishna Quantitative abstraction refinement . . 115--128
Azadeh Farzan and
Zachary Kincaid and
Andreas Podelski Inductive data flow graphs . . . . . . . 129--142
Vijay D'Silva and
Leopold Haller and
Daniel Kroening Abstract conflict driven learning . . . 143--154
Alexis Goyet The Lambda Lambda-Bar calculus: a dual
calculus for unconstrained strategies 155--166
Ugo Dal lago and
Barbara Petit The geometry of types . . . . . . . . . 167--178
Sam Staton and
Paul Blain Levy Universal properties of impure
programming languages . . . . . . . . . 179--192
Chung-Kil Hur and
Georg Neis and
Derek Dreyer and
Viktor Vafeiadis The power of parameterization in
coinductive proof . . . . . . . . . . . 193--206
Benjamin Delaware and
Bruno C. d. S. Oliveira and
Tom Schrijvers Meta-theory \`a la carte . . . . . . . . 207--218
Jonghyun Park and
Jeongbong Seo and
Sungwoo Park A theorem prover for Boolean BI . . . . 219--232
Shriram Krishnamurthi From principles to programming languages
(and back) . . . . . . . . . . . . . . . 233--234
Mark Batty and
Mike Dodds and
Alexey Gotsman Library abstraction for C/C++
concurrency . . . . . . . . . . . . . . 235--248
Ganesan Ramalingam and
Kapil Vaswani Fault tolerance via idempotence . . . . 249--262
Marco Carbone and
Fabrizio Montesi Deadlock-freedom-by-design: multiparty
asynchronous global programming . . . . 263--274
Luís Caires and
João C. Seco The type discipline of behavioral
separation . . . . . . . . . . . . . . . 275--286
Thomas Dinsdale-Young and
Lars Birkedal and
Philippa Gardner and
Matthew Parkinson and
Hongseok Yang Views: compositional reasoning for
concurrent programs . . . . . . . . . . 287--300
Jonas B. Jensen and
Nick Benton and
Andrew Kennedy High-level separation logic for
low-level code . . . . . . . . . . . . . 301--314
Andrew C. Myers How languages can save distributed
computing . . . . . . . . . . . . . . . 315--316
Thomas A. Henzinger and
Christoph M. Kirsch and
Hannes Payer and
Ali Sezgin and
Ana Sokolova Quantitative relaxation of concurrent
data structures . . . . . . . . . . . . 317--328
Delphine Demange and
Vincent Laporte and
Lei Zhao and
Suresh Jagannathan and
David Pichardie and
Jan Vitek Plan B: a buffered memory model for Java 329--342
Aaron J. Turon and
Jacob Thamsborg and
Amal Ahmed and
Lars Birkedal and
Derek Dreyer Logical relations for fine-grained
concurrency . . . . . . . . . . . . . . 343--356
Marco Gaboardi and
Andreas Haeberlen and
Justin Hsu and
Arjun Narayan and
Benjamin C. Pierce Linear dependent types for differential
privacy . . . . . . . . . . . . . . . . 357--370
Cedric Fournet and
Nikhil Swamy and
Juan Chen and
Pierre-Evariste Dagand and
Pierre-Yves Strub and
Benjamin Livshits Fully abstract compilation to JavaScript 371--384
Benjamin Livshits and
Stephen Chong Towards fully automatic placement of
security sanitizers and declassifiers 385--398
Noah D. Goodman The principles and practice of
probabilistic programming . . . . . . . 399--402
Andrew D. Gordon and
Mihhail Aizatulin and
Johannes Borgstrom and
Guillaume Claret and
Thore Graepel and
Aditya V. Nori and
Sriram K. Rajamani and
Claudio Russo A model-learner pattern for Bayesian
reasoning . . . . . . . . . . . . . . . 403--416
Kohei Suenaga and
Hiroyoshi Sekine and
Ichiro Hasuo Hyperstream processing systems:
nonstandard modeling of continuous-time
signals . . . . . . . . . . . . . . . . 417--430
Dimitrios Vytiniotis and
Simon Peyton Jones and
Koen Claessen and
Dan Rosén HALO: Haskell to logic through
denotational semantics . . . . . . . . . 431--442
Matko Botincan and
Domagoj Babi\'c Sigma*: symbolic learning of
input-output specifications . . . . . . 443--456
Filippo Bonchi and
Damien Pous Checking NFA equivalence with
bisimulations up to congruence . . . . . 457--468
Ali Sinan Koksal and
Yewen Pu and
Saurabh Srivastava and
Rastislav Bodik and
Jasmin Fisher and
Nir Piterman Synthesis of biological models from
mutation experiments . . . . . . . . . . 469--482
Ramakrishna Upadrasta and
Albert Cohen Sub-polyhedral scheduling using
(unit-)two-variable-per-inequality
polyhedra . . . . . . . . . . . . . . . 483--496
Tiark Rompf and
Arvind K. Sujeeth and
Nada Amin and
Kevin J. Brown and
Vojin Jovanovic and
HyoukJoong Lee and
Manohar Jonnalagedda and
Kunle Olukotun and
Martin Odersky Optimizing data structures in high-level
programs: new directions for extensible
compilers based on staging . . . . . . . 497--510
Michael D. Adams Principled parsing for
indentation-sensitive languages:
revisiting Landin's offside rule . . . . 511--522
Aquinas Hobor and
Jules Villard The ramifications of sharing in data
structures . . . . . . . . . . . . . . . 523--536
Nishant Totla and
Thomas Wies Complete instantiation-based
interpolation . . . . . . . . . . . . . 537--548
Earl T. Barr and
Thanh Vo and
Vu Le and
Zhendong Su Automatic detection of floating-point
exceptions . . . . . . . . . . . . . . . 549--560
Ruy Ley-Wild and
Aleksandar Nanevski Subjective auxiliary state for
coarse-grained concurrency . . . . . . . 561--574
Mark Miller A tested semantics for getters, setters,
and eval in JavaScript . . . . . . . . . 1--16
Michael Homer and
James Noble and
Kim B. Bruce and
Andrew P. Black and
David J. Pearce Patterns as objects in Grace . . . . . . 17--28
Bard Bloom and
Martin J. Hirzel Robust scripting via patterns . . . . . 29--40
Kurt Nòrmark and
Lone Leth Thomsen and
Bent Thomsen Object-oriented programming with gradual
abstraction . . . . . . . . . . . . . . 41--52
Alessandro Pignotti and
Adam Welc and
Bernd Mathiske Adaptive data parallelism for Internet
clients on heterogeneous platforms . . . 53--62
Håkan Ardö and
Carl Friedrich Bolz and
Maciej Fija\lkowski Loop-aware optimizations in PyPy's
tracing JIT . . . . . . . . . . . . . . 63--72
Thomas Würthinger and
Andreas Wöß and
Lukas Stadler and
Gilles Duboscq and
Doug Simon and
Christian Wimmer Self-optimizing AST interpreters . . . . 73--82
Erwann Wernli and
Pascal Maerki and
Oscar Nierstrasz Ownership, filters and crossing
handlers: flexible ownership in dynamic
languages . . . . . . . . . . . . . . . 83--94
Benjamin S. Lerner and
Dan Grossman Detecting conflicts among declarative UI
extensions . . . . . . . . . . . . . . . 95--106
Bastian Steinert and
Damien Cassou and
Robert Hirschfeld CoExist: overcoming aversion to change 107--118
Ferruccio Damiani and
Luca Padovani and
Ina Schaefer A formal foundation for dynamic
delta-oriented software product lines 1--10
Thomas Thüm and
Ina Schaefer and
Sven Apel and
Martin Hentschel Family-based deductive verification of
software product lines . . . . . . . . . 11--20
Uwe Ryssel and
Joern Ploennigs and
Klaus Kabitzsch Reasoning of feature models from derived
features . . . . . . . . . . . . . . . . 21--30
Derek Rayside and
Vajihollah Montaghami and
Francesca Leung and
Albert Yuen and
Kevin Xu and
Daniel Jackson Synthesizing iterators from abstraction
functions . . . . . . . . . . . . . . . 31--40
Geoffrey C. Hulette and
Matthew Sottile and
Allen D. Malony Composing typemaps in Twig . . . . . . . 41--49
Eyvind W. Axelsen and
Stein Krogdahl Package Templates: a definition by
semantics-preserving source-to-source
transformations to efficient Java code 50--59
Petr Spacek and
Christophe Dony and
Chouki Tibermacine and
Luc Fabresse An inheritance system for structural &
behavioral reuse in component-based
software programming . . . . . . . . . . 60--69
Huaxi (Yulin) Zhang and
Lei Zhang and
Christelle Urtado and
Sylvain Vauttier and
Marianne Huchard A three-level component model in
component based software development . . 70--79
John Freeman and
Jaakko Järvi and
Gabriel Foust HotDrink: a library for Web user
interfaces . . . . . . . . . . . . . . . 80--83
T. L. Riché and
R. Gonçalves and
B. Marker and
D. Batory Pushouts in software architecture design 84--92
Hamid Bagheri and
Kevin Sullivan Pol: specification-driven synthesis of
architectural code frameworks for
platform-based applications . . . . . . 93--102
Tim Bauer and
Martin Erwig and
Alan Fern and
Jervis Pinto Faster program adaptation through reward
attribution inference . . . . . . . . . 103--111
Sven Efftinge and
Moritz Eysholdt and
Jan Köhnlein and
Sebastian Zarnekow and
Robert von Massow and
Wilhelm Hasselbring and
Michael Hanus Xbase: implementing domain-specific
languages for Java . . . . . . . . . . . 112--121
Jon Rafkind and
Matthew Flatt Honu: syntactic extension for algebraic
notation through enforestation . . . . . 122--131
Eric Walkingshaw and
Martin Erwig A calculus for modeling and implementing
variation . . . . . . . . . . . . . . . 132--140
Michael Bond GPUDet: a deterministic GPU architecture 1--12
Hyojin Sung and
Rakesh Komuravelli and
Sarita V. Adve DeNovoND: efficient hardware support for
disciplined non-determinism . . . . . . 13--26
Benjamin Wester and
David Devecsery and
Peter M. Chen and
Jason Flinn and
Satish Narayanasamy Parallelizing data race detection . . . 27--38
Brandon Lucia and
Luis Ceze Cooperative empirical failure avoidance
for multithreaded programs . . . . . . . 39--50
Íñigo Goiri and
William Katsak and
Kien Le and
Thu D. Nguyen and
Ricardo Bianchini Parasol and GreenSwitch: managing
datacenters powered by renewable energy 51--64
Kai Shen and
Arrvindh Shriraman and
Sandhya Dwarkadas and
Xiao Zhang and
Zhuan Chen Power containers: an OS facility for
fine-grained power and energy management
on multicore servers . . . . . . . . . . 65--76
Christina Delimitrou and
Christos Kozyrakis Paragon: QoS-aware scheduling for
heterogeneous datacenters . . . . . . . 77--88
Lingjia Tang and
Jason Mars and
Wei Wang and
Tanima Dey and
Mary Lou Soffa ReQoS: reactive static/dynamic
compilation for QoS in warehouse scale
computers . . . . . . . . . . . . . . . 89--100
Joy Arulraj and
Po-Chun Chang and
Guoliang Jin and
Shan Lu Production-run software failure
diagnosis via hardware performance
counters . . . . . . . . . . . . . . . . 101--112
Wei Zhang and
Marc de Kruijf and
Ang Li and
Shan Lu and
Karthikeyan Sankaralingam ConAir: featherweight concurrency bug
recovery via single-threaded idempotent
execution . . . . . . . . . . . . . . . 113--126
Nicolas Viennot and
Siddharth Nair and
Jason Nieh Transparent mutable replay for multicore
debugging and patch validation . . . . . 127--138
Swarup Kumar Sahoo and
John Criswell and
Chase Geigle and
Vikram Adve Using likely invariants for automated
software fault localization . . . . . . 139--152
Eric Paulos The rise of the expert amateur: DIY
culture and the evolution of computer
science . . . . . . . . . . . . . . . . 153--154
Arun Raghavan and
Laurel Emurian and
Lei Shao and
Marios Papaefthymiou and
Kevin P. Pipe and
Thomas F. Wenisch and
Milo M. K. Martin Computational sprinting on a
hardware/software testbed . . . . . . . 155--166
Wonsun Ahn and
Yuelu Duan and
Josep Torrellas DeAliaser: alias speculation using
atomic region support . . . . . . . . . 167--180
Heekwon Park and
Seungjae Baek and
Jongmoo Choi and
Donghee Lee and
Sam H. Noh Regularities considered harmful: forcing
randomness to memory accesses to reduce
row buffer conflicts for multi-core,
multi-bank systems . . . . . . . . . . . 181--192
Nima Honarmand and
Nathan Dautenhahn and
Josep Torrellas and
Samuel T. King and
Gilles Pokam and
Cristiano Pereira Cyrus: unintrusive application-level
record-replay for replay parallelism . . 193--206
Augusto Born de Oliveira and
Sebastian Fischmeister and
Amer Diwan and
Matthias Hauswirth and
Peter F. Sweeney Why you should care about quantile
regression . . . . . . . . . . . . . . . 207--218
Charlie Curtsinger and
Emery D. Berger STABILIZER: statistically sound
performance evaluation . . . . . . . . . 219--228
Lokesh Gidra and
Gaël Thomas and
Julien Sopena and
Marc Shapiro A study of the scalability of
stop-the-world garbage collectors on
multicores . . . . . . . . . . . . . . . 229--240
Daniel S. McFarlin and
Charles Tucker and
Craig Zilles Discerning the dominant out-of-order
performance advantage: is it speculation
or dynamism? . . . . . . . . . . . . . . 241--252
Stephen Checkoway and
Hovav Shacham Iago attacks: why the system call API is
a bad untrusted RPC interface . . . . . 253--264
Owen S. Hofmann and
Sangman Kim and
Alan M. Dunn and
Michael Z. Lee and
Emmett Witchel InkTag: secure applications on an
untrusted operating system . . . . . . . 265--278
Cristiano Giuffrida and
Anton Kuijsten and
Andrew S. Tanenbaum Safe and automatic live update for
operating systems . . . . . . . . . . . 279--292
Haohui Mai and
Edgar Pek and
Hui Xue and
Samuel Talmadge King and
Parthasarathy Madhusudan Verifying security invariants in
ExpressOS . . . . . . . . . . . . . . . 293--304
Eric Schkufza and
Rahul Sharma and
Alex Aiken Stochastic superoptimization . . . . . . 305--316
Eric Schulte and
Jonathan DiLorenzo and
Westley Weimer and
Stephanie Forrest Automated repair of binary and assembly
programs for cooperating embedded
devices . . . . . . . . . . . . . . . . 317--328
Heming Cui and
Gang Hu and
Jingyue Wu and
Junfeng Yang Verifying systems rules using
rule-directed symbolic execution . . . . 329--342
Xiaoya Xiang and
Chen Ding and
Hao Luo and
Bin Bao HOTL: a higher order theory of locality 343--356
Hui Kang and
Jennifer L. Wong To hardware prefetch or not to
prefetch?: a virtualized environment
study and core binding approach . . . . 357--368
Hwanju Kim and
Sangwook Kim and
Jinkyu Jeong and
Joonwon Lee and
Seungryoul Maeng Demand-based coordinated scheduling for
SMP VMs . . . . . . . . . . . . . . . . 369--380
Mohammad Dashti and
Alexandra Fedorova and
Justin Funston and
Fabien Gaud and
Renaud Lachaize and
Baptiste Lepers and
Vivien Quema and
Mark Roth Traffic management: a holistic approach
to memory placement on NUMA systems . . 381--394
Adwait Jog and
Onur Kayiran and
Nachiappan Chidambaram Nachiappan and
Asit K. Mishra and
Mahmut T. Kandemir and
Onur Mutlu and
Ravishankar Iyer and
Chita R. Das OWL: cooperative thread array aware
scheduling techniques for improving
GPGPU performance . . . . . . . . . . . 395--406
Sreepathi Pai and
Matthew J. Thazhuthaveetil and
R. Govindarajan Improving GPGPU concurrency with elastic
kernels . . . . . . . . . . . . . . . . 407--418
Taewook Oh and
Hanjun Kim and
Nick P. Johnson and
Jae W. Lee and
David I. August Practical automatic loop specialization 419--430
Phitchaya Mangpo Phothilimthana and
Jason Ansel and
Jonathan Ragan-Kelley and
Saman Amarasinghe Portable performance on heterogeneous
architectures . . . . . . . . . . . . . 431--444
Aashish Mittal and
Dushyant Bansal and
Sorav Bansal and
Varun Sethi Efficient virtualization on embedded
Power Architecture\reg platforms . . . . 445--458
Mark D. Hill Research directions for 21st Century
computer systems: ASPLOS 2013 panel . . 459--460
Anil Madhavapeddy and
Richard Mortier and
Charalampos Rotsos and
David Scott and
Balraj Singh and
Thomas Gazagnaire and
Steven Smith and
Steven Hand and
Jon Crowcroft Unikernels: library operating systems
for the cloud . . . . . . . . . . . . . 461--472
Asim Kadav and
Matthew J. Renzelmann and
Michael M. Swift Fine-grained fault tolerance using
device checkpoints . . . . . . . . . . . 473--484
Mark Silberstein and
Bryan Ford and
Idit Keidar and
Emmett Witchel GPUfs: integrating a file system with
GPUs . . . . . . . . . . . . . . . . . . 485--498
Nicholas Hunt and
Tom Bergan and
Luis Ceze and
Steven D. Gribble DDOS: taming nondeterminism in
distributed systems . . . . . . . . . . 499--508
Cheng Wang and
Youfeng Wu TSO\_ATOMICITY: efficient hardware
primitive for TSO-preserving region
optimizations . . . . . . . . . . . . . 509--520
Syed Ali Raza Jafri and
Gwendolyn Voskuilen and
T. N. Vijaykumar Wait-n-GoTM: improving HTM performance
by serializing cyclic dependencies . . . 521--534
Xuehai Qian and
Josep Torrellas and
Benjamin Sahelices and
Depei Qian Volition: scalable and precise
sequential consistency violation
detection . . . . . . . . . . . . . . . 535--548
J. P. Grossman and
Jeffrey S. Kuskin and
Joseph A. Bank and
Michael Theobald and
Ron O. Dror and
Douglas J. Ierardi and
Richard H. Larson and
U. Ben Schafer and
Brian Towles and
Cliff Young and
David E. Shaw Hardware support for fine-grained
event-driven computation in Anton 2 . . 549--560
Jan Vitek SIGPLAN Chair's report . . . . . . . . . 1--2
Jeremy Gibbons ACM SIGPLAN Vice-Chair's report . . . . 3--3
Andrew P. Black SIGPLAN Secretary's report . . . . . . . 4--5
Cristina V. Lopes SIGPLAN Treasurer's report . . . . . . . 6--6
Derek Dreyer SIGPLAN most influential paper awards 7--8
Julia Lawall and
Cristina V. Lopes SIGPLAN Professional Activities
Committee report . . . . . . . . . . . . 9--9
Michael Hind CACM research highlights annual report 10--11
Derek Dreyer and
John Field and
Roberto Giacobazzi and
Michael Hicks and
Suresh Jagannathan and
Mooly Sagiv and
Peter Sewell and
Phil Wadler Principles of POPL . . . . . . . . . . . 12--16
Shriram Krishnamurthi Artifact evaluation for software
conferences . . . . . . . . . . . . . . 17--21
Cormac Flanagan and
K. Rustan M. Leino and
Mark Lillibridge and
Greg Nelson and
James B. Saxe and
Raymie Stata PLDI 2002: Extended static checking for
Java . . . . . . . . . . . . . . . . . . 22--33
Robert Bruce Findler and
Matthias Felleisen ICFP 2002: Contracts for higher-order
functions . . . . . . . . . . . . . . . 34--45
Emery D. Berger and
Benjamin G. Zorn and
Kathryn S. McKinley OOPSLA 2002: Reconsidering custom memory
allocation . . . . . . . . . . . . . . . 46--57
David F. Bacon and
Perry Cheng and
V. T. Rajan POPL 2003: a real-time garbage collector
with low overhead and consistent
utilization . . . . . . . . . . . . . . 58--71
Youfeng Wu HW/SW co-designed acceleration of
dynamic languages . . . . . . . . . . . 1--2
Daya Shanker Khudia and
Scott Mahlke Low cost control flow protection using
abstract control signatures . . . . . . 3--12
Hao Chen and
Chengmo Yang Boosting efficiency of fault detection
and recovery through
application-specific comparison and
checkpointing . . . . . . . . . . . . . 13--20
Isabella Stilkerich and
Michael Strotz and
Christoph Erhardt and
Martin Hoffmann and
Daniel Lohmann and
Fabian Scheler and
Wolfgang Schröder-Preikschat A JVM for soft-error-prone embedded
systems . . . . . . . . . . . . . . . . 21--32
Ian Finlayson and
Brandon Davis and
Peter Gavin and
Gang-Ryung Uh and
David Whalley and
Magnus Själander and
Gary Tyson Improving processor efficiency by
statically pipelining instructions . . . 33--44
Vasileios Porpodas and
Marcelo Cintra LUCAS: latency-adaptive unified cluster
assignment and instruction scheduling 45--54
Hakbeom Jang and
Channoh Kim and
Jae W. Lee Practical speculative parallelization of
variable-length decompression algorithms 55--64
Sudipta Chattopadhyay and
Lee Kee Chong and
Abhik Roychoudhury Program performance spectrum . . . . . . 65--76
Carlos Moreno and
Sebastian Fischmeister and
M. Anwar Hasan Non-intrusive program tracing and
debugging of deployed embedded systems
through side-channel analysis . . . . . 77--88
Marcel Beemster The role of C in the dark ages of
multi-core . . . . . . . . . . . . . . . 89--90
Tianzheng Wang and
Duo Liu and
Yi Wang and
Zili Shao FTL 2: a hybrid \em flash \em
translation \em layer with logging for
write reduction in flash memory . . . . 91--100
Qingan Li and
Lei Jiang and
Youtao Zhang and
Yanxiang He and
Chun Jason Xue Compiler directed write-mode selection
for high performance low power volatile
PCM . . . . . . . . . . . . . . . . . . 101--110
Yong Guan and
Guohui Wang and
Yi Wang and
Renhai Chen and
Zili Shao BLog: block-level log-block management
for NAND flash memory storage systems 111--120
Asma Mehiaoui and
Ernest Wozniak and
Sara Tucci-Piergiovanni and
Chokri Mraidha and
Marco Di Natale and
Haibo Zeng and
Jean-Philippe Babau and
Laurent Lemarchand and
Sébastien Gerard A two-step optimization technique for
functions placement, partitioning, and
priority assignment in distributed
systems . . . . . . . . . . . . . . . . 121--132
Adnan Bouakaz and
Jean-Pierre Talpin Buffer minimization in earliest-deadline
first scheduling of dataflow graphs . . 133--142
Stefan J. Geuns and
Joost P. H. M. Hausmans and
Marco J. G. Bekooij Automatic dataflow model extraction from
modal real-time stream processing
applications . . . . . . . . . . . . . . 143--152
Cheng Wang and
Sunita Chandrasekaran and
Peng Sun and
Barbara Chapman and
Jim Holt Portable mapping of openMP to multicore
embedded systems using MCA APIs . . . . 153--162
Benedikt Huber and
Daniel Prokesch and
Peter Puschner Combined WCET analysis of bitcode and
machine code using control-flow relation
graphs . . . . . . . . . . . . . . . . . 163--172
Yannis Smaragdakis Look up!: your future is in the cloud 1--2
Alvin Cheung and
Armando Solar-Lezama and
Samuel Madden Optimizing database-backed applications
with query synthesis . . . . . . . . . . 3--14
Rishabh Singh and
Sumit Gulwani and
Armando Solar-Lezama Automated feedback generation for
introductory programming assignments . . 15--26
Tihomir Gvero and
Viktor Kuncak and
Ivan Kuraj and
Ruzica Piskac Complete completion using types and
weights . . . . . . . . . . . . . . . . 27--38
Nick P. Johnson and
Taewook Oh and
Ayal Zaks and
David I. August Fast condensation of the program
dependence graph . . . . . . . . . . . . 39--50
Khaled ElWazeer and
Kapil Anand and
Aparna Kotha and
Matthew Smithson and
Rajeev Barua Scalable variable and data type
detection in a binary rewriter . . . . . 51--60
Bharghava Rajaram and
Vijay Nagarajan and
Susmit Sarkar and
Marco Elver Fast RMWs for TSO: semantics and
implementation . . . . . . . . . . . . . 61--72
Colin S. Gordon and
Michael D. Ernst and
Dan Grossman Rely-guarantee references for refinement
types over aliased mutable data . . . . 73--84
Ben L. Titzer Harmonizing classes, functions, tuples,
and type parameters in Virgil III . . . 85--94
Sebastian Burckhardt and
Manuel Fahndrich and
Peli de Halleux and
Sean McDirmid and
Michal Moskal and
Nikolai Tillmann and
Jun Kato It's alive! Continuous feedback in UI
programming . . . . . . . . . . . . . . 95--104
Zachary DeVito and
James Hegarty and
Alex Aiken and
Pat Hanrahan and
Jan Vitek Terra: a multi-stage language for
high-performance computing . . . . . . . 105--116
Jiajia Li and
Guangming Tan and
Mingyu Chen and
Ninghui Sun SMAT: an input adaptive auto-tuner for
sparse matrix-vector multiplication . . 117--126
Martin Kong and
Richard Veras and
Kevin Stock and
Franz Franchetti and
Louis-Noël Pouchet and
P. Sadayappan When polyhedral transformations meet
SIMD code generation . . . . . . . . . . 127--138
Fred B. Schneider Programming languages in security:
keynote . . . . . . . . . . . . . . . . 139--140
Jeff Huang and
Charles Zhang and
Julian Dolby CLAP: recording local executions to
reproduce concurrency failures . . . . . 141--152
Tayfun Elmas and
Jacob Burnim and
George Necula and
Koushik Sen CONCURRIT: a domain specific language
for reproducing concurrency bugs . . . . 153--164
Max Schäefer and
Manu Sridharan and
Julian Dolby and
Frank Tip Dynamic determinacy analysis . . . . . . 165--174
Jianzhou Zhao and
Santosh Nagarakatte and
Milo M. K. Martin and
Steve Zdancewic Formal verification of SSA-based
optimizations for LLVM . . . . . . . . . 175--186
Robin Morisset and
Pankaj Pawan and
Francesco Zappa Nardelli Compiler testing via a theory of sound
optimisations in the C11/C++11 memory
model . . . . . . . . . . . . . . . . . 187--196
Yang Chen and
Alex Groce and
Chaoqiang Zhang and
Weng-Keen Wong and
Xiaoli Fern and
Eric Eide and
John Regehr Taming compiler fuzzers . . . . . . . . 197--208
Sam Blackshear and
Shuvendu K. Lahiri Almost-correct specifications: a modular
semantic framework for assigning
confidence to warnings . . . . . . . . . 209--218
Byron Cook and
Eric Koskinen Reasoning about nondeterminism in
programs . . . . . . . . . . . . . . . . 219--230
Xiaokang Qiu and
Pranav Garg and
Andrei Stefanescu and
Parthasarathy Madhusudan Natural proofs for structure, data, and
separation . . . . . . . . . . . . . . . 231--242
Hongtao Yu and
Hou-Jen Ko and
Zhiyuan Li General data structure expansion for
multi-threading . . . . . . . . . . . . 243--252
Wei-Lun Hung and
Vijay K. Garg AutoSynch: an automatic-signal monitor
based on predicate tagging . . . . . . . 253--262
Guy Golan-Gueta and
G. Ramalingam and
Mooly Sagiv and
Eran Yahav Concurrent libraries with foresight . . 263--274
Sam Blackshear and
Bor-Yuh Evan Chang and
Manu Sridharan Thresher: precise refutations for heap
reachability . . . . . . . . . . . . . . 275--286
Abhishek Udupa and
Arun Raghavan and
Jyotirmoy V. Deshmukh and
Sela Mador-Haim and
Milo M. K. Martin and
Rajeev Alur TRANSIT: specifying protocols with
concolic snippets . . . . . . . . . . . 287--296
Tiejun Gao and
Karin Strauss and
Stephen M. Blackburn and
Kathryn S. McKinley and
Doug Burger and
James Larus Using managed runtime systems to
tolerate holes in wearable memories . . 297--308
Nachshon Cohen and
Erez Petrank Limitations of partial compaction:
towards practical bounds . . . . . . . . 309--320
Ankush Desai and
Vivek Gupta and
Ethan Jackson and
Shaz Qadeer and
Sriram Rajamani and
Damien Zufferey P: safe asynchronous event-driven
programming . . . . . . . . . . . . . . 321--332
Alexander S. Green and
Peter LeFanu Lumsdaine and
Neil J. Ross and
Peter Selinger and
Beno\^\it Valiron Quipper: a scalable quantum programming
language . . . . . . . . . . . . . . . . 333--342
Chinawat Isradisaikul and
Andrew C. Myers Reconciling exhaustive pattern matching
with objects . . . . . . . . . . . . . . 343--354
Eric Bodden and
Társis Tolêdo and
Márcio Ribeiro and
Claus Brabrand and
Paulo Borba and
Mira Mezini SPL LIFT: statically analyzing software
product lines in minutes instead of
years . . . . . . . . . . . . . . . . . 355--364
Xin Zhang and
Mayur Naik and
Hongseok Yang Finding optimum abstractions in
parametric dataflow analysis . . . . . . 365--376
Kalmer Apinis and
Helmut Seidl and
Vesal Vojdani How to combine widening and narrowing
for non-monotonic systems of equations 377--386
Nikhil Swamy and
Joel Weinberger and
Cole Schlesinger and
Juan Chen and
Benjamin Livshits Verifying higher-order programs with the
Dijkstra monad . . . . . . . . . . . . . 387--398
Ilya Sergey and
Dominique Devriese and
Matthew Might and
Jan Midtgaard and
David Darais and
Dave Clarke and
Frank Piessens Monadic abstract interpreters . . . . . 399--410
Evan Czaplicki and
Stephen Chong Asynchronous functional reactive
programming for GUIs . . . . . . . . . . 411--422
George Kastrinis and
Yannis Smaragdakis Hybrid context-sensitivity for points-to
analysis . . . . . . . . . . . . . . . . 423--434
Qirun Zhang and
Michael R. Lyu and
Hao Yuan and
Zhendong Su Fast algorithms for
Dyck--CFL-reachability with applications
to alias analysis . . . . . . . . . . . 435--446
Sriram Sankaranarayanan and
Aleksandar Chakarov and
Sumit Gulwani Static analysis for probabilistic
programs: inferring whole program
properties from finitely many paths . . 447--458
Hongjin Liang and
Xinyu Feng Modular verification of linearizability
with non-fixed linearization points . . 459--470
Thomas Arthur Leck Sewell and
Magnus O. Myreen and
Gerwin Klein Translation validation for a verified OS
kernel . . . . . . . . . . . . . . . . . 471--482
Arjun Guha and
Mark Reitblatt and
Nate Foster Machine-verified network controllers . . 483--494
Tony Nowatzki and
Michael Sartin-Tarm and
Lorenzo De Carli and
Karthikeyan Sankaralingam and
Cristian Estan and
Behnam Robatmili A general constraint-centric scheduling
framework for spatial architectures . . 495--506
Jonathan Lifflander and
Sriram Krishnamoorthy and
Laxmikant V. Kale Steal Tree: low-overhead tracing of work
stealing schedulers . . . . . . . . . . 507--518
Jonathan Ragan-Kelley and
Connelly Barnes and
Andrew Adams and
Sylvain Paris and
Frédo Durand and
Saman Amarasinghe Halide: a language and compiler for
optimizing parallelism, locality, and
recomputation in image processing
pipelines . . . . . . . . . . . . . . . 519--530
Ning Jia and
Chun Yang and
Jing Wang and
Dong Tong and
Keyi Wang SPIRE: improving dynamic binary
translation through SPC-indexed indirect
branch redirecting . . . . . . . . . . . 1--12
Tobias J. K. Edler von Koch and
Björn Franke Limits of region-based dynamic binary
parallelization . . . . . . . . . . . . 13--22
Chun-Chen Hsu and
Pangfeng Liu and
Jan-Jan Wu and
Pen-Chung Yew and
Ding-Yong Hong and
Wei-Chung Hsu and
Chien-Min Wang Improving dynamic binary optimization
through early-exit guided code region
formation . . . . . . . . . . . . . . . 23--32
Marco Kaufmann and
Rainer G. Spallek Superblock compilation and other
optimization techniques for a Java-based
DBT machine emulator . . . . . . . . . . 33--40
Changyeon Jo and
Erik Gustafsson and
Jeongseok Son and
Bernhard Egger Efficient live migration of virtual
machines using shared storage . . . . . 41--50
Jui-Hao Chiang and
Han-Lin Li and
Tzi-cker Chiueh Introspection-based memory
de-duplication and migration . . . . . . 51--62
Lei Cui and
Jianxin Li and
Bo Li and
Jinpeng Huai and
Chunming Hu and
Tianyu Wo and
Hussain Al-Aqrabi and
Lu Liu VMScatter: migrate virtual machines to
many hosts . . . . . . . . . . . . . . . 63--72
Ruijin Zhou and
Fang Liu and
Chao Li and
Tao Li Optimizing virtual machine live storage
migration in heterogeneous storage
environment . . . . . . . . . . . . . . 73--84
Xiang Song and
Jicheng Shi and
Ran Liu and
Jian Yang and
Haibo Chen Parallelizing live migration of virtual
machines . . . . . . . . . . . . . . . . 85--96
Yangchun Fu and
Zhiqiang Lin EXTERIOR: using a dual-VM based external
shell for guest-OS introspection,
configuration, and recovery . . . . . . 97--110
Yuehua Dai and
Yong Qi and
Jianbao Ren and
Yi Shi and
Xiaoguang Wang and
Xuan Yu A lightweight VMM on many core for high
performance computing . . . . . . . . . 111--120
Hiroshi Yamada and
Kenji Kono Traveling forward in time to newer
operating systems using ShadowReboot . . 121--130
Michael R. Jantz and
Prasad A. Kulkarni Performance potential of optimization
phase selection during dynamic JIT
compilation . . . . . . . . . . . . . . 131--142
Nurudeen A. Lameed and
Laurie J. Hendren A modular approach to on-stack
replacement in LLVM . . . . . . . . . . 143--154
Michael R. Jantz and
Carl Strickland and
Karthik Kumar and
Martin Dimitrov and
Kshitij A. Doshi A framework for application guidance in
virtual memory systems . . . . . . . . . 155--166
Chen Chen and
Petros Maniatis and
Adrian Perrig and
Amit Vasudevan and
Vyas Sekar Towards verifiable resource accounting
for outsourced computation . . . . . . . 167--178
Ruijin Zhou and
Tao Li Leveraging phase change memory to
achieve efficient virtual machine
execution . . . . . . . . . . . . . . . 179--190
Jiannan Ouyang and
John R. Lange Preemptable ticket spinlocks: improving
consolidated performance in the cloud 191--200
Chao Yang and
Wei Xue and
Haohuan Fu and
Lin Gan and
Linfeng Li and
Yangtong Xu and
Yutong Lu and
Jiachang Sun and
Guangwen Yang and
Weimin Zheng A peta-scalable CPU-GPU algorithm for
global atmospheric simulations . . . . . 1--12
Jonathan Lifflander and
Phil Miller and
Laxmikant Kale Adoption protocols for fanout-optimal
fault-tolerant termination detection . . 13--22
Tomofumi Yuki and
Paul Feautrier and
Sanjay Rajopadhye and
Vijay Saraswat Array dataflow analysis for polyhedral
X10 programs . . . . . . . . . . . . . . 23--34
Dimitrios Prountzos and
Keshav Pingali Betweenness centrality: algorithms and
implementations . . . . . . . . . . . . 35--46
Lingxiang Xiang and
Michael Lee Scott Compiler aided manual speculation for
high performance concurrent data
structures . . . . . . . . . . . . . . . 47--56
Bo Wu and
Zhijia Zhao and
Eddy Zheng Zhang and
Yunlian Jiang and
Xipeng Shen Complexity analysis and algorithm design
for reorganizing data to minimize
non-coalesced memory accesses on GPU . . 57--68
Nhat Minh Lê and
Antoniu Pop and
Albert Cohen and
Francesco Zappa Nardelli Correct and efficient work-stealing for
weak memory models . . . . . . . . . . . 69--80
Lars Bergstrom and
Matthew Fluet and
Mike Rainey and
John Reppy and
Stephen Rosen and
Adam Shaw Data-only flattening for nested data
parallelism . . . . . . . . . . . . . . 81--92
Dmitriy Morozov and
Gunther Weber Distributed merge trees . . . . . . . . 93--102
Adam Morrison and
Yehuda Afek Fast concurrent queues for x86
processors . . . . . . . . . . . . . . . 103--112
Jons-Tobias Wamhoff and
Christof Fetzer and
Pascal Felber and
Etienne Rivi\`ere and
Gilles Muller FastLane: improving performance of
software transactional memory for low
thread counts . . . . . . . . . . . . . 113--122
Gilles Barthe and
Juan Manuel Crespo and
Sumit Gulwani and
Cesar Kunz and
Mark Marron From relational verification to SIMD
loop synthesis . . . . . . . . . . . . . 123--134
Julian Shun and
Guy E. Blelloch Ligra: a lightweight graph processing
framework for shared memory . . . . . . 135--146
Rupesh Nasre and
Martin Burtscher and
Keshav Pingali Morph algorithms on GPUs . . . . . . . . 147--156
Irina Calciu and
Dave Dice and
Yossi Lev and
Victor Luchangco and
Virendra J. Marathe and
Nir Shavit NUMA-aware reader-writer locks . . . . . 157--166
Zizhong Chen Online-ABFT: an online algorithm based
fault tolerance scheme for soft error
detection in iterative methods . . . . . 167--176
Andrew Friedley and
Torsten Hoefler and
Greg Bronevetsky and
Andrew Lumsdaine and
Ching-Chen Ma Ownership passing: efficient distributed
memory programming on multi-core systems 177--186
Leo A. Meyerovich and
Matthew E. Torok and
Eric Atkinson and
Rastislav Bodik Parallel schedule synthesis for
attribute grammars . . . . . . . . . . . 187--196
Mrinal Deo and
Sean Keely Parallel suffix array and least common
prefix for the GPU . . . . . . . . . . . 197--206
Yufei Chen and
Haibo Chen Scalable deterministic replay in a
parallel full-system emulator . . . . . 207--218
Umut A. Acar and
Arthur Chargueraud and
Mike Rainey Scheduling parallel programs by work
stealing with private deques . . . . . . 219--228
Shengen Yan and
Guoping Long and
Yunquan Zhang StreamScan: fast scan algorithms for
GPUs without global barrier
synchronization . . . . . . . . . . . . 229--238
Stephen T. Heumann and
Vikram S. Adve and
Shengjie Wang The tasks with effects model for safe
concurrency . . . . . . . . . . . . . . 239--250
Daniele Bonetta and
Walter Binder and
Cesare Pautasso TigerQuoll: parallel event-based
JavaScript . . . . . . . . . . . . . . . 251--260
Dave Dice and
Yossi Lev and
Yujie Liu and
Victor Luchangco and
Mark Moir Using hardware transactional memory to
correct and simplify and readers-writer
lock algorithm . . . . . . . . . . . . . 261--270
Calin Cascaval and
Seth Fowler and
Pablo Montesinos-Ortego and
Wayne Piekarski and
Mehrdad Reshadi and
Behnam Robatmili and
Michael Weber and
Vrajesh Bhavsar ZOOMM: a parallel Web browser engine for
multicore mobile devices . . . . . . . . 271--280
Ivan Grasso and
Klaus Kofler and
Biagio Cosenza and
Thomas Fahringer Automatic problem size sensitive task
partitioning on heterogeneous parallel
systems . . . . . . . . . . . . . . . . 281--282
Jun Liu and
Wei Ding and
Ohyoung Jang and
Mahmut Kandemir Data layout optimization for GPGPU
architectures . . . . . . . . . . . . . 283--284
Shobana Padmanabhan and
Yixin Chen and
Roger D. Chamberlain Decomposition techniques for optimal
design-space exploration of streaming
applications . . . . . . . . . . . . . . 285--286
Xiaodong Yu and
Michela Becchi Exploring different automata
representations for efficient regular
expression matching on GPUs . . . . . . 287--288
Nick Edmonds and
Jeremiah Willcock and
Andrew Lumsdaine Expressing graph algorithms using
generalized active messages . . . . . . 289--290
Ligang Lu and
Karen Magerlein Multi-level parallel computing of
reverse time migration for seismic
imaging on Blue Gene/Q . . . . . . . . . 291--292
Changhee Park and
Guy L. Steele, Jr. and
Jean-Baptiste Tristan Parallel programming with big operators 293--294
Yehuda Afek and
Amir Levy and
Adam Morrison Programming with hardware lock elision 295--296
Kai Lu and
Xu Zhou and
Xiaoping Wang and
Wenzhe Zhang and
Gen Li RaceFree: an efficient multi-threading
model for determinism . . . . . . . . . 297--298
Julian Shun and
Guy E. Blelloch and
Jeremy T. Fineman and
Phillip B. Gibbons Reducing contention through priority
updates . . . . . . . . . . . . . . . . 299--300
Gregory Diamos and
Haicheng Wu and
Jin Wang and
Ashwin Lele and
Sudhakar Yalamanchili Relational algorithms for
multi-bulk-synchronous processors . . . 301--302
Fernando Miguel Carvalho and
João Cachopo Runtime elision of transactional
barriers for captured memory . . . . . . 303--304
Chang-Seo Park and
Koushik Sen and
Costin Iancu Scalable data race detection for
partitioned global address space
programs . . . . . . . . . . . . . . . . 305--306
Dave Dice and
Yossi Lev and
Mark Moir Scalable statistics counters . . . . . . 307--308
Justin M. Wozniak and
Timothy G. Armstrong and
Michael Wilde and
Daniel S. Katz and
Ewing Lusk and
Ian T. Foster Swift/T: scalable data flow programming
for many-task applications . . . . . . . 309--310
Yan Cai and
Ke Zhai and
Shangru Wu and
W. K. Chan TeamWork: synchronizing threads globally
to detect real deadlocks for
multithreaded programs . . . . . . . . . 311--312
Mohammed El Mehdi Diouri and
Olivier Glück and
Laurent Lef\`evre and
Franck Cappello Towards an energy estimator for fault
tolerance protocols . . . . . . . . . . 313--314
Martin Wimmer and
Daniel Cederman and
Jesper Larsson Träff and
Philippas Tsigas Work-stealing with configurable
scheduling strategies . . . . . . . . . 315--316
Bowen Zhou and
Milind Kulkarni and
Saurabh Bagchi WuKong: effective diagnosis of bugs at
large system scales . . . . . . . . . . 317--318
Ulf Norell Interactive programming with dependent
types . . . . . . . . . . . . . . . . . 1--2
Dmitriy Traytel and
Tobias Nipkow Verified decision procedures for MSO on
words based on derivatives of regular
expressions . . . . . . . . . . . . . . 3--12
Christopher Broadbent and
Arnaud Carayol and
Matthew Hague and
Olivier Serre C-SHORe: a collapsible approach to
higher-order verification . . . . . . . 13--24
Leaf Petersen and
Dominic Orchard and
Neal Glew Automatic SIMD vectorization for Haskell 25--36
Geoffrey Mainland and
Roman Leshchinskiy and
Simon Peyton Jones Exploiting vector instructions with
generalized stream fusion . . . . . . . 37--48
Trevor L. McDonell and
Manuel M. T. Chakravarty and
Gabriele Keller and
Ben Lippmeier Optimising purely functional GPU
programs . . . . . . . . . . . . . . . . 49--60
Jean-Philippe Bernardy and
Moulin Guilhem Type-theory in color . . . . . . . . . . 61--72
Dominique Devriese and
Frank Piessens Typed syntactic meta-programming . . . . 73--86
Beta Ziliani and
Derek Dreyer and
Neelakantan R. Krishnaswami and
Aleksandar Nanevski and
Viktor Vafeiadis Mtac: a monad for typed tactic
programming in Coq . . . . . . . . . . . 87--100
Stephen Dolan Fun with semirings: a functional pearl
on the abuse of linear algebra . . . . . 101--110
Jean-Philippe Bernardy and
Koen Claessen Efficient divide-and-conquer parsing of
practical context-free languages . . . . 111--122
Harry George Mairson Functional geometry and the Traité de
Lutherie: functional pearl . . . . . . . 123--132
Edwin Brady Programming and reasoning with algebraic
effects and dependent types . . . . . . 133--144
Ohad Kammar and
Sam Lindley and
Nicolas Oury Handlers in action . . . . . . . . . . . 145--158
Simon Peyton Jones Computer science as a school subject . . 159--160
Manfred Schmidt-Schauß and
David Sabel Correctness of an STM Haskell
implementation . . . . . . . . . . . . . 161--172
François Pottier and
Jonathan Protzenko Programming with permissions in Mezzo 173--184
Andreas M. Abel and
Brigitte Pientka Wellfounded recursion with copatterns: a
unified approach to termination and
productivity . . . . . . . . . . . . . . 185--196
Robert Atkey and
Conor McBride Productive coprogramming with guarded
recursion . . . . . . . . . . . . . . . 197--208
Ralf Hinze and
Nicolas Wu and
Jeremy Gibbons Unifying structured recursion schemes 209--220
Neelakantan R. Krishnaswami Higher-order functional reactive
programming without spacetime leaks . . 221--232
Alan Jeffrey Functional reactive programming with
liveness guarantees . . . . . . . . . . 233--244
Akimasa Morihata A short cut to parallelization theorems 245--256
Emil Axelsson and
Koen Claessen Using circular programs for higher-order
syntax: functional pearl . . . . . . . . 257--262
Thibaut Balabonski Weak optimality, and the meaning of
sharing . . . . . . . . . . . . . . . . 263--274
Stephanie Weirich and
Justin Hsu and
Richard A. Eisenberg System FC with explicit kind equality 275--286
Neil Sculthorpe and
Jan Bracker and
George Giorgidze and
Andy Gill The constrained-monad problem . . . . . 287--298
Josef David Svenningsson and
Bo Joel Svensson Simple and compositional reification of
monadic embedded languages . . . . . . . 299--304
Soichiro Hidaka and
Kazuyuki Asada and
Zhenjiang Hu and
Hiroyuki Kato and
Keisuke Nakano Structural recursion for querying
ordered graphs . . . . . . . . . . . . . 305--318
Benjamin Delaware and
Steven Keuchel and
Tom Schrijvers and
Bruno C.d.S. Oliveira Modular monadic meta-theory . . . . . . 319--330
Florian Lorenzen and
Sebastian Erdweg Modular and automated type-soundness
verification for language extensions . . 331--342
Andrew W. Keep and
R. Kent Dybvig A nanopass framework for commercial
compiler development . . . . . . . . . . 343--350
Vincent St-Amour and
Neil Toronto Experience report: applying random
testing to a base type environment . . . 351--356
Christian L. Petersen and
Matthias Gorges and
Dustin Dunsmuir and
Mark Ansermino and
Guy A. Dumont Experience report: functional
programming of mHealth applications . . 357--362
Germán Andrés Delbianco and
Aleksandar Nanevski Hoare-style reasoning with (algebraic)
continuations . . . . . . . . . . . . . 363--376
Aaron Turon and
Derek Dreyer and
Lars Birkedal Unifying refinement and Hoare-style
reasoning in a logic for higher-order
concurrency . . . . . . . . . . . . . . 377--390
Adam Chlipala The bedrock structured programming
system: combining generative
metaprogramming and Hoare logic in an
extensible program verifier . . . . . . 391--402
James Cheney and
Sam Lindley and
Philip Wadler A practical theory of
language-integrated query . . . . . . . 403--416
Ronald Garcia Calculating threesomes, with blame . . . 417--428
Joshua Dunfield and
Neelakantan R. Krishnaswami Complete and easy bidirectional
typechecking for higher-rank
polymorphism . . . . . . . . . . . . . . 429--442
J. Ian Johnson and
Nicholas Labich and
Matthew Might and
David Van Horn Optimizing abstract abstract machines 443--454
Catalin Hritcu and
John Hughes and
Benjamin C. Pierce and
Antal Spector-Zabusky and
Dimitrios Vytiniotis and
Arthur Azevedo de Amorim and
Leonidas Lampropoulos Testing noninterference, quickly . . . . 455--468
Cristina V. Lopes Empirical analysis of programming
language adoption . . . . . . . . . . . 1--18
You Li and
Zhendong Su and
Linzhang Wang and
Xuandong Li Steering symbolic execution to less
traveled paths . . . . . . . . . . . . . 19--32
Michael Carbin and
Sasa Misailovic and
Martin C. Rinard Verifying quantitative reliability for
programs that execute on unreliable
hardware . . . . . . . . . . . . . . . . 33--52
Jipeng Huang and
Michael D. Bond Efficient context sensitivity for
dynamic analyses via calling context
uptrees and customized memory management 53--72
Vlad Ureche and
Cristian Talau and
Martin Odersky Miniboxing: improving the speed to code
size tradeoff in parametric polymorphism
translations . . . . . . . . . . . . . . 73--92
Rifat Shahriyar and
Stephen Michael Blackburn and
Xi Yang and
Kathryn S. McKinley Taking off the gloves with reference
counting Immix . . . . . . . . . . . . . 93--110
Guoqing Xu Resurrector: a tunable object lifetime
profiling technique for optimizing
real-world programs . . . . . . . . . . 111--130
Brian Norris and
Brian Demsky CDSChecker: checking concurrent data
structures written with C/C++ atomics 131--150
Veselin Raychev and
Martin Vechev and
Manu Sridharan Effective race detection for
event-driven programs . . . . . . . . . 151--166
Carl Friedrich Bolz and
Lukas Diekmann and
Laurence Tratt Storage strategies for collections in
dynamically typed languages . . . . . . 167--182
Heather Miller and
Philipp Haller and
Eugene Burmako and
Martin Odersky Instant pickles: generating
object-oriented pickler combinators for
fast and extensible serialization . . . 183--202
Robin Salkeld and
Gregor Kiczales Interacting with dead objects . . . . . 203--216
Joe Gibbs Politz and
Alejandro Martinez and
Matthew Milano and
Sumner Warren and
Daniel Patterson and
Junsong Li and
Anand Chitipothu and
Shriram Krishnamurthi Python: the full monty . . . . . . . . . 217--232
Prodromos Gerakios and
Aggelos Biboudis and
Yannis Smaragdakis Forsaking inheritance: supercharged
delegation in DelphJ . . . . . . . . . . 233--252
Yannis Smaragdakis and
George Balatsouras and
George Kastrinis Set-based pre-processing for points-to
analysis . . . . . . . . . . . . . . . . 253--270
Sai Deep Tetali and
Mohsen Lesani and
Rupak Majumdar and
Todd Millstein MrCrypt: static analysis for secure
cloud computations . . . . . . . . . . . 271--286
Christian DeLozier and
Richard Eisenberg and
Santosh Nagarakatte and
Peter-Michael Osera and
Milo M. K. Martin and
Steve Zdancewic Ironclad C++: a library-augmented
type-safe subset of C++ . . . . . . . . 287--304
Gregor Richards and
Christian Hammer and
Francesco Zappa Nardelli and
Suresh Jagannathan and
Jan Vitek Flexible access control for JavaScript 305--322
Asger Feldthaus and
Anders Mòller Semi-automatic rename refactoring for
JavaScript . . . . . . . . . . . . . . . 323--338
Veselin Raychev and
Max Schäfer and
Manu Sridharan and
Martin Vechev Refactoring with synthesis . . . . . . . 339--354
Kristof Du Bois and
Jennifer B. Sartor and
Stijn Eyerman and
Lieven Eeckhout Bottle graphs: visualizing scalability
bottlenecks in multi-threaded
applications . . . . . . . . . . . . . . 355--372
Daniele Cono D'Elia and
Camil Demetrescu Ball--Larus path profiling across
multiple loop iterations . . . . . . . . 373--390
Rahul Sharma and
Eric Schkufza and
Berkeley Churchill and
Alex Aiken Data-driven equivalence checking . . . . 391--406
Etienne Kneuss and
Ivan Kuraj and
Viktor Kuncak and
Philippe Suter Synthesis modulo recursive functions . . 407--426
Yao Shi and
Bernard Blackham and
Gernot Heiser Code optimizations using formally
verified properties . . . . . . . . . . 427--442
Isil Dillig and
Thomas Dillig and
Boyang Li and
Ken McMillan Inductive invariant generation via
abductive inference . . . . . . . . . . 443--456
Michael Hoppe and
Stefan Hanenberg Do developers benefit from generic
types?: an empirical comparison of
generic and raw types in Java . . . . . 457--474
Christos Dimoulas and
Robert Bruce Findler and
Matthias Felleisen Option contracts . . . . . . . . . . . . 475--494
Sean Treichler and
Michael Bauer and
Alex Aiken Language support for dynamic,
hierarchical data partitioning . . . . . 495--514
George Balatsouras and
Yannis Smaragdakis Class hierarchy complementation: soundly
completing a partial type graph . . . . 515--532
Kaushik Ravichandran and
Santosh Pande Multiverse: efficiently supporting
distributed high-level speculation . . . 533--552
Sylvan Clebsch and
Sophia Drossopoulou Fully concurrent garbage collection of
actors on many-core machines . . . . . . 553--570
Jisheng Zhao and
Roberto Lublinerman and
Zoran Budimli\'c and
Swarat Chaudhuri and
Vivek Sarkar Isolation for nested task parallelism 571--588
Omer Tripp and
Eric Koskinen and
Mooly Sagiv Turning nondeterminism into parallelism 589--604
Nathan Chong and
Alastair F. Donaldson and
Paul H. J. Kelly and
Jeroen Ketema and
Shaz Qadeer Barrier invariants: a shared state
abstraction for the analysis of
data-dependent GPU kernels . . . . . . . 605--622
Wontae Choi and
George Necula and
Koushik Sen Guided GUI testing of Android apps with
minimal restart and approximate learning 623--640
Tanzirul Azim and
Iulian Neamtiu Targeted and depth-first exploration for
systematic testing of Android apps . . . 641--660
Aman Kansal and
Scott Saponas and
A. J. Bernheim Brush and
Kathryn S. McKinley and
Todd Mytkowicz and
Ryder Ziola The latency, accuracy, and battery (LAB)
abstraction: programmer productivity and
energy efficiency for continuous mobile
context sensing . . . . . . . . . . . . 661--676
Tom Bergan and
Luis Ceze and
Dan Grossman Input-covering schedules for
multithreaded programs . . . . . . . . . 677--692
Michael D. Bond and
Milind Kulkarni and
Man Cao and
Minjia Zhang and
Meisam Fathi Salmi and
Swarnendu Biswas and
Aritra Sengupta and
Jipeng Huang OCTET: capturing and controlling
cross-thread dependences efficiently . . 693--712
Albert Noll and
Thomas Gross Online feedback-directed optimizations
for parallel Java code . . . . . . . . . 713--728
Stephan Herhut and
Richard L. Hudson and
Tatiana Shpeisman and
Jaswanth Sreeram River Trail: a path to parallelism in
JavaScript . . . . . . . . . . . . . . . 729--744
Suparna Bhattacharya and
Kanchi Gopinath and
Mangala Gowri Nanda Combining concern input with program
analysis for bloat detection . . . . . . 745--764
Lingming Zhang and
Lu Zhang and
Sarfraz Khurshid Injecting mechanical faults to localize
developer faults for evolving software 765--784
Dongdong Deng and
Wei Zhang and
Shan Lu Efficient concurrency-bug detection
across inputs . . . . . . . . . . . . . 785--802
Hao Zhong and
Zhendong Su Detecting API documentation errors . . . 803--816
Tao Bao and
Xiangyu Zhang On-the-fly detection of instability
problems in floating-point program
execution . . . . . . . . . . . . . . . 817--832
Katherine E. Coons and
Madan Musuvathi and
Kathryn S. McKinley Bounded partial-order reduction . . . . 833--848
Nick Mitchell and
Peter F. Sweeney On-the-fly capacity planning . . . . . . 849--866
Viktor Vafeiadis and
Chinmay Narayan Relaxed separation logic: a program
logic for C11 concurrency . . . . . . . 867--884
Erez Petrank Safety-first approach to memory
consistency models . . . . . . . . . . . 1--2
Philip Reames and
George Necula Towards hinted collection: annotations
for decreasing garbage collector pause
times . . . . . . . . . . . . . . . . . 3--14
Kazuya Morikawa and
Tomoharu Ugawa and
Hideya Iwasaki Adaptive scanning reduces sweep time for
the Lisp2 mark-compact garbage collector 15--26
David R. White and
Jeremy Singer and
Jonathan M. Aitken and
Richard E. Jones Control theory for principled heap
sizing . . . . . . . . . . . . . . . . . 27--38
Jacob Brock and
Xiaoming Gu and
Bin Bao and
Chen Ding Pacman: program-assisted cache
management . . . . . . . . . . . . . . . 39--50
Yan Wang and
Iulian Neamtiu and
Rajiv Gupta Generating sound and effective memory
debuggers . . . . . . . . . . . . . . . 51--62
Tomas Kalibera and
Richard Jones Rigorous benchmarking in reasonable time 63--74
Martin Aigner and
Christoph M. Kirsch ACDC: towards a universal mutator for
benchmarking heap management systems . . 75--84
Lian Li and
Cristina Cifuentes and
Nathan Keynes Precise and scalable context-sensitive
pointer analysis via value flow graph 85--96
Tristan Ravitch and
Ben Liblit Analyzing memory ownership patterns in C
libraries . . . . . . . . . . . . . . . 97--108
Nathan P. Ricci and
Samuel Z. Guyer and
J. Eliot B. Moss Elephant Tracks: portable production of
complete and precise GC traces . . . . . 109--118
Yingyi Bu and
Vinayak Borkar and
Guoqing Xu and
Michael J. Carey A bloat-aware design for big data
applications . . . . . . . . . . . . . . 119--130
Johan Ankner and
Josef David Svenningsson An EDSL approach to high performance
Haskell programming . . . . . . . . . . 1--12
Jean-Philippe Bernardy and
Nicolas Pouillard Names for free: polymorphic views of
names and binders . . . . . . . . . . . 13--24
Richard Bird and
Jeremy Gibbons and
Stefan Mehner and
Janis Voigtländer and
Tom Schrijvers Understanding idiomatic traversals
backwards and forwards . . . . . . . . . 25--36
Mario Bla\vzevi\'c Adding structure to monoids: thus
hopefully ending Haskell's string type
confusion . . . . . . . . . . . . . . . 37--46
Koen Claessen and
Michal H. Palka Splittable pseudorandom number
generators using cryptographic hashing 47--58
Oleg Kiselyov and
Amr Sabry and
Cameron Swords Extensible effects: an alternative to
monad transformers . . . . . . . . . . . 59--70
Joe Leslie-Hurd Maintaining verified software . . . . . 71--80
Sam Lindley and
Conor McBride Hasochism: the pleasure and pain of
dependently typed Haskell programming 81--92
Ben Lippmeier and
Manuel M. T. Chakravarty and
Gabriele Keller and
Amos Robinson Data flow fusion with series expressions
in Haskell . . . . . . . . . . . . . . . 93--104
Hai Liu and
Neal Glew and
Leaf Petersen and
Todd A. Anderson The Intel labs Haskell research compiler 105--116
Atze van der Ploeg Monadic functional reactive programming 117--128
Andreas Richard Voellmy and
Junchang Wang and
Paul Hudak and
Kazuhiko Yamamoto Mio: a high-performance multicore IO
manager for GHC . . . . . . . . . . . . 129--140
Peter M. Wortmann and
David Duke Causality of optimized Haskell: what is
burning our cycles? . . . . . . . . . . 141--152
Lars Birkedal Modular reasoning about concurrent
higher-order imperative programs . . . . 1--1
Patrick` Cousot and
Radhia Cousot A Galois connection calculus for
abstract interpretation . . . . . . . . 3--4
Giuseppe Castagna and
Kim Nguyen and
Zhiwu Xu and
Hyeonseung Im and
Sergue\"\i Lenglet and
Luca Padovani Polymorphic functions with set-theoretic
types: part 1: syntax, semantics, and
evaluation . . . . . . . . . . . . . . . 5--17
Scott Kilpatrick and
Derek Dreyer and
Simon Peyton Jones and
Simon Marlow Backpack: retrofitting Haskell with
interfaces . . . . . . . . . . . . . . . 19--31
Chris Casinghino and
Vilhelm Sjöberg and
Stephanie Weirich Combining proofs and programs in a
dependently typed language . . . . . . . 33--45
Stefano Dissegna and
Francesco Logozzo and
Francesco Ranzato Tracing compilation by abstract
interpretation . . . . . . . . . . . . . 47--59
Steven J. Ramsay and
Robin P. Neatherway and
C.-H. Luke Ong A type-directed abstraction refinement
approach to higher-order model checking 61--72
Devin Coughlin and
Bor-Yuh Evan Chang Fissile type analysis: modular checking
of almost everywhere invariants . . . . 73--85
Martin Bodin and
Arthur Chargueraud and
Daniele Filaretti and
Philippa Gardner and
Sergio Maffeis and
Daiva Naudziuniene and
Alan Schmitt and
Gareth Smith A trusted mechanised JavaScript
specification . . . . . . . . . . . . . 87--100
Robbert Krebbers An operational and axiomatic semantics
for non-determinism and sequence points
in C . . . . . . . . . . . . . . . . . . 101--112
Carolyn Jane Anderson and
Nate Foster and
Arjun Guha and
Jean-Baptiste Jeannin and
Dexter Kozen and
Cole Schlesinger and
David Walker NetKAT: semantic foundations for
networks . . . . . . . . . . . . . . . . 113--126
Rahul Sharma and
Aditya V. Nori and
Alex Aiken Bias-variance tradeoffs in program
analysis . . . . . . . . . . . . . . . . 127--137
Vijay D'Silva and
Leopold Haller and
Daniel Kroening Abstract satisfaction . . . . . . . . . 139--150
Azadeh Farzan and
Zachary Kincaid and
Andreas Podelski Proofs that count . . . . . . . . . . . 151--164
Arthur Azevedo de Amorim and
Nathan Collins and
André DeHon and
Delphine Demange and
Catalin Hritcu and
David Pichardie and
Benjamin C. Pierce and
Randy Pollack and
Andrew Tolmach A verified information-flow architecture 165--178
Ramana Kumar and
Magnus O. Myreen and
Michael Norrish and
Scott Owens CakeML: a verified implementation of ML 179--191
Gilles Barthe and
Cédric Fournet and
Benjamin Grégoire and
Pierre-Yves Strub and
Nikhil Swamy and
Santiago Zanella-Béguelin Probabilistic relational verification
for cryptographic implementations . . . 193--205
Swarat Chaudhuri and
Martin Clochard and
Armando Solar-Lezama Bridging boolean and quantitative
synthesis using smoothed proof search 207--220
Tewodros Beyene and
Swarat Chaudhuri and
Corneliu Popeea and
Andrey Rybalchenko A constraint-based approach to solving
games on infinite graphs . . . . . . . . 221--233
Eva Darulova and
Viktor Kuncak Sound compilation of reals . . . . . . . 235--248
Gérard Huet and
Hugo Herbelin 30 years of research and development
around Coq . . . . . . . . . . . . . . . 249--249
Stephen Brookes and
Peter W. O'Hearn and
Uday Reddy The essence of Reynolds . . . . . . . . 251--255
Lindsey Kuper and
Aaron Turon and
Neelakantan R. Krishnaswami and
Ryan R. Newton Freeze after writing:
quasi-deterministic parallel programming
with LVars . . . . . . . . . . . . . . . 257--270
Sebastian Burckhardt and
Alexey Gotsman and
Hongseok Yang and
Marek Zawirski Replicated data types: specification,
verification, optimality . . . . . . . . 271--284
Ahmed Bouajjani and
Constantin Enea and
Jad Hamza Verifying eventual consistency of
optimistic replication systems . . . . . 285--296
Ugo Dal Lago and
Davide Sangiorgi and
Michele Alberti On coinductive equivalences for
higher-order probabilistic functional
programs . . . . . . . . . . . . . . . . 297--308
Thomas Ehrhard and
Christine Tasson and
Michele Pagani Probabilistic coherence spaces are fully
abstract for probabilistic PCF . . . . . 309--320
Andrew D. Gordon and
Thore Graepel and
Nicolas Rolland and
Claudio Russo and
Johannes Borgstrom and
John Guiver Tabular: a schema-driven probabilistic
programming language . . . . . . . . . . 321--334
Ilya Sergey and
Dimitrios Vytiniotis and
Simon Peyton Jones Modular, higher-order cardinality
analysis in theory and practice . . . . 335--347
Stephen Chang and
Matthias Felleisen Profiling for laziness . . . . . . . . . 349--360
Andrew Cave and
Francisco Ferreira and
Prakash Panangaden and
Brigitte Pientka Fair reactive programming . . . . . . . 361--372
Parosh Abdulla and
Stavros Aronis and
Bengt Jonsson and
Konstantinos Sagonas Optimal dynamic partial order reduction 373--384
Shachar Itzhaky and
Anindya Banerjee and
Neil Immerman and
Ori Lahav and
Aleksandar Nanevski and
Mooly Sagiv Modular reasoning about heap paths via
effectively propositional formulas . . . 385--396
Nathan Chong and
Alastair F. Donaldson and
Jeroen Ketema A sound and complete abstraction for
reasoning about parallel prefix sums . . 397--409
Andrew Miller and
Michael Hicks and
Jonathan Katz and
Elaine Shi Authenticated data structures,
generically . . . . . . . . . . . . . . 411--423
Nikhil Swamy and
Cedric Fournet and
Aseem Rastogi and
Karthikeyan Bhargavan and
Juan Chen and
Pierre-Yves Strub and
Gavin Bierman Gradual typing embedded securely in
JavaScript . . . . . . . . . . . . . . . 425--437
Fan Long and
Stelios Sidiroglou-Douskos and
Deokhwan Kim and
Martin Rinard Sound input filter generation for
integer overflow errors . . . . . . . . 439--452
James Brotherston and
Jules Villard Parametric completeness for separation
theories . . . . . . . . . . . . . . . . 453--464
Zhé Hóu and
Ranald Clouston and
Rajeev Goré and
Alwen Tiu Proof search for propositional abstract
separation logics via labelled sequents 465--476
Wonyeol Lee and
Sungwoo Park A proof system for separation logic with
magic wand . . . . . . . . . . . . . . . 477--490
Robert Atkey From parametricity to conservation laws,
via Noether's theorem . . . . . . . . . 491--502
Robert Atkey and
Neil Ghani and
Patricia Johann A relationally parametric model of
dependent type theory . . . . . . . . . 503--515
Andrzej S. Murawski and
Nikos Tzevelekos Game semantics for interface
middleweight Java . . . . . . . . . . . 517--528
Bertrand Jeannet and
Peter Schrammel and
Sriram Sankaranarayanan Abstract acceleration of general linear
loops . . . . . . . . . . . . . . . . . 529--540
Loris D'Antoni and
Margus Veanes Minimization of symbolic automata . . . 541--553
Swarat Chaudhuri and
Azadeh Farzan and
Zachary Kincaid Consistency analysis of decision-making
programs . . . . . . . . . . . . . . . . 555--567
Danfeng Zhang and
Andrew C. Myers Toward general diagnosis of static
errors . . . . . . . . . . . . . . . . . 569--581
Sheng Chen and
Martin Erwig Counter-factual typing for debugging
type errors . . . . . . . . . . . . . . 583--594
Udi Boker and
Thomas A. Henzinger and
Arjun Radhakrishna Battery transition systems . . . . . . . 595--606
Yi Li and
Aws Albarghouthi and
Zachary Kincaid and
Arie Gurfinkel and
Marsha Chechik Symbolic optimization with SMT solvers 607--618
Nick Benton and
Martin Hofmann and
Vivek Nigam Abstract effects and proof-relevant
logical relations . . . . . . . . . . . 619--631
Shin-ya Katsumata Parametric effect monads and semantics
of effect systems . . . . . . . . . . . 633--645
Michele Pagani and
Peter Selinger and
Beno\^\it Valiron Applying quantitative semantics to
higher-order quantum computing . . . . . 647--658
Beniamino Accattoli and
Eduardo Bonelli and
Delia Kesner and
Carlos Lombardi A nonstandard standardization theorem 659--670
Richard A. Eisenberg and
Dimitrios Vytiniotis and
Simon Peyton Jones and
Stephanie Weirich Closed type families with overlapping
equations . . . . . . . . . . . . . . . 671--683
Benjamin S. Lerner and
Joe Gibbs Politz and
Arjun Guha and
Shriram Krishnamurthi TeJaS: retrofitting type systems for
JavaScript . . . . . . . . . . . . . . . 1--16
Vineeth Kashyap and
John Sarracino and
John Wagner and
Ben Wiedermann and
Ben Hardekopf Type refinement for static analysis of
JavaScript . . . . . . . . . . . . . . . 17--26
Esteban Allende and
Johan Fabry and
Éric Tanter Cast insertion strategies for
gradually-typed objects . . . . . . . . 27--36
Madhukar N. Kedlaya and
Jared Roesch and
Behnam Robatmili and
Mehrdad Reshadi and
Ben Hardekopf Improved type specialization for dynamic
scripting languages . . . . . . . . . . 37--48
Matthias Keil and
Peter Thiemann Efficient dynamic access analysis using
JavaScript proxies . . . . . . . . . . . 49--60
Marcel Weiher and
Robert Hirschfeld Polymorphic identifiers: uniform
resource access in Objective-Smalltalk 61--72
Changhee Park and
Hongki Lee and
Sukyoung Ryu All about the with statement in
JavaScript: removing with statements in
JavaScript applications . . . . . . . . 73--84
Nurudeen A. Lameed and
Laurie J. Hendren Optimizing MATLAB \tt feval with dynamic
techniques . . . . . . . . . . . . . . . 85--96
Danny Yoo and
Shriram Krishnamurthi Whalesong: running Racket in the browser 97--108
Rastislav Bodik Modeling biology with solver-aided
programming languages . . . . . . . . . 1--2
Sebastian Erdweg and
Felix Rieger A framework for extensible languages . . 3--12
Matthew Flatt Submodules in Racket: you want it when,
again? . . . . . . . . . . . . . . . . . 13--22
Robert Dyer and
Hridesh Rajan and
Tien N. Nguyen Declarative visitors to ease
fine-grained source code mining with
full history on billions of AST nodes 23--32
Yuriy Solodkyy and
Gabriel Dos Reis and
Bjarne Stroustrup Open pattern matching for C++ . . . . . 33--42
Marko Martin and
Mira Mezini and
Sebastian Erdweg Template constructors for reusable
object initialization . . . . . . . . . 43--52
Julien Richard-Foy and
Olivier Barais and
Jean-Marc Jézéquel Efficient high-level abstractions for
Web programming . . . . . . . . . . . . 53--60
Prodromos Gerakios and
Aggelos Biboudis and
Yannis Smaragdakis Reified type parameters using Java
annotations . . . . . . . . . . . . . . 61--64
Sandro Schulze and
Jörg Liebig and
Janet Siegmund and
Sven Apel Does the discipline of preprocessor
annotations matter?: a controlled
experiment . . . . . . . . . . . . . . . 65--74
Flávio Medeiros and
Márcio Ribeiro and
Rohit Gheyi Investigating preprocessor-based syntax
errors . . . . . . . . . . . . . . . . . 75--84
Dean Kramer and
Samia Oussena and
Peter Komisarczuk and
Tony Clark Using document-oriented GUIs in dynamic
software product lines . . . . . . . . . 85--94
Norbert Siegmund and
Alexander von Rhein and
Sven Apel Family-based performance measurement . . 95--104
Lukás Marek and
Stephen Kell and
Yudi Zheng and
Lubomír Bulej and
Walter Binder and
Petr Tuma and
Danilo Ansaloni and
Aibek Sarimbekov and
Andreas Sewe ShadowVM: robust and comprehensive
dynamic program analysis for the Java
platform . . . . . . . . . . . . . . . . 105--114
Sergiy Kolesnikov and
Alexander von Rhein and
Claus Hunsen and
Sven Apel A comparison of product-based,
feature-based, and family-based type
checking . . . . . . . . . . . . . . . . 115--124
Georg Ofenbeck and
Tiark Rompf and
Alen Stojanov and
Martin Odersky and
Markus Püschel Spiral in Scala: towards the systematic
construction of generators for
performance libraries . . . . . . . . . 125--134
Peter Chapin and
Christian Skalka and
Scott Smith and
Michael Watson Scalaness/nesT: type specialized staged
programming for sensor networks . . . . 135--144
Arvind K. Sujeeth and
Austin Gibbons and
Kevin J. Brown and
HyoukJoong Lee and
Tiark Rompf and
Martin Odersky and
Kunle Olukotun Forge: generating a high performance DSL
implementation from a declarative
specification . . . . . . . . . . . . . 145--154
Darya Kurilova and
Derek Rayside On the simplicity of synthesizing linked
data structure operations . . . . . . . 155--158
Deepak Dhungana and
Andreas Falkner and
Alois Haselböck Generation of conjoint domain models for
system-of-systems . . . . . . . . . . . 159--168
Fábio Paulo Basso and
Raquel Mainardi Pillat and
Toacy Cavalcante Oliveira and
Leandro Buss Becker Supporting large scale model
transformation reuse . . . . . . . . . . 169--178
Kyoungho An and
Takayuki Kuroda and
Aniroddha Gokhale and
Sumant Tambe and
Andrea Sorbini Model-driven generative framework for
automated OMG DDS performance testing in
the cloud . . . . . . . . . . . . . . . 179--182
Jan Vitek SIGPLAN Chair's report . . . . . . . . . 1--1
Jeremy Gibbons SIGPLAN Vice-Chair's report . . . . . . 2--2
Andrew Black SIGPLAN Secretary's report . . . . . . . 3--3
Cristina V. Lopes SIGPLAN Treasurer's report . . . . . . . 4--4
Derek Dreyer SIGPLAN awards . . . . . . . . . . . . . 5--7
Julia Lawall and
Cristina V. Lopes SIGPLAN Professional Activities
Committee Report . . . . . . . . . . . . 8--8
Michael Hind SIGPLAN Research Highlights Annual
Report . . . . . . . . . . . . . . . . . 9--9
Peter Sewell POPL 2014 Program Chair's report . . . . 10--26
Cristina V. Lopes The OOPSLA two-phase review process . . 27--32
Hans Boehm and
Jack Davidson and
Kathleen Fisher and
Cormac Flanagan and
Jeremy Gibbons and
Mary Hall and
Graham Hutton and
David Padua and
Frank Tip and
Jan Vitek and
Philip Wadler Practices of PLDI . . . . . . . . . . . 33--38
Manuel Fähndrich and
Francesco Logozzo SAS2013 artifact submission experience
report . . . . . . . . . . . . . . . . . 39--40
David Gay and
Philip Levis and
Robert von Behren and
Matt Welsh and
Eric Brewer and
David Culler The nesC language: a holistic approach
to networked embedded systems . . . . . 41--51
Didier Le Botlan and
Didier Rémy MLF: raising ML to the power of System F 52--63
Tim Harris and
Keir Fraser Language support for lightweight
transactions . . . . . . . . . . . . . . 64--78
Thomas A. Henzinger and
Ranjit Jhala and
Rupak Majumdar and
Kenneth L. McMillan Abstractions from proofs . . . . . . . . 79--91
Prasad A. Kulkarni Energy efficient data access techniques 1--1
Tom Spink and
Harry Wagstaff and
Björn Franke and
Nigel Topham Efficient code generation in a
region-based dynamic binary translator 3--12
Roland Lezuo and
Philipp Paulweber and
Andreas Krall CASM: optimized compilation of abstract
state machines . . . . . . . . . . . . . 13--22
Roberto Castañeda Lozano and
Mats Carlsson and
Gabriel Hjort Blindell and
Christian Schulte Combinatorial spill code optimization
and ultimate coalescing . . . . . . . . 23--32
Clément Ballabriga and
Lee Kee Chong and
Abhik Roychoudhury Cache-related preemption delay analysis
for FIFO caches . . . . . . . . . . . . 33--42
Julien Henry and
Mihail Asavoae and
David Monniaux and
Claire Ma\"\iza How to compute worst-case execution time
by optimization modulo theory and a
clever encoding of program semantics . . 43--52
Wenguang Zheng and
Hui Wu WCET: aware dynamic instruction cache
locking . . . . . . . . . . . . . . . . 53--62
Luiz G. A. Martins and
Ricardo Nobre and
Alexandre C. B. Delbem and
Eduardo Marques and
João M. P. Cardoso Exploration of compiler optimization
sequences using clustering-based
selection . . . . . . . . . . . . . . . 63--72
Kiran Chandramohan and
Michael F. P. O'Boyle Partitioning data-parallel programs for
heterogeneous MPSoCs: time and energy
design space exploration . . . . . . . . 73--82
Minyi Guo Energy efficient data access and storage
through HW/SW co-design . . . . . . . . 83--83
Tobias J. K. Edler von Koch and
Björn Franke and
Pranav Bhandarkar and
Anshuman Dasgupta Exploiting function similarity for code
size reduction . . . . . . . . . . . . . 85--94
Pooja Roy and
Rajarshi Ray and
Chundong Wang and
Weng Fai Wong ASAC: automatic sensitivity analysis for
approximate computing . . . . . . . . . 95--104
Sandeep Chaudhary and
Sebastian Fischmeister and
Lin Tan em-SPADE: a compiler extension for
checking rules extracted from processor
specifications . . . . . . . . . . . . . 105--114
Ulysse Beaugnon and
Alexey Kravets and
Sven van Haastregt and
Riyadh Baghdadi and
David Tweed and
Javed Absar and
Anton Lokhmotov VOBLA: a vehicle for optimized basic
linear algebra . . . . . . . . . . . . . 115--124
Vagelis Bebelis and
Pascal Fradet and
Alain Girault A framework to schedule parametric
dataflow applications on many-core
platforms . . . . . . . . . . . . . . . 125--134
Jinyong Lee and
Jongwon Lee and
Jongeun Lee and
Yunheung Paek Improving performance of loops on
DIAM-based VLIW architectures . . . . . 135--144
Joseph G. Wingbermuehle and
Ron K. Cytron and
Roger D. Chamberlain Superoptimization of memory subsystems 145--154
Hongjune Kim and
Seonmyeong Bak and
Jaejin Lee Lightweight and block-level concurrent
sweeping for JavaScript garbage
collection . . . . . . . . . . . . . . . 155--164
David Padua What exactly is inexact computation good
for? . . . . . . . . . . . . . . . . . . 1--1
Lindsey Kuper and
Aaron Todd and
Sam Tobin-Hochstadt and
Ryan R. Newton Taming the parallel effect zoo:
extensible deterministic parallelism
with LVish . . . . . . . . . . . . . . . 2--14
Rishi Surendran and
Raghavan Raman and
Swarat Chaudhuri and
John Mellor-Crummey and
Vivek Sarkar Test-driven repair of data races in
structured parallel programs . . . . . . 15--25
Sven Stork and
Karl Naden and
Joshua Sunshine and
Manual Mohr and
Alcides Fonseca and
Paulo Marques and
Jonathan Aldrich Æminium: a permission based
concurrent-by-default programming
language approach . . . . . . . . . . . 26--26
Suresh Jagannathan and
Vincent Laporte and
Gustavo Petri and
David Pichardie and
Jan Vitek Atomicity refinement for verified
compilation . . . . . . . . . . . . . . 27--27
Swarnendu Biswas and
Jipeng Huang and
Aritra Sengupta and
Michael D. Bond DoubleChecker: efficient sound and
precise atomicity checking . . . . . . . 28--39
Jade Alglave and
Luc Maranget and
Michael Tautschnig Herding cats: modelling, simulation,
testing, and data-mining for weak memory 40--40
Tiark Rompf and
Arvind K. Sujeeth and
Kevin J. Brown and
HyoukJoong Lee and
Hassan Chafi and
Kunle Olukotun Surgical precision JIT compilers . . . . 41--52
Eric Schkufza and
Rahul Sharma and
Alex Aiken Stochastic optimization of
floating-point programs with tunable
precision . . . . . . . . . . . . . . . 53--64
Kevin Stock and
Martin Kong and
Tobias Grosser and
Louis-Noël Pouchet and
Fabrice Rastello and
J. Ramanujam and
P. Sadayappan A framework for enhancing data reuse via
associative reordering . . . . . . . . . 65--76
Zachary DeVito and
Daniel Ritchie and
Matt Fisher and
Alex Aiken and
Pat Hanrahan First-class runtime generation of
high-performance types using exotypes 77--88
Ben Greenman and
Fabian Muehlboeck and
Ross Tate Getting F-bounded polymorphism into
shape . . . . . . . . . . . . . . . . . 89--99
Axel Simon Optimal inference of fields in
row-polymorphic records . . . . . . . . 100--111
Adrian Sampson and
Pavel Panchekha and
Todd Mytkowicz and
Kathryn S. McKinley and
Dan Grossman and
Luis Ceze Expressing and verifying probabilistic
assertions . . . . . . . . . . . . . . . 112--122
Mateus Borges and
Antonio Filieri and
Marcelo d'Amorim and
Corina S. Pasareanu and
Willem Visser Compositional solution space
quantification for probabilistic
software analysis . . . . . . . . . . . 123--132
Chung-Kil Hur and
Aditya V. Nori and
Sriram K. Rajamani and
Selva Samuel Slicing probabilistic programs . . . . . 133--144
Yufei Cai and
Paolo G. Giarrusso and
Tillmann Rendel and
Klaus Ostermann A theory of changes for higher-order
languages: incrementalizing $ \lambda
$-calculi by static differentiation . . 145--155
Matthew A. Hammer and
Khoo Yit Phang and
Michael Hicks and
Jeffrey S. Foster Adapton: composable, demand-driven
incremental computation . . . . . . . . 156--166
Min Aung and
Susan Horwitz and
Rich Joiner and
Thomas Reps Specialization slicing . . . . . . . . . 167--167
Tony Hoare Laws of concurrent programming . . . . . 168--168
Srinath Sridharan and
Gagan Gupta and
Gurindar S. Sohi Adaptive, efficient, parallel execution
of parallel programs . . . . . . . . . . 169--180
Gagan Gupta and
Srinath Sridharan and
Gurindar S. Sohi Globally precise-restartable execution
of parallel programs . . . . . . . . . . 181--192
Subrata Mitra and
Ignacio Laguna and
Dong H. Ahn and
Saurabh Bagchi and
Martin Schulz and
Todd Gamblin Accurate application progress analysis
for large-scale parallel debugging . . . 193--203
Sanket Tavarageri and
Sriram Krishnamoorthy and
P. Sadayappan Compiler-assisted detection of transient
memory errors . . . . . . . . . . . . . 204--215
Vu Le and
Mehrdad Afshari and
Zhendong Su Compiler validation via equivalence
modulo inputs . . . . . . . . . . . . . 216--226
Fan Long and
Stelios Sidiroglou-Douskos and
Martin Rinard Automatic runtime error repair and
containment via recovery shepherding . . 227--238
Xin Zhang and
Ravi Mangal and
Radu Grigore and
Mayur Naik and
Hongseok Yang On abstraction refinement for program
analyses in Datalog . . . . . . . . . . 239--248
Xin Zhang and
Ravi Mangal and
Mayur Naik and
Hongseok Yang Hybrid top-down and bottom-up
interprocedural analysis . . . . . . . . 249--258
Steven Arzt and
Siegfried Rasthofer and
Christian Fritz and
Eric Bodden and
Alexandre Bartel and
Jacques Klein and
Yves Le Traon and
Damien Octeau and
Patrick McDaniel FlowDroid: precise context, flow, field,
object-sensitive and lifecycle-aware
taint analysis for Android apps . . . . 259--269
Quentin Carbonneaux and
Jan Hoffmann and
Tahina Ramananandro and
Zhong Shao End-to-end verification of stack-space
bounds for C programs . . . . . . . . . 270--281
Thomas Ball and
Nikolaj Bjòrner and
Aaron Gember and
Shachar Itzhaky and
Aleksandr Karbyshev and
Mooly Sagiv and
Michael Schapira and
Asaf Valadarsky VeriCon: towards verifying controller
programs in software-defined networks 282--293
Francesco Logozzo and
Shuvendu K. Lahiri and
Manuel Fähndrich and
Sam Blackshear Verification modulo versions: towards
usable verification . . . . . . . . . . 294--304
Dimitar Dimitrov and
Veselin Raychev and
Martin Vechev and
Eric Koskinen Commutativity race detection . . . . . . 305--315
Pallavi Maiya and
Aditya Kanade and
Rupak Majumdar Race detection for Android applications 316--325
Chun-Hung Hsiao and
Jie Yu and
Satish Narayanasamy and
Ziyun Kong and
Cristiano L. Pereira and
Gilles A. Pokam and
Peter M. Chen and
Jason Flinn Race detection for event-driven mobile
applications . . . . . . . . . . . . . . 326--336
Jeff Huang and
Patrick O'Neil Meredith and
Grigore Rosu Maximal sound predictive race detection
with control flow abstraction . . . . . 337--348
Yaniv David and
Eran Yahav Tracelet-based code search in
executables . . . . . . . . . . . . . . 349--360
Justin Pombrio and
Shriram Krishnamurthi Resugaring: lifting evaluation sequences
through syntactic sugar . . . . . . . . 361--371
Reinhard von Hanxleden and
Björn Duderstadt and
Christian Motika and
Steven Smyth and
Michael Mendler and
Joaquín Aguado and
Stephen Mercer and
Owen O'Brien SCCharts: sequentially constructive
statecharts for safety-critical
applications: HW/SW-synthesis for a
conservative extension of synchronous
statecharts . . . . . . . . . . . . . . 372--383
Loris D'Antoni and
Margus Veanes and
Benjamin Livshits and
David Molnar Fast: a transducer-based language for
tree manipulation . . . . . . . . . . . 384--394
Jayadev Misra A personal perspective on concurrency 395--395
Phitchaya Mangpo Phothilimthana and
Tikhon Jelvis and
Rohin Shah and
Nishant Totla and
Sarah Chasins and
Rastislav Bodik Chlorophyll: synthesis-aided compiler
for low-power spatial architectures . . 396--407
Daniel Perelman and
Sumit Gulwani and
Dan Grossman and
Peter Provost Test-driven synthesis . . . . . . . . . 408--418
Veselin Raychev and
Martin Vechev and
Eran Yahav Code completion with statistical
language models . . . . . . . . . . . . 419--428
David Greenaway and
Japheth Lim and
June Andronick and
Gerwin Klein Don't sweat the small stuff: formal
verification of C code without the pain 429--439
Edgar Pek and
Xiaokang Qiu and
P. Madhusudan Natural proofs for data structure
manipulation in C using separation logic 440--451
Daniel Ricketts and
Valentin Robert and
Dongseok Jang and
Zachary Tatlock and
Sorin Lerner Automating formal proofs for reactive
systems . . . . . . . . . . . . . . . . 452--462
Xiao Xiao and
Qirun Zhang and
Jinguo Zhou and
Charles Zhang Persistent pointer information . . . . . 463--474
Hakjoo Oh and
Wonchan Lee and
Kihong Heo and
Hongseok Yang and
Kwangkeun Yi Selective context-sensitivity guided by
impact pre-analysis . . . . . . . . . . 475--484
Yannis Smaragdakis and
George Kastrinis and
George Balatsouras Introspective analysis:
context-sensitivity, across the board 485--495
Wonsun Ahn and
Jiho Choi and
Thomas Shull and
María J. Garzarán and
Josep Torrellas Improving JavaScript performance by
deconstructing the type system . . . . . 496--507
John Vilk and
Emery D. Berger Doppio: breaking the browser language
barrier . . . . . . . . . . . . . . . . 508--518
Li Lu and
Weixing Ji and
Michael L. Scott Dynamic enforcement of determinism in a
parallel scripting language . . . . . . 519--529
Emina Torlak and
Rastislav Bodik A lightweight symbolic virtual machine
for solver-aided host languages . . . . 530--541
Vu Le and
Sumit Gulwani FlashExtract: a framework for data
extraction by examples . . . . . . . . . 542--553
Marcelo Sousa and
Isil Dillig and
Dimitrios Vytiniotis and
Thomas Dillig and
Christos Gkantsidis Consolidation of queries with
user-defined functions . . . . . . . . . 554--564
Loi Luu and
Shweta Shinde and
Prateek Saxena and
Brian Demsky A model counter for constraints over
unbounded strings . . . . . . . . . . . 565--576
Ben Niu and
Gang Tan Modular control-flow integrity . . . . . 577--587
Edward Z. Yang and
David Mazi\`eres Dynamic space limits for Haskell . . . . 588--598
Dan Tsafrir Experiences in the land of virtual
abstractions . . . . . . . . . . . . . . 1--2
Jennia Hizver and
Tzi-cker Chiueh Real-time deep virtual machine
introspection and its applications . . . 3--14
Kapil Arya and
Yury Baskakov and
Alex Garthwaite Tesseract: reconciling guest I/O and
hypervisor swapping in a VM . . . . . . 15--28
Hwanju Kim and
Sangwook Kim and
Jinkyu Jeong and
Joonwon Lee Virtual asymmetric multiprocessor for
interactive performance of consolidated
desktops . . . . . . . . . . . . . . . . 29--40
Orna Agmon Ben-Yehuda and
Eyal Posener and
Muli Ben-Yehuda and
Assaf Schuster and
Ahuva Mu'alem Ginseng: market-driven memory allocation 41--52
Jinho Hwang and
Ahsen Uppal and
Timothy Wood and
Howie Huang Mortar: filling the gaps in data center
memory . . . . . . . . . . . . . . . . . 53--64
Licheng Chen and
Zhipeng Wei and
Zehan Cui and
Mingyu Chen and
Haiyang Pan and
Yungang Bao CMD: classification-based memory
deduplication through page access
characteristics . . . . . . . . . . . . 65--76
Behnam Robatmili and
Calin Cascaval and
Mehrdad Reshadi and
Madhukar N. Kedlaya and
Seth Fowler and
Vrajesh Bhavsar and
Michael Weber and
Ben Hardekopf MuscalietJS: rethinking layered dynamic
web runtimes . . . . . . . . . . . . . . 77--88
Tomas Kalibera and
Petr Maj and
Floreal Morandat and
Jan Vitek A fast abstract syntax tree interpreter
for R . . . . . . . . . . . . . . . . . 89--102
Madhukar N. Kedlaya and
Behnam Robatmili and
Cglin Cascaval and
Ben Hardekopf Deoptimization for dynamic language JITs
on typed, stack-based virtual machines 103--114
Jan Vitek The case for the three R's of systems
research: repeatability, reproducibility
and rigor . . . . . . . . . . . . . . . 115--116
Chao-Jui Chang and
Jan-Jan Wu and
Wei-Chung Hsu and
Pangfeng Liu and
Pen-Chung Yew Efficient memory virtualization for
Cross-ISA system mode emulation . . . . 117--128
Mingwei Zhang and
Rui Qiao and
Niranjan Hasabnis and
R. Sekar A platform for secure static binary
instrumentation . . . . . . . . . . . . 129--140
Yi-Hong Lyu and
Ding-Yong Hong and
Tai-Yi Wu and
Jan-Jan Wu and
Wei-Chung Hsu and
Pangfeng Liu and
Pen-Chung Yew DBILL: an efficient and retargetable
dynamic binary instrumentation framework
using LLVM backend . . . . . . . . . . . 141--152
Jie Zheng and
Tze Sing Eugene Ng and
Kunwadee Sripanidkulchai and
Zhaolei Liu COMMA: coordinating the migration of
multi-tier applications . . . . . . . . 153--164
Vivek Kumar and
Stephen M. Blackburn and
David Grove Friendly barriers: efficient
work-stealing with return barriers . . . 165--176
Michihiro Horie and
Kazunori Ogata and
Kiyokuni Kawachiya and
Tamiya Onodera String deduplication for Java-based
middleware in virtualized environments 177--188
Julian Stecklina Shrinking the hypervisor one subsystem
at a time: a userspace packet switch for
virtual machines . . . . . . . . . . . . 189--200
Ye Li and
Richard West and
Eric Missimer A virtualized separation kernel for
mixed criticality systems . . . . . . . 201--212
David Johnson and
Mike Hibler and
Eric Eric Composable multi-level debugging with
Stackdb . . . . . . . . . . . . . . . . 213--226
Mark D. Hill 21st century computer architecture . . . 1--2
Tongping Liu and
Chen Tian and
Ziang Hu and
Emery D. Berger PREDATOR: predictive false sharing
detection . . . . . . . . . . . . . . . 3--14
Paul Thomson and
Alastair F. Donaldson and
Adam Betts Concurrency testing using schedule
bounding: an empirical study . . . . . . 15--28
Malavika Samak and
Murali Krishna Ramanathan Trace driven dynamic deadlock detection
and reproduction . . . . . . . . . . . . 29--42
Wei-Fan Chiang and
Ganesh Gopalakrishnan and
Zvonimir Rakamaric and
Alexey Solovyev Efficient search for inputs causing high
floating-point errors . . . . . . . . . 43--52
Olivier Tardieu and
Benjamin Herta and
David Cunningham and
David Grove and
Prabhanjan Kambadur and
Vijay Saraswat and
Avraham Shinnar and
Mikio Takeuchi and
Mandana Vaziri X10 and APGAS at Petascale . . . . . . . 53--66
David Cunningham and
David Grove and
Benjamin Herta and
Arun Iyengar and
Kiyokuni Kawachiya and
Hiroki Murata and
Vijay Saraswat and
Mikio Takeuchi and
Olivier Tardieu Resilient X10: efficient failure-aware
programming . . . . . . . . . . . . . . 67--80
Chaoran Yang and
Wesley Bland and
John Mellor-Crummey and
Pavan Balaji Portable, MPI-interoperable Coarray
Fortran . . . . . . . . . . . . . . . . 81--92
Yi Yang and
Huiyang Zhou CUDA-NP: realizing nested thread-level
parallelism in GPGPU applications . . . 93--106
Shengen Yan and
Chao Li and
Yunquan Zhang and
Huiyang Zhou yaSpMV: yet another SpMV framework on
GPUs . . . . . . . . . . . . . . . . . . 107--118
Michael Bauer and
Sean Treichler and
Alex Aiken Singe: leveraging warp specialization
for high performance on GPUs . . . . . . 119--130
Rei Odaira and
Jose G. Castanos and
Hisanobu Tomari Eliminating global interpreter locks in
Ruby through hardware transactional
memory . . . . . . . . . . . . . . . . . 131--142
Darko Petrovi\'c and
Thomas Ropars and
André Schiper Leveraging hardware message passing for
efficient thread synchronization . . . . 143--154
Maurice Herlihy and
Zhiyu Liu Well-structured futures and cache
locality . . . . . . . . . . . . . . . . 155--166
Nuno Diegues and
Paolo Romano Time-Warp: lightweight abort
minimization in transactional memory . . 167--178
Kunle Olukotun Beyond parallel programming with domain
specific languages . . . . . . . . . . . 179--180
Sukhyun Song and
Jeffrey K. Hollingsworth Designing and auto-tuning parallel $3$-D
FFT for computation-communication
overlap . . . . . . . . . . . . . . . . 181--192
Bryan Catanzaro and
Alexander Keller and
Michael Garland A decomposition for in-place matrix
transposition . . . . . . . . . . . . . 193--206
I-Jui Sung and
Juan Gómez-Luna and
José María González-Linares and
Nicolás Guil and
Wen-Mei W. Hwu In-place transposition of rectangular
matrices on accelerators . . . . . . . . 207--218
Saeed Maleki and
Madanlal Musuvathi and
Todd Mytkowicz Parallelizing dynamic programming
through rank convergence . . . . . . . . 219--232
Sanyam Mehta and
Pei-Hung Lin and
Pen-Chung Yew Revisiting loop fusion in the polyhedral
framework . . . . . . . . . . . . . . . 233--246
Christopher Rodrigues and
Thomas Jablin and
Abdul Dakkak and
Wen-Mei Hwu Triolet: a programming system that
unifies algorithmic skeleton interfaces
for high-performance cluster computing 247--258
Xu Liu and
John Mellor-Crummey A tool to analyze the performance of
multithreaded programs on NUMA
architectures . . . . . . . . . . . . . 259--272
Jia Rao and
Xiaobo Zhou Towards fair and efficient SMP virtual
machine scheduling . . . . . . . . . . . 273--286
Kai Lu and
Xu Zhou and
Tom Bergan and
Xiaoping Wang Efficient deterministic multithreading
without global barriers . . . . . . . . 287--300
Mahdi Eslamimehr and
Jens Palsberg Race directed scheduling of concurrent
programs . . . . . . . . . . . . . . . . 301--314
Norm Rubin Heterogeneous computing: what does it
mean for compiler research? . . . . . . 315--316
Aravind Natarajan and
Neeraj Mittal Fast concurrent lock-free binary search
trees . . . . . . . . . . . . . . . . . 317--328
Trevor Brown and
Faith Ellen and
Eric Ruppert A general technique for non-blocking
trees . . . . . . . . . . . . . . . . . 329--342
Dana Drachsler and
Martin Vechev and
Eran Yahav Practical concurrent binary search trees
via logical ordering . . . . . . . . . . 343--356
Shahar Timnat and
Erez Petrank A practical wait-free simulation for
lock-free data structures . . . . . . . 357--368
Kishore Kumar Pusukuri and
Rajiv Gupta and
Laxmi Narayan Bhuyan Lock contention aware thread migrations 369--370
Kyu Hyung Lee and
Dohyeong Kim and
Xiangyu Zhang Infrastructure-free logging and replay
of concurrent execution on multiple
cores . . . . . . . . . . . . . . . . . 371--372
Cfir Aguston and
Yosi Ben Asher and
Gadi Haber Parallelization hints via code
skeletonization . . . . . . . . . . . . 373--374
Wenwen Wang and
Chenggang Wu and
Pen-Chung Yew and
Xiang Yuan and
Zhenjiang Wang and
Jianjun Li and
Xiaobing Feng Concurrency bug localization using
shared memory access pairs . . . . . . . 375--376
Vitus J. Leung and
David P. Bunde and
Jonathan Ebbers and
Stefan P. Feer and
Nickolas W. Price and
Zachary D. Rhodes and
Matthew Swank Task mapping stencil computations for
non-contiguous allocations . . . . . . . 377--378
Martin Wimmer and
Francesco Versaci and
Jesper Larsson Träff and
Daniel Cederman and
Philippas Tsigas Data structures for task-based priority
scheduling . . . . . . . . . . . . . . . 379--380
Leonardo Bautista Gomez and
Franck Cappello Detecting silent data corruption through
data dynamic monitoring for scientific
applications . . . . . . . . . . . . . . 381--382
Edans F. de O. Sandes and
Guillermo Miranda and
Alba C. M. A. Melo and
Xavier Martorell and
Eduard Ayguade Fine-grain parallel megabase sequence
comparison with multiple heterogeneous
GPUs . . . . . . . . . . . . . . . . . . 383--384
Guy Golan-Gueta and
G. Ramalingam and
Mooly Sagiv and
Eran Yahav Automatic semantic locking . . . . . . . 385--386
Ahmed Hassan and
Roberto Palmieri and
Binoy Ravindran Optimistic transactional boosting . . . 387--388
Kunal Agrawal and
Jeremy T. Fineman and
Brendan Sheridan and
Jim Sukha and
Robert Utterback Provably good scheduling for parallel
programs that use data structures
through implicit batching . . . . . . . 389--390
Lin Ma and
Kunal Agrawal and
Roger D. Chamberlain Theoretical analysis of classic
algorithms on highly-threaded many-core
GPUs . . . . . . . . . . . . . . . . . . 391--392
Daniel Tomkins and
Timmie Smith and
Nancy M. Amato and
Lawrence Rauchwerger SCCMulti: an improved parallel strongly
connected components algorithm . . . . . 393--394
Miao Luo and
Xiaoyi Lu and
Khaled Hamidouche and
Krishna Kandalla and
Dhabaleswar K. Panda Initial study of multi-endpoint runtime
for MPI + OpenMP hybrid programming
model on multi-core systems . . . . . . 395--396
Katherine E. Isaacs and
Todd Gamblin and
Abhinav Bhatele and
Peer-Timo Bremer and
Martin Schulz and
Bernd Hamann Extracting logical structure and
identifying stragglers in parallel
execution traces . . . . . . . . . . . . 397--398
Kathleen Fisher Using formal methods to enable more
secure vehicles: DARPA's HACMS program 1--1
Patrick C. Hickey and
Lee Pike and
Trevor Elliott and
James Bielman and
John Launchbury Building embedded systems with embedded
DSLs . . . . . . . . . . . . . . . . . . 3--9
Cole Schlesinger and
Michael Greenberg and
David Walker Concurrent NetCore: from policies to
pipelines . . . . . . . . . . . . . . . 11--24
Daniel Schoepe and
Daniel Hedin and
Andrei Sabelfeld SeLINQ: tracking information across
application-database boundaries . . . . 25--38
Sheng Chen and
Martin Erwig Type-based parametric analysis of
program families . . . . . . . . . . . . 39--51
Paul Stansifer and
Mitchell Wand Romeo: a system for more flexible
binding-safe programming . . . . . . . . 53--65
Clemens Grabmayer and
Jan Rochel Maximal sharing in the Lambda calculus
with letrec . . . . . . . . . . . . . . 67--80
Lars Bergstrom and
Matthew Fluet and
Matthew Le and
John Reppy and
Nora Sandler Practical and effective higher-order
optimizations . . . . . . . . . . . . . 81--93
Jennifer Hackett and
Graham Hutton Worker/wrapper/makes it/faster . . . . . 95--107
Paul Downen and
Zena M. Ariola Compositional semantics for composable
continuations: from abortive to
delimited control . . . . . . . . . . . 109--122
Tomas Petricek and
Dominic Orchard and
Alan Mycroft Coeffects: a calculus of
context-dependent computation . . . . . 123--135
Robert Bruce Findler Behavioral software contracts . . . . . 137--138
Phúc C. Nguyen and
Sam Tobin-Hochstadt and
David Van Horn Soft contract verification . . . . . . . 139--152
Norman Ramsey On teaching *how to design programs*:
observations from a newcomer . . . . . . 153--166
Atsushi Ohori and
Katsuhiro Ueno and
Kazunori Hoshi and
Shinji Nozaki and
Takashi Sato and
Tasuku Makabe and
Yuki Ito SML# in industry: a practical ERP system
development . . . . . . . . . . . . . . 167--173
Dominic P. Mulligan and
Scott Owens and
Kathryn E. Gray and
Tom Ridge and
Peter Sewell Lem: reusable engineering of real-world
semantics . . . . . . . . . . . . . . . 175--188
Joachim Breitner and
Richard A. Eisenberg and
Simon Peyton Jones and
Stephanie Weirich Safe zero-cost coercions for Haskell . . 189--202
François Pottier Hindley--Milner elaboration in
applicative style: functional pearl . . 203--212
Daniel Winograd-Cort and
Paul Hudak Settable and non-interfering signal
functions for FRP: how a first-order
switch is more than enough . . . . . . . 213--225
Yan Chen and
Umut A. Acar and
Kanat Tangwongsan Functional programming for dynamic and
large data with self-adjusting
computation . . . . . . . . . . . . . . 227--240
Stephanie Weirich Depending on types . . . . . . . . . . . 241--241
Carlo Angiuli and
Edward Morehouse and
Daniel R. Licata and
Robert Harper Homotopical patch theory . . . . . . . . 243--256
Jesper Cockx and
Dominique Devriese and
Frank Piessens Pattern matching without K . . . . . . . 257--268
Niki Vazou and
Eric L. Seidel and
Ranjit Jhala and
Dimitrios Vytiniotis and
Simon Peyton-Jones Refinement types for Haskell . . . . . . 269--282
Felipe Bañados Schwerter and
Ronald Garcia and
Éric Tanter A theory of gradual effect systems . . . 283--295
Conor Thomas McBride How to keep your neighbours in order . . 297--309
Gowtham Kaki and
Suresh Jagannathan A relational framework for higher-order
shape analysis . . . . . . . . . . . . . 311--324
Simon Marlow and
Louis Brandy and
Jonathan Coens and
Jon Purdy There is no fork: an abstraction for
efficient, concurrent, and concise data
access . . . . . . . . . . . . . . . . . 325--337
Jeremy Gibbons and
Nicolas Wu Folding domain-specific languages: deep
and shallow embeddings (functional
Pearl) . . . . . . . . . . . . . . . . . 339--347
Olle Fredriksson and
Dan R. Ghica Krivine nets: a semantic foundation for
distributed execution . . . . . . . . . 349--361
Beniamino Accattoli and
Pablo Barenbaum and
Damiano Mazza Distilling abstract machines . . . . . . 363--376
Stephen Chong Checking correctness of TypeScript
interfaces for JavaScript libraries . . 1--16
Esben Andreasen and
Anders Mòller Determinacy in static analysis for
jQuery . . . . . . . . . . . . . . . . . 17--31
Michael Pradel and
Parker Schuh and
George Necula and
Koushik Sen EventBreak: analyzing the responsiveness
of user interfaces through
performance-guided test generation . . . 33--47
Chun-Hung Hsiao and
Michael Cafarella and
Satish Narayanasamy Using web corpus statistics for program
analysis . . . . . . . . . . . . . . . . 49--65
Earl T. Barr and
Mark Marron Tardis: affordable time-travel debugging
in managed runtimes . . . . . . . . . . 67--82
Jonathan Bell and
Gail Kaiser Phosphor: illuminating dynamic data flow
in commodity JVMs . . . . . . . . . . . 83--101
Luís Pina and
Luís Veiga and
Michael Hicks Rubah: DSU for Java on a stock JVM . . . 103--119
Rifat Shahriyar and
Stephen M. Blackburn and
Kathryn S. McKinley Fast conservative garbage collection . . 121--139
Eric Holk and
Ryan Newton and
Jeremy Siek and
Andrew Lumsdaine Region-based memory management for GPU
programming languages: enabling rich
data structures on a spartan host . . . 141--155
Richard Uhler and
Nirav Dave Smten with satisfiability-based search 157--176
Jeffrey Bosboom and
Sumanaruban Rajadurai and
Weng-Fai Wong and
Saman Amarasinghe StreamJIT: a commensal compiler for
high-performance stream programming . . 177--195
Emma Tosch and
Emery D. Berger SurveyMan: programming and automatically
debugging surveys . . . . . . . . . . . 197--211
Thomas W. Bartenstein and
Yu David Liu Rate types for stream programs . . . . . 213--232
Nada Amin and
Tiark Rompf and
Martin Odersky Foundations of path-dependent types . . 233--249
Esteban Allende and
Johan Fabry and
Ronald Garcia and
Éric Tanter Confined gradual typing . . . . . . . . 251--270
John Altidor and
Yannis Smaragdakis Refactoring Java generics by inferring
wildcards, in practice . . . . . . . . . 271--290
Florian David and
Gael Thomas and
Julia Lawall and
Gilles Muller Continuously measuring critical section
pressure with the free-lunch profiler 291--307
Sasa Misailovic and
Michael Carbin and
Sara Achour and
Zichao Qi and
Martin C. Rinard Chisel: reliability- and accuracy-aware
optimization of approximate
computational kernels . . . . . . . . . 309--328
Melanie Kambadur and
Martha A. Kim An experimental survey of energy
management across the stack . . . . . . 329--344
Gustavo Pinto and
Fernando Castor and
Yu David Liu Understanding energy behaviors of thread
management constructs . . . . . . . . . 345--360
Joscha Drechsler and
Guido Salvaneschi and
Ragnar Mogk and
Mira Mezini Distributed REScala: an update algorithm
for distributed reactive programming . . 361--376
Tillmann Rendel and
Jonathan Immanuel Brachthäuser and
Klaus Ostermann From object algebras to attribute
grammars . . . . . . . . . . . . . . . . 377--395
Vlad Ureche and
Eugene Burmako and
Martin Odersky Late data layout: unifying data
representation transformations . . . . . 397--416
Ralf Mitschke and
Sebastian Erdweg and
Mirko Köhler and
Mira Mezini and
Guido Salvaneschi i3QL: language-integrated live data
views . . . . . . . . . . . . . . . . . 417--432
Dhruva R. Chakrabarti and
Hans-J. Boehm and
Kumud Bhandari Atlas: leveraging locks for non-volatile
memory consistency . . . . . . . . . . . 433--452
Guy L. Steele, Jr. and
Doug Lea and
Christine H. Flood Fast splittable pseudorandom number
generators . . . . . . . . . . . . . . . 453--472
Malavika Samak and
Murali Krishna Ramanathan Multithreaded test synthesis for
deadlock detection . . . . . . . . . . . 473--489
Tom Bergan and
Dan Grossman and
Luis Ceze Symbolic execution of multithreaded
programs from arbitrary program contexts 491--506
Daniel W. Barowy and
Dimitar Gochev and
Emery D. Berger CheckCell: data debugging for
spreadsheets . . . . . . . . . . . . . . 507--523
Zvonimir Pavlinovic and
Tim King and
Thomas Wies Finding minimum type error sources . . . 525--542
Peng Liu and
Omer Tripp and
Xiangyu Zhang Flint: fixing linearizability violations 543--560
Linhai Song and
Shan Lu Statistical debugging for real-world
performance problems . . . . . . . . . . 561--578
Terence Parr and
Sam Harwell and
Kathleen Fisher Adaptive LL(*) parsing: the power of
dynamic analysis . . . . . . . . . . . . 579--598
Milos Gligoric and
Wolfram Schulte and
Chandra Prasad and
Danny van Velzen and
Iman Narasamdya and
Benjamin Livshits Automated migration of build scripts
using dynamic analysis and search-based
refactoring . . . . . . . . . . . . . . 599--616
Vineet Kumar and
Laurie Hendren MIX10: compiling MATLAB to X10 for high
performance . . . . . . . . . . . . . . 617--636
Manohar Jonnalagedda and
Thierry Coppey and
Sandro Stucki and
Tiark Rompf and
Martin Odersky Staged parser combinators for efficient
data processing . . . . . . . . . . . . 637--653
Nicolás Rosner and
Valeria Bengolea and
Pablo Ponzio and
Shadi Abdul Khalek and
Nazareno Aguirre and
Marcelo F. Frias and
Sarfraz Khurshid Bounded exhaustive test input generation
from hybrid invariants . . . . . . . . . 655--674
Peng Wang and
Santiago Cuellar and
Adam Chlipala Compiler verification meets
cross-language linking via data
abstraction . . . . . . . . . . . . . . 675--690
Aaron Turon and
Viktor Vafeiadis and
Derek Dreyer GPS: navigating weak memory with ghosts,
protocols, and separation . . . . . . . 691--707
Ankush Desai and
Pranav Garg and
P. Madhusudan Natural proofs for asynchronous programs
using almost-synchronous reductions . . 709--725
Wei Zhang and
Per Larsen and
Stefan Brunthaler and
Michael Franz Accelerating iterators in optimizing AST
interpreters . . . . . . . . . . . . . . 727--743
Zhijia Zhao and
Bo Wu and
Mingzhou Zhou and
Yufei Ding and
Jianhua Sun and
Xipeng Shen and
Youfeng Wu Call sequence prediction through
probabilistic calling automata . . . . . 745--762
Mingzhou Zhou and
Xipeng Shen and
Yaoqing Gao and
Graham Yiu Space-efficient multi-versioning for
input-adaptive feedback-driven program
optimizations . . . . . . . . . . . . . 763--776
Keith Adams and
Jason Evans and
Bertrand Maher and
Guilherme Ottoni and
Andrew Paroski and
Brett Simmers and
Edwin Smith and
Owen Yamauchi The HipHop Virtual Machine . . . . . . . 777--790
Henrique Nazaré and
Izabela Maffra and
Willer Santos and
Leonardo Barbosa and
Laure Gonnord and
Fernando Magno Quintão Pereira Validation of memory accesses through
symbolic analyses . . . . . . . . . . . 791--809
Nimrod Partush and
Eran Yahav Abstract semantic differencing via
speculative correlation . . . . . . . . 811--828
Qirun Zhang and
Xiao Xiao and
Charles Zhang and
Hao Yuan and
Zhendong Su Efficient subcubic alias analysis for C 829--845
Lucas Brutschy and
Pietro Ferrara and
Peter Müller Static analysis for independent app
developers . . . . . . . . . . . . . . . 847--860
Keval Vora and
Sai Charan Koduru and
Rajiv Gupta ASPIRE: exploiting asynchronous
parallelism in iterative algorithms
using a relaxed consistency based DSM 861--878
Brandon Holt and
Preston Briggs and
Luis Ceze and
Mark Oskin Alembic: automatic locality extraction
via migration . . . . . . . . . . . . . 879--894
Tian Xiao and
Zhenyu Guo and
Hucheng Zhou and
Jiaxing Zhang and
Xu Zhao and
Chencheng Ye and
Xi Wang and
Wei Lin and
Wenguang Chen and
Lidong Zhou Cybertron: pushing the limit on I/O
reduction in data-parallel programs . . 895--908
Cosmin Radoi and
Stephen J. Fink and
Rodric Rabbah and
Manu Sridharan Translating imperative code to MapReduce 909--927
Samuel Z. Guyer Use of the JVM at Twitter: a bird's eye
view . . . . . . . . . . . . . . . . . . 1--1
David Terei and
Alex Aiken and
Jan Vitek $ M^3 $: high-performance memory
management from off-the-shelf components 3--13
Daniel Clifford and
Hannes Payer and
Michael Starzinger and
Ben L. Titzer Allocation folding based on dominance 15--24
Bollu Ratnakar and
Rupesh Nasre Push-pull constraint graph for efficient
points-to analysis . . . . . . . . . . . 25--33
Pramod G. Joisha Sticky tries: fast insertions, fast
lookups, no deletions for large key
universes . . . . . . . . . . . . . . . 35--46
Steven R. Brandt and
Hari Krishnan and
Gokarna Sharma and
Costas Busch Concurrent, parallel garbage collection
in linear time . . . . . . . . . . . . . 47--58
Tomoharu Ugawa and
Richard E. Jones and
Carl G. Ritson Reference object processing in
on-the-fly garbage collection . . . . . 59--69
Pengcheng Li and
Chen Ding and
Hao Luo Modeling heap data growth using average
liveness . . . . . . . . . . . . . . . . 71--82
Foivos S. Zakkak and
Polyvios Pratikakis JDMM: a Java memory model for
non-cache-coherent memory architectures 83--92
Ian J. Egielski and
Jesse Huang and
Eddy Z. Zhang Massive atomics for massive parallelism
on GPUs . . . . . . . . . . . . . . . . 93--103
Carl G. Ritson and
Tomoharu Ugawa and
Richard E. Jones Exploring garbage collection with
Haswell hardware transactional memory 105--115
David F. Bacon and
Perry Cheng and
Sunil Shukla Parallel real-time garbage collection of
multiple heaps in reconfigurable
hardware . . . . . . . . . . . . . . . . 117--127
Nicolas Wu and
Tom Schrijvers and
Ralf Hinze Effect handlers in scope . . . . . . . . 1--12
Dominic Orchard and
Tomas Petricek Embedding effect systems in Haskell . . 13--24
Jasmin Christian Blanchette and
Lars Hupel and
Tobias Nipkow and
Lars Noschinski and
Dmitriy Traytel Experience report: the next 1100 Haskell
programmers . . . . . . . . . . . . . . 25--30
Takayuki Muranushi and
Richard A. Eisenberg Experience report: type-checking
polymorphic units for astrophysics
research in Haskell . . . . . . . . . . 31--38
Niki Vazou and
Eric L. Seidel and
Ranjit Jhala LiquidHaskell: experience with
refinement types in the real world . . . 39--51
Lee Pike SmartCheck: automatic and efficient
counterexample reduction and
generalization . . . . . . . . . . . . . 53--64
Patrick Maier and
Robert Stewart and
Phil Trinder The HdpH DSLs for scalable reliable
computation . . . . . . . . . . . . . . 65--76
Kiwamu Okabe and
Takayuki Muranushi Systems demonstration: writing NetBSD
sound drivers in Haskell . . . . . . . . 77--78
Anton Ekblad and
Koen Claessen A seamless, client-centric programming
model for type safe web applications . . 79--89
Amit A. Levy and
David Terei and
Deian Stefan and
David Maziéres Demo proposal: making web applications
--- XSafe . . . . . . . . . . . . . . . 91--91
Deian Stefan and
Amit Levy and
Alejandro Russo and
David Maziéres Building secure systems with LIO (demo) 93--94
Richard A. Eisenberg and
Jan Stolarek Promoting functions to type families in
Haskell . . . . . . . . . . . . . . . . 95--106
J. Garrett Morris A simple semantics for Haskell
overloading . . . . . . . . . . . . . . 107--118
Manuel M. T. Chakravarty Foreign inline code: systems
demonstration . . . . . . . . . . . . . 119--120
Michael D. Adams and
Ömer S. Agacan Indentation-sensitive parsing for Parsec 121--132
Atze van der Ploeg and
Oleg Kiselyov Reflection without remorse: revealing a
hidden sequence to speed up monadic
reflection . . . . . . . . . . . . . . . 133--144
Sriram Rajamani Automating Repetitive Tasks for the
Masses . . . . . . . . . . . . . . . . . 1--2
Paul-André Melli\`es and
Noam Zeilberger Functors are Type Refinement Systems . . 3--16
Neelakantan R. Krishnaswami and
Pierre Pradic and
Nick Benton Integrating Linear and Dependent Types 17--30
Kristina Sojakova Higher Inductive Types as
Homotopy-Initial Algebras . . . . . . . 31--42
Minh Ngo and
Fabio Massacci and
Dimiter Milushev and
Frank Piessens Runtime Enforcement of Security Policies
on Black Box Reactive Programs . . . . . 43--54
Gilles Barthe and
Marco Gaboardi and
Emilio Jesús Gallego Arias and
Justin Hsu and
Aaron Roth and
Pierre-Yves Strub Higher-Order Approximate Relational
Refinement Types for Mechanism Design
and Differential Privacy . . . . . . . . 55--68
Hamid Ebadi and
David Sands and
Gerardo Schneider Differential Privacy: Now it's Getting
Personal . . . . . . . . . . . . . . . . 69--81
Hao Tang and
Xiaoyin Wang and
Lingming Zhang and
Bing Xie and
Lu Zhang and
Hong Mei Summary-Based Context-Sensitive
Data-Dependence Analysis in Presence of
Callbacks . . . . . . . . . . . . . . . 83--95
Krishnendu Chatterjee and
Rasmus Ibsen-Jensen and
Andreas Pavlogiannis and
Prateesh Goyal Faster Algorithms for Algebraic Path
Properties in Recursive State Machines
with Constant Treewidth . . . . . . . . 97--109
Veselin Raychev and
Martin Vechev and
Andreas Krause Predicting Program Properties from ``Big
Code'' . . . . . . . . . . . . . . . . . 111--124
Rajeev Alur and
Loris D'Antoni and
Mukund Raghothaman DReX: a Declarative Language for
Efficiently Evaluating Regular String
Transformations . . . . . . . . . . . . 125--137
Margus Veanes and
Todd Mytkowicz and
David Molnar and
Benjamin Livshits Data-Parallel String-Manipulating
Programs . . . . . . . . . . . . . . . . 139--152
Adam Chlipala Ur/Web: a Simple Model for Programming
the Web . . . . . . . . . . . . . . . . 153--165
Aseem Rastogi and
Nikhil Swamy and
Cédric Fournet and
Gavin Bierman and
Panagiotis Vekris Safe & Efficient Gradual Typing for
TypeScript . . . . . . . . . . . . . . . 167--180
Michael Greenberg Space-Efficient Manifest Contracts . . . 181--194
Taro Sekiyama and
Yuki Nishida and
Atsushi Igarashi Manifest Contracts for Datatypes . . . . 195--207
Viktor Vafeiadis and
Thibaut Balabonski and
Soham Chakraborty and
Robin Morisset and
Francesco Zappa Nardelli Common Compiler Optimisations are
Invalid in the C11 Memory Model and what
we can do about it . . . . . . . . . . . 209--220
Julien Lange and
Emilio Tuosto and
Nobuko Yoshida From Communicating Machines to Graphical
Choreographies . . . . . . . . . . . . . 221--232
Mike Dodds and
Andreas Haas and
Christoph M. Kirsch A Scalable, Correct Time-Stamped Stack 233--246
Jacques-Henri Jourdan and
Vincent Laporte and
Sandrine Blazy and
Xavier Leroy and
David Pichardie A Formally-Verified C Static Analyzer 247--259
Roberto Giacobazzi and
Francesco Logozzo and
Francesco Ranzato Analyzing Program Analyses . . . . . . . 261--273
Gordon Stewart and
Lennart Beringer and
Santiago Cuellar and
Andrew W. Appel Compositional CompCert . . . . . . . . . 275--287
Giuseppe Castagna and
Kim Nguyen and
Zhiwu Xu and
Pietro Abate Polymorphic Functions with Set-Theoretic
Types: Part 2: Local Type Inference and
Type Reconstruction . . . . . . . . . . 289--302
Ronald Garcia and
Matteo Cimini Principal Type Schemes for Gradual
Programs . . . . . . . . . . . . . . . . 303--315
Luísa Lourenço and
Luís Caires Dependent Information Flow Types . . . . 317--328
Mila Dalla Preda and
Roberto Giacobazzi and
Arun Lakhotia and
Isabella Mastroeni Abstract Symbolic Automata: Mixed
syntactic/semantic similarity analysis
of executables . . . . . . . . . . . . . 329--341
Nate Foster and
Dexter Kozen and
Matthew Milano and
Alexandra Silva and
Laure Thompson A Coalgebraic Decision Procedure for
NetKAT . . . . . . . . . . . . . . . . . 343--355
Damien Pous Symbolic Algorithms for Language
Equivalence and Kleene Algebra with
Tests . . . . . . . . . . . . . . . . . 357--368
Vilhelm Sjöberg and
Stephanie Weirich Programming up to Congruence . . . . . . 369--382
Kazunori Tobisawa A Meta Lambda Calculus with Cross-Level
Computation . . . . . . . . . . . . . . 383--393
Sam Staton Algebraic Effects, Linearity, and
Quantum Programming Languages . . . . . 395--406
Azadeh Farzan and
Zachary Kincaid and
Andreas Podelski Proof Spaces for Unbounded Parallelism 407--420
Davide Sangiorgi Equations, Contractions, and Unique
Solutions . . . . . . . . . . . . . . . 421--432
Ashutosh Gupta and
Thomas A. Henzinger and
Arjun Radhakrishna and
Roopsha Samanta and
Thorsten Tarrach Succinct Representation of Concurrent
Trace Sets . . . . . . . . . . . . . . . 433--444
Denis Bogdanas and
Grigore Rosu K-Java: a Complete Semantics of Java . . 445--456
Michael D. Adams Towards the Essence of Hygiene . . . . . 457--469
Matt Brown and
Jens Palsberg Self-Representation in Girard's System U 471--484
Peter Lee Coding by Everyone, Every Day . . . . . 485--485
Peter Buneman Databases and Programming: Two Subjects
Divided by a Common Language? . . . . . 487--487
Luis María Ferrer Fioriti and
Holger Hermanns Probabilistic Termination: Soundness,
Completeness, and Compositionality . . . 489--501
Fei He and
Xiaowei Gao and
Bow-Yaw Wang and
Lijun Zhang Leveraging Weighted Automata in
Compositional Reasoning about Concurrent
Probabilistic Systems . . . . . . . . . 503--514
Filippo Bonchi and
Pawel Sobocinski and
Fabio Zanasi Full Abstraction for Signal Flow Graphs 515--526
Ralf Hinze and
Nicolas Wu and
Jeremy Gibbons Conjugate Hylomorphisms --- Or: The
Mother of All Structured Recursion
Schemes . . . . . . . . . . . . . . . . 527--538
Krishnendu Chatterjee and
Andreas Pavlogiannis and
Yaron Velner Quantitative Interprocedural Analysis 539--551
Osbert Bastani and
Saswat Anand and
Alex Aiken Specification Inference Using
Context-Free Language Reachability . . . 553--566
Venmugil Elango and
Fabrice Rastello and
Louis-Noël Pouchet and
J. Ramanujam and
P. Sadayappan On Characterizing the Data Access
Complexity of Programs . . . . . . . . . 567--580
Pieter Agten and
Bart Jacobs and
Frank Piessens Sound Modular Verification of C Code
Executing in an Unverified Context . . . 581--594
Ronghui Gu and
Jérémie Koenig and
Tahina Ramananandro and
Zhong Shao and
Xiongnan (Newman) Wu and
Shu-Chun Weng and
Haozhong Zhang and
Yu Guo Deep Specifications and Certified
Abstraction Layers . . . . . . . . . . . 595--608
Adam Chlipala From Network Interface to Multithreaded
Web Applications: a Case Study in
Modular Program Verification . . . . . . 609--622
Karl Crary and
Michael J. Sullivan A Calculus for Relaxed Memory . . . . . 623--636
Ralf Jung and
David Swasey and
Filip Sieczkowski and
Kasper Svendsen and
Aaron Turon and
Lars Birkedal and
Derek Dreyer Iris: Monoids and Invariants as an
Orthogonal Basis for Concurrent
Reasoning . . . . . . . . . . . . . . . 637--650
Ahmed Bouajjani and
Michael Emmi and
Constantin Enea and
Jad Hamza Tractable Refinement Checking for
Concurrent Objects . . . . . . . . . . . 651--662
Oded Padon and
Neil Immerman and
Aleksandr Karbyshev and
Ori Lahav and
Mooly Sagiv and
Sharon Shoham Decentralizing SDN Policies . . . . . . 663--676
Robert A. Cochran and
Loris D'Antoni and
Benjamin Livshits and
David Molnar and
Margus Veanes Program Boosting: Program Synthesis via
Crowd-Sourcing . . . . . . . . . . . . . 677--688
Benjamin Delaware and
Clément Pit-Claudel and
Jason Gross and
Adam Chlipala Fiat: Deductive Synthesis of Abstract
Data Types in a Proof Assistant . . . . 689--700
Stefan Hanenberg Why do we know so little about
programming languages, and what would
have happened if we had known more? . . 1--1
Lourival Vieira Neto and
Roberto Ierusalimschy and
Ana Lúcia de Moura and
Marc Balmer Scriptable operating systems with Lua 2--10
James Ian Johnson and
David Van Horn Abstracting abstract control . . . . . . 11--22
T. Stephen Strickland and
Brianna M. Ren and
Jeffrey S. Foster Contracts for domain-specific languages
in Ruby . . . . . . . . . . . . . . . . 23--34
Tim Disney and
Nathan Faubion and
David Herman and
Cormac Flanagan Sweeten your JavaScript: hygienic macros
for ES5 . . . . . . . . . . . . . . . . 35--44
Michael M. Vitousek and
Andrew M. Kent and
Jeremy G. Siek and
Jim Baker Design and evaluation of gradual typing
for Python . . . . . . . . . . . . . . . 45--56
Bert Freudenberg and
Dan H. H. Ingalls and
Tim Felgentreff and
Tobias Pape and
Robert Hirschfeld SqueakJS: a modern and practical
smalltalk that runs in any browser . . . 57--66
Martin Aigner and
Thomas Hütter and
Christoph M. Kirsch and
Alexander Miller and
Hannes Payer and
Mario Preishuber ACDC-JS: explorative benchmarking of
JavaScript memory management . . . . . . 67--78
Helena Kotthaus and
Ingo Korb and
Michael Engel and
Peter Marwedel Dynamic page sharing optimization for
the R language . . . . . . . . . . . . . 79--90
Faiz Khan and
Vincent Foley-Bourgon and
Sujay Kathrotia and
Erick Lavoie and
Laurie Hendren Using JavaScript and WebCL for numerical
computations: a comparative study of
native and web technologies . . . . . . 91--102
Dustin Rhodes and
Tim Disney and
Cormac Flanagan Dynamic detection of object capability
violations through model checking . . . 103--112
Bastian Steinert and
Lauritz Thamsen and
Tim Felgentreff and
Robert Hirschfeld Object versioning to support recovery
needs: using proxies to preserve
previous development states in lively 113--124
Nicholas D. Matsakis and
David Herman and
Dmitry Lomov Typed objects in JavaScript . . . . . . 125--134
Oscar Callaú and
Romain Robbes and
Éric Tanter and
David Röthlisberger and
Alexandre Bergel On the use of type predicates in
object-oriented software: the case of
smalltalk . . . . . . . . . . . . . . . 135--146
Jaakko Järvi and
Gabriel Foust and
Magne Haveraaen Specializing planners for hierarchical
multi-way dataflow constraint systems 1--10
Michael J. Steindorfer and
Jurgen J. Vinju Code specialization for memory efficient
hash tries (short paper) . . . . . . . . 11--14
Somayeh Malakuti and
Mehmet Aksit Emergent gummy modules: modular
representation of emergent behavior . . 15--24
Maria Gouseti and
Chiel Peters and
Tijs van der Storm Extensible language implementation with
object algebras (short paper) . . . . . 25--28
Eric Walkingshaw and
Klaus Ostermann Projectional editing of variational
software . . . . . . . . . . . . . . . . 29--38
Andreas Ruprecht and
Bernhard Heinloth and
Daniel Lohmann Automatic feature selection in
large-scale system-software product
lines . . . . . . . . . . . . . . . . . 39--48
Lei Ma and
Cyrille Artho and
Cheng Zhang and
Hiroyuki Sato Efficient testing of software product
lines via centralization (short paper) 49--52
Karl Smeltzer and
Martin Erwig and
Ronald Metoyer A transformational approach to data
visualization . . . . . . . . . . . . . 53--62
Masato Shioda and
Hideya Iwasaki and
Shigeyuki Sato LibDSL: a library for developing
embedded domain specific languages in D
via template metaprogramming . . . . . . 63--72
Vojin Jovanovic and
Amir Shaikhha and
Sandro Stucki and
Vladimir Nikolaev and
Christoph Koch and
Martin Odersky Yin-Yang: concealing the deep embedding
of DSLs . . . . . . . . . . . . . . . . 73--82
Benjamin Hess and
Thomas R. Gross and
Markus Püschel Automatic locality-friendly interface
extension of numerical functions . . . . 83--92
Sam Kamin and
María Jesús Garzarán and
Baris Aktemur and
Danqing Xu and
Buse Yilmaz and
Zhongbo Chen Optimization by runtime specialization
for sparse matrix--vector multiplication 93--102
Piotr Danilewski and
Marcel Köster and
Roland Leißa and
Richard Membarth and
Philipp Slusallek Specialization through dynamic staging 103--112
Kenichi Asai Compiling a reflective language using
MetaOCaml . . . . . . . . . . . . . . . 113--122
Christian Humer and
Christian Wimmer and
Christian Wirth and
Andreas Wöß and
Thomas Würthinger A domain-specific language for building
self-optimizing AST interpreters . . . . 123--132
James H. Hill and
Dennis C. Feiock Pin++: an object-oriented framework for
writing Pintools . . . . . . . . . . . . 133--141
Ozcan Ozturk Architectural Support for Cyber-Physical
Systems . . . . . . . . . . . . . . . . 1--1
Yiying Zhang and
Jian Yang and
Amirsaman Memaripour and
Steven Swanson Mojim: a Reliable and Highly-Available
Non-Volatile Memory System . . . . . . . 3--18
Rujia Wang and
Lei Jiang and
Youtao Zhang and
Jun Yang SD-PCM: Constructing Reliable Super
Dense Phase Change Memory under Write
Disturbance . . . . . . . . . . . . . . 19--31
Vinson Young and
Prashant J. Nair and
Moinuddin K. Qureshi DEUCE: Write-Efficient Encryption for
Non-Volatile Memories . . . . . . . . . 33--44
Adam Morrison and
Yehuda Afek Temporally Bounding TSO for Fence-Free
Asymmetric Synchronization . . . . . . . 45--58
Alexander Matveev and
Nir Shavit Reduced Hardware NOrec: a Safe and
Scalable Hybrid Transactional Memory . . 59--71
Marc S. Orr and
Shuai Che and
Ayse Yilmazer and
Bradford M. Beckmann and
Mark D. Hill and
David A. Wood Synchronization Using Remote-Scope
Promotion . . . . . . . . . . . . . . . 73--86
Chang Liu and
Austin Harris and
Martin Maas and
Michael Hicks and
Mohit Tiwari and
Elaine Shi GhostRider: a Hardware-Software System
for Memory Trace Oblivious Computation 87--101
Christopher W. Fletcher and
Ling Ren and
Albert Kwon and
Marten van Dijk and
Srinivas Devadas Freecursive ORAM: [Nearly] Free
Recursion and Integrity Verification for
Position-based Oblivious RAM . . . . . . 103--116
David Chisnall and
Colin Rothwell and
Robert N. M. Watson and
Jonathan Woodruff and
Munraj Vadera and
Simon W. Moore and
Michael Roe and
Brooks Davis and
Peter G. Neumann Beyond the PDP-11: Architectural Support
for a Memory-Safe C Abstract Machine . . 117--130
Jiuyue Ma and
Xiufeng Sui and
Ninghui Sun and
Yupeng Li and
Zihao Yu and
Bowen Huang and
Tianni Xu and
Zhicheng Yao and
Yun Chen and
Haibin Wang and
Lixin Zhang and
Yungang Bao Supporting Differentiated Services in
Computers via Programmable Architecture
for Resourcing-on-Demand (PARD) . . . . 131--143
Yushi Omote and
Takahiro Shinagawa and
Kazuhiko Kato Improving Agility and Elasticity in
Bare-metal Clouds . . . . . . . . . . . 145--159
Md E. Haque and
Yong hun Eom and
Yuxiong He and
Sameh Elnikety and
Ricardo Bianchini and
Kathryn S. McKinley Few-to-Many: Incremental Parallelism for
Reducing Tail Latency in Interactive
Services . . . . . . . . . . . . . . . . 161--175
Patrick Colp and
Jiawen Zhang and
James Gleeson and
Sahil Suneja and
Eyal de Lara and
Himanshu Raj and
Stefan Saroiu and
Alec Wolman Protecting Data on Smartphones and
Tablets from Memory Attacks . . . . . . 177--189
Nathan Dautenhahn and
Theodoros Kasampalis and
Will Dietz and
John Criswell and
Vikram Adve Nested Kernel: an Operating System
Architecture for Intra-Kernel Privilege
Separation . . . . . . . . . . . . . . . 191--206
Zhangxi Tan and
Zhenghao Qian and
Xi Chen and
Krste Asanovic and
David Patterson DIABLO: a Warehouse-Scale Computer
Network Simulator using FPGAs . . . . . 207--221
Johann Hauswald and
Michael A. Laurenzano and
Yunqi Zhang and
Cheng Li and
Austin Rovinski and
Arjun Khurana and
Ronald G. Dreslinski and
Trevor Mudge and
Vinicius Petrucci and
Lingjia Tang and
Jason Mars Sirius: an Open End-to-End Voice and
Vision Personal Assistant and Its
Implications for Future Warehouse Scale
Computers . . . . . . . . . . . . . . . 223--238
Chao Xu and
Felix Xiaozhu Lin and
Yuyang Wang and
Lin Zhong Automated OS-level Device Runtime Power
Management . . . . . . . . . . . . . . . 239--252
Íñigo Goiri and
Thu D. Nguyen and
Ricardo Bianchini CoolAir: Temperature- and
Variation-Aware Management for
Free-Cooled Datacenters . . . . . . . . 253--265
Nikita Mishra and
Huazhe Zhang and
John D. Lafferty and
Henry Hoffmann A Probabilistic Graphical Model-based
Approach for Minimizing Energy Under
Performance Constraints . . . . . . . . 267--281
Jun Pang and
Chris Dwyer and
Alvin R. Lebeck More is Less, Less is More:
Molecular-Scale Photonic NoC Power
Topologies . . . . . . . . . . . . . . . 283--296
Vilas Sridharan and
Nathan DeBardeleben and
Sean Blanchard and
Kurt B. Ferreira and
Jon Stearley and
John Shalf and
Sudhanva Gurumurthi Memory Errors in Modern Systems: The
Good, The Bad, and The Ugly . . . . . . 297--310
Yavuz Yetim and
Sharad Malik and
Margaret Martonosi CommGuard: Mitigating Communication
Errors in Error-Prone Parallel Execution 311--323
Dohyeong Kim and
Yonghwi Kwon and
William N. Sumner and
Xiangyu Zhang and
Dongyan Xu Dual Execution for On-the-Fly Fine
Grained Execution Comparison . . . . . . 325--338
Petr Hosek and
Cristian Cadar VARAN the Unbelievable: an Efficient
$N$-version Execution Framework . . . . 339--353
Moshe Malka and
Nadav Amit and
Muli Ben-Yehuda and
Dan Tsafrir rIOMMU: Efficient IOMMU for I/O Devices
that Employ Ring Buffers . . . . . . . . 355--368
Daofu Liu and
Tianshi Chen and
Shaoli Liu and
Jinhong Zhou and
Shengyuan Zhou and
Olivier Teman and
Xiaobing Feng and
Xuehai Zhou and
Yunji Chen PuDianNao: a Polyvalent Machine Learning
Accelerator . . . . . . . . . . . . . . 369--381
Inigo Goiri and
Ricardo Bianchini and
Santosh Nagarakatte and
Thu D. Nguyen ApproxHadoop: Bringing Approximations to
MapReduce Frameworks . . . . . . . . . . 383--397
Michael Ringenburg and
Adrian Sampson and
Isaac Ackerman and
Luis Ceze and
Dan Grossman Monitoring and Debugging the Quality of
Results in Approximate Programs . . . . 399--411
Guruduth Banavar Watson and the Era of Cognitive
Computing . . . . . . . . . . . . . . . 413--413
Gordon Stewart and
Mahanth Gowda and
Geoffrey Mainland and
Bozidar Radunovic and
Dimitrios Vytiniotis and
Cristina Luengo Agullo Ziria: a DSL for Wireless Systems
Programming . . . . . . . . . . . . . . 415--428
Ravi Teja Mullapudi and
Vinay Vasista and
Uday Bondhugula PolyMage: Automatic Optimization for
Image Processing Pipelines . . . . . . . 429--443
Jeff Heckey and
Shruti Patil and
Ali JavadiAbhari and
Adam Holmes and
Daniel Kudrow and
Kenneth R. Brown and
Diana Franklin and
Frederic T. Chong and
Margaret Martonosi Compiler Management of Communication and
Parallelism for Quantum Computation . . 445--456
Muhammad Amber Hassaan and
Donald D. Nguyen and
Keshav K. Pingali Kinetic Dependence Graphs . . . . . . . 457--471
Stelios Sidiroglou-Douskos and
Eric Lahtinen and
Nathan Rittenhouse and
Paolo Piselli and
Fan Long and
Deokhwan Kim and
Martin Rinard Targeted Automatic Integer Overflow
Discovery Using Goal-Directed
Conditional Branch Enforcement . . . . . 473--486
Udit Dhawan and
Catalin Hritcu and
Raphael Rubin and
Nikos Vasilakis and
Silviu Chiricescu and
Jonathan M. Smith and
Thomas F. Knight, Jr. and
Benjamin C. Pierce and
Andre DeHon Architectural Support for
Software-Defined Metadata Processing . . 487--502
Danfeng Zhang and
Yao Wang and
G. Edward Suh and
Andrew C. Myers A Hardware Design Language for
Timing-Sensitive Information-Flow
Security . . . . . . . . . . . . . . . . 503--516
Matthew Hicks and
Cynthia Sturton and
Samuel T. King and
Jonathan M. Smith SPECS: a Lightweight Runtime Mechanism
for Protecting Software from
Security-Critical Processor Bugs . . . . 517--529
Yuelu Duan and
Nima Honarmand and
Josep Torrellas Asymmetric Memory Fences: Optimizing
Both Performance and Implementability 531--543
Hyojin Sung and
Sarita V. Adve DeNovoSync: Efficient Support for
Arbitrary Synchronization without
Writer-Initiated Invalidations . . . . . 545--559
Aritra Sengupta and
Swarnendu Biswas and
Minjia Zhang and
Michael D. Bond and
Milind Kulkarni Hybrid Static-Dynamic Analysis for
Statically Bounded Region
Serializability . . . . . . . . . . . . 561--575
Jade Alglave and
Mark Batty and
Alastair F. Donaldson and
Ganesh Gopalakrishnan and
Jeroen Ketema and
Daniel Poetzl and
Tyler Sorensen and
John Wickerson GPU Concurrency: Weak Behaviours and
Programming Assumptions . . . . . . . . 577--591
Jason Jong Kyu Park and
Yongjun Park and
Scott Mahlke Chimera: Collaborative Preemption for
Multitasking on a Shared GPU . . . . . . 593--606
Neha Agarwal and
David Nellans and
Mark Stephenson and
Mike O'Connor and
Stephen W. Keckler Page Placement Strategies for GPUs
within Heterogeneous Memory Systems . . 607--618
Zhijia Zhao and
Xipeng Shen On-the-Fly Principled Speculation for
FSM Parallelization . . . . . . . . . . 619--630
Tudor David and
Rachid Guerraoui and
Vasileios Trigonakis Asynchronized Concurrency: The Secret to
Scaling Concurrent Search Data
Structures . . . . . . . . . . . . . . . 631--644
Pramod Bhatotia and
Pedro Fonseca and
Umut A. Acar and
Björn B. Brandenburg and
Rodrigo Rodrigues iThreads: a Threading Library for
Parallel Incremental Computation . . . . 645--659
Lokesh Gidra and
Gaël Thomas and
Julien Sopena and
Marc Shapiro and
Nhan Nguyen NumaGiC: a Garbage Collector for Big
Data on Big NUMA Machines . . . . . . . 661--673
Khanh Nguyen and
Kai Wang and
Yingyi Bu and
Lu Fang and
Jianfei Hu and
Guoqing Xu FACADE: a Compiler and Runtime for
(Almost) Object-Bounded Big Data
Applications . . . . . . . . . . . . . . 675--690
Varun Agrawal and
Abhiroop Dabral and
Tapti Palit and
Yongming Shen and
Michael Ferdman Architectural Support for Dynamic
Linking . . . . . . . . . . . . . . . . 691--702
Ryan Baird and
Peter Gavin and
Magnus Själander and
David Whalley and
Gang-Ryung Uh Optimizing Transfers of Control in the
Static Pipeline Architecture . . . . . . 1:1--1:??
Qingrui Liu and
Changhee Jung and
Dongyoon Lee and
Devesh Tiwari Clover: Compiler Directed Lightweight
Soft Error Resilience . . . . . . . . . 2:1--2:??
Alen Bardizbanyan and
Magnus Själander and
David Whalley and
Per Larsson-Edefors Improving Data Access Efficiency by
Using Context-Aware Loads and Stores . . 3:1--3:??
Isabella Stilkerich and
Clemens Lang and
Christoph Erhardt and
Michael Stilkerich A Practical Getaway: Applications of
Escape Analysis in Embedded Real-Time
Systems . . . . . . . . . . . . . . . . 4:1--4:??
Stanislav Manilov and
Björn Franke and
Anthony Magrath and
Cedric Andrieu Free Rider: a Tool for Retargeting
Platform-Specific Intrinsic Functions 5:1--5:??
Christian Dietrich and
Martin Hoffmann and
Daniel Lohmann Cross-Kernel Control-Flow--Graph
Analysis for Event-Driven Real-Time
Systems . . . . . . . . . . . . . . . . 6:1--6:??
Soumyadeep Ghosh and
Yongjun Park and
Arun Raman Enabling Efficient Alias Speculation . . 7:1--7:??
Wenguang Zheng and
Hui Wu WCET-Aware Dynamic D-cache Locking for a
Single Task . . . . . . . . . . . . . . 8:1--8:??
Yixiao Lin and
Sayan Mitra StarL: Towards a Unified Framework for
Programming, Simulating and Verifying
Distributed Robotic Systems . . . . . . 9:1--9:??
Zhenkai Zhang and
Xenofon Koutsoukos Improving the Precision of Abstract
Interpretation Based Cache Persistence
Analysis . . . . . . . . . . . . . . . . 10:1--10:??
Kamyar Mirzazad Barijough and
Matin Hashemi and
Volodymyr Khibin and
Soheil Ghiasi Implementation-Aware Model Analysis: The
Case of Buffer-Throughput Tradeoff in
Streaming Applications . . . . . . . . . 11:1--11:??
Chen Liu and
Chengmo Yang Secure and Durable (SEDURA): an
Integrated Encryption and Wear-leveling
Framework for PCM-based Main Memory . . 12:1--12:??
Adam Procter and
William L. Harrison and
Ian Graves and
Michela Becchi and
Gerard Allwein Semantics Driven Hardware Design,
Implementation, and Verification with
ReWire . . . . . . . . . . . . . . . . . 13:1--13:??
Hans Christian Woithe and
Ulrich Kremer TrilobiteG: a programming architecture
for autonomous underwater vehicles . . . 14:1--14:??
Pavel Panchekha and
Alex Sanchez-Stern and
James R. Wilcox and
Zachary Tatlock Automatically improving accuracy for
floating point expressions . . . . . . . 1--11
Danfeng Zhang and
Andrew C. Myers and
Dimitrios Vytiniotis and
Simon Peyton-Jones Diagnosing type errors with class . . . 12--21
Nuno P. Lopes and
David Menendez and
Santosh Nagarakatte and
John Regehr Provably correct peephole optimizations
with Alive . . . . . . . . . . . . . . . 22--32
Maarten Faddegon and
Olaf Chitil Algorithmic debugging of real-world
Haskell programs: deriving dependencies
from the cost centre stack . . . . . . . 33--42
Stelios Sidiroglou-Douskos and
Eric Lahtinen and
Fan Long and
Martin Rinard Automatic error elimination by
horizontal code transfer across multiple
applications . . . . . . . . . . . . . . 43--54
Peng Liu and
Xiangyu Zhang and
Omer Tripp and
Yunhui Zheng Light: replay via tightly bounded
recording . . . . . . . . . . . . . . . 55--64
Christopher Lidbury and
Andrei Lascu and
Nathan Chong and
Alastair F. Donaldson Many-core compiler fuzzing . . . . . . . 65--76
Ilya Sergey and
Aleksandar Nanevski and
Anindya Banerjee Mechanized verification of fine-grained
concurrent programs . . . . . . . . . . 77--87
Rahul Sharma and
Michael Bauer and
Alex Aiken Verification of producer-consumer
synchronization in GPU programs . . . . 88--98
Peter Gammie and
Antony L. Hosking and
Kai Engelhardt Relaxing safely: verified on-the-fly
garbage collection for x86-TSO . . . . . 99--109
Joseph Tassarotti and
Derek Dreyer and
Viktor Vafeiadis Verifying read-copy-update in a logic
for weak memory . . . . . . . . . . . . 110--120
Yousun Ko and
Bernd Burgstaller and
Bernhard Scholz LaminarIR: compile-time queues for
structured streams . . . . . . . . . . . 121--130
Wei Ding and
Xulong Tang and
Mahmut Kandemir and
Yuanrui Zhang and
Emre Kultursay Optimizing off-chip accesses in
multicores . . . . . . . . . . . . . . . 131--142
Sanyam Mehta and
Pen-Chung Yew Improving compiler scalability:
optimizing large programs at small price 143--152
Andrew W. Appel Verification of a cryptographic
primitive: SHA-256 (abstract) . . . . . 153--153
Pantazis Deligiannis and
Alastair F. Donaldson and
Jeroen Ketema and
Akash Lal and
Paul Thomson Asynchronous programming, analysis and
testing with state machines . . . . . . 154--164
Jeff Huang Stateless model checking concurrent
programs with maximal causality
reduction . . . . . . . . . . . . . . . 165--174
Malavika Samak and
Murali Krishna Ramanathan and
Suresh Jagannathan Synthesizing racy tests . . . . . . . . 175--185
Eric Koskinen and
Matthew Parkinson The Push/Pull model of transactions . . 186--195
Jedidiah McClurg and
Hossein Hojjat and
Pavol Cerný and
Nate Foster Efficient synthesis of network updates 196--207
Aditya V. Nori and
Sherjil Ozair and
Sriram K. Rajamani and
Deepak Vijaykeerthy Efficient synthesis of probabilistic
programs . . . . . . . . . . . . . . . . 208--217
Daniel W. Barowy and
Sumit Gulwani and
Ted Hart and
Benjamin Zorn FlashRelate: extracting relational data
from semi-structured spreadsheets using
examples . . . . . . . . . . . . . . . . 218--228
John K. Feser and
Swarat Chaudhuri and
Isil Dillig Synthesizing data structure
transformations from input-output
examples . . . . . . . . . . . . . . . . 229--239
Ofri Ziv and
Alex Aiken and
Guy Golan-Gueta and
G. Ramalingam and
Mooly Sagiv Composing concurrency control . . . . . 240--249
Naling Zhang and
Markus Kusano and
Chao Wang Dynamic partial order reduction for
relaxed memory models . . . . . . . . . 250--259
Michael Emmi and
Constantin Enea and
Jad Hamza Monitoring refinement via symbolic
reasoning . . . . . . . . . . . . . . . 260--269
Stephen Longfield and
Brittany Nkounkou and
Rajit Manohar and
Ross Tate Preventing glitches and short circuits
in high-level self-timed chip
specifications . . . . . . . . . . . . . 270--279
Akash Lal and
Shaz Qadeer DAG inlining: a decision procedure for
reachability-modulo-theories in
hierarchical programs . . . . . . . . . 280--290
Andrew Johnson and
Lucas Waye and
Scott Moore and
Stephen Chong Exploring and enforcing security
guarantees via program dependence graphs 291--302
Gagandeep Singh and
Markus Püschel and
Martin Vechev Making numerical program analysis fast 303--313
Yusheng Weijiang and
Shruthi Balakrishna and
Jianqiao Liu and
Milind Kulkarni Tree dependence analysis . . . . . . . . 314--325
Jeehoon Kang and
Chung-Kil Hur and
William Mansky and
Dmitri Garbuzov and
Steve Zdancewic and
Viktor Vafeiadis A formal C memory model supporting
integer-pointer casts . . . . . . . . . 326--335
Chris Hathhorn and
Chucky Ellison and
Grigore Rosu Defining the undefinedness of C . . . . 336--345
Daejun Park and
Andrei Stefanescu and
Grigore Rosu KJS: a complete formal semantics of
JavaScript . . . . . . . . . . . . . . . 346--356
James R. Wilcox and
Doug Woos and
Pavel Panchekha and
Zachary Tatlock and
Xi Wang and
Michael D. Ernst and
Thomas Anderson Verdi: a framework for implementing and
formally verifying distributed systems 357--368
Oswaldo Olivo and
Isil Dillig and
Calvin Lin Static detection of asymptotic
performance bugs in collection
traversals . . . . . . . . . . . . . . . 369--378
Yufei Ding and
Jason Ansel and
Kalyan Veeramachaneni and
Xipeng Shen and
Una-May O'Reilly and
Saman Amarasinghe Autotuning algorithmic choice for input
sensitivity . . . . . . . . . . . . . . 379--390
Charith Mendis and
Jeffrey Bosboom and
Kevin Wu and
Shoaib Kamil and
Jonathan Ragan-Kelley and
Sylvain Paris and
Qin Zhao and
Saman Amarasinghe Helium: lifting high-performance stencil
kernels from stripped x86 binaries to
halide DSL code . . . . . . . . . . . . 391--402
William J. Bowman and
Swaha Miller and
Vincent St-Amour and
R. Kent Dybvig Profile-guided meta-programming . . . . 403--412
KC Sivaramakrishnan and
Gowtham Kaki and
Suresh Jagannathan Declarative programming over eventually
consistent data stores . . . . . . . . . 413--424
Jeremy Siek and
Peter Thiemann and
Philip Wadler Blame and coercion: together again for
the first time . . . . . . . . . . . . . 425--435
Yizhou Zhang and
Matthew C. Loring and
Guido Salvaneschi and
Barbara Liskov and
Andrew C. Myers Lightweight, flexible object-oriented
generics . . . . . . . . . . . . . . . . 436--445
Phúc C. Nguy\ven and
David Van Horn Relatively complete counterexamples for
higher-order programs . . . . . . . . . 446--456
Duc-Hiep Chu and
Joxan Jaffar and
Minh-Thai Trinh Automatic induction proofs of
data-structures in imperative programs 457--466
Quentin Carbonneaux and
Jan Hoffmann and
Zhong Shao Compositional certified resource bounds 467--478
Karl Crary and
Michael J. Sullivan Peer-to-peer affine commitment using
bitcoin . . . . . . . . . . . . . . . . 479--488
Ton Chanh Le and
Shengchao Qin and
Wei-Ngan Chin Termination and non-termination
specification inference . . . . . . . . 489--498
Murali Krishna Emani and
Michael O'Boyle Celebrating diversity: a mixture of
experts approach for runtime mapping in
dynamic environments . . . . . . . . . . 499--508
Bin Ren and
Youngjoon Jo and
Sriram Krishnamoorthy and
Kunal Agrawal and
Milind Kulkarni Efficient execution of recursive
programs on commodity vector hardware 509--520
Anand Venkat and
Mary Hall and
Michelle Strout Loop and data transformations for sparse
matrix code . . . . . . . . . . . . . . 521--532
Dimitrios Prountzos and
Roman Manevich and
Keshav Pingali Synthesizing parallel graph programs via
automated planning . . . . . . . . . . . 533--544
Stefan Marr and
Chris Seaton and
Stéphane Ducasse Zero-overhead metaprogramming:
reflection and metaobject protocols fast
and without compromises . . . . . . . . 545--554
Chinawat Isradisaikul and
Andrew C. Myers Finding counterexamples from parsing
conflicts . . . . . . . . . . . . . . . 555--564
Alan Leung and
John Sarracino and
Sorin Lerner Interactive parser synthesis by example 565--574
Brandon Lucia and
Benjamin Ransford A simpler, safer programming and
execution model for intermittent systems 575--585
Nuno Machado and
Brandon Lucia and
Luís Rodrigues Concurrency debugging with differential
schedule projections . . . . . . . . . . 586--595
Venkatesh Srinivasan and
Thomas Reps Synthesis of machine code from semantics 596--607
Laure Gonnord and
David Monniaux and
Gabriel Radanne Synthesis of ranking functions using
extremal counterexamples . . . . . . . . 608--618
Peter-Michael Osera and
Steve Zdancewic Type-and-example-directed program
synthesis . . . . . . . . . . . . . . . 619--630
Cheng-Chun Tu and
Michael Ferdman and
Chao-tung Lee and
Tzi-cker Chiueh A Comprehensive Implementation and
Evaluation of Direct Interrupt Delivery 1--15
Jonas Pfefferle and
Patrick Stuedi and
Animesh Trivedi and
Bernard Metzler and
Ionnis Koltsidas and
Thomas R. Gross A Hybrid I/O Virtualization Framework
for RDMA-capable Network Interfaces . . 17--30
Andrew J. Younge and
John Paul Walters and
Stephen P. Crago and
Geoffrey C. Fox Supporting High Performance Molecular
Dynamics in Virtualized Clusters using
IOMMU, SR-IOV, and GPUDirect . . . . . . 31--38
Fei Guo and
Seongbeom Kim and
Yury Baskakov and
Ishan Banerjee Proactively Breaking Large Pages to
Improve Memory Overcommitment
Performance in VMware ESXi . . . . . . . 39--51
Zhe Wang and
Jianjun Li and
Chenggang Wu and
Dongyan Yang and
Zhenjiang Wang and
Wei-Chung Hsu and
Bin Li and
Yong Guan HSPT: Practical Implementation and
Efficient Management of Embedded Shadow
Page Tables for Cross-ISA System Virtual
Machines . . . . . . . . . . . . . . . . 53--64
Jens Kehne and
Jonathan Metter and
Frank Bellosa GPUswap: Enabling Oversubscription of
GPU Memory through Transparent Swapping 65--77
Vishal Gupta and
Min Lee and
Karsten Schwan HeteroVisor: Exploiting Resource
Heterogeneity to Enhance the Elasticity
of Cloud Platforms . . . . . . . . . . . 79--92
Hui Wang and
Canturk Isci and
Lavanya Subramanian and
Jongmoo Choi and
Depei Qian and
Onur Mutlu A-DRM: Architecture-aware Distributed
Resource Management of Virtualized
Clusters . . . . . . . . . . . . . . . . 93--106
Rayman Preet Singh and
Tim Brecht and
S. Keshav Towards VM Consolidation Using a
Hierarchy of Idle States . . . . . . . . 107--119
Stephen Kyle and
Hugh Leather and
Björn Franke and
Dave Butcher and
Stuart Monteith Application of Domain-aware Binary
Fuzzing to Aid Android Virtual Machine
Testing . . . . . . . . . . . . . . . . 121--132
Sahil Suneja and
Canturk Isci and
Eyal de Lara and
Vasanth Bala Exploring VM Introspection: Techniques
and Trade-offs . . . . . . . . . . . . . 133--146
Junyuan Zeng and
Yangchun Fu and
Zhiqiang Lin PEMU: a Pin Highly Compatible Out-of-VM
Dynamic Binary Instrumentation Framework 147--160
Shehbaz Jaffer and
Piyus Kedia and
Sorav Bansal Improving Remote Desktopping Through
Adaptive Record/Replay . . . . . . . . . 161--172
JinSeok Oh and
Jin-woo Kwon and
Hyukwoo Park and
Soo-Mook Moon Migration of Web Applications with
Seamless Execution . . . . . . . . . . . 173--185
Jianbao Ren and
Yong Qi and
Yuehua Dai and
Xiaoguang Wang and
Yi Shi AppSec: a Safe Execution Environment for
Security Sensitive Applications . . . . 187--199
Seongwook Jin and
Jinho Seol and
Jaehyuk Huh and
Seungryoul Maeng Hardware-Assisted Secure Resource
Accounting under a Vulnerable Hypervisor 201--213
Lei Cui and
Tianyu Wo and
Bo Li and
Jianxin Li and
Bin Shi and
Jinpeng Huai PARS: a Page-Aware Replication System
for Efficiently Storing Virtual Machine
Snapshots . . . . . . . . . . . . . . . 215--228
Vincent Gramoli More than you ever wanted to know about
synchronization: synchrobench, measuring
the impact of the synchronization on
concurrent algorithms . . . . . . . . . 1--10
Dan Alistarh and
Justin Kopinsky and
Jerry Li and
Nir Shavit The SprayList: a scalable relaxed
priority queue . . . . . . . . . . . . . 11--20
Maya Arbel and
Adam Morrison Predicate RCU: an RCU for scalable
concurrent updates . . . . . . . . . . . 21--30
Guy Golan-Gueta and
G. Ramalingam and
Mooly Sagiv and
Eran Yahav Automatic scalable atomicity via
semantic locking . . . . . . . . . . . . 31--41
Austin R. Benson and
Grey Ballard A framework for practical parallel fast
matrix multiplication . . . . . . . . . 42--53
Aravind Acharya and
Uday Bondhugula PLUTO+: near-complete modeling of affine
transformations for parallelism and
locality . . . . . . . . . . . . . . . . 54--64
Mahesh Ravishankar and
Roshan Dathathri and
Venmugil Elango and
Louis-Noël Pouchet and
J. Ramanujam and
Atanas Rountev and
P. Sadayappan Distributed memory code generation for
mixed irregular/regular computations . . 65--75
Lingxiang Xiang and
Michael L. Scott Software partitioning of hardware
transactions . . . . . . . . . . . . . . 76--86
Alexandro Baldassin and
Edson Borin and
Guido Araujo Performance implications of dynamic
memory allocators on transactional
memory systems . . . . . . . . . . . . . 87--96
Minjia Zhang and
Jipeng Huang and
Man Cao and
Michael D. Bond Low-overhead software transactional
memory with progress guarantees and
strong semantics . . . . . . . . . . . . 97--108
Milind Chabbi and
Wim Lavrijsen and
Wibe de Jong and
Koushik Sen and
John Mellor-Crummey and
Costin Iancu Barrier elision for production parallel
programs . . . . . . . . . . . . . . . . 109--119
Lo\"\ic Thébault and
Eric Petit and
Quang Dinh Scalable and efficient implementation of
$3$D unstructured meshes computation: a
case study on matrix assembly . . . . . 120--129
Nathan R. Tallent and
Abhinav Vishnu and
Hubertus Van Dam and
Jeff Daily and
Darren J. Kerbyson and
Adolfy Hoisie Diagnosing the causes and severity of
one-sided message contention . . . . . . 130--139
Yen-Jung Chang and
Vijay K. Garg A parallel algorithm for global states
enumeration in concurrent systems . . . 140--149
Tiago Cogumbreiro and
Raymond Hu and
Francisco Martins and
Nobuko Yoshida Dynamic deadlock verification for
general barrier synchronisation . . . . 150--160
Yi-Ping You and
Hen-Jung Wu and
Yeh-Ning Tsai and
Yen-Ting Chao VirtCL: a framework for OpenCL device
abstraction and management . . . . . . . 161--172
Arash Ashari and
Shirish Tatikonda and
Matthias Boehm and
Berthold Reinwald and
Keith Campbell and
John Keenleyside and
P. Sadayappan On optimizing machine learning workloads
via kernel fusion . . . . . . . . . . . 173--182
Kaiyuan Zhang and
Rong Chen and
Haibo Chen NUMA-aware graph-structured analytics 183--193
Chenning Xie and
Rong Chen and
Haibing Guan and
Binyu Zang and
Haibo Chen SYNC or ASYNC: time to fuse for
distributed graph-parallel computation 194--204
Yuan Tang and
Ronghui You and
Haibin Kan and
Jesmin Jahan Tithi and
Pramod Ganapathi and
Rezaul A. Chowdhury Cache-oblivious wavefront: improving
parallelism of recursive dynamic
programming algorithms without losing
cache-efficiency . . . . . . . . . . . . 205--214
Milind Chabbi and
Michael Fagan and
John Mellor-Crummey High performance locks for multi-level
NUMA systems . . . . . . . . . . . . . . 215--226
Zoltan Majo and
Thomas R. Gross A library for portable and composable
data locality optimizations for NUMA
systems . . . . . . . . . . . . . . . . 227--238
Abdelhalim Amer and
Huiwei Lu and
Yanjie Wei and
Pavan Balaji and
Satoshi Matsuoka MPI+Threads: runtime contention and
remedies . . . . . . . . . . . . . . . . 239--248
Andrew J. McPherson and
Vijay Nagarajan and
Susmit Sarkar and
Marcelo Cintra Fence placement for legacy
data-race-free programs via
synchronization read detection . . . . . 249--250
Xianglan Piao and
Channoh Kim and
Younghwan Oh and
Huiying Li and
Jincheon Kim and
Hanjun Kim and
Jae W. Lee JAWS: a JavaScript framework for
adaptive CPU--GPU work sharing . . . . . 251--252
Hyunseok Seo and
Jinwook Kim and
Min-Soo Kim GStream: a graph streaming processing
method for large-scale graphs on GPUs 253--254
Nabeel Al-Saber and
Milind Kulkarni SemCache++: semantics-aware caching for
efficient multi-GPU offloading . . . . . 255--256
Jungwon Kim and
Seyong Lee and
Jeffrey S. Vetter An OpenACC-based unified programming
model for multi-accelerator systems . . 257--258
Paul Thomson and
Alastair F. Donaldson The lazy happens-before relation: better
partial-order reduction for systematic
concurrency testing . . . . . . . . . . 259--260
Azzam Haidar and
Tingxing Dong and
Piotr Luszczek and
Stanimire Tomov and
Jack Dongarra Towards batched linear solvers on
accelerated hardware platforms . . . . . 261--262
Saurav Muralidharan and
Michael Garland and
Bryan Catanzaro and
Albert Sidelnik and
Mary Hall A collection-oriented programming model
for performance portability . . . . . . 263--264
Yangzihao Wang and
Andrew Davidson and
Yuechao Pan and
Yuduo Wu and
Andy Riffel and
John D. Owens Gunrock: a high-performance graph
processing library on the GPU . . . . . 265--266
Olga Pearce and
Todd Gamblin and
Bronis R. de Supinski and
Martin Schulz and
Nancy M. Amato Decoupled load balancing . . . . . . . . 267--268
Ye Jin and
Mingliang Liu and
Xiaosong Ma and
Qing Liu and
Jeremy Logan and
Norbert Podhorszki and
Jong Youl Choi and
Scott Klasky Combining phase identification and
statistic modeling for automated
parallel benchmark generation . . . . . 269--270
Xuanhua Shi and
Junling Liang and
Sheng Di and
Bingsheng He and
Hai Jin and
Lu Lu and
Zhixiang Wang and
Xuan Luo and
Jianlong Zhong Optimization of asynchronous graph
processing on GPU with hybrid coloring
model . . . . . . . . . . . . . . . . . 271--272
Scott West and
Sebastian Nanz and
Bertrand Meyer Efficient and reasonable object-oriented
concurrency . . . . . . . . . . . . . . 273--274
Vassilis Vassiliadis and
Konstantinos Parasyris and
Charalambos Chalios and
Christos D. Antonopoulos and
Spyros Lalis and
Nikolaos Bellas and
Hans Vandierendonck and
Dimitrios S. Nikolopoulos A programming model and runtime system
for significance-aware energy-efficient
computing . . . . . . . . . . . . . . . 275--276
Martin Wimmer and
Jakob Gruber and
Jesper Larsson Träff and
Philippas Tsigas The lock-free $k$-LSM relaxed priority
queue . . . . . . . . . . . . . . . . . 277--278
Emmanuelle Saillard and
Patrick Carribault and
Denis Barthou Static/dynamic validation of MPI
collective communications in
multi-threaded context . . . . . . . . . 279--280
Arunmoezhi Ramachandran and
Neeraj Mittal CASTLE: fast concurrent internal binary
search tree using edge-based locking . . 281--282
Madan Das and
Gabriel Southern and
Jose Renau Section based program analysis to reduce
overhead of detecting unsynchronized
thread communication . . . . . . . . . . 283--284
Harshvardhan and
Nancy M. Amato and
Lawrence Rauchwerger A hierarchical approach to reducing
communication in parallel graph
algorithms . . . . . . . . . . . . . . . 285--286
Yifeng Chen and
Xiang Cui and
Hong Mei Tiles: a new language mechanism for
heterogeneous parallelism . . . . . . . 287--288
Cosmin Radoi and
Stephan Herhut and
Jaswanth Sreeram and
Danny Dig Are web applications ready for
parallelism? . . . . . . . . . . . . . . 289--290
Rastislav Bodik Program synthesis: opportunities for the
next decade . . . . . . . . . . . . . . 1--1
Tiark Rompf and
Nada Amin Functional pearl: a SQL to C compiler in
500 lines of code . . . . . . . . . . . 2--9
Adam Chlipala An optimizing compiler for a purely
functional web-application language . . 10--21
Spenser Bauman and
Carl Friedrich Bolz and
Robert Hirschfeld and
Vasily Kirilichev and
Tobias Pape and
Jeremy G. Siek and
Sam Tobin-Hochstadt Pycket: a tracing JIT for a functional
language . . . . . . . . . . . . . . . . 22--34
Andreas Rossberg 1ML --- core and modules united ($F$-ing
first-class modules) . . . . . . . . . . 35--47
Niki Vazou and
Alexander Bakst and
Ranjit Jhala Bounded refinement types . . . . . . . . 48--61
Kazutaka Matsuda and
Meng Wang Applicative bidirectional programming
with lenses . . . . . . . . . . . . . . 62--74
Justin Pombrio and
Shriram Krishnamurthi Hygienic resugaring of compositional
desugaring . . . . . . . . . . . . . . . 75--87
Pierre Genev\`es and
Nils Gesbert XQuery and static typing: tackling the
problem of backward axes . . . . . . . . 88--100
William J. Bowman and
Amal Ahmed Noninterference for free . . . . . . . . 101--113
Marco Gaboardi and
Romain Péchoux Algebras and coalgebras in the light
affine Lambda calculus . . . . . . . . . 114--126
Paul Downen and
Philip Johnson-Freyd and
Zena M. Ariola Structures for structural recursion . . 127--139
Norman Danner and
Daniel R. Licata and
Ramyaa Ramyaa Denotational cost semantics for
functional languages with inductive
types . . . . . . . . . . . . . . . . . 140--151
Martin Avanzini and
Ugo Dal Lago and
Georg Moser Analysing the complexity of functional
programs: higher-order meets first-order 152--164
Mary Sheeran Functional programming and hardware
design: still interesting after all
these years . . . . . . . . . . . . . . 165--165
Georg Neis and
Chung-Kil Hur and
Jan-Oliver Kaiser and
Craig McLaughlin and
Derek Dreyer and
Viktor Vafeiadis Pilsner: a compositionally verified
compiler for a higher-order imperative
language . . . . . . . . . . . . . . . . 166--178
Beta Ziliani and
Matthieu Sozeau A unification algorithm for Coq
featuring universe polymorphism and
overloading . . . . . . . . . . . . . . 179--191
Jasmin Christian Blanchette and
Andrei Popescu and
Dmitriy Traytel Foundational extensible corecursion: a
proof assistant perspective . . . . . . 192--204
Michel Steuwer and
Christian Fensch and
Sam Lindley and
Christophe Dubach Generating performance portable code
using rewrite rules: from high-level
functional expressions to
high-performance OpenCL code . . . . . . 205--217
Ryan R. Newton and
Peter P. Fogg and
Ali Varamesh Adaptive lock-free maps:
purely-functional to scalable . . . . . 218--229
Matthew Le and
Matthew Fluet Partial aborts for transactions via
first-class continuations . . . . . . . 230--242
Gabriel Scherer and
Didier Rémy Which simple types have a unique
inhabitant? . . . . . . . . . . . . . . 243--255
Joshua Dunfield Elaborating evaluation-order
polymorphism . . . . . . . . . . . . . . 256--268
Tillmann Rendel and
Julia Trieflinger and
Klaus Ostermann Automatic refunctionalization to a
language with copattern matching: with
applications to the expression problem 269--279
Alejandro Russo Functional pearl: two can keep a secret,
if one of them uses Haskell . . . . . . 280--288
Pablo Buiras and
Dimitrios Vytiniotis and
Alejandro Russo HLIO: mixing static and dynamic typing
for information-flow control in Haskell 289--301
Atze van der Ploeg and
Koen Claessen Practical principled FRP: forget the
past, change the future, FRPNow! . . . . 302--314
Patrick Bahr and
Jost Berthold and
Martin Elsman Certified symbolic management of
financial multi-party contracts . . . . 315--327
Steffen Smolka and
Spiridon Eliopoulos and
Nate Foster and
Arjun Guha A fast compiler for NetKAT . . . . . . . 328--341
Nicolas Stucki and
Tiark Rompf and
Vlad Ureche and
Phil Bagwell RRB vector: a practical general purpose
immutable sequence . . . . . . . . . . . 342--354
Mauro Jaskelioff and
Exequiel Rivas Functional pearl: a smart view on
datatypes . . . . . . . . . . . . . . . 355--361
Edward Z. Yang and
Giovanni Campagna and
Ömer S. Agacan and
Ahmed El-Hassany and
Abhishek Kulkarni and
Ryan R. Newton Efficient communication and collection
with compact normal forms . . . . . . . 362--374
Matthias Keil and
Peter Thiemann Blame assignment for higher-order
contracts with intersection and union 375--386
Cameron Swords and
Amr Sabry and
Sam Tobin-Hochstadt Expressing contract monitors as patterns
of communication . . . . . . . . . . . . 387--399
He Zhu and
Aditya V. Nori and
Suresh Jagannathan Learning refinement types . . . . . . . 400--411
Zvonimir Pavlinovic and
Tim King and
Thomas Wies Practical SMT-based type error
localization . . . . . . . . . . . . . . 412--423
Georgios Karachalias and
Tom Schrijvers and
Dimitrios Vytiniotis and
Simon Peyton Jones GADTs meet their match: pattern-matching
warnings that account for GADTs, guards,
and laziness . . . . . . . . . . . . . . 424--436
Matthew Hague and
Anthony W. Lin and
C.-H. Luke Ong Detecting redundant CSS rules in HTML5
applications: a tree rewriting approach 1--19
Brian Demsky and
Patrick Lam SATCheck: SAT-directed stateless model
checking for SC and TSO . . . . . . . . 20--36
Ivan Kuraj and
Viktor Kuncak and
Daniel Jackson Programming with enumerable sets of
structures . . . . . . . . . . . . . . . 37--56
Casper S. Jensen and
Anders Mòller and
Veselin Raychev and
Dimitar Dimitrov and
Martin Vechev Stateless model checking of event-driven
applications . . . . . . . . . . . . . . 57--73
Thibaud Hottelier and
Rastislav Bodik Synthesis of layout engines from
relational constraints . . . . . . . . . 74--88
Sebastian Erdweg and
Moritz Lichter and
Manuel Weiel A sound and optimal incremental build
system with dynamic dependencies . . . . 89--106
Oleksandr Polozov and
Sumit Gulwani FlashMeta: a framework for inductive
program synthesis . . . . . . . . . . . 107--126
Haoyuan Zhang and
Zewei Chu and
Bruno C. d. S. Oliveira and
Tijs van der Storm Scrap your boilerplate with object
algebras . . . . . . . . . . . . . . . . 127--146
Rahul Sharma and
Eric Schkufza and
Berkeley Churchill and
Alex Aiken Conditionally correct superoptimization 147--162
Sam Blackshear and
Bor-Yuh Evan Chang and
Manu Sridharan Selective control-flow abstraction via
jumping . . . . . . . . . . . . . . . . 163--182
Ravichandhran Madhavan and
Mikaël Mayer and
Sumit Gulwani and
Viktor Kuncak Automating grammar comparison . . . . . 183--200
Gian Ntzik and
Philippa Gardner Reasoning about the POSIX file system:
local update and global pathnames . . . 201--220
Peizhao Ou and
Brian Demsky AutoMO: automatic inference of memory
order parameters for C/C++11 . . . . . . 221--240
Swarnendu Biswas and
Minjia Zhang and
Michael D. Bond and
Brandon Lucia Valor: efficient, software-only region
conflict exceptions . . . . . . . . . . 241--259
Nachshon Cohen and
Erez Petrank Automatic memory reclamation for
lock-free data structures . . . . . . . 260--279
Hugo A. López and
Eduardo R. B. Marques and
Francisco Martins and
Nicholas Ng and
César Santos and
Vasco Thudichum Vasconcelos and
Nobuko Yoshida Protocol-based verification of
message-passing parallel programs . . . 280--298
Osbert Bastani and
Saswat Anand and
Alex Aiken Interactively verifying absence of
explicit information flows in Android
apps . . . . . . . . . . . . . . . . . . 299--315
Lucas Brutschy and
Pietro Ferrara and
Omer Tripp and
Marco Pistoia ShamDroid: gracefully degrading
functionality in the presence of limited
resource access . . . . . . . . . . . . 316--331
Pavol Bielik and
Veselin Raychev and
Martin Vechev Scalable race detection for Android
applications . . . . . . . . . . . . . . 332--348
Yongjian Hu and
Tanzirul Azim and
Iulian Neamtiu Versatile yet lightweight
record-and-replay for Android . . . . . 349--366
John Bender and
Mohsen Lesani and
Jens Palsberg Declarative fence insertion . . . . . . 367--385
Vu Le and
Chengnian Sun and
Zhendong Su Finding deep compiler bugs via guided
stochastic program mutation . . . . . . 386--399
Haichuan Wang and
David Padua and
Peng Wu Vectorization of Apply to reduce
interpretation overhead of R . . . . . . 400--415
Tihomir Gvero and
Viktor Kuncak Synthesizing Java expressions from
free-form queries . . . . . . . . . . . 416--432
Yudi Zheng and
Lubomír Bulej and
Walter Binder Accurate profiling in the presence of
dynamic compilation . . . . . . . . . . 433--450
Martin Aigner and
Christoph M. Kirsch and
Michael Lippautz and
Ana Sokolova Fast, multicore-scalable,
low-fragmentation memory allocation
through large virtual memory and global
data structures . . . . . . . . . . . . 451--469
Brett Boston and
Adrian Sampson and
Dan Grossman and
Luis Ceze Probability type inference for flexible
approximate programming . . . . . . . . 470--487
Michael R. Jantz and
Forrest J. Robinson and
Prasad A. Kulkarni and
Kshitij A. Doshi Cross-layer memory management for
managed language applications . . . . . 488--504
Magnus Madsen and
Frank Tip and
Ondrej Lhoták Static analysis of event-driven Node.js
JavaScript applications . . . . . . . . 505--519
Yu Feng and
Xinyu Wang and
Isil Dillig and
Calvin Lin EXPLORER : query- and demand-driven
exploration of interprocedural control
flow properties . . . . . . . . . . . . 520--534
Jens Dietrich and
Nicholas Hollingum and
Bernhard Scholz Giga-scale exhaustive points-to analysis
for Java in under a minute . . . . . . . 535--551
David Darais and
Matthew Might and
David Van Horn Galois transformers and modular abstract
interpreters: reusable metatheory for
program analysis . . . . . . . . . . . . 552--571
Hakjoo Oh and
Hongseok Yang and
Kwangkeun Yi Learning a strategy for adapting a
program analysis via Bayesian
optimisation . . . . . . . . . . . . . . 572--588
Péricles Alves and
Fabian Gruber and
Johannes Doerfert and
Alexandros Lamprineas and
Tobias Grosser and
Fabrice Rastello and
Fernando Magno Quintão Pereira Runtime pointer disambiguation . . . . . 589--606
Luca Della Toffola and
Michael Pradel and
Thomas R. Gross Performance problems you can fix: a
dynamic analysis of memoization
opportunities . . . . . . . . . . . . . 607--622
Wen-Chuan Lee and
Tao Bao and
Yunhui Zheng and
Xiangyu Zhang and
Keval Vora and
Rajiv Gupta RAIVE: runtime assessment of
floating-point instability by
vectorization . . . . . . . . . . . . . 623--638
Zhoulai Fu and
Zhaojun Bai and
Zhendong Su Automated backward error analysis for
numerical code . . . . . . . . . . . . . 639--654
Markus Voelter and
Arie van Deursen and
Bernd Kolb and
Stephan Eberle Using C language extensions for
developing embedded software: a case
study . . . . . . . . . . . . . . . . . 655--674
Cristina V. Lopes and
Joel Ossher How scale affects structure in Java
programs . . . . . . . . . . . . . . . . 675--694
Luis Mastrangelo and
Luca Ponzanelli and
Andrea Mocci and
Michele Lanza and
Matthias Hauswirth and
Nathaniel Nystrom Use at your own risk: the Java unsafe
API in the wild . . . . . . . . . . . . 695--710
Sara Achour and
Martin C. Rinard Approximate computation with outlier
detection in Topaz . . . . . . . . . . . 711--730
John Wickerson and
Mark Batty and
Bradford M. Beckmann and
Alastair F. Donaldson Remote-scope promotion: clarified,
rectified, and verified . . . . . . . . 731--747
Matthew A. Hammer and
Joshua Dunfield and
Kyle Headley and
Nicholas Labich and
Jeffrey S. Foster and
Michael Hicks and
David Van Horn Incremental computation with names . . . 748--766
Tim Felgentreff and
Todd Millstein and
Alan Borning and
Robert Hirschfeld Checks and balances: constraint solving
without surprises in object-constraint
programming languages . . . . . . . . . 767--782
Michael J. Steindorfer and
Jurgen J. Vinju Optimizing hash-array mapped tries for
fast and lean immutable JVM collections 783--800
Vlad Ureche and
Aggelos Biboudis and
Yannis Smaragdakis and
Martin Odersky Automating ad hoc data representation
transformations . . . . . . . . . . . . 801--820
Stefan Marr and
Stéphane Ducasse Tracing vs. partial evaluation:
comparing meta-compilation approaches
for self-optimizing interpreters . . . . 821--839
Ganesha Upadhyaya and
Hridesh Rajan Effectively mapping linguistic
abstractions for message-passing
concurrency to threads on the Java
Virtual Machine . . . . . . . . . . . . 840--859
Venkatesh Srinivasan and
Thomas Reps Partial evaluation of machine code . . . 860--879
Sebastian Erdweg and
Oliver Bracevac and
Edlira Kuci and
Matthias Krebs and
Mira Mezini A co-contextual formulation of type
rules and its application to incremental
type checking . . . . . . . . . . . . . 880--897
Stephan Brandauer and
Dave Clarke and
Tobias Wrigstad Disjointness domains for fine-grained
aliasing . . . . . . . . . . . . . . . . 898--916
Silvia Crafa and
Luca Padovani The chemical approach to
typestate-oriented programming . . . . . 917--934
Matías Toro and
Éric Tanter Customizable gradual polymorphic effects
for Scala . . . . . . . . . . . . . . . 935--953
Sang-Hoon Kim and
Sejun Kwon and
Jin-Soo Kim and
Jinkyu Jeong Controlling physical memory
fragmentation in mobile systems . . . . 1--14
Ahmed Hussein and
Antony L. Hosking and
Mathias Payer and
Christopher A. Vick Don't race the memory bus: taming the GC
leadfoot . . . . . . . . . . . . . . . . 15--27
Nachshon Cohen and
Erez Petrank Data structure aware garbage collector 28--40
Bradley C. Kuszmaul SuperMalloc: a super fast multithreaded
\tt malloc for 64-bit machines . . . . . 41--55
Erik Österlund and
Welf Löwe Concurrent compaction using a field
pinning protocol . . . . . . . . . . . . 56--69
Yi Lin and
Kunshan Wang and
Stephen M. Blackburn and
Antony L. Hosking and
Michael Norrish Stop and go: understanding yieldpoint
behavior . . . . . . . . . . . . . . . . 70--80
Codrut Stancu and
Christian Wimmer and
Stefan Brunthaler and
Per Larsen and
Michael Franz Safe and efficient hybrid memory
management for Java . . . . . . . . . . 81--92
Eliot Miranda and
Clément Béra A partial read barrier for efficient
support of live object-oriented
programming . . . . . . . . . . . . . . 93--104
Daniel Clifford and
Hannes Payer and
Michael Stanton and
Ben L. Titzer Memento mori: dynamic
allocation-site-based optimizations . . 105--117
Jonathan Shidal and
Ari J. Spilo and
Paul T. Scheid and
Ron K. Cytron and
Krishna M. Kavi Recycling trash in cache . . . . . . . . 118--130
Cody Cutler and
Robert Morris Reducing pause times with clustered
collection . . . . . . . . . . . . . . . 131--142
Callum Cameron and
Jeremy Singer and
David Vengerov The judgment of FORSETI: economic
utility for dynamic heap sizing of
multiple runtimes . . . . . . . . . . . 143--156
Iavor S. Diatchki Improving Haskell types with SMT . . . . 1--10
Adam Gundry A typechecker plugin for units of
measure: domain-specific constraint
solving in GHC Haskell . . . . . . . . . 11--22
Andrew Farmer and
Neil Sculthorpe and
Andy Gill Reasoning with the HERMIT: tool support
for equational reasoning on GHC core
programs . . . . . . . . . . . . . . . . 23--34
Joachim Breitner Formally proving a compiler
transformation safe . . . . . . . . . . 35--46
Ivan Perez and
Henrik Nilsson Bridging the GUI gap with reactive
values and relations . . . . . . . . . . 47--58
Andy Gill and
Neil Sculthorpe and
Justin Dawson and
Aleksander Eskilson and
Andrew Farmer and
Mark Grebe and
Jeffrey Rosenbluth and
Ryan Scott and
James Stanton The remote monad design pattern . . . . 59--70
J. Garrett Morris Variations on variants . . . . . . . . . 71--81
Bruno C. d. S. Oliveira and
Shin-Cheng Mu and
Shu-Hung You Modular reifiable matching: a
list-of-functors approach to two-level
types . . . . . . . . . . . . . . . . . 82--93
Oleg Kiselyov and
Hiromi Ishii Freer monads, more extensible effects 94--105
Kenneth Foner Functional pearl: getting a quick fix on
comonads . . . . . . . . . . . . . . . . 106--117
Jan Stolarek and
Simon Peyton Jones and
Richard A. Eisenberg Injective type families for Haskell . . 118--128
Alejandro Serrano and
Jurriaan Hage and
Patrick Bahr Type families with class, type classes
with family . . . . . . . . . . . . . . 129--140
Michael Walker and
Colin Runciman Déj\`a Fu: a concurrency testing library
for Haskell . . . . . . . . . . . . . . 141--152
José Manuel Calderón Trilla and
Colin Runciman Improving implicit parallelism . . . . . 153--164
Adam \'Scibior and
Zoubin Ghahramani and
Andrew D. Gordon Practical probabilistic programming with
monads . . . . . . . . . . . . . . . . . 165--176
Jeff Polakow Embedding a full linear lambda calculus
in Haskell . . . . . . . . . . . . . . . 177--188
Trevor Elliott and
Lee Pike and
Simon Winwood and
Pat Hickey and
James Bielman and
Jamey Sharp and
Eric Seidel and
John Launchbury Guilt free Ivory . . . . . . . . . . . . 189--200
Trevor L. McDonell and
Manuel M. T. Chakravarty and
Vinod Grover and
Ryan R. Newton Type-safe runtime code generation:
accelerate to LLVM . . . . . . . . . . . 201--212
Kathryn S. McKinley Programming the world of uncertain
things (keynote) . . . . . . . . . . . . 1--2
Richard M. Murray Synthesis of reactive controllers for
hybrid systems (keynote) . . . . . . . . 3--3
David Walker Confluences in programming languages
research (keynote) . . . . . . . . . . . 4--4
Matt Brown and
Jens Palsberg Breaking through the normalization
barrier: a self-interpreter for F$_{\rm
omega}$ . . . . . . . . . . . . . . . . 5--17
Thorsten Altenkirch and
Ambrus Kaposi Type theory in type theory using
quotient inductive types . . . . . . . . 18--29
Yufei Cai and
Paolo G. Giarrusso and
Klaus Ostermann System F$_{\rm omega}$ with
equirecursive types for datatype-generic
programming . . . . . . . . . . . . . . 30--43
Pierre-Louis Curien and
Marcelo Fiore and
Guillaume Munch-Maccagnoni A theory of effects and resources:
adjunction models and polarised calculi 44--56
Akihiro Murase and
Tachio Terauchi and
Naoki Kobayashi and
Ryosuke Sato and
Hiroshi Unno Temporal verification of higher-order
functional programs . . . . . . . . . . 57--68
Gordon D. Plotkin and
Nikolaj Bjòrner and
Nuno P. Lopes and
Andrey Rybalchenko and
George Varghese Scaling network verification using
symmetry and surgery . . . . . . . . . . 69--83
James Brotherston and
Nikos Gorogiannis and
Max Kanovich and
Reuben Rowe Model checking for symbolic-heap
separation logic with inductive
predicates . . . . . . . . . . . . . . . 84--96
Eric Koskinen and
Junfeng Yang Reducing crash recoverability to
reachability . . . . . . . . . . . . . . 97--108
Xin Zhang and
Ravi Mangal and
Aditya V. Nori and
Mayur Naik Query-guided maximum satisfiability . . 109--122
Anthony W. Lin and
Pablo Barceló String solving with word equations and
transducers: towards a logic for
analysing mutation XSS . . . . . . . . . 123--136
Luca Cardelli and
Mirco Tribastone and
Max Tschaikowski and
Andrea Vandin Symbolic computation of differential
equivalences . . . . . . . . . . . . . . 137--150
Matthew Hague and
Jonathan Kochems and
C.-H. Luke Ong Unboundedness and downward closures of
higher-order pushdown automata . . . . . 151--163
Dominique Devriese and
Marco Patrignani and
Frank Piessens Fully-abstract compilation by
approximate back-translation . . . . . . 164--177
Jeehoon Kang and
Yoonseung Kim and
Chung-Kil Hur and
Derek Dreyer and
Viktor Vafeiadis Lightweight verification of separate
compilation . . . . . . . . . . . . . . 178--190
Ed Robbins and
Andy King and
Tom Schrijvers From MinX to MinC: semantics-driven
decompilation of recursive datatypes . . 191--203
Florian Lorenzen and
Sebastian Erdweg Sound type-dependent syntactic language
extension . . . . . . . . . . . . . . . 204--216
Oded Padon and
Neil Immerman and
Sharon Shoham and
Aleksandr Karbyshev and
Mooly Sagiv Decidability of inferring inductive
invariants . . . . . . . . . . . . . . . 217--231
Rahman Lavaee The hardness of data packing . . . . . . 232--242
Stéphane Gimenez and
Georg Moser The complexity of interaction . . . . . 243--255
Nikhil Swamy and
Catalin Hritcu and
Chantal Keller and
Aseem Rastogi and
Antoine Delignat-Lavaud and
Simon Forest and
Karthikeyan Bhargavan and
Cédric Fournet and
Pierre-Yves Strub and
Markulf Kohlweiss and
Jean-Karim Zinzindohoue and
Santiago Zanella-Béguelin Dependent types and multi-monadic
effects in F* . . . . . . . . . . . . . 256--270
Johannes Borgström and
Andrew D. Gordon and
Long Ouyang and
Claudio Russo and
Adam \'Scibior and
Marcin Szymczak Fabular: regression formulas as
probabilistic programming . . . . . . . 271--283
Bjòrn Bugge Grathwohl and
Fritz Henglein and
Ulrik Terp Rasmussen and
Kristoffer Aalund Sòholm and
Sebastian Paaske Tòrholm Kleenex: compiling nondeterministic
transducers to deterministic streaming
transducers . . . . . . . . . . . . . . 284--297
Fan Long and
Martin Rinard Automatic patch generation by learning
correct code . . . . . . . . . . . . . . 298--312
Omer Katz and
Ran El-Yaniv and
Eran Yahav Estimating types in binaries using
predictive modeling . . . . . . . . . . 313--326
Krishnendu Chatterjee and
Hongfei Fu and
Petr Novotný and
Rouzbeh Hasheminezhad Algorithmic analysis of qualitative and
quantitative termination problems for
affine probabilistic programs . . . . . 327--342
Rishabh Singh and
Sumit Gulwani Transforming spreadsheet data types
using examples . . . . . . . . . . . . . 343--356
Mohsen Lesani and
Christian J. Bell and
Adam Chlipala Chapar: certified causally consistent
distributed key-value stores . . . . . . 357--370
Alexey Gotsman and
Hongseok Yang and
Carla Ferreira and
Mahsa Najafzadeh and
Marc Shapiro 'Cause I'm strong enough': Reasoning
about consistency choices in distributed
systems . . . . . . . . . . . . . . . . 371--384
Hongjin Liang and
Xinyu Feng A program logic for concurrent objects
under fair scheduling . . . . . . . . . 385--399
Cezara Dragoi and
Thomas A. Henzinger and
Damien Zufferey PSync: a partially synchronous language
for fault-tolerant distributed
algorithms . . . . . . . . . . . . . . . 400--415
Sheng Chen and
Martin Erwig Principal type inference for GADTs . . . 416--428
Ronald Garcia and
Alison M. Clark and
Éric Tanter Abstracting gradual typing . . . . . . . 429--442
Matteo Cimini and
Jeremy G. Siek The gradualizer: a methodology and
algorithm for generating gradual type
systems . . . . . . . . . . . . . . . . 443--455
Asumu Takikawa and
Daniel Feltey and
Ben Greenman and
Max S. New and
Jan Vitek and
Matthias Felleisen Is sound gradual typing dead? . . . . . 456--468
Damien Octeau and
Somesh Jha and
Matthew Dering and
Patrick McDaniel and
Alexandre Bartel and
Li Li and
Jacques Klein and
Yves Le Traon Combining static analysis with
probabilistic models to enable
market-scale Android inter-component
analysis . . . . . . . . . . . . . . . . 469--484
Radu Grigore and
Hongseok Yang Abstraction refinement guided by a
learnt probabilistic model . . . . . . . 485--498
Pranav Garg and
Daniel Neider and
P. Madhusudan and
Dan Roth Learning invariants using decision trees
and implication counterexamples . . . . 499--512
Michael Emmi and
Constantin Enea Symbolic abstract data type inference 513--525
Somashekaracharya G. Bhaskaracharya and
Uday Bondhugula and
Albert Cohen SMO: an integrated approach to
intra-array and inter-array storage
optimization . . . . . . . . . . . . . . 526--538
Wenlei Bao and
Sriram Krishnamoorthy and
Louis-Noël Pouchet and
Fabrice Rastello and
P. Sadayappan PolyCheck: dynamic verification of
iteration space transformations on
affine programs . . . . . . . . . . . . 539--554
Marc Andrysco and
Ranjit Jhala and
Sorin Lerner Printing floating-point numbers: a
faster, always correct method . . . . . 555--567
Dominic Orchard and
Nobuko Yoshida Effects as sessions, sessions as effects 568--581
Limin Jia and
Hannah Gommerstadt and
Frank Pfenning Monitors and blame assignment for
higher-order session types . . . . . . . 582--594
Davide Sangiorgi and
Valeria Vignudelli Environmental bisimulations for
probabilistic higher-order languages . . 595--607
Shaked Flur and
Kathryn E. Gray and
Christopher Pulte and
Susmit Sarkar and
Ali Sezgin and
Luc Maranget and
Will Deacon and
Peter Sewell Modelling the ARMv8 architecture,
operationally: concurrency and ISA . . . 608--621
Jean Pichon-Pharabod and
Peter Sewell A concurrency semantics for relaxed
atomics that permits optimisation and
avoids thin-air executions . . . . . . . 622--633
Mark Batty and
Alastair F. Donaldson and
John Wickerson Overhauling SC atomics in C11 and OpenCL 634--648
Ori Lahav and
Nick Giannarakis and
Viktor Vafeiadis Taming release-acquire consistency . . . 649--662
Thomas Reps and
Emma Turetsky and
Prathmesh Prabhu Newtonian program analysis via tensor
product . . . . . . . . . . . . . . . . 663--677
Rongxin Wu and
Xiao Xiao and
Shing-Chi Cheung and
Hongyu Zhang and
Charles Zhang Casper: an efficient approach to call
trace collection . . . . . . . . . . . . 678--690
Thomas Gilray and
Steven Lyde and
Michael D. Adams and
Matthew Might and
David Van Horn Pushdown control-flow analysis for free 691--704
Matthew Flatt Binding as sets of scopes . . . . . . . 705--717
Ichiro Hasuo and
Shunsuke Shimizu and
Corina C\^\irstea Lattice-theoretic progress measures and
coalgebraic model checking . . . . . . . 718--732
Krishnendu Chatterjee and
Amir Kafshdar Goharshady and
Rasmus Ibsen-Jensen and
Andreas Pavlogiannis Algorithms for algebraic path properties
in concurrent systems of constant
treewidth components . . . . . . . . . . 733--747
Koko Muroya and
Naohiko Hoshino and
Ichiro Hasuo Memoryful geometry of interaction II:
recursion and adequacy . . . . . . . . . 748--760
Veselin Raychev and
Pavol Bielik and
Martin Vechev and
Andreas Krause Learning programs from noisy data . . . 761--774
James Bornholt and
Emina Torlak and
Dan Grossman and
Luis Ceze Optimizing synthesis with metasketches 775--788
Aws Albarghouthi and
Isil Dillig and
Arie Gurfinkel Maximal specification synthesis . . . . 789--801
Jonathan Frankle and
Peter-Michael Osera and
David Walker and
Steve Zdancewic Example-directed synthesis: a
type-theoretic interpretation . . . . . 802--815
Michael Homer and
Timothy Jones and
James Noble From APIs to languages: generalising
method names . . . . . . . . . . . . . . 1--12
André Murbach Maidl and
Fabio Mascarenhas and
Roberto Ierusalimschy A formalization of typed lua . . . . . . 13--25
Éric Tanter and
Nicolas Tabareau Gradual certified programming in coq . . 26--40
Erik Ernst and
Anders Mòller and
Mathias Schwarz and
Fabio Strocco Message safety in Dart . . . . . . . . . 41--53
Steven Lyde and
William E. Byrd and
Matthew Might Control-flow analysis of dynamic
languages via pointer analysis . . . . . 54--62
Marc Feeley Compiling for multi-language task
migration . . . . . . . . . . . . . . . 63--77
Matthias Grimmer and
Chris Seaton and
Roland Schatz and
Thomas Würthinger and
Hanspeter Mössenböck High-performance cross-language
interoperability in a multi-language
runtime . . . . . . . . . . . . . . . . 78--90
David Leopoldseder and
Lukas Stadler and
Christian Wimmer and
Hanspeter Mössenböck Java-to-JavaScript translation via
structured control flow reconstruction
of compiler IR . . . . . . . . . . . . . 91--103
Tobias Pape and
Tim Felgentreff and
Robert Hirschfeld and
Anton Gulenko and
Carl Friedrich Bolz Language-independent storage strategies
for tracing JIT-based virtual machines 104--113
Beatrice Åkerblom and
Tobias Wrigstad Measuring polymorphism in Python
programs . . . . . . . . . . . . . . . . 114--128
Juan Pablo Sandoval Alcocer and
Alexandre Bergel Tracking down performance variation
against source code evolution . . . . . 129--139
Madhukar N. Kedlaya and
Behnam Robatmili and
Ben Hardekopf Server-side type profiling for
optimizing client-side JavaScript
engines . . . . . . . . . . . . . . . . 140--153
Lars Fischer and
Stefan Hanenberg An empirical investigation of the
effects of type systems and code
completion on API usability using
TypeScript and JavaScript in MS Visual
Studio . . . . . . . . . . . . . . . . . 154--167
Camille Teruel and
Stéphane Ducasse and
Damien Cassou and
Marcus Denker Access control to reflection with object
ownership . . . . . . . . . . . . . . . 168--176
Priya Narasimhan and
Utsav Drolia and
Jiaqi Tan and
Nathan D. Mickulicz and
Rajeev Gandhi The next-generation in-stadium
experience (keynote) . . . . . . . . . . 1--10
Roland Leißa and
Klaas Boesche and
Sebastian Hack and
Richard Membarth and
Philipp Slusallek Shallow embedding of DSLs via online
partial evaluation . . . . . . . . . . . 11--20
Maximilian Scherr and
Shigeru Chiba Almost first-class language embedding:
taming staged embedded DSLs . . . . . . 21--30
Bob Reynders and
Dominique Devriese and
Frank Piessens Generating safe boundary APIs between
typed EDSLs and their environments . . . 31--34
Flávio Medeiros and
Iran Rodrigues and
Márcio Ribeiro and
Leopoldo Teixeira and
Rohit Gheyi An empirical study on
configuration-related issues:
investigating undeclared and unused
identifiers . . . . . . . . . . . . . . 35--44
Sascha El-Sharkawy and
Adam Krafczyk and
Klaus Schmid Analysing the Kconfig semantics and its
analysis tools . . . . . . . . . . . . . 45--54
Zakarea Alshara and
Abdelhak-Djamel Seriai and
Chouki Tibermacine and
Hinde Lilia Bouziane and
Christophe Dony and
Anas Shatnawi Migrating large object-oriented
applications into component-based ones:
instantiation and inheritance
transformation . . . . . . . . . . . . . 55--64
Michael Lopez and
C. Jasson Casey and
Gabriel Dos Reis and
Colton Chojnacki Safer SDN programming through Arbiter 65--74
Alexey Kolesnichenko and
Christopher M. Poskitt and
Sebastian Nanz and
Bertrand Meyer Contract-based general-purpose GPU
programming . . . . . . . . . . . . . . 75--84
Hiroshi Yamaguchi and
Shigeru Chiba Inverse macro in Scala . . . . . . . . . 85--94
Sorin Adam and
Ulrik Pagh Schultz Towards tool support for
spreadsheet-based domain-specific
languages . . . . . . . . . . . . . . . 95--98
Antuan Byalik and
Sanchit Chadha and
Eli Tilevich Native-$2$-native: automated
cross-platform code synthesis from
web-based programming resources . . . . 99--108
Dmitri Makarov and
Matthias Hauswirth CLOP: a multi-stage compiler to
seamlessly embed heterogeneous code . . 109--112
Jan Oliver Ringert and
Bernhard Rumpe and
Andreas Wortmann Composing code generators for C&C ADLs
with Application-specific behavior
languages (tool demonstration) . . . . . 113--116
Milan Kabác and
Charles Consel Orchestrating masses of sensors: a
design-driven development approach . . . 117--120
Gabriel Foust and
Jaakko Järvi and
Sean Parent Generating reactive programs for
graphical user interfaces from multi-way
dataflow constraint systems . . . . . . 121--130
Spencer P. Florence and
Bruke Fetscher and
Matthew Flatt and
William H. Temps and
Tina Kiguradze and
Dennis P. West and
Charlotte Niznik and
Paul R. Yarnold and
Robert Bruce Findler and
Steven M. Belknap POP-PL: a patient-oriented prescription
programming language . . . . . . . . . . 131--140
Kai Selgrad and
Alexander Lier and
Franz Köferl and
Marc Stamminger and
Daniel Lohmann Lightweight, generative variant
exploration for high-performance
graphics applications . . . . . . . . . 141--150
Christoph Seidl and
Sven Schuster and
Ina Schaefer Generative software product line
development using variability-aware
design patterns . . . . . . . . . . . . 151--160
Jaime Font and
Lorena Arcega and
Òystein Haugen and
Carlos Cetina Addressing metamodel revisions in
model-based software product lines . . . 161--170
Pablo Inostroza and
Tijs van der Storm Modular interpreters for the masses:
implicit context propagation using
object algebras . . . . . . . . . . . . 171--180
Carlos Noguera and
Viviane Jonckers Model querying with query models . . . . 181--184
Yuanyuan Zhou Programming Uncertain $<$T$>$ hings . . . 1--2
Sergi Abadal and
Albert Cabellos-Aparicio and
Eduard Alarcon and
Josep Torrellas WiSync: an Architecture for Fast
Synchronization through On-Chip Wireless
Communication . . . . . . . . . . . . . 3--17
Xiaodong Wang and
José F. Martínez ReBudget: Trading Off Efficiency vs.
Fairness in Market-Based Multicore
Resource Allocation via Runtime Budget
Reassignment . . . . . . . . . . . . . . 19--32
Haishan Zhu and
Mattan Erez Dirigent: Enforcing QoS for
Latency-Critical Tasks on Shared
Multicore Systems . . . . . . . . . . . 33--47
Yossi Kuperman and
Eyal Moscovici and
Joel Nider and
Razya Ladelsky and
Abel Gordon and
Dan Tsafrir Paravirtual Remote I/O . . . . . . . . . 49--65
Antoine Kaufmann and
Simon Peter and
Naveen Kr. Sharma and
Thomas Anderson and
Arvind Krishnamurthy High Performance Packet Processing with
FlexNIC . . . . . . . . . . . . . . . . 67--81
James Bornholt and
Antoine Kaufmann and
Jialin Li and
Arvind Krishnamurthy and
Emina Torlak and
Xi Wang Specifying and Checking File System
Crash-Consistency Models . . . . . . . . 83--98
Aravinda Prasad and
K. Gopinath Prudent Memory Reclamation in
Procrastination-Based Synchronization 99--112
Anurag Mukkara and
Nathan Beckmann and
Daniel Sanchez Whirlpool: Improving Dynamic Cache
Management with Static Data
Classification . . . . . . . . . . . . . 113--127
Myeongjae Jeon and
Yuxiong He and
Hwanju Kim and
Sameh Elnikety and
Scott Rixner and
Alan L. Cox TPC: Target-Driven Parallelism Combining
Prediction and Correction to Reduce Tail
Latency in Interactive Services . . . . 129--141
Fraser Brown and
Andres Nötzli and
Dawson Engler How to Build Static Checking Systems
Using Orders of Magnitude Less Code . . 143--157
Tong Zhang and
Dongyoon Lee and
Changhee Jung TxRace: Efficient Data Race Detection
Using Commodity Hardware Transactional
Memory . . . . . . . . . . . . . . . . . 159--173
Sidney Amani and
Alex Hixon and
Zilin Chen and
Christine Rizkallah and
Peter Chubb and
Liam O'Connor and
Joel Beeren and
Yutaka Nagashima and
Japheth Lim and
Thomas Sewell and
Joseph Tuong and
Gabriele Keller and
Toby Murray and
Gerwin Klein and
Gernot Heiser CoGENT: Verifying High-Assurance File
System Implementations . . . . . . . . . 175--188
Nils Asmussen and
Marcus Völp and
Benedikt Nöthen and
Hermann Härtig and
Gerhard Fettweis M3: a Hardware/Operating-System
Co-Design to Tame Heterogeneous
Manycores . . . . . . . . . . . . . . . 189--203
Daniyal Liaqat and
Silviu Jingoi and
Eyal de Lara and
Ashvin Goel and
Wilson To and
Kevin Lee and
Italo De Moraes Garcia and
Manuel Saldana Sidewinder: an Energy Efficient and
Developer Friendly Heterogeneous
Architecture for Continuous Mobile
Sensing . . . . . . . . . . . . . . . . 205--215
Jonathan Balkind and
Michael McKeown and
Yaosheng Fu and
Tri Nguyen and
Yanqi Zhou and
Alexey Lavrov and
Mohammad Shahrad and
Adi Fuchs and
Samuel Payne and
Xiaohua Liang and
Matthew Matl and
David Wentzlaff OpenPiton: an Open Source Manycore
Research Framework . . . . . . . . . . . 217--232
Daniel Lustig and
Geet Sethi and
Margaret Martonosi and
Abhishek Bhattacharjee COATCheck: Verifying Memory Ordering at
the Hardware-OS Interface . . . . . . . 233--247
Alex Markuze and
Adam Morrison and
Dan Tsafrir True IOMMU Protection from DMA Attacks:
When Copy is Faster than Zero Copy . . . 249--262
Amro Awad and
Pratyusa Manadhata and
Stuart Haber and
Yan Solihin and
William Horne Silent Shredder: Zero-Cost Shredding for
Secure Non-Volatile Main Memory
Controllers . . . . . . . . . . . . . . 263--276
Youngjin Kwon and
Alan M. Dunn and
Michael Z. Lee and
Owen S. Hofmann and
Yuanzhong Xu and
Emmett Witchel Sego: Pervasive Trusted Metadata for
Efficiently Verified Untrusted System
Services . . . . . . . . . . . . . . . . 277--290
Dan Tsafrir Synopsis of the ASPLOS '16 Wild and
Crazy Ideas (WACI) Invited-Speakers
Session . . . . . . . . . . . . . . . . 291--294
R. Stanley Williams Brain Inspired Computing . . . . . . . . 295--295
Phitchaya Mangpo Phothilimthana and
Aditya Thakur and
Rastislav Bodik and
Dinakar Dhurjati Scaling up Superoptimization . . . . . . 297--310
Niranjan Hasabnis and
R. Sekar Lifting Assembly to Intermediate
Representation: a Novel Approach
Leveraging Compilers . . . . . . . . . . 311--324
Saurav Muralidharan and
Amit Roy and
Mary Hall and
Michael Garland and
Piyush Rai Architecture-Adaptive Code Variant
Tuning . . . . . . . . . . . . . . . . . 325--338
Xiaofeng Lin and
Yu Chen and
Xiaodong Li and
Junjie Mao and
Jiaquan He and
Wei Xu and
Yuanchun Shi Scalable Kernel TCP Design and
Implementation for Short-Lived
Connections . . . . . . . . . . . . . . 339--352
Izzat El Hajj and
Alexander Merritt and
Gerd Zellweger and
Dejan Milojicic and
Reto Achermann and
Paolo Faraboschi and
Wen-mei Hwu and
Timothy Roscoe and
Karsten Schwan SpaceJMP: Programming with Multiple
Virtual Address Spaces . . . . . . . . . 353--368
Felix Xiaozhu Lin and
Xu Liu memif: Towards Programming Heterogeneous
Memory Asynchronously . . . . . . . . . 369--383
Wook-Hee Kim and
Jinwoong Kim and
Woongki Baek and
Beomseok Nam and
Youjip Won NVWAL: Exploiting NVRAM in Write-Ahead
Logging . . . . . . . . . . . . . . . . 385--398
Aasheesh Kolli and
Steven Pelley and
Ali Saidi and
Peter M. Chen and
Thomas F. Wenisch High-Performance Transactions for
Persistent Memories . . . . . . . . . . 399--411
Qing Guo and
Karin Strauss and
Luis Ceze and
Henrique S. Malvar High-Density Image Storage Using
Approximate Memory Cells . . . . . . . . 413--426
Joseph Izraelevitz and
Terence Kelly and
Aasheesh Kolli Failure-Atomic Persistent Memory Updates
via JUSTDO Logging . . . . . . . . . . . 427--442
Jaeung Han and
Seungheun Jeon and
Young-ri Choi and
Jaehyuk Huh Interference Management for Distributed
Parallel Applications in Consolidated
Clusters . . . . . . . . . . . . . . . . 443--456
Martin Maas and
Krste Asanovi\'c and
Tim Harris and
John Kubiatowicz Taurus: a Holistic Language Runtime
System for Coordinating Distributed
Managed-Language Applications . . . . . 457--471
Christina Delimitrou and
Christos Kozyrakis HCloud: Resource-Efficient Provisioning
in Shared Cloud Systems . . . . . . . . 473--488
Xiao Yu and
Pallavi Joshi and
Jianwu Xu and
Guoliang Jin and
Hui Zhang and
Guofei Jiang CloudSeer: Workflow Monitoring of Cloud
Infrastructures via Interleaved Logs . . 489--502
Yonghwi Kwon and
Dohyeong Kim and
William Nick Sumner and
Kyungtae Kim and
Brendan Saltaformaggio and
Xiangyu Zhang and
Dongyan Xu LDX: Causality Inference by Lightweight
Dual Execution . . . . . . . . . . . . . 503--515
Tanakorn Leesatapornwongsa and
Jeffrey F. Lukman and
Shan Lu and
Haryadi S. Gunawi TaxDC: a Taxonomy of Non-Deterministic
Concurrency Bugs in Datacenter
Distributed Systems . . . . . . . . . . 517--530
Junjie Mao and
Yu Chen and
Qixue Xiao and
Yuanchun Shi RID: Finding Reference Count Bugs with
Inconsistent Path Pair Checking . . . . 531--544
Huazhe Zhang and
Henry Hoffmann Maximizing Performance Under a Power
Cap: a Comparison of Hardware, Software,
and Hybrid Techniques . . . . . . . . . 545--559
Songchun Fan and
Seyed Majid Zahedi and
Benjamin C. Lee The Computational Sprinting Game . . . . 561--575
Alexei Colin and
Graham Harvey and
Brandon Lucia and
Alanson P. Sample An Energy-interference-free
Hardware-Software Debugger for
Intermittent Energy-harvesting Systems 577--589
Emmett Witchel Programmer Productivity in a World of
Mushy Interfaces: Challenges of the
Post-ISA Reality . . . . . . . . . . . . 591--591
Kevin Angstadt and
Westley Weimer and
Kevin Skadron RAPID Programming of Pattern-Recognition
Processors . . . . . . . . . . . . . . . 593--605
Xin Sui and
Andrew Lenharth and
Donald S. Fussell and
Keshav Pingali Proactive Control of Approximate
Programs . . . . . . . . . . . . . . . . 607--621
Jongse Park and
Emmanuel Amaro and
Divya Mahajan and
Bradley Thwaites and
Hadi Esmaeilzadeh AxGames: Towards Crowdsourcing Quality
Target Determination in Approximate
Computing . . . . . . . . . . . . . . . 623--636
James Bornholt and
Randolph Lopez and
Douglas M. Carmean and
Luis Ceze and
Georg Seelig and
Karin Strauss A DNA-Based Archival Storage System . . 637--649
Raghu Prabhakar and
David Koeplinger and
Kevin J. Brown and
HyoukJoong Lee and
Christopher De Sa and
Christos Kozyrakis and
Kunle Olukotun Generating Configurable Hardware from
Parallel Patterns . . . . . . . . . . . 651--665
Li-Wen Chang and
Hee-Seok Kim and
Wen-mei W. Hwu DySel: Lightweight Dynamic Selection for
Kernel-based Data-parallel Programming
Model . . . . . . . . . . . . . . . . . 667--680
Quan Chen and
Hailong Yang and
Jason Mars and
Lingjia Tang Baymax: QoS Awareness and Increased
Utilization for Non-Preemptive
Accelerators in Warehouse Scale
Computers . . . . . . . . . . . . . . . 681--696
Tony Nowatzki and
Karthikeyan Sankaralingam Analyzing Behavior Specialized
Acceleration . . . . . . . . . . . . . . 697--711
Man-Ki Yoon and
Negin Salajegheh and
Yin Chen and
Mihai Christodorescu PIFT: Predictive Information-Flow
Tracking . . . . . . . . . . . . . . . . 713--725
Ashish Venkat and
Sriskanda Shamasunder and
Hovav Shacham and
Dean M. Tullsen HIPStR: Heterogeneous-ISA Program State
Relocation . . . . . . . . . . . . . . . 727--741
Zelalem Birhanu Aweke and
Salessawi Ferede Yitbarek and
Rui Qiao and
Reetuparna Das and
Matthew Hicks and
Yossi Oren and
Todd Austin ANVIL: Software-Based Protection Against
Next-Generation Rowhammer Attacks . . . 743--755
Diego Didona and
Nuno Diegues and
Anne-Marie Kermarrec and
Rachid Guerraoui and
Ricardo Neves and
Paolo Romano ProteusTM: Abstraction Meets Performance
in Transactional Memory . . . . . . . . 757--771
Noam Shalev and
Eran Harpaz and
Hagar Porat and
Idit Keidar and
Yaron Weinsberg CSR: Core Surprise Removal in Commodity
Operating Systems . . . . . . . . . . . 773--787
Tanmay Gangwani and
Adam Morrison and
Josep Torrellas CASPAR: Breaking Serialization in
Lock-Free Multicore Synchronization . . 789--804
Tom Spink and
Harry Wagstaff and
Björn Franke Efficient asynchronous interrupt
handling in a full-system instruction
set simulator . . . . . . . . . . . . . 1--10
Forrest J. Robinson and
Michael R. Jantz and
Prasad A. Kulkarni Code cache management in managed
language VMs to reduce memory
consumption for embedded systems . . . . 11--20
Ricardo Nobre and
Luiz G. A. Martins and
João M. P. Cardoso A graph-based iterative compiler pass
selection and phase ordering approach 21--30
Kunal Banerjee and
Chittaranjan Mandal and
Dipankar Sarkar Translation validation of loop and
arithmetic transformations in the
presence of recurrences . . . . . . . . 31--40
Yulei Sui and
Xiaokang Fan and
Hao Zhou and
Jingling Xue Loop-oriented array- and field-sensitive
pointer analysis for automatic SIMD
vectorization . . . . . . . . . . . . . 41--51
Lukasz Domagala and
Duco van Amstel and
Fabrice Rastello Generalized cache tiling for dataflow
programs . . . . . . . . . . . . . . . . 52--61
Duc-Hiep Chu and
Joxan Jaffar and
Rasool Maghareh Symbolic execution for memory
consumption analysis . . . . . . . . . . 62--71
Ravindra Metta and
Martin Becker and
Prasad Bokil and
Samarjit Chakraborty and
R. Venkatesh TIC: a scalable model checking based
approach to WCET estimation . . . . . . 72--81
Kuan-Hsun Chen and
Björn Bönninghoff and
Jian-Jia Chen and
Peter Marwedel Compensate or ignore? Meeting control
robustness requirements through adaptive
soft-error handling . . . . . . . . . . 82--91
Prasenjit Chakraborty and
Gautam Doshi and
Shashank Shekhar and
Vikrant Kumar Opportunity for compute partitioning in
pursuit of energy-efficient systems . . 92--101
Phitchaya Mangpo Phothilimthana and
Michael Schuldt and
Rastislav Bodik Compiling a gesture recognition
application for a low-power spatial
architecture . . . . . . . . . . . . . . 102--112
Paul-Jules Micolet and
Aaron Smith and
Christophe Dubach A machine learning approach to mapping
streaming workloads to dynamic multicore
processors . . . . . . . . . . . . . . . 113--122
Kayvan Memarian and
Justus Matthiesen and
James Lingard and
Kyndylan Nienhuis and
David Chisnall and
Robert N. M. Watson and
Peter Sewell Into the depths of C: elaborating the de
facto standards . . . . . . . . . . . . 1--15
Buddhika Chamith and
Bo Joel Svensson and
Luke Dalessandro and
Ryan R. Newton Living on the edge: rapid-toggling
probes with cross-modification on x86 16--26
Matt Noonan and
Alexey Loginov and
David Cok Polymorphic type inference for machine
code . . . . . . . . . . . . . . . . . . 27--41
Saswat Padhi and
Rahul Sharma and
Todd Millstein Data-driven precondition inference with
learned features . . . . . . . . . . . . 42--56
Marcelo Sousa and
Isil Dillig Cartesian Hoare logic for verifying
$k$-safety properties . . . . . . . . . 57--69
Wonyeol Lee and
Rahul Sharma and
Alex Aiken Verifying bit-manipulations of
floating-point . . . . . . . . . . . . . 70--84
Yuting Chen and
Ting Su and
Chengnian Sun and
Zhendong Su and
Jianjun Zhao Coverage-directed differential testing
of JVM implementations . . . . . . . . . 85--99
Tyler Sorensen and
Alastair F. Donaldson Exposing errors related to weak memory
in GPU applications . . . . . . . . . . 100--113
Maarten Faddegon and
Olaf Chitil Lightweight computation tree tracing for
lazy functional languages . . . . . . . 114--128
Changwan Hong and
Wenlei Bao and
Albert Cohen and
Sriram Krishnamoorthy and
Louis-Noël Pouchet and
Fabrice Rastello and
J. Ramanujam and
P. Sadayappan Effective padding of multidimensional
arrays to avoid cache conflict misses 129--144
Yuhao Zhu and
Vijay Janapa Reddi GreenWeb: language extensions for
energy-efficient mobile web computing 145--160
Michael A. Laurenzano and
Parker Hill and
Mehrzad Samadi and
Scott Mahlke and
Jason Mars and
Lingjia Tang Input responsiveness: using canary
inputs to dynamically steer
approximation . . . . . . . . . . . . . 161--176
Sara Achour and
Rahul Sarpeshkar and
Martin C. Rinard Configuration synthesis for programmable
analog devices with Arco . . . . . . . . 177--193
Magnus Madsen and
Ming-Ho Yee and
Ondrej Lhoták From Datalog to Flix: a declarative
language for fixed points on lattices 194--208
Leonard Truong and
Rajkishore Barik and
Ehsan Totoni and
Hai Liu and
Chick Markley and
Armando Fox and
Tatiana Shpeisman Latte: a language, compiler, and runtime
for elegant and efficient deep neural
networks . . . . . . . . . . . . . . . . 209--223
Michael D. Adams and
Celeste Hollenbeck and
Matthew Might On the complexity and performance of
parsing with derivatives . . . . . . . . 224--236
Stefan Heule and
Eric Schkufza and
Rahul Sharma and
Alex Aiken Stratified synthesis: automatically
learning the x86-64 instruction set . . 237--250
Ariel Eizenberg and
Shiliang Hu and
Gilles Pokam and
Joseph Devietti Remix: online detection and repair of
cache contention for the JVM . . . . . . 251--265
Yaniv David and
Nimrod Partush and
Eran Yahav Statistical similarity of binaries . . . 266--280
Yizhou Zhang and
Guido Salvaneschi and
Quinn Beightol and
Barbara Liskov and
Andrew C. Myers Accepting blame for safe tunneled
exceptions . . . . . . . . . . . . . . . 281--295
Andrew M. Kent and
David Kempe and
Sam Tobin-Hochstadt Occurrence typing modulo theories . . . 296--309
Panagiotis Vekris and
Benjamin Cosman and
Ranjit Jhala Refinement types for TypeScript . . . . 310--325
Calvin Smith and
Aws Albarghouthi MapReduce program synthesis . . . . . . 326--340
Ravi Chugh and
Brian Hempel and
Mitchell Spradlin and
Jacob Albers Programmatic and direct manipulation,
together at last . . . . . . . . . . . . 341--354
Calvin Loncaric and
Emina Torlak and
Michael D. Ernst Fast synthesis of fast collections . . . 355--368
Jedidiah McClurg and
Hossein Hojjat and
Nate Foster and
Pavol Cerný Event-driven network programming . . . . 369--385
Ryan Beckett and
Michael Greenberg and
David Walker Temporal NetKAT . . . . . . . . . . . . 386--401
Ahmed El-Hassany and
Jeremie Miserez and
Pavol Bielik and
Laurent Vanbever and
Martin Vechev SDNRacer: concurrency analysis for
software-defined networks . . . . . . . 402--415
Rian Shambaugh and
Aaron Weiss and
Arjun Guha Rehearsal: a configuration verification
tool for puppet . . . . . . . . . . . . 416--430
Hao Chen and
Xiongnan (Newman) Wu and
Zhong Shao and
Joshua Lockerman and
Ronghui Gu Toward compositional verification of
interruptible OS kernels and device
drivers . . . . . . . . . . . . . . . . 431--447
Eric Mullen and
Daryl Zuniga and
Zachary Tatlock and
Dan Grossman Verified peephole optimizations for
CompCert . . . . . . . . . . . . . . . . 448--461
Brianna M. Ren and
Jeffrey S. Foster Just-in-time static type checking for
dynamic languages . . . . . . . . . . . 462--476
Tomas Petricek and
Gustavo Guerra and
Don Syme Types from data: making structured data
first-class citizens in F# . . . . . . . 477--490
He Zhu and
Gustavo Petri and
Suresh Jagannathan Automatically learning shape
specifications . . . . . . . . . . . . . 491--507
Navid Yaghmazadeh and
Christian Klinger and
Isil Dillig and
Swarat Chaudhuri Synthesizing transformations on
hierarchically structured data . . . . . 508--521
Nadia Polikarpova and
Ivan Kuraj and
Armando Solar-Lezama Program synthesis from polymorphic
refinement types . . . . . . . . . . . . 522--538
Sepideh Maleki and
Annie Yang and
Martin Burtscher Higher-order and tuple-based
massively-parallel prefix sums . . . . . 539--552
Junghyun Kim and
Gangwon Jo and
Jaehoon Jung and
Jungwon Kim and
Jaejin Lee A distributed OpenCL framework using
redundant computation and data
replication . . . . . . . . . . . . . . 553--569
Ulan Degenbaev and
Jochen Eisinger and
Manfred Ernst and
Ross McIlroy and
Hannes Payer Idle time garbage collection scheduling 570--583
Nicholas Jacek and
Meng-Chieh Chiu and
Benjamin Marlin and
Eliot Moss Assessing the limits of program-specific
garbage collection performance . . . . . 584--598
Klaus v. Gleissenthall and
Nikolaj Bjòrner and
Andrey Rybalchenko Cardinalities and universal quantifiers
for verifying parameterized systems . . 599--613
Oded Padon and
Kenneth L. McMillan and
Aurojit Panda and
Mooly Sagiv and
Sharon Shoham Ivy: safety verification by interactive
generalization . . . . . . . . . . . . . 614--630
Jean Yang and
Travis Hance and
Thomas H. Austin and
Armando Solar-Lezama and
Cormac Flanagan and
Stephen Chong Precise, dynamic information flow for
database-backed applications . . . . . . 631--647
David Costanzo and
Zhong Shao and
Ronghui Gu End-to-end verification of
information-flow security for C and
assembly programs . . . . . . . . . . . 648--664
Rohit Sinha and
Manuel Costa and
Akash Lal and
Nuno P. Lopes and
Sriram Rajamani and
Sanjit A. Seshia and
Kapil Vaswani A design and verification methodology
for secure isolated regions . . . . . . 665--681
Alexander Spiegelman and
Guy Golan-Gueta and
Idit Keidar Transactional data structure libraries 682--696
Sara S. Baghsorkhi and
Nalini Vasudevan and
Youfeng Wu FlexVec: auto-vectorization for
irregular loops . . . . . . . . . . . . 697--710
Shoaib Kamil and
Alvin Cheung and
Shachar Itzhaky and
Armando Solar-Lezama Verified lifting of stencil computations 711--726
Yunji Chen Big Data Analytics and Intelligence at
Alibaba Cloud . . . . . . . . . . . . . 1--1
Hari Cherupalli and
Henry Duwe and
Weidong Ye and
Rakesh Kumar and
John Sartori Determining Application-specific Peak
Power and Energy Requirements for
Ultra-low Power Processors . . . . . . . 3--16
Quan Chen and
Hailong Yang and
Minyi Guo and
Ram Srivatsa Kannan and
Jason Mars and
Lingjia Tang Prophet: Precise QoS Prediction on
Non-Preemptive Accelerators to Improve
Utilization in Warehouse-Scale Computers 17--32
Svilen Kanev and
Sam Likun Xi and
Gu-Yeon Wei and
David Brooks Mallacc: Accelerating Memory Allocation 33--45
Shasha Wen and
Milind Chabbi and
Xu Liu REDSPY: Exploring Value Locality in
Software . . . . . . . . . . . . . . . . 47--61
Abhishek Bhattacharjee Translation-Triggered Prefetching . . . 63--76
Channoh Kim and
Jaehyeok Kim and
Sungmin Kim and
Dooyoung Kim and
Namho Kim and
Gitae Na and
Young H. Oh and
Hyeon Gyu Cho and
Jae W. Lee Typed Architectures: Architectural
Support for Lightweight Scripting . . . 77--90
Jihye Seo and
Wook-Hee Kim and
Woongki Baek and
Beomseok Nam and
Sam H. Noh Failure-Atomic Slotted Paging for
Persistent Memory . . . . . . . . . . . 91--104
Donald Nguyen and
Keshav Pingali What Scalable Programs Need from
Transactional Memory . . . . . . . . . . 105--118
Caroline Trippel and
Yatin A. Manerkar and
Daniel Lustig and
Michael Pellauer and
Margaret Martonosi TriCheck: Memory Model Verification at
the Trisection of Software, Hardware,
and ISA . . . . . . . . . . . . . . . . 119--133
Sanketh Nalli and
Swapnil Haria and
Mark D. Hill and
Michael M. Swift and
Haris Volos and
Kimberly Keeton An Analysis of Persistent Memory Use
with WHISPER . . . . . . . . . . . . . . 135--148
Tong Zhang and
Changhee Jung and
Dongyoon Lee ProRace: Practical Data Race Detection
for Production Use . . . . . . . . . . . 149--162
Lena E. Olson and
Mark D. Hill and
David A. Wood Crossing Guard: Mediating
Host-Accelerator Coherence Interactions 163--176
Joseph McMahan and
Michael Christensen and
Lawton Nichols and
Jared Roesch and
Sung-Yee Guo and
Ben Hardekopf and
Timothy Sherwood An Architecture Supporting Formal and
Compositional Binary Analysis . . . . . 177--191
Chun-Hung Hsiao and
Satish Narayanasamy and
Essam Muhammad Idris Khan and
Cristiano L. Pereira and
Gilles A. Pokam AsyncClock: Scalable Inference of
Asynchronous Event Causality . . . . . . 193--205
Irina Calciu and
Siddhartha Sen and
Mahesh Balakrishnan and
Marcos K. Aguilera Black-box Concurrent Data Structures for
NUMA Architectures . . . . . . . . . . . 207--221
Keval Vora and
Chen Tian and
Rajiv Gupta and
Ziang Hu CoRAL: Confined Recovery in Distributed
Asynchronous Graph Processing . . . . . 223--236
Keval Vora and
Rajiv Gupta and
Guoqing Xu KickStarter: Fast and Accurate
Computations on Streaming Graphs via
Trimmed Approximations . . . . . . . . . 237--251
Bobby Powers and
John Vilk and
Emery D. Berger Browsix: Bridging the Gap Between Unix
and the Browser . . . . . . . . . . . . 253--266
Samyam Rajbhandari and
Yuxiong He and
Olatunji Ruwase and
Michael Carbin and
Trishul Chilimbi Optimizing CNNs on Multicores for
Scalability, Performance and Goodput . . 267--280
Kirshanthan Sundararajah and
Laith Sakka and
Milind Kulkarni Locality Transformations for Nested
Recursive Iteration Spaces . . . . . . . 281--295
Ang Li and
Shuaiwen Leon Song and
Weifeng Liu and
Xu Liu and
Akash Kumar and
Henk Corporaal Locality-Aware CTA Clustering for Modern
GPUs . . . . . . . . . . . . . . . . . . 297--311
Berkeley Churchill and
Rahul Sharma and
J. F. Bastien and
Alex Aiken Sound Loop Superoptimization for Google
Native Client . . . . . . . . . . . . . 313--326
Ricardo Bianchini Improving Datacenter Efficiency . . . . 327--327
Mengxing Liu and
Mingxing Zhang and
Kang Chen and
Xuehai Qian and
Yongwei Wu and
Weimin Zheng and
Jinglei Ren DudeTM: Building Durable Transactions
with Decoupling for Persistent Memory 329--343
Ana Klimovic and
Heiner Litz and
Christos Kozyrakis ReFlex: Remote Flash $ \approx $ Local
Flash . . . . . . . . . . . . . . . . . 345--359
Djordje Jevdjic and
Karin Strauss and
Luis Ceze and
Henrique S. Malvar Approximate Storage of Compressed and
Encrypted Videos . . . . . . . . . . . . 361--373
Nima Elyasi and
Mohammad Arjomand and
Anand Sivasubramaniam and
Mahmut T. Kandemir and
Chita R. Das and
Myoungsoo Jung Exploiting Intra-Request Slack to
Improve SSD Performance . . . . . . . . 375--388
Kai Wang and
Aftab Hussain and
Zhiqiang Zuo and
Guoqing Xu and
Ardalan Amiri Sani Graspan: a Single-machine Disk-based
Graph System for Interprocedural Static
Analyses of Large-scale Systems Code . . 389--404
Ao Ren and
Zhe Li and
Caiwen Ding and
Qinru Qiu and
Yanzhi Wang and
Ji Li and
Xuehai Qian and
Bo Yuan SC-DCNN: Highly-Scalable Deep
Convolutional Neural Network using
Stochastic Computing . . . . . . . . . . 405--418
Jerry Ajay and
Chen Song and
Aditya Singh Rathore and
Chi Zhou and
Wenyao Xu $3$DGates: an Instruction-Level Energy
Analysis and Optimization of $3$D
Printers . . . . . . . . . . . . . . . . 419--433
Guilherme Cox and
Abhishek Bhattacharjee Efficient Address Translation for
Architectures with Multiple Page Sizes 435--448
Ilya Lesokhin and
Haggai Eran and
Shachar Raindel and
Guy Shapiro and
Sagi Grimberg and
Liran Liss and
Muli Ben-Yehuda and
Nadav Amit and
Dan Tsafrir Page Fault Support for Network
Controllers . . . . . . . . . . . . . . 449--466
Yang Hu and
Mingcong Song and
Tao Li Towards ``Full Containerization'' in
Containerized Network Function
Virtualization . . . . . . . . . . . . . 467--481
Bo Wu and
Xu Liu and
Xiaobo Zhou and
Changjun Jiang FLEP: Enabling Flexible and Efficient
Preemption on GPUs . . . . . . . . . . . 483--496
Kaiwei Li and
Jianfei Chen and
Wenguang Chen and
Jun Zhu SaberLDA: Sparsity-Aware Learning of
Topic Models on GPUs . . . . . . . . . . 497--509
Moein Khazraee and
Lu Zhang and
Luis Vega and
Michael Bedford Taylor Moonwalk: NRE Optimization in ASIC
Clouds . . . . . . . . . . . . . . . . . 511--526
Jason Jong Kyu Park and
Yongjun Park and
Scott Mahlke Dynamic Resource Management for
Efficient Utilization of Multitasking
GPUs . . . . . . . . . . . . . . . . . . 527--540
Rui Zhang and
Natalie Stanley and
Christopher Griggs and
Andrew Chi and
Cynthia Sturton Identifying Security Critical Properties
for the Dynamic Verification of a
Processor . . . . . . . . . . . . . . . 541--554
Andrew Ferraiuolo and
Rui Xu and
Danfeng Zhang and
Andrew C. Myers and
G. Edward Suh Verification of a Practical Hardware
Security Architecture Through Static
Information Flow Analysis . . . . . . . 555--568
David Chisnall and
Brooks Davis and
Khilan Gudka and
David Brazdil and
Alexandre Joannou and
Jonathan Woodruff and
A. Theodore Markettos and
J. Edward Maste and
Robert Norton and
Stacey Son and
Michael Roe and
Simon W. Moore and
Peter G. Neumann and
Ben Laurie and
Robert N. M. Watson CHERI JNI: Sinking the Java Security
Model into the C . . . . . . . . . . . . 569--583
Xinyang Ge and
Weidong Cui and
Trent Jaeger GRIFFIN: Guarding Control Flows Using
Intel Processor Trace . . . . . . . . . 585--598
Christina Delimitrou and
Christos Kozyrakis Bolt: I Know What You Did Last
Summer\ldots In The Cloud . . . . . . . 599--613
Yiping Kang and
Johann Hauswald and
Cao Gao and
Austin Rovinski and
Trevor Mudge and
Jason Mars and
Lingjia Tang Neurosurgeon: Collaborative Intelligence
Between the Cloud and Mobile Edge . . . 615--629
Neha Agarwal and
Thomas F. Wenisch Thermostat: Application-transparent Page
Management for Two-tiered Main Memory 631--644
Antonio Barbalace and
Robert Lyerly and
Christopher Jelesnianski and
Anthony Carno and
Ho-Ren Chuang and
Vincent Legout and
Binoy Ravindran Breaking the Boundaries in
Heterogeneous-ISA Datacenters . . . . . 645--659
Daniel Lustig and
Andrew Wright and
Alexandros Papakonstantinou and
Olivier Giroux Automated Synthesis of Comprehensive
Memory Model Litmus Test Suites . . . . 661--675
Haopeng Liu and
Guangpu Li and
Jeffrey F. Lukman and
Jiaxin Li and
Shan Lu and
Haryadi S. Gunawi and
Chen Tian DCatch: Automatically Detecting
Distributed Concurrency Bugs in Cloud
Systems . . . . . . . . . . . . . . . . 677--691
Ali José Mashtizadeh and
Tal Garfinkel and
David Terei and
David Mazieres and
Mendel Rosenblum Towards Practical Default-On Multi-Core
Record/Replay . . . . . . . . . . . . . 693--708
Jian Huang and
Michael Allen-Bond and
Xuechen Zhang Pallas: Semantic-Aware Checking for
Finding Deep Bugs in Fast Path . . . . . 709--722
Jagadish B. Kotra and
Narges Shahidi and
Zeshan A. Chishti and
Mahmut T. Kandemir Hardware-Software Co-design to Mitigate
DRAM Refresh Overheads: a Case for
Refresh-Aware Process Scheduling . . . . 723--736
Jinchun Kim and
Elvira Teran and
Paul V. Gratz and
Daniel A. Jiménez and
Seth H. Pugsley and
Chris Wilkerson Kill the Program Counter: Reconstructing
Program Behavior in the Processor Cache
Hierarchy . . . . . . . . . . . . . . . 737--749
Mingyu Gao and
Jing Pu and
Xuan Yang and
Mark Horowitz and
Christos Kozyrakis TETRIS: Scalable and Efficient Neural
Network Acceleration with $3$D Memory 751--764
Wonjun Song and
Gwangsun Kim and
Hyungjoon Jung and
Jongwook Chung and
Jung Ho Ahn and
Jae W. Lee and
John Kim History-Based Arbitration for Fairness
in Processor-Interconnect of NUMA
Servers . . . . . . . . . . . . . . . . 765--777
Pulkit A. Misra and
Jeffrey S. Chase and
Johannes Gehrke and
Alvin R. Lebeck Enabling Lightweight Transactions with
Precision Time . . . . . . . . . . . . . 779--794
Ming Liu and
Liang Luo and
Jacob Nelson and
Luis Ceze and
Arvind Krishnamurthy and
Kishore Atreya IncBricks: Toward In-Network Computation
with an In-Network Cache . . . . . . . . 795--809
Ismail Akturk and
Ulya R. Karpuzcu AMNESIAC: Amnesic Automatic Computer . . 811--824
Yuxin Bai and
Victor W. Lee and
Engin Ipek Voltage Regulator Efficiency Aware Power
Management . . . . . . . . . . . . . . . 825--838
Thomas S. Heinze and
Anders Mòller and
Fabio Strocco Type safety analysis for Dart . . . . . 1--12
Gianluca Mezzetti and
Anders Mòller and
Fabio Strocco Type unsoundness in practice: an
empirical study of Dart . . . . . . . . 13--24
Changhee Park and
Hyeonseung Im and
Sukyoung Ryu Precise and scalable static analysis of
jQuery using a regular expression domain 25--36
Mattias De Wael and
Janwillem Swalens and
Wolfgang De Meuter Just-in-time inheritance: a dynamic and
implicit multiple inheritance mechanism 37--47
Remigius Meier and
Armin Rigo and
Thomas R. Gross Parallel virtual machines with RPython 48--59
Guido Chari and
Diego Garbervetsky and
Stefan Marr Building efficient and highly run-time
adaptable virtual machines . . . . . . . 60--71
Vincent Foley-Bourgon and
Laurie Hendren Efficiently implementing the copy
semantics of MATLAB's arrays in
JavaScript . . . . . . . . . . . . . . . 72--83
Lukas Stadler and
Adam Welc and
Christian Humer and
Mick Jordan Optimizing R language execution via
aggressive speculation . . . . . . . . . 84--95
Jason Hemann and
Daniel P. Friedman and
William E. Byrd and
Matthew Might A small embedding of logic programming
with a simple complete search . . . . . 96--107
Alessandro Warth and
Patrick Dubroy and
Tony Garnock-Jones Modular semantic actions . . . . . . . . 108--119
Stefan Marr and
Benoit Daloze and
Hanspeter Mössenböck Cross-language compiler benchmarking:
are we fast yet? . . . . . . . . . . . . 120--131
Tiark Rompf Lightweight modular staging (LMS):
generate all the things! (keynote) . . . 1--1
Aggelos Biboudis and
Pablo Inostroza and
Tijs van der Storm Recaf: Java dialects as libraries . . . 2--13
Yanlin Wang and
Haoyuan Zhang and
Bruno C. d. S. Oliveira and
Marco Servetto Classless Java . . . . . . . . . . . . . 14--24
Theologos Zacharopoulos and
Pablo Inostroza and
Tijs van der Storm Extensible modeling with managed data in
Java . . . . . . . . . . . . . . . . . . 25--35
Andrea Ros\`a and
Lydia Y. Chen and
Walter Binder Actor profiling in virtual execution
environments . . . . . . . . . . . . . . 36--46
Gabriël Konat and
Sebastian Erdweg and
Eelco Visser Bootstrapping domain-specific
meta-languages in language workbenches 47--58
Laure Philips and
Joeri De Koster and
Wolfgang De Meuter and
Coen De Roover Dependence-driven delimited CPS
transformation for JavaScript . . . . . 59--69
Mina Lee and
Sunbeom So and
Hakjoo Oh Synthesizing regular expressions from
examples for introductory automata
assignments . . . . . . . . . . . . . . 70--80
Cyrus Omar and
Jonathan Aldrich Programmable semantic fragments: the
design and implementation of typy . . . 81--92
Jörg Kienzle and
Gunter Mussbacher and
Philippe Collet and
Omar Alam Delaying decisions in variable concern
hierarchies . . . . . . . . . . . . . . 93--103
Sorin Adam and
Marco Kuhrmann and
Ulrik Pagh Schultz Automatic code generation in practice:
experiences with embedded robot
controllers . . . . . . . . . . . . . . 104--108
Larissa Braz and
Rohit Gheyi and
Melina Mongiovi and
Márcio Ribeiro and
Flávio Medeiros and
Leopoldo Teixeira A change-centric approach to compile
configurable systems with #ifdefs . . . 109--119
Juliana Alves Pereira and
Pawel Matuszyk and
Sebastian Krieter and
Myra Spiliopoulou and
Gunter Saake A feature-based personalized recommender
system for product-line configuration 120--131
Matthias Kowal and
Sofia Ananieva and
Thomas Thüm Explaining anomalies in feature models 132--143
Mustafa Al-Hajjaji and
Sebastian Krieter and
Thomas Thüm and
Malte Lochau and
Gunter Saake IncLing: efficient product-line testing
using incremental pairwise sampling . . 144--155
Valentin Rothberg and
Christian Dietrich and
Andreas Ziegler and
Daniel Lohmann Towards scalable configuration testing
in variable software . . . . . . . . . . 156--167
Michael J. Steindorfer and
Jurgen J. Vinju Towards a software product line of
trie-based collections . . . . . . . . . 168--172
Mustafa Al-Hajjaji and
Jens Meinicke and
Sebastian Krieter and
Reimar Schröter and
Thomas Thüm and
Thomas Leich and
Gunter Saake Tool demo: testing configurable systems
with FeatureIDE . . . . . . . . . . . . 173--177
Majid Makki and
Dimitri Van Landuyt and
Wouter Joosen Automated regression testing of BPMN 2.0
processes: a capture and replay
framework for continuous delivery . . . 178--189
Matthew A. Hammer and
Bor-Yuh Evan Chang and
David Van Horn A vision for online
verification-validation . . . . . . . . 190--201
Mohamed Boussaa and
Olivier Barais and
Benoit Baudry and
Gerson Sunyé Automatic non-functional testing of code
generators families . . . . . . . . . . 202--212
Martín Abadi TensorFlow: learning functions at scale 1--1
Sukyoung Ryu Journey to find bugs in JavaScript web
applications in the wild . . . . . . . . 2--2
Dan Licata A functional programmer's guide to
homotopy type theory . . . . . . . . . . 3--3
David Castro and
Kevin Hammond and
Susmit Sarkar Farms, pipes, streams and reforestation:
reasoning about structured parallel
processes using types and hylomorphisms 4--17
Umut A. Acar and
Arthur Charguéraud and
Mike Rainey and
Filip Sieczkowski Dag-calculus: a calculus for parallel
computation . . . . . . . . . . . . . . 18--32
Johannes Borgström and
Ugo Dal Lago and
Andrew D. Gordon and
Marcin Szymczak A lambda-calculus foundation for
universal probabilistic programming . . 33--46
Wazim Mohammed Ismail and
Chung-chieh Shan Deriving a probability density
calculator (functional pearl) . . . . . 47--59
Yong Kiam Tan and
Magnus O. Myreen and
Ramana Kumar and
Anthony Fox and
Scott Owens and
Michael Norrish A new verified compiler backend for
CakeML . . . . . . . . . . . . . . . . . 60--73
Paul Downen and
Luke Maurer and
Zena M. Ariola and
Simon Peyton Jones Sequent calculus as a compiler
intermediate language . . . . . . . . . 74--88
Liam O'Connor and
Zilin Chen and
Christine Rizkallah and
Sidney Amani and
Japheth Lim and
Toby Murray and
Yutaka Nagashima and
Thomas Sewell and
Gerwin Klein Refinement through restraint: bringing
down the cost of verification . . . . . 89--102
Max S. New and
William J. Bowman and
Amal Ahmed Fully abstract compilation via universal
embedding . . . . . . . . . . . . . . . 103--116
Christos Dimoulas and
Max S. New and
Robert Bruce Findler and
Matthias Felleisen Oh Lord, please don't let contracts be
misunderstood (functional pearl) . . . . 117--131
Ezgi Çiçek and
Zoe Paraskevopoulou and
Deepak Garg A type theory for incremental
computational complexity with control
flow changes . . . . . . . . . . . . . . 132--145
Kotaro Takeda and
Naoki Kobayashi and
Kazuya Yaguchi and
Ayumi Shinohara Compact bit encoding schemes for
simply-typed lambda-terms . . . . . . . 146--157
Shin-Cheng Mu and
Yu-Hsi Chiang and
Yu-Han Lyu Queueing and glueing for optimal
partitioning (functional pearl) . . . . 158--167
Jan Christiansen and
Nikita Danilenko and
Sandra Dylus All sorts of permutations (functional
pearl) . . . . . . . . . . . . . . . . . 168--179
Manuel Serrano and
Vincent Prunet A glimpse of Hopjs . . . . . . . . . . . 180--192
Ilya Sergey Experience report: growing and shrinking
polygons for random testing of
computational geometry algorithms . . . 193--199
Kento Emoto and
Kiminori Matsuzaki and
Zhenjiang Hu and
Akimasa Morihata and
Hideya Iwasaki Think like a vertex, behave like a
function! A functional DSL for
vertex-centric big graph processing . . 200--213
Michael Arntzenius and
Neelakantan R. Krishnaswami Datafun: a functional Datalog . . . . . 214--227
Eric L. Seidel and
Ranjit Jhala and
Westley Weimer Dynamic witnesses for static type errors
(or, ill-typed programs usually go
wrong) . . . . . . . . . . . . . . . . . 228--242
Keiichi Watanabe and
Ryosuke Sato and
Takeshi Tsukada and
Naoki Kobayashi Automatically disproving fair
termination of higher-order functional
programs . . . . . . . . . . . . . . . . 243--255
Ralf Jung and
Robbert Krebbers and
Lars Birkedal and
Derek Dreyer Higher-order ghost state . . . . . . . . 256--269
Jesper Cockx and
Dominique Devriese and
Frank Piessens Unifiers as equivalences: proof-relevant
unification of dependently typed data 270--283
David Christiansen and
Edwin Brady Elaborator reflection: extending Idris
in Idris . . . . . . . . . . . . . . . . 284--297
Pierre-Evariste Dagand and
Nicolas Tabareau and
Éric Tanter Partial type equivalences for verified
dependent interoperability . . . . . . . 298--310
David Darais and
David Van Horn Constructive Galois connections: taming
the Galois connection framework for
mechanized metatheory . . . . . . . . . 311--324
Sandrine Blazy and
Vincent Laporte and
David Pichardie An abstract memory functor for verified
C static analyzers . . . . . . . . . . . 325--337
Trevor L. McDonell and
Timothy A. K. Zakian and
Matteo Cimini and
Ryan R. Newton Ghostbuster: a tool for simplifying and
converting GADTs . . . . . . . . . . . . 338--350
David Thibodeau and
Andrew Cave and
Brigitte Pientka Indexed codata types . . . . . . . . . . 351--363
Bruno C. d. S. Oliveira and
Zhiyuan Shi and
João Alpuim Disjoint intersection types . . . . . . 364--377
Giuseppe Castagna and
Tommaso Petrucciani and
Kim Nguy\~ên Set-theoretic types for polymorphic
variants . . . . . . . . . . . . . . . . 378--391
Ram Raghunathan and
Stefan K. Muller and
Umut A. Acar and
Guy Blelloch Hierarchical memory management for
parallel programs . . . . . . . . . . . 392--406
Thomas Gilray and
Michael D. Adams and
Matthew Might Allocation characterizes polyvariance: a
unified methodology for polyvariant
control-flow analysis . . . . . . . . . 407--420
Katsuhiro Ueno and
Atsushi Ohori A fully concurrent garbage collector for
functional programs on multicore
processors . . . . . . . . . . . . . . . 421--433
Sam Lindley and
J. Garrett Morris Talking bananas: structural recursion
for session types . . . . . . . . . . . 434--447
J. Garrett Morris The best of both worlds: linear
functional programming without
compromise . . . . . . . . . . . . . . . 448--461
Peter Thiemann and
Vasco T. Vasconcelos Context-free session types . . . . . . . 462--475
Marco Gaboardi and
Shin-ya Katsumata and
Dominic Orchard and
Flavien Breuvart and
Tarmo Uustalu Combining effects and coeffects via
grading . . . . . . . . . . . . . . . . 476--489
Maciej Piróg and
Nicolas Wu String diagrams for free monads
(functional pearl) . . . . . . . . . . . 490--501
April W. Wade and
Prasad A. Kulkarni and
Michael R. Jantz AOT vs. JIT: impact of profile data on
code quality . . . . . . . . . . . . . . 1--10
Ben Taylor and
Vicent Sanz Marco and
Zheng Wang Adaptive optimization for OpenCL
programs on embedded heterogeneous
systems . . . . . . . . . . . . . . . . 11--20
Oliver Reiche and
Christof Kobylko and
Frank Hannig and
Jürgen Teich Auto-vectorization for image processing
DSLs . . . . . . . . . . . . . . . . . . 21--30
Sheng-Yu Fu and
Ding-Yong Hong and
Yu-Ping Liu and
Jan-Jan Wu and
Wei-Chung Hsu Dynamic translation of structured
Loads/Stores and register mapping for
architectures with SIMD extensions . . . 31--40
Weiwen Jiang and
Edwin H.-M. Sha and
Qingfeng Zhuge and
Hailiang Dong and
Xianzhang Chen Optimal functional unit assignment and
voltage selection for pipelined MPSoC
with guaranteed probability on time
performance . . . . . . . . . . . . . . 41--50
Gyeongmin Lee and
Seonyeong Heo and
Bongjun Kim and
Jong Kim and
Hanjun Kim Integrated IoT programming with
selective abstraction . . . . . . . . . 51--60
Min Zhang and
Yunhui Ying Towards SMT-based LTL model checking of
clock constraint specification language
for real-time and embedded systems . . . 61--70
Wenguang Zheng and
Hui Wu and
Chuanyao Nie Integrating task scheduling and cache
locking for multicore real-time embedded
systems . . . . . . . . . . . . . . . . 71--80
Yi Wang and
Mingxu Zhang and
Jing Yang Towards memory-efficient
processing-in-memory architecture for
convolutional neural networks . . . . . 81--90
Xianzhong Ding and
Zhiyong Zhang and
Zhiping Jia and
Lei Ju and
Mengying Zhao and
Huawei Huang Unified nvTCAM and sTCAM architecture
for improving packet matching
performance . . . . . . . . . . . . . . 91--100
Chen Pan and
Mimi Xie and
Yongpan Liu and
Yanzhi Wang and
Chun Jason Xue and
Yuangang Wang and
Yiran Chen and
Jingtong Hu A lightweight progress maximization
scheduler for non-volatile processor
under unstable energy harvesting . . . . 101--110
Christian Dietrich and
Daniel Lohmann OSEK-V: application-specific RTOS
instantiation in hardware . . . . . . . 111--120
Sreepathi Pai and
Keshav Pingali A compiler for throughput optimization
of graph algorithms on GPUs . . . . . . 1--19
Rishi Surendran and
Vivek Sarkar Automatic parallelization of pure method
calls via conditional future synthesis 20--38
Tyler Sorensen and
Alastair F. Donaldson and
Mark Batty and
Ganesh Gopalakrishnan and
Zvonimir Rakamari\'c Portable inter-workgroup barrier
synchronisation for GPUs . . . . . . . . 39--58
Sébastien Doeraene and
Tobias Schlatter Parallel incremental whole-program
optimizations for Scala.js . . . . . . . 59--73
Andrei Stefanescu and
Daejun Park and
Shijiao Yuwen and
Yilong Li and
Grigore Rosu Semantics-based program verifiers for
all languages . . . . . . . . . . . . . 74--91
Ilya Sergey and
Aleksandar Nanevski and
Anindya Banerjee and
Germán Andrés Delbianco Hoare-style specifications as
correctness conditions for
non-linearizable concurrent objects . . 92--110
Kyndylan Nienhuis and
Kayvan Memarian and
Peter Sewell An operational semantics for C/C++11
concurrency . . . . . . . . . . . . . . 111--128
Andrei Marian Dan and
Patrick Lam and
Torsten Hoefler and
Martin Vechev Modeling and analysis of remote memory
access programming . . . . . . . . . . . 129--144
Shachar Itzhaky and
Rohit Singh and
Armando Solar-Lezama and
Kuat Yessenov and
Yongquan Lu and
Charles Leiserson and
Rezaul Chowdhury Deriving divide-and-conquer dynamic
programming algorithms using
solver-aided transformations . . . . . . 145--164
Venkatesh Srinivasan and
Tushar Sharma and
Thomas Reps Speeding up machine-code synthesis . . . 165--180
Pavel Panchekha and
Emina Torlak Automated reasoning for web page layout 181--194
Xinyu Wang and
Sumit Gulwani and
Rishabh Singh FIDEX: filtering spreadsheet data using
examples . . . . . . . . . . . . . . . . 195--213
Scott Moore and
Christos Dimoulas and
Robert Bruce Findler and
Matthew Flatt and
Stephen Chong Extensible access control with
authorization contracts . . . . . . . . 214--233
Leo Osvald and
Grégory Essertel and
Xilun Wu and
Lilliam I. González Alayón and
Tiark Rompf Gentrification gone too far? Affordable
2nd-class values for fun and (co-)effect 234--251
Jonathan DiLorenzo and
Richard Zhang and
Erin Menzies and
Kathleen Fisher and
Nate Foster Incremental forest: a DSL for
efficiently managing filestores . . . . 252--271
Philipp Haller and
Alex Loiko LaCasa: lightweight affinity and object
capabilities in Scala . . . . . . . . . 272--291
Santiago Perez De Rosso and
Daniel Jackson Purposes, concepts, misfits, and a
redesign of git . . . . . . . . . . . . 292--310
Dohyeong Kim and
Yonghwi Kwon and
Peng Liu and
I. Luk Kim and
David Mitchel Perry and
Xiangyu Zhang and
Gustavo Rodriguez-Rivera Apex: automatic programming assignment
error explanation . . . . . . . . . . . 311--327
Oliver Hanappi and
Waldemar Hummer and
Schahram Dustdar Asserting reliable convergence for
configuration management scripts . . . . 328--343
Sean Treichler and
Michael Bauer and
Rahul Sharma and
Elliott Slaughter and
Alex Aiken Dependent partitioning . . . . . . . . . 344--358
Sulekha Kulkarni and
Ravi Mangal and
Xin Zhang and
Mayur Naik Accelerating program analyses by
cross-program training . . . . . . . . . 359--377
Venkatesh Srinivasan and
Thomas Reps An improved algorithm for slicing
machine code . . . . . . . . . . . . . . 378--393
Dmitry Petrashko and
Vlad Ureche and
Ondrej Lhoták and
Martin Odersky Call graphs for languages with
parametric polymorphism . . . . . . . . 394--409
Satish Chandra and
Colin S. Gordon and
Jean-Baptiste Jeannin and
Cole Schlesinger and
Manu Sridharan and
Frank Tip and
Youngil Choi Type inference for static compilation of
JavaScript . . . . . . . . . . . . . . . 410--429
Malavika Samak and
Omer Tripp and
Murali Krishna Ramanathan Directed synthesis of failing concurrent
executions . . . . . . . . . . . . . . . 430--446
Shiyou Huang and
Jeff Huang Maximal causality reduction for TSO and
PSO . . . . . . . . . . . . . . . . . . 447--461
Jeff Huang and
Arun K. Rajagopalan Precise and maximal race detection from
incomplete traces . . . . . . . . . . . 462--476
Ben Blum and
Garth Gibson Stateless model checking with data-race
preemption points . . . . . . . . . . . 477--493
Anitha Gollamudi and
Stephen Chong Automatic enforcement of expressive
security policies using enclaves . . . . 494--513
Alexei Colin and
Brandon Lucia Chain: tasks and channels for reliable
intermittent programs . . . . . . . . . 514--530
Daniele Bonetta and
Luca Salucci and
Stefan Marr and
Walter Binder GEMs: shared-memory parallel programming
for Node.js . . . . . . . . . . . . . . 531--547
Arthur Michener Peters and
David Kitchin and
John A. Thywissen and
William R. Cook OrcO: a concurrency-first approach to
objects . . . . . . . . . . . . . . . . 548--567
Davide Ancona and
Andrea Corradi Semantic subtyping for imperative
object-oriented languages . . . . . . . 568--587
Jonathan Immanuel Brachthäuser and
Tillmann Rendel and
Klaus Ostermann Parsing with first-class derivatives . . 588--606
Stephen Kell and
Dominic P. Mulligan and
Peter Sewell The missing link: explaining ELF static
linking, semantically . . . . . . . . . 607--623
Tiark Rompf and
Nada Amin Type soundness for dependent object
types (DOT) . . . . . . . . . . . . . . 624--641
Benoit Daloze and
Stefan Marr and
Daniele Bonetta and
Hanspeter Mössenböck Efficient and thread-safe objects for
dynamically-typed languages . . . . . . 642--659
Keith Chapman and
Antony L. Hosking and
J. Eliot B. Moss Hybrid STM/HTM for nested transactions
on OpenJDK . . . . . . . . . . . . . . . 660--676
Kumud Bhandari and
Dhruva R. Chakrabarti and
Hans-J. Boehm Makalu: fast recoverable allocation of
non-volatile memory . . . . . . . . . . 677--694
Diogenes Nunez and
Samuel Z. Guyer and
Emery D. Berger Prioritized garbage collection: explicit
GC support for software caches . . . . . 695--710
Friedrich Steimann and
Jörg Hagemann and
Bastian Ulke Computing repair alternatives for
malformed programs using constraint
attribute grammars . . . . . . . . . . . 711--730
Veselin Raychev and
Pavol Bielik and
Martin Vechev Probabilistic model for code with
decision trees . . . . . . . . . . . . . 731--747
Shaon Barman and
Sarah Chasins and
Rastislav Bodik and
Sumit Gulwani Ringer: web automation by demonstration 748--764
Konstantin Weitz and
Doug Woos and
Emina Torlak and
Michael D. Ernst and
Arvind Krishnamurthy and
Zachary Tatlock Scalable verification of Border Gateway
Protocol configurations with an SMT
solver . . . . . . . . . . . . . . . . . 765--780
Calvin Loncaric and
Satish Chandra and
Cole Schlesinger and
Manu Sridharan A practical framework for type inference
error explanation . . . . . . . . . . . 781--799
Stephen Kell Dynamically diagnosing type errors in
unsafe code . . . . . . . . . . . . . . 800--819
Yuheng Long and
Yu David Liu and
Hridesh Rajan First-class effect reflection for
effect-guided programming . . . . . . . 820--837
Nada Amin and
Ross Tate Java and Scala's type systems are
unsound: the existential crisis of null
pointers . . . . . . . . . . . . . . . . 838--848
Chengnian Sun and
Vu Le and
Zhendong Su Finding compiler bugs via live code
mutation . . . . . . . . . . . . . . . . 849--863
Zhiyong Shan and
Tanzirul Azim and
Iulian Neamtiu Finding resume and restart errors in
Android applications . . . . . . . . . . 864--880
Zhiqiang Zuo and
Lu Fang and
Siau-Cheng Khoo and
Guoqing Xu and
Shan Lu Low-overhead and fully automated
statistical debugging with abstraction
refinement . . . . . . . . . . . . . . . 881--896
Rohan Bavishi and
Awanish Pandey and
Subhajit Roy To be precise: regression aware
debugging . . . . . . . . . . . . . . . 897--915
Jonathan Lifflander and
Sriram Krishnamoorthy Cache locality optimization for
recursive programs . . . . . . . . . . . 1--16
Olli Saarikivi and
Margus Veanes and
Todd Mytkowicz and
Madan Musuvathi Fusing effectful comprehensions . . . . 17--32
Yufei Ding and
Lin Ning and
Hui Guan and
Xipeng Shen Generalizations of the theory and
deployment of triangular inequality for
compiler-based strength reduction . . . 33--48
David Menendez and
Santosh Nagarakatte Alive-Infer: data-driven precondition
inference for peephole optimizations in
LLVM . . . . . . . . . . . . . . . . . . 49--63
Kuat Yessenov and
Ivan Kuraj and
Armando Solar-Lezama DemoMatch: API discovery from
demonstrations . . . . . . . . . . . . . 64--78
Yaniv David and
Nimrod Partush and
Eran Yahav Similarity of binaries through
re-optimization . . . . . . . . . . . . 79--94
Osbert Bastani and
Rahul Sharma and
Alex Aiken and
Percy Liang Synthesizing program input grammars . . 95--110
Daniel Huang and
Jean-Baptiste Tristan and
Greg Morrisett Compiling Markov chain Monte Carlo
algorithms for probabilistic modeling 111--125
Ariel Eizenberg and
Yuanfeng Peng and
Toma Pigli and
William Mansky and
Joseph Devietti BARRACUDA: binary-level analysis of
runtime RAces in CUDA programs . . . . . 126--140
Dustin Rhodes and
Cormac Flanagan and
Stephen N. Freund BigFoot: static check placement for
dynamic race detection . . . . . . . . . 141--156
Dileep Kini and
Umang Mathur and
Mahesh Viswanathan Dynamic race prediction in linear time 157--170
Marina Billes and
Anders Mòller and
Michael Pradel Systematic black-box analysis of
collaborative web applications . . . . . 171--184
Andreas Haas and
Andreas Rossberg and
Derek L. Schuff and
Ben L. Titzer and
Michael Holman and
Dan Gohman and
Luke Wagner and
Alon Zakai and
J. F. Bastien Bringing the web up to speed with
WebAssembly . . . . . . . . . . . . . . 185--200
Dmitry Petrashko and
Ondrej Lhoták and
Martin Odersky Miniphases: compilation using modular
and efficient tree transformations . . . 201--216
Anthony Canino and
Yu David Liu Proactive and adaptive energy-aware
programming with mixed typechecking . . 217--232
Piyus Kedia and
Manuel Costa and
Matthew Parkinson and
Kapil Vaswani and
Dimitrios Vytiniotis and
Aaron Blankstein Simple, fast, and safe manual memory
management . . . . . . . . . . . . . . . 233--247
Zachary Kincaid and
Jason Breck and
Ashkan Forouhi Boroujeni and
Thomas Reps Compositional recurrence analysis
revisited . . . . . . . . . . . . . . . 248--262
Rei Thiessen and
Ondrej Lhoták Context transformations for pointer
analysis . . . . . . . . . . . . . . . . 263--277
Tian Tan and
Yue Li and
Jingling Xue Efficient and precise points-to
analysis: modeling the heap by merging
equivalent automata . . . . . . . . . . 278--291
Anirudh Santhiar and
Aditya Kanade Static deadlock detection for
asynchronous C# programs . . . . . . . . 292--305
Zhoulai Fu and
Zhendong Su Achieving high coverage for
floating-point code via unconstrained
programming . . . . . . . . . . . . . . 306--319
Buddhika Chamith and
Bo Joel Svensson and
Luke Dalessandro and
Ryan R. Newton Instruction punning: lightweight
instrumentation for x86-64 . . . . . . . 320--332
Amanieu D'Antras and
Cosmin Gorgovan and
Jim Garside and
Mikel Luján Low overhead dynamic binary translation
on ARM . . . . . . . . . . . . . . . . . 333--346
Qirun Zhang and
Chengnian Sun and
Zhendong Su Skeletal program enumeration for
rigorous compiler testing . . . . . . . 347--361
Timos Antonopoulos and
Paul Gazzillo and
Michael Hicks and
Eric Koskinen and
Tachio Terauchi and
Shiyi Wei Decomposition instead of
self-composition for proving the absence
of timing channels . . . . . . . . . . . 362--375
Qinheping Hu and
Loris D'Antoni Automatic program inversion using
symbolic transducers . . . . . . . . . . 376--389
Peter Ohmann and
Alexander Brooks and
Loris D'Antoni and
Ben Liblit Control-flow recovery from partial
failure reports . . . . . . . . . . . . 390--405
Goran Doychev and
Boris Köpf Rigorous analysis of software
countermeasures against cache attacks 406--421
Yu Feng and
Ruben Martins and
Jacob Van Geffen and
Isil Dillig and
Swarat Chaudhuri Component-based synthesis of table
consolidation and transformation tasks
from examples . . . . . . . . . . . . . 422--436
Ryan Beckett and
Ratul Mahajan and
Todd Millstein and
Jitendra Padhye and
David Walker Network configuration synthesis with
abstract topologies . . . . . . . . . . 437--451
Chenglong Wang and
Alvin Cheung and
Rastislav Bodik Synthesizing highly expressive SQL
queries from input-output examples . . . 452--466
James Bornholt and
Emina Torlak Synthesizing memory models from
framework sketches and Litmus tests . . 467--481
Luke Maurer and
Paul Downen and
Zena M. Ariola and
Simon Peyton Jones Compiling without continuations . . . . 482--494
Daniel Patterson and
Jamie Perconti and
Christos Dimoulas and
Amal Ahmed FunTAL: reasonably mixing a functional
language with assembly . . . . . . . . . 495--509
Shumo Chu and
Konstantin Weitz and
Alvin Cheung and
Dan Suciu HoTTSQL: proving query rewrites with
univalent SQL semantics . . . . . . . . 510--524
Richard A. Eisenberg and
Simon Peyton Jones Levity polymorphism . . . . . . . . . . 525--539
Azadeh Farzan and
Victor Nicolet Synthesis of divide and conquer
parallelism for loops . . . . . . . . . 540--555
Troels Henriksen and
Niels G. W. Serup and
Martin Elsman and
Fritz Henglein and
Cosmin E. Oancea Futhark: purely functional
GPU-programming with nested parallelism
and in-place array updates . . . . . . . 556--571
Grigory Fedyukovich and
Maaz Bin Safeer Ahmad and
Rastislav Bodik Gradual synthesis for static
parallelization of single-pass
array-processing programs . . . . . . . 572--585
Timothy Bourke and
Lélio Brun and
Pierre-Évariste Dagand and
Xavier Leroy and
Marc Pouzet and
Lionel Rieg A formally verified compiler for Lustre 586--601
Parosh Aziz Abdulla and
Mohamed Faouzi Atig and
Yu-Fang Chen and
Bui Phi Diep and
Lukás Holík and
Ahmed Rezine and
Philipp Rümmer Flatten and conquer: a framework for
efficient analysis of string constraints 602--617
Ori Lahav and
Viktor Vafeiadis and
Jeehoon Kang and
Chung-Kil Hur and
Derek Dreyer Repairing sequential consistency in
C/C++11 . . . . . . . . . . . . . . . . 618--632
Juneyoung Lee and
Yoonseung Kim and
Youngju Song and
Chung-Kil Hur and
Sanjoy Das and
David Majnemer and
John Regehr and
Nuno P. Lopes Taming undefined behavior in LLVM . . . 633--647
Scott Schneider and
Kun-Lung Wu Low-synchronization, mostly lock-free,
elastic scheduling for streaming
runtimes . . . . . . . . . . . . . . . . 648--661
Thomas Würthinger and
Christian Wimmer and
Christian Humer and
Andreas Wöß and
Lukas Stadler and
Chris Seaton and
Gilles Duboscq and
Doug Simon and
Matthias Grimmer Practical partial evaluation for
high-performance dynamic language
runtimes . . . . . . . . . . . . . . . . 662--676
Stefan K. Muller and
Umut A. Acar and
Robert Harper Responsive parallel computation:
bridging competitive and cooperative
threading . . . . . . . . . . . . . . . 677--692
Konstantinos Mamouras and
Mukund Raghothaman and
Rajeev Alur and
Zachary G. Ives and
Sanjeev Khanna StreamQRE: modular specification and
efficient evaluation of quantitative
queries over streaming data . . . . . . 693--708
Stephanie Weirich The influence of dependent types
(keynote) . . . . . . . . . . . . . . . 1--1
Aaron Turon Rust: from POPL to practice (keynote) 2--2
Jade Alglave and
Patrick Cousot Ogre and Pythia: an invariance proof
method for weak consistency models . . . 3--18
Kimball Germane and
Matthew Might A posteriori environment analysis with
Pushdown Delta CFA . . . . . . . . . . . 19--31
Huisong Li and
François Berenger and
Bor-Yuh Evan Chang and
Xavier Rival Semantic-directed clumping of
disjunctive abstract states . . . . . . 32--45
Gagandeep Singh and
Markus Püschel and
Martin Vechev Fast polyhedra abstract domain . . . . . 46--59
Stephen Dolan and
Alan Mycroft Polymorphism, subtyping, and type
inference in MLsub . . . . . . . . . . . 60--72
Radu Grigore Java generics are Turing complete . . . 73--85
Cyrus Omar and
Ian Voysey and
Michael Hilton and
Jonathan Aldrich and
Matthew A. Hammer Hazelnut: a bidirectionally typed
structure editor calculus . . . . . . . 86--99
Karl Crary Modules, abstraction, and parametric
polymorphism . . . . . . . . . . . . . . 100--113
Leonidas Lampropoulos and
Diane Gallois-Wong and
Catalin Hritcu and
John Hughes and
Benjamin C. Pierce and
Li-yao Xia Beginner's luck: a language for
property-based generators . . . . . . . 114--129
Chung-chieh Shan and
Norman Ramsey Exact Bayesian inference by symbolic
disintegration . . . . . . . . . . . . . 130--144
Krishnendu Chatterjee and
Petr Novotný and
\Ethorde Zikeli\'c Stochastic invariants for probabilistic
termination . . . . . . . . . . . . . . 145--160
Gilles Barthe and
Benjamin Grégoire and
Justin Hsu and
Pierre-Yves Strub Coupling proofs are probabilistic
product programs . . . . . . . . . . . . 161--174
Jeehoon Kang and
Chung-Kil Hur and
Ori Lahav and
Viktor Vafeiadis and
Derek Dreyer A promising semantics for relaxed-memory
concurrency . . . . . . . . . . . . . . 175--189
John Wickerson and
Mark Batty and
Tyler Sorensen and
George A. Constantinides Automatically comparing memory
consistency models . . . . . . . . . . . 190--204
Robbert Krebbers and
Amin Timany and
Lars Birkedal Interactive proofs in higher-order
concurrent separation logic . . . . . . 205--217
Morten Krogh-Jespersen and
Kasper Svendsen and
Lars Birkedal A relational model of types-and-effects
in higher-order concurrent separation
logic . . . . . . . . . . . . . . . . . 218--231
Loris D'Antoni and
Margus Veanes Monadic second-order logic on finite
sequences . . . . . . . . . . . . . . . 232--245
Naoki Kobayashi and
Étienne Lozes and
Florian Bruse On the relationship between higher-order
recursion schemes and higher-order
fixpoint logic . . . . . . . . . . . . . 246--259
Laura Kovács and
Simon Robillard and
Andrei Voronkov Coming to terms with quantified
reasoning . . . . . . . . . . . . . . . 260--270
Ziv Scully and
Adam Chlipala A program optimization for automatic
database result caching . . . . . . . . 271--284
Oleg Kiselyov and
Aggelos Biboudis and
Nick Palladinos and
Yannis Smaragdakis Stream fusion, to completeness . . . . . 285--299
Wei-Fan Chiang and
Mark Baranowski and
Ian Briggs and
Alexey Solovyev and
Ganesh Gopalakrishnan and
Zvonimir Rakamari\'c Rigorous floating-point mixed-precision
tuning . . . . . . . . . . . . . . . . . 300--315
Ezgi Çiçek and
Gilles Barthe and
Marco Gaboardi and
Deepak Garg and
Jan Hoffmann Relational cost analysis . . . . . . . . 316--329
Ravichandhran Madhavan and
Sumith Kulal and
Viktor Kuncak Contract-based resource verification for
higher-order functions with memoization 330--343
Qirun Zhang and
Zhendong Su Context-sensitive data-dependence
analysis via linear conjunctive language
reachability . . . . . . . . . . . . . . 344--358
Jan Hoffmann and
Ankush Das and
Shu-Chun Weng Towards automatic resource bound
analysis for OCaml . . . . . . . . . . . 359--373
Gabriel Scherer Deciding equivalence with sums and the
empty type . . . . . . . . . . . . . . . 374--386
Danko Ilik The exp--log normal form of types:
decomposing extensional equality and
representing terms compactly . . . . . . 387--399
Paul Blain Levy Contextual isomorphisms . . . . . . . . 400--414
Matt Brown and
Jens Palsberg Typed self-evaluation via intensional
type functions . . . . . . . . . . . . . 415--428
Shaked Flur and
Susmit Sarkar and
Christopher Pulte and
Kyndylan Nienhuis and
Luc Maranget and
Kathryn E. Gray and
Ali Sezgin and
Mark Batty and
Peter Sewell Mixed-size concurrency: ARM, POWER,
C/C++11, and SC . . . . . . . . . . . . 429--442
Christopher Lidbury and
Alastair F. Donaldson Dynamic race detection for C++11 . . . . 443--457
Lucas Brutschy and
Dimitar Dimitrov and
Peter Müller and
Martin Vechev Serializability for eventual
consistency: criterion, analysis, and
applications . . . . . . . . . . . . . . 458--472
Jochen Hoenicke and
Rupak Majumdar and
Andreas Podelski Thread modularity at many levels: a
pearl in compositional verification . . 473--485
Daan Leijen Type directed compilation of row-typed
algebraic effects . . . . . . . . . . . 486--499
Sam Lindley and
Conor McBride and
Craig McLaughlin Do be do be do . . . . . . . . . . . . . 500--514
Danel Ahman and
Catalin Hritcu and
Kenji Maillard and
Guido Martínez and
Gordon Plotkin and
Jonathan Protzenko and
Aseem Rastogi and
Nikhil Swamy Dijkstra monads for free . . . . . . . . 515--529
Taro Sekiyama and
Atsushi Igarashi Stateful manifest contracts . . . . . . 530--544
Arthur Azevedo de Amorim and
Marco Gaboardi and
Justin Hsu and
Shin-ya Katsumata and
Ikram Cherigui A semantic account of metric
preservation . . . . . . . . . . . . . . 545--556
Steffen Smolka and
Praveen Kumar and
Nate Foster and
Dexter Kozen and
Alexandra Silva Cantor meets Scott: semantic foundations
for probabilistic networks . . . . . . . 557--571
Kausik Subramanian and
Loris D'Antoni and
Aditya Akella Genesis: synthesizing forwarding tables
in multi-tenant networks . . . . . . . . 572--585
Eryk Kopczy\'nski and
Szymon Toru\'nczyk LOIS: syntax and semantics . . . . . . . 586--598
Yu Feng and
Ruben Martins and
Yuepeng Wang and
Isil Dillig and
Thomas W. Reps Component-based synthesis for complex
APIs . . . . . . . . . . . . . . . . . . 599--612
Joshua Moerman and
Matteo Sammartino and
Alexandra Silva and
Bartek Klin and
Michal Szynwelski Learning nominal automata . . . . . . . 613--625
Ahmed Bouajjani and
Constantin Enea and
Rachid Guerraoui and
Jad Hamza On verifying causal consistency . . . . 626--638
Akhilesh Srikanth and
Burak Sahin and
William R. Harris Complexity verification using guided
theorem enumeration . . . . . . . . . . 639--652
Andrej Dudenhefner and
Jakob Rehof Intersection type calculi of bounded
dimension . . . . . . . . . . . . . . . 653--665
Nada Amin and
Tiark Rompf Type soundness proofs with definitional
interpreters . . . . . . . . . . . . . . 666--679
Carlo Angiuli and
Robert Harper and
Todd Wilson Computational higher-dimensional type
theory . . . . . . . . . . . . . . . . . 680--693
Stephen Chang and
Alex Knauth and
Ben Greenman Type systems as macros . . . . . . . . . 694--705
Ananya Kumar and
Guy E. Blelloch and
Robert Harper Parallel functional arrays . . . . . . . 706--718
Igor Konnov and
Marijana Lazi\'c and
Helmut Veith and
Josef Widder A short counterexample property for
safety and liveness verification of
fault-tolerant distributed algorithms 719--734
Xinxin Liu and
Tingting Yu and
Wenhui Zhang Analyzing divergence in bisimulation
semantics . . . . . . . . . . . . . . . 735--747
Julien Lange and
Nicholas Ng and
Bernardo Toninho and
Nobuko Yoshida Fencing off Go: liveness and safety for
channel-based programming . . . . . . . 748--761
Michael M. Vitousek and
Cameron Swords and
Jeremy G. Siek Big types in little runtime: open-world
soundness and collaborative blame for
gradual type systems . . . . . . . . . . 762--774
Nico Lehmann and
Éric Tanter Gradual refinement types . . . . . . . . 775--788
Matteo Cimini and
Jeremy G. Siek Automatically generating the dynamic
semantics of gradually typed languages 789--803
Khurram A. Jafery and
Joshua Dunfield Sums of uncertainty: refinements go
gradual . . . . . . . . . . . . . . . . 804--817
Mingsheng Ying and
Shenggang Ying and
Xiaodi Wu Invariants of quantum programs:
characterisations and generation . . . . 818--832
Ugo Dal Lago and
Claudia Faggian and
Beno\^\it Valiron and
Akira Yoshimizu The geometry of parallelism: classical,
probabilistic, and quantum effects . . . 833--845
Jennifer Paykin and
Robert Rand and
Steve Zdancewic QWIRE: a core language for quantum
circuits . . . . . . . . . . . . . . . . 846--858
Nada Amin and
Tiark Rompf LMS-Verify: abstraction without regret
for verified systems programming . . . . 859--873
Mounir Assaf and
David A. Naumann and
Julien Signoles and
Éric Totel and
Frédéric Tronel Hypercollecting semantics and its
application to static analysis of
information flow . . . . . . . . . . . . 874--887
Danfeng Zhang and
Daniel Kifer LightDP: towards automating differential
privacy proofs . . . . . . . . . . . . . 888--901
Marc Gonzalez Tallada Coarse grain parallelization of deep
neural networks . . . . . . . . . . . . 1:1--1:??
Xiao Wang and
Amit Sabne and
Sherman Kisner and
Anand Raghunathan and
Charles Bouman and
Samuel Midkiff High performance model based image
reconstruction . . . . . . . . . . . . . 2:1--2:??
Sandeep R. Agrawal and
Christopher M. Dee and
Alvin R. Lebeck Exploiting accelerators for efficient
high dimensional similarity search . . . 3:1--3:??
Flavio Cruz and
Ricardo Rocha and
Seth Copen Goldstein Declarative coordination of graph-based
parallel programs . . . . . . . . . . . 4:1--4:??
Tyler Denniston and
Shoaib Kamil and
Saman Amarasinghe Distributed Halide . . . . . . . . . . . 5:1--5:??
Ryan R. Newton and
Ömer S. Agacan and
Peter Fogg and
Sam Tobin-Hochstadt Parallel type-checking with Haskell
using saturating LVars and stream
generators . . . . . . . . . . . . . . . 6:1--6:??
Lei Wang and
Fan Yang and
Liangji Zhuang and
Huimin Cui and
Fang Lv and
Xiaobing Feng Articulation points guided redundancy
elimination for betweenness centrality 7:1--7:??
Vincent Bloemen and
Alfons Laarman and
Jaco van de Pol Multi-core on-the-fly SCC decomposition 8:1--8:??
Ramakrishnan Kannan and
Grey Ballard and
Haesun Park A high-performance parallel algorithm
for nonnegative matrix factorization . . 9:1--9:??
Rezaul Chowdhury and
Pramod Ganapathi and
Jesmin Jahan Tithi and
Charles Bachmeier and
Bradley C. Kuszmaul and
Charles E. Leiserson and
Armando Solar-Lezama and
Yuan Tang AUTOGEN: automatic discovery of
cache-oblivious parallel recursive
algorithms for solving dynamic programs 10:1--10:??
Yangzihao Wang and
Andrew Davidson and
Yuechao Pan and
Yuduo Wu and
Andy Riffel and
John D. Owens Gunrock: a high-performance graph
processing library on the GPU . . . . . 11:1--11:??
Saman Ashkiani and
Andrew Davidson and
Ulrich Meyer and
John D. Owens GPU multisplit . . . . . . . . . . . . . 12:1--12:??
Tiziano De Matteis and
Gabriele Mencagli Keep calm and react with foresight:
strategies for low-latency and
energy-efficient elastic data stream
processing . . . . . . . . . . . . . . . 13:1--13:??
Jing Li and
Kunal Agrawal and
Sameh Elnikety and
Yuxiong He and
I-Ting Angelina Lee and
Chenyang Lu and
Kathryn S. McKinley Work stealing for interactive services
to meet target latency . . . . . . . . . 14:1--14:??
Guy L. Steele, Jr. and
Jean-Baptiste Tristan Adding approximate counters . . . . . . 15:1--15:??
Chaoran Yang and
John Mellor-Crummey A wait-free queue as fast as
fetch-and-add . . . . . . . . . . . . . 16:1--16:??
Syed Kamran Haider and
William Hasenplaugh and
Dan Alistarh Lease/release: architectural support for
scaling contended data structures . . . 17:1--17:??
Rachid Guerraoui and
Vasileios Trigonakis Optimistic concurrency with OPTIK . . . 18:1--18:??
Dave Dice and
Alex Kogan and
Yossi Lev Refined transactional lock elision . . . 19:1--19:??
Man Cao and
Minjia Zhang and
Aritra Sengupta and
Michael D. Bond Drinking from both glasses: combining
pessimistic and optimistic tracking of
cross-thread dependences . . . . . . . . 20:1--20:??
Tianzheng Wang and
Milind Chabbi and
Hideaki Kimura Be my guest: MCS lock now welcomes
guests . . . . . . . . . . . . . . . . . 21:1--21:??
Milind Chabbi and
John Mellor-Crummey Contention-conscious,
locality-preserving locks . . . . . . . 22:1--22:??
Saurabh Kalikar and
Rupesh Nasre DomLock: a new multi-granularity locking
technique for hierarchies . . . . . . . 23:1--23:??
Carl G. Ritson and
Scott Owens Benchmarking weak memory models . . . . 24:1--24:??
Ganesh Narayanaswamy and
Saurabh Joshi and
Daniel Kroening The virtues of conflict: analysing
modern concurrency . . . . . . . . . . . 25:1--25:??
Matthieu Perrin and
Achour Mostefaoui and
Claude Jard Causal consistency: beyond memory . . . 26:1--26:??
Georgios Chatzopoulos and
Aleksandar Dragojevi\'c and
Rachid Guerraoui ESTIMA: extrapolating scalability of
in-memory applications . . . . . . . . . 27:1--27:??
Ananya Muddukrishna and
Peter A. Jonsson and
Artur Podobas and
Mats Brorsson Grain graphs: OpenMP performance
analysis made easy . . . . . . . . . . . 28:1--28:??
Nuno Machado and
Brandon Lucia and
Luís Rodrigues Production-guided concurrency debugging 29:1--29:??
Naila Farooqui and
Rajkishore Barik and
Brian T. Lewis and
Tatiana Shpeisman and
Karsten Schwan Affinity-aware work-stealing for
integrated CPU--GPU processors . . . . . 30:1--30:??
François Gindraud and
Fabrice Rastello and
Albert Cohen and
François Broquedis An interval constrained memory allocator
for the Givy GAS runtime . . . . . . . . 31:1--31:??
Li-Wen Chang and
Izzat El Hajj and
Hee-Seok Kim and
Juan Gómez-Luna and
Abdul Dakkak and
Wen-mei Hwu A programming system for future proofing
performance critical libraries . . . . . 32:1--32:??
Jesper Puge Nielsen and
Sven Karlsson A scalable lock-free hash table with
open addressing . . . . . . . . . . . . 33:1--33:??
Tobias Maier and
Peter Sanders and
Roman Dementiev Concurrent hash tables: fast and
general?(!) . . . . . . . . . . . . . . 34:1--34:??
Javier Prades and
Carlos Reaño and
Federico Silla CUDA acceleration for Xen virtual
machines in InfiniBand clusters with
rCUDA . . . . . . . . . . . . . . . . . 35:1--35:??
Ibrahim Umar and
Otto J. Anshus and
Phuong H. Ha Effect of portable fine-grained locality
on energy efficiency and performance in
concurrent search trees . . . . . . . . 36:1--36:??
Hrushit Parikh and
Vinit Deodhar and
Ada Gavrilovska and
Santosh Pande Efficient distributed workstealing via
matchmaking . . . . . . . . . . . . . . 37:1--37:??
Hao Luo and
Guoyang Chen and
Pengcheng Li and
Chen Ding and
Xipeng Shen Data-centric combinatorial optimization
of parallel code . . . . . . . . . . . . 38:1--38:??
Saeed Maleki and
Donald Nguyen and
Andrew Lenharth and
María Garzarán and
David Padua and
Keshav Pingali DSMR: a shared and distributed memory
algorithm for single-source shortest
path problem . . . . . . . . . . . . . . 39:1--39:??
Luca Salucci and
Daniele Bonetta and
Stefan Marr and
Walter Binder Generic messages: capability-based
shared memory parallelism for event-loop
systems . . . . . . . . . . . . . . . . 40:1--40:??
Jianqiao Liu and
Nikhil Hegde and
Milind Kulkarni Hybrid CPU--GPU scheduling and execution
of tree traversals . . . . . . . . . . . 41:1--41:??
Arunmoezhi Ramachandran and
Neeraj Mittal Improving efficacy of internal binary
search trees using local recovery . . . 42:1--42:??
Duane Merrill and
Michael Garland Merge-based sparse matrix-vector
multiplication (SpMV) using the CSR
storage format . . . . . . . . . . . . . 43:1--43:??
Andi Drebes and
Antoniu Pop and
Karine Heydemann and
Nathalie Drach and
Albert Cohen NUMA-aware scheduling and memory
allocation for data-flow task-parallel
applications . . . . . . . . . . . . . . 44:1--44:??
Mohamed Mohamedin and
Roberto Palmieri and
Sebastiano Peluso and
Binoy Ravindran On designing NUMA-aware concurrency
control for scalable transactional
memory . . . . . . . . . . . . . . . . . 45:1--45:??
Mohamed M. Saad and
Roberto Palmieri and
Binoy Ravindran On ordering transaction commit . . . . . 46:1--46:??
Xuehai Qian and
Koushik Sen and
Paul Hargrove and
Costin Iancu OPR: deterministic group replay for
one-sided communication . . . . . . . . 47:1--47:??
Marco Rabozzi and
Matteo Mazzucchelli and
Roberto Cordone and
Giovanni Matteo Fumarola and
Marco D. Santambrogio Preemption-aware planning on big-data
systems . . . . . . . . . . . . . . . . 48:1--48:??
Yifeng Chen and
Kun Huang and
Bei Wang and
Guohui Li and
Xiang Cui Samsara Parallel: a non-BSP
parallel-in-time model . . . . . . . . . 49:1--49:??
Mingzhe Zhang and
Francis C. M. Lau and
Cho-Li Wang and
Luwei Cheng and
Haibo Chen Scalable adaptive NUMA-aware lock:
combining local locking and remote
locking for efficient concurrency . . . 50:1--50:??
Nikhil Hegde and
Jianqiao Liu and
Milind Kulkarni SPIRIT: a runtime system for distributed
irregular tree applications . . . . . . 51:1--51:??
Pedro Ramalhete and
Andreia Correia Tidex: a mutual exclusion lock . . . . . 52:1--52:??
Aristeidis Mastoras and
Thomas R. Gross Unifying fixed code and fixed data
mapping of load-imbalanced pipelined
loops . . . . . . . . . . . . . . . . . 53:1--53:??
Mehmet Can Kurt and
Bin Ren and
Sriram Krishnamoorthy and
Gagan Agrawal User-assisted storage reuse
determination for dynamic task graphs 54:1--54:??
Waqas Ur Rehman and
Muhammad Sohaib Ayub and
Junaid Haroon Siddiqui Verification of MPI Java programs using
software model checking . . . . . . . . 55:1--55:??
Vivek Sarkar Virtualizing the Edge of the Cloud: the
New Frontier . . . . . . . . . . . . . . 1--1
Yu-Ju Huang and
Hsuan-Heng Wu and
Yeh-Ching Chung and
Wei-Chung Hsu Building a KVM-based Hypervisor for a
Heterogeneous System Architecture
Compliant System . . . . . . . . . . . . 3--15
Jiannan Ouyang and
John R. Lange and
Haoqiang Zheng Shoot4U: Using VMM Assists to Optimize
TLB Operations on Preempted vCPUs . . . 17--23
Timothy Merrifield and
H. Reza Taheri Performance Implications of Extended
Page Tables on Virtualized x86
Processors . . . . . . . . . . . . . . . 25--35
Senthil Nathan and
Umesh Bellur and
Purushottam Kulkarni On Selecting the Right Optimizations for
Virtual Machine Migration . . . . . . . 37--49
Yoshihisa Abe and
Roxana Geambasu and
Kaustubh Joshi and
Mahadev Satyanarayanan Urgent Virtual Machine Eviction with
Enlightened Post-Copy . . . . . . . . . 51--64
Xin Xu and
Bhavesh Davda SRVM: Hypervisor Support for Live
Migration with Passthrough SR-IOV
Network Devices . . . . . . . . . . . . 65--77
Dan Williams and
Yaohui Hu and
Umesh Deshpande and
Piush K. Sinha and
Nilton Bila and
Kartik Gopalan and
Hani Jamjoom Enabling Efficient
Hypervisor-as-a-Service Clouds with
Ephemeral Virtualization . . . . . . . . 79--92
Anton Burtsev and
David Johnson and
Mike Hibler and
Eric Eide and
John Regehr Abstractions for Practical Virtual
Machine Replay . . . . . . . . . . . . . 93--106
Kathryn S. McKinley Next Generation Virtual Memory
Management . . . . . . . . . . . . . . . 107--107
Junjie Qian and
Witawas Srisa-an and
Sharad Seth and
Hong Jiang and
Du Li and
Pan Yi Exploiting FIFO Scheduler to Improve
Parallel Garbage Collection Performance 109--121
Yang Yu and
Tianyang Lei and
Weihua Zhang and
Haibo Chen and
Binyu Zang Performance Analysis and Optimization of
Full Garbage Collection in Memory-hungry
Environments . . . . . . . . . . . . . . 123--130
Rebecca Smith and
Scott Rixner Leveraging Managed Runtime Systems to
Build, Analyze, and Optimize Memory
Graphs . . . . . . . . . . . . . . . . . 131--143
Muli Ben-Yehuda and
Orna Agmon Ben-Yehuda and
Dan Tsafrir The nom Profit-Maximizing Operating
System . . . . . . . . . . . . . . . . . 145--160
Kyle C. Hale and
Peter A. Dinda Enabling Hybrid Parallel Runtimes
Through Kernel and Virtualization
Support . . . . . . . . . . . . . . . . 161--175
Carl Waldspurger and
Emery Berger and
Abhishek Bhattacharjee and
Kevin Pedretti and
Simon Peter and
Chris Rossbach Sweet Spots and Limits for
Virtualization . . . . . . . . . . . . . 177--177
Vlad Nitu and
Pierre Olivier and
Alain Tchana and
Daniel Chiba and
Antonio Barbalace and
Daniel Hagimont and
Binoy Ravindran Swift Birth and Quick Death: Enabling
Fast Parallel Guest Boot and Destruction
in the Xen Hypervisor . . . . . . . . . 1--14
Simon Kuenzer and
Anton Ivanov and
Filipe Manco and
Jose Mendes and
Yuri Volchkov and
Florian Schmidt and
Kenichi Yasukata and
Michio Honda and
Felipe Huici Unikernels Everywhere: The Case for
Elastic CDNs . . . . . . . . . . . . . . 15--29
Jinshi Zhang and
Eddie Dong and
Jian Li and
Haibing Guan MigVisor: Accurate Prediction of VM Live
Migration Behavior using a Working-Set
Pattern Model . . . . . . . . . . . . . 30--43
Anshuj Garg and
Debadatta Mishra and
Purushottam Kulkarni Catalyst: GPU-assisted rapid memory
deduplication in virtualization
environments . . . . . . . . . . . . . . 44--59
Juan Fumero and
Michel Steuwer and
Lukas Stadler and
Christophe Dubach Just-In-Time GPU Compilation for
Interpreted Languages with Partial
Evaluation . . . . . . . . . . . . . . . 60--73
Christos Kotselidis and
James Clarkson and
Andrey Rodchenko and
Andy Nisbet and
John Mawer and
Mikel Luján Heterogeneous Managed Runtime Systems: a
Computer Vision Case Study . . . . . . . 74--82
Liang Deng and
Peng Liu and
Jun Xu and
Ping Chen and
Qingkai Zeng Dancing with Wolves: Towards Practical
Event-driven VMM Monitoring . . . . . . 83--96
Sahil Suneja and
Ricardo Koller and
Canturk Isci and
Eyal de Lara and
Ali Hashemi and
Arnamoy Bhattacharyya and
Cristiana Amza Safe Inspection of Live Virtual Machines 97--111
Leo Arulraj and
Andrea C. Arpaci-Dusseau and
Remzi H. Arpaci-Dusseau Improving Virtualized Storage
Performance with Sky . . . . . . . . . . 112--128
Felicitas Hetzelt and
Robert Buhren Security Analysis of Encrypted Virtual
Machines . . . . . . . . . . . . . . . . 129--142
Zhe Wang and
Chenggang Wu and
Jianjun Li and
Yuanming Lai and
Xiangyu Zhang and
Wei-Chung Hsu and
Yueqiang Cheng ReRanz: a Light-Weight Virtual Machine
to Mitigate Memory Disclosure Attacks 143--156
Zachary J. Estrada and
Read Sprabery and
Lok Yan and
Zhongzhi Yu and
Roy Campbell and
Zbigniew Kalbarczyk and
Ravishankar K. Iyer Using OS Design Patterns to Provide
Reliability and Security as-a-Service
for VM-based Clouds . . . . . . . . . . 157--170
Ahmed Hussein and
Mathias Payer and
Antony L. Hosking and
Chris Vick One Process to Reap Them All: Garbage
Collection as-a-Service . . . . . . . . 171--186
Jie Zhang and
Xiaoyi Lu and
Dhabaleswar K. (DK) Panda Designing Locality and NUMA Aware MPI
Runtime for Nested Virtualization based
HPC Cloud with SR--IOV Enabled
InfiniBand . . . . . . . . . . . . . . . 187--200
Kai Lu and
Wenzhe Zhang and
Xiaoping Wang and
Mikel Luján and
Andy Nisbet Flexible Page-level Memory Access
Monitoring Based on Virtualization
Hardware . . . . . . . . . . . . . . . . 201--213
Chun Yang and
Xianhua Liu and
Xu Cheng Content Look-Aside Buffer for
Redundancy-Free Virtual Disk I/O and
Caching . . . . . . . . . . . . . . . . 214--227
Amanieu d'Antras and
Cosmin Gorgovan and
Jim Garside and
John Goodacre and
Mikel Luján HyperMAMBO-X64: Using Virtualization to
Support High-Performance Transparent
Binary Translation . . . . . . . . . . . 228--241
Min Zhu and
Bibo Tu and
Wei Wei and
Dan Meng HA-VMSI: a Lightweight Virtual Machine
Isolation Approach with Commodity
Hardware for ARM . . . . . . . . . . . . 242--256
Guy L. Steele, Jr. It's Time for a New Old Language . . . . 1--1
Guoyang Chen and
Yue Zhao and
Xipeng Shen and
Huiyang Zhou EffiSha: a Software Framework for
Enabling Efficient Preemptive Scheduling
of GPU . . . . . . . . . . . . . . . . . 3--16
Nachshon Cohen and
Arie Tal and
Erez Petrank Layout Lock: a Scalable Locking Paradigm
for Concurrent Data Layout Modifications 17--29
Xiuxia Zhang and
Guangming Tan and
Shuangbai Xue and
Jiajia Li and
Keren Zhou and
Mingyu Chen Understanding the GPU Microarchitecture
to Achieve Bare-Metal Performance Tuning 31--43
Peizhao Ou and
Brian Demsky Checking Concurrent Data Structures
Under the C/C++11 Memory Model . . . . . 45--59
Milind Chabbi and
Abdelhalim Amer and
Shasha Wen and
Xu Liu An Efficient Abortable-locking Protocol
for Multi-level NUMA Systems . . . . . . 61--74
Umut A. Acar and
Naama Ben-David and
Mike Rainey Contention in Structured Concurrency:
Provably Efficient Dynamic Non-Zero
Indicators for Nested Parallelism . . . 75--88
Kento Sato and
Dong H. Ahn and
Ignacio Laguna and
Gregory L. Lee and
Martin Schulz and
Christopher M. Chambreau Noise Injection Techniques to Expose
Subtle and Unintended Message Races . . 89--101
Hao Luo and
Pengcheng Li and
Chen Ding Thread Data Sharing in Cache: Theory and
Measurement . . . . . . . . . . . . . . 103--115
Bin Ren and
Sriram Krishnamoorthy and
Kunal Agrawal and
Milind Kulkarni Exploiting Vector and Multicore
Parallelism for Recursive, Data- and
Task-Parallel Programs . . . . . . . . . 117--130
Sergei Shudler and
Alexandru Calotoiu and
Torsten Hoefler and
Felix Wolf Isoefficiency in Practice: Configuring
and Understanding the Performance of
Task-based Applications . . . . . . . . 131--143
Robert Utterback and
Kunal Agrawal and
I-Ting Angelina Lee and
Milind Kulkarni Processor-Oblivious Record and Replay 145--161
Nirmal Prajapati and
Waruna Ranasinghe and
Sanjay Rajopadhye and
Rumen Andonov and
Hristo Djidjev and
Tobias Grosser Simple, Accurate, Analytical Time
Modeling and Optimal Tile Size Selection
for GPGPU Stencils . . . . . . . . . . . 163--177
Peng Jiang and
Gagan Agrawal Combining SIMD and Many/Multi-core
Parallelism for Finite State Machines
with Enumerative Speculation . . . . . . 179--191
Ammar Ahmad Awan and
Khaled Hamidouche and
Jahanzeb Maqbool Hashmi and
Dhabaleswar K. Panda S-Caffe: Co-designing MPI Runtimes and
Caffe for Scalable Deep Learning on
Modern GPU Clusters . . . . . . . . . . 193--205
Amit Sabne and
Xiao Wang and
Sherman J. Kisner and
Charles A. Bouman and
Anand Raghunathan and
Samuel P. Midkiff Model-based Iterative CT Image
Reconstruction on GPUs . . . . . . . . . 207--220
Tsung Tai Yeh and
Amit Sabne and
Putt Sakdhnagool and
Rudolf Eigenmann and
Timothy G. Rogers Pagoda: Fine-Grained GPU Resource
Virtualization for Narrow Tasks . . . . 221--234
Tal Ben-Nun and
Michael Sutton and
Sreepathi Pai and
Keshav Pingali Groute: an Asynchronous Multi-GPU
Programming Model for Irregular
Computations . . . . . . . . . . . . . . 235--248
Tao B. Schardl and
William S. Moses and
Charles E. Leiserson Tapir: Embedding Fork-Join Parallelism
into LLVM's Intermediate Representation 249--265
Alexander Matveev and
Yaron Meirovitch and
Hayk Saribekyan and
Wiktor Jakubiuk and
Tim Kaler and
Gergely Odor and
David Budden and
Aleksandar Zlateski and
Nir Shavit A Multicore Path to
Connectomics-on-Demand . . . . . . . . . 267--281
Michael Vollmer and
Ryan G. Scott and
Madanlal Musuvathi and
Ryan R. Newton SC-Haskell: Sequential Consistency in
Languages That Minimize Mutable Shared
Heap . . . . . . . . . . . . . . . . . . 283--298
Martin Bättig and
Thomas R. Gross Synchronized-by-Default Concurrency for
Shared-Memory Systems . . . . . . . . . 299--312
Rubens E. A. Moreira and
Sylvain Collange and
Fernando Magno Quintão Pereira Function Call Re-Vectorization . . . . . 313--326
Samyam Rajbhandari and
Fabrice Rastello and
Karol Kowalski and
Sriram Krishnamoorthy and
P. Sadayappan Optimizing the Four-Index Integral
Transform Using Data Movement Lower
Bounds Analysis . . . . . . . . . . . . 327--340
Guy L. Steele, Jr. and
Jean-Baptiste Tristan Using Butterfly-Patterned Partial Sums
to Draw from Discrete Distributions . . 341--355
Dmitry Basin and
Edward Bortnikov and
Anastasia Braginsky and
Guy Golan-Gueta and
Eshcar Hillel and
Idit Keidar and
Moshe Sulamy KiWi: a Key--Value Map for Scalable
Real-Time Analytics . . . . . . . . . . 357--369
Lin Jiang and
Zhijia Zhao Grammar-aware Parallelization for
Scalable XPath Querying . . . . . . . . 371--383
Xin Wang and
Weihua Zhang and
Zhaoguo Wang and
Ziyun Wei and
Haibo Chen and
Wenyun Zhao Eunomia: Scaling Concurrent Search Trees
under Contention Using HTM . . . . . . . 385--399
Xiongchao Tang and
Jidong Zhai and
Bowen Yu and
Wenguang Chen and
Weimin Zheng Self-Checkpoint: an In-Memory Checkpoint
Method Using Less Space and Its Practice
on Fault-Tolerant HPL . . . . . . . . . 401--413
Panruo Wu and
Nathan DeBardeleben and
Qiang Guan and
Sean Blanchard and
Jieyang Chen and
Dingwen Tao and
Xin Liang and
Kaiming Ouyang and
Zizhong Chen Silent Data Corruption Resilient
Two-sided Matrix Factorizations . . . . 415--427
Maya Arbel-Raviv and
Trevor Brown Poster: Reuse, don't Recycle:
Transforming Algorithms that Throw Away
Descriptors . . . . . . . . . . . . . . 429--430
Vignesh Balaji and
Dhruva Tirumala and
Brandon Lucia Poster: an Architecture and Programming
Model for Accelerating Parallel
Commutative Computations via
Privatization . . . . . . . . . . . . . 431--432
Arnamoy Bhattacharyya and
Mike Dai Wang and
Mihai Burcea and
Yi Ding and
Allen Deng and
Sai Varikooty and
Shafaaf Hossain and
Cristiana Amza Poster: HythTM: Extending the
Applicability of Intel TSX Hardware
Transactional Support . . . . . . . . . 433--434
Rezaul Chowdhury and
Pramod Ganapathi and
Yuan Tang and
Jesmin Jahan Tithi Poster: Provably Efficient Scheduling of
Cache-Oblivious Wavefront Algorithms . . 435--436
Nachshon Cohen and
Maurice Herlihy and
Erez Petrank and
Elias Wald Poster: State Teleportation via Hardware
Transactional Memory . . . . . . . . . . 437--438
Dong Dai and
Wei Zhang and
Yong Chen Poster: IOGP: an Incremental Online
Graph Partitioning for Large-Scale
Distributed Graph Databases . . . . . . 439--440
Jesun Shariar Firoz and
Thejaka Amila Kanewala and
Marcin Zalewski and
Martina Barnas and
Andrew Lumsdaine Poster: Distributed Control: The
Benefits of Eliminating Global
Synchronization via Effective Scheduling 441--442
Gangwon Jo and
Jaehoon Jung and
Jiyoung Park and
Jaejin Lee Poster: MAPA: an Automatic Memory Access
Pattern Analyzer for GPU Applications 443--444
Shigang Li and
Yunquan Zhang and
Torsten Hoefler Poster: Cache-Oblivious MPI All-to-All
Communications on Many-Core
Architectures . . . . . . . . . . . . . 445--446
Harshitha Menon and
Kavitha Chandrasekar and
Laxmikant V. Kale Poster: Automated Load Balancer
Selection Based on Application
Characteristics . . . . . . . . . . . . 447--448
Nurit Moscovici and
Nachshon Cohen and
Erez Petrank Poster: a GPU-Friendly Skiplist
Algorithm . . . . . . . . . . . . . . . 449--450
Pedro Ramalhete and
Andreia Correia Poster: Poor Man's URCU . . . . . . . . 451--452
Pedro Ramalhete and
Andreia Correia Poster: a Wait-Free Queue with Wait-Free
Memory Reclamation . . . . . . . . . . . 453--454
Yuan Tang and
Ronghui You Poster: STAR (Space-Time Adaptive and
Reductive) Algorithms for Real-World
Space-Time Optimality . . . . . . . . . 455--456
Mingyu Wu and
Haibing Guan and
Binyu Zang and
Haibo Chen Poster: Recovering Performance for
Vector-based Machine Learning on Managed
Runtime . . . . . . . . . . . . . . . . 457--458
Minjia Zhang and
Swarnendu Biswas and
Michael D. Bond Poster: On the Problem of Consistency
Exceptions in the Context of Strong
Memory Models . . . . . . . . . . . . . 459--460
Yue Zhao and
Chunhua Liao and
Xipeng Shen Poster: an Infrastructure for HPC
Knowledge Sharing and Reuse . . . . . . 461--462
Xipeng Shen Bridging the gap between memory
performance and massive parallelism: the
critical role of programming systems
innovations (keynote) . . . . . . . . . 1--1
Rodrigo Bruno and
Luís Picciochi Oliveira and
Paulo Ferreira NG2C: pretenuring garbage collection
with dynamic generations for HotSpot big
data applications . . . . . . . . . . . 2--13
Albert Mingkun Yang and
Tobias Wrigstad Type-assisted automatic garbage
collection for lock-free data structures 14--24
Nick Vrvilo and
Lechen Yu and
Vivek Sarkar A marshalled data format for pointers in
relocatable data blocks . . . . . . . . 25--35
Zhengyang Liu and
John Criswell Flexible and efficient memory object
metadata . . . . . . . . . . . . . . . . 36--46
Kostyantyn Vorobyov and
Julien Signoles and
Nikolai Kosmatov Shadow state encoding for efficient
monitoring of block-level properties . . 47--58
Mohammad Dashti and
Alexandra Fedorova Analyzing memory management methods on
integrated CPU--GPU systems . . . . . . 59--69
Ellis Giles and
Kshitij Doshi and
Peter Varman Continuous checkpointing of HTM
transactions in NVM . . . . . . . . . . 70--81
Ivy Bo Peng and
Roberto Gioiosa and
Gokcen Kestor and
Pietro Cicotti and
Erwin Laure and
Stefano Markidis RTHMS: a tool for data placement on
hybrid memory system . . . . . . . . . . 82--91
Vini Kanvar and
Uday P. Khedker ``What's in a name?'' going beyond
allocation site names in heap analysis 92--103
Bin Fang and
Mihaela Sighireanu A refinement hierarchy for free list
memory allocators . . . . . . . . . . . 104--114
Minjia Zhang and
Swarnendu Biswas and
Michael D. Bond Avoiding consistency exceptions under
strong memory models . . . . . . . . . . 115--127
Didier Rémy Ornaments: exploiting parametricity for
safer, more automated code
refactorization and code reuse (invited
talk) . . . . . . . . . . . . . . . . . 1--1
Andrey Mokhov Algebraic graphs with class (functional
pearl) . . . . . . . . . . . . . . . . . 2--13
Mario Blazevi\'c and
Jacques Légaré Packrats parse in packs . . . . . . . . 14--25
Leonidas Lampropoulos and
Antal Spector-Zabusky and
Kenneth Foner Ode on a random urn (functional pearl) 26--37
Maximilian Algehed and
Koen Claessen and
Moa Johansson and
Nick Smallbone QuickSpec: a lightweight theory
exploration tool for programmers (system
demonstration) . . . . . . . . . . . . . 38--39
Rudy Braquehais and
Colin Runciman Speculate: discovering conditional
equations and inequalities about
black-box functions by reasoning from
test results . . . . . . . . . . . . . . 40--51
John Wiegley and
Benjamin Delaware Using Coq to write fast and correct
Haskell . . . . . . . . . . . . . . . . 52--62
Niki Vazou and
Leonidas Lampropoulos and
Jeff Polakow A tale of two provers: verifying
monoidal string matching in liquid
Haskell and Coq . . . . . . . . . . . . 63--74
Anton Ekblad A meta-EDSL for distributed web
applications . . . . . . . . . . . . . . 75--85
Justin Dawson and
Mark Grebe and
Andy Gill Composable network stacks and remote
monads . . . . . . . . . . . . . . . . . 86--97
Donya Quick Algorithmic music in Haskell (invited
talk) . . . . . . . . . . . . . . . . . 98--98
Dmitrij Szamozvancev and
Michael B. Gale Well-typed music does not sound wrong
(experience report) . . . . . . . . . . 99--104
Ivan Perez Back to the future: time travel in FRP 105--116
Jennifer Paykin and
Steve Zdancewic The Linearity Monad . . . . . . . . . . 117--132
Georgios Karachalias and
Tom Schrijvers Elaboration on functional dependencies:
functional dependencies are dead, long
live functional dependencies! . . . . . 133--147
Gert-Jan Bottu and
Georgios Karachalias and
Tom Schrijvers and
Bruno C. d. S. Oliveira and
Philip Wadler Quantified class constraints . . . . . . 148--161
Markus Aronsson and
Mary Sheeran Hardware software co-design in Haskell 162--173
Robert Clifton-Everest and
Trevor L. McDonell and
Manuel M. T. Chakravarty and
Gabriele Keller Streaming irregular arrays . . . . . . . 174--185
Ryan Yates and
Michael L. Scott Improving STM performance with
transactional structs . . . . . . . . . 186--196
Chao-Hong Chen and
Vikraman Choudhury and
Ryan R. Newton Adaptive lock-free data structures in
Haskell: a general method for concurrent
implementation swapping . . . . . . . . 197--211
Filip Pizlo The JavaScriptCore virtual machine
(invited talk) . . . . . . . . . . . . . 1--1
Jeremy Siek Challenges and progress toward efficient
gradual typing (invited talk) . . . . . 2--2
Stefan Marr and
Carmen Torres Lopez and
Dominik Aumayr and
Elisa Gonzalez Boix and
Hanspeter Mössenböck A concurrency-agnostic protocol for
multi-paradigm concurrent debugging
tools . . . . . . . . . . . . . . . . . 3--14
David Ungar and
David Grove and
Hubertus Franke Dynamic atomicity: optimizing swift
memory management . . . . . . . . . . . 15--26
Alejandro Infante and
Alexandre Bergel Object equivalence: revisiting object
equality profiling (an experience
report) . . . . . . . . . . . . . . . . 27--38
Javier Pimás and
Javier Burroni and
Jean Baptiste Arnaud and
Stefan Marr Garbage collection and efficiency in
dynamic metacircular runtimes: an
experience report . . . . . . . . . . . 39--50
Matthew C. Loring and
Mark Marron and
Daan Leijen Semantics of asynchronous JavaScript . . 51--62
Vlad Vergu and
Michiel Haisma and
Eelco Visser The semantics of name resolution in
Grace . . . . . . . . . . . . . . . . . 63--74
Mallku Soldevila and
Beta Ziliani and
Bruno Silvestre and
Daniel Fridlender and
Fabio Mascarenhas Decoding Lua: formal semantics for the
developer and the semanticist . . . . . 75--86
Danny Dig The landscape of refactoring research in
the last decade (keynote) . . . . . . . 1--1
Rui Ge and
Ronald Garcia Refining semantics for multi-stage
programming . . . . . . . . . . . . . . 2--14
Georg Ofenbeck and
Tiark Rompf and
Markus Püschel Staging for generic programming in space
and time . . . . . . . . . . . . . . . . 15--28
Junpei Oishi and
Yukiyoshi Kameyama Staging with control: type-safe
multi-stage programming with control
operators . . . . . . . . . . . . . . . 29--40
Ludovic Court\`es Code staging in GNU Guix . . . . . . . . 41--48
Lukas Linsbauer and
Thorsten Berger and
Paul Grünbacher A classification of variation control
systems . . . . . . . . . . . . . . . . 49--62
Raúl Lapeña and
Jaime Font and
Óscar Pastor and
Carlos Cetina Analyzing the impact of natural language
processing over feature location in
models . . . . . . . . . . . . . . . . . 63--76
Wolfram Fenske and
Sandro Schulze and
Gunter Saake How preprocessor annotations (do not)
affect maintainability: a case study on
change-proneness . . . . . . . . . . . . 77--90
Travis Carlson and
Eric Van Wyk Type qualifiers as composable language
extensions . . . . . . . . . . . . . . . 91--103
Andrea Ros\`a and
Eduardo Rosales and
Walter Binder Accurate reification of complete
supertype information for dynamic
analysis on the JVM . . . . . . . . . . 104--116
David J. Pearce Rewriting for sound and complete union,
intersection and negation types . . . . 117--130
Lionel Parreaux and
Amir Shaikhha and
Christoph E. Koch Quoted staged rewriting: a practical
approach to library-defined
optimizations . . . . . . . . . . . . . 131--145
Joseph Caldwell and
Shigeru Chiba Reducing calling convention overhead in
object-oriented programming on embedded
ARM Thumb-2 platforms . . . . . . . . . 146--156
Ars\`ene Pérard-Gayot and
Martin Weier and
Richard Membarth and
Philipp Slusallek and
Roland Leißa and
Sebastian Hack RaTrace: simple and efficient
abstractions for BVH ray traversal
algorithms . . . . . . . . . . . . . . . 157--168
Adilla Susungi and
Norman A. Rink and
Jerónimo Castrillón and
Immo Huismann and
Albert Cohen and
Claude Tadonki and
Jörg Stiller and
Jochen Fröhlich Towards compositional and generative
tensor optimizations . . . . . . . . . . 169--175
Jafar M. Al-Kofahi and
Suresh Kothari and
Christian Kästner Four languages and lots of macros:
analyzing autotools build systems . . . 176--186
Leonardo Fernandes and
Márcio Ribeiro and
Luiz Carvalho and
Rohit Gheyi and
Melina Mongiovi and
André Santos and
Ana Cavalcanti and
Fabiano Ferrari and
José Carlos Maldonado Avoiding useless mutants . . . . . . . . 187--198
Tomoki Nakamaru and
Kazuhiro Ichikawa and
Tetsuro Yamazaki and
Shigeru Chiba Silverchain: a fluent API generator . . 199--211
Vadim Zaytsev Parser generation by example for legacy
pattern languages . . . . . . . . . . . 212--218
Geoffrey Mainland and
Jeremy Johnson A Haskell compiler for signal transforms 219--232
Ricardo Giuliani Martini and
Pedro Rangel Henriques Automatic generation of virtual learning
spaces driven by CaVa DSL: an experience
report . . . . . . . . . . . . . . . . . 233--245
Mark Grebe and
David Young and
Andy Gill Rewriting a shallow DSL using a GHC
compiler extension . . . . . . . . . . . 246--258
Haosen Wen and
Joseph Izraelevitz and
Wentao Cai and
H. Alan Beadle and
Michael L. Scott Interval-based memory reclamation . . . 1--13
Maya Arbel-Raviv and
Trevor Brown Harnessing epoch-based reclamation for
efficient range queries . . . . . . . . 14--27
Michal Friedman and
Maurice Herlihy and
Virendra Marathe and
Erez Petrank A persistent lock-free queue for
non-volatile memory . . . . . . . . . . 28--40
Linnan Wang and
Jinmian Ye and
Yiyang Zhao and
Wei Wu and
Ang Li and
Shuaiwen Leon Song and
Zenglin Xu and
Tim Kraska Superneurons: dynamic GPU memory
management for training deep neural
networks . . . . . . . . . . . . . . . . 41--53
Mehmet E. Belviranli and
Seyong Lee and
Jeffrey S. Vetter and
Laxmi N. Bhuyan Juggler: a dependence-aware task-based
execution framework for GPUs . . . . . . 54--67
Maria Kotsifakou and
Prakalp Srivastava and
Matthew D. Sinclair and
Rakesh Komuravelli and
Vikram Adve and
Sarita Adve HPVM: heterogeneous parallel virtual
machine . . . . . . . . . . . . . . . . 68--80
Adrien Guatto and
Sam Westrick and
Ram Raghunathan and
Umut Acar and
Matthew Fluet Hierarchical memory management for
mutable state . . . . . . . . . . . . . 81--93
Yue Zhao and
Jiajia Li and
Chunhua Liao and
Xipeng Shen Bridging the gap between deep learning
and sparse matrix format selection . . . 94--108
Zhen Jia and
Aleksandar Zlateski and
Fredo Durand and
Kai Li Optimizing $N$-dimensional,
Winograd-based convolution for manycore
CPUs . . . . . . . . . . . . . . . . . . 109--123
Xiongchao Tang and
Jidong Zhai and
Xuehai Qian and
Bingsheng He and
Wei Xue and
Wenguang Chen vSensor: leveraging fixed-workload
snippets of programs for performance
variance detection . . . . . . . . . . . 124--136
Aleksandar Prokopec Cache-tries: concurrent lock-free hash
tries with constant-time operations . . 137--151
Milind Chabbi and
Shasha Wen and
Xu Liu Featherlight on-the-fly false-sharing
detection . . . . . . . . . . . . . . . 152--167
Prashant Singh Rawat and
Fabrice Rastello and
Aravind Sukumaran-Rajam and
Louis-Noël Pouchet and
Atanas Rountev and
P. Sadayappan Register optimizations for stencils on
GPUs . . . . . . . . . . . . . . . . . . 168--182
Da Zheng and
Disa Mhembere and
Joshua T. Vogelstein and
Carey E. Priebe and
Randal Burns FlashR: parallelize and scale R for
machine learning using SSDs . . . . . . 183--194
Harshitha Menon and
Kathryn Mohror DisCVar: discovering critical variables
using algorithmic differentiation for
transient faults . . . . . . . . . . . . 195--206
Dana Drachsler-Cohen and
Martin Vechev and
Eran Yahav Practical concurrent traversals in
search trees . . . . . . . . . . . . . . 207--218
Lukas Gianinazzi and
Pavel Kalvoda and
Alessandro De Palma and
Maciej Besta and
Torsten Hoefler Communication-avoiding parallel minimum
cuts and connected components . . . . . 219--232
Artem Khyzha and
Hagit Attiya and
Alexey Gotsman and
Noam Rinetzky Safe privatization in transactional
memory . . . . . . . . . . . . . . . . . 233--245
Samuel Grossman and
Heiner Litz and
Christos Kozyrakis Making pull-based graph processing
performant . . . . . . . . . . . . . . . 246--260
Abhinav Jangda and
Uday Bondhugula An effective fusion and tile size model
for optimizing image processing
pipelines . . . . . . . . . . . . . . . 261--275
Lei Wang and
Liangji Zhuang and
Junhang Chen and
Huimin Cui and
Fang Lv and
Ying Liu and
Xiaobing Feng Lazygraph: lazy data coherency for
replicas in distributed graph-parallel
computation . . . . . . . . . . . . . . 276--289
Yihan Sun and
Daniel Ferizovic and
Guy E. Belloch PAM: parallel augmented maps . . . . . . 290--304
Zhouwang Fu and
Tao Song and
Zhengwei Qi and
Haibing Guan Efficient shuffle management with SCache
for DAG computing frameworks . . . . . . 305--316
Xueqi Li and
Guangming Tan and
Bingchen Wang and
Ninghui Sun High-performance genomic analysis
framework with in-memory computing . . . 317--328
Yang Liu and
Jianguo Wang and
Steven Swanson Griffin: uniting CPU and GPU in
information retrieval systems for
intra-query parallelism . . . . . . . . 327--337
Xinliang Wang and
Weifeng Liu and
Wei Xue and
Li Wu swSpTRSV: a fast sparse triangular solve
with sparse level tile layout on Sunway
architectures . . . . . . . . . . . . . 338--353
James R. Wilcox and
Cormac Flanagan and
Stephen N. Freund VerifiedFT: a verified, high-performance
precise dynamic race detector . . . . . 354--367
Yifan Xu and
I-Ting Angelina Lee and
Kunal Agrawal Efficient parallel determinacy race
detection for two-dimensional dags . . . 368--380
Umut A. Acar and
Vitaly Aksenov and
Arthur Charguéraud and
Mike Rainey Performance challenges in modular
parallel programs . . . . . . . . . . . 381--382
Mahwish Arif and
Hans Vandierendonck Reducing the burden of parallel loop
schedulers for many-core processors . . 383--384
Nachshon Cohen and
Erez Petrank and
James R. Larus Reducing transaction aborts by looking
to the future . . . . . . . . . . . . . 385--386
Andreia Correia and
Pedro Ramalhete Strong trylocks for reader-writer locks 387--388
Yao Dong and
Ana Milanova and
Julian Dolby SecureMR: secure mapreduce using
homomorphic encryption and program
partitioning . . . . . . . . . . . . . . 389--390
Jesun Sahariar Firoz and
Marcin Zalewski and
Andrew Lumsdaine A scalable distance-1 vertex coloring
algorithm for power-law graphs . . . . . 391--392
Koby Hayashi and
Grey Ballard and
Yujie Jiang and
Michael J. Tobia Shared-memory parallelization of MTTKRP
for dense tensors . . . . . . . . . . . 393--394
Peng Jiang and
Gagan Agrawal Revealing parallel scans and reductions
in sequential loops through function
reconstruction . . . . . . . . . . . . . 395--396
Changwan Hong and
Aravind Sukumaran-Rajam and
Jinsung Kim and
Prashant Singh Rawat and
Sriram Krishnamoorthy and
Louis-Noël Pouchet and
Fabrice Rastello and
P. Sadayappan Performance modeling for GPUs using
abstract kernel emulation . . . . . . . 397--398
Herbert Jordan and
Bernhard Scholz and
Pavle Subotic Two concurrent data structures for
efficient datalog query processing . . . 399--400
Bernhard Kerbl and
Jörg Müller and
Michael Kenzel and
Dieter Schmalstieg and
Markus Steinberger A scalable queue for work distribution
on GPUs . . . . . . . . . . . . . . . . 401--402
Johannes de Fine Licht and
Michaela Blott and
Torsten Hoefler Designing scalable FPGA architectures
using high-level synthesis . . . . . . . 403--404
Bo Liu and
Wenbin Jiang and
Hai Jin and
Xuanhua Shi and
Yang Ma Layrub: layer-centric GPU memory reuse
and data migration in extreme-scale deep
learning systems . . . . . . . . . . . . 405--406
Junhong Liu and
Xin He and
Weifeng Liu and
Guangming Tan Register-based implementation of the
sparse general matrix--matrix
multiplication on GPUs . . . . . . . . . 407--408
Girish Mururu and
Ada Gavrilovska and
Santosh Pande Quantifying and reducing execution
variance in STM via model driven commit
optimization . . . . . . . . . . . . . . 409--410
Jungho Park and
Hyungmin Cho and
Wookeun Jung and
Jaejin Lee Transparent GPU memory management for
DNNs . . . . . . . . . . . . . . . . . . 411--412
Manuel Pöter and
Jesper Larsson Träff Stamp-it, amortized constant-time memory
reclamation in comparison to five other
schemes . . . . . . . . . . . . . . . . 413--414
Stefan Reif and
Wolfgang Schröder-Preikschat A predictable synchronisation algorithm 415--416
Heinrich Riebler and
Gavin Vaz and
Tobias Kenter and
Christian Plessl Automated code acceleration targeting
heterogeneous OpenCL devices . . . . . . 417--418
Isaac Sánchez Barrera and
Marc Casas and
Miquel Moretó and
Eduard Ayguadé and
Jesús Labarta and
Mateo Valero Graph partitioning applied to DAG
scheduling to reduce NUMA effects . . . 419--420
Vasily Volkov A microbenchmark to study GPU
performance models . . . . . . . . . . . 421--422
Tuowen Zhao and
Mary Hall and
Protonu Basu and
Samuel Williams and
Hans Johansen SIMD code generation for stencils on
brick decompositions . . . . . . . . . . 423--424
Daichi Fujiki and
Scott Mahlke and
Reetuparna Das In-Memory Data Parallel Processor . . . 1--14
Jordan Fix and
Nayana P. Nagendra and
Sotiris Apostolakis and
Hansen Zhang and
Sophie Qiu and
David I. August Hardware Multithreaded Transactions . . 15--29
Rakesh Kumar and
Boris Grot and
Vijay Nagarajan Blasting through the Front-End
Bottleneck with Shotgun . . . . . . . . 30--42
Maciej Besta and
Syed Minhaj Hassan and
Sudhakar Yalamanchili and
Rachata Ausavarungnirun and
Onur Mutlu and
Torsten Hoefler Slim NoC: a Low-Diameter On-Chip Network
Topology for High Energy Efficiency and
Scalability . . . . . . . . . . . . . . 43--55
Khanh Nguyen and
Lu Fang and
Christian Navasca and
Guoqing Xu and
Brian Demsky and
Shan Lu Skyway: Connecting Managed Heaps in
Distributed Big Data Systems . . . . . . 56--69
Mingyu Wu and
Ziming Zhao and
Haoyu Li and
Heting Li and
Haibo Chen and
Binyu Zang and
Haibing Guan Espresso: Brewing Java For More
Non-Volatility with Non-volatile Memory 70--83
Wenwen Wang and
Stephen McCamant and
Antonia Zhai and
Pen-Chung Yew Enhancing Cross-ISA DBT Through
Automatically Learned Translation Rules 84--97
Sumanaruban Rajadurai and
Jeffrey Bosboom and
Weng-Fai Wong and
Saman Amarasinghe Gloss: Seamless Live Reconfiguration and
Reoptimization of Stream Programs . . . 98--112
Hongil Yoon and
Jason Lowe-Power and
Gurindar S. Sohi Filtering Translation Bandwidth with
Virtual Caching . . . . . . . . . . . . 113--127
Sepideh Maleki and
Martin Burtscher Automatic Hierarchical Parallelization
of Linear Recurrences . . . . . . . . . 128--138
Philip Ginsbach and
Toomas Remmelg and
Michel Steuwer and
Bruno Bodin and
Christophe Dubach and
Michael F. P. O'Boyle Automatic Matching of Legacy Code to
Heterogeneous APIs: an Idiomatic
Approach . . . . . . . . . . . . . . . . 139--153
Shu Wang and
Chi Li and
Henry Hoffmann and
Shan Lu and
William Sentosa and
Achmad Imam Kistijantoro Understanding and Auto-Adjusting
Performance-Sensitive Configurations . . 154--168
Amir M. Rahmani and
Bryan Donyanavard and
Tiago Mück and
Kasra Moazzemi and
Axel Jantsch and
Onur Mutlu and
Nikil Dutt SPECTR: Formal Supervisory Control and
Coordination for Many-core Systems
Resource Management . . . . . . . . . . 169--183
Nikita Mishra and
Connor Imes and
John D. Lafferty and
Henry Hoffmann CALOREE: Learning Control for
Predictable Latency and Low Energy . . . 184--198
Yatish Turakhia and
Gill Bejerano and
William J. Dally Darwin: a Genomics Co-processor Provides
up to $ 15 \, 000 \times $ Acceleration
on Long Read Assembly . . . . . . . . . 199--213
Yue Zha and
Jing Li Liquid Silicon-Monona: a Reconfigurable
Memory-Oriented Computing Fabric with
Scalable Multi-Context Support . . . . . 214--228
Sara Achour and
Martin Rinard Time Dilation and Contraction for
Programmable Analog Devices with Jaunt 229--242
Yuting Dai and
Tao Li and
Benyong Liu and
Mingcong Song and
Huixiang Chen Exploiting Dynamic Thermal Energy
Harvesting for Reusing in Smartphone
with Mobile Applications . . . . . . . . 243--256
Yongjian Hu and
Iulian Neamtiu Static Detection of Event-based Races in
Android Apps . . . . . . . . . . . . . . 257--270
Peizhen Guo and
Wenjun Hu Potluck: Cross-Application Approximate
Deduplication for Computation-Intensive
Mobile Applications . . . . . . . . . . 271--284
Frederic T. Chong Quantum Computing is Getting Real:
Architecture, PL, and OS Roles in
Closing the Gap between Quantum
Algorithms and Machines . . . . . . . . 285--285
Christian DeLozier and
Ariel Eizenberg and
Brandon Lucia and
Joseph Devietti SOFRITAS: Serializable Ordering-Free
Regions for Increasing Thread Atomicity
Scalably . . . . . . . . . . . . . . . . 286--300
Alex Markuze and
Igor Smolyar and
Adam Morrison and
Dan Tsafrir DAMN: Overhead-Free IOMMU Protection for
Networking . . . . . . . . . . . . . . . 301--315
Amirali Boroumand and
Saugata Ghose and
Youngsok Kim and
Rachata Ausavarungnirun and
Eric Shiu and
Rahul Thakur and
Daehyun Kim and
Aki Kuusela and
Allan Knies and
Parthasarathy Ranganathan and
Onur Mutlu Google Workloads for Consumer Devices:
Mitigating Data Movement Bottlenecks . . 316--331
Shasha Wen and
Xu Liu and
John Byrne and
Milind Chabbi Watching for Software Inefficiencies
with Witch . . . . . . . . . . . . . . . 332--347
David Devecsery and
Peter M. Chen and
Jason Flinn and
Satish Narayanasamy Optimistic Hybrid Analysis: Accelerating
Dynamic Analysis through Predicated
Static Analysis . . . . . . . . . . . . 348--362
Omer Katz and
Noam Rinetzky and
Eran Yahav Statistical Reconstruction of Class
Hierarchies in Binaries . . . . . . . . 363--376
Manuel Rigger and
Roland Schatz and
René Mayrhofer and
Matthias Grimmer and
Hanspeter Mössenböck Sulong, and Thanks for All the Bugs:
Finding Errors in C Programs by
Abstracting from the Native Execution
Model . . . . . . . . . . . . . . . . . 377--391
Yaniv David and
Nimrod Partush and
Eran Yahav FirmUp: Precise Static Detection of
Common Vulnerabilities in Firmware . . . 392--404
Jade Alglave and
Luc Maranget and
Paul E. McKenney and
Andrea Parri and
Alan Stern Frightening Small Children and
Disconcerting Grown-ups: Concurrency in
the Linux Kernel . . . . . . . . . . . . 405--418
Haopeng Liu and
Xu Wang and
Guangpu Li and
Shan Lu and
Feng Ye and
Chen Tian FCatch: Automatically Detecting
Time-of-fault Bugs in Cloud Systems . . 419--431
Enrico A. Deiana and
Vincent St-Amour and
Peter A. Dinda and
Nikos Hardavellas and
Simone Campanoni Unconventional Parallelization of
Nondeterministic Applications . . . . . 432--447
Yu Ji and
Youhui Zhang and
Wenguang Chen and
Yuan Xie Bridge the Gap between Neural Networks
and Neuromorphic Hardware with a Neural
Network Compiler . . . . . . . . . . . . 448--460
Hyoukjun Kwon and
Ananda Samajdar and
Tushar Krishna MAERI: Enabling Flexible Dataflow
Mapping over DNN Accelerators via
Reconfigurable Interconnects . . . . . . 461--475
Ruizhe Cai and
Ao Ren and
Ning Liu and
Caiwen Ding and
Luhao Wang and
Xuehai Qian and
Massoud Pedram and
Yanzhi Wang VIBNN: Hardware Acceleration of Bayesian
Neural Networks . . . . . . . . . . . . 476--488
Mohammad Sadrosadati and
Amirhossein Mirhosseini and
Seyed Borna Ehsani and
Hamid Sarbazi-Azad and
Mario Drumond and
Babak Falsafi and
Rachata Ausavarungnirun and
Onur Mutlu LTRF: Enabling High-Capacity Register
Files for GPUs via Hardware/Software
Cooperative Register Prefetching . . . . 489--502
Rachata Ausavarungnirun and
Vance Miller and
Joshua Landgraf and
Saugata Ghose and
Jayneel Gandhi and
Adwait Jog and
Christopher J. Rossbach and
Onur Mutlu MASK: Redesigning the GPU Memory
Hierarchy to Support Multi-Application
Concurrency . . . . . . . . . . . . . . 503--518
Zhihao Yao and
Zongheng Ma and
Yingtong Liu and
Ardalan Amiri Sani and
Aparna Chandramowlishwaran Sugar: Secure GPU Acceleration in Web
Browsers . . . . . . . . . . . . . . . . 519--534
Chang-Hong Hsu and
Qingyuan Deng and
Jason Mars and
Lingjia Tang SmoothOperator: Reducing Power
Fragmentation and Improving Power
Utilization in Large-scale Datacenters 535--548
Jaewon Lee and
Changkyu Kim and
Kun Lin and
Liqun Cheng and
Rama Govindaraju and
Jangwoo Kim WSMeter: a Performance Evaluation
Methodology for Google's Production
Warehouse-Scale Computers . . . . . . . 549--563
Zhibin Yu and
Zhendong Bei and
Xuehai Qian Datasize-Aware High Dimensional
Configurations Auto-Tuning of In-Memory
Cluster Computing . . . . . . . . . . . 564--577
Sam Ainsworth and
Timothy M. Jones An Event-Triggered Programmable
Prefetcher for Irregular Workloads . . . 578--592
Dan Zhang and
Xiaoyu Ma and
Michael Thomson and
Derek Chiou Minnow: Lightweight Offload Engines for
Worklist Management and
Worklist-Directed Prefetching . . . . . 593--607
Mingxing Zhang and
Yongwei Wu and
Youwei Zhuo and
Xuehai Qian and
Chengying Huan and
Kang Chen Wonderland: a Novel Abstraction-Based
Out-Of-Core Graph Processing System . . 608--621
Amir Hossein Nodehi Sabet and
Junqiao Qiu and
Zhijia Zhao Tigr: Transforming Irregular Graphs for
GPU-Friendly Graph Processing . . . . . 622--636
Swapnil Haria and
Mark D. Hill and
Michael M. Swift Devirtualizing Memory in Heterogeneous
Systems . . . . . . . . . . . . . . . . 637--650
Mohan Kumar Kumar and
Steffen Maass and
Sanidhya Kashyap and
Ján Veselý and
Zi Yan and
Taesoo Kim and
Abhishek Bhattacharjee and
Tushar Krishna LATR: Lazy Translation Coherence . . . . 651--664
Meysam Taassori and
Ali Shafiee and
Rajeev Balasubramonian VAULT: Reducing Paging Overheads in SGX
with Efficient Integrity Verification
Structures . . . . . . . . . . . . . . . 665--678
Ashish Panwar and
Aravinda Prasad and
K. Gopinath Making Huge Pages Actually Useful . . . 679--692
Dmitry Evtyushkin and
Ryan Riley and
Nael CSE and
ECE Abu-Ghazaleh and
Dmitry Ponomarev BranchScope: a New Side-Channel Attack
on Directional Branch Predictor . . . . 693--707
Bernard Dickens III and
Haryadi S. Gunawi and
Ariel J. Feldman and
Henry Hoffmann StrongBox: Confidentiality, Integrity,
and Performance using Stream Ciphers for
Full Drive Encryption . . . . . . . . . 708--721
Casen Hunger and
Lluis Vilanova and
Charalampos Papamanthou and
Yoav Etsion and
Mohit Tiwari DATS --- Data Containers for Web
Applications . . . . . . . . . . . . . . 722--736
Stephen Mallon and
Vincent Gramoli and
Guillaume Jourjon DLibOS: Performance and Protection with
a Network-on-Chip . . . . . . . . . . . 737--750
Shih-Chieh Lin and
Yunqi Zhang and
Chang-Hong Hsu and
Matt Skach and
Md E. Haque and
Lingjia Tang and
Jason Mars The Architectural Implications of
Autonomous Driving: Constraints and
Acceleration . . . . . . . . . . . . . . 751--766
Alexei Colin and
Emily Ruppel and
Brandon Lucia A Reconfigurable Energy Storage
Architecture for Energy-harvesting
Devices . . . . . . . . . . . . . . . . 767--781
Kaisheng Ma and
Xueqing Li and
Mahmut Taylan Kandemir and
Jack Sampson and
Vijaykrishnan Narayanan and
Jinyang Li and
Tongda Wu and
Zhibo Wang and
Yongpan Liu and
Yuan Xie NEOFog: Nonvolatility-Exploiting
Optimizations for Fog Computing . . . . 782--796
Andrea Lottarini and
Alex Ramirez and
Joel Coburn and
Martha A. Kim and
Parthasarathy Ranganathan and
Daniel Stodolsky and
Mark Wachsler vbench: Benchmarking Video Transcoding
in the Cloud . . . . . . . . . . . . . . 797--809
Steve Blackburn Session details: Session 7B: Memory 2 ??
John Carter Session details: Session 6B: Datacenters ??
John Criswell Session details: Session 8A: Security
and Protection . . . . . . . . . . . . . ??
Jayneel Gandhi Session details: Session 6A: GPU 2 . . . ??
Hank Hoffmann Session details: Session 5A: Concurrency
and Parallelism . . . . . . . . . . . . ??
Martha Kim Session details: Session 7A: Irregular
Apps and Graphs . . . . . . . . . . . . ??
James Larus Session details: Session 2B: Performance
Management . . . . . . . . . . . . . . . ??
Dongyoon Lee Session details: Session 3B: Mobile
Applications . . . . . . . . . . . . . . ??
Lei Liu Session details: Session 1B: Managed
Runtimes and Dynamic Translation . . . . ??
Shan Lu Session details: Session 4B: Program
Analysis . . . . . . . . . . . . . . . . ??
Satish Narayanasamy Session details: Session 3A:
Programmable Devices and Co-processors ??
Christopher J. Rossbach Session details: Session 2A: GPUs 1 . . ??
Adrian Sampson? Session details: Session 5B Neural
Networks . . . . . . . . . . . . . . . . ??
Yan Solihin Session details: Session 8B: Potpourri ??
Josep Torrellas Session details: Session 1A: New
Architectures . . . . . . . . . . . . . ??
Dan Tsafrir Session details: Session 4A: Memory 1 ??
Kunshan Wang and
Stephen M. Blackburn and
Antony L. Hosking and
Michael Norrish Hop, Skip, & Jump: Practical On-Stack
Replacement for a Cross-Platform
Language-Neutral VM . . . . . . . . . . 1--16
Wenwen Wang and
Jiacheng Wu and
Xiaoli Gong and
Tao Li and
Pen-Chung Yew Improving Dynamically-Generated Code
Performance on Dynamic Binary
Translators . . . . . . . . . . . . . . 17--30
Jiacheng Ma and
Xiao Zheng and
Yaozu Dong and
Wentai Li and
Zhengwei Qi and
Bingsheng He and
Haibing Guan gMig: Efficient GPU Live Migration
Optimized by Software Dirty Page for
Full Virtualization . . . . . . . . . . 31--44
Adam Ruprecht and
Danny Jones and
Dmitry Shiraev and
Greg Harmon and
Maya Spivak and
Michael Krebs and
Miche Baker-Harvey and
Tyler Sanderson VM Live Migration At Scale . . . . . . . 45--56
Yu Xu and
Jianguo Yao and
Yaozu Dong and
Kun Tian and
Xiao Zheng and
Haibing Guan Demon: an Efficient Solution for
on-Device MMU Virtualization in Mediated
Pass-Through . . . . . . . . . . . . . . 57--70
Qiuchen Yan and
Stephen McCamant Fast PokeEMU: Scaling Generated
Instruction Tests Using Aggregation and
State Chaining . . . . . . . . . . . . . 71--83
Manuel Rigger and
Stefan Marr and
Stephen Kell and
David Leopoldseder and
Hanspeter Mössenböck An Analysis of x86-64 Inline Assembly in
C Programs . . . . . . . . . . . . . . . 84--99
Pavel Panchekha and
Adam T. Geller and
Michael D. Ernst and
Zachary Tatlock and
Shoaib Kamil Verifying that web pages have accessible
layout . . . . . . . . . . . . . . . . . 1--14
John Vilk and
Emery D. Berger BLeak: automatically debugging memory
leaks in web applications . . . . . . . 15--29
Samuel Baxter and
Rachit Nigam and
Joe Gibbs Politz and
Shriram Krishnamurthi and
Arjun Guha Putting in all the stops: execution
control for JavaScript . . . . . . . . . 30--45
Vaibhav Gogte and
Stephan Diestelhorst and
William Wang and
Satish Narayanasamy and
Peter M. Chen and
Thomas F. Wenisch Persistency for synchronization-free
regions . . . . . . . . . . . . . . . . 46--61
Shoaib Akram and
Jennifer B. Sartor and
Kathryn S. McKinley and
Lieven Eeckhout Write-rationing garbage collection for
hybrid memories . . . . . . . . . . . . 62--77
Chit-Kwan Lin and
Andreas Wild and
Gautham N. Chinya and
Tsung-Han Lin and
Mike Davies and
Hong Wang Mapping spiking neural networks onto a
manycore neuromorphic architecture . . . 78--89
Lucas Brutschy and
Dimitar Dimitrov and
Peter Müller and
Martin Vechev Static serializability analysis for
causal consistency . . . . . . . . . . . 90--104
Peizun Liu and
Thomas Wahl CUBA: interprocedural Context-UnBounded
Analysis of concurrent programs . . . . 105--119
Kostas Ferles and
Jacob Van Geffen and
Isil Dillig and
Yannis Smaragdakis Symbolic reasoning for automatic signal
placement . . . . . . . . . . . . . . . 120--134
Yu-Fang Chen and
Matthias Heizmann and
Ondrej Lengál and
Yong Li and
Ming-Hsien Tsai and
Andrea Turrini and
Lijun Zhang Advanced automata-based algorithms for
program termination checking . . . . . . 135--150
Guilherme Ottoni HHVM JIT: a profile-guided, region-based
compiler for PHP and Hack . . . . . . . 151--165
Daniele Cono D'Elia and
Camil Demetrescu On-stack replacement, distilled . . . . 166--180
Gregory J. Duck and
Roland H. C. Yap EffectiveSan: type and memory error
detection using dynamically typed C/C++ 181--195
Cheng Cai and
Qirun Zhang and
Zhiqiang Zuo and
Khanh Nguyen and
Guoqing Xu and
Zhendong Su Calling-to-reference context translation
via constraint-guided CFL-reachability 196--210
Nathan Chong and
Tyler Sorensen and
John Wickerson The semantics of transactions and weak
memory in x86, Power, ARM, and C++ . . . 211--225
Matthew Milano and
Andrew C. Myers MixT: a language for mixing consistency
in geodistributed transactions . . . . . 226--241
Stephen Dolan and
KC Sivaramakrishnan and
Anil Madhavapeddy Bounding data races in space and time 242--255
Alex Sanchez-Stern and
Pavel Panchekha and
Sorin Lerner and
Zachary Tatlock Finding root causes of floating point
error . . . . . . . . . . . . . . . . . 256--269
Ulf Adams Ry\=u: fast float-to-string conversion 270--282
Michael J. Steindorfer and
Jurgen J. Vinju To-many or to-one? All-in-one! Efficient
purely functional multi-maps with
type-heterogeneous hash-tries . . . . . 283--295
David Koeplinger and
Matthew Feldman and
Raghu Prabhakar and
Yaqi Zhang and
Stefan Hadjis and
Ruben Fiszel and
Tian Zhao and
Luigi Nardi and
Ardavan Pedram and
Christos Kozyrakis and
Kunle Olukotun Spatial: a language and compiler for
application accelerators . . . . . . . . 296--311
Orhan Kislal and
Jagadish Kotra and
Xulong Tang and
Mahmut Taylan Kandemir and
Myoungsoo Jung Enhancing computation-to-core assignment
with physical location information . . . 312--327
Kim-Anh Tran and
Alexandra Jimborean and
Trevor E. Carlson and
Konstantinos Koukos and
Magnus Själander and
Stefanos Kaxiras SWOOP: software-hardware co-design for
non-speculative, execute-ahead, in-order
cores . . . . . . . . . . . . . . . . . 328--343
Hongyu Liu and
Sam Silvestro and
Wei Wang and
Chen Tian and
Tongping Liu iReplayer: in-situ and identical
record-and-replay for multithreaded
applications . . . . . . . . . . . . . . 344--358
Bozhen Liu and
Jeff Huang D4: fast concurrency debugging with
parallel differential analysis . . . . . 359--373
Jake Roemer and
Kaan Genç and
Michael D. Bond High-coverage, unbounded sound
predictive race detection . . . . . . . 374--389
Yuanfeng Peng and
Vinod Grover and
Joseph Devietti CURD: a dynamic CUDA race detector . . . 390--403
Uri Alon and
Meital Zilberstein and
Omer Levy and
Eran Yahav A general path-based representation for
predicting program properties . . . . . 404--419
Yu Feng and
Ruben Martins and
Osbert Bastani and
Isil Dillig Program synthesis using conflict-driven
learning . . . . . . . . . . . . . . . . 420--435
Woosuk Lee and
Kihong Heo and
Rajeev Alur and
Mayur Naik Accelerating search-based program
synthesis using learned probabilistic
models . . . . . . . . . . . . . . . . . 436--449
Rumen Paletov and
Petar Tsankov and
Veselin Raychev and
Martin Vechev Inferring crypto API rules from code
changes . . . . . . . . . . . . . . . . 450--464
Sumit Gulwani and
Ivan Radicek and
Florian Zuleger Automated clustering and program repair
for introductory programming assignments 465--480
Ke Wang and
Rishabh Singh and
Zhendong Su Search, align, and repair: data-driven
feedback generation for introductory
programming exercises . . . . . . . . . 481--495
Van Chan Ngo and
Quentin Carbonneaux and
Jan Hoffmann Bounded expectations: resource analysis
for probabilistic programs . . . . . . . 496--512
Di Wang and
Jan Hoffmann and
Thomas Reps PMAF: an algebraic framework for static
analysis of probabilistic programs . . . 513--528
Aravind Acharya and
Uday Bondhugula and
Albert Cohen Polyhedral auto-transformation with no
integer linear programming . . . . . . . 529--542
Simon Moll and
Sebastian Hack Partial control-flow linearization . . . 543--556
Dong Chen and
Fangzhou Liu and
Chen Ding and
Sreepathi Pai Locality analysis through static
parallel sampling . . . . . . . . . . . 557--570
Marco Cusumano-Towner and
Benjamin Bichsel and
Timon Gehr and
Martin Vechev and
Vikash K. Mansinghka Incremental inference for probabilistic
programs . . . . . . . . . . . . . . . . 571--585
Timon Gehr and
Sasa Misailovic and
Petar Tsankov and
Laurent Vanbever and
Pascal Wiesmann and
Martin Vechev Bayonet: probabilistic inference for
networks . . . . . . . . . . . . . . . . 586--602
Vikash K. Mansinghka and
Ulrich Schaechtle and
Shivam Handa and
Alexey Radul and
Yutian Chen and
Martin Rinard Probabilistic programming with
programmable inference . . . . . . . . . 603--616
Brandon Bohrer and
Yong Kiam Tan and
Stefan Mitsch and
Magnus O. Myreen and
André Platzer VeriPhy: verified controller executables
from verified cyber--physical system
models . . . . . . . . . . . . . . . . . 617--630
Jeehoon Kang and
Yoonseung Kim and
Youngju Song and
Juneyoung Lee and
Sanghoon Park and
Mark Dongyeon Shin and
Yonghyun Kim and
Sungkeun Cho and
Joonwon Choi and
Chung-Kil Hur and
Kwangkeun Yi Crellvm: verified credible compilation
for LLVM . . . . . . . . . . . . . . . . 631--645
Ronghui Gu and
Zhong Shao and
Jieung Kim and
Xiongnan (Newman) Wu and
Jérémie Koenig and
Vilhelm Sjöberg and
Hao Chen and
David Costanzo and
Tahina Ramananandro Certified concurrent abstraction layers 646--661
Marcelo Taube and
Giuliano Losa and
Kenneth L. McMillan and
Oded Padon and
Mooly Sagiv and
Sharon Shoham and
James R. Wilcox and
Doug Woos Modularity for decidability of deductive
verification with applications to
distributed systems . . . . . . . . . . 662--677
Osbert Bastani and
Rahul Sharma and
Alex Aiken and
Percy Liang Active learning of points-to
specifications . . . . . . . . . . . . . 678--692
Qingkai Shi and
Xiao Xiao and
Rongxin Wu and
Jinguo Zhou and
Gang Fan and
Charles Zhang Pinpoint: fast and precise sparse value
flow analysis for million lines of code 693--706
He Zhu and
Stephen Magill and
Suresh Jagannathan A data-driven CHC solver . . . . . . . . 707--721
Mukund Raghothaman and
Sulekha Kulkarni and
Kihong Heo and
Mayur Naik User-guided program reasoning using
Bayesian inference . . . . . . . . . . . 722--735
Changwan Hong and
Aravind Sukumaran-Rajam and
Jinsung Kim and
Prashant Singh Rawat and
Sriram Krishnamoorthy and
Louis-Noël Pouchet and
Fabrice Rastello and
P. Sadayappan GPU code optimization using abstract
kernel emulation and sensitivity
analysis . . . . . . . . . . . . . . . . 736--751
Roshan Dathathri and
Gurbinder Gill and
Loc Hoang and
Hoang-Vu Dang and
Alex Brooks and
Nikoli Dryden and
Marc Snir and
Keshav Pingali Gluon: a communication-optimizing
substrate for distributed heterogeneous
graph analytics . . . . . . . . . . . . 752--768
Umut A. Acar and
Arthur Charguéraud and
Adrien Guatto and
Mike Rainey and
Filip Sieczkowski Heartbeat scheduling: provable
efficiency for nested parallelism . . . 769--782
Alejandro Serrano and
Jurriaan Hage and
Dimitrios Vytiniotis and
Simon Peyton Jones Guarded impredicative polymorphism . . . 783--796
William J. Bowman and
Amal Ahmed Typed closure conversion for the
calculus of constructions . . . . . . . 797--811
Justin Pombrio and
Shriram Krishnamurthi Inferring type rules for syntactic sugar 812--825
Stuart Byma and
James R. Larus Detailed heap profiling . . . . . . . . 1--13
Charles Tripp and
David Hyde and
Benjamin Grossman-Ponemon FRC: a high-performance concurrent
parallel deferred reference counter for
C++ . . . . . . . . . . . . . . . . . . 14--28
Steven R. Brandt and
Hari Krishnan and
Costas Busch and
Gokarna Sharma Distributed garbage collection for
general graphs . . . . . . . . . . . . . 29--44
Mohamed Ismail and
G. Edward Suh Hardware-software co-optimization of
memory management in dynamic languages 45--58
Rodrigo Bruno and
Paulo Ferreira and
Ruslan Synytsky and
Tetiana Fydorenchyk and
Jia Rao and
Hang Huang and
Song Wu Dynamic vertical memory scalability for
OpenJDK cloud applications . . . . . . . 59--70
Gurneet Kaur and
Keval Vora and
Sai Charan Koduru and
Rajiv Gupta OMR: out-of-core MapReduce for large
data sets . . . . . . . . . . . . . . . 71--83
Daniel Byrne and
Nilufer Onder and
Zhenlin Wang mPart: miss-ratio curve guided
partitioning in key--value stores . . . 84--95
Jacob Brock and
Chen Ding and
Rahman Lavaee and
Fangzhou Liu and
Liang Yuan Prediction and bounds on shared cache
demand from memory access interleaving 96--108
Michihiro Horie and
Hiroshi Horii and
Kazunori Ogata and
Tamiya Onodera Balanced double queues for GC
work-stealing on weak memory models . . 109--119
Rodrigo C. M. Santos and
Guilherme F. Lima and
Francisco Sant'Anna and
Roberto Ierusalimschy and
Edward H. Haeusler A memory-bounded, deterministic and
terminating semantics for the
synchronous programming language Céu . . 1--18
James Devine and
Joe Finney and
Peli de Halleux and
Micha\l Moskal and
Thomas Ball and
Steve Hodges MakeCode and CODAL: intuitive and
efficient embedded systems programming
for education . . . . . . . . . . . . . 19--30
Ben Taylor and
Vicent Sanz Marco and
Willy Wolff and
Yehia Elkhatib and
Zheng Wang Adaptive deep learning model selection
on embedded systems . . . . . . . . . . 31--43
Lei Han and
Zhaoyan Shen and
Zili Shao and
Tao Li Optimizing RAID/SSD controllers with
lifetime extension for flash-based SSD
array . . . . . . . . . . . . . . . . . 44--54
Mladen Skelin and
Marc Geilen Compositionality in scenario-aware
dataflow: a rendezvous perspective . . . 55--64
Michael Stokes and
Ryan Baird and
Zhaoxiang Jin and
David Whalley and
Soner Onder Decoupling address generation from loads
and stores to improve data access energy
efficiency . . . . . . . . . . . . . . . 65--75
Bernhard Egger and
Eunjin Song and
Hochan Lee and
Daeyoung Shin Verification of coarse-grained
reconfigurable arrays through random
test programs . . . . . . . . . . . . . 76--88
Andre Xian Ming Chang and
Aliasger Zaidy and
Lukasz Burzawa and
Eugenio Culurciello Deep neural networks compiler for a
trace-based accelerator (short WIP
paper) . . . . . . . . . . . . . . . . . 89--93
Francisco Sant'Anna and
Alexandre Sztajnberg and
Ana Lúcia de Moura and
Noemi Rodrigues Transparent standby for low-power,
resource-constrained embedded systems: a
programming language-based approach
(short WIP paper) . . . . . . . . . . . 94--98
Bharti Chimdyalwar and
Priyanka Darke Statically relating program properties
for efficient verification (short WIP
paper) . . . . . . . . . . . . . . . . . 99--103
Gaurav Chadha JSCore: architectural support for
accelerating JavaScript execution (short
WIP paper) . . . . . . . . . . . . . . . 104--108
Pavan Mehrotra and
Sabar Dasgupta and
Samantha Robertson and
Paul Nuyujukian An open-source realtime computational
platform (short WIP paper) . . . . . . . 109--112
Agustín Mista and
Alejandro Russo and
John Hughes Branching processes for QuickCheck
generators . . . . . . . . . . . . . . . 1--13
Joachim Breitner A promise checked is a promise kept:
inspection testing . . . . . . . . . . . 14--25
Martin A. T. Handley and
Graham Hutton AutoBench: comparing the time
performance of Haskell programs . . . . 26--37
Marilyn Sun and
Kathleen Fisher Autobahn 2.0: minimizing bangs while
maintaining performance (system
demonstration) . . . . . . . . . . . . . 38--40
Alejandro Serrano and
Victor Cacciari Miraldo Generic programming of all kinds . . . . 41--54
Baldur Blöndal and
Andres Löh and
Ryan Scott Deriving Via: or, how to turn
hand-written instances into an
anti-pattern . . . . . . . . . . . . . . 55--67
Guido Martínez and
Mauro Jaskelioff and
Guido De Luca Improving typeclass relations by being
open . . . . . . . . . . . . . . . . . . 68--80
Thomas Winant and
Dominique Devriese Coherent explicit dictionary application
for Haskell . . . . . . . . . . . . . . 81--93
Richard A. Eisenberg and
Joachim Breitner and
Simon Peyton Jones Type variables in patterns . . . . . . . 94--105
Divesh Otwani and
Richard A. Eisenberg The Thoralf plugin: for your fancy type
needs . . . . . . . . . . . . . . . . . 106--118
Matt Noonan Ghosts of departed proofs (functional
pearl) . . . . . . . . . . . . . . . . . 119--131
Niki Vazou and
Joachim Breitner and
Rose Kunkel and
David Van Horn and
Graham Hutton Theorem proving for all: equational
reasoning in liquid Haskell (functional
pearl) . . . . . . . . . . . . . . . . . 132--144
Manuel Bärenz and
Ivan Perez Rhine: FRP with type-level clocks . . . 145--157
Kazutaka Matsuda and
Meng Wang Embedding invertible languages with
binders: a case of the FliPpr language 158--171
Dong Han and
Tao He A high-performance multicore IO manager
based on \tt libuv (experience report) 172--178
Matthías Páll Gissurarson Suggesting valid hole fits for
typed-holes (experience report) . . . . 179--185
Preston Tunnell Wilson and
Ben Greenman and
Justin Pombrio and
Shriram Krishnamurthi The behavior of gradual types: a user
study . . . . . . . . . . . . . . . . . 1--12
Martin Bodin and
Tomás Diaz and
Éric Tanter A trustworthy mechanized formalization
of R . . . . . . . . . . . . . . . . . . 13--24
Mark Marron Log++ logging for a cloud-native world 25--36
Hanfeng Chen and
Joseph Vinish D'Silva and
Hongji Chen and
Bettina Kemme and
Laurie Hendren HorseIR: bringing array programming
languages together with database query
processing . . . . . . . . . . . . . . . 37--49
Manuel Serrano JavaScript AOT compilation . . . . . . . 50--63
Yoav Seginer and
Theo Vosse and
Gil Harari and
Uri Kolodny Query-based object-oriented programming:
a declarative web of objects . . . . . . 64--75
Guido Chari and
Javier Pimás and
Jan Vitek and
Olivier Flückiger Self-contained development environments 76--87
David Herrera and
Hanfeng Chen and
Erick Lavoie and
Laurie Hendren Numerical computing on the web:
benchmarking for the future . . . . . . 88--100
Karl Smeltzer and
Martin Erwig A domain-specific language for
exploratory data visualization . . . . . 1--13
Nicolas Stucki and
Aggelos Biboudis and
Martin Odersky A practical unification of multi-stage
programming and macros . . . . . . . . . 14--27
William Gallard Hatch and
Matthew Flatt Rash: from reckless interactions to
reliable programs . . . . . . . . . . . 28--39
Larissa Rocha Soares and
Jens Meinicke and
Sarah Nadi and
Christian Kästner and
Eduardo Santana de Almeida Exploring feature interactions without
specifications: a controlled experiment 40--52
Ebrahim Khalaj and
Marwan Abi-Antoun Inferring ownership domains from
refinements . . . . . . . . . . . . . . 53--65
Nic Volanschi and
Bernard Serpette and
Charles Consel Implementing a semi-causal
domain-specific language for context
detection over binary sensors . . . . . 66--78
Adilla Susungi and
Norman A. Rink and
Albert Cohen and
Jeronimo Castrillon and
Claude Tadonki Meta-programming for cross-domain tensor
optimizations . . . . . . . . . . . . . 79--92
Sven Peldszus and
Daniel Strüber and
Jan Jürjens Model-based security analysis of
feature-oriented software product lines 93--106
Laurent Christophe and
Coen De Roover and
Elisa Gonzalez Boix and
Wolfgang De Meuter Orchestrating dynamic analyses of
distributed processes for full-stack
JavaScript programs . . . . . . . . . . 107--118
Sebastian Ruland and
Lars Luthmann and
Johannes Bürdek and
Sascha Lity and
Thomas Thüm and
Malte Lochau and
Márcio Ribeiro Measuring effectiveness of sample-based
product-line testing . . . . . . . . . . 119--133
Weixin Zhang and
Bruno C. d. S. Oliveira Pattern matching in an open world . . . 134--146
Ahmad Salim Al-Sibahi and
Thomas P. Jensen and
Aleksandar S. Dimovski and
Andrzej Wasowski Verification of high-level
transformations with inductive
refinement types . . . . . . . . . . . . 147--160
Jácome Cunha and
Mihai Dan and
Martin Erwig and
Danila Fedorin and
Alex Grejuc Explaining spreadsheets with
spreadsheets (short paper) . . . . . . . 161--167
L. Thomas van Binsbergen Funcons for HGMP: the fundamental
constructs of homogeneous generative
meta-programming (short paper) . . . . . 168--174
Yin Liu and
Kijin An and
Eli Tilevich RT-trust: automated refactoring for
trusted execution under real-time
constraints . . . . . . . . . . . . . . 175--187
Michael Nieke and
Jacopo Mauro and
Christoph Seidl and
Thomas Thüm and
Ingrid Chieh Yu and
Felix Franzke Anomaly analyses for feature-model
evolution . . . . . . . . . . . . . . . 188--201
Gabriel Radanne and
Peter Thiemann Regenerate: a language generator for
extended regular expressions . . . . . . 202--214