Asynchronous multilevel adaptive methods for solving partial differential equations on multiprocessors: performance results. - Stephen F. McCormick; Daniel J. Quinlan (Parallel Comput., 1989)

P++, a C++ Virtual Shared Grids Based Programming Environment for Architecture-Independent Development of Structured Grid Applications. - Max Lemke; Daniel J. Quinlan (CONPAR, 1992)

P++, a Parallel C++ Array Class Library for Architecture-Independent Development of Structured Grid Applications. - Max Lemke; Daniel J. Quinlan (SIGPLAN Workshop, 1992)

A Comparison of Performance-Enhancing Strategies for Parallel Numerical Object-Oriented Frameworks. - Federico Bassetti; Kei Davis; Daniel J. Quinlan (ISCOPE, 1997)

Overture: An Object-Oriented Framework for Solving Partial Differential Equations. - David L. Brown; William D. Henshaw; Daniel J. Quinlan (ISCOPE, 1997)

Parallel Object-Oriented Adaptive Mesh Refinement. - Dinshaw S. Balsara; Daniel J. Quinlan (PP, 1997)

OVERTURE: An Object-Oriented Software System for Solving Partial Differential Equations in Serial and Parallel Environments. - David L. Brown; Geoffrey S. Chesshire; William D. Henshaw; Daniel J. Quinlan (PP, 1997)

MLB: Multilevel Load Balancing for Structured Grid Applications. - Daniel J. Quinlan; Markus Berndt (PP, 1997)

OVERTURE: Object-Oriented Parallel Adaptive Mesh Refinement for Serial and Parallel Environments. - David L. Brown; Kei Davis; William D. Henshaw; Daniel J. Quinlan; Kristi Brislawn (ECOOP Workshops, 1998)

ROSE: An Optimizing Transformation System for C++ Array-Class Libraries. - Kei Davis; Daniel J. Quinlan (ECOOP Workshops, 1998)

The Parallel Asynchronous Data Routing Environment PADRE. - Kei Davis; Daniel J. Quinlan (ECOOP Workshops, 1998)

C++ Expression Templates Performance Issues in Scientific Computing. - Federico Bassetti; Kei Davis; Daniel J. Quinlan (IPPS/SPDP, 1998)

Optimizing Transformations of Stencil Operations for Parallel Object-Oriented Scientific Frameworks on Cache-Based Architectures. - Federico Bassetti; Kei Davis; Daniel J. Quinlan (ISCOPE, 1998)

OVERTURE: An Object-Oriented Framework for High Performance Scientific Computing. - Federico Bassetti; David L. Brown; Kei Davis; William D. Henshaw; Daniel J. Quinlan (SC, 1998)

Improving Cache Utilization of Linear Relaxation Methods: Theory and Practice. - Federico Bassetti; Kei Davis; Madhav V. Marathe; Daniel J. Quinlan; Bobby Philip (ISCOPE, 1999)

Overture: Object-Oriented Tools for Applications with Complex Geometry. - David L. Brown; William D. Henshaw; Daniel J. Quinlan (ISCOPE, 1999)

Parallel Adaptive Mesh Refinement for Elliptic Equations. - Bobby Philip; Daniel J. Quinlan (PP, 1999)

ROSE: Compiler Support for Object-Oriented Frameworks. - Daniel J. Quinlan (Parallel Process. Lett., 2000)

The Specification of Source-to-Source Transformations for the Compile-Time Optimization of Parallel Object-Oriented Scientific Applications. - Daniel J. Quinlan; Markus Schordan; Bobby Philip; Markus Kowarschik (LCPC, 2001)

Treating a User-Defined Parallel Library as a Domain-Specific Language. - Daniel J. Quinlan; Brian Miller 001; Bobby Philip; Markus Schordan (IPDPS, 2002)

A Source-to-Source Architecture for User-Defined Optimizations. - Markus Schordan; Daniel J. Quinlan (JMLC, 2003)

Semantic-Driven Parallelization of Loops Operating on User-Defined Containers. - Daniel J. Quinlan; Markus Schordan; Qing Yi; Bronis R. de Supinski (LCPC, 2003)

