The Experts below are selected from a list of 35667 Experts worldwide ranked by ideXlab platform
Reiji Suda - One of the best experts on this subject based on the ideXlab platform.
-
Xevolver: A User-Defined Code Transformation Approach to Streamlining Legacy Code Migration
Advanced Software Technologies for Post-Peta Scale Computing, 2018Co-Authors: Hiroyuki Takizawa, Daisuke Takahashi, Reiji Suda, Ryusuke EgawaAbstract:Since different systems usually require different performance optimizations, an application Code is likely “specialized” for a particular system configuration to fully extract the system performance. This is one major reason why migration of an existing application Code, so-called legacy Code migration, is so labor-intensive and error-prone especially in the high-performance computing (HPC) area. To make matters worse, the diversity of system architectures would increase the number of system configurations that have to be considered during the life of an application. As a result, the increasing system complexity and diversity will force programmers to further invest enormous time and effort on HPC application development and maintenance. For long-term software development and maintenance, an HPC application Code should not be optimized for a particular system configuration. However, simply excluding system-awareness from the Code just results in reducing the performance, because system-awareness can be regarded as the necessary information to exploit the performance of the target system. The goal of this project is to express system-awareness separately from the HPC application Code to achieve high performance while keeping the Code maintainability. To this end, we have been developing a Code Transformation framework, Xevolver, so that users can express system-awareness as user-defined Code Transformation rules separately from HPC application Codes. By defining custom Code Transformations for individual cases, an HPC application Code itself does not need to be modified for each system configuration and is transformed for each system by using the Code Transformations defined separately from the Code.
-
Embedded-DSL-Like Code Generation and Optimization of Bayesian Estimation Routines with User-Defined Source-to-Source Code Transformation Framework Xevolver
2017 Fifth International Symposium on Computing and Networking (CANDAR), 2017Co-Authors: Reiji SudaAbstract:Xevolver is a source-to-source Code Transformation framework where users can define their own Code Transformation rules. The Transformations in Xevolver can break the semantics of the Code, that is, the resulting Code can do different computations than the original source Code does. This feature of Xevolver enables its usage as a Code generator like embedded DSL (Domain Specific Language). This paper demonstrates such a usage in a Code generator that inputs hierarchical Bayesian models in a form of Fortran Code, and outputs a Code that estimates Bayesian parameters from observed data. We found that Xevolver is also useful to optimize the generated Codes.
-
CANDAR - Embedded-DSL-Like Code Generation and Optimization of Bayesian Estimation Routines with User-Defined Source-to-Source Code Transformation Framework Xevolver
2017 Fifth International Symposium on Computing and Networking (CANDAR), 2017Co-Authors: Reiji SudaAbstract:Xevolver is a source-to-source Code Transformation framework where users can define their own Code Transformation rules. The Transformations in Xevolver can break the semantics of the Code, that is, the resulting Code can do different computations than the original source Code does. This feature of Xevolver enables its usage as a Code generator like embedded DSL (Domain Specific Language). This paper demonstrates such a usage in a Code generator that inputs hierarchical Bayesian models in a form of Fortran Code, and outputs a Code that estimates Bayesian parameters from observed data. We found that Xevolver is also useful to optimize the generated Codes.
-
a use case of a Code Transformation rule generator for data layout optimization
2016Co-Authors: Hiroyuki Takizawa, Shoichi Hirasawa, Takeshi Yamada, Reiji SudaAbstract:Xevolver is a Code Transformation framework for users to define their own Code Transformation rules. In the framework, an abstract syntax tree (AST) of an application Code is written in an XML format, and its Transformation rules are expressed in the XSLT format, which is a standard XML format to describe XML data conversion; an AST and its Transformation rules are both written in XML. Since it is too low-level for standard users to manually write XSLT rules, Xevtgen is now being developed as a tool to generate such rules from simple Code description. In Xevtgen, users basically write just two Code patterns, the original and transformed Code patterns. Then, Xevtgen automatically generates a Transformation rule that transforms the original Code pattern to the transformed one. The generated rule is written in XSLT, and hence usable by other tools of the Xevolver framework. This article shows a use case of using Xevtgen for data layout optimization, and discusses the benefits of using the tool.
-
CANDAR - Xevdriver: A Software System Supporting XML-based Source-to-Source Code Transformations on Fortran Programs
2016 Fourth International Symposium on Computing and Networking (CANDAR), 2016Co-Authors: Reiji Suda, Hiroyuki TakizawaAbstract:The Xevolver framework is a Code Transformation framework for supporting evolutional modifications of high performance computing Codes. This paper introduces a set of software modules that facilitates administrative tasks about multiple Code Transformations on multiple source Codes. We call this set of software modules the xevdriver, because it drives Transformations using Xevolver framework. First, xevdriver provides an abstract view of temporary files. Parsing and unparsing between Fortran and XML are done automatically, and the user do not have to keep track of temporary file names during a series of applications of Code Transformations. Second, xevdriver also provides an abstract view of combinations of Transformations. Xevdriver provides a script language, in which users can define combinations of Code Transformations as procedures. Third, the logging functions and a log-viewer are provided in accordance with the above abstractions. Users can check how the source Codes are transformed on the log-viewer from the high level abstractions of Code Transformation procedures, and can inspect the intermediate results down into an arbitrary level of concreteness of the implementations of Transformations. Our toolset will help development, management and applications of complex Code Transformations based on Xevolver framework.
Hiroyuki Takizawa - One of the best experts on this subject based on the ideXlab platform.
-
Xevolver: A User-Defined Code Transformation Approach to Streamlining Legacy Code Migration
Advanced Software Technologies for Post-Peta Scale Computing, 2018Co-Authors: Hiroyuki Takizawa, Daisuke Takahashi, Reiji Suda, Ryusuke EgawaAbstract:Since different systems usually require different performance optimizations, an application Code is likely “specialized” for a particular system configuration to fully extract the system performance. This is one major reason why migration of an existing application Code, so-called legacy Code migration, is so labor-intensive and error-prone especially in the high-performance computing (HPC) area. To make matters worse, the diversity of system architectures would increase the number of system configurations that have to be considered during the life of an application. As a result, the increasing system complexity and diversity will force programmers to further invest enormous time and effort on HPC application development and maintenance. For long-term software development and maintenance, an HPC application Code should not be optimized for a particular system configuration. However, simply excluding system-awareness from the Code just results in reducing the performance, because system-awareness can be regarded as the necessary information to exploit the performance of the target system. The goal of this project is to express system-awareness separately from the HPC application Code to achieve high performance while keeping the Code maintainability. To this end, we have been developing a Code Transformation framework, Xevolver, so that users can express system-awareness as user-defined Code Transformation rules separately from HPC application Codes. By defining custom Code Transformations for individual cases, an HPC application Code itself does not need to be modified for each system configuration and is transformed for each system by using the Code Transformations defined separately from the Code.
-
IPDPS Workshops - A Customizable Auto-Tuning Scenario with User-Defined Code Transformations
2017 IEEE International Parallel and Distributed Processing Symposium Workshops (IPDPSW), 2017Co-Authors: Hiroyuki Takizawa, Shoichi Hirasawa, Daichi Sato, Daisuke TakahashiAbstract:At present, most of real-world HPC applications are being developed without considering any auto-tuning techniques; those applications are not "gauto-tunable" for several reasons. One reason is that making a Code auto-tunable often results in messing up the Code and degrading the readability and/or maintainability. In our previous work, we have employed a Code Transformation framework, Xevolver, for making a Code auto-tunable without messing it up. However, there is no standardized way to express the collaboration between Code Transformation and auto-tuning. In this paper, therefore, we design a standard tuning scenario and some directives to customize the scenario for individual applications. Our case studies show that the scenario can be reusable among different applications and different auto-tuning techniques by only partially customizing it. As a result, in terms of the number of Code lines, the proposed approach requires much less programming effort for achieving auto-tuning.
-
a user defined Code Transformation approach to overlapping mpi communication with computation
International Symposium on Computing and Networking, 2016Co-Authors: Yasuharu Hayashi, Hiroyuki Takizawa, Hiroaki KobayashiAbstract:The Xevolver framework has been developed to enable application programmers to define their own Code translation rules outside of their Codes so that they can express platform-specific optimizations separately from algorithm-level application Codes. Due to the diversity of HPC node architectures, the Xevolver framework has so far mainly been used to separate node-level Code optimizations from application Codes. However, user-defined Code Transformation rules are also potentially useful for optimizing MPI applications without messing up their Codes. Therefore, this paper shows a case study of using the Xevolver framework to optimize MPI applications through customizable Code Transformations without loss of high performance portability, and discusses the benefits of the framework.
-
a use case of a Code Transformation rule generator for data layout optimization
2016Co-Authors: Hiroyuki Takizawa, Shoichi Hirasawa, Takeshi Yamada, Reiji SudaAbstract:Xevolver is a Code Transformation framework for users to define their own Code Transformation rules. In the framework, an abstract syntax tree (AST) of an application Code is written in an XML format, and its Transformation rules are expressed in the XSLT format, which is a standard XML format to describe XML data conversion; an AST and its Transformation rules are both written in XML. Since it is too low-level for standard users to manually write XSLT rules, Xevtgen is now being developed as a tool to generate such rules from simple Code description. In Xevtgen, users basically write just two Code patterns, the original and transformed Code patterns. Then, Xevtgen automatically generates a Transformation rule that transforms the original Code pattern to the transformed one. The generated rule is written in XSLT, and hence usable by other tools of the Xevolver framework. This article shows a use case of using Xevtgen for data layout optimization, and discusses the benefits of using the tool.
-
CANDAR - A User-Defined Code Transformation Approach to Overlapping MPI Communication with Computation
2016 Fourth International Symposium on Computing and Networking (CANDAR), 2016Co-Authors: Yasuharu Hayashi, Hiroyuki Takizawa, Hiroaki KobayashiAbstract:The Xevolver framework has been developed to enable application programmers to define their own Code translation rules outside of their Codes so that they can express platform-specific optimizations separately from algorithm-level application Codes. Due to the diversity of HPC node architectures, the Xevolver framework has so far mainly been used to separate node-level Code optimizations from application Codes. However, user-defined Code Transformation rules are also potentially useful for optimizing MPI applications without messing up their Codes. Therefore, this paper shows a case study of using the Xevolver framework to optimize MPI applications through customizable Code Transformations without loss of high performance portability, and discusses the benefits of the framework.
Alexander B. Wiltschko - One of the best experts on this subject based on the ideXlab platform.
-
Tangent: Automatic differentiation using source-Code Transformation for dynamically typed array programming
arXiv: Learning, 2018Co-Authors: Bart Van Merrienboer, Dan Moldovan, Alexander B. WiltschkoAbstract:The need to efficiently calculate first- and higher-order derivatives of increasingly complex models expressed in Python has stressed or exceeded the capabilities of available tools. In this work, we explore techniques from the field of automatic differentiation (AD) that can give researchers expressive power, performance and strong usability. These include source-Code Transformation (SCT), flexible gradient surgery, efficient in-place array operations, higher-order derivatives as well as mixing of forward and reverse mode AD. We implement and demonstrate these ideas in the Tangent software library for Python, the first AD framework for a dynamic language that uses SCT.
-
tangent automatic differentiation using source Code Transformation for dynamically typed array programming
Neural Information Processing Systems, 2018Co-Authors: Bart Van Merrienboer, Dan Moldovan, Alexander B. WiltschkoAbstract:The need to efficiently calculate first- and higher-order derivatives of increasingly complex models expressed in Python has stressed or exceeded the capabilities of available tools. In this work, we explore techniques from the field of automatic differentiation (AD) that can give researchers expressive power, performance and strong usability. These include source-Code Transformation (SCT), flexible gradient surgery, efficient in-place array operations, and higher-order derivatives. We implement and demonstrate these ideas in the Tangent software library for Python, the first AD framework for a dynamic language that uses SCT.
-
NeurIPS - Tangent: Automatic differentiation using source-Code Transformation for dynamically typed array programming
2018Co-Authors: Bart Van Merrienboer, Dan Moldovan, Alexander B. WiltschkoAbstract:The need to efficiently calculate first- and higher-order derivatives of increasingly complex models expressed in Python has stressed or exceeded the capabilities of available tools. In this work, we explore techniques from the field of automatic differentiation (AD) that can give researchers expressive power, performance and strong usability. These include source-Code Transformation (SCT), flexible gradient surgery, efficient in-place array operations, and higher-order derivatives. We implement and demonstrate these ideas in the Tangent software library for Python, the first AD framework for a dynamic language that uses SCT.
-
Tangent: Automatic Differentiation Using Source Code Transformation in Python
Workshop on ML Systems at NIPS 2017, 2017Co-Authors: Bart Van Merrienboer, Alexander B. Wiltschko, Dumitriţa MoldovanAbstract:Automatic differentiation (AD) is an essential primitive for machine learning pro-gramming systems. Tangent is a new library that performs AD using source Code Transformation (SCT) in Python. It takes numeric functions written in a syntactic subset of Python and NumPy as input, and generates new Python functions which calculate a derivative. This approach to automatic differentiation is different from existing packages popular in machine learning, such as TensorFlow[1] and Auto-grad 1 . Advantages are that Tangent generates gradient Code in Python which is readable by the user, easy to understand and debug, and has no runtime overhead. Tangent also introduces abstractions for easily injecting logic into the generated gradient Code, further improving usability.
R. Buskens - One of the best experts on this subject based on the ideXlab platform.
-
ICSM - C Macro Handling in Automated Source Code Transformation Systems
2006 22nd IEEE International Conference on Software Maintenance, 2006Co-Authors: Bin Yao, W. Mielke, S. Kennedy, R. BuskensAbstract:We have been using our source Code Transformation system, Proteus, inside Lucent to automate various programming tasks, to improve time to market as well as software quality. Specific areas include API migration, security enhancement, and logging Code instrumentation, etc. Based on our experience, source Code Transformation systems must be able to consistently apply Transformations, while preserving the original Code as much as possible, to make transformed Code programmer-friendly, and to reduce effort involved in reviewing Code changes. An important feature of C/C++ is macro support, which has been widely used in large Code bases to achieve source Code portability, allow easy customization, reduce coding efforts, etc. It has been shown that macro uses can occur as frequently as 0.6 macro uses per line [4]. Therefore, source Code Transformation systems targeted at C/C++ must be effective in their ability to handle macros.
Shoichi Hirasawa - One of the best experts on this subject based on the ideXlab platform.
-
IPDPS Workshops - A Customizable Auto-Tuning Scenario with User-Defined Code Transformations
2017 IEEE International Parallel and Distributed Processing Symposium Workshops (IPDPSW), 2017Co-Authors: Hiroyuki Takizawa, Shoichi Hirasawa, Daichi Sato, Daisuke TakahashiAbstract:At present, most of real-world HPC applications are being developed without considering any auto-tuning techniques; those applications are not "gauto-tunable" for several reasons. One reason is that making a Code auto-tunable often results in messing up the Code and degrading the readability and/or maintainability. In our previous work, we have employed a Code Transformation framework, Xevolver, for making a Code auto-tunable without messing it up. However, there is no standardized way to express the collaboration between Code Transformation and auto-tuning. In this paper, therefore, we design a standard tuning scenario and some directives to customize the scenario for individual applications. Our case studies show that the scenario can be reusable among different applications and different auto-tuning techniques by only partially customizing it. As a result, in terms of the number of Code lines, the proposed approach requires much less programming effort for achieving auto-tuning.
-
a use case of a Code Transformation rule generator for data layout optimization
2016Co-Authors: Hiroyuki Takizawa, Shoichi Hirasawa, Takeshi Yamada, Reiji SudaAbstract:Xevolver is a Code Transformation framework for users to define their own Code Transformation rules. In the framework, an abstract syntax tree (AST) of an application Code is written in an XML format, and its Transformation rules are expressed in the XSLT format, which is a standard XML format to describe XML data conversion; an AST and its Transformation rules are both written in XML. Since it is too low-level for standard users to manually write XSLT rules, Xevtgen is now being developed as a tool to generate such rules from simple Code description. In Xevtgen, users basically write just two Code patterns, the original and transformed Code patterns. Then, Xevtgen automatically generates a Transformation rule that transforms the original Code pattern to the transformed one. The generated rule is written in XSLT, and hence usable by other tools of the Xevolver framework. This article shows a use case of using Xevtgen for data layout optimization, and discusses the benefits of using the tool.
-
xevtgen fortran Code transformer generator for high performance scientific Codes
International Symposium on Computing and Networking, 2015Co-Authors: Reiji Suda, Hiroyuki Takizawa, Shoichi HirasawaAbstract:HPC scientific Codes are less readable and less manageable because of complex hand optimization which is often platform-dependent. We are developing a toolset that hopefully mitigates that maintainability problem by user-defined easy-to-use Code Transformation: The Code is written in a simpler form, and coding technique for high performance is introduced by Code Transformations. In this paper, we present xevtgen, which is a Code Transformation generator of our toolset. Transformation rules are defined using dummy Fortran Codes with some directives, and we expect that design makes it easier to learn for Fortran programmers. Some examples of Code Transformations are shown to discuss the practicality of the proposed approach.
-
CANDAR - A Case Study of User-Defined Code Transformations for Data Layout Optimizations
2015 Third International Symposium on Computing and Networking (CANDAR), 2015Co-Authors: Takeshi Yamada, Hiroyuki Takizawa, Shoichi Hirasawa, Hiroaki KobayashiAbstract:This paper reports a case study of using the Xevolver Code Transformation framework for data layout optimizations of high-performance computing (HPC) applications. Due to the variety of data structures used in individual applications, a Code Transformation rule for data layout optimizations is generally specific to a particular application. Since the Xevolver framework enables users to define their own Code Transformations, a custom Code Transformation can be defined so that a specific data representation in an existing Code can mechanically and consistently be translated to another one. Our evaluation results clearly demonstrate that such a Code Transformation is effective to improve memory access efficiency and hence the performance of an HPC application without overcomplicating the Code.
-
CANDAR - Xevtgen: Fortran Code Transformer Generator for High Performance Scientific Codes
2015 Third International Symposium on Computing and Networking (CANDAR), 2015Co-Authors: Reiji Suda, Hiroyuki Takizawa, Shoichi HirasawaAbstract:HPC scientific Codes are less readable and less manageable because of complex hand optimization which is often platform-dependent. We are developing a toolset that hopefully mitigates that maintainability problem by user-defined easy-to-use Code Transformation: The Code is written in a simpler form, and coding technique for high performance is introduced by Code Transformations. In this paper, we present xevtgen, which is a Code Transformation generator of our toolset. Transformation rules are defined using dummy Fortran Codes with some directives, and we expect that design makes it easier to learn for Fortran programmers. Some examples of Code Transformations are shown to discuss the practicality of the proposed approach.