@misc{1989infocomStatusLine,
  title = {The {Status} {Line}},
  author = {{Infocom}},
  date = {1989-21},
  url = {https://archive.org/details/Status_Line_The_Vol._VIII_No._1_1984-01_Infocom_US},
  keywords = {ejr-CV,mention},
  note = {Solved Puzzle \#18.}
}

@inproceedings{1997wilsonEfficientSIMDEvaluation,
  title = {Efficient {{SIMD}} Evaluation of Image Processing Programs},
  booktitle = {Parallel and Distributed Methods for Image Processing},
  author = {Wilson, Joseph N. and Riedy, E. Jason},
  editor = {Shi, Hongchi and Coffield, Patrick C.},
  date = {1997-07},
  volume = {3166},
  pages = {199--210},
  publisher = {SPIE},
  location = {San Diego, CA},
  doi = {10.1117/12.279618},
  abstract = {SIMD parallel systems have been employed for image processing and computer vision applications since their inception. This paper describes a system in which parallel programs are implemented using a machine-independent, retargetable object library that provides SIMD execution on the Lockheed Martin PAL-I SIMD parallel processor. Programs' performance on this machine is improved through on-the-fly execution analysis and scheduling. We describe the relevant elements of the system structure, the general scheme for execution analysis, and the current cost model for scheduling.},
  keywords = {ejr-CV,image algebra,parallel algorithm,proceedings}
}

@unpublished{1999riedyMicrobenchmarkingTeraMTA,
  title = {Microbenchmarking the {{Tera MTA}}},
  author = {Riedy, E. Jason and Vuduc, Rich},
  date = {1999-05},
  abstract = {The Tera Multithreaded Architecture, or MTA, addresses scalable shared memory system design with a difierent approach; it tolerates latency through providing fast access to multiple threads of execution. The MTA employs a number of radical design ideas: creation of hardware threads (streams) with frequent context switching; full-empty bits for each memory word; a flat memory hierarchy; and deep pipelines. Recent evaluations of the MTA have taken a top-down approach: port applications and application benchmarks, and compare the absolute performance with conventional systems. While useful, these studies do not reveal the effect of the Tera MTA's unique hardware features on an application. We present a bottom-up approach to the evaluation of the MTA via a suite of microbenchmarks to examine in detail the underlying hardware mechanisms and the cost of runtime system support for multithreading. In particular, we measure memory, network, and instruction latencies; memory bandwidth; the cost of low-level synchronization via full-empty bits; overhead for stream management; and the effects of software pipelining. These data should provide a foundation for performance modeling on the MTA. We also present results for list ranking on the MTA, an application which has traditionally been difficult to scale on conventional parallel systems.},
  keywords = {ejr-CV,memory-centric,novel architecture,parallel algorithm,unpublished},
  note = {Cited}
}

@incollection{1999wilsonImageAlgebraBased,
  title = {An {{Image Algebra}} Based {{SIMD}} Image Processing Environment},
  booktitle = {Visual Information Representation, Communication, and Image Processing},
  author = {Wilson, Joseph N. and Riedy, E. Jason and Ritter, Gerhard X. and Shi, Hongchi},
  editor = {Chen, C. W. and Zhang, Y. Q.},
  date = {1999},
  pages = {523--542},
  publisher = {Marcel Dekker},
  location = {New York},
  abstract = {SIMD parallel computers have been employed for image related applications since their inception. They have been leading the way in improving processing speed for those applications. However, current parallel programming technologies have not kept pace with the performance growth and cost decline of parallel hardware. A highly usable parallel software development environment is needed. This chapter presents a computing environment that integrates a SIMD mesh architecture with image algebra for high-performance image processing applications. The environment describes parallel programs through a machine-independent, retargetable image algebra object library that supports SIMD execution on the Lockheed Martin PAL-I parallel computer. Program performance on this machine is improved through on-the-fly execution analysis and scheduling. We describe the relevant elements of the system structure, outline the scheme for execution analysis, and provide examples of the current cost model and scheduling system.},
  isbn = {0-8247-1928-X},
  keywords = {book-chapter,ejr-CV,image algebra,parallel algorithm}
}

@unpublished{2000riedyPowerControlNetworked,
  title = {Power and Control in Networked Sensors},
  author = {Riedy, E. Jason and Szewczyk, Robert},
  date = {2000-05},
  abstract = {The fundamental constraint on a networked sensor is its energy consumption, since it may be either impossible or not feasible to replace its energy source. We analyze the power dissipation implications of implementing the network sensor with either a central processor switching between I/O devices or a family of processors, each dedicated to a single device. We present the energy measurements of the current generations of networked sensors, and develop an abstract description of tradeoffs between both designs.},
  keywords = {ejr-CV,embedded,IoT,novel architecture,sensor,unpublished},
  note = {Cited}
}

@unpublished{2002bindelExceptionHandlingInterfaces,
  title = {Exception Handling Interfaces, Implementations, and Evaluation},
  author = {Bindel, David and Riedy, E. Jason},
  date = {2002-08},
  url = {http://grouper.ieee.org/groups/754/meeting-materials/2002-08-22-pres.pdf},
  keywords = {ejr-CV,floating point,ieee754,presentation}
}

@unpublished{2002riedyParallelBipartiteMatching,
  title = {Parallel Bipartite Matching for Sparse Matrix Computation},
  author = {Riedy, E. Jason},
  date = {2002-03},
  venue = {Livermore, CA},
  keywords = {ejr-CV,graph analysis,parallel algorithm,presentation,sparse matrix}
}

@unpublished{2003riedyParallelBipartiteMatching,
  title = {Parallel Bipartite Matching for Sparse Matrix Computations},
  author = {Riedy, E. Jason},
  date = {2003-02},
  url = {http://purl.oclc.org/NET/jason-riedy/resume/material/siam-cse03-poster.pdf},
  abstract = {Practical and efficient methods exist for parallelizing the numerical work in sparse matrix calculations. The initial symbolic analysis is now becoming a sequential bottleneck, limiting problems' sizes. One such analysis is the weighted bipartite matching used to achieve scalable, unsymmetric LU factorization in Super\textsc{lu}. Applying a mathematical optimization algorithm produces a distributed-memory implementation with explicit trade-offs between speed and matching quality. We present accuracy and performance results for this phase alone and in the context of Super\textsc{lu}.},
  keywords = {ejr-CV,graph analysis,linear algebra,parallel algorithm,presentation,sparse matrix}
}

@unpublished{2003riedyPracticalAlternativesParallel,
  title = {Practical Alternatives for Parallel Pivoting},
  author = {Riedy, E. Jason},
  date = {2003-06},
  url = {http://purl.oclc.org/NET/jason-riedy/resume/material/siam-am03.pdf},
  abstract = {Traditional pivoting during parallel, unsymmetric LU factorization introduces heavy communication and restructuring costs. Possible alternatives include pre-pivoting to place heavy elements along the diagonal and limited pivoting that maintains the factors' structures. Each alternative comes with trade-offs that affect accuracy and performance.},
  keywords = {ejr-CV,graph analysis,linear algebra,parallel algorithm,presentation,sparse matrix}
}

@unpublished{2004riedyParallelWeightedBipartite,
  title = {Parallel Weighted Bipartite Matching and Applications},
  author = {Riedy, E. Jason},
  date = {2004-02},
  url = {http://purl.oclc.org/NET/jason-riedy/resume/material/pp04.pdf},
  abstract = {Bipartite matching is one of graph theory's workhorses, occuring in the solution or approximation of many problems. Increasingly, applications' data spans multiple memory spaces, but there is little recent experience with distributed matching algorithms. We present a distributed, parallel implementation for weighted bipartite matching based on Bertsekas's auction algorithm. The bidding process finds local matchings while summarizing updates for occasional communication, leading to superlinear speed-ups on some sparse problems and modest performance on others.},
  keywords = {ejr-CV,graph analysis,parallel algorithm,presentation,sparse matrix}
}

@unpublished{2004riedySparseDataStructures,
  title = {Sparse Data Structures for Weighted Bipartite Matching},
  author = {Riedy, E. Jason},
  date = {2004-02},
  url = {http://purl.oclc.org/NET/jason-riedy/resume/material/csc04.pdf},
  keywords = {ejr-CV,graph analysis,presentation,sparse matrix}
}

@report{2005demmelErrorBoundsExtraprecise,
  type = {LAPACK Working Note},
  title = {Error Bounds from Extra-Precise Iterative Refinement},
  author = {Demmel, James W. and Hida, Yozo and Kahan, W. and Li, Xiaoye S. and Mukherjee, Sonil and Riedy, E. Jason},
  date = {2005-02},
  number = {165},
  institution = {Netlib},
  url = {http://www.netlib.org/lapack/lawnspdf/lawn165.pdf},
  abstract = {We present the design and testing of an algorithm for iterative refinement of the solution of linear equations, where the residual is computed with extra precision. This algorithm was originally proposed in the 1960s [6, 22] as a means to compute very accurate solutions to all but the most ill-conditioned linear systems of equations. However two obstacles have until now prevented its adoption in standard subroutine libraries like LAPACK: (1) There was no standard way to access the higher precision arithmetic needed to compute residuals, and (2) it was unclear how to compute a reliable error bound for the computed solution. The completion of the new BLAS Technical Forum Standard [5] has recently removed the first obstacle. To overcome the second obstacle, we show how a single application of iterative refinement can be used to compute an error bound in any norm at small cost, and use this to compute both an error bound in the usual infinity norm, and a componentwise relative error bound. We report extensive test results on over 6.2 million matrices of dimension 5, 10, 100, and 1000. As long as a normwise (resp. componentwise) condition number computed by the algorithm is less than 1/max\{10,√n\}ε\textsubscript{w} , the computed normwise (resp. componentwise) error bound is at most 2max\{10,√n\}⋅ε\textsubscript{w} , and indeed bounds the true error. Here, n is the matrix dimension and ε\textsubscript{w} is single precision roundoff error. For worse conditioned problems, we get similarly small correct error bounds in over 89.4\% of cases.},
  keywords = {ejr-CV,technical-report},
  note = {Also issued as UCB//CSD-05-1414, UT-CS-05-547, and LBNL-56965; expanded from TOMS version}
}

@inproceedings{2005houghArithmeticInteractionsHardware,
  title = {Arithmetic Interactions: {{From}} Hardware to Applications},
  booktitle = {17th {{IEEE}} Symposium on Computer Arithmetic ({{ARITH}}'05)},
  author = {Hough, David and Hay, Bill and Kidder, Jeff and Riedy, E. Jason and Jr., Guy L. Steele and Thomas, Jim},
  date = {2005-06},
  doi = {10.1109/ARITH.2005.10},
  abstract = {The entire process of creating and executing applications that solve interesting problems with acceptable cost and accuracy involves a complex interaction among hardware, system software, programming environments, mathematical software libraries, and applications software, all mediated by standards for arithmetic, operating systems, and programming environments. This panel will discuss various issues arising among these various contending points of view, sometimes from the point of view of issues raised during the current IEEE 754R standards revision effort.},
  isbn = {0-7695-2366-8},
  keywords = {ejr-CV,floating point,ieee754,proceedings},
  note = {See http://purl.oclc.org/NET/jason-riedy/resume/material/arith17-slides.pdfrelated presentation}
}

@report{2005marquesBenefitsIEEE754Features,
  type = {LAPACK Working Note},
  title = {Benefits of {{IEEE-754}} Features in Modern Symmetric Tridiagonal Eigensolvers},
  author = {Marques, Osni A. and Riedy, E. Jason and Vömel, Christof},
  date = {2005-09},
  number = {172},
  institution = {Netlib},
  url = {http://www.netlib.org/lapack/lawnspdf/lawn172.pdf},
  abstract = {Bisection is one of the most common methods used to compute the eigenvalues of symmetric tridiagonal matrices. Bisection relies on the Sturm count: For a given shift sigma, the number of negative pivots in the factorization T-σI=LDL\textsuperscript{T} equals the number of eigenvalues of T that are smaller than sigma. In IEEE-754 arithmetic, the value ∞ permits the computation to continue past a zero pivot, producing a correct Sturm count when T is unreduced. Demmel and Li showed [IEEE Trans. Comput., 43 (1994), pp. 983–992] that using ∞ rather than testing for zero pivots within the loop could significantly improve performance on certain architectures. When eigenvalues are to be computed to high relative accuracy, it is often preferable to work with LDL\textsuperscript{T} factorizations instead of the original tridiagonal T. One important example is the MRRR algorithm. When bisection is applied to the factored matrix, the Sturm count is computed from LDL\textsuperscript{T} which makes differential stationary and progressive qds algorithms the methods of choice. While it seems trivial to replace T by LDL\textsuperscript{T}, in reality these algorithms are more complicated: In IEEE-754 arithmetic, a zero pivot produces an overflow followed by an invalid exception (NaN, or “Not a Number”) that renders the Sturm count incorrect. We present alternative, safe formulations that are guaranteed to produce the correct result. Benchmarking these algorithms on a variety of platforms shows that the original formulation without tests is always faster provided that no exception occurs. The transforms see speed-ups of up to 2.6x over the careful formulations. Tests on industrial matrices show that encountering exceptions in practice is rare. This leads to the following design: First, compute the Sturm count by the fast but unsafe algorithm. Then, if an exception occurs, recompute the count by a safe, slower alternative. The new Sturm count algorithms improve the speed of bisection by up to 2x on our test matrices. Furthermore, unlike the traditional tiny-pivot substitution, proper use of IEEE-754 features provides a careful formulation that imposes no input range restrictions.},
  keywords = {ejr-CV,technical-report},
  note = {Also issued as UCB//CSD-05-1414; expanded from SISC version}
}

@unpublished{2005riedyFutureLAPACKScaLAPACK,
  title = {The Future of {{LAPACK}} and {{ScaLAPACK}}},
  author = {Riedy, E. Jason and Hida, Yozo and Demmel, James W.},
  date = {2005-11},
  url = {http://purl.oclc.org/NET/jason-riedy/resume/material/future-of-scalapack.pdf},
  abstract = {We are planning new releases of the widely used LAPACK and ScaLAPACK numerical linear algebra libraries. Based on an on-going user survey (http://www.netlib.org/lapack-dev) and research by many people, we are proposing the following improvements: Faster algorithms (including better numerical methods, memory hierarchy optimizations, parallelism, and automatic performance tuning to accomodate new architectures), more accurate algorithms (including better numerical methods, and use of extra precision), expanded functionality (including updating and downdating, new eigenproblems, etc. and putting more of LAPACK into ScaLAPACK), and improved ease of use (friendlier interfaces in multiple languages). To accomplish these goals we are also relying on better software engineering techniques and contributions from collaborators at many institutions. This is joint work with Jack Dongarra.},
  keywords = {ejr-CV,floating point,lapack,linear algebra,presentation}
}

@unpublished{2005riedyModernLanguageTools,
  title = {Modern Language Tools and {{754R}}},
  author = {Riedy, E. Jason},
  date = {2005-06},
  url = {http://purl.oclc.org/NET/jason-riedy/resume/material/arith17-slides.pdf},
  keywords = {ejr-CV,foating point,invited-presentation,lapack,linear algebra,sparse matrix},
  note = {Invited presentation and panelist}
}

@unpublished{2005riedyParallelCombinatorialComputing,
  title = {Parallel Combinatorial Computing and Sparse Matrices},
  author = {Riedy, E. Jason},
  date = {2005-02},
  url = {http://purl.oclc.org/NET/jason-riedy/resume/material/cse05.pdf},
  abstract = {Increasingly, sparse matrix applications produce matrices too large for a single computer's memory. Distributed, parallel computers provide an avenue around memory limitations, but distributing combinatorial algorithms is historically difficult. We use insights from combinatorial optimization to design loosely coupled algorithms for sparse matrix matching, ordering, and symbolic factorization. These algorithms' performance depends on both problem instance and computer architecture. We investigate these aspects of performance and demonstrate issues that affect distributed combinatorial computing.},
  keywords = {ejr-CV,graph analysis,parallel algorithm,presentation,sparse matrix}
}

@article{2006demmelErrorBoundsExtraprecise,
  title = {Error Bounds from Extra-Precise Iterative Refinement},
  author = {Demmel, James W. and Hida, Yozo and Kahan, W. and Li, Xiaoye S. and Mukherjee, Sonil and Riedy, E. Jason},
  date = {2006-06},
  journaltitle = {ACM Transactions on Mathematical Software},
  volume = {32},
  number = {2},
  pages = {325--351},
  issn = {0098-3500},
  doi = {10.1145/1141885.1141894},
  abstract = {We present the design and testing of an algorithm for iterative refinement of the solution of linear equations where the residual is computed with extra precision. This algorithm was originally proposed in 1948 and analyzed in the 1960s as a means to compute very accurate solutions to all but the most ill-conditioned linear systems. However, two obstacles have until now prevented its adoption in standard subroutine libraries like LAPACK: (1) There was no standard way to access the higher precision arithmetic needed to compute residuals, and (2) it was unclear how to compute a reliable error bound for the computed solution. The completion of the new BLAS Technical Forum Standard has essentially removed the first obstacle. To overcome the second obstacle, we show how the application of iterative refinement can be used to compute an error bound in any norm at small cost and use this to compute both an error bound in the usual infinity norm, and a componentwise relative error bound.},
  keywords = {ejr-CV,floating point,ieee754,lapack,linear algebra,refereed}
}

@inproceedings{2006demmelProspectusNextLAPACK,
  title = {Prospectus for the next {{LAPACK}} and {{ScaLAPACK}} Libraries},
  booktitle = {{{PARA}}'06: {{State-of-the-art}} in Scientific and Parallel Computing},
  author = {Demmel, James W. and Dongarra, Jack and Parlett, Beresford and Kahan, W. and Gu, Ming and Bindel, David and Hida, Yozo and Li, Xiaoye S. and Marques, Osni A. and Riedy, E. Jason and Vömel, Christof and Langou, Julien and Luszczek, Piotr and Kurzak, Jakub and Buttari, Alfredo and Langou, Julie and Tomov, Stanimire},
  date = {2006-06},
  publisher = {{Springer / High Performance Computing Center North (HPC2N) and the Department of Computing Science, Umeå University}},
  location = {Umeå, Sweden},
  doi = {10.1007/978-3-540-75755-9\_2},
  url = {http://www.netlib.org/utk/people/JackDongarra/PAPERS/para06-lapack.pdf},
  abstract = {LAPACK and ScaLAPACK are widely used software libraries for numerical linear algebra. There have been over 68M web hits at www.netlib.org for the associated libraries LAPACK, ScaLAPACK, CLAPACK and LAPACK95. LAPACK and ScaLAPACK are used to solve leading edge science problems and they have been adopted by many vendors and software providers as the basis for their own libraries, including AMD, Apple (under Mac OS X), Cray, Fujitsu, HP, IBM, Intel, NEC, SGI, several Linux distributions (such as Debian), NAG, IMSL, the MathWorks (producers of MATLAB), Interactive Supercomputing, and PGI. Future improvements in these libraries will therefore have a large impact on users.},
  keywords = {ejr-CV,floating point,lapack,linear algebra,proceedings}
}

@online{2006dongarraScaLAPACKProgram,
  title = {Sca/{{LAPACK}} Program Style},
  author = {Dongarra, Jack and Langou, Julien and Riedy, E. Jason},
  date = {2006-08},
  url = {http://www.netlib.org/lapack-dev/lapack-coding/program-style.html},
  abstract = {The purpose of this document is to facilitate contributions to LAPACK and ScaLAPACK by documenting their design and implementation guidelines. The long-term goal is to provide guidelines for both LAPACK and ScaLAPACK. However, the parallel ScaLAPACK code has more open issues, so this document primarily concerns LAPACK.},
  keywords = {blas,ejr-CV,lapack,linear algebra,unpublished}
}

@article{2006marquesBenefitsIEEE754Features,
  title = {Benefits of {{IEEE-754}} Features in Modern Symmetric Tridiagonal Eigensolvers},
  author = {Marques, Osni and Riedy, Jason E. and Vömel, Christof},
  date = {2006},
  journaltitle = {SIAM journal on scientific computing},
  volume = {28},
  number = {5},
  pages = {1613--1633},
  location = {United States},
  issn = {1064-8275},
  doi = {10.1137/050641624},
  abstract = {Bisection is one of the most common methods used to compute the eigenvalues of symmetric tridiagonal matrices. Bisection relies on the Sturm count: For a given shift a, the number of negative pivots in the factorization T - \{sigma\}I = LDL\{sup T\} equals the number of eigenvalues of T that are smaller than a. In IEEE-754 arithmetic, the value oo permits the computation to continue past a zero pivot, producing a correct Sturm count when T is unreduced. Demmel and Li showed that using oo rather than testing for zero pivots within the loop could significantly improve performance on certain architectures. When eigenvalues are to be computed to high relative accuracy, it is often preferable to work with LDL\{sup T\} factorizations instead of the original tridiagonal T. One important example is the MRRR algorithm. When bisection is applied to the factored matrix, the Sturm count is computed from LDL\{sup T\} which makes differential stationary and progressive qds algorithms the methods of choice. While it seems trivial to replace T by LDL\{sup T\}, in reality these algorithms are more complicated: In IEEE-754 arithmetic, a zero pivot produces an overflow followed by an invalid exception (NaN, or 'Not a Number') that renders the Sturm count incorrect. We present alternative, safe formulations that are guaranteed to produce the correct result. Benchmarking these algorithms on a variety of platforms shows that the original formulation without tests is always faster provided that no exception occurs. The transforms see speed-ups of up to 2.6x over the careful formulations. Tests on industrial matrices show that encountering exceptions in practice is rare. This leads to the following design: First, compute the Sturm count by the fast but unsafe algorithm. Then, if an exception occurs, recompute the count by a safe, slower alternative. The new Sturm count algorithms improve the speed of bisection by up to 2x on our test matrices. Furthermore, unlike the traditional tiny-pivot substitution, proper use of IEEE-754 features provides a careful formulation that imposes no input range restrictions.},
  langid = {english},
  keywords = {Algorithms,Design,Eigenvalues,ejr-CV,floating point,ieee754,lapack,linear algebra,Matrices,refereed,Testing},
  file = {/home/ejr/Zotero/storage/W2RI8EZV/Marques et al. - 2006 - Benefits of IEEE-754 features in modern symmetric tridiagonal eigensolvers.pdf}
}

@unpublished{2006riedyMakingStaticPivoting,
  title = {Making Static Pivoting Dependable},
  author = {Riedy, E. Jason},
  date = {2006-03},
  url = {http://purl.oclc.org/NET/jason-riedy/resume/material/bascd2006-poster.pdf},
  abstract = {For sparse LU factorization, dynamic pivoting tightly couples symbolic and numerical computation. Dynamic structural changes limit parallel scalability. Demmel and Li use static pivoting in distributed SuperLU for performance, but intentionally perturbing the input may lead silently to erroneous results. Are there experimentally stable static pivoting heuristics that lead to a dependable direct solver? The answer is currently a qualified yes. Current heuristics fail on a few systems, but all failures are detectable.},
  venue = {Livermore, CA},
  keywords = {ejr-CV,floating point,graph analysis,linear algebra,presentation,sparse matrix}
}

@report{2007demmelExtrapreciseIterativeRefinement,
  type = {LAPACK Working Note},
  title = {Extra-Precise Iterative Refinement for Overdetermined Least Squares Problems},
  author = {Demmel, James W. and Hida, Yozo and Li, Xiaoye S. and Riedy, E. Jason},
  date = {2007-05},
  number = {188},
  institution = {Netlib},
  url = {http://www.netlib.org/lapack/lawnspdf/lawn188.pdf},
  abstract = {We present the algorithm, error bounds, and numerical results for extra-precise iterative refinement applied to overdetermined linear least squares (LLS) problems. We apply our linear system refinement algorithm to Björck’s augmented linear system formulation of an LLS problem. Our algorithm reduces the forward normwise and componentwise errors to O(ε) unless the system is too ill conditioned. In contrast to linear systems, we provide two separate error bounds for the solution x and the residual r. The refinement algorithm requires only limited use of extra precision and adds only O(mn) work to the O(mn²) cost of QR factorization for problems of size m-by-n. The extra precision calculation is facilitated by the new extended-precision BLAS standard in a portable way, and the refinement algorithm will be included in a future release of LAPACK and can be extended to the other types of least squares problems.},
  keywords = {ejr-CV,technical-report},
  note = {Also issued as UCB/EECS-2007-77; version accepted for TOMS.}
}

@unpublished{2007demmelPreciseSolutionsOverdetermined,
  title = {Precise Solutions for Overdetermined Least Squares Problems},
  author = {Demmel, James W. and Hida, Yozo and Li, Xiaoye S. and Riedy, E. Jason and Vishvanath, Meghana and Vu, David},
  date = {2007-03},
  url = {http://purl.oclc.org/NET/jason-riedy/resume/material/bascd2007-poster.pdf},
  abstract = {Linear least squares (LLS) fitting is the most widely used data modeling technique and is included in almost every data analysis system (e.g. spreadsheets). These software systems often give no feedback on the conditioning of the LLS problem or the floating-point calculation errors present in the solution. With limited use of extra precision, we can eliminate these concerns for all but the most ill-conditioned LLS problems. Our algorithm provides either a solution and residual with relatively tiny error or a notice that the LLS problem is too ill-conditioned.},
  venue = {Stanford, CA},
  keywords = {blas,ejr-CV,floating point,lapack,least squares,linear algebra,presentation}
}

@report{2007demmelProspectusNextLAPACK,
  type = {LAPACK Working Note},
  title = {Prospectus for the next {{LAPACK}} and {{ScaLAPACK}} Libraries},
  author = {Demmel, James W. and Dongarra, Jack and Parlett, Beresford and Kahan, W. and Gu, Ming and Bindel, David and Hida, Yozo and Li, Xiaoye S. and Marques, Osni A. and Riedy, E. Jason and Vömel, Christof and Langou, Julien and Luszczek, Piotr and Kurzak, Jakub and Buttari, Alfredo and Langou, Julie and Tomov, Stanimire},
  date = {2007-02},
  number = {181},
  institution = {Netlib},
  url = {http://www.netlib.org/lapack/lawnspdf/lawn181.pdf},
  keywords = {ejr-CV,technical-report},
  note = {Also issued as UT-CS-07-592}
}

@report{2008demmelNonnegativeDiagonalsHigh,
  type = {LAPACK Working Note},
  title = {Non-Negative Diagonals and High Performance on Low-Profile Matrices from {{Householder QR}}},
  author = {Demmel, James W. and Hoemmen, Mark Frederick and Hida, Yozo and Riedy, E. Jason},
  date = {2008-05},
  number = {203},
  institution = {Netlib},
  url = {http://www.netlib.org/lapack/lawnspdf/lawn203.pdf},
  abstract = {The Householder reflections used in LAPACK's QR factorization leave positive and negative real entries along R's diagonal. This is sufficient for most applications of QR factorizations, but a few require that R have a nonnegative diagonal. This note describes a new Householder generation routine to produce a nonnegative diagonal. Additionally, we find that scanning for trailing zeros in the generated reflections leads to large performance improvements when applying reflections with many trailing zeros. Factoring low-profile matrices, those with nonzero entries mostly near the diagonal (e.g., band matrices), now require far fewer operations. For example, QR factorization of matrices with profile width b that are stored densely in an n×n matrix improves from O(n³) to O(n²+nb²). These routines are in LAPACK 3.2.},
  keywords = {ejr-CV,technical-report},
  note = {Also issued as UCB/EECS-2008-76; modified from SISC version.}
}

@standard{2008ieee754committeeIEEEStandardFloatingpoint,
  type = {IEEE Std},
  title = {{{IEEE}} Standard for Floating-Point Arithmetic},
  author = {{IEEE 754 Committee}},
  date = {2008-08},
  number = {754--2008},
  publisher = {Microprocessor Standards Committee of the IEEE Computer Society},
  location = {New York, NY},
  doi = {10.1109/IEEESTD.2008.4610935},
  abstract = {This standard specifies interchange and arithmetic formats and methods for binary and decimal floating-point arithmetic in computer programming environments. This standard specifies exception conditions and their default handling. An implementation of a floating-point system conforming to this standard may be realized entirely in software, entirely in hardware, or in any combination of software and hardware. For operations specified in the normative part of this standard, numerical results and exceptions are uniquely determined by the values of the input data, sequence of operations, and destination formats, all under user control.},
  isbn = {978-0-7381-5753-5},
  keywords = {754-2008,arithmetic,arithmetic formats,binary,computer,computer programming,decimal,decimal floating-point arithmetic,ejr-CV,exponent,floating point arithmetic,floating-point,format,IEEE standard,IEEE standards,interchange,NaN,number,programming,rounding,significand,subnormal,technical-report},
  note = {(committee member and contributor)}
}

@unpublished{2008riedyAuctionsDistributedPossibly,
  title = {Auctions for Distributed (and Possibly Parallel) Matchings},
  author = {Riedy, E. Jason},
  date = {2008-12},
  url = {http://www.cerfacs.fr/},
  keywords = {ejr-CV,foating point,invited-presentation,lapack,linear algebra,sparse matrix},
  note = {Invited presentation}
}

@article{2009demmelExtrapreciseIterativeRefinement,
  title = {Extra-Precise Iterative Refinement for Overdetermined Least Squares Problems},
  author = {Demmel, James W. and Hida, Yozo and Li, Xiaoye S. and Riedy, E. Jason},
  date = {2009-02},
  journaltitle = {ACM Transactions on Mathematical Software},
  volume = {35},
  number = {4},
  pages = {1--32},
  issn = {0098-3500},
  doi = {10.1145/1462173.1462177},
  abstract = {We present the algorithm, error bounds, and numerical results for extra-precise iterative refinement applied to overdetermined linear least squares (LLS) problems. We apply our linear system refinement algorithm to Björck’s augmented linear system formulation of an LLS problem. Our algorithm reduces the forward normwise and componentwise errors to O(ε) unless the system is too ill conditioned. In contrast to linear systems, we provide two separate error bounds for the solution x and the residual r. The refinement algorithm requires only limited use of extra precision and adds only O(mn) work to the O(mn²) cost of QR factorization for problems of size m-by-n. The extra precision calculation is facilitated by the new extended-precision BLAS standard in a portable way, and the refinement algorithm will be included in a future release of LAPACK and can be extended to the other types of least squares problems.},
  keywords = {ejr-CV,floating point,ieee754,lapack,linear algebra,refereed}
}

@article{2009demmelNonnegativeDiagonalsHigh,
  title = {Non-Negative Diagonals and High Performance on Low-Profile Matrices from {{Householder QR}}},
  author = {Demmel, James W. and Hoemmen, Mark Frederick and Hida, Yozo and Riedy, E. Jason},
  date = {2009-07},
  journaltitle = {SIAM Journal on Scientific Computing},
  volume = {31},
  number = {4},
  pages = {2832--2841},
  publisher = {SIAM},
  issn = {1064-8275},
  doi = {10.1137/080725763},
  abstract = {The Householder reflections used in LAPACK's QR factorization leave positive and negative real entries along R's diagonal. This is sufficient for most applications of QR factorizations, but a few require that R have a nonnegative diagonal. This note describes a new Householder generation routine to produce a nonnegative diagonal. Additionally, we find that scanning for trailing zeros in the generated reflections leads to large performance improvements when applying reflections with many trailing zeros. Factoring low-profile matrices, those with nonzero entries mostly near the diagonal (e.g., band matrices), now require far fewer operations. For example, QR factorization of matrices with profile width b that are stored densely in an n×n matrix improves from O(n³) to O(n²+nb²). These routines are in LAPACK 3.2.},
  keywords = {ejr-CV,floating-point,Householder reflection,lapack,LAPACK,linear algebra,QR factorization,refereed}
}

@report{2009e.jasonriedycopiDynamicGraphData,
  title = {Dynamic Graph Data Structures in {{X10}}},
  author = {{E. Jason Riedy (coPI)} and {David A. Bader (PI)}},
  date = {2009-12},
  institution = {Georgia Institute of Technology},
  keywords = {ejr-CV,grants},
  note = {\$20\,000}
}

@unpublished{2009riedyDependableDirectSolutions,
  title = {Dependable Direct Solutions for Linear Systems Using a Little Extra Precision},
  author = {Riedy, E. Jason},
  date = {2009-08},
  eprint = {1853/29795},
  eprinttype = {hdl},
  url = {http://hdl.handle.net/1853/29795},
  abstract = {Solving a square linear system Ax=b often is considered a black box. It's supposed to "just work," and failures often are blamed on the original data or subtleties of floating-point. Now that we have an abundance of cheap computations, however, we can do much better. A little extra precision in just the right places produces accurate solutions cheaply or demonstrates when problems are too hard to solve without significant cost. This talk will outline the method, iterative refinement with a new twist; the benefits, small backward and forward errors; and the trade-offs and unexpected benefits.},
  keywords = {ejr-CV,foating point,lapack,linear algebra,presentation,sparse matrix},
  note = {Invited presentation}
}

@unpublished{2010baderGraph500Benchmark,
  title = {Graph 500 Benchmark 1 (“Search”)},
  author = {Bader, David A. and Berry, Jonathan and Kahan, Simon and Murphy, Richard and Riedy, E. Jason and Willcock, Jeremiah},
  date = {2010-10},
  url = {http://www.graph500.org/Specifications.html},
  keywords = {ejr-CV,graph analysis,mistake,parallel algorithm,unpublished},
  note = {Version 1.1}
}

@report{2010e.jasonriedypiSTINGSpatiotemporalInteraction,
  title = {{{STING}}: {{Spatio-temporal}} Interaction Networks and Graphs; an Open-Source Dynamic Graph Package for Intel Platforms},
  author = {{E. Jason Riedy (PI)} and {David A. Bader}},
  date = {2010-04},
  institution = {Georgia Institute of Technology},
  keywords = {ejr-CV,grants},
  note = {\$375\,000}
}

@inproceedings{2010edigerMassiveSocialNetwork,
  title = {Massive Social Network Analysis: {{Mining}} Twitter for Social Good},
  booktitle = {39th International Conference on Parallel Processing ({{ICPP}})},
  author = {Ediger, David and Jiang, Karl and Riedy, E. Jason and Bader, David A. and Corley, Courtney and Farber, Rob and Reynolds, William N.},
  date = {2010-09},
  location = {San Diego, CA},
  doi = {10.1109/ICPP.2010.66},
  abstract = {Social networks produce an enormous quantity of data. Facebook consists of over 400 million active users sharing over 5 \mkbibemph{billion} pieces of information each month. Analyzing this vast quantity of unstructured data presents challenges for software and hardware. We present GraphCT, a \mkbibemph{Graph C}haracterization \mkbibemph{T}ooklit for massive graphs representing social network data. On a 128-processor Cray XMT, GraphCT estimates the betweenness centrality of an artificially generated (R-MAT) 537 million vertex, 8.6 billion edge graph in 55 minutes. We use GraphCT to analyze public data from Twitter, a microblogging network. Twitter's message connections appear primarily tree-structured as a news dissemination system. Within the public data, however, are clusters of conversations. Using GraphCT, we can rank actors within these conversations and help analysts focus attention on a much smaller data subset.},
  keywords = {ejr-CV,graph analysis,hpda,parallel algorithm,proceedings,streaming data}
}

@inproceedings{2010edigerMassiveStreamingData,
  title = {Massive Streaming Data Analytics: A Case Study with Clustering Coefficients},
  booktitle = {4th Workshop on Multithreaded Architectures and Applications ({{MTAAP}})},
  author = {Ediger, David and Jiang, Karl and Riedy, E. Jason and Bader, David A.},
  date = {2010-04},
  location = {Atlanta, GA},
  doi = {10.1109/IPDPSW.2010.5470687},
  abstract = {We present a new approach for parallel massive graph analysis of streaming, temporal data with a dynamic and extensible representation. Handling the constant stream of new data from health care, security, business, and social network applications requires new algorithms and data structures. We examine data structure and algorithm trade-offs that extract the parallelism necessary for high-performance updating analysis of massive graphs. Static analysis kernels often rely on storing input data in a specific structure. Maintaining these structures for each possible kernel with high data rates incurs a significant performance cost. A case study computing clustering coefficients on a general-purpose data structure demonstrates incremental updates can be more efficient than global recomputation. Within this kernel, we compare three methods for dynamically updating local clustering coefficients: a brute-force local recalculation, a sorting algorithm, and our new approximation method using a Bloom filter. On 32 processors of a Cray XMT with a synthetic scale-free graph of 2²⁴≈16 million vertices and 2²⁹≈537 million edges, the brute-force method processes a mean of over 50\,000 updates per second and our Bloom filter approaches 200\,000 updates per second.},
  keywords = {ejr-CV,graph analysis,hpda,parallel algorithm,proceedings,streaming data}
}

@unpublished{2010participantsReportNSFWorkshop,
  title = {Report on {{NSF}} Workshop on Center Scale Activities Related to Accelerators for Data Intensive Applications},
  author = {{Participants}},
  namea = {Prasanna, Viktor K. and Bader, David A.},
  nameatype = {collaborator},
  date = {2010-10},
  keywords = {accelerator,ejr-CV,high performance data analysis,parallel algorithm,unpublished},
  note = {This workshop is supported by NSF Grant Number 1051537, in response to the Call for Exploratory Workshop Proposals for Scientific Software Innovation Institutes (S2I2).}
}

@unpublished{2010riedyApplicationsSocialNetworks,
  title = {Applications in Social Networks},
  author = {Riedy, Jason and Bader, David and Ediger, David},
  date = {2010-10},
  journaltitle = {NSF workshop on accelerators for data-intensive applications},
  url = {http://purl.oclc.org/NET/jason-riedy/resume/material/nsf-workshop-socnet.pdf},
  keywords = {ejr-CV,graph analysis,hpda,parallel algorithm,presentation,streaming data}
}

@incollection{2010riedyHereFarthestPoint,
  title = {Here, on the Farthest Point of the Peninsula},
  booktitle = {Read Write Poem {{NaPoWriMo}} Anthology},
  author = {Riedy, E. Jason},
  editor = {Guthrie, Dana Martin},
  date = {2010-09},
  pages = {86},
  publisher = {issuu.com},
  url = {http://issuu.com/readwritepoem/docs/read_write_poem_napowrimo_anthology},
  keywords = {ejr-CV,non-technical,poetry}
}

@thesis{2010riedyMakingStaticPivoting,
  type = {phdthesis},
  title = {Making Static Pivoting Scalable and Dependable},
  author = {Riedy, E. Jason},
  date = {2010-12},
  institution = {EECS Department, University of California, Berkeley},
  url = {http://www.eecs.berkeley.edu/Pubs/TechRpts/2010/EECS-2010-172.html},
  abstract = {Solving square linear systems of equations Ax=b is one of the primary workhorses in scientific computing. With asymptotically and practically small amounts of extra calculation and higher precision, we can render solution techniques \mkbibemph{dependable}. We produce a solution with tiny error for almost all systems where we should expect a tiny error, and we correctly flag potential failures. Our method uses a proven technique: iterative refinement. We extend prior work by applying extra precision not only in calculating the residual b-Ay\textsubscript{i} of an intermediate solution y\textsubscript{i} but also in carrying that intermediate solution y\textsubscript{i}. Analysis shows that extra precision in the intermediate solutions lowers the limiting backward error (measuring perturbations in the initial problem) to levels that produce a forward error (measuring perturbations in the solution) not much larger than the precision used to store the result. We also demonstrate that condition estimation is not necessary for determining success, reducing the computation in refinement substantially. This basic, dependable solver applies to typical dense LU factorization methods using partial pivoting as well as methods that risk greater failure by choosing pivots for non-numerical reasons. Sparse factorization methods may choose pivots to promote structural sparsity or even choose pivots \mkbibemph{before} factorization to decouple the phases. We show through experiments that solutions using these restrictive pivoting methods still have small error so long as an estimate of factorization quality, the growth factor, does not grow too large. Our refinement algorithm dependably flags such failures. Additionally, we find a better choice of heuristic for sparse static pivoting than the defaults in Li and Demmel's SuperLU package. Static pivoting in a distributed-memory setting needs an algorithm for choosing pivots that does not rely on fitting the entire matrix into one memory space. We investigate a set of algorithms, Bertsekas's auction algorithms, for choosing a static pivoting via maximum weight perfect bipartite matching. Auction algorithms have a natural mapping to distributed memory computation through their bidding mechanism. We provide an analysis of the auction algorithm fitting it comfortably in linear optimization theory and characterizing approximately maximum weight perfect bipartite matches. These approximately maximum weight perfect matches work well as static pivot choices and can be computed much more quickly than the exact maximum weight matching. Finally, we consider the performance of auction algorithm implementations on a suite of real-world sparse problems. Sequential performance is roughly equivalent to existing implementations like Duff and Koster's MC64, but varies widely with different parameter and input settings. The parallel performance is even more wildly unpredictable. Computing approximately maximum weight matchings helps performance somewhat, but we still conclude that the performance is too variable for a black-box solution method.},
  keywords = {ejr-CV,floating point,graph analysis,ieee754,linear algebra,parallel algorithm,phd-thesis}
}

@unpublished{2011baderParallelProgrammingGraph,
  title = {Parallel Programming for Graph Analysis},
  author = {Bader, David A. and Ediger, David and Riedy, E. Jason},
  date = {2011-09},
  journaltitle = {full day tutorial},
  venue = {Columbia, MD},
  keywords = {ejr-CV,graph analysis,high performance data analysis,streaming data,tutorial}
}

@unpublished{2011baderParallelProgrammingGrapha,
  title = {Parallel Programming for Graph Analysis},
  author = {Bader, David A. and Ediger, David and Riedy, E. Jason},
  date = {2011-02},
  journaltitle = {16th ACM SIGPLAN annual symposium on principles and practice of parallel programming (PPoPP)},
  url = {http://www.cc.gatech.edu/~bader/papers/GraphAnalysisTutorial-PPoPP2011.html},
  abstract = {An increasingly fast-paced, digital world has produced an ever-growing volume of petabyte-sized datasets. At the same time, terabytes of new, unstructured data arrive daily. As the desire to ask more detailed questions about these massive streams has grown, parallel software and hardware have only recently begun to enable complex analytics in this non-scientific space. In this tutorial, we will discuss the open problems facing us with analyzing this "data deluge". We will present algorithms and data structures capable of analyzing spatio-temporal data at massive scale on parallel systems. We will try to understand the difficulties and bottlenecks in parallel graph algorithm design on current systems and will show how multithreaded and hybrid systems can overcome these challenges. We will demonstrate how parallel graph algorithms can be implemented on a variety of architectures using different programming models. The goal of this tutorial is to provide a comprehensive introduction to the field of parallel graph analysis to an audience with computing background, interested in participating in research and/or commercial applications of this field. Moreover, we will cover leading-edge technical and algorithmic developments in the field and discuss open problems and potential solutions.},
  venue = {San Antonio, TX},
  keywords = {ejr-CV,graph analysis,high performance data analysis,streaming data,tutorial}
}

@report{2011e.jasonriedycopiBenchmarkingIBMPERCS,
  title = {Benchmarking the {{IBM PERCS}} and {{Cray CASCADE}} Architectures},
  author = {{E. Jason Riedy (coPI)} and {David A. Bader (PI)}},
  date = {2011-06},
  institution = {Georgia Institute of Technology},
  keywords = {ejr-CV,grants},
  note = {\$287\,994}
}

@report{2011e.jasonriedypiEvaluatingPGASScientific,
  title = {Evaluating {{PGAS}} Scientific Graph Analysis Codes on the {{Gemini}} Interconnect},
  author = {{E. Jason Riedy (PI)}},
  date = {2011-06},
  institution = {Georgia Institute of Technology},
  keywords = {ejr-CV,grants},
  note = {250\,000 hours of DoE processing time}
}

@report{2011e.jasonriedypiTeachingMassiveData,
  title = {Teaching Massive Data Analysis and Manycore Computing},
  author = {{E. Jason Riedy (PI)} and {Logan Moon}},
  date = {2011-07},
  institution = {Georgia Institute of Technology},
  keywords = {ejr-CV,grants},
  note = {\$223\,800}
}

@inproceedings{2011edigerTrackingStructureStreaming,
  title = {Tracking Structure of Streaming Social Networks},
  booktitle = {5th Workshop on Multithreaded Architectures and Applications ({{MTAAP}})},
  author = {Ediger, David and Riedy, E. Jason and Bader, David A. and Meyerhenke, Henning},
  date = {2011-05},
  doi = {10.1109/IPDPS.2011.326},
  abstract = {Current online social networks are massive and still growing. For example, Facebook has over 500 million active users sharing over 30 billion items per month. The scale within these data streams has outstripped traditional graph analysis methods. Monitoring requires dynamic analysis rather than repeated static analysis. The massive state behind multiple persistent queries requires shared data structures and not problem-specific representations. We present a framework based on the STINGER data structure that can monitor a global property, connected components, on a graph of 16 million vertices at rates of up to 240\,000 updates per second on a 32 processor Cray XMT. For very large scale-free graphs, our implementation uses novel batching techniques that exploit the scale-free nature of the data and run over three times faster than prior methods. Our framework handles, for the first time, real-world data rates, opening the door to higher-level analytics such as community and anomaly detection.},
  keywords = {ejr-CV,graph analysis,hpda,parallel algorithm,proceedings,streaming data}
}

@report{2011riedyDetectingCommunitiesGiven,
  title = {Detecting Communities from given Seeds in Social Networks},
  author = {Riedy, Jason and Bader, David A. and Jiang, Karl and Pande, Pushkar and Sharma, Richa},
  date = {2011-02},
  number = {GT-CSE-11-01},
  eprint = {1853/36980},
  eprinttype = {hdl},
  institution = {Georgia Institute of Technology},
  url = {http://hdl.handle.net/1853/36980},
  abstract = {Analyzing massive social networks challenges both high-performance computers and human understanding. These massive networks cannot be visualized easily, and their scale makes applying complex analysis methods computationally expensive. We present a region-growing method for finding a smaller, more tractable subgraph, a community, given a few example seed vertices. Unlike existing work, we focus on a small number of seed vertices, from two to a few dozen. We also present the first comparison between five algorithms for expanding a small seed set into a community. Our comparison applies these algorithms to an R-MAT generated graph component with 240 thousand vertices and 32 million edges and evaluates the community size, modularity, Kullback-Leibler divergence, conductance, and clustering coefficient. We find that our new algorithm with a local modularity maximizing heuristic based on Clauset, Newman, and Moore performs very well when the output is limited to 100 or 1000 vertices. When run without a vertex size limit, a heuristic from McCloskey and Bader generates communities containing around 60\% of the graph's vertices and having a small conductance and modularity appropriate to the result size. A personalized PageRank algorithm based on Andersen, Lang, and Chung also performs well with respect to our metrics.},
  keywords = {ejr-CV,technical-report}
}

@inproceedings{2011riedyParallelCommunityDetection,
  title = {Parallel Community Detection for Massive Graphs},
  booktitle = {9th International Conference on Parallel Processing and Applied Mathematics ({{PPAM11}})},
  author = {Riedy, E. Jason and Meyerhenke, Henning and Ediger, David and Bader, David A.},
  date = {2011-09},
  publisher = {Springer},
  doi = {10.1007/978-3-642-31464-3\_29},
  abstract = {Tackling the current volume of graph-structured data requires parallel tools. We extend our work on analyzing such massive graph data with the first massively parallel algorithm for community detection that scales to current data sizes, scaling to graphs of over 122 million vertices and nearly 2 billion edges in under 7300 seconds on a massively multithreaded Cray XMT. Our algorithm achieves moderate parallel scalability without sacrificing sequential operational complexity. Community detection partitions a graph into subgraphs more densely connected within the subgraph than to the rest of the graph. We take an agglomerative approach similar to Clauset, Newman, and Moore's sequential algorithm, merging pairs of connected intermediate subgraphs to optimize different graph properties. Working in parallel opens new approaches to high performance. On smaller data sets, we find the output's modularity compares well with the standard sequential algorithms.},
  keywords = {ejr-CV,graph analysis,hpda,parallel algorithm,proceedings}
}

@unpublished{2011riedySTINGSpatiotemporalInteraction,
  title = {{{STING}}: {{Spatio-temporal}} Interaction Networks and Graphs for {{Intel}} Platforms},
  author = {Riedy, Jason and Bader, David A. and Meyerhenke, Henning and Ediger, David and Mattson, Timothy},
  date = {2011-08},
  url = {http://purl.oclc.org/NET/jason-riedy/resume/material/GT-STING-for-Intel-beamer.pdf},
  keywords = {ejr-CV,graph analysis,hpda,parallel algorithm,presentation,streaming data}
}

@incollection{2011riedyStormsComingWhen,
  title = {The Storm's Coming When the Chickens Spread Out},
  booktitle = {Pay Attention: A River of Stones},
  author = {Riedy, Jason},
  editor = {Robyn, Fiona and {Kaspalita}},
  date = {2011-03},
  pages = {77},
  publisher = {lulu.com},
  url = {https://www.lulu.com/en/us/shop/kaspalita-and-fiona-robyn/pay-attention-a-river-of-stones/ebook/product-1vkzw9kr.html},
  keywords = {ejr-CV,non-technical,poetry}
}

@unpublished{2011riedyTrackingStructureStreaming,
  title = {Tracking Structure of Streaming Social Networks},
  author = {Riedy, Jason and Ediger, David and Bader, David A. and Meyerhenke, Henning},
  date = {2011-08},
  url = {http://purl.oclc.org/NET/jason-riedy/resume/material/GraphEx-2011.pdf},
  keywords = {ejr-CV,graph analysis,hpda,presentation,streaming data},
  note = {Invited presentation.}
}

@unpublished{2012baderStreamingGraphAnalytics,
  title = {Streaming Graph Analytics for Massive Graphs},
  author = {Bader, David A. and Ediger, David and Riedy, Jason},
  date = {2012-07},
  url = {http://www.slideshare.net/jasonriedy/streaming-graph-analytics-for-massive-graphs},
  abstract = {Emerging real-world graph problems include detecting community structure in large social networks, improving the resilience of the electric power grid, and detecting and preventing disease in human populations. The volume and richness of data combined with its rate of change renders monitoring properties at scale by static recomputation infeasible. We approach these problems with massive, fine-grained parallelism across different shared memory architectures both to compute solutions and to explore the sensitivity of these solutions to natural bias and omissions within the data.},
  venue = {Minneapolis, MN},
  keywords = {ejr-CV,graph analysis,hpda,parallel algorithm,presentation,streaming data}
}

@report{2012e.jasonriedycopiGRATEFULGRaphAnalysis,
  title = {{{GRATEFUL}}: {{GRaph Analysis Tackling}} Power {{EFficiency}}, {{Uncertainty}}, and {{Locality}}},
  author = {{E. Jason Riedy (coPI)} and {David A. Bader (PI)}},
  date = {2012-08},
  number = {HR0011-13-2-0001},
  institution = {Georgia Institute of Technology},
  keywords = {ejr-CV,grants},
  note = {\$2\,929\,819}
}

@report{2012e.jasonriedypiOracleMultithreadedAlgorithms,
  title = {Oracle: {{Multithreaded}} Algorithms},
  author = {{E. Jason Riedy (PI)} and {David A. Bader}},
  date = {2012-04},
  institution = {Georgia Institute of Technology},
  keywords = {ejr-CV,grants},
  note = {\$118\,000}
}

@unpublished{2012edigerAnalyzingMassiveNetworks,
  title = {Analyzing Massive Networks with {{GraphCT}}},
  author = {Ediger, David and Riedy, E. Jason and Meyerhenke, Henning and Bader, David A.},
  date = {2012-02},
  venue = {Savannah, GA},
  keywords = {ejr-CV,graph analysis,hpda,parallel algorithm,presentation,streaming data}
}

@unpublished{2012edigerParallelProgrammingGraph,
  title = {Parallel Programming for Graph Analysis},
  author = {Ediger, David and Riedy, Jason and McColl, Rob and Bader, David A.},
  date = {2012-02},
  journaltitle = {17th ACM SIGPLAN annual symposium on principles and practice of parallel programming (PPoPP)},
  url = {http://www.cc.gatech.edu/~bader/papers/GraphAnalysisTutorial-PPoPP2012.html},
  abstract = {An increasingly fast-paced, digital world has produced an ever-growing volume of petabyte-sized datasets. At the same time, terabytes of new, unstructured data arrive daily. As the desire to ask more detailed questions about these massive streams has grown, parallel software and hardware have only recently begun to enable complex analytics in this non-scientific space. In this tutorial, we will discuss the open problems facing us with analyzing this "data deluge". We will present algorithms and data structures capable of analyzing spatio-temporal data at massive scale on parallel systems. We will try to understand the difficulties and bottlenecks in parallel graph algorithm design on current systems and will show how multithreaded and hybrid systems can overcome these challenges. We will demonstrate how parallel graph algorithms can be implemented on a variety of architectures using different programming models. The goal of this tutorial is to provide a comprehensive introduction to the field of parallel graph analysis to an audience with computing background, interested in participating in research and/or commercial applications of this field. Moreover, we will cover leading-edge technical and algorithmic developments in the field and discuss open problems and potential solutions.},
  venue = {New Orleans, LA},
  keywords = {ejr-CV,graph analysis,high performance data analysis,streaming data,tutorial}
}

@inproceedings{2012edigerSTINGERHighPerformance,
  title = {{{STINGER}}: {{High}} Performance Data Structure for Streaming Graphs},
  booktitle = {The {{IEEE}} High Performance Extreme Computing Conference ({{HPEC}})},
  author = {Ediger, David and McColl, Robert and Riedy, Jason and Bader, David A.},
  date = {2012-09},
  location = {Waltham, MA},
  doi = {10.1109/HPEC.2012.6408680},
  abstract = {The current research focus on “big data” problems highlights the scale and complexity of analytics required and the high rate at which data may be changing. In this paper, we present our high performance, scalable and portable software, Spatio-Temporal Interaction Networks and Graphs Extensible Representation (STINGER), that includes a graph data structure that enables these applications. Key attributes of STINGER are fast insertions, deletions, and updates on semantic graphs with skewed degree distributions. We demonstrate a process of algorithmic and architectural optimizations that enable high performance on the Cray XMT family and Intel multicore servers. Our implementation of STINGER on the Cray XMT processes over 3 million updates per second on a scale-free graph with 537 million edges.},
  keywords = {ejr-CV,graph analysis,hpda,parallel algorithm,proceedings,streaming data},
  note = {Best paper award}
}

@unpublished{2012meyerhenkeParallelCommunityDetection,
  title = {Parallel Community Detection in Streaming Graphs},
  author = {Meyerhenke, Henning and Riedy, E. Jason and Bader, David A.},
  date = {2012-02},
  venue = {Savannah, GA},
  keywords = {ejr-CV,graph analysis,hpda,parallel algorithm,presentation,streaming data}
}

@incollection{2012riedyAnalysisStreamingSocial,
  title = {Analysis of Streaming Social Networks and Graphs on Multicore Architectures},
  booktitle = {{{IEEE}} International Conference on Acoustics, Speech and Signal Processing ({{ICASSP}})},
  author = {Riedy, Jason and Meyerhenke, Henning and Bader, David A. and Ediger, David and Mattson, Timothy G.},
  date = {2012-03},
  location = {Kyoto, Japan},
  doi = {10.1109/ICASSP.2012.6289126},
  url = {http://www.slideshare.net/jasonriedy/icassp-2012-analysis-of-streaming-social-networks-and-graphs-on-multicore-architectures},
  abstract = {Analyzing static snapshots of massive, graph-structured data cannot keep pace with the growth of social networks, financial transactions, and other valuable data sources. We introduce a framework, STING (Spatio-Temporal Interaction Networks and Graphs), and evaluate its performance on multicore, multisocket Intel(R)-based platforms. STING achieves rates of around 100\,000 edge updates per second on large, dynamic graphs with a single, general data structure. We achieve speed-ups of up to 1000× over parallel static computation, improve monitoring a dynamic graph's connected components, and show an exact algorithm for maintaining local clustering coefficients performs better on Intel-based platforms than our earlier approximate algorithm.},
  keywords = {ejr-CV,graph analysis,hpda,parallel algorithm,proceedings,streaming data}
}

@inproceedings{2012riedyParallelCommunityDetection,
  title = {Parallel Community Detection for Massive Graphs},
  booktitle = {10th {{DIMACS}} Implementation Challenge Workshop - Graph Partitioning and Graph Clustering},
  author = {Riedy, E. Jason and Meyerhenke, Henning and Ediger, David and Bader, David A.},
  date = {2012-02},
  location = {Atlanta, Georgia},
  url = {http://www.cc.gatech.edu/dimacs10/papers/[15]-dimacs10-community-detection.pdf},
  abstract = {Tackling the current volume of graph-structured data requires parallel tools. We extend our work on analyzing such massive graph data with a massively parallel algorithm for community detection that scales to current data sizes, clustering a real-world graph of over 100 million vertices and over 3 billion edges in under 500 seconds on a four- processor Intel E7-8870-based server. Our algorithm achieves moderate parallel scalability without sacrificing sequential operational complexity. Community detection partitions a graph into subgraphs more densely connected within the subgraph than to the rest of the graph. We take an agglomerative approach similar to Clauset, Newman, and Moore’s sequential algorithm, merging pairs of connected intermediate subgraphs to optimize different graph properties. Working in parallel opens new approaches to high performance. We improve performance of our parallel community detection algorithm on both the Cray XMT2 and OpenMP platforms and adapt our algorithm to the DIMACS Implementation Challenge data set.},
  keywords = {ejr-CV,graph analysis,hpda,parallel algorithm,proceedings},
  note = {Won first place in the Mix Challenge and Mix Pareto Challenge}
}

@incollection{2012riedyParallelCommunityDetectiona,
  title = {Parallel Community Detection for Massive Graphs},
  booktitle = {Graph Partitioning and Graph Clustering},
  author = {Riedy, E. Jason and Meyerhenke, Henning and Ediger, David and Bader, David A.},
  editor = {Bader, David A. and Meyerhenke, Henning and Sanders, Peter and Wagner, Dorothea},
  date = {2012},
  series = {Contemporary Mathematics},
  volume = {588},
  pages = {207--222},
  publisher = {American Mathematical Society},
  doi = {10.1090/conm/588/11703},
  abstract = {Tackling the current volume of graph-structured data requires parallel tools. We extend our work on analyzing such massive graph data with a massively parallel algorithm for community detection that scales to current data sizes, clustering a real-world graph of over 100 million vertices and over 3 billion edges in under 500 seconds on a four-processor Intel E7-8870-based server. Our algorithm achieves moderate parallel scalability without sacrificing sequential operational complexity. Community detection partitions a graph into subgraphs more densely connected within the subgraph than to the rest of the graph. We take an agglomerative approach similar to Clauset, Newman, and Moore’s sequential algorithm, merging pairs of connected intermediate subgraphs to optimize different graph properties. Working in parallel opens new approaches to high performance. We improve performance of our parallel community detection algorithm on both the Cray XMT2 and OpenMP platforms and adapt our algorithm to the DIMACS Implementation Challenge data set.},
  isbn = {978-0-8218-9038-7},
  keywords = {book-chapter,community detection,ejr-CV,graph analysis,hpda,parallel algorithm}
}

@unpublished{2012riedyScalableAlgorithmsAnalysis,
  title = {Scalable Algorithms for Analysis of Massive, Streaming Graphs},
  author = {Riedy, E. Jason and Meyerhenke, Henning},
  date = {2012-02},
  url = {http://www.slideshare.net/jasonriedy/siam-pp-2012-scalable-algorithms-for-analysis-of-massive-streaming-graphs},
  abstract = {Graph-structured data in social networks, finance, network security, and others not only are massive but also under continual change. These changes often are scattered across the graph. Repeating complex global analyses on massive snapshots to capture only what has changed is inefficient. We discuss analysis algorithms for streaming graph data that maintain both local and global metrics. We extract parallelism from both analysis kernel and graph data to scale performance to real-world sizes.},
  venue = {Savannah, GA},
  keywords = {ejr-CV,graph analysis,hpda,parallel algorithm,presentation,streaming data},
  note = {Minisymposium organizer with Henning Meyerhenke.}
}

@inproceedings{2012riedyScalableMultithreadedCommunity,
  title = {Scalable Multi-Threaded Community Detection in Social Networks},
  booktitle = {6th Workshop on Multithreaded Architectures and Applications ({{MTAAP}})},
  author = {Riedy, E. Jason and Bader, David A. and Meyerhenke, Henning},
  date = {2012-05},
  doi = {10.1109/IPDPSW.2012.203},
  abstract = {The volume of existing graph-structured data requires improved parallel tools and algorithms. Finding communities, smaller subgraphs densely connected within the subgraph than to the rest of the graph, plays a role both in developing new parallel algorithms as well as opening smaller portions of the data to current analysis tools. We improve performance of our parallel community detection algorithm by 20\% on the massively multithreaded Cray XMT, evaluate its performance on the next-generation Cray XMT2, and extend its reach to Intel-based platforms with OpenMP. To our knowledge, not only is this the first massively parallel community detection algorithm but also the only such algorithm that achieves excellent performance and good parallel scalability across all these platforms. Our implementation analyzes a moderate sized graph with 105 million vertices and 3.3 billion edges in around 500 seconds on a four processor, 80-logical-core Intel-based system and 1100 seconds on a 64-processor Cray XMT2.},
  keywords = {ejr-CV,graph analysis,hpda,parallel algorithm,proceedings}
}

@unpublished{2012riedySTINGSoftwareAnalysis,
  title = {{{STING}}: {{Software}} for Analysis of Spatio-Temporal Interaction Networks and Graphs},
  author = {Riedy, E. Jason and Ediger, David and Meyerhenke, Henning and Bader, David A.},
  date = {2012-02},
  abstract = {Current tools for analyzing graph-structured data and semantic networks focus on static graphs. Our STING package tackles analysis of streaming graphs like today's social networks and communication tools. STING maintains a massive graph under changes while coordinating analysis kernels to achieve analysis at real-world data rates. We show examples of local metrics like clustering coefficients and global metrics like connected components and agglomerative clustering. STING supports parallel Intel architectures as well as the Cray XMT.},
  venue = {Savannah, GA},
  keywords = {ejr-CV,graph analysis,hpda,parallel algorithm,presentation,streaming data}
}

@unpublished{2012riedySTINGSpatiotemporalInteraction,
  title = {{{STING}}: {{Spatio-temporal}} Interaction Networks and Graphs for {{Intel}} Platforms},
  author = {Riedy, Jason and Bader, David A. and Ediger, David and McColl, Rob and Mattson, Timothy G.},
  date = {2012-07},
  url = {http://www.slideshare.net/jasonriedy/gt-stingintelslides},
  keywords = {ejr-CV,graph analysis,hpda,parallel algorithm,presentation,streaming data}
}

@unpublished{2012smithDARPAsHighProductivity,
  title = {{{DARPA}}'s {{High Productivity Computing Systems Program}}: {{A Final Report}}},
  author = {Smith, Lauren L. and Shaffer, Dolores A.},
  date = {2012-11},
  abstract = {The DARPA High Productivity Computing Systems (HPCS) program has been focused on providing a new generation of economically viable high productivity computing systems for national security, scientific, industrial and commercial applications. This program was unique because it focused on system productivity that was defined to include enhancing performance, programmability, portability, usability, manageability and robustness of systems as opposed to just being focused on one execution time performance metric. The BOF is for anyone interested in learning about the two HPCS systems and how productivity in High Performance Computing has been enhanced.},
  keywords = {ejr-CV,graph analysis,hpda,invited-presentation,novel architectures,streaming data},
  note = {Invited panel speaker}
}

@report{2012viktorprasannapiuscCollaborativeResearchSoftware,
  title = {Collaborative Research: {{Software}} Infrastructure for Accelerating Grand Challenge Science with Future Computing Platforms},
  author = {{Viktor Prasanna (PI USC)} and {Manish Parashar (PI Rutgers)} and {Jason Riedy (coPI GT)} and {Rich Vuduc (coPI GT)} and {Yogesh Simmhan (coPI USC)} and {Shantenu Jha (coPI Rutgers)} and {David A. Bader (PI GT)}},
  date = {2012-10},
  number = {NSF 1216504},
  institution = {Georgia Institute of Technology},
  keywords = {ejr-CV,grants},
  note = {\$104\,386}
}

@unpublished{2013baderApplicationsChallengesLargescale,
  title = {Applications and Challenges in Large-Scale Graph Analysis},
  author = {Bader, David A. and Meyerhenke, Henning and Riedy, Jason},
  date = {2013-02},
  url = {http://www.graphanalysis.org/SIAM-CSE13/01_Bader.pdf},
  abstract = {Emerging real-world graph problems include detecting community structure in large social networks, improving the resilience of the electric power grid, and detecting and preventing disease in human populations. We discuss the opportunities and challenges in massive data-intensive computing for applications in social network analysis, genomics, and security. The explosion of real-world graph data poses substantial challenges for software, hardware, algorithms, and application experts.},
  venue = {Boston, MA},
  keywords = {ejr-CV,graph analysis,hpda,presentation,streaming data}
}

@incollection{2013edigerComputationalGraphAnalytics,
  title = {Computational Graph Analytics for Massive Streaming Data},
  booktitle = {Large Scale Network-Centric Computing Systems},
  author = {Ediger, David and Riedy, Jason and Bader, David A. and Meyerhenke, Henning},
  editor = {Sarbazi-azad, Hamid and Zomaya, Albert},
  date = {2013-07},
  series = {Parallel and Distributed Computing},
  publisher = {Wiley},
  doi = {10.1002/9781118640708.ch25},
  abstract = {Handling the constant stream of data from health care, security, business, and social network applications requires new algorithms and data structures. We present a new approach for parallel massive analysis of streaming, temporal, graph-structured data. For this purpose we examine data structure and algorithm trade-offs that extract the parallelism necessary for high-performance updating analysis of massive graphs. As a result of this study, we propose the extensible and flexible data structure for massive graphs called STINGER (Spatio-Temporal Interaction Networks and Graphs Extensible Representation). Two case studies demonstrate our new approach's effectiveness. The first one computes a dynamic graph's vertices' \mkbibemph{clustering coefficients}. We show that incremental updates are far more efficient than global recomputation. Within this kernel, we compare three methods for dynamically updating local clustering coefficients: a brute-force local recalculation, a sorting algorithm, and our new approximation method using a Bloom filter. On 32 processors of a  with a synthetic scale-free graph of 2²⁴≈16 million vertices and 2²⁹≈537 million edges, the brute-force method processes a mean of over 50\,000 updates per second, while our Bloom filter approaches 200\,000 updates per second. The second case study monitors a global feature, a dynamic graph's connected components. We use similar algorithmic ideas as before to exploit the parallelism in the problem and provided by the hardware architecture. On a 16 million vertex graph, we obtain rates of up to 240\,000 updates per second on 32 processors of a . For the large scale-free graphs typical in our applications, our implementation uses novel batching techniques that exploit the scale-free nature of the data and run over three times faster than prior methods. Our new framework is the first to handle real-world data rates, opening the door to higher-level analytics such as community and anomaly detection.},
  isbn = {978-0-470-93688-7},
  keywords = {book-chapter,ejr-CV,graph analysis,hpda,parallel algorithm,streaming data}
}

@article{2013edigerGraphCTMultithreadedAlgorithms,
  title = {{{GraphCT}}: {{Multithreaded}} Algorithms for Massive Graph Analysis},
  author = {Ediger, David and Jiang, Karl and Riedy, Jason and Bader, David A.},
  date = {2013-09},
  journaltitle = {IEEE Transactions in Parallel and Distributed Systems},
  pages = {2220--2229},
  issn = {1045-9219},
  doi = {10.1109/TPDS.2012.323},
  url = {http://dx.doi.org/10.1109/TPDS.2012.323},
  abstract = {The digital world has given rise to massive quantities of data that include rich semantic and complex networks. A social graph, for example, containing hundreds of millions of actors and tens of billions of relationships is not uncommon. Analyzing these large data sets, even to answer simple analytic queries, often pushes the limits of algorithms and machine architectures. We present GraphCT, a scalable framework for graph analysis using parallel and multithreaded algorithms on shared memory platforms. Utilizing the unique characteristics of the Cray XMT, GraphCT enables fast network analysis at unprecedented scales on a variety of input data sets. On a synthetic power law graph with 2 billion vertices and 17 billion edges, we can find the connected components in 2 minutes. We can estimate the betweenness centrality of a similar graph with 537 million vertices and over 8 billion edges in under 1 hour. GraphCT is built for portability and performance.},
  keywords = {ejr-CV,refereed}
}

@unpublished{2013mccollAnalyzingGraphStructure,
  title = {Analyzing Graph Structure in Streaming Data with {{STINGER}}},
  author = {McColl, Robert C. and Ediger, David and Bader, David A. and Riedy, Jason},
  date = {2013-02},
  abstract = {Analyzing static snapshots of massive, graph-structured data cannot keep pace with the growth of social networks, financial transactions, and other valuable data sources. Our software framework, STING (Spatio-Temporal Interaction Networks and Graphs), uses a scalable, high-performance graph data structure to enable these applications. STING supports fast insertions, deletions, and updates on graphs with semantic information and skewed degree distributions. STING achieves large speed-ups over parallel, static recomputation on both common multicore and specialized multithreaded platforms.},
  venue = {Boston, MA},
  keywords = {ejr-CV,graph analysis,hpda,parallel algorithm,presentation,streaming data}
}

@article{2013riedyMassiveStreamingData,
  entrysubtype = {magazine},
  title = {Massive Streaming Data Analytics: A Graph-Based Approach},
  author = {Riedy, Jason and Bader, David A.},
  date = {2013-03},
  journaltitle = {XRDS: Crossroads, The ACM Magazine for Students — Scientific Computing},
  volume = {19},
  number = {3},
  pages = {37--43},
  publisher = {ACM},
  location = {New York, NY, USA},
  issn = {1528-4972},
  doi = {10.1145/2425676.2425689},
  abstract = {Analyzing massive streaming graphs efficiently requires new algorithms, data structures, and computing platforms.},
  keywords = {ejr-CV,graph analysis,high performance data analysis,streaming data,trade-pub}
}

@inproceedings{2013riedyMultithreadedCommunityMonitoring,
  title = {Multithreaded Community Monitoring for Massive Streaming Graph Data},
  booktitle = {7th Workshop on Multithreaded Architectures and Applications ({{MTAAP}})},
  author = {Riedy, E. Jason and Bader, David A.},
  date = {2013-05},
  location = {Boston, MA},
  doi = {10.1109/IPDPSW.2013.229},
  abstract = {Analyzing static snapshots of massive, graph-structured data cannot keep pace with the growth of social networks, financial transactions, and other valuable data sources. Current state-of-the-art industrial methods analyze these streaming sources using only simple, aggregate metrics. There are few existing scalable algorithms for monitoring complex global quantities like decomposition into community structure. Using our framework STING, we present the first known parallel algorithm specifically for monitoring communities in this massive, streaming, graph-structured data. Our algorithm performs incremental re-agglomeration rather than starting from scratch after each batch of changes, reducing the problem's size to that of the change rather than the entire graph. We analyze our initial implementation's performance on multithreaded platforms for execution time and latency. On an Intel-based multithreaded platform, our algorithm handles up to 100 million updates per second on social networks with one to 30 million edges, providing a speed-up from 4× to 3700× over statically recomputing the decomposition after each batch of changes. Possibly because of our artificial graph generator, resulting communities' modularity varies little from the initial graph.},
  keywords = {ejr-CV,graph analysis,hpda,parallel algorithm,proceedings,streaming data}
}

@unpublished{2013riedySTINGERAnalyzingMassive,
  title = {{{STINGER}}: {{Analyzing}} Massive, Streaming Graphs},
  author = {Riedy, Jason},
  date = {2013-07},
  venue = {San Francisco, CA},
  keywords = {ejr-CV,graph analysis,hpda,presentation,streaming data}
}

@unpublished{2013swensonReportWorkshopAccelerating,
  title = {Report on “Workshop on Accelerating Bioinformatics Applications Enabled by {{NextGen-sequencing}}”},
  author = {Swenson, Shel and Simmhan, Yogesh and Prasanna, Viktor and Parashar, Manish and Bader, David and Riedy, Jason and Vuduc, Richard},
  date = {2013-05},
  location = {Boston, MA},
  url = {http://future-compute.usc.edu/index.php/NGS_Workshop},
  keywords = {accelerator,ejr-CV,high performance data analysis,parallel algorithm,unpublished},
  note = {Co-located with IPDPS 2013}
}

@unpublished{2013swensonReportWorkshopChallenges,
  title = {Report on “Workshop on Challenges in Accelerating next-Gen Sequencing ({{NGS}}) Bioinformatics”},
  author = {Swenson, Shel and Simmhan, Yogesh and Prasanna, Viktor and Parashar, Manish and Bader, David and Riedy, Jason and Vuduc, Richard},
  date = {2013-09},
  location = {Washington, DC},
  url = {http://future-compute.usc.edu/index.php/NGS_Bioinformatics_Workshop},
  keywords = {accelerator,ejr-CV,high performance data analysis,parallel algorithm,unpublished},
  note = {in conjunction with ACM-BCB 2013}
}

@inproceedings{2013swensonSustainableSoftwareDevelopment,
  title = {Sustainable Software Development for Next-Gen Sequencing ({{NGS}}) Bioinformatics on Emerging Platforms},
  booktitle = {First Workshop on Sustainable Software for Science: {{Practice}} and Experiences ({{WSSSPE1}})},
  author = {Swenson, Shel and Simmhan, Yogesh and Prasanna, Viktor and Parashar, Manish and Riedy, Jason and Bader, David and Vuduc, Richard},
  date = {2013-11},
  location = {Denver, CO},
  url = {http://arxiv.org/abs/1309.1828},
  abstract = {DNA sequence analysis is fundamental to life science research. The rapid development of next generation sequencing (NGS) technologies, and the richness and diversity of applications it makes feasible, have created an enormous gulf between the potential of this technology and the development of computational methods to realize this potential. Bridging this gap holds possibilities for broad impacts toward multiple grand challenges and offers unprecedented opportunities for software innovation and research. We argue that NGS-enabled applications need a critical mass of sustainable software to benefit from emerging computing platforms' transformative potential. Accumulating the necessary critical mass will require leaders in computational biology, bioinformatics, computer science, and computer engineering work together to identify core opportunity areas, critical software infrastructure, and software sustainability challenges. Furthermore, due to the quickly changing nature of both bioinformatics software and accelerator technology, we conclude that creating sustainable accelerated bioinformatics software means constructing a sustainable bridge between the two fields. In particular, sustained collaboration between domain developers and technology experts is needed to develop the accelerated kernels, libraries, frameworks and middleware that could provide the needed flexible link from NGS bioinformatics applications to emerging platforms.},
  keywords = {accelerator,ejr-CV,high performance data analysis,parallel algorithm,unpublished},
  note = {held in conjunction with SC13, published electronically (\href{http://wssspe.researchcomputing.org.uk/}{http://wssspe.researchcomputing.org.uk/})}
}

@online{2013swensonSustainableSoftwareDevelopmenta,
  title = {Sustainable Software Development for Next-Gen Sequencing ({{NGS}}) Bioinformatics on Emerging Platforms},
  author = {Swenson, Shel and Simmhan, Yogesh and Prasanna, Viktor K. and Parashar, Manish and Riedy, E. Jason and Bader, David A. and Vuduc, Richard W.},
  date = {2013},
  url = {http://arxiv.org/abs/1309.1828},
  pubstate = {prepublished},
  keywords = {ejr-CV,technical-report}
}

@report{2013viktorprasannapiuscSI2SSICollaborativeXScala,
  title = {{{SI2-SSI}}: {{Collaborative}}: {{The XScala}} Project: A Community Repository for Model-Driven Design and Tuning of Data-Intensive Applications for Extreme-Scale Accelerator-Based Systems},
  author = {{Viktor Prasanna (PI USC)} and {E. Jason Riedy (coPI GT)} and {Rich Vudic (coPI GT)} and {David A. Bader (PI GT)}},
  date = {2013-10},
  number = {NSF ACI-1339745},
  institution = {Georgia Institute of Technology},
  keywords = {ejr-CV,grants},
  note = {\$1\,937\,624, (\$1\,188\,710 GA Tech portion)}
}

@inproceedings{2014mclaughlinOptimizingEnergyConsumption,
  title = {Optimizing Energy Consumption and Parallel Performance for Betweenness Centrality Using {{GPUs}}},
  booktitle = {The {{IEEE}} High Performance Extreme Computing Conference ({{HPEC}})},
  author = {McLaughlin, Adam and Riedy, Jason and Bader, David A.},
  date = {2014-09},
  location = {Waltham, MA},
  doi = {10.1109/HPEC.2014.7040980},
  abstract = {Applications of high-performance graph analysis range from computational biology to network security and even transportation. These applications often consider graphs under rapid change and are moving beyond HPC platforms into energy-constrained embedded systems. This paper optimizes one successful and demanding analysis kernel, betweenness centrality, for NVIDIA GPU accelerators in both environments. Our algorithm for static analysis is capable of exceeding 2 million traversed edges per second per watt (MTEPS/W). Optimizing the parallel algorithm and treating the dynamic problem directly achieves a 6.39× average speed-up and 84\% average reduction in energy consumption.},
  keywords = {ejr-CV,graph analysis,hpda,parallel algorithm,proceedings},
  note = {“Rising Stars” section}
}

@unpublished{2014riedyGraphAnalysisTrends,
  title = {Graph Analysis Trends and Opportunities},
  author = {Riedy, Jason and Bader, David A.},
  date = {2014-11},
  journaltitle = {CMG performance and capacity},
  url = {http://www.slideshare.net/jasonriedy/cmg-20141104},
  abstract = {High-performance graph analysis is unlocking knowledge in problems like anomaly detection in computer security, community structure in social networks, and many other data integration areas. While graphs provide a convenient abstraction, real-world problems' sparsity and lack of locality challenge current systems. This talk will cover current trends ranging from massive scales to low-power, low-latency systems and summarize opportunities and directions for graphs and computing systems.},
  venue = {Atlanta, GA},
  keywords = {ejr-CV,graph analysis,high performance data analysis,invited-presentation,parallel algorithm,streaming data},
  note = {Invited presentation
\par
Invited presentation},
  file = {/home/ejr/Zotero/storage/HPXN72FV/cmg-2014-11-04.pdf}
}

@unpublished{2014riedySTINGERAnalyzingMassive,
  title = {{{STINGER}}: {{Analyzing}} Massive, Streaming Graphs},
  author = {Riedy, Jason},
  date = {2014-07},
  venue = {San Francisco, CA},
  keywords = {ejr-CV,graph analysis,hpda,presentation,streaming data}
}

@unpublished{2014riedySTINGERMultithreadedGraph,
  title = {{{STINGER}}: {{Multi-threaded}} Graph Streaming},
  author = {Riedy, Jason and Bader, David A.},
  date = {2014-05},
  journaltitle = {Graph Algorithms Building Blocks (GABB 2014)},
  url = {http://www.slideshare.net/jasonriedy/stinger-multithreaded-graph-streaming},
  venue = {Phoeniz, AZ},
  keywords = {ejr-CV,graph analysis,high performance data analysis,invited-presentation,parallel algorithm,streaming data},
  note = {Invited presentation and panelist. (Workshop with IPDPS 2014)
\par
Invited presentation and panelist. (Workshop with IPDPS 2014)},
  file = {/home/ejr/Zotero/storage/FB4XJYSV/gabb-2014-pres.pdf}
}

@unpublished{2014riedySTINGSpatiotemporalInteraction,
  title = {{{STING}}: {{Spatio-temporal}} Interaction Networks and Graphs for {{Intel}} Platforms},
  author = {Riedy, Jason and Bader, David A. and Ediger, David and McColl, Rob and Mattson, Timothy G.},
  date = {2014-01},
  url = {http://www.slideshare.net/jasonriedy/intel-20140117},
  keywords = {ejr-CV,graph analysis,hpda,presentation,streaming data}
}

@report{2015jackdongarrapiutkCollaborativeResearchEMBRACE,
  title = {Collaborative {{Research}}: {{EMBRACE}}: {{Evolvable Methods}} for {{Benchmarking Realism}} through {{Application}} and {{Community Engagement}}},
  author = {{Jack Dongarra (PI UTK)} and {Jason Riedy (coPI GT)} and {Richard Vuduc (coPI GT)} and {Piotr Luszczek (coPI UTK)} and {David A. Bader (PI GT)}},
  date = {2015-09},
  number = {NSF 1535058},
  institution = {Georgia Institute of Technology},
  keywords = {ejr-CV,grants},
  note = {\$125\,000}
}

@inproceedings{2015mclaughlinEnergyefficientAbstractionSimultaneous,
  title = {An Energy-Efficient Abstraction for Simultaneous Breadth-First Searches},
  booktitle = {The {{IEEE}} High Performance Extreme Computing Conference ({{HPEC}})},
  author = {McLaughlin, Adam and Riedy, Jason and Bader, David A.},
  date = {2015-09},
  location = {Waltham, MA},
  abstract = {Optimized GPU kernels are sufficiently complicated to write that they often are specialized to specific input data, target architectures, or applications. This paper presents a multi-search abstraction for computing multiple breadth-first searches in parallel and demonstrates a high-performance, general implementation. Our abstraction removes the burden of orchestrating graph traversal from the user while providing high performance and low energy usage, an often overlooked component of algorithm design. Energy consumption has become a first-class hardware design constraint for both massive and embedded computing platforms. Our abstraction can be applied to such problems as the all-pairs shortest-path problem, community detection, reachability querying, and others. To map graph traversal efficiently to NVIDIA GPUs, our hybrid implementation chooses between processing active vertices with a single thread or an entire warp based on vertex outdegree. For a set of twelve varied graphs, the implementation of our abstraction saves 42\% time and 62\% energy on average compared to representative implementations of specific applications from existing literature.},
  keywords = {ejr-CV,graph analysis,hpda,parallel algorithm,proceedings}
}

@unpublished{2015riedyGraphAnalysisLinear,
  title = {Graph Analysis beyond Linear Algebra},
  author = {Riedy, E. Jason},
  date = {2015-10},
  url = {http://www.slideshare.net/jasonriedy/graph-analysis-beyond-linear-algebra},
  abstract = {High-performance graph analysis is unlocking knowledge in computer security, bioinformatics, social networks, and many other data integration areas. Graphs provide a convenient abstraction for many data problems beyond linear algebra. Some problems map directly to linear algebra. Others, like community detection, look eerily similar to sparse linear algebra techniques. And then there are algorithms that strongly resist attempts at making them look like linear algebra. This talk will cover recent results with an emphasis on streaming graph problems where the graph changes and results need updated with minimal latency. We’ll also touch on issues of sensitivity and reliability where graph analysis needs to learn from numerical analysis and linear algebra.},
  keywords = {blas,ejr-CV,graph analysis,lapack,linear algebra,presentation,streaming data},
  note = {Invited presentation}
}

@unpublished{2015riedyNetworkChallengeError,
  title = {Network Challenge: {{Error}} and Sensitivity Analysis},
  author = {Riedy, Jason},
  date = {2015-05},
  url = {http://www.slideshare.net/jasonriedy/network-challenge-error-and-sensitivity-analysis},
  venue = {Vancouver, BC},
  keywords = {ejr-CV,graph analysis,invited-presentation,sensitivity},
  note = {Invited panelist}
}

@inproceedings{2016baderSemanticDatabaseApplications,
  title = {Semantic Database Applications at the {{Samtavro Cemetery}}, {{Georgia}}},
  booktitle = {The 44th Computer Applications and Quantitative Methods in Archaeology Conference ({{CAA}})},
  author = {Bader, David and Michalewicz, Aleksandra and Green, Oded and Birkett-Rees, Jessie and Riedy, Jason and Fairbanks, James and Zakrzewska, Anita},
  date = {2016-03},
  location = {Oslo, Norway},
  abstract = {In 2013 a paper was offered to the CAA concerning archaeological legacy data and semantic database applications, with some preliminary results for a study conducted into the Samtavro cemetery, situated in the South Caucasus in the modern republic of Georgia. The present paper presents further research outcomes of data mining the Samtavro material. Over four thousand graves were excavated at this site, used most intensively during the Late Bronze and Iron Ages, and later in the Roman and Late Antique periods. The current project focuses on the latter period—and the legacy of Soviet and post-Soviet excavations—in a collaborative effort between computer scientists based at the Georgia Institute of Technology, USA, and archaeologists at the University of Melbourne and Monash University, Australia. Data for 1075 tombs, 1249 individuals, and 5842 grave accoutrements were collected across 74 data fields, resulting in the identification of 9 tomb types, 37 artefact types and 320 artefact subtypes. Methods tested against the Samtavro material culture included the application of clustering techniques to understand associations of related items based on patterns of co-occurrence, using traditional data mining (hierarchical link clustering) and spectral graph theory—focusing on tomb types in relation to artefact types. The other method calculated the probability of each event occurring and comparing this to what we would expect if these were truly random—focusing on artefact types in relation to biological sex and age brackets. In some instances, our work confirmed previously established relationships, but it likewise revealed new results concerning particular entities. The project demonstrates that although sites for which comprehensive archival records exist can benefit from these types of approaches, often the greatest limitation in taking a ‘big data’ approach is the relative scarcity of archaeological data.},
  keywords = {archaeology,ejr-CV,graph analysis,proceedings}
}

@inproceedings{2016dukhanWantedFloatingpointAdd,
  title = {Wanted: {{Floating-point}} Add Round-off Error Instruction},
  booktitle = {The 2nd International Workshop on Performance Modeling: {{Methods}} and Applications ({{PMMA16}})},
  author = {Dukhan, Marat and Vuduc, Richard and Riedy, Jason},
  date = {2016-06},
  location = {Frankfurt, Germany},
  url = {https://blogs.fau.de/hager/files/2016/06/pmma2016-slides_Dukhan.pdf},
  abstract = {We propose a new instruction (FPADDRE) that computes the round-off error in floating-point addition. We explain how this instruction benefits high-precision arithmetic operations in applications where double precision is not sufficient. Performance estimates on Intel Haswell, Intel Skylake, and AMD Steamroller processors, as well as Intel Knights Corner co-processor, demonstrate that such an instruction would improve the latency of double-double addition by up to 55\% and increase double-double addition throughput by up to 103\%, with smaller, but non-negligible benefits for double-double multiplication. The new instruction delivers up to 2x speedups on three benchmarks that use high-precision floating-point arithmetic: double-double matrix-matrix multiplication, compensated dot product, and polynomial evaluation via the compensated Horner scheme.},
  keywords = {ejr-CV,floating point,ieee754,proceedings},
  note = {(Workshop with ISC High Performance)}
}

@online{2016dukhanWantedFloatingpointAdda,
  title = {Wanted: {{Floating-point}} Add Round-off Error Instruction},
  author = {Dukhan, Marat and Vuduc, Richard W. and Riedy, E. Jason},
  date = {2016},
  url = {http://arxiv.org/abs/1603.00491},
  pubstate = {prepublished},
  keywords = {ejr-CV,technical-report}
}

@report{2016e.jasonriedypiSupportDataAnalytics,
  title = {Support for Data Analytics for {{CSE}} Programs and Courses},
  author = {{E. Jason Riedy (PI)} and {David Bader}},
  date = {2016-07},
  institution = {Georgia Institute of Technology},
  keywords = {ejr-CV,grants},
  note = {\$194\,150}
}

@article{2016holderCurrentFutureChallenges,
  title = {Current and Future Challenges in Mining Large Networks: {{Report}} on the Second {{SDM}} Workshop on Mining Networks and Graphs},
  author = {Holder, Lawrence B. and Caceres, Rajmonda and Gleich, David F. and Riedy, Jason and Khan, Maleq and Chawla, Nitesh V. and Kumar, Ravi and Wu, Yinghui and Klymko, Christine and Eliassi-Rad, Tina and Prakash, Aditya},
  date = {2016-08},
  journaltitle = {SIGKDD Explorations Newsletter},
  volume = {18},
  number = {1},
  pages = {39--45},
  publisher = {ACM},
  location = {New York, NY, USA},
  issn = {1931-0145},
  doi = {10.1145/2980765.2980770},
  keywords = {big data,challenges,ejr-CV,graph mining,Network mining,technical-report}
}

@unpublished{2016riedyScalableNetworkAnalysis,
  title = {Scalable Network Analysis: {{Tools}}, Algorithms, Applications},
  author = {Riedy, E. Jason and Bader, David A.},
  date = {2016-04},
  url = {http://www.slideshare.net/jasonriedy/scalable-and-efficient-algorithms-for-analysis-of-massive-streaming-graphs-60975076},
  abstract = {Graph analysis provides tools for analyzing the irregular data sets common in health informatics, computational biology, climate science, sociology, security, finance, and many other fields. These graphs possess different structures than typical finite element meshes. Scaling graph analysis to the scales of data being gathered and created has spawned many directions of exciting new research. This minisymposium includes talks on massive graph generation for testing and evaluating parallel algorithms, novel streaming techniques, and parallel graph algorithms for new and existing problems. It also covers existing parallel frameworks and interdisciplinary applications, e.g. the analysis of climate networks.},
  venue = {Paris, France},
  keywords = {ejr-CV,graph analysis,hpda,parallel algorithm,presentation,streaming data},
  note = {Minisymposium organizer with Henning Meyerhenke and David A. Bader.}
}

@inproceedings{2016riedyUpdatingPageRankStreaming,
  title = {Updating {{PageRank}} for Streaming Graphs},
  booktitle = {Graph {{Algorithms Building Blocks}} ({{GABB}} 2016)},
  author = {Riedy, Jason},
  date = {2016-05},
  location = {Chicago, IL},
  abstract = {Incremental graph algorithms can respond quickly to small changes in massive graphs by updating rather than recomputing analysis metrics. Here we use the linear system formulation of PageRank and ideas from iterative refinement to compute the update to a PageRank vector accurately and quickly. The core idea is to express the residual of the original solution with respect to the updated matrix representing the graph. The update to the residual is sparse. Solving for the solution update with a straight-forward iterative method spreads the change outward from the change locations but converges before traversing the entire graph. We achieve speed-ups of 2× to over 40× relative to a restarted, highly parallel PageRank iteration for small, low-latency batches of edge insertions. These cases traverse 2× to nearly 10\,000× fewer edges than the restarted PageRank iteration. This provides an interesting test case for the ongoing GraphBLAS effort: Can the APIs support our incremental algorithms cleanly and efficiently?},
  keywords = {ejr-CV,graph analysis,hpda,parallel algorithm,proceedings,streaming data},
  note = {(Workshop with IPDPS 2016)}
}

@unpublished{2017demmelProposalNextgenerationBLAS,
  title = {A Proposal for a Next-Generation {{BLAS}}},
  author = {Demmel, James and Gates, Mark and Henry, Greg and Li, Xiaoye S. and Riedy, Jason and Tang, P.T. Peter},
  date = {2017-11},
  url = {https://goo.gl/hvDu3d},
  keywords = {blas,ejr-CV,lapack,linear algebra,unpublished},
  note = {(living document, being updated)}
}

@unpublished{2017demmelProposalNextgenerationBLASa,
  title = {A Proposal for a Next-Generation {{BLAS}}},
  author = {Demmel, James and Henry, Greg and Li, Xiaoye and Riedy, Jason and Tang, Peter},
  date = {2017-02},
  url = {http://www.netlib.org/utk/people/JackDongarra/WEB-PAGES/Batched-BLAS-2017/talk05-demmel.pdf},
  venue = {Atlanta, Georgia},
  keywords = {blas,ejr-CV,linear algebra,presentation}
}

@report{2017e.jasonriedypiEvaluatingMemorycentricArchitectures,
  title = {Evaluating Memory-Centric Architectures for High Performance Data Analysis},
  author = {{E. Jason Riedy (PI)} and {David A. Bader} and {Thomas M. Conte}},
  date = {2017-08},
  institution = {Georgia Institute of Technology},
  keywords = {ejr-CV,grants},
  note = {\$662\,525}
}

@report{2017jeffreys.youngpiCDSESuperSTARLUSTacked,
  title = {{{CDS}}\&{{E}}: {{SuperSTARLU}} - {{STacked}}, {{AcceleRated Algorithms}} for Sparse Linear Systems},
  author = {{Jeffrey S. Young (PI)} and {Jason Riedy (coPI)} and {Richard Vuduc (coPI)}},
  date = {2017-08},
  number = {NSF 1710371},
  institution = {Georgia Institute of Technology},
  keywords = {ejr-CV,grants},
  note = {\$500\,000}
}

@article{2017nathanLocalCommunityDetection,
  title = {Local Community Detection in Dynamic Graphs Using Personalized Centrality},
  author = {Nathan, Eisha and Zakrzewska, Anita and Riedy, Jason and Bader, David A.},
  date = {2017-08},
  journaltitle = {Algorithms},
  volume = {10},
  number = {3},
  issn = {1999-4893},
  doi = {10.3390/a10030102},
  abstract = {Analyzing massive graphs poses challenges due to the vast amount of data available. Extracting smaller relevant subgraphs allows for further visualization and analysis that would otherwise be too computationally intensive. Furthermore, many real data sets are constantly changing, and require algorithms to update as the graph evolves. This work addresses the topic of local community detection, or seed set expansion, using personalized centrality measures, specifically PageRank and Katz centrality. We present a method to efficiently update local communities in dynamic graphs. By updating the personalized ranking vectors, we can incrementally update the corresponding local community. Applying our methods on real-world graphs, we are able to obtain speedups of up to 60× compared to static recomputation while maintaining an average recall of 0.94 of the highly ranked vertices returned. Next, we investigate how approximations of a centrality vector affect the resulting local community. Specifically, our method that guarantees that the vertices returned in the community are the highly ranked vertices from a personalized centrality metric.},
  keywords = {ejr-CV,refereed}
}

@unpublished{2017nathanNewDirectionStreaming,
  title = {A New Direction for Streaming Graph Analysis},
  author = {Nathan, Eisha and Zakrzewska, Anita and Yin, Chunxing and Riedy, Jason},
  date = {2017-09},
  abstract = {Applications in computer network security, social media analysis, and other areas rely on analyzing a changing environment. The data is rich in relationships and lends itself to graph analysis. Traditional static graph analysis cannot keep pace with network security applications analyzing nearly one million events per second and social networks like Facebook collecting 500 thousand comments per second. Streaming frameworks like STINGER support ingesting up three million of edge changes per second but there are few streaming analysis kernels that keep up with these rates. Here we introduce a new, non-stop model and use it to decouple the analysis from the data ingest.},
  venue = {Honolulu, HI},
  keywords = {ejr-CV,graph analysis,hpda,memory-centric,novel architectures,presentation,streaming data}
}

@unpublished{2017riedyHighperformanceAnalysisStreaming,
  title = {High-Performance Analysis of Streaming Graphs},
  author = {Riedy, Jason},
  date = {2017-06},
  url = {https://www.slideshare.net/jasonriedy/highperformance-analysis-of-streaming-graphs-77348572},
  abstract = {Graph-structured data in social networks, finance, network security, and others not only are massive but also under continual change. These changes often are scattered across the graph. Stopping the world to run a single, static query is infeasible. Repeating complex global analyses on massive snapshots to capture only what has changed is inefficient. We discuss requirements for single-shot queries on changing graphs as well as recent high-performance algorithms that update rather than recompute results. These algorithms are incorporated into our software framework for streaming graph analysis, STINGER.},
  venue = {Hanover, MD},
  keywords = {ejr-CV,graph analysis,hpda,memory-centric,novel architectures,presentation,streaming data}
}

@unpublished{2017riedyHighperformanceAnalysisStreaminga,
  title = {High-Performance Analysis of Streaming Graphs},
  author = {Riedy, E. Jason},
  date = {2017-03},
  url = {https://www.slideshare.net/jasonriedy/highperformance-analysis-of-streaming-graphs},
  abstract = {Graph-structured data in social networks, finance, network security, and others not only are massive but also under continual change. These changes often are scattered across the graph. Stopping the world to run a single, static query is infeasible. Repeating complex global analyses on massive snapshots to capture only what has changed is inefficient. We discuss requirements for single-shot queries on changing graphs as well as recent high-performance algorithms that update rather than recompute results. These algorithms are incorporated into our software framework for streaming graph analysis, STING (Spatio-Temporal Interaction Networks and Graphs).},
  venue = {Atlanta, GA},
  keywords = {ejr-CV,graph analysis,hpda,parallel algorithm,presentation,streaming data},
  note = {Minisymposium organizer with Henning Meyerhenke.}
}

@inproceedings{2017riedyNewAlgorithmModel,
  title = {A New Algorithm Model for Massive-Scale Streaming Graph Analysis},
  booktitle = {{{SIAM}} Workshop on Network Science},
  author = {Riedy, E. Jason and Yin, Chunxing and Bader, David A.},
  date = {2017-07},
  location = {Pittsburgh, PA},
  url = {https://www.slideshare.net/jasonriedy/a-new-algorithm-model-for-massivescale-streaming-graph-analysis},
  keywords = {ejr-CV,graph analysis,hpda,proceedings,streaming data}
}

@unpublished{2017riedyProposalNextgenerationBLAS,
  title = {A Proposal for a Next-Generation {{BLAS}}},
  author = {Riedy, E. Jason and Henry, Greg and Demmel, James and Gates, Mark and Li, Xiaoye S. and Tang, Ping Tak P.},
  date = {2017-11},
  url = {http://icl.utk.edu/bblas/sc17/files/bblas-sc17-riedy.pdf},
  keywords = {blas,ejr-CV,linear algebra,presentation}
}

@article{2018demmelReproducibleBLASMake,
  entrysubtype = {newspaper},
  title = {Reproducible {{BLAS}}: {{Make}} Addition Associative Again!},
  author = {Demmel, James and Riedy, Jason and Ahrens, Peter},
  date = {2018-10},
  journaltitle = {SIAM News},
  volume = {51},
  number = {8},
  pages = {8},
  url = {https://sinews.siam.org/Details-Page/reproducible-blas-make-addition-associative-again},
  keywords = {ejr-CV,floating point,ieee754,linear algebra,trade-pub}
}

@inproceedings{2018heinInitialCharacterizationEmu,
  title = {An Initial Characterization of the {{Emu Chick}}},
  booktitle = {The Eighth International Workshop on Accelerators and Hybrid Exascale Systems ({{AsHES}})},
  author = {Hein, Eric and Conte, Tom and Young, Jeffrey S. and Eswar, Srinivas and Li, Jiajia and Lavin, Patrick and Vuduc, Richard and Riedy, Jason},
  date = {2018-05},
  pages = {579--588},
  doi = {10.1109/IPDPSW.2018.00097},
  abstract = {The Emu Chick is a prototype system designed around the concept of migratory memory-side processing. Rather than transferring large amounts of data across power-hungry, high-latency interconnects, the Emu Chick moves lightweight thread contexts to near-memory cores before the beginning of each memory read. The current prototype hardware uses FPGAs to implement cache-less "Gossamer" cores for doing computational work and a stationary core to run basic operating system functions and migrate threads between nodes. In this initial characterization of the Emu Chick, we study the memory bandwidth characteristics of the system through benchmarks like STREAM, pointer chasing, and sparse matrix vector multiply. We compare the Emu Chick hardware to architectural simulation and Intel Xeon-based platforms. While it is difficult to accurately compare prototype hardware with existing systems, our initial evaluation demonstrates that the Emu Chick uses available memory bandwidth more efficiently than a more traditional, cache-based architecture. Moreover, the Emu Chick provides stable, predictable performance with 80\% bandwidth utilization on a random-access pointer chasing benchmark with weak locality.},
  isbn = {978-1-5386-5555-9},
  keywords = {Bandwidth,Benchmark testing,benchmarking,computer architecture,Computer architecture,ejr-CV,emu,Hardware,hpda,Instruction sets,Kernel,memory-centric,novel architectures,proceedings,Prototypes,sparse tensors,streaming graphs}
}

@report{2018jasonriedycopiHighperformanceDataAnalytics,
  title = {High-Performance Data Analytics ({{HPDA}}) Research Topics},
  author = {{Jason Riedy (coPI)} and Park, Haesun and {David A. Bader (PI)}},
  date = {2018-01},
  institution = {Georgia Institute of Technology},
  keywords = {ejr-CV,grants},
  note = {\$100\,000}
}

@online{2018lavinSpatterBenchmarkSuite,
  title = {Spatter: {{A}} Benchmark Suite for Evaluating Sparse Access Patterns},
  author = {Lavin, Patrick and Riedy, E. Jason and Vuduc, Rich and Young, Jeffrey},
  date = {2018},
  url = {http://arxiv.org/abs/1811.03743},
  abstract = {Recent characterizations of data movement performance have evaluated optimizations for dense and blocked accesses used by accelerators like GPUs and Xeon Phi, but sparse access patterns like scatter and gather are still not well understood across current and emerging architectures. We propose a tunable benchmark suite, Spatter, that allows users to characterize scatter, gather, and related sparse access patterns at a low level across multiple backends, including CUDA, OpenCL, and OpenMP. Spatter also allows users to vary the block size and amount of data that is moved to create a more comprehensive picture of sparse access patterns and to model patterns that are found in real applications. With Spatter we aim to characterize the performance of memory systems in a novel way by evaluating how the density of accesses compares against real-world effective memory bandwidths (measured by STREAM) and how it can be compared across widely varying architectures including GPUs and x86, ARM, and Power CPUs. We demonstrate how Spatter can be used to generate analysis plots comparing different architectures and show that current GPU systems achieve up to 65\% of STREAM bandwidth for sparse accesses and are more energy efficient in doing so for several different sparsity patterns. Our future plans for the spatter benchmark are to use these results to predict the impact of new memory access primitives on various architectures, develop backends for novel hardware like FPGAs and the Emu Chick, and automate testing so that users can perform their own sparse access studies.},
  pubstate = {prepublished},
  keywords = {ejr-CV,technical-report}
}

@online{2018powellWranglingRoguesManaging,
  title = {Wrangling Rogues: {{Managing}} Experimental Post-Moore Architectures},
  author = {Powell, Will and Riedy, E. Jason and Young, Jeffrey S. and Conte, Thomas M.},
  date = {2018},
  url = {http://arxiv.org/abs/1808.06334},
  abstract = {The Rogues Gallery is a new experimental testbed that is focused on tackling "rogue" architectures for the Post-Moore era of computing. While some of these devices have roots in the embedded and high-performance computing spaces, managing current and emerging technologies provides a challenge for system administration that are not always foreseen in traditional data center environments. We present an overview of the motivations and design of the initial Rogues Gallery testbed and cover some of the unique challenges that we have seen and foresee with upcoming hardware prototypes for future post-Moore research. Specifically, we cover the networking, identity management, scheduling of resources, and tools and sensor access aspects of the Rogues Gallery and techniques we have developed to manage these new platforms.},
  pubstate = {prepublished},
  keywords = {ejr-CV,technical-report}
}

@inproceedings{2018riedyAugmentedArithmeticOperations,
  title = {Augmented Arithmetic Operations Proposed for {{IEEE-754}} 2018},
  booktitle = {25th {{IEEE}} Symposium on Computer Arithmetic ({{ARITH}} 25)},
  author = {Riedy, Jason and Demmel, James},
  date = {2018-06},
  doi = {10.1109/ARITH.2018.8464813},
  keywords = {ejr-CV,floating point,ieee754,proceedings}
}

@unpublished{2018riedyGraphAnalysisNew,
  title = {Graph Analysis: {{New}} Algorithm Models, New Architectures},
  author = {Riedy, Jason},
  date = {2018-03},
  venue = {Tokyo, Japan},
  keywords = {ejr-CV,graph analysis,hpda,memory-centric,novel architectures,presentation,streaming data},
  note = {Minisymposium organizer with Oded Green and David A. Bader.}
}

@unpublished{2018riedyPlansIEEEStandard,
  title = {Plans for {{IEEE}} Standard 754-2028},
  author = {Riedy, Jason},
  date = {2018-06},
  journaltitle = {25th IEEE symposium on computer arithmetic (ARITH 25)},
  url = {https://www.slideshare.net/jasonriedy/plans-for-ieee-standard-7542028},
  keywords = {ejr-CV,floating point,ieee754,invited-presentation,linear algebra,memory centric},
  note = {Invited talk
\par
Invited talk}
}

@unpublished{2018riedyStreamingGraphAnalysis,
  title = {Streaming Graph Analysis: {{New}} Models, New Architectures},
  author = {Riedy, Jason},
  date = {2018-05},
  journaltitle = {ACM international conference on computing frontiers},
  url = {https://www.slideshare.net/jasonriedy/graph-analysis-new-algorithm-models-new-architectures},
  keywords = {ejr-CV,graph analysis,hpda,invited-presentation,memory-centric,novel architectures,streaming data},
  note = {Invited talk.
\par
Invited talk.}
}

@unpublished{2018riedyUpdatedProposalNextgeneration,
  title = {Updated Proposal for a Next-Generation {{BLAS}}},
  author = {Riedy, E. Jason and Henry, Greg and Demmel, James and Gates, Mark and Li, Xiaoye S. and Tang, Ping Tak P.},
  date = {2018-11},
  url = {http://icl.utk.edu/bblas/sc18/files/NG_BLAS_SC18.pdf},
  abstract = {The classic BLAS interface is concise and mostly predictable. The BLAS Technical Forum produced a 301-page document in 2001 that incorporated mixed precision and extended operations. And now we face different implementations for reproducibility, even more precisions, and the batched interfaces. The explosion of interfaces causes problems for platform optimization and interface generation. The "Next-Generation BLAS Proposal" provides a unified naming scheme and semantic requirements for extensions. Inspired by the BLIS project, we also consider a minimal set of microkernels to provide a smaller optimization surface.},
  keywords = {blas,ejr-CV,linear algebra,presentation}
}

@inproceedings{2018yinNewAlgorithmicModel,
  title = {A New Algorithmic Model for Graph Analysis of Streaming Data},
  booktitle = {Proceedings of the 14th International Workshop on Mining and Learning with Graphs ({{MLG}})},
  author = {Yin, Chunxing and Riedy, Jason and Bader, David A.},
  date = {2018-05},
  url = {http://www.mlgworkshop.org/2018/papers/MLG2018_paper_23.pdf},
  keywords = {ejr-CV,graph analysis,hpda,proceedings,streaming data}
}

@online{2018youngMicrobenchmarkCharacterizationEmu,
  title = {A Microbenchmark Characterization of the {{Emu Chick}}},
  author = {Young, Jeffrey and Hein, Eric R. and Eswar, Srinivas and Lavin, Patrick and Li, Jiajia and Riedy, E. Jason and Vuduc, Richard W. and Conte, Tom},
  date = {2018},
  url = {http://arxiv.org/abs/1809.07696},
  pubstate = {prepublished},
  keywords = {ejr-CV,technical-report}
}

@unpublished{2019donofrioSpecializingArchitecturesData,
  title = {Specializing Architectures for Data Analytics},
  author = {Donofrio, David and Riedy, Jason},
  date = {2019-09},
  url = {https://hpc.pnl.gov/armbof/},
  venue = {Austin, TX},
  keywords = {ejr-CV,presentation},
  note = {Introduction to invited panel on "We can't build specialized architectures for graphs that can work efficiently with other workloads, so we just need to hand-optimize each and every algorithm for each and every architecture"}
}

@unpublished{2019gatesProposalNextgenerationBLAS,
  title = {A Proposal for Next-Generation {{BLAS}}},
  author = {Gates, Mark and Demmel, James W. and Henry, Greg and Li, Xiaoye S. and Riedy, E. Jason and Tang, Peter},
  date = {2019-02},
  url = {http://icl.utk.edu/bblas/siam-cse19/},
  venue = {Spokane, WA},
  keywords = {ejr-CV,presentation}
}

@online{2019heinProgrammingStrategiesIrregular,
  title = {Programming Strategies for Irregular Algorithms on the {{Emu Chick}}},
  author = {Hein, Eric R. and Eswar, Srinivas and Yasar, Abdurrahman and Li, Jiajia and Young, Jeffrey S. and Conte, Thomas M. and Çatalyürek, Ümit V. and Vuduc, Rich and Riedy, E. Jason and Uçar, Bora},
  date = {2019},
  url = {http://arxiv.org/abs/1901.02775},
  abstract = {The Emu Chick prototype implements migratory memory-side processing in a novel hardware system. Rather than transferring large amounts of data across the system interconnect, the Emu Chick moves lightweight thread contexts to near-memory cores before the beginning of each remote memory read. Previous work has characterized the performance of the Chick prototype in terms of memory bandwidth and programming differences from more typical, non-migratory platforms, but there has not yet been an analysis of algorithms on this system. This work evaluates irregular algorithms that could benefit from the lightweight, memory-side processing of the Chick and demonstrates techniques and optimization strategies for achieving performance in sparse matrix-vector multiply operation (SpMV), breadth-first search (BFS), and graph alignment across up to eight distributed nodes encompassing 64 nodelets in the Chick system. We also define and justify relative metrics to compare prototype FPGA-based hardware with established ASIC architectures. The Chick currently supports up to 68x scaling for graph alignment, 80 MTEPS for BFS on balanced graphs, and 50\% of measured STREAM bandwidth for SpMV.},
  pubstate = {prepublished},
  keywords = {ejr-CV,technical-report}
}

@standard{2019ieee754committeeIEEEStandardFloatingpoint,
  type = {IEEE Std},
  title = {{{IEEE}} Standard for Floating-Point Arithmetic},
  author = {{IEEE 754 Committee}},
  date = {2019},
  number = {754--2019},
  publisher = {Microprocessor Standards Committee of the IEEE Computer Society},
  location = {New York, NY},
  url = {https://ieeexplore.ieee.org/servlet/opac?punumber=8739148},
  isbn = {978-1-5044-5897-9},
  keywords = {754-2008,arithmetic,arithmetic formats,binary,computer,computer programming,decimal,decimal floating-point arithmetic,ejr-CV,exponent,floating point arithmetic,floating-point,format,IEEE standard,IEEE standards,interchange,NaN,number,programming,rounding,significand,subnormal,technical-report},
  note = {(committee member and contributor)}
}

@report{2019jasonriedypiPOWERSystemsData,
  title = {{{POWER}} Systems for Data Analysis and {{HPC}} Classes},
  author = {{Jason Riedy (PI)} and {Will Powell} and {David Bader}},
  date = {2019-07},
  institution = {Georgia Institute of Technology},
  keywords = {ejr-CV,grants},
  note = {\$96\,272}
}

@inproceedings{2019powellWranglingRoguesCase,
  title = {Wrangling {{Rogues}}: A Case Study on Managing Experimental Post-{{Moore}} Architectures},
  booktitle = {Practice and Experience in Advanced Research Computing ({{PEARC}} '19)},
  author = {Powell, Will and Riedy, Jason and Young, Jeffrey S. and Conte, Tom},
  date = {2019-07},
  location = {Chicago, IL},
  doi = {10.1145/3332186.3332223},
  keywords = {ejr-CV,proceedings}
}

@unpublished{2019riedyCharacterizationEmuMicrobenchmarks,
  title = {Characterization of {{Emu}} with Microbenchmarks},
  author = {Riedy, E. Jason},
  date = {2019-01},
  venue = {Catonsville, MD},
  keywords = {ejr-CV,presentation}
}

@unpublished{2019riedyNovelArchitecturesApplications,
  title = {Novel Architectures for Applications in Data Science and Beyond},
  author = {Riedy, Jason and Young, Jeffrey and Conte, Tom},
  date = {2019-03},
  url = {http://www.crnch.gatech.edu/content/siam-cse-2019-go-bananas},
  venue = {Spokane, WA},
  keywords = {ejr-CV,presentation},
  note = {Minisymposium organizer with Jeffrey Young and Tom Conte.}
}

@unpublished{2019riedyProgrammingNovelArchitectures,
  title = {Programming Novel Architectures in the Post-{{Moore}} Era with the {{Rogues Gallery}}},
  author = {Riedy, E. Jason and Young, Jeffrey S.},
  date = {2019-07},
  journaltitle = {Practice and experience in advanced research computing (PEARC)},
  url = {https://crnch-rg.gitlab.io/pearc-2019/},
  venue = {Chicago, IL},
  keywords = {ejr-CV,tutorial},
  note = {\href{https://crnch-rg.gitlab.io/pearc-2019/}{https://crnch-rg.gitlab.io/pearc-2019/}}
}

@unpublished{2019riedyProgrammingNovelArchitecturesa,
  title = {Programming Novel Architectures in the Post-{{Moore}} Era with the {{Rogues Gallery}}},
  author = {Riedy, E. Jason and Young, Jeffrey S.},
  date = {2019-04},
  journaltitle = {24th ACM international conference on architectural support for programming languages and operating systems (ASPLOS)},
  url = {https://crnch-rg.gitlab.io/asplos-2019/},
  venue = {Providence, RI},
  keywords = {ejr-CV,tutorial},
  note = {\href{https://crnch-rg.gitlab.io/asplos-2019/}{https://crnch-rg.gitlab.io/asplos-2019/}}
}

@unpublished{2019riedyReproducibleLinearAlgebra,
  title = {Reproducible Linear Algebra from Application to Architecture},
  author = {Riedy, Jason and Demmel, James and Ahrens, Peter},
  date = {2019-07},
  url = {https://www.slideshare.net/jasonriedy/reproducible-linear-algebra-from-application-to-architecture},
  venue = {Valencia, Spain},
  keywords = {ejr-CV,presentation}
}

@inproceedings{2019yinConcurrentKatzCentrality,
  title = {Concurrent {{Katz}} Centrality for Streaming Graphs},
  booktitle = {The {{IEEE}} High Performance Extreme Computing Conference ({{HPEC}})},
  author = {Yin, Chunxing and Riedy, Jason},
  date = {2019-09},
  location = {Waltham, MA},
  doi = {10.1109/HPEC.2019.8916572},
  keywords = {ejr-CV,graph analysis,hpda,parallel algorithm,proceedings}
}

@unpublished{2019yinNewAlgorithmModel,
  title = {A New Algorithm Model for Massive-Scale Streaming Graph Analysis},
  author = {Yin, Chunxing and Riedy, Jason},
  date = {2019-07},
  url = {https://www.slideshare.net/jasonriedy/a-new-algorithm-model-for-massivescale-streaming-graph-analysis-156808819},
  venue = {Valencia, Spain},
  keywords = {ejr-CV,presentation}
}

@inproceedings{2019youngExperimentalInsightsRogues,
  title = {Experimental Insights from the {{Rogues Gallery}} Testbed},
  booktitle = {{{IEEE}} International Conference on Rebooting Computing ({{ICRC19}})},
  author = {Young, Jeffrey and Riedy, Jason and Conte, Tom and Sarkar, Vivek and Chatarasi, Prasanth and Srikanth, Srisehan},
  date = {2019-11},
  location = {San Mateo, CA},
  doi = {10.1109/ICRC.2019.8914707},
  keywords = {ejr-CV,proceedings}
}

@article{2019youngMicrobenchmarkCharacterizationEmu,
  title = {A Microbenchmark Characterization of the {{Emu Chick}}},
  author = {Young, Jeffrey and Hein, Eric and Eswar, Srinivas and Lavin, Patrick and Li, Jiajia and Riedy, Jason and Vuduc, Richard and Conte, Thomas M.},
  date = {2019-09},
  journaltitle = {Parallel Computing},
  doi = {10.1016/j.parco.2019.04.012},
  abstract = {The Emu Chick is a prototype system designed around the concept of migratory memory-side processing. Rather than transferring large amounts of data across power-hungry, high-latency interconnects, the Emu Chick moves lightweight thread contexts to near-memory cores before the beginning of each memory read. The current prototype hardware uses FPGAs to implement cache-less “Gossamer” cores for doing computational work and a stationary core to run basic operating system functions and migrate threads between nodes. In this multi-node characterization of the Emu Chick, we extend an earlier single-node investigation of the the memory bandwidth characteristics of the system through benchmarks like STREAM, pointer chasing, and sparse matrix-vector multiplication. We compare the Emu Chick hardware to architectural simulation and an Intel Xeon-based platform. Our results demonstrate that for many basic operations the Emu Chick can use available memory bandwidth more efficiently than a more traditional, cache-based architecture although bandwidth usage suffers for computationally intensive workloads like SpMV. Moreover, the Emu Chick provides stable, predictable performance with up to 65\% of the peak bandwidth utilization on a random-access pointer chasing benchmark with weak locality.},
  keywords = {ejr-CV,refereed}
}

@article{2020heinProgrammingStrategiesIrregular,
  title = {Programming Strategies for Irregular Algorithms on the {{Emu Chick}}},
  author = {Hein, Eric R. and Eswar, Srinivas and Yaşar, Abdurrahman and Li, Jiajia and Young, Jeffrey S. and Conte, Thomas M. and Çatalyürek, Ümit V. and Vuduc, Richard and Riedy, Jason and Uçar, Bora},
  date = {2020-10},
  journaltitle = {ACM Transactions on Parallel Computing},
  shortjournal = {ACM Trans. Parallel Comput.},
  volume = {7},
  number = {4},
  publisher = {Association for Computing Machinery},
  location = {New York, NY, USA},
  issn = {2329-4949},
  doi = {10.1145/3418077},
  abstract = {The Emu Chick prototype implements migratory memory-side processing in a novel hardware system. Rather than transferring large amounts of data across the system interconnect, the Emu Chick moves lightweight thread contexts to near-memory cores before the beginning of each remote memory read. Previous work has characterized the performance of the Chick prototype in terms of memory bandwidth and programming differences from more typical, non-migratory platforms, but there has not yet been an analysis of algorithms on this system.This work evaluates irregular algorithms that could benefit from the lightweight, memory-side processing of the Chick and demonstrates techniques and optimization strategies for achieving performance in sparse matrix-vector multiply operation (SpMV), breadth-first search (BFS), and graph alignment across up to eight distributed nodes encompassing 64 nodelets in the Chick system. We also define and justify relative metrics to compare prototype FPGA-based hardware with established ASIC architectures. The Chick currently supports up to 68x scaling for graph alignment, 80 MTEPS for BFS on balanced graphs, and 50\% of measured STREAM bandwidth for SpMV.},
  keywords = {ejr-CV,EMU architecture,refereed}
}

@report{2020jefferyyoungpiReconfigurableClusterInitiative,
  title = {Reconfigurable Cluster Initiative},
  author = {{Jeffery Young (PI)} and {Hyesoon Kim} and {Jason Riedy} and {Lee Lerner}},
  date = {2020-07},
  institution = {Georgia Institute of Technology},
  keywords = {ejr-CV,grants},
  note = {\$74\,905}
}

@report{2020jeffreyyoungpiCCRIMediumRogues,
  title = {{{CCRI}}: {{Medium}}: {{Rogues}} Gallery: A Community Research Infrastructure for Post-Moore Computing},
  author = {{Jeffrey Young (PI)} and {Jennifer Hasler} and {Ada Gavrilovska} and {Thomas Conte} and {Jason Riedy}},
  date = {2020-09},
  number = {NSF 2016701},
  institution = {Georgia Institute of Technology},
  keywords = {ejr-CV,grants},
  note = {\$1\,351\,699}
}

@article{2020lavinEvaluatingGatherScatter,
  title = {Evaluating Gather and Scatter Performance on Cpus and Gpus},
  author = {Lavin, Patrick and Young, Jeffrey and Vuduc, Richard and Riedy, Jason and Vose, Aaron and Ernst, Daniel},
  date = {2020-09},
  journaltitle = {The International Symposium on Memory Systems (MEMSYS)},
  publisher = {ACM},
  location = {Washington, DC},
  doi = {10.1145/3422575.3422794},
  url = {http://dx.doi.org/10.1145/3422575.3422794},
  keywords = {ejr-CV,proceedings}
}

@unpublished{2020riedyGraphAnalysisNovel,
  title = {Graph Analysis and Novel Architectures},
  author = {Riedy, Jason},
  date = {2020-09},
  url = {https://www2.slideshare.net/jasonriedy/graph-analysis-and-novel-architectures},
  keywords = {ejr-CV,presentation}
}

@unpublished{2020riedyGraphBLASEmus,
  title = {{{GraphBLAS}} and {{Emus}}},
  author = {Riedy, Jason},
  date = {2020-09},
  url = {https://www2.slideshare.net/jasonriedy/graphblas-and-emus},
  keywords = {ejr-CV,presentation}
}

@unpublished{2020riedyPotentialDirectionsMoving,
  title = {Potential Directions for Moving {{IEEE-754}} Forward},
  author = {Riedy, Jason},
  date = {2020-05},
  url = {https://icerm.brown.edu/materials/Slides/htw-20-vp/Potential_Directions_for_Moving_IEEE-754_Forward_%5D_Jason_Riedy,_Georgia_Institute_of_Technology.pdf},
  keywords = {ejr-CV,presentation}
}

@unpublished{2020riedyReproducibleLinearAlgebra,
  title = {Reproducible Linear Algebra from Application to Architecture},
  author = {Riedy, Jason and Demmel, James and Ahrens, Peter},
  date = {2020-02},
  url = {https://www.slideshare.net/jasonriedy/reproducible-linear-algebra-from-application-to-architecture-228263588},
  venue = {Seattle, WA},
  keywords = {ejr-CV,presentation}
}

@report{2021martindeneroffpiNonblockingUpdatesGraph,
  title = {Non-Blocking Updates to Graph Databases},
  author = {{Martin Deneroff (PI)} and {Jason Riedy (coPI)}},
  date = {2021-08},
  number = {NSF 2105977},
  institution = {Lucata Corporation},
  keywords = {ejr-CV,grants},
  note = {\$255\,916}
}

@unpublished{2021riedyLightningTalksUpdates,
  title = {Lightning Talks: {{Updates}}/News from the {{GraphBLAS}} Implementers},
  author = {Riedy, Jason and Kuntz, Shannon},
  date = {2021-10},
  url = {https://www.slideshare.net/jasonriedy/lagraph-20211013},
  keywords = {ejr-CV,presentation}
}

@unpublished{2021riedyLightningTalksUpdatesa,
  title = {Lightning Talks: {{Updates}}/News from the {{GraphBLAS}} Implementers},
  author = {Riedy, Jason},
  date = {2021-09},
  url = {https://www.slideshare.net/jasonriedy/lucata-at-the-hpec-graphblas-bof-250439305},
  keywords = {ejr-CV,presentation}
}

@online{2022demmelProposedConsistentException,
  title = {Proposed Consistent Exception Handling for the {{BLAS}} and {{LAPACK}}},
  author = {Demmel, James and Dongarra, Jack and Gates, Mark and Henry, Greg and Langou, Julien and Li, Xiaoye and Luszczek, Piotr and Pereira, Weslley and Riedy, Jason and Rubio-González, Cindy},
  date = {2022},
  url = {http://arxiv.org/abs/2207.09281v1},
  abstract = {Numerical exceptions, which may be caused by overflow, operations like division by 0 or sqrt(-1), or convergence failures, are unavoidable in many cases, in particular when software is used on unforeseen and difficult inputs. As more aspects of society become automated, e.g., self-driving cars, health monitors, and cyber-physical systems more generally, it is becoming increasingly important to design software that is resilient to exceptions, and that responds to them in a consistent way. Consistency is needed to allow users to build higher-level software that is also resilient and consistent (and so on recursively). In this paper we explore the design space of consistent exception handling for the widely used BLAS and LAPACK linear algebra libraries, pointing out a variety of instances of inconsistent exception handling in the current versions, and propose a new design that balances consistency, complexity, ease of use, and performance. Some compromises are needed, because there are preexisting inconsistencies that are outside our control, including in or between existing vendor BLAS implementations, different programming languages, and even compilers for the same programming language. And user requests from our surveys are quite diverse. We also propose our design as a possible model for other numerical software, and welcome comments on our design choices.},
  pubstate = {prepublished},
  keywords = {ejr-CV,technical-report}
}

@unpublished{2022riedyProgrammingLucataDatafirst,
  title = {Programming on the {{Lucata}} Data-First Architecture},
  author = {Riedy, Jason},
  date = {2022-01},
  journaltitle = {Boston area architecture workshop (BARC)},
  url = {https://bostonarch.github.io/2022/BARC23.pdf},
  keywords = {ejr-CV,invited-presentation},
  note = {Keynote
\par
Keynote},
  file = {/home/ejr/Zotero/storage/HENB28KR/Riedy - 2022 - Programming on the Lucata data-first architecture.pdf}
}

@online{2022smithConcurrentGraphQueries,
  title = {Concurrent Graph Queries on the {{Lucata Pathfinder}}},
  author = {Smith, Emory and Kuntz, Shannon and Riedy, Jason and Deneroff, Martin},
  date = {2022},
  url = {http://arxiv.org/abs/2209.11889v1},
  abstract = {High-performance analysis of unstructured data like graphs now is critical for applications ranging from business intelligence to genome analysis. Towards this, data centers hold large graphs in memory to serve multiple concurrent queries from different users. Even a single analysis often explores multiple options. Current computing architectures often are not the most time- or energy-efficient solutions. The novel Lucata Pathfinder architecture tackles this problem, combining migratory threads for low-latency reading with memory-side processing for high-performance accumulation. One hundred to 750 concurrent breadth-first searches (BFS) all achieve end-to-end speed-ups of 81 \% to 97 \% over one-at-a-time queries on a graph with 522M edges. Comparing to RedisGraph running on a large Intel-based server, the Pathfinder achieves a 19× speed-up running 128 BFS queries concurrently. The Pathfinder also efficiently supports a mix of concurrent analyses, demonstrated with connected components and BFS.},
  pubstate = {prepublished},
  keywords = {ejr-CV,technical-report}
}

@unpublished{2022youngExploringGraphAnalysis,
  title = {Exploring Graph Analysis for {{HPC}} with Near-Memory Accelerators},
  author = {Young, Jeffrey and Lavin, Patrick and Riedy, Jason and Eswar, Srinivas},
  date = {2022-09},
  journaltitle = {IEEE high performance extreme computing (HPEC)},
  url = {https://github.com/gt-crnch-rg/lucata-pathfinder-tutorial},
  keywords = {ejr-CV,tutorial},
  note = {\href{https://crnch-rg.gitlab.io/pearc-2019/}{https://crnch-rg.gitlab.io/pearc-2019/},}
}

@misc{2024abdelfattahInterfaceSparseLinear,
  title = {Interface for Sparse Linear Algebra Operations},
  author = {Abdelfattah, Ahmad and Ahrens, Willow and Anzt, Hartwig and Armstrong, Chris and Brock, Ben and Buluc, Aydin and Busato, Federico and Cojean, Terry and Davis, Tim and Demmel, Jim and Dinh, Grace and Gardener, David and Fiala, Jan and Gates, Mark and Haider, Azzam and Imamura, Toshiyuki and Lara, Pedro Valero and Moreira, Jose and Li, Sherry and Luszczek, Piotr and Melichenko, Max and Moeira, Jose and Mokwinski, Yvan and Murray, Riley and Patty, Spencer and Peles, Slaven and Ribizel, Tobias and Riedy, Jason and Rajamanickam, Siva and Sao, Piyush and Shantharam, Manu and Teranishi, Keita and Tomov, Stan and Tsai, Yu-Hsiang and Weichelt, Heiko},
  date = {2024},
  url = {https://arxiv.org/abs/2411.13259},
  abstract = {The standardization of an interface for dense linear algebra operations in the BLAS standard has enabled interoperability between different linear algebra libraries, thereby boosting the success of scientific computing, in particular in scientific HPC. Despite numerous efforts in the past, the community has not yet agreed on a standardization for sparse linear algebra operations due to numerous reasons. One is the fact that sparse linear algebra objects allow for many different storage formats, and different hardware may favor different storage formats. This makes the definition of a FORTRAN-style all-circumventing interface extremely challenging. Another reason is that opposed to dense linear algebra functionality, in sparse linear algebra, the size of the sparse data structure for the operation result is not always known prior to the information. Furthermore, as opposed to the standardization effort for dense linear algebra, we are late in the technology readiness cycle, and many production-ready software libraries using sparse linear algebra routines have implemented and committed to their own sparse BLAS interface. At the same time, there exists a demand for standardization that would improve interoperability, and sustainability, and allow for easier integration of building blocks. In an inclusive, cross-institutional effort involving numerous academic institutions, US National Labs, and industry, we spent two years designing a hardware-portable interface for basic sparse linear algebra functionality that serves the user needs and is compatible with the different interfaces currently used by different vendors. In this paper, we present a C++ API for sparse linear algebra functionality, discuss the design choices, and detail how software developers preserve a lot of freedom in terms of how to implement functionality behind this API.},
  keywords = {ejr-CV,technical-report}
}

@online{wikimediaVariousUses,
  title = {Various Uses},
  author = {{Wikimedia}},
  url = {https://www.google.com/search?q=wikimedia+%22Jason+Riedy%22},
  keywords = {ejr-CV,mention}
}