检索结果-内蒙古大学图书馆

Exhaustive Execution of CHR Through source-to-source transformation 24th

24th International Symposium on Logic-Based Program Synthesis and transformation (LOPSTR)

作者： Elsawy, Ahmed Zaki, Amira Abdennadher, Slim German Univ Cairo Cairo Egypt Univ Ulm D-89069 Ulm Germany

ISBN: (纸本)9783319178226;9783319178219

Constraint Handling Rules (CHR) is a committed-choice rule-based programming language. Rules rewrite a global multi-set of constraints to another. Overlapping sets of constraints within the rules and the order of constraints within rules and queries entail different derivation paths. In this work, a novel operational strategy is proposed which enables a high-level form of execution control that empowers a comprehensive and customizable execution strategy. It allows full space exploration for any CHR program, thus finding all possible results to a query which is interesting for many non-confluent programs. The proposed transformation is performed as a source-to-source transformation from any CHR program to one utilizing disjunction to force an exhaustive explorative execution strategy. The work is complemented by formal arguments to prove the correctness and completeness of the transformation.

关键词： Constraint Handling Rules Execution flow control Exhaustive execution Search space exploration source-to-source transformation

来源：评论

学校读者我要写书评

暂无评论

Towards the Implementation of a source-to-source transformation Tool for CHR Operational Semantics 1

引用

23rd International Symposium on Logic-based Program Synthesis and transformation (LOPSTR)

作者： Fakhry, Ghada Sharaf, Nada Abdennadher, Slim German Univ Cairo Dept Comp Sci & Engn Cairo Egypt

ISBN: (数字)9783319141251

ISBN: (纸本)9783319141251;9783319141244

Constraint Handling Rules (CHR) is a high-level committed-choice language based on multi-headed and guarded rules. Over the past decades, several extensions to CHR and variants of operational semantics were introduced. In this paper, we present a generic approach to simulate the execution of a set of different CHR operational semantics. The proposed approach uses source-to-source transformation to convert programs written under different CHR operational semantics into equivalent programs in the CHR refined operational semantics without the need to change the compiler or the runtime system.

关键词： source-to-source transformation Constraint Handling Rules Operational Semantics

来源：评论

学校读者我要写书评

暂无评论

A large-scale empirical study of low-level function use in Ethereum smart contracts and automated replacement

引用

SOFTWARE-PRACTICE & EXPERIENCE 2023年第3期53卷 631-664页

作者： Xi, Rui Pattabiraman, Karthik Univ British Columbia UBC Dept Elect & Comp Engn Rm 4048Fred Kaiser Bldg2332 Main Mall Vancouver BC V6T 1Z4 Canada

The Ethereum blockchain stores and executes complex logic via smart contracts written in Solidity, a high-level programming language. The Solidity language (in its early versions) provides features to exercise fine-grained control over smart contracts, whose usage is discouraged by later-released Solidity documentation, but nonetheless supported in later versions for backward compatibility. We define these features as low-level functions. However, the high-volume of transactions and the improper use of low-level functions lead to security exploits with heavy financial loss. Consequently, the documentation suggests secure alternatives to the use of low-level functions. In this article, we first perform an empirical study on the use of low-level functions in Ethereum smart contracts. We study a smart contract dataset consisting of over 2,100,000 real-world smart contracts. We find that low-level functions are widely used and that the majority of these uses are gratuitous. We then propose GoHigh, a source-to-source transformation tool to eliminate low-level function-related vulnerabilities, by replacing low-level functions with secure alternatives. Our experimental evaluation on the dataset shows that GoHigh successfully replaces all low-level functions with 4.9% fewer compiler warnings. Further, no unintended side-effects are introduced in 80% of the contracts, and the remaining 20% are not verifiable due to their external dependency. GoHigh saves more than 5% of the gas cost of the contract. Finally, GoHigh takes 7 s on average per contract.

