Proceedings of the 15th ACM SIGPLAN International Symposium on Dynamic Languages最新文献

Python programmers have GPUs too: automatic Python loop parallelization with staged dependence analysis Python程序员也有gpu:带有阶段依赖分析的自动Python循环并行化

Proceedings of the 15th ACM SIGPLAN International Symposium on Dynamic Languages Pub Date : 2019-10-20 DOI: 10.1145/3359619.3359743

D. Jacob, P. Trinder, Jeremy Singer

{"title":"Python programmers have GPUs too: automatic Python loop parallelization with staged dependence analysis","authors":"D. Jacob, P. Trinder, Jeremy Singer","doi":"10.1145/3359619.3359743","DOIUrl":"https://doi.org/10.1145/3359619.3359743","url":null,"abstract":"Python is a popular language for end-user software development in many application domains. End-users want to harness parallel compute resources effectively, by exploiting commodity manycore technology including GPUs. However, existing approaches to parallelism in Python are esoteric, and generally seem too complex for the typical end-user developer. We argue that implicit, or automatic, parallelization is the best way to deliver the benefits of manycore to end-users, since it avoids domain-specific languages, specialist libraries, complex annotations or restrictive language subsets. Auto-parallelization fits the Python philosophy, provides effective performance, and is convenient for non-expert developers. Despite being a dynamic language, we show that Python is a suitable target for auto-parallelization. In an empirical study of 3000+ open-source Python notebooks, we demonstrate that typical loop behaviour ‘in the wild’ is amenable to auto-parallelization. We show that staging the dependence analysis is an effective way to maximize performance. We apply classical dependence analysis techniques, then leverage the Python runtime’s rich introspection capabilities to resolve additional loop bounds and variable types in a just-in-time manner. The parallel loop nest code is then converted to CUDA kernels for GPU execution. We achieve orders of magnitude speedup over baseline interpreted execution and some speedup (up to 50x, although not consistently) over CPU JIT-compiled execution, across 12 loop-intensive standard benchmarks.","PeriodicalId":191261,"journal":{"name":"Proceedings of the 15th ACM SIGPLAN International Symposium on Dynamic Languages","volume":"151 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2019-10-20","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"121042375","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}

引用次数: 5

First-class dynamic types 一级动态类型

Proceedings of the 15th ACM SIGPLAN International Symposium on Dynamic Languages Pub Date : 2019-10-20 DOI: 10.1145/3359619.3359740

Michael Homer, T. Jones, J. Noble

引用次数: 3

Reflections on the compatibility, performance, and scalability of parallel Python 关于并行Python的兼容性、性能和可伸缩性的思考

Proceedings of the 15th ACM SIGPLAN International Symposium on Dynamic Languages Pub Date : 2019-10-20 DOI: 10.1145/3359619.3359747

Remigius Meier, T. Gross

{"title":"Reflections on the compatibility, performance, and scalability of parallel Python","authors":"Remigius Meier, T. Gross","doi":"10.1145/3359619.3359747","DOIUrl":"https://doi.org/10.1145/3359619.3359747","url":null,"abstract":"Today's hardware is increasingly parallel, and to increase performance, applications must be able to use this parallelism. Hence, programming languages must provide the means for parallel execution. The language Python offers a multithreading, shared-memory model for concurrency. However, simultaneous execution of threads, i.e., parallel execution, is not a standard feature of current virtual machines (VM) for Python. Instead, the predominant Python VMs depend on a global interpreter lock, which serializes the execution. In a parallel VM, replicating Python's concurrency semantics is challenging. Today, there are three parallel VMs, which use one of two approaches to address the challenges: Jython, IronPython, and PyPy-STM. These VMs use two fundamentally different approaches to synchronize parallel execution under Python's concurrency semantics: Jython and IronPython use fine-grained locking, and PyPy-STM uses software transactional memory (STM). The two approaches result in different performance characteristics and levels of Python compatibility for these VMs. In this paper, we report on our experience with the three parallel VMs by comparing their compatibility, performance, and scalability. The comparison shows that fine-grained locking can yield better scalability than the STM approach. However, regarding the faithful reproduction of Python's concurrency semantics and the absolute performance, the STM approach currently has the advantage.","PeriodicalId":191261,"journal":{"name":"Proceedings of the 15th ACM SIGPLAN International Symposium on Dynamic Languages","volume":"31 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2019-10-20","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"126275989","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}

引用次数: 7

Standard object out: streaming objects with polymorphic write streams 标准对象输出:具有多态写流的流对象

Proceedings of the 15th ACM SIGPLAN International Symposium on Dynamic Languages Pub Date : 2019-10-20 DOI: 10.1145/3359619.3359748

Marcel Weiher, R. Hirschfeld

{"title":"Standard object out: streaming objects with polymorphic write streams","authors":"Marcel Weiher, R. Hirschfeld","doi":"10.1145/3359619.3359748","DOIUrl":"https://doi.org/10.1145/3359619.3359748","url":null,"abstract":"We propose standard object out, an object-oriented analog to the output part of the Unix standard input output library. Polymorphic Write Streams (PWS) act as architectural adapters between the object-oriented architectural style and the pipes and filters architectural style in the same way that stdio acts as an architectural adapter between the call/return architectural style and the pipes and filters architectural style. Current object-oriented interfaces to the Unix I/O system mimic their procedural counterparts so closely that they manage to be neither polymorphic nor streaming, at least not for objects. Specifically the object is first converted to a fixed byte-representation by sending it a specific message and the result is then output on the underlying byte stream. With this approach, these APIs do not allow for streaming behaviour: the entire result has to be constructed in-memory before it can be output. In addition, output of nested structures can require large multiples of time and space compared to the final output size, and fails completely if there are cycles in the object graph. It also does not allow for polymorphic behaviour. To solve these problems, we propose Polymorphic Write-Streams (PWS). PWSs represent a hierarchy of classes that decouple encoding from specific streaming destinations. Using triple dispatch they provide streaming behaviour and allow each stream to react specifically to each kind of object and vice versa: sharing of common functionality is enabled by chaining messages along the streams’ inheritance chain.","PeriodicalId":191261,"journal":{"name":"Proceedings of the 15th ACM SIGPLAN International Symposium on Dynamic Languages","volume":"132 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2019-10-20","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"122292350","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}

引用次数: 1

Lazy pointer update for low heap compaction pause times 针对低堆压缩暂停时间的延迟指针更新

Proceedings of the 15th ACM SIGPLAN International Symposium on Dynamic Languages Pub Date : 2019-10-20 DOI: 10.1145/3359619.3359741

Clément Béra, E. Miranda, E. G. Boix

{"title":"Lazy pointer update for low heap compaction pause times","authors":"Clément Béra, E. Miranda, E. G. Boix","doi":"10.1145/3359619.3359741","DOIUrl":"https://doi.org/10.1145/3359619.3359741","url":null,"abstract":"To keep applications highly responsive, garbage collectors (GCs) try to minimize interruptions of the application threads. While pauses due to non moving GCs can be drastically reduced through concurrent or incremental strategies, compaction pauses remain a big problem. A strategy to decrease stop the world compaction pauses is to compact subsets of the heap at any one time. But this only reduces the time spent in moving compacted objects, not the time spent updating all references to those objects, which may be significant in large heaps. In this paper, we propose to only move compacted objects during the compaction pause, replacing moved objects by low-overhead forwarding objects. References to compacted objects are lazily updated while the application is running and during the next GC marking phase, outside of the compaction pause. We evaluate our technique on a suite of high workload (2 to 14Gb) benchmarks built from a real industrial application. Results show that not updating pointers during the compaction pause decreases the median pause up to 31% and the longest pause up to 71% on these benchmarks, while the forwarding objects slow down execution time without GC by no more than 1%.","PeriodicalId":191261,"journal":{"name":"Proceedings of the 15th ACM SIGPLAN International Symposium on Dynamic Languages","volume":"2013 4","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2019-10-20","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"132030180","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}

引用次数: 1

Language-independent development environment support for dynamic runtimes 对动态运行时的独立于语言的开发环境支持

Proceedings of the 15th ACM SIGPLAN International Symposium on Dynamic Languages Pub Date : 2019-10-20 DOI: 10.1145/3359619.3359746

Daniel Stolpe, T. Felgentreff, Christian Humer, Fabio Niephaus, R. Hirschfeld

{"title":"Language-independent development environment support for dynamic runtimes","authors":"Daniel Stolpe, T. Felgentreff, Christian Humer, Fabio Niephaus, R. Hirschfeld","doi":"10.1145/3359619.3359746","DOIUrl":"https://doi.org/10.1145/3359619.3359746","url":null,"abstract":"There are many factors for the success of a new programming language implementation. Existing language implementation frameworks such as Truffle or RPython have focused on run-time performance and security, or on providing a comprehensive set of libraries. The tools that language users need to be productive are also an important factor for the adoption of a programming language. The aforementioned frameworks, however, provide limited support for creating comprehensive development tools. This is an impediment to language adoption that can be as serious as performance issues or lack of libraries. Both Truffle and RPython already provide run-time tools such as for debugging, profiling, or coverage in a language-independent manner, but neither support static development tasks carried out in code editors. In this work, we propose a language-agnostic approach to add this missing tooling by making the LSP available automatically to all language implementations on the Truffle framework. Furthermore, we show how our approach can utilize runtime information to provide IDE features rarely available for dynamic programming languages.","PeriodicalId":191261,"journal":{"name":"Proceedings of the 15th ACM SIGPLAN International Symposium on Dynamic Languages","volume":"16 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2019-10-20","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"128294001","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}

引用次数: 7

Proceedings of the 15th ACM SIGPLAN International Symposium on Dynamic Languages 第15届ACM SIGPLAN动态语言国际研讨会论文集

Proceedings of the 15th ACM SIGPLAN International Symposium on Dynamic Languages Pub Date : 2019-10-20 DOI: 10.1145/3359619

引用次数: 0

Sindarin: a versatile scripting API for the Pharo debugger 用于Pharo调试器的通用脚本API

Proceedings of the 15th ACM SIGPLAN International Symposium on Dynamic Languages Pub Date : 2019-09-09 DOI: 10.1145/3359619.3359745

Thomas Dupriez, G. Polito, Steven Costiou, Vincent Aranega, Stéphane Ducasse

引用次数: 5

R melts brains: an IR for first-class environments and lazy effectful arguments R可以融化大脑:用于一流环境的IR和懒惰的有效论证

Proceedings of the 15th ACM SIGPLAN International Symposium on Dynamic Languages Pub Date : 2019-07-11 DOI: 10.1145/3359619.3359744

O. Flückiger, Guido Chari, Jan Jecmen, Ming-Ho Yee, Jakob Hain, J. Vitek

引用次数: 14

Optimizing and evaluating transient gradual typing 瞬态渐进分型的优化与评价

Proceedings of the 15th ACM SIGPLAN International Symposium on Dynamic Languages Pub Date : 2019-02-20 DOI: 10.1145/3359619.3359742

Michael M. Vitousek, Jeremy G. Siek, A. Chaudhuri

{"title":"Optimizing and evaluating transient gradual typing","authors":"Michael M. Vitousek, Jeremy G. Siek, A. Chaudhuri","doi":"10.1145/3359619.3359742","DOIUrl":"https://doi.org/10.1145/3359619.3359742","url":null,"abstract":"Gradual typing enables programmers to combine static and dynamic typing in the same language. However, ensuring sound interaction between the static and dynamic parts can incur runtime cost. In this paper, we analyze the performance of the transient design for gradual typing in Reticulated Python, a gradually typed variant of Python. This approach inserts lightweight checks throughout a program rather than installing proxies on higher order values. We show that, when using CPython as a host, performance decreases as programs evolve from dynamic to static types, up to a 6x slowdown compared to equivalent Python programs. To reduce this overhead, we design a static analysis and optimization that removes redundant runtime checks, employing a type inference algorithm that solves traditional subtyping constraints and also a new kind of check constraint. We evaluate the resulting performance and find that for many programs, the efficiency of partially typed programs is close to their untyped counterparts, removing most of the cost of transient checks. Finally, we measure the efficiency of Reticulated Python programs when running on PyPy, a tracing JIT. We find that combining PyPy with our type inference algorithm results in an average overhead of less than 1%.","PeriodicalId":191261,"journal":{"name":"Proceedings of the 15th ACM SIGPLAN International Symposium on Dynamic Languages","volume":"1 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2019-02-20","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"130837039","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}

引用次数: 16