A C++ Infrastructure for Automatic Introduction and Translation of OpenMP Directives. - Daniel J. Quinlan; Markus Schordan; Qing Yi; Bronis R. de Supinski (WOMPAT, 2003)

Asynchronous Fast Adaptive Composite-Grid Methods: Numerical Results. - Barry Lee; Stephen F. McCormick; Bobby Philip; Daniel J. Quinlan (SIAM J. Sci. Comput., 2003)

Topic 10: Parallel Programming: Models, Methods and Programming Languages. - Paul H. J. Kelly; Sergei Gorlatch; Christoph W. Kessler; Daniel J. Quinlan (Euro-Par, 2004)

Classification and Utilization of Abstractions for Optimization. - Daniel J. Quinlan; Markus Schordan; Qing Yi; Andreas Sæbjørnsen (ISoLA (Preliminary proceedings), 2004)

Applying Loop Optimizations to Object-Oriented Abstractions Through General Classification of Array Semantics. - Qing Yi; Daniel J. Quinlan (LCPC, 2004)

Parallel object-oriented framework optimization. - Daniel J. Quinlan; Markus Schordan; Brian Miller 001; Markus Kowarschik (Concurr. Comput. Pract. Exp., 2004)

Asynchronous Fast Adaptive Composite-Grid Methods for Elliptic Problems: Theoretical Foundations. - Barry Lee; Stephen F. McCormick; Bobby Philip; Daniel J. Quinlan (SIAM J. Numer. Anal., 2004)

An Extensible Open-Source Compiler Infrastructure for Testing. - Daniel J. Quinlan; Shmuel Ur; Richard W. Vuduc (Haifa Verification Conference, 2005)

Improving the computational intensity of unstructured mesh applications. - Brian S. White; Sally A. McKee; Bronis R. de Supinski; Brian Miller 001; Daniel J. Quinlan; Martin Schulz 001 (ICS, 2005)

Specifying Transformation Sequences as Computation on Program Fragments with an Abstract Attribute Grammar. - Markus Schordan; Daniel J. Quinlan (SCAM, 2005)

Topic 9: Parallel Programming: Models, Methods and Languages. - José C. Cunha; Sergei Gorlatch; Daniel J. Quinlan; Peter H. Welch (Euro-Par, 2006)

Annotating user-defined abstractions for optimization. - Daniel J. Quinlan; Markus Schordan; Richard W. Vuduc; Qing Yi (IPDPS, 2006)

Improving distributed memory applications testing by message perturbation. - Richard W. Vuduc; Martin Schulz 001; Daniel J. Quinlan; Bronis R. de Supinski; Andreas Sæbjørnsen (PADTAD, 2006)

Communicating Software Architecture using a Unified Single-View Visualization. - Thomas Panas; Thomas Epperly; Daniel J. Quinlan; Andreas Sæbjørnsen; Richard W. Vuduc (ICECCS, 2007)

POET: Parameterized Optimizations for Empirical Tuning. - Qing Yi; Keith Seymour; Haihang You; Richard W. Vuduc; Daniel J. Quinlan (IPDPS, 2007)

Techniques for specifying bug patterns. - Daniel J. Quinlan; Richard W. Vuduc; Ghassan Misherghi (PADTAD, 2007)

Towards Distributed Memory Parallel Program Analysis. - Daniel J. Quinlan; Gergö Barany; Thomas Panas (Scalable Program Analysis, 2008)

Using MPI Communication Patterns to Guide Source Code Transformations. - Robert Preissl; Martin Schulz 001; Dieter Kranzlmüller; Bronis R. de Supinski; Daniel J. Quinlan (ICCS (3), 2008)

Detecting Patterns in MPI Communication Traces. - Robert Preissl; Thomas Köckerbauer; Martin Schulz 001; Dieter Kranzlmüller; Bronis R. de Supinski; Daniel J. Quinlan (ICPP, 2008)

A projection-based optimization framework for abstractions with application to the unstructured mesh domain. - Brian S. White; Sally A. McKee; Daniel J. Quinlan (ICS, 2008)

Source code and binary analysis of software defects. - Daniel J. Quinlan; Thomas Panas (CSIIRW, 2009)

