Cited By
View all- Cutler JWatson CNkurumeh EHilliard PGoldstein HStanford CPierce B(2024)Stream TypesProceedings of the ACM on Programming Languages10.1145/36564348:PLDI(1412-1436)Online publication date: 20-Jun-2024
The essence of online data processing
Article No.: 157, Pages 899 - 928
Abstract
Data processing systems are a fundamental component of the modern computing stack. These systems are routinely deployed online: they continuously receive the requests of data processing operations, and continuously return the results to end users or client applications. Online data processing systems have unique features beyond conventional data processing, and the optimizations designed for them are complex, especially when data themselves are structured and dynamic. This paper describes DON Calculus, the first rigorous foundation for online data processing. It captures the essential behavior of both the backend data processing engine and the frontend application, with the focus on two design dimensions essential yet unique to online data processing systems: incremental operation processing (IOP) and temporal locality optimization (TLO). A novel design insight is that the operations continuously applied to the data can be defined as an operation stream flowing through the data structure, and this abstraction unifies diverse designs of IOP and TLO in one calculus. DON Calculus is endowed with a mechanized metatheory centering around a key observable equivalence property: despite the significant non-deterministic executions introduced by IOP and TLO, the observable result of DON Calculus data processing is identical to that of conventional data processing without IOP and TLO. Broadly, DON Calculus is a novel instance in the active pursuit of providing rigorous guarantees to the software system stack. The specification and mechanization of DON Calculus provide a sound base for the designers of future data processing systems to build upon, helping them embrace rigorous semantic engineering without the need of developing from scratch.
References
[1]
2010. Neo4j Graph Database. http://www.neo4j.org
[2]
Umut A. Acar, Guy E. Blelloch, and Robert Harper. 2006. Adaptive Functional Programming. ACM Trans. Program. Lang. Syst., 28, 6 (2006), Nov., https://doi.org/10.1145/1186632.1186634
[3]
Andrew W. Appel, Lennart Beringer, Adam Chlipala, Benjamin C. Pierce, Zhong Shao, Stephanie Weirich, and Steve Zdancewic. 2016. The DeepSpec Project: The Science of Deep Specification,. https://deepspec.org/
[4]
Arvind Arasu and Jennifer Widom. 2004. A Denotational Semantics for Continuous Queries over Streams and Relations. SIGMOD Rec., 33, 3 (2004), sep, 6–11. issn:0163-5808 https://doi.org/10.1145/1031570.1031572
[5]
E. A. Ashcroft and W. W. Wadge. 1977. Lucid, a nonprocedural language with iteration. Commun. ACM, 20, 7 (1977), July, 8 pages. https://doi.org/10.1145/359636.359715
[6]
Thomas W. Bartenstein and Yu David Liu. 2014. Rate Types for Stream Programs. In OOPSLA’14 (OOPSLA ’14). 213–232. https://doi.org/10.1145/2660193.2660225
[7]
Dimitri P Bertsekas and John N Tsitsiklis. 1989. Parallel and distributed computation: numerical methods. 23, Prentice hall Englewood Cliffs, NJ.
[8]
Sergey Brin and Lawrence Page. 1998. The Anatomy of a Large-Scale Hypertextual Web Search Engine. Computer Networks, 30 (1998), 107–117. https://doi.org/10.1016/S0169-7552(98)00110-X
[9]
Peter Buneman, Susan Davidson, Gerd Hillebrand, and Dan Suciu. 1996. A query language and optimization techniques for unstructured data. In Proceedings of the 1996 ACM SIGMOD international conference on Management of data. 505–516. https://doi.org/10.1145/233269.233368
[10]
Cristiano Calcagno, Walid Taha, Liwen Huang, and Xavier Leroy. 2003. Implementing Multi-Stage Languages Using ASTs, Gensym, and Reflection. In Proceedings of the 2nd International Conference on Generative Programming and Component Engineering (GPCE ’03). Springer-Verlag, 57–76. isbn:3540201025 https://doi.org/10.1007/978-3-540-39815-8_4
[11]
Luca Cardelli. 1988. Phase Distinctions in Type Theory.
[12]
P. Caspi, D. Pilaud, N. Halbwachs, and J. A. Plaice. 1987. LUSTRE: a declarative language for real-time programming. In POPL ’87. 178–188. https://doi.org/10.1145/41625.41641
[13]
Raymond Cheng, Ji Hong, Aapo Kyrola, Youshan Miao, Xuetian Weng, Ming Wu, Fan Yang, Lidong Zhou, Feng Zhao, and Enhong Chen. 2012. Kineograph: Taking the Pulse of a Fast-changing and Connected World. In Proceedings of the 7th ACM European Conference on Computer Systems (EuroSys ’12). ACM, New York, NY, USA. 85–98. isbn:978-1-4503-1223-3 https://doi.org/10.1145/2168836.2168846
[14]
James Cipar, Greg Ganger, Kimberly Keeton, Charles B. Morrey, Craig A.N. Soules, and Alistair Veitch. 2012. LazyBase: Trading Freshness for Performance in a Scalable Database. In Proceedings of the 7th ACM European Conference on Computer Systems (EuroSys ’12). Association for Computing Machinery, New York, NY, USA. 169–182. isbn:9781450312233 https://doi.org/10.1145/2168836.2168854
[15]
Albert Cohen, Marc Duranton, Christine Eisenbeis, Claire Pagetti, Florence Plateau, and Marc Pouzet. 2006. N-Synchronous Kahn Networks: A Relaxed Model of Synchrony for Real-Time Systems. In POPL’06 (POPL ’06). 180–193. https://doi.org/10.1145/1111320.1111054
[16]
Jeffrey Dean and Sanjay Ghemawat. 2004. MapReduce: Simplified Data Processing on Large Clusters. In OSDI’04: Sixth Symposium on Operating System Design and Implementation. San Francisco, CA. 137–150. https://doi.org/10.1145/1327452.1327492
[17]
Philip Dexter, Yu David Liu, and Kenneth Chiu. 2016. Lazy graph processing in Haskell. In Proceedings of the 9th International Symposium on Haskell. 182–192. https://doi.org/10.1145/3241625.2976014
[18]
Philip Dexter, Yu David Liu, and Kenneth Chiu. 2022. The Essence of Online Data Processing - Coq Mechanization. https://doi.org/10.5281/zenodo.7051651
[19]
Laxman Dhulipala, Guy E Blelloch, and Julian Shun. 2019. Low-latency graph streaming using compressed purely-functional trees. In Proceedings of the 40th ACM SIGPLAN Conference on Programming Language Design and Implementation. 918–934. https://doi.org/10.1145/3314221.3314598
[20]
David Ediger, Rob McColl, Jason Riedy, and David A Bader. 2012. Stinger: High performance data structure for streaming graphs. In 2012 IEEE Conference on High Performance Extreme Computing. 1–5. https://doi.org/10.1109/HPEC.2012.6408680
[21]
Marwa Elteir, Heshan Lin, and Wu-chun Feng. 2010. Enhancing mapreduce via asynchronous data processing. In 2010 IEEE 16th International Conference on Parallel and Distributed Systems. 397–405. https://doi.org/10.1109/ICPADS.2010.116
[22]
Kento Emoto, Kiminori Matsuzaki, Zhenjiang Hu, Akimasa Morihata, and Hideya Iwasaki. 2016. Think like a Vertex, Behave like a Function! A Functional DSL for Vertex-Centric Big Graph Processing. In Proceedings of the 21st ACM SIGPLAN International Conference on Functional Programming (ICFP 2016). Association for Computing Machinery, New York, NY, USA. 200–213. isbn:9781450342193 https://doi.org/10.1145/2951913.2951938
[23]
Jeffrey Eymer, Philip Dexter, and Yu David Liu. 2019. Toward Lazy Evaluation in a Graph Database. In The Second Workshop on Incremental Computing (IC’19).
[24]
Jeff Eymer, Philip Dexter, Joseph Raskind, and Yu David Liu. 2022. The PitStop System, online at. https://github.com/PitStop-Github/PitStop
[25]
Cormac Flanagan and Matthias Felleisen. 1995. The Semantics of Future and Its Use in Program Optimizations. In Conference Record of POPL’95: 22nd ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, San Francisco, California, USA, January 23-25, 1995, Ron K. Cytron and Peter Lee (Eds.). ACM Press, 209–220. https://doi.org/10.1145/199448.199484
[26]
Cormac Flanagan and Matthias Felleisen. 1999. The Semantics of Future and an Application. J. Funct. Program., 9, 1 (1999), 1–31. http://journals.cambridge.org/action/displayAbstract?aid=44231
[27]
Joseph E. Gonzalez, Yucheng Low, Haijie Gu, Danny Bickson, and Carlos Guestrin. 2012. PowerGraph: Distributed Graph-Parallel Computation on Natural Graphs. In Presented as part of the 10th USENIX Symposium on Operating Systems Design and Implementation (OSDI 12). USENIX, Hollywood, CA. 17–30. isbn:978-1-931971-96-6
[28]
Samuel Grossman, Heiner Litz, and Christos Kozyrakis. 2018. Making Pull-Based Graph Processing Performant. SIGPLAN Not., 53, 1 (2018), Feb., 246–260. issn:0362-1340 https://doi.org/10.1145/3200691.3178506
[29]
Yuri Gurevich, Dirk Leinders, and Jan Van Den Bussche. 2007. A Theory of Stream Queries. In Proceedings of the 11th International Conference on Database Programming Languages (DBPL’07). Springer-Verlag, Berlin, Heidelberg. 153–168. isbn:3540759867 https://doi.org/10.1007/978-3-540-75987-4_11
[30]
Philipp Haller and Heather Miller. 2019. A reduction semantics for direct-style asynchronous observables. J. Log. Algebraic Methods Program., 105 (2019), 75–111. https://doi.org/10.1016/j.jlamp.2019.03.002
[31]
Philipp Haller, Heather Miller, and Normen Müller. 2018. A programming model and foundation for lineage-based distributed computation. JFP, 28 (2018), https://doi.org/10.1017/S0956796818000035
[32]
Robert H. Halstead, Jr. 1985. MULTILISP: a language for concurrent symbolic computation. ACM Trans. Program. Lang. Syst., 7 (1985), 10, 501–538. issn:0164-0925 https://doi.org/10.1145/4472.4478
[33]
Matthew A. Hammer, Khoo Yit Phang, Michael Hicks, and Jeffrey S. Foster. 2014. Adapton: Composable, Demand-driven Incremental Computation. In PLDI ’14. https://doi.org/10.1145/2666356.2594324
[34]
Wentao Han, Youshan Miao, Kaiwei Li, Ming Wu, Fan Yang, Lidong Zhou, Vijayan Prabhakaran, Wenguang Chen, and Enhong Chen. 2014. Chronos: a graph engine for temporal graph analysis. In Proceedings of the Ninth European Conference on Computer Systems. 1–14. https://doi.org/10.1145/2592798.2592799
[35]
Daco C Harkes, Danny M Groenewegen, and Eelco Visser. 2016. IceDust: Incremental and Eventual Computation of Derived Values. In ECOOP ’16. https://doi.org/10.4230/LIPIcs.ECOOP.2016.11
[36]
Daco C Harkes and Eelco Visser. 2017. IceDust 2: Derived Bidirectional Relations and Calculation Strategy Composition. In 31st European Conference on Object-Oriented Programming. https://doi.org/10.4230/LIPIcs.ECOOP.2017.14
[37]
Robert Harper, John C. Mitchell, and Eugenio Moggi. 1989. Higher-Order Modules and the Phase Distinction. In Proceedings of the 17th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL ’90). 341–354. isbn:0897913434 https://doi.org/10.1145/96709.96744
[38]
Martin Hirzel, Robert Soulé, Scott Schneider, Buğra Gedik, and Robert Grimm. 2014. A Catalog of Stream Processing Optimizations. ACM Comput. Surv., 46, 4 (2014), Article 46, mar, 34 pages. issn:0360-0300 https://doi.org/10.1145/2528412
[39]
Gérard Huet. 1980. Confluent Reductions: Abstract Properties and Applications to Term Rewriting Systems: Abstract Properties and Applications to Term Rewriting Systems. J. ACM, 27, 4 (1980), Oct., 797–821. issn:0004-5411
[40]
Xiaoen Ju, Dan Williams, Hani Jamjoom, and Kang G. Shin. 2016. Version Traveler: Fast and Memory-Efficient Version Switching in Graph Processing Systems. In 2016 USENIX Annual Technical Conference (USENIX ATC 16). USENIX Association, Denver, CO. 523–536. isbn:978-1-931971-30-0
[41]
Pradeep Kumar and H. Howie Huang. 2020. GraphOne: A Data Store for Real-Time Analytics on Evolving Graphs. ACM Trans. Storage, 15, 4 (2020), Article 29, Jan., 40 pages. issn:1553-3077 https://doi.org/10.1145/3364180
[42]
W. Le, A. Kementsietsidis, S. Duan, and F. Li. 2012. Scalable Multi-query Optimization for SPARQL. In 2012 IEEE 28th International Conference on Data Engineering. 666–677. https://doi.org/10.1109/ICDE.2012.37
[43]
E. A. Lee and D. G. Messerschmitt. 1987. Synchronous data flow. Proc. IEEE, 75, 9 (1987), 1235–1245. https://doi.org/10.1109/PROC.1987.13876
[44]
Yu David Liu, Christian Skalka, and Scott F. Smith. 2009. Type-specialized staged programming with process separation. Higher-Order and Symbolic Computation, 24 (2009), 341–385. https://doi.org/10.1145/1596614.1596622
[45]
Yucheng Low, Danny Bickson, Joseph Gonzalez, Carlos Guestrin, Aapo Kyrola, and Joseph M Hellerstein. 2012. Distributed GraphLab: a framework for machine learning and data mining in the cloud. Proceedings of the VLDB Endowment, 5, 8 (2012), 716–727. https://doi.org/10.14778/2212351.2212354
[46]
Grzegorz Malewicz, Matthew H. Austern, Aart J.C Bik, James C. Dehnert, Ilan Horn, Naty Leiser, and Grzegorz Czajkowski. 2010. Pregel: A System for Large-scale Graph Processing. In SIGMOD ’10. 135–146. isbn:978-1-4503-0032-2 https://doi.org/10.1145/1807167.1807184
[47]
Mugilan Mariappan, Joanna Che, and Keval Vora. 2021. DZiG: Sparsity-Aware Incremental Processing of Streaming Graphs. In Proceedings of the Sixteenth European Conference on Computer Systems (EuroSys ’21). Association for Computing Machinery, New York, NY, USA. 83–98. isbn:9781450383349 https://doi.org/10.1145/3447786.3456230
[48]
Mugilan Mariappan and Keval Vora. 2019. GraphBolt: Dependency-Driven Synchronous Processing of Streaming Graphs. In Proceedings of the Fourteenth EuroSys Conference 2019 (EuroSys ’19). Association for Computing Machinery, New York, NY, USA. Article 25, 16 pages. isbn:9781450362818 https://doi.org/10.1145/3302424.3303974
[49]
Leo A. Meyerovich, Arjun Guha, Jacob Baskin, Gregory H. Cooper, Michael Greenberg, Aleks Bromfield, and Shriram Krishnamurthi. 2009. Flapjax: A Programming Language for Ajax Applications. In Proceedings of the 24th ACM SIGPLAN Conference on Object Oriented Programming Systems Languages and Applications (OOPSLA ’09). ACM, New York, NY, USA. 1–20. isbn:978-1-60558-766-0 https://doi.org/10.1145/1640089.1640091
[50]
Ralf Mitschke, Sebastian Erdweg, Mirko Köhler, Mira Mezini, and Guido Salvaneschi. 2014. I3QL: Language-Integrated Live Data Views. In OOPSLA’14. 417–432. https://doi.org/10.1145/2660193.2660242
[51]
Derek G Murray, Frank McSherry, Rebecca Isaacs, Michael Isard, Paul Barham, and Martín Abadi. 2013. Naiad: a timely dataflow system. In Proceedings of the Twenty-Fourth ACM Symposium on Operating Systems Principles. 439–455. https://doi.org/10.1145/2517349.2522738
[52]
Derek G Murray, Malte Schwarzkopf, Christopher Smowton, Steven Smith, Anil Madhavapeddy, and Steven Hand. 2011. CIEL: a universal execution engine for distributed data-flow computing. In Proc. 8th ACM/USENIX Symposium on Networked Systems Design and Implementation. 113–126.
[53]
Kay Ousterhout, Ryan Rasti, Sylvia Ratnasamy, Scott Shenker, and Byung-Gon Chun. 2015. Making Sense of Performance in Data Analytics Frameworks. In 12th USENIX Symposium on Networked Systems Design and Implementation (NSDI 15). USENIX Association, Oakland, CA. 293–307. isbn:978-1-931971-218
[54]
Yannis Papakonstantinou, Hector Garcia-Molina, and Jennifer Widom. 1995. Object exchange across heterogeneous information sources. In Proceedings of the eleventh international conference on data engineering. 251–260. https://doi.org/10.1109/ICDE.1995.380386
[55]
J. Park and A. Segev. 1988. Using common subexpressions to optimize multiple queries. In Proceedings. Fourth International Conference on Data Engineering. 311–319. https://doi.org/10.1109/ICDE.1988.105474
[56]
W. Pugh and T. Teitelbaum. 1989. Incremental Computation via Function Caching. In POPL ’89. https://doi.org/10.1145/75277.75305
[57]
Karthik Ramachandra and S. Sudarshan. 2012. Holistic Optimization by Prefetching Query Results. In Proceedings of the 2012 ACM SIGMOD International Conference on Management of Data (SIGMOD ’12). 133–144. isbn:978-1-4503-1247-9
[58]
Xuguang Ren and Junhu Wang. 2016. Multi-Query Optimization for Subgraph Isomorphism Search. Proc. VLDB Endow., 10, 3 (2016), Nov., 121–132. issn:2150-8097 https://doi.org/10.14778/3021924.3021929
[59]
Amitabha Roy, Ivo Mihailovic, and Willy Zwaenepoel. 2013. X-stream: Edge-centric graph processing using streaming partitions. In SOSP ’13. 472–488. https://doi.org/10.1145/2517349.2522740
[60]
Ziv Scully and Adam Chlipala. 2017. A Program Optimization for Automatic Database Result Caching. In Proceedings of the 44th ACM SIGPLAN Symposium on Principles of Programming Languages (POPL 2017). 271–284. isbn:978-1-4503-4660-3 https://doi.org/10.1145/3009837.3009891
[61]
Timos K. Sellis. 1988. Multiple-Query Optimization. ACM Trans. Database Syst., 13, 1 (1988), March, 23–52. issn:0362-5915 https://doi.org/10.1145/42201.42203
[62]
Timos K. Sellis and Leonard Shapiro. 1985. Optimization of Extended Database Query Languages. In Proceedings of the 1985 ACM SIGMOD International Conference on Management of Data (SIGMOD ’85). Association for Computing Machinery, New York, NY, USA. 424–436. isbn:0897911601 https://doi.org/10.1145/971699.318993
[63]
Feng Sheng, Qiang Cao, Haoran Cai, Jie Yao, and Changsheng Xie. 2018. GraPU: Accelerate Streaming Graph Analysis through Preprocessing Buffered Updates. In Proceedings of the ACM Symposium on Cloud Computing (SoCC ’18). Association for Computing Machinery, New York, NY, USA. 301–312. isbn:9781450360111 https://doi.org/10.1145/3267809.3267811
[64]
Xiaogang Shi, Bin Cui, Yingxia Shao, and Yunhai Tong. 2016. Tornado: A system for real-time iterative analysis over evolving data. In SIGMOD ’16. 417–430. https://doi.org/10.1145/2882903.2882950
[65]
Julian Shun and Guy E. Blelloch. 2013. Ligra: A Lightweight Graph Processing Framework for Shared Memory. In Proceedings of the 18th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming (PPoPP ’13). Association for Computing Machinery, New York, NY, USA. 135–146. isbn:9781450319225 https://doi.org/10.1145/2442516.2442530
[66]
Robert Soulé, Martin Hirzel, Robert Grimm, Buğra Gedik, Henrique Andrade, Vibhore Kumar, and Kun-Lung Wu. 2010. A Universal Calculus for Stream Processing Languages. In Proceedings of the 19th European Conference on Programming Languages and Systems (ESOP’10). Springer-Verlag, Berlin, Heidelberg. 507–528. isbn:3642119565 https://doi.org/10.1007/978-3-642-11957-6_27
[67]
Marcelo Sousa, Isil Dillig, Dimitrios Vytiniotis, Thomas Dillig, and Christos Gkantsidis. 2014. Consolidation of Queries with User-defined Functions. In Proceedings of the 35th ACM SIGPLAN Conference on Programming Language Design and Implementation. 554–564. isbn:978-1-4503-2784-8 https://doi.org/10.1145/2666356.2594305
[68]
Jesper H. Spring, Jean Privat, Rachid Guerraoui, and Jan Vitek. 2007. Streamflex: High-Throughput Stream Programming in Java. In Proceedings of the 22nd Annual ACM SIGPLAN Conference on Object-Oriented Programming Systems and Applications (OOPSLA ’07). Association for Computing Machinery, New York, NY, USA. 211–228. isbn:9781595937865 https://doi.org/10.1145/1297027.1297043
[69]
Nicolas Stucki, Jonathan Immanuel Brachthäuser, and Martin Odersky. 2021. Multi-Stage Programming with Generative and Analytical Macros. In Proceedings of the 20th ACM SIGPLAN International Conference on Generative Programming: Concepts and Experiences (GPCE 2021). Association for Computing Machinery, New York, NY, USA. 110–122. isbn:9781450391122 https://doi.org/10.1145/3486609.3487203
[70]
Toyotaro Suzumura, Shunsuke Nishii, and Masaru Ganse. 2014. Towards Large-Scale Graph Stream Processing Platform. In Proceedings of the 23rd International Conference on World Wide Web (WWW ’14 Companion). Association for Computing Machinery, New York, NY, USA. 1321–1326. isbn:9781450327459 https://doi.org/10.1145/2567948.2580051
[71]
Walid Taha and Tim Sheard. 1997. Multi-Stage Programming with Explicit Annotations. In Proceedings of the 1997 ACM SIGPLAN Symposium on Partial Evaluation and Semantics-Based Program Manipulation (PEPM ’97). 203–217. https://doi.org/10.1145/258993.259019
[72]
Kanat Tangwongsan, Martin Hirzel, Scott Schneider, and Kun-Lung Wu. 2015. General Incremental Sliding-Window Aggregation. Proc. VLDB Endow., 8, 7 (2015), feb, 702–713. issn:2150-8097 https://doi.org/10.14778/2752939.2752940
[73]
William Thies, Michal Karczmarek, and Saman Amarasinghe. 2002. StreamIt: A Language for Streaming Applications. In Compiler Construction, R. Nigel Horspool (Ed.). 2304, Springer Berlin Heidelberg, Berlin, Heidelberg. 179–196. isbn:978-3-540-45937-8
[74]
Mandana Vaziri, Olivier Tardieu, Rodric Rabbah, Philippe Suter, and Martin Hirzel. 2014. Stream Processing with a Spreadsheet. In ECOOP 2014 – Object-Oriented Programming, Richard Jones (Ed.). Springer Berlin Heidelberg, Berlin, Heidelberg. 360–384. isbn:978-3-662-44202-9 https://doi.org/10.1007/978-3-662-44202-9_15
[75]
Venkateshwaran Venkataramani, Zach Amsden, Nathan Bronson, George Cabrera III, Prasad Chakka, Peter Dimov, Hui Ding, Jack Ferris, Anthony Giardullo, Jeremy Hoon, Sachin Kulkarni, Nathan Lawrence, Mark Marchukov, Dmitri Petrov, and Lovro Puzar. 2012. TAO: How Facebook Serves the Social Graph. In Proceedings of the 2012 ACM SIGMOD International Conference on Management of Data (SIGMOD ’12). ACM, New York, NY, USA. 791–792. isbn:978-1-4503-1247-9 https://doi.org/10.1145/2213836.2213957
[76]
Keval Vora, Rajiv Gupta, and Guoqing Xu. 2017. KickStarter: Fast and Accurate Computations on Streaming Graphs via Trimmed Approximations. In ASPLOS ’17. 237–251. isbn:978-1-4503-4465-4 https://doi.org/10.1145/3037697.3037748
[77]
Guozhang Wang, Wenlei Xie, Alan J Demers, and Johannes Gehrke. 2013. Asynchronous Large-Scale Graph Processing Made Easy. In CIDR. 13, 3–6.
[78]
Kai Wang, Guoqing Xu, Zhendong Su, and Yu David Liu. 2015. GraphQ: Graph Query Processing with Abstraction Refinement— Scalable and Programmable Analytics over Very Large Graphs on a Single PC. In 2015 USENIX Annual Technical Conference (USENIX ATC 15). USENIX Association, Santa Clara, CA. 387–401. isbn:978-1-931971-225
[79]
Yangzihao Wang, Andrew Davidson, Yuechao Pan, Yuduo Wu, Andy Riffel, and John D. Owens. 2016. Gunrock: A High-Performance Graph Processing Library on the GPU. In Proceedings of the 21st ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming (PPoPP ’16). Article 11, 12 pages. https://doi.org/10.1145/2851141.2851145
[80]
Matei Zaharia, Tathagata Das, Haoyuan Li, Timothy Hunter, Scott Shenker, and Ion Stoica. 2013. Discretized Streams: Fault-Tolerant Streaming Computation at Scale. In Proceedings of the Twenty-Fourth ACM Symposium on Operating Systems Principles (SOSP ’13). Association for Computing Machinery, New York, NY, USA. 423–438. isbn:9781450323888 https://doi.org/10.1145/2517349.2522737
[81]
Matei Zaharia, Reynold S. Xin, Patrick Wendell, Tathagata Das, Michael Armbrust, Ankur Dave, Xiangrui Meng, Josh Rosen, Shivaram Venkataraman, Michael J. Franklin, Ali Ghodsi, Joseph Gonzalez, Scott Shenker, and Ion Stoica. 2016. Apache Spark: A Unified Engine for Big Data Processing. Commun. ACM, 59, 11 (2016), Oct., 56–65. issn:0001-0782 https://doi.org/10.1145/2934664
[82]
Kaiyuan Zhang, Rong Chen, and Haibo Chen. 2015. NUMA-Aware Graph-Structured Analytics. In Proceedings of the 20th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming (PPoPP 2015). 183–193.
Index Terms
- The essence of online data processing
Recommendations
Nominal Recursors as Epi-Recursors
We study nominal recursors from the literature on syntax with bindings and compare them with respect to expressiveness. The term "nominal" refers to the fact that these recursors operate on a syntax representation where the names of bound variables ...
An essence of SSReflect
CICM'12: Proceedings of the 11th international conference on Intelligent Computer MathematicsSSReflect is a powerful language for proving theorems in the Coq system. It has been used for some of the largest proofs in formal mathematics thus far. However, although it constructs proofs in a formal system, like most other proof languages the ...
Formal verification of higher-order probabilistic programs: reasoning about approximation, convergence, Bayesian inference, and optimization
Probabilistic programming provides a convenient lingua franca for writing succinct and rigorous descriptions of probabilistic models and inference tasks. Several probabilistic programming languages, including Anglican, Church or Hakaru, derive their ...
Comments
Information & Contributors
Information
Published In
October 2022
1932 pages
Copyright © 2022 Owner/Author.
This work is licensed under a Creative Commons Attribution 4.0 International License.
Publisher
Association for Computing Machinery
New York, NY, United States
Publication History
Published: 31 October 2022
Published in PACMPL Volume 6, Issue OOPSLA2
Check for updates
Badges
Author Tags
Qualifiers
- Research-article
Funding Sources
- NSF
Contributors
Other Metrics
Bibliometrics & Citations
Bibliometrics
Article Metrics
- View Citations1Total Citations
- 324Total Downloads
- Downloads (Last 12 months)184
- Downloads (Last 6 weeks)16
Reflects downloads up to 30 Aug 2024
Other Metrics
Citations
Cited By
View all- Cutler JWatson CNkurumeh EHilliard PGoldstein HStanford CPierce B(2024)Stream TypesProceedings of the ACM on Programming Languages10.1145/36564348:PLDI(1412-1436)Online publication date: 20-Jun-2024
View Options
Get Access
Login options
Check if you have access through your login credentials or your institution to get full access on this article.
Sign in