%% This BibTeX bibliography file was created using BibDesk.
%% http://bibdesk.sourceforge.net/


%% Created for kmorel at 2016-01-11 16:38:01 -0700 


%% Saved with string encoding Unicode (UTF-8) 



@inproceedings{Larsen2015,
	Abstract = {Current architectural trends on supercomputers have dramatic increases in the number of cores and available computational power per die, but this power is increasingly difficult for programmers to harness effectively. High-level language constructs can simplify programming many-core devices, but this ease comes with a potential loss of processing power, particularly for cross-platform constructs. Recently, scientific visualization packages have embraced language constructs centering around data parallelism, with familiar operators such as map, reduce, gather, and scatter. Complete adoption of data parallelism will require that central visualization algorithms be revisited, and expressed in this new paradigm while preserving both functionality and performance. This investment has a large potential payoff: portable performance in software bases that can span over the many architectures that scientific visualization applications run on. With this work, we present a method for ray tracing consisting of entirely of data parallel primitives. Given the extreme computational power on nodes now prevalent on supercomputers, we believe that ray tracing can supplant rasterization as the work-horse graphics solution for scientific visualization. Our ray tracing method is relatively efficient, and we describe its performance with a series of tests, and also compare to leading-edge ray tracers that are optimized for specific platforms. We find that our data parallel approach leads to results that are acceptable for many scientific visualization use cases, with the key benefit of providing a single code base that can run on many architectures.},
	Annote = {An experiment where a ray tracer was written using a system of data-parallel primitives (specifically in EAVL although later work moved to VTK-m). The EAVL ray tracer was compared with NVIDIA's in-house solution designed specifically for CUDA (OptiX) and the Intel in-house solution for Xeon (Embree). The portable data-parallel primitive implementation got within a factor of two of each.},
	Author = {Matthew Larsen and Jeremy S. Meredith and Paul A. Navratil and Hank Childs},
	Booktitle = {IEEE Pacific Visualization Symposium (PacificVis)},
	Date-Added = {2016-01-11 23:37:50 +0000},
	Date-Modified = {2016-01-11 23:37:55 +0000},
	Month = {April},
	Note = {{DOI}~10.1109/PACIFICVIS.2015.7156388},
	Pages = {279--286},
	Title = {Ray Tracing Within a Data Parallel Framework},
	Year = {2015},
	Bdsk-Url-1 = {http://dx.doi.org/10.1109/PACIFICVIS.2015.7156388}}

@inproceedings{Lo2012,
	Abstract = {Due to the wide variety of current and next-generation supercomputing architectures, the development of highperformance parallel visualization and analysis operators frequently requires re-writing the underlying algorithms for many different platforms. In order to facilitate portability, we have devised a framework for creating such operators that employs the data-parallel programming model. By writing the operators using only data-parallel primitives (such as scans, transforms, stream compactions, etc.), the same code may be compiled to multiple targets using architecture-specific backend implementations of these primitives. Specifically, we make use of and extend NVIDIA's Thrust library, which provides CUDA and OpenMP backends. Using this framework, we have implemented isosurface, cut surface, and threshold operators, and have achieved good parallel performance on two different architectures (multi-core CPUs and NVIDIA GPUs) using the exact same operator code. We have applied these operators to several large, real scientific data sets, and have open-source released a beta version of our code base.},
	Annote = {A library providing portable implementations of visualization algorithms on multi- and many-core processors.  Uses Thrust to implement algorithms and portability.  Compares marching cubes isosurface generation to existing implementations by NVIDIA and VTK.
},
	Author = {Li-ta Lo and Chris Sewell and James Ahrens},
	Booktitle = {Eurographics Symposium on Parallel Graphics and Visualization},
	Date-Added = {2016-01-11 23:36:53 +0000},
	Date-Modified = {2016-01-11 23:36:58 +0000},
	Note = {{DOI}~10.2312/EGPGV/EGPGV12/011-020},
	Title = {{PISTON}: A Portable Cross-Platform Framework for Data-Parallel Visualization Operators},
	Year = {2012},
	Bdsk-Url-1 = {http://viz.lanl.gov/projects/PISTON.html},
	Bdsk-Url-2 = {http://dx.doi.org/10.2312/EGPGV/EGPGV12/011-020}}

@misc{ScientificDiscoveryExascale2011,
	Annote = {Workshop report on upcoming visualization challenges at exascale.  Big challenges include overcoming lower relative I/O rates through various more advanced I/O technologies such as in situ computations.  Also includes discussion on upcoming algorithmic challenges.},
	Author = {Sean Ahern and Arie Shoshani and Kwan-Liu Ma and others},
	Date-Added = {2016-01-11 23:31:41 +0000},
	Date-Modified = {2016-01-11 23:31:41 +0000},
	Howpublished = {Report from the DOE ASCR 2011 Workshop on Exascale Data Management, Analysis, and Visualization},
	Month = {February},
	Title = {Scientific Discovery at the Exascale},
	Year = {2011},
	Bdsk-Url-1 = {http://www.sandia.gov/~kmorel/documents/Exascale-ASCR-Analysis.pdf}}

@inproceedings{Moreland2012:PDAC:predecessors,
	Abstract = {We are on the threshold of a transformative change in the basic architecture of high-performance computing. The use of accelerator processors, characterized by large core counts, shared but asymmetrical memory, and heavy thread loading, is quickly becoming the norm in high performance computing. These accelerators represent significant challenges in updating our existing base of software. An intrinsic problem with this transition is a fundamental programming shift from message passing processes to much more fine thread scheduling with memory sharing. Another problem is the lack of stability in accelerator implementation; processor and compiler technology is currently changing rapidly. In this paper we describe our approach to address these two immediate problems with respect to scientific analysis and visualization algorithms. Our approach to accelerator programming forms the basis of the Dax toolkit, a framework to build data analysis and visualization algorithms applicable to exascale computing.},
	Annote = {A high level description of the Dax toolkit and more detailed descriptions of some features that allow it to flex to different applications and algorithms.  It describes how the device adapter allows the framework to be ported across architectures, how the array handle can mange different data layouts, and meta template programming magic allows you to define different algorithm signatures in worklets.  The paper also provides some test runs of the threshold algorithm and compares that with VTK and PISTON as well as running on multiple architectures.
},
	Author = {Kenneth Moreland and Brad King and Robert Maynard and Kwan-Liu Ma},
	Booktitle = {2012 SC Companion (Petascale Data Analytics: Challenges and Opportunities)},
	Date-Added = {2016-01-11 22:03:45 +0000},
	Date-Modified = {2016-01-11 23:33:14 +0000},
	Month = {November},
	Note = {{DOI}~10.1109/SC.Companion.2012.115},
	Pages = {821--826},
	Title = {Flexible Analysis Software for Emerging Architectures},
	Year = {2012},
	Bdsk-Url-1 = {http://dx.doi.org/10.1109/SC.Companion.2012.115}}

@inbook{Thrust:predecessors,
	Annote = {A portable STL-like template library for use on multi- and many-core systems.},
	Author = {Nathan Bell and Jared Hoberock},
	Chapter = {Thrust: A Productivity-Oriented Library for {CUDA}},
	Date-Added = {2016-01-11 21:56:53 +0000},
	Date-Modified = {2016-01-11 23:32:50 +0000},
	Month = {October},
	Pages = {359--371},
	Publisher = {Morgan Kaufmann},
	Title = {GPU Computing Gems, Jade Edition},
	Year = {2011}}

@article{Lorensen1987,
	Annote = {The seminal work on the marching cubes algorithm for contour/isosurface.},
	Author = {William E. Lorensen and Harvey E. Cline},
	Date-Added = {2015-08-29 21:47:15 +0000},
	Date-Modified = {2015-08-29 21:47:15 +0000},
	Journal = {Computer Graphics (Proceedings of SIGGRAPH 87)},
	Month = {July},
	Number = {4},
	Pages = {163--169},
	Title = {Marching Cubes: A High Resolution {3D} Surface Construction Algorithm},
	Volume = {21},
	Year = {1987}}

@inproceedings{Meredith2012,
	Abstract = {Analysis and visualization of the data generated by scientific simulation codes is a key step in enabling science from computation. However, a number of challenges lie along the current hardware and software paths to scientific discovery. First, only advanced parallelism techniques can take full advantage of the unprecedented scale of coming machines. In addition, as computational improvements outpace those of I/O, more data will be discarded and I/O-heavy analysis will suffer. Furthermore, the limited memory environment, particularly in the context of in situ analysis which can sidestep some I/O limitations, will require efficiency of both algorithms and infrastructure. Finally, advanced simulation codes with complex data models require commensurate data models in analysis tools. However, community visualization and analysis tools designed for parallelism and large data fall short in a number of these areas. In this paper, we describe EAVL, a new library with infrastructure and algorithms designed to address these critical needs for current and future generations of scientific software and hardware. We show results from EAVL demonstrating the strengths of its robust data model, advanced parallelism, and efficiency.},
	Annote = {Another EAVL paper with a bit more technical content than the GPGPU-5 reference. Talks a bit more about how the data model works and provides more examples.

Specifically talkes about dimentionality reduction, high order interpolation, scalar warp (called elevation in the paper) and threshold using advanced structures.
},
	Author = {Jeremy S. Meredith and Sean Ahern and Dave Pugmire and Robert Sisneros},
	Booktitle = {Eurographics Symposium on Parallel Graphics and Visualization (EGPGV)},
	Date-Added = {2015-08-26 14:39:52 +0000},
	Date-Modified = {2015-08-26 14:39:52 +0000},
	Note = {{DOI}~10.2312/EGPGV/EGPGV12/021-030},
	Pages = {21--30},
	Title = {{EAVL}: The Extreme-scale Analysis and Visualization Library},
	Year = {2012},
	Bdsk-Url-1 = {http://dx.doi.org/10.2312/EGPGV/EGPGV12/021-030}}

@inproceedings{Moreland2013:UltraVis,
	Abstract = {As the number of cores in processors increase and accelerator architectures
are becoming more common, an ever greater number of threads is required to
achieve full processor utilization. Our current parallel scientific
visualization codes rely on partitioning data to achieve parallel
processing, but this approach will not scale as we approach massive
threading in which work is distributed in such a fine level that each
thread is responsible for a minute portion of data. In this paper we
characterize the challenges of refactoring our current visualization
algorithms by considering the finest portion of work each performs and
examining the domain of input data, overlaps of output domains, and
interdependencies among work instances. We divide our visualization
algorithms into eight categories, each containing algorithms with the same
interdependencies. By focusing our research efforts to solving these
categorial challenges rather than this legion of individual algorithms, we
can make attainable advancement for extreme computing.
},
	Annote = {Classifies all (well, most) of the filters in ParaView into catagories based on how they break up data, how they map input to output, and what collective work is done. This paper is meant to serve a basis for the worklet types implemented in Dax.},
	Author = {Kenneth Moreland and Berk Geveci and Kwan-Liu Ma and Robert Maynard},
	Booktitle = {Proceedings of Ultrascale Visualization Workshop},
	Date-Added = {2015-08-25 22:49:02 +0000},
	Date-Modified = {2015-08-25 22:49:02 +0000},
	Month = {November},
	Note = {{DOI}~10.1145/2535571.2535591},
	Title = {A Classification of Scientific Visualization Algorithms for Massive Threading},
	Year = {2013},
	Bdsk-Url-1 = {http://dx.doi.org/10.1145/2535571.2535591}}

@book{Blelloch1990,
	Abstract = {Vector Models for Data-Parallel Computing describes a model of parallelism that extends and formalizes the Data-Parallel model on which the Connection Machine and other supercomputers are based. It presents many algorithms based on the model, ranging from graph algorithms to numerical algorithms, and argues that data-parallel models are not only practical and can be applied to a surprisingly wide variety of problems, they are also well suited for very-high-level languages and lead to a concise and clear description of algorithms and their complexity. Many of the author's ideas have been incorporated into the instruction set and into algorithms currently running on the Connection Machine.

The book includes the definition of a parallel vector machine; an extensive description of the uses of the scan (also called parallel-prefix) operations; the introduction of segmented vector operations; parallel data structures for trees, graphs, and grids; many parallel computational-geometry, graph, numerical and sorting algorithms; techniques for compiling nested parallelism; a compiler for Paralation Lisp; and details on the implementation of the scan operations.},
	Annote = {Seminal work on using scans and other basic parallel algorithms to build more specific data-parallel algorithms.},
	Author = {Guy E. Blelloch},
	Date-Added = {2015-08-25 22:16:17 +0000},
	Date-Modified = {2015-08-25 22:16:17 +0000},
	Note = {{ISBN}~0-262-02313-X},
	Publisher = {MIT Press},
	Title = {Vector Models for Data-Parallel Computing},
	Year = {1990}}

@inproceedings{Lindstrom2000,
	Abstract = {We present an algorithm for out-of-core simplification of large polygonal datasets that are too complex to fit in main memory. The algorithm extends the vertex clustering scheme of Rossignac and Borrel [13] by using error quadric information for the placement of each cluster's representative vertex, which better preserves fine details and results in a low mean geometric error. The use of quadrics instead of the vertex grading approach in [13] has the additional benefits of requiring less disk space and only a single pass over the model rather than two. The resulting linear time algorithm allows simplification of datasets of arbitrary complexity. In order to handle degenerate quadrics associated with (near) flat regions and regions with zero Gaussian curvature, we present a robust method for solving the corresponding underconstrained least-squares problem. The algorithm is able to detect these degeneracies and handle them gracefully. Key features of the simplification method include a bounded Hausdorff error, low mean geometric error, high simplification speed (up to 100,000 triangles/second reduction), output (but not input) sensitive memory requirements, no disk space overhead, and a running time that is independent of the order in which vertices and triangles occur in the mesh.},
	Annote = {The mesh simplification algorithm used by the Quadric Clustring filter in VTK.},
	Author = {Peter Lindstrom},
	Booktitle = {Proceedings of SIGGRAPH '00},
	Date-Added = {2015-08-24 15:29:19 +0000},
	Date-Modified = {2015-08-24 15:29:19 +0000},
	Month = {August},
	Note = {{DOI}~10.1145/344779.344912},
	Pages = {259--262},
	Title = {Out-of-Core Simplification of Large Polygonal Models},
	Year = {2000},
	Bdsk-Url-1 = {http://dx.doi.org/10.1145/344779.344912}}

@misc{ASCACSummaryReport2010,
	Annote = {A workshop report prediciting the nature of an Exascale machine.  A reasonable source to pull some numbers comparing petascale to exascale machines (a la slide of doom).  See [Moreland2011:LDAV] for a usage.

Declares a real need for science in going to exascale (Executive Summary findings).

Also declares multicore-friendly algorithms as an important algorithmic challenge (S 5.5.1) and the difficulty in updating our exiting code base to the new architecture (S 5.6.4).},
	Author = {Steve Ashby and others},
	Date-Added = {2015-07-23 20:22:52 +0000},
	Date-Modified = {2015-07-23 20:22:52 +0000},
	Howpublished = {Summary Report of the Advanced Scientific Computing Advisory Committee (ASCAC) Subcommittee},
	Month = {Fall},
	Title = {The Opportunities and Challenges of Exascale Computing},
	Year = {2010},
	Bdsk-Url-1 = {http://science.energy.gov/~/media/ascr/ascac/pdf/reports/exascale_subcommittee_report.pdf}}

@techreport{DARPAExascaleStudy,
	Annote = {An exascale workshop study.  I've specifically used this one to pull out the following quote to demonstrate the limitation of memory that we have at the exascale:

  The concurrency challenge is manifest in the need for software to expose
  at least 1000$\times$ more concurrency in applications for Extreme Scale
  systems, relative to current systems. It is further exacerbated by the
  projected memory-computation imbalances in Extreme Scale systems, with
  Bytes/Ops ratios that may drop to values as low as $10^{-2}$ where Bytes
  and Ops represent the main memory and computation capacities of the
  system respectively. These ratios will result in 100$\times$ reductions
  in memory per core relative to Petascale systems, with accompanying
  reductions in memory bandwidth per core.  Thus, a significant fraction of
  software concurrency in Extreme Scale systems must come from exploiting
  more parallelism within the computation performed on a single datum.
},
	Author = {Mark Richards and others},
	Date-Added = {2015-07-23 20:13:48 +0000},
	Date-Modified = {2015-07-23 20:13:48 +0000},
	Institution = {DARPA Information Processing Techniques Office (IPTO)},
	Month = {September},
	Title = {ExaScale Software Study: Software Challenges in Extreme Scale Systems},
	Year = {2009}}

@techreport{ExascaleArchitecturesReport,
	Annote = {Another workshop report for predicting exascale computers and the necessary changes for it.},
	Author = {Rick Stevens and Andrew White and others},
	Date-Added = {2015-07-23 20:13:40 +0000},
	Date-Modified = {2015-07-23 20:13:40 +0000},
	Institution = {ASCR Scientific Grand Challenges Workshop Series},
	Month = {December},
	Title = {Architectures and Technology for Extreme Scale Computing},
	Year = {2009},
	Bdsk-Url-1 = {http://science.energy.gov/~/media/ascr/pdf/program-documents/docs/Arch_tech_grand_challenges_report.pdf}}

@techreport{ExascaleRoadMap,
	Annote = {A workshop report prediciting the nature of an Exascale machine.  A reasonable source to pull some numbers comparing petascale to exascale machines (a la slide of doom).  See [Moreland2011:LDAV] for a usage.},
	Author = {Jack Dongarra and Pete Beechman and others},
	Date-Added = {2015-07-23 20:13:33 +0000},
	Date-Modified = {2015-07-23 20:13:33 +0000},
	Institution = {University of Tennessee},
	Month = {January},
	Number = {ut-cs-10-652},
	Title = {The International Exascale Software Project RoadMap},
	Year = {2010},
	Bdsk-Url-1 = {http://www.cs.utk.edu/~library/TechReports/2010/ut-cs-10-652.pdf}}

@misc{ScientificDiscoveryExascale2011:predecessors,
	Annote = {Workshop report on upcoming visualization challenges at exascale.  Big challenges include overcoming lower relative I/O rates through various more advanced I/O technologies such as in situ computations.  Also includes discussion on upcoming algorithmic challenges.},
	Author = {Sean Ahern and Arie Shoshani and Kwan-Liu Ma and others},
	Date-Added = {2015-07-23 20:12:24 +0000},
	Date-Modified = {2016-01-11 23:31:51 +0000},
	Howpublished = {Report from the DOE ASCR 2011 Workshop on Exascale Data Management, Analysis, and Visualization},
	Month = {February},
	Title = {Scientific Discovery at the Exascale},
	Year = {2011},
	Bdsk-Url-1 = {http://www.sandia.gov/~kmorel/documents/Exascale-ASCR-Analysis.pdf}}

@inproceedings{Larsen2015:portability,
	Abstract = {Current architectural trends on supercomputers have dramatic increases in the number of cores and available computational power per die, but this power is increasingly difficult for programmers to harness effectively. High-level language constructs can simplify programming many-core devices, but this ease comes with a potential loss of processing power, particularly for cross-platform constructs. Recently, scientific visualization packages have embraced language constructs centering around data parallelism, with familiar operators such as map, reduce, gather, and scatter. Complete adoption of data parallelism will require that central visualization algorithms be revisited, and expressed in this new paradigm while preserving both functionality and performance. This investment has a large potential payoff: portable performance in software bases that can span over the many architectures that scientific visualization applications run on. With this work, we present a method for ray tracing consisting of entirely of data parallel primitives. Given the extreme computational power on nodes now prevalent on supercomputers, we believe that ray tracing can supplant rasterization as the work-horse graphics solution for scientific visualization. Our ray tracing method is relatively efficient, and we describe its performance with a series of tests, and also compare to leading-edge ray tracers that are optimized for specific platforms. We find that our data parallel approach leads to results that are acceptable for many scientific visualization use cases, with the key benefit of providing a single code base that can run on many architectures.},
	Annote = {An experiment where a ray tracer was written using a system of data-parallel primitives (specifically in EAVL although later work moved to VTK-m). The EAVL ray tracer was compared with NVIDIA's in-house solution designed specifically for CUDA (OptiX) and the Intel in-house solution for Xeon (Embree). The portable data-parallel primitive implementation got within a factor of two of each.},
	Author = {Matthew Larsen and Jeremy S. Meredith and Paul A. Navratil and Hank Childs},
	Booktitle = {IEEE Pacific Visualization Symposium (PacificVis)},
	Date-Added = {2015-07-23 18:40:52 +0000},
	Date-Modified = {2016-01-11 23:37:11 +0000},
	Month = {April},
	Note = {{DOI}~10.1109/PACIFICVIS.2015.7156388},
	Pages = {279--286},
	Title = {Ray Tracing Within a Data Parallel Framework},
	Year = {2015},
	Bdsk-Url-1 = {http://dx.doi.org/10.1109/PACIFICVIS.2015.7156388}}

@inproceedings{Lo2012:predecessors,
	Abstract = {Due to the wide variety of current and next-generation supercomputing architectures, the development of highperformance parallel visualization and analysis operators frequently requires re-writing the underlying algorithms for many different platforms. In order to facilitate portability, we have devised a framework for creating such operators that employs the data-parallel programming model. By writing the operators using only data-parallel primitives (such as scans, transforms, stream compactions, etc.), the same code may be compiled to multiple targets using architecture-specific backend implementations of these primitives. Specifically, we make use of and extend NVIDIA's Thrust library, which provides CUDA and OpenMP backends. Using this framework, we have implemented isosurface, cut surface, and threshold operators, and have achieved good parallel performance on two different architectures (multi-core CPUs and NVIDIA GPUs) using the exact same operator code. We have applied these operators to several large, real scientific data sets, and have open-source released a beta version of our code base.},
	Annote = {A library providing portable implementations of visualization algorithms on multi- and many-core processors.  Uses Thrust to implement algorithms and portability.  Compares marching cubes isosurface generation to existing implementations by NVIDIA and VTK.
},
	Author = {Li-ta Lo and Chris Sewell and James Ahrens},
	Booktitle = {Eurographics Symposium on Parallel Graphics and Visualization},
	Date-Added = {2015-07-23 18:26:30 +0000},
	Date-Modified = {2016-01-11 23:32:35 +0000},
	Note = {{DOI}~10.2312/EGPGV/EGPGV12/011-020},
	Title = {{PISTON}: A Portable Cross-Platform Framework for Data-Parallel Visualization Operators},
	Year = {2012},
	Bdsk-Url-1 = {http://viz.lanl.gov/projects/PISTON.html},
	Bdsk-Url-2 = {http://dx.doi.org/10.2312/EGPGV/EGPGV12/011-020}}

@article{Fuller2011:mixedmode,
	Abstract = {The end of dramatic exponential growth in single-processor performance marks the end of the dominance of the single microproessor in computing. The era of sequential computing must give way to an era in which parallelism holds the forefront. Although important scientific and engineering challenges lie ahead, this is an opportune time for innovation in programming systems and computing architectures.},
	Annote = {This is neither the first nor the last time a paper has observed clock rates flatlining and core counts rising. However, it gives a very complete and clear description. More importantly, it backs up its claims with an interesting and data-rich plot of processor specifications dating between 1985 and 2010. The data show a clear shift in trends in 2004.},
	Author = {Samuel H. Fuller and Lynette I. Millett},
	Date-Added = {2015-07-23 13:18:20 +0000},
	Date-Modified = {2016-01-11 23:36:34 +0000},
	Journal = {IEEE Computer},
	Month = {January},
	Note = {{DOI}~10.1109/MC.2011.15},
	Number = {1},
	Pages = {31--38},
	Title = {Computing Performance: Game Over or Next Level?},
	Volume = {44},
	Year = {2011},
	Bdsk-Url-1 = {http://dx.doi.org/10.1109/MC.2011.15}}

@article{Childs2010:mixedmode,
	Annote = {Explores the scaling of visualization pipelines (VisIt specifically) on full petascale machines.},
	Author = {Hank Childs and David Pugmire and Sean Ahern and Brad Whitlock and Mark Howison and Prabhat and Gunther H. Weber and E. Wes Bethel},
	Date-Added = {2015-07-21 20:53:50 +0000},
	Date-Modified = {2016-01-11 23:36:25 +0000},
	Journal = {IEEE Computer Graphics and Applications},
	Month = {May/June},
	Note = {{DOI}~10.1109/MCG.2010.51},
	Number = {3},
	Pages = {22--31},
	Title = {Extreme Scaling of Production Visualization Software on Diverse Architectures},
	Volume = {30},
	Year = {2010},
	Bdsk-Url-1 = {http://dx.doi.org/10.1109/MCG.2010.51}}

@article{Childs2013,
	Abstract = {As the visualization research community reorients its software to address up-coming challenges, it must successfully deal with diverse processor architectures, distributed systems, various data sources, massive parallelism, multiple input and output devices, and interactivity.
},
	Annote = {This article gives a high level overview of the challenges of large-scale HPC visualization in the exascale/extreme scale from a technical standpoint.  The issues raised are: Massive Parallelization, Processor Architectures and Programming Models, Application Architecture and Data Management, Data Models, Rendering, and Interaction.},
	Author = {Hank Childs and Berk Geveci and Will Schroeder and Jeremy Meredith and Kenneth Moreland and Christopher Sewell and Torsten Kuhlen and E. Wes Bethel},
	Date-Added = {2015-07-21 20:50:31 +0000},
	Date-Modified = {2015-07-21 20:50:31 +0000},
	Journal = {IEEE Computer},
	Month = {May},
	Note = {{DOI}~10.1109/MC.2013.179},
	Number = {5},
	Pages = {34--42},
	Title = {Research Challenges for Visualization Software},
	Volume = {46},
	Year = {2013},
	Bdsk-Url-1 = {http://dx.doi.org/10.1109/MC.2013.179}}

@inproceedings{Law1999:mixedmode,
	Annote = {Describes out-of-core streaming in VTK/visualization pipelines.  Also describes the properties an algorithm must have to enable streaming: separable, result invariant, and mappable.},
	Author = {C. Charles Law and Kenneth M. Martin and William J. Schroeder and Joshua Temkin},
	Booktitle = {Proceedings of IEEE Visualization 1999},
	Date-Added = {2015-07-09 21:44:17 +0000},
	Date-Modified = {2016-01-11 23:36:10 +0000},
	Month = {October},
	Pages = {225--232},
	Title = {A Multi-Threaded Streaming Pipeline Architecture for Large Structured Data Sets},
	Year = {1999}}

@inproceedings{EAVL2012EGPGV:predecessors,
	Author = {Meredith, J. S. and Ahern, S. and Pugmire, D. and Sisneros, R.},
	Booktitle = {Eurographics Symposium on Parallel Graphics and Visualization},
	Date-Modified = {2016-01-11 23:34:05 +0000},
	Isbn = {3905674351},
	Pages = {21--30},
	Publisher = {The Eurographics Association},
	Title = {{EAVL:} The Extreme-scale Analysis and Visualization Library},
	Year = {2012}}

@inproceedings{BDAC:Pugmire14,
	Author = {David Pugmire and James Kress and Jeremy Meredith and Norbert Podhorszki and Jong Choi and Scott Klasky},
	Booktitle = {Big Data Analytics: Challenges and Opportunities (BDAC-14) Workshop at Supercomputing Conference},
	Month = {November},
	Title = {Towards Scalable Visualization Plugins for Data Staging Workflows},
	Year = {2014}}

@article{HelloADIOS,
	Author = {Liu, Qing and Logan, Jeremy and Tian, Yuan and Abbasi, Hasan and Podhorszki, Norbert and Choi, Jong Youl and Klasky, Scott and Tchoua, Roselyne and Lofstead, Jay and Oldfield, Ron and Parashar, Manish and Samatova, Nagiza and Schwan, Karsten and Shoshani, Arie and Wolf, Matthew and Wu, Kesheng and Yu, Weikuan},
	Doi = {10.1002/cpe.3125},
	Issn = {1532-0634},
	Journal = {Concurrency and Computation: Practice and Experience},
	Keywords = {high performance computing, high performance I/O, I/O middleware},
	Number = {7},
	Pages = {1453--1473},
	Title = {Hello {ADIOS}: the challenges and lessons of developing leadership class {I/O} frameworks},
	Url = {http://dx.doi.org/10.1002/cpe.3125},
	Volume = {26},
	Year = {2014},
	Bdsk-Url-1 = {http://dx.doi.org/10.1002/cpe.3125}}

@article{chang2009compressed,
	Author = {C. S. Chang and S. Ku and P. H. Diamond and Z. Lin and S. Parker and T. S. Hahm and N. Samatova},
	Date-Modified = {2015-09-14 17:54:28 +0000},
	Journal = {Physics of Plasmas},
	Note = {{DOI}~10.1063/1.3099329},
	Number = {5},
	Pages = {056108},
	Publisher = {AIP Publishing},
	Title = {Compressed ion temperature gradient turbulence in diverted tokamak edge},
	Volume = {16},
	Year = {2009}}

@article{docan2014,
	Author = {Docan, Ciprian and Zhang, Fan and Jin, Tong and Bui, Hoang and Sun, Qian and Cummings, Julian and Podhorszki, Norbert and Klasky, Scott and Parashar, Manish},
	Journal = {Concurrency and Computation: Practice and Experience},
	Pages = {1-22},
	Publisher = {Wiley Online Library},
	Title = {ActiveSpaces: Exploring dynamic code deployment for extreme scale data processing},
	Year = {2014}}