Reusable, generic program analyses and transformations. - Jeremiah Willcock; Andrew Lumsdaine; Daniel J. Quinlan (GPCE, 2009)

Detecting code clones in binary executables. - Andreas Sæbjørnsen; Jeremiah Willcock; Thomas Panas; Daniel J. Quinlan; Zhendong Su 001 (ISSTA, 2009)

Extending Automatic Parallelization to Optimize High-Level Abstractions for Multicore. - Chunhua Liao; Daniel J. Quinlan; Jeremiah Willcock; Thomas Panas (IWOMP, 2009)

Static Validation of C Preprocessor Macros. - Andreas Saebjoernsen; Lingxiao Jiang; Daniel J. Quinlan; Zhendong Su 001 (ASE, 2009)

Effective Source-to-Source Outlining to Support Whole Program Empirical Optimization. - Chunhua Liao; Daniel J. Quinlan; Richard W. Vuduc; Thomas Panas (LCPC, 2009)

Discovery of C++ data structures from binaries. - Daniel J. Quinlan; Cory Cohen (CSIIRW, 2010)

Exploitation of Dynamic Communication Patterns through Static Analysis. - Robert Preissl; Bronis R. de Supinski; Martin Schulz 001; Daniel J. Quinlan; Dieter Kranzlmüller; Thomas Panas (ICPP, 2010)

A ROSE-Based OpenMP 3.0 Research Compiler Supporting Multiple Runtime Libraries. - Chunhua Liao; Daniel J. Quinlan; Thomas Panas; Bronis R. de Supinski (IWOMP, 2010)

A symbolic verifier for CUDA programs. - Guodong Li; Ganesh Gopalakrishnan; Robert M. Kirby; Daniel J. Quinlan (PPoPP, 2010)

Transforming MPI source code based on communication patterns. - Robert Preissl; Martin Schulz 001; Dieter Kranzlmüller; Bronis R. de Supinski; Daniel J. Quinlan (Future Gener. Comput. Syst., 2010)

Semantic-Aware Automatic Parallelization of Modern Applications Using High-Level Abstractions. - Chunhua Liao; Daniel J. Quinlan; Jeremiah Willcock; Thomas Panas (Int. J. Parallel Program., 2010)

The Backstroke framework for source level reverse computation applied to parallel discrete event simulation. - George Vulov; Cong Hou; Richard W. Vuduc; Richard Fujimoto; Daniel J. Quinlan; David R. Jefferson (WSC, 2011)

Rethinking Hardware-Software Codesign for Exascale Systems. - John Shalf; Daniel J. Quinlan; Curtis L. Janssen (Computer, 2011)

Auto-tuning full applications: A case study. - Ananta Tiwari; Jeffrey K. Hollingsworth; Chun Chen 002; Mary W. Hall; Chunhua Liao; Daniel J. Quinlan; Jacqueline Chame (Int. J. High Perform. Comput. Appl., 2011)

A New Method for Program Inversion. - Cong Hou; George Vulov; Daniel J. Quinlan; David R. Jefferson; Richard Fujimoto; Richard W. Vuduc (CC, 2012)

Studying the impact of application-level optimizations on the power consumption of multi-core architectures. - Shah Mohammad Faizur Rahman; Jichi Guo; Akshatha Bhat; Carlos D. Garcia; Majedul Haque Sujon; Qing Yi; Chunhua Liao; Daniel J. Quinlan (Conf. Computing Frontiers, 2012)

ROSE: : FTTransform - A source-to-source translation framework for exascale fault-tolerance research. - Jacob Lidman; Daniel J. Quinlan; Chunhua Liao; Sally A. McKee (DSN Workshops, 2012)

An OpenMP Analyzer for Detecting Concurrency Errors. - Hongyi Ma; Qichang Chen; Liqiang Wang; Chunhua Liao; Daniel J. Quinlan (ICPP Workshops, 2012)

Auto-scoping for OpenMP Tasks. - Sara Royuela; Alejandro Duran; Chunhua Liao; Daniel J. Quinlan (IWOMP, 2012)

Synthesizing Loops for Program Inversion. - Cong Hou; Daniel J. Quinlan; David R. Jefferson; Richard Fujimoto; Richard W. Vuduc (RC, 2012)