关键词： Ethereum blockchain smart contract source-to-source transformation static analysis

来源：评论

学校读者我要写书评

暂无评论

When They Go Low: Automated Replacement of Low-level Functions in Ethereum Smart Contracts 29

When They Go Low: Automated Replacement of Low-level Functio...

引用

29th IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER)

作者： Xi, Rui Pattabiraman, Karthik Univ British Columbia UBC Dept Elect & Comp Engn Vancouver BC Canada

ISBN: (纸本)9781665437868

Smart contracts in the Ethereum blockchain are typically written using a high-level, Turing-complete language called Solidity. However, the Solidity language has many features to allow programmers fine-grained control over their smart contracts. We call these features low-level functions. Unfortunately, the improper use of low-level functions can lead to security vulnerabilities leading to heavy financial losses. Therefore, the Solidity community has suggested alternatives for the low-level functions in the official guidelines for developers. We first perform a large-scale empirical study on the use of low-level functions in Ethereum smart contracts written in Solidity. We find that such functions are widely used in realworld Ethereum smart contracts, and that the majority of these uses are gratuitous for the smart contract's functionality. We then propose GoHigh, a source-to-source transformation tool to eliminate low-level function-related vulnerabilities, by replacing low-level functions with high-level alternatives. We evaluate GoHigh on over 300, 000 real-world smart contracts on the Ethereum blockchain. GoHigh replaces all low-level functions that are amenable to replacement in the contracts with 17% fewer compiler warnings, and the externally-visible behaviors of at least 92% of the replaced contracts are identical to the original ones. Finally, GoHigh takes 7 seconds on average per contract.

关键词： Ethereum blockchain Smart contract source-to-source transformation Static analysis

来源：评论

学校读者我要写书评

暂无评论

source-to-source transformations for Parallel Optimizations in STAPL

Source-to-Source Transformations for Parallel Optimizations ...

引用

作者： Kelley, Brian M Texas A&M University

Programs that use the STAPL C++ parallel programming library express their control and data flow explicitly through the use of skeletons. Skeletons can be simple parallel operations like map and reduce, or the result of composing several skeletons. Composition is implemented by tracking the dependencies among individual data elements in the STAPL runtime system. However, the operations and dependencies within a compose skeleton can be determined at compile time from the C++ abstract syntax tree. This enables the use of source-to-source transformations to fuse the composed skeletons. transformations can also be used to replace skeletons entirely with equivalent code. Both transformations greatly reduce STAPL runtime overhead, and zip fusion also allows a compiler to optimize the work functions as a single unit. We present a Clang compiler plugin and wrapper that automatically perform these transformations, and demonstrate its ability to improve performance.

关键词： source-to-source transformation algorithmic skeletons Thesis

来源：评论

学校读者我要写书评

暂无评论

Runtime Verification of Memory Safety via source transformation 18

Runtime Verification of Memory Safety via Source Transformat...

引用

40th ACM/IEEE International Conference on Software Engineering (ICSE)

作者： Chen, Zhe Yan, Junqi Li, Wenming Qian, Ju Huang, Zhiqiu Nanjing Univ Aeronaut & Astronaut Coll Comp Sci & Technol Nanjing Jiangsu Peoples R China

ISBN: (纸本)9781450356633

The unsafe features of C often lead to memory errors that can result in vulnerabilities. Many runtime verification tools are widely used to detect memory errors. However, existing tools lack DO178C compliance, show limited performance, and demonstrate poor accessibility, e.g., lacking platform-independence. In this paper, we propose to implement dynamic analysis tools using source-to-source transformation, which operates on the original source code to insert code fragments written in ANSI C, and generates source files similar to the original files in structure. We show that source transformation can effectively avoid the mentioned drawbacks of existing tools, but it also faces many new challenges in implementation.

关键词： runtime verification dynamic analysis memory safety C programs source-to-source transformation

来源：评论

学校读者我要写书评

