The Experts below are selected from a list of 618 Experts worldwide ranked by ideXlab platform
Shriram Krishnamurthi - One of the best experts on this subject based on the ideXlab platform.
-
inferring type rules for Syntactic Sugar
Programming Language Design and Implementation, 2018Co-Authors: Justin Pombrio, Shriram KrishnamurthiAbstract:Type systems and Syntactic Sugar are both valuable to programmers, but sometimes at odds. While Sugar is a valuable mechanism for implementing realistic languages, the expansion process obscures program source structure. As a result, type errors can reference terms the programmers did not write (and even constructs they do not know), baffling them. The language developer must also manually construct type rules for the Sugars, to give a typed account of the surface language. We address these problems by presenting a process for automatically reconstructing type rules for the surface language using rules for the core. We have implemented this theory, and show several interesting case studies.
-
PLDI - Inferring type rules for Syntactic Sugar
Proceedings of the 39th ACM SIGPLAN Conference on Programming Language Design and Implementation - PLDI 2018, 2018Co-Authors: Justin Pombrio, Shriram KrishnamurthiAbstract:Type systems and Syntactic Sugar are both valuable to programmers, but sometimes at odds. While Sugar is a valuable mechanism for implementing realistic languages, the expansion process obscures program source structure. As a result, type errors can reference terms the programmers did not write (and even constructs they do not know), baffling them. The language developer must also manually construct type rules for the Sugars, to give a typed account of the surface language. We address these problems by presenting a process for automatically reconstructing type rules for the surface language using rules for the core. We have implemented this theory, and show several interesting case studies.
-
Inferring scope through Syntactic Sugar
Proceedings of the ACM on Programming Languages, 2017Co-Authors: Justin Pombrio, Shriram Krishnamurthi, Mitchell WandAbstract:Many languages use Syntactic Sugar to define parts of their surface language in terms of a smaller core. Thus some properties of the surface language, like its scoping rules, are not immediately evident. Nevertheless, IDEs, refactorers, and other tools that traffic in source code depend on these rules to present information to users and to soundly perform their operations. In this paper, we show how to lift scoping rules defined on a core language to rules on the surface, a process of scope inference. In the process we introduce a new representation of binding structure---scope as a preorder---and present a theoretical advance: proving that a deSugaring system preserves I�-equivalence even though scoping rules have been provided only for the core language. We have also implemented the system presented in this paper.
-
ICFP - Hygienic reSugaring of compositional deSugaring
Proceedings of the 20th ACM SIGPLAN International Conference on Functional Programming - ICFP 2015, 2015Co-Authors: Justin Pombrio, Shriram KrishnamurthiAbstract:Syntactic Sugar is widely used in language implementation. Its benefits are, however, offset by the comprehension problems it presents to programmers once their program has been transformed. In particular, after a transformed program has begun to evaluate (or otherwise be altered by a black-box process), it can become unrecognizable. We present a new approach to _reSugaring_ programs, which is the act of reflecting evaluation steps in the core language in terms of the Syntactic Sugar that the programmer used. Relative to prior work, our approach has two important advances: it handles hygiene, and it allows almost arbitrary rewriting rules (as opposed to restricted patterns). We do this in the context of a DAG representation of programs, rather than more traditional trees.
-
reSugaring lifting evaluation sequences through Syntactic Sugar
Programming Language Design and Implementation, 2014Co-Authors: Justin Pombrio, Shriram KrishnamurthiAbstract:Syntactic Sugar is pervasive in language technology. It is used to shrink the size of a core language; to define domain-specific languages; and even to let programmers extend their language. Unfortunately, Syntactic Sugar is eliminated by transformation, so the resulting programs become unfamiliar to authors. Thus, it comes at a price: it obscures the relationship between the user's source program and the program being evaluated. We address this problem by showing how to compute reduction steps in terms of the surface syntax. Each step in the surface language emulates one or more steps in the core language. The computed steps hide the transformation, thus maintaining the abstraction provided by the surface language. We make these statements about emulation and abstraction precise, prove that they hold in our formalism, and verify part of the system in Coq. We have implemented this work and applied it to three very different languages.
Charles E. Leiserson - One of the best experts on this subject based on the ideXlab platform.
-
tapir embedding fork join parallelism into llvm s intermediate representation
ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, 2017Co-Authors: Tao B Schardl, William S. Moses, Charles E. LeisersonAbstract:This paper explores how fork-join parallelism, as supported by concurrency platforms such as Cilk and OpenMP, can be embedded into a compiler's intermediate representation (IR). Mainstream compilers typically treat parallel linguistic constructs as Syntactic Sugar for function calls into a parallel runtime. These calls prevent the compiler from performing optimizations across parallel control constructs. Remedying this situation is generally thought to require an extensive reworking of compiler analyses and code transformations to handle parallel semantics. Tapir is a compiler IR that represents logically parallel tasks asymmetrically in the program's control flow graph. Tapir allows the compiler to optimize across parallel control constructs with only minor changes to its existing analyses and code transformations. To prototype Tapir in the LLVM compiler, for example, we added or modified about 6000 lines of LLVM's 4-million-line codebase. Tapir enables LLVM's existing compiler optimizations for serial code -- including loop-invariant-code motion, common-subexpression elimination, and tail-recursion elimination -- to work with parallel control constructs such as spawning and parallel loops. Tapir also supports parallel optimizations such as loop scheduling.
-
PPOPP - Tapir: Embedding Fork-Join Parallelism into LLVM's Intermediate Representation
Proceedings of the 22nd ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, 2017Co-Authors: Tao B Schardl, William S. Moses, Charles E. LeisersonAbstract:This paper explores how fork-join parallelism, as supported by concurrency platforms such as Cilk and OpenMP, can be embedded into a compiler's intermediate representation (IR). Mainstream compilers typically treat parallel linguistic constructs as Syntactic Sugar for function calls into a parallel runtime. These calls prevent the compiler from performing optimizations across parallel control constructs. Remedying this situation is generally thought to require an extensive reworking of compiler analyses and code transformations to handle parallel semantics. Tapir is a compiler IR that represents logically parallel tasks asymmetrically in the program's control flow graph. Tapir allows the compiler to optimize across parallel control constructs with only minor changes to its existing analyses and code transformations. To prototype Tapir in the LLVM compiler, for example, we added or modified about 6000 lines of LLVM's 4-million-line codebase. Tapir enables LLVM's existing compiler optimizations for serial code -- including loop-invariant-code motion, common-subexpression elimination, and tail-recursion elimination -- to work with parallel control constructs such as spawning and parallel loops. Tapir also supports parallel optimizations such as loop scheduling.
Justin Pombrio - One of the best experts on this subject based on the ideXlab platform.
-
inferring type rules for Syntactic Sugar
Programming Language Design and Implementation, 2018Co-Authors: Justin Pombrio, Shriram KrishnamurthiAbstract:Type systems and Syntactic Sugar are both valuable to programmers, but sometimes at odds. While Sugar is a valuable mechanism for implementing realistic languages, the expansion process obscures program source structure. As a result, type errors can reference terms the programmers did not write (and even constructs they do not know), baffling them. The language developer must also manually construct type rules for the Sugars, to give a typed account of the surface language. We address these problems by presenting a process for automatically reconstructing type rules for the surface language using rules for the core. We have implemented this theory, and show several interesting case studies.
-
PLDI - Inferring type rules for Syntactic Sugar
Proceedings of the 39th ACM SIGPLAN Conference on Programming Language Design and Implementation - PLDI 2018, 2018Co-Authors: Justin Pombrio, Shriram KrishnamurthiAbstract:Type systems and Syntactic Sugar are both valuable to programmers, but sometimes at odds. While Sugar is a valuable mechanism for implementing realistic languages, the expansion process obscures program source structure. As a result, type errors can reference terms the programmers did not write (and even constructs they do not know), baffling them. The language developer must also manually construct type rules for the Sugars, to give a typed account of the surface language. We address these problems by presenting a process for automatically reconstructing type rules for the surface language using rules for the core. We have implemented this theory, and show several interesting case studies.
-
Inferring scope through Syntactic Sugar
Proceedings of the ACM on Programming Languages, 2017Co-Authors: Justin Pombrio, Shriram Krishnamurthi, Mitchell WandAbstract:Many languages use Syntactic Sugar to define parts of their surface language in terms of a smaller core. Thus some properties of the surface language, like its scoping rules, are not immediately evident. Nevertheless, IDEs, refactorers, and other tools that traffic in source code depend on these rules to present information to users and to soundly perform their operations. In this paper, we show how to lift scoping rules defined on a core language to rules on the surface, a process of scope inference. In the process we introduce a new representation of binding structure---scope as a preorder---and present a theoretical advance: proving that a deSugaring system preserves I�-equivalence even though scoping rules have been provided only for the core language. We have also implemented the system presented in this paper.
-
ICFP - Hygienic reSugaring of compositional deSugaring
Proceedings of the 20th ACM SIGPLAN International Conference on Functional Programming - ICFP 2015, 2015Co-Authors: Justin Pombrio, Shriram KrishnamurthiAbstract:Syntactic Sugar is widely used in language implementation. Its benefits are, however, offset by the comprehension problems it presents to programmers once their program has been transformed. In particular, after a transformed program has begun to evaluate (or otherwise be altered by a black-box process), it can become unrecognizable. We present a new approach to _reSugaring_ programs, which is the act of reflecting evaluation steps in the core language in terms of the Syntactic Sugar that the programmer used. Relative to prior work, our approach has two important advances: it handles hygiene, and it allows almost arbitrary rewriting rules (as opposed to restricted patterns). We do this in the context of a DAG representation of programs, rather than more traditional trees.
-
reSugaring lifting evaluation sequences through Syntactic Sugar
Programming Language Design and Implementation, 2014Co-Authors: Justin Pombrio, Shriram KrishnamurthiAbstract:Syntactic Sugar is pervasive in language technology. It is used to shrink the size of a core language; to define domain-specific languages; and even to let programmers extend their language. Unfortunately, Syntactic Sugar is eliminated by transformation, so the resulting programs become unfamiliar to authors. Thus, it comes at a price: it obscures the relationship between the user's source program and the program being evaluated. We address this problem by showing how to compute reduction steps in terms of the surface syntax. Each step in the surface language emulates one or more steps in the core language. The computed steps hide the transformation, thus maintaining the abstraction provided by the surface language. We make these statements about emulation and abstraction precise, prove that they hold in our formalism, and verify part of the system in Coq. We have implemented this work and applied it to three very different languages.
Tao B Schardl - One of the best experts on this subject based on the ideXlab platform.
-
tapir embedding fork join parallelism into llvm s intermediate representation
ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, 2017Co-Authors: Tao B Schardl, William S. Moses, Charles E. LeisersonAbstract:This paper explores how fork-join parallelism, as supported by concurrency platforms such as Cilk and OpenMP, can be embedded into a compiler's intermediate representation (IR). Mainstream compilers typically treat parallel linguistic constructs as Syntactic Sugar for function calls into a parallel runtime. These calls prevent the compiler from performing optimizations across parallel control constructs. Remedying this situation is generally thought to require an extensive reworking of compiler analyses and code transformations to handle parallel semantics. Tapir is a compiler IR that represents logically parallel tasks asymmetrically in the program's control flow graph. Tapir allows the compiler to optimize across parallel control constructs with only minor changes to its existing analyses and code transformations. To prototype Tapir in the LLVM compiler, for example, we added or modified about 6000 lines of LLVM's 4-million-line codebase. Tapir enables LLVM's existing compiler optimizations for serial code -- including loop-invariant-code motion, common-subexpression elimination, and tail-recursion elimination -- to work with parallel control constructs such as spawning and parallel loops. Tapir also supports parallel optimizations such as loop scheduling.
-
PPOPP - Tapir: Embedding Fork-Join Parallelism into LLVM's Intermediate Representation
Proceedings of the 22nd ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, 2017Co-Authors: Tao B Schardl, William S. Moses, Charles E. LeisersonAbstract:This paper explores how fork-join parallelism, as supported by concurrency platforms such as Cilk and OpenMP, can be embedded into a compiler's intermediate representation (IR). Mainstream compilers typically treat parallel linguistic constructs as Syntactic Sugar for function calls into a parallel runtime. These calls prevent the compiler from performing optimizations across parallel control constructs. Remedying this situation is generally thought to require an extensive reworking of compiler analyses and code transformations to handle parallel semantics. Tapir is a compiler IR that represents logically parallel tasks asymmetrically in the program's control flow graph. Tapir allows the compiler to optimize across parallel control constructs with only minor changes to its existing analyses and code transformations. To prototype Tapir in the LLVM compiler, for example, we added or modified about 6000 lines of LLVM's 4-million-line codebase. Tapir enables LLVM's existing compiler optimizations for serial code -- including loop-invariant-code motion, common-subexpression elimination, and tail-recursion elimination -- to work with parallel control constructs such as spawning and parallel loops. Tapir also supports parallel optimizations such as loop scheduling.
William S. Moses - One of the best experts on this subject based on the ideXlab platform.
-
tapir embedding fork join parallelism into llvm s intermediate representation
ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, 2017Co-Authors: Tao B Schardl, William S. Moses, Charles E. LeisersonAbstract:This paper explores how fork-join parallelism, as supported by concurrency platforms such as Cilk and OpenMP, can be embedded into a compiler's intermediate representation (IR). Mainstream compilers typically treat parallel linguistic constructs as Syntactic Sugar for function calls into a parallel runtime. These calls prevent the compiler from performing optimizations across parallel control constructs. Remedying this situation is generally thought to require an extensive reworking of compiler analyses and code transformations to handle parallel semantics. Tapir is a compiler IR that represents logically parallel tasks asymmetrically in the program's control flow graph. Tapir allows the compiler to optimize across parallel control constructs with only minor changes to its existing analyses and code transformations. To prototype Tapir in the LLVM compiler, for example, we added or modified about 6000 lines of LLVM's 4-million-line codebase. Tapir enables LLVM's existing compiler optimizations for serial code -- including loop-invariant-code motion, common-subexpression elimination, and tail-recursion elimination -- to work with parallel control constructs such as spawning and parallel loops. Tapir also supports parallel optimizations such as loop scheduling.
-
PPOPP - Tapir: Embedding Fork-Join Parallelism into LLVM's Intermediate Representation
Proceedings of the 22nd ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, 2017Co-Authors: Tao B Schardl, William S. Moses, Charles E. LeisersonAbstract:This paper explores how fork-join parallelism, as supported by concurrency platforms such as Cilk and OpenMP, can be embedded into a compiler's intermediate representation (IR). Mainstream compilers typically treat parallel linguistic constructs as Syntactic Sugar for function calls into a parallel runtime. These calls prevent the compiler from performing optimizations across parallel control constructs. Remedying this situation is generally thought to require an extensive reworking of compiler analyses and code transformations to handle parallel semantics. Tapir is a compiler IR that represents logically parallel tasks asymmetrically in the program's control flow graph. Tapir allows the compiler to optimize across parallel control constructs with only minor changes to its existing analyses and code transformations. To prototype Tapir in the LLVM compiler, for example, we added or modified about 6000 lines of LLVM's 4-million-line codebase. Tapir enables LLVM's existing compiler optimizations for serial code -- including loop-invariant-code motion, common-subexpression elimination, and tail-recursion elimination -- to work with parallel control constructs such as spawning and parallel loops. Tapir also supports parallel optimizations such as loop scheduling.