Graphical processing units and scientific applications. - Beniamino Di Martino; Eduard Mehofer; Daniel J. Quinlan; Markus Schordan (Int. J. High Perform. Comput. Appl., 2012)

Symbolic Analysis of Concurrency Errors in OpenMP Programs. - Hongyi Ma; Steve Diersen; Liqiang Wang; Chunhua Liao; Daniel J. Quinlan; Zijiang Yang 006 (ICPP, 2013)

Early Experiences with the OpenMP Accelerator Model. - Chunhua Liao; Yonghong Yan 001; Bronis R. de Supinski; Daniel J. Quinlan; Barbara M. Chapman (IWOMP, 2013)

ForOpenCL: transformations exploiting array syntax in Fortran for accelerator programming. - Matthew J. Sottile; Craig Edward Rasmussen; Wayne N. Weseloh; Robert W. Robey; Daniel J. Quinlan; Jeffrey Overbey (Int. J. Comput. Sci. Eng., 2013)

An Automated Performance-Aware Approach to Reliability Transformations. - Jacob Lidman; Sally A. McKee; Daniel J. Quinlan; Chunhua Liao (Euro-Par Workshops (1), 2014)

Verification of Polyhedral Optimizations with Constant Loop Bounds in Finite State Space Computations. - Markus Schordan; Pei-Hung Lin; Daniel J. Quinlan; Louis-Noël Pouchet (ISoLA (2), 2014)

Experiences of Using the OpenMP Accelerator Model to Port DOE Stencil Applications. - Pei-Hung Lin; Chunhua Liao; Daniel J. Quinlan; Stephen M. Guzik (IWOMP, 2015)

Supporting multiple accelerators in high-level programming models. - Yonghong Yan 001; Pei-Hung Lin; Chunhua Liao; Bronis R. de Supinski; Daniel J. Quinlan (PMAM@PPoPP, 2015)

Reverse Code Generation for Parallel Discrete Event Simulation. - Markus Schordan; David R. Jefferson; Peter D. Barnes Jr.; Tomas Oppelstrup; Daniel J. Quinlan (RC, 2015)

Runtime checking C programs. - Reed Milewicz; Rajeshwar Vanka; James Tuck 001; Daniel J. Quinlan; Peter Pirkelbauer (SAC, 2015)

Enhancing domain specific language implementations through ontology. - Chunhua Liao; Pei-Hung Lin; Daniel J. Quinlan; Yue Zhao 011; Xipeng Shen (WOLFHPC@SC, 2015)

HBTM: A Heartbeat-based Behavior Detection Mechanism for POSIX Threads and OpenMP Applications. - Weidong Wang; Chunhua Liao; Liqiang Wang 001; Daniel J. Quinlan; Wei Lu 010 (CoRR, 2015)

Pragma-Controlled Source-to-Source Code Transformations for Robust Application Execution. - Pedro C. Diniz; Chunhua Liao; Daniel J. Quinlan; Robert F. Lucas (Euro-Par Workshops, 2016)

Automatically Optimizing Stencil Computations on Many-Core NUMA Architectures. - Pei-Hung Lin; Qing Yi; Daniel J. Quinlan; Chunhua Liao; Yongqing Yan (LCPC, 2016)

Automatic Generation of Reversible C++ Code and Its Performance in a Scalable Kinetic Monte-Carlo Application. - Markus Schordan; Tomas Oppelstrup; David R. Jefferson; Peter D. Barnes Jr.; Daniel J. Quinlan (SIGSIM-PADS, 2016)

Lightweight runtime checking of C programs with RTC. - Reed Milewicz; Rajeshwar Vanka; James Tuck 001; Daniel J. Quinlan; Peter Pirkelbauer (Comput. Lang. Syst. Struct., 2016)

Directive-based tile abstraction to distribute loops on accelerators. - Tristan Vanderbruggen; John Cavazos; Chunhua Liao; Daniel J. Quinlan (GPGPU@PPoPP, 2017)

Automatic translation of MPI source into a latency-tolerant, data-driven form. - Tan Nguyen 001; Pietro Cicotti; Eric J. Bylaska; Daniel J. Quinlan; Scott B. Baden (J. Parallel Distributed Comput., 2017)