暂无评论

FLASH: Fast, Parallel, and Accurate Simulator for HLS

引用

IEEE TRANSACTIONS ON COMPUTER-AIDED DESIGN OF INTEGRATED CIRCUITS AND SYSTEMS 2020年第12期39卷 4828-4841页

作者： Choi, Young-Kyu Chi, Yuze Wang, Jie Cong, Jason Univ Calif Los Angeles Comp Sci Dept Los Angeles CA 90095 USA

A large semantic gap between a high-level synthesis (HLS) design and a low-level RTL simulation environment often creates a barrier for those who are not field-programmable gate array (FPGA) experts. Moreover, such a low-level simulation takes a long time to complete. Software HLS simulators can help bridge this gap and accelerate the simulation process;but their shortcoming is that they do not provide performance estimation. To make matters worse, we found that the current FPGA HLS commercial software simulators sometimes produce incorrect results. In order to solve these performance estimation and correctness problems while maintaining the high speed of software simulators, this article proposes a new HLS simulation flow named FLASH. The main idea behind the proposed flow is to extract scheduling information from the HLS tool and automatically construct an equivalent cycle-accurate simulation model while preserving C semantics. The experimental results show that FLASH runs three orders of magnitude faster than the RTL simulation.

关键词： Software Tools Field programmable gate arrays Force Semantics Acceleration Estimation Field-programmable gate array (FPGA) high-level synthesis (HLS) simulation acceleration source-to-source transformation

来源：评论

学校读者我要写书评

暂无评论

Rapid Cycle-Accurate Simulator for High-Level Synthesis 19

Rapid Cycle-Accurate Simulator for High-Level Synthesis

引用

ACM/SIGDA International Symposium on Field-Programmable Gate Arrays (FPGA)

作者： Chi, Yuze Choi, Young-kyu Cong, Jason Wang, Jie Univ Calif Los Angeles Dept Comp Sci Los Angeles CA 90024 USA

ISBN: (纸本)9781450361378

A large semantic gap between the high-level synthesis (HLS) design and the low-level (on-board or RTL) simulation environment often creates a barrier for those who are not FPGA experts. Moreover, such low-level simulation takes a long time to complete. Software-based HLS simulators can help bridge this gap and accelerate the simulation process;however, we found that the current FPGA HLS commercial software simulators sometimes produce incorrect results. In order to solve this correctness issue while maintaining the high speed of a software-based simulator, this paper proposes a new HLS simulation flow named FLASH. The main idea behind the proposed flow is to extract the scheduling information from the HLS tool and automatically construct an equivalent cycle-accurate simulation model while preserving C semantics. Experimental results show that FLASH runs three orders of magnitude faster than the RTL simulation.

关键词： high-level synthesis simulation acceleration source-to-source transformation fpga

来源：评论

学校读者我要写书评

暂无评论

SkePU 2: Flexible and Type-Safe Skeleton Programming for Heterogeneous Parallel Systems

引用

INTERNATIONAL JOURNAL OF PARALLEL PROGRAMMING 2018年第1期46卷 62-80页

作者： Ernstsson, August Li, Lu Kessler, Christoph Linkoping Univ Dept Comp & Informat Sci PELAB Linkoping Sweden

In this article we present SkePU 2, the next generation of the SkePU C++ skeleton programming framework for heterogeneous parallel systems. We critically examine the design and limitations of the SkePU 1 programming interface. We present a new, flexible and type-safe, interface for skeleton programming in SkePU 2, and a source-to-source transformation tool which knows about SkePU 2 constructs such as skeletons and user functions. We demonstrate how the source-to-source compiler transforms programs to enable efficient execution on parallel heterogeneous systems. We show how SkePU 2 enables new use-cases and applications by increasing the flexibility from SkePU 1, and how programming errors can be caught earlier and easier thanks to improved type safety. We propose a new skeleton, Call, unique in the sense that it does not impose any predefined skeleton structure and can encapsulate arbitrary user-defined multi-backend computations. We also discuss how the source-to-source compiler can enable a new optimization opportunity by selecting among multiple user function specializations when building a parallel program. Finally, we show that the performance of our prototype SkePU 2 implementation closely matches that of SkePU 1.

关键词： Skeleton programming SkePU source-to-source transformation C++11 Heterogeneous parallel systems Portability

来源：评论

学校读者我要写书评

暂无评论

An Empirical Study of the Effect of source-Level Loop transformations on Compiler Stability

引用

PROCEEDINGS OF THE ACM ON PROGRAMMING LANGUAGES-PACMPL 2018年第OOPSLA期2卷 1–29页

作者： Gong, Zhangxiaowen Chen, Zhi Szaday, Justin Wong, David Sura, Zehra Watkinson, Neftali Maleki, Saeed Padua, David Veidenbaum, Alexander Nicolau, Alexandru Torrellas, Josep Univ Illinois Champaign IL 61820 USA Univ Calif Irvine Irvine CA 92717 USA Intel Corp Santa Clara CA 95051 USA IBM Corp Armonk NY 10504 USA Microsoft Corp Redmond WA 98052 USA

Modern compiler optimization is a complex process that offers no guarantees to deliver the fastest, most efficient target code. For this reason, compilers struggle to produce a stable performance from versions of code that carry out the same computation and only differ in the order of operations. This instability makes compilers much less effective program optimization tools and often forces programmers to carry out a brute force search when tuning for performance. In this paper, we analyze the stability of the compilation process arid the performance headroom of three widely used general purpose compilers: GCC, ICC, and Clang. For the study, we extracted over 1,000 for loop nests from well-known benchmarks, libraries, and real applications;then, we applied sequences of source-level loop transformations to these loop nests to create numerous semantically equivalent mutations;finally, we analyzed the impact of transformations on code quality in terms of locality, dynamic instruction count, and vectorization. Our results show that, by applying source-to-source transformations and searching for the best vectorization setting, the percentage of loops sped up by at least 1.15x is 46.7% for GCC, 35.7% for ICC, and 46.5% for Clang, and on average the potential for performance improvement is estimated to be at least 23.7% for GCC, 18.1% for ICC, and 26.4% for Clang. Our stability analysis shows that, under our experimental setup, the average coefficient of variation of the execution time across all mutations is 18.2% for GCC, 19.5% for ICC, and 16.9% for Clang, and the highest coefficient of variation for a single loop nest reaches 118.9% for GCC, 124.3% for ICC, and 110.5% for Clang. We conclude that the evaluated compilers need further improvements to claim they have stable behavior.

关键词： compiler stability source-to-source transformation vectorization

来源：评论

学校读者我要写书评

暂无评论

建议与咨询留下您的常用邮箱和电话号码，以便我们向您反馈解决方案和替代方法

时间限定

文献类型

馆藏选择

核心期刊

语言

文献类型

帮助

文字说明：

检索规则说明：

检索范例：

分类表

所选分类

限定检索结果

文献类型

馆藏范围

日期分布

学科分类号

主题

机构

作者

语言

请选择保存的检索档案：

请选择收藏分类：

通借通还

建议与咨询 留下您的常用邮箱和电话号码，以便我们向您反馈解决方案和替代方法

时间限定

文献类型

馆藏选择

核心期刊

语言

文献类型

帮助

文字说明：

检索规则说明：

检索范例：

分类表

所选分类

限定检索结果

文献类型

馆藏范围

日期分布

学科分类号

主题

机构

作者

语言

请选择保存的检索档案： 新增检索档案 确定 取消

请选择收藏分类： 新增自定义分类 确定 取消

通借通还

建议与咨询留下您的常用邮箱和电话号码，以便我们向您反馈解决方案和替代方法

请选择保存的检索档案：

请选择收藏分类：