Manuel Serrano · 1995
Article Control flow analysis: a functional languages compilation paradigm Share on Author: Manuel Serrano INRIA-Rocquencourt INRIA-RocquencourtView Profile Authors Info & Claims SAC '95: Proceedings of the 1995 ACM symposium on Applied computingFebruary 1995 Pages 118–122https://doi.org/10.1145/315891.315934Online:26 February 1995Publication History 20citation397DownloadsMetricsTotal Citations20Total Downloads397Last 12 Months10Last 6 weeks0 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteGet Access
Cited by 35
Flemming Nielson, Hanne Riis Nielson · 1997
Defining the collecting semantics is usually the first crucial step in adapting the general methodology of abstract interpretation to the semantic framework or programming language at hand. In this paper we show how to define a collecting semantics for control flow analysis: due to the generality of the formulation we need to appeal to coinduction (or greatest fixed points) in order to define the analysis. We then prove the semantic soundness of the collecting semantics and that all totally deterministic instantiations have a least solution; this incorporates k-CFA, polymorphic splitting and a new class of uniform-k-CFA analyses.
Cited by 115Open access
Chiara Braghin, Agostino Cortesi, Riccardo Focardi · ARCA (Università Ca' Foscari Venezia) · 2001
Cited by 1
Calculus Chiara Bodei, Chiara Bodei, Pierpaolo Degano et al. · 2007
. Control Flow Analysis is a static technique for predicting safe and computable approximations to the set of values that the objects of a program may assume during its execution. We present an analysis for the -calculus that shows how names will be bound to actual channels at run time. The formulation of the analysis requires no extensions to the -calculus, except for assigning "channels" to the occurrences of names within restrictions, and assigning "binders" to the occurrences of names within input prefixes. The result of our analysis establishes a super-set of the set of names to which a given name may be bound and of the set of names that may be sent along a given channel. Applications of our analysis include establishing simple security properties of processes. One example is that P has no leaks, i.e. P offers communication through public channels only, and confines its secret names within itself. 1 Introduction Program analysis aims at analysing properties of a program that h...
Cited by 0
2005
Higher-order typed languages, such as ML, provide strong support for data and type abstraction. While such abstraction is often viewed as costing performance, there are situations where it may provide opportunities for more aggressive program optimization. Specifically, we can exploit the fact that type abstraction guarantees representation independence, which allows the compiler to specialize data representations. This paper describes a first step in supporting such optimizations; namely a modular control-flow analysis that uses the program’s type information to compute more precise results. We present our algorithm as an extension of Serrano’s version of 0-CFA and we show that it respects types. We also discuss applications of the analysis with a specific focus on optimizing Concurrent ML programs. 1
Cited by 0
Flemming Nielson, Hanne Riis Nielson · Lecture notes in computer science · 2007
Cited by 0
2013
There are two steps in error control: error detection and error correction. Error detection schemes include parity codes, checksums, and Cyclic Redundancy Codes (CRC) codes. Error correction schemes include ARQ (Automatic Repeat reQuest) and FEC (Forward Error Correction). We shall analyze ARQ schemes in this course. FEC codes are used to send in the forward direction along with the user data. The receiver is able to correct simple errors that may occur in the data stream using the FEC code. ARQ: The fundamental idea is to use acknowledgments (ACKs) sent from the receiver to the sender for data frames sent from the sender to the receiver. We introduce concepts used in ARQ here: Timers: Sender keeps a timer, if an ACK is not received before the timer expires, it resends the frame. How large should the timer value be? Need for sequence numbers for the frames: If a frame is properly received, but the ACK is lost, then the sender will time-out and retransmit. This will result in the receiver receiving duplicate frames. Hence frames need sequence numbers to allow the receiver to detect duplicates. Need for sequence numbers in the ACKs: If a frame 0 is sent, but the timer times-out before the ACK is received, the sender will resend frame 0. If the ACK for the first frame 0 arrives soon after the sender retransmitted frame 0, the sender will assume that the ACK was for the retransmitted frame 0 and hence send frame 1. Now if frame 1 gets lost, but the receiver sends another ACK for the retransmitted frame 0, the sender may mistakenly think this ACK is for frame 1. If ACKs said what frames they were acknowledging (using their sequence numbers), this problem would not arise. Checkpointing: periodically sending ENQ (enquiries) to see what frames were received.
Cited by 0
Flemming Nielson, Helmut Seidl · Lecture notes in computer science · 2001
Cited by 32
Nevin Heintze · 1994
Cited by 9
National Association of Accountants. · The Journal of the Abraham Lincoln Association
Cited by 0Open access
A. B. Ehinmowo, Yi Cao · Systems Science & Control Engineering · 2016
The threat of slugging to production facilities has been known since the 1970s. This undesirable flow phenomenon continues to attract the attention of researchers and operators alike. The most common method for slug mitigation is by choking the valve at the exit of the riser which unfortunately could negatively affect production. The focus, therefore, is to satisfy the need for system stability and to maximize production simultaneously. Active feedback control is a promising way to achieve this. However, due to the complexity of multiphase flow systems, it is a challenge to develop a robust slug control system to achieve the desired performance using existing design tools. In this paper, a new general method for multiphase flow system stability analysis was proposed. Active feedback control was observed to optimize slug attenuation compared with manual choking. The use of soft sensors was believed to be desirable for the practical implementation of the proposed control technique.
Cited by 6Open access
Benney, David J., Orszag, Steven A., Langley Research Center. et al. · The Journal of the Abraham Lincoln Association
Cited by 0Open access
Flemming Nielson And, Flemming Nielson · 2001
It is well-known that context-independent control flow analysis can be performed in cubic time for functional and object-oriented languages. Yet recent applications of control flow analysis to calculi of computation (like the #-calculus and the ambient calculus) have reported considerably higher complexities. In this paper we introduce two general techniques, the use of Horn clauses with sharing and the use of tiling of Horn clauses, for reducing the worst-case complexity of analyses. Applying these techniques to the #-calculus and the ambient calculus we reduce the complexity from O(n 5 ) to O(n 3 ) in both cases.
Cited by 0
Geon Youn, William C. Pisano · Journal of the Sanitary Engineering Division · 1968
A numerical flow routing approach for assessing reservoir requirements for insuring that releases equal or exceed those flows necessary for pollution control is presented.
Cited by 0
Thomas Gilray, Steven Lyde, Michael D. Adams et al. · 2016
Traditional control-flow analysis (CFA) for higher-order languages introduces spurious connections between callers and callees, and different invocations of a function may pollute each other's return flows. Recently, three distinct approaches have been published that provide perfect call-stack precision in a computable manner: CFA2, PDCFA, and AAC. Unfortunately, implementing CFA2 and PDCFA requires significant engineering effort. Furthermore, all three are computationally expensive. For a monovariant analysis, CFA2 is in O(2^n), PDCFA is in O(n^6), and AAC is in O(n^8). In this paper, we describe a new technique that builds on these but is both straightforward to implement and computationally inexpensive. The crucial insight is an unusual state-dependent allocation strategy for the addresses of continuations. Our technique imposes only a constant-factor overhead on the underlying analysis and costs only O(n^3) in the monovariant case. We present the intuitions behind this development, benchmarks demonstrating its efficacy, and a proof of the precision of this analysis.
Cited by 38Open access
2008
Higher-order typed languages, such as ML, provide strong support for data and type abstraction. While such abstraction is often viewed as costing performance, there are situations where it may provide opportunities for more aggressive program optimization. Specifically, we can exploit the fact that type abstraction guarantees representation independence, which allows the compiler to specialize data representations. This paper describes a first step in supporting such optimizations; namely a control-flow analysis that uses the program’s type information to compute more precise results. We present our algorithm as an extension of Serrano’s version of 0-CFA and we show that it respects types. We also discuss applications of the analysis with examples of optimizations enabled by the analysis that would not be possible using normal CFA.
Cited by 0
Ward Muylaert · VUBIR (Vrije Universiteit Brussel) · 2024
When creating and maintaining programs, software developers make use of version control software to store different versions of the source code.Version control software uses commits as building blocks.Commits play a dual role: they represent a version of the software program at a certain point in time; they also represent the changes compared to the preceding version of the program.In this dissertation, we investigate two types of commits that are harder for developers to understand.First, we consider composite commits.Composite commits group many unrelated changes.The changes target different tasks, such as fixing a bug or introducing a new feature.Besides being harder to understand, composite commits also prove harder for software developers to revert or integrate and for empirical researchers to analyse.Second, we consider merge commits.Versions of the program start to diverge when different developers work on different features or bug fixes.A merge commit recombines divergent versions.An overlap in source code or an interaction in behaviour demands a resolution from the software developer, requiring them to understand the source code of the different versions.We propose an algorithmic foundation for tool support for these two types of problematic commits.Our first algorithm untangles composite commits using a data flow driven approach.Our algorithm considers a program dependence graph and fine-grained changes to the abstract syntax tree.The algorithm groups fine-grained changes according to the program dependence graph slices they belong to.Our second algorithm analyses merge commits using a control flow driven approach.It uses symbolic execution to gather path conditions of the different versions of the program.We define the program semantics in function of these path conditions.The path conditions are checked against rules that indicate presence of a semantic merge conflict.We evaluate both algorithms.By analysing, refining, and using an established dataset of composite commits, we find our untangling algorithm can determine whether a commit is composite.The groups of fine-grained changes tend to be smaller than the commit's tasks, but stay within their boundaries.We evaluate our semantic merge conflict detection algorithm in two ways.First, we evaluate its correctness through mutation testing.Second, we evaluate it empirically by applying it to real-world merges.We discuss challenges in the empirical evaluation of semantic merge conflicts.Our evaluation shows that in specific cases our approach is a promising extension to existing mechanisms in semantic merge conflict detection.iii This work would not have been possible without the support of many people, be it academical, technical, or mental support.Thanks to my promotor Prof. Dr. Coen De Roover.It drained blood, sweat, and tears out of the both of us, perhaps out of you more so than out of me, but we got there in the end.
Cited by 0Open access
2004
There are two steps in error control: error detection and error correction. Error detection schemes include parity codes, checksums, and Cyclic Redundancy Codes (CRC) codes. Error cor-rection schemes include ARQ (Automatic Repeat reQuest) and FEC (Forward Error Correction). We shall analyze ARQ schemes in this course. FEC codes are used to send in the forward direc-tion along with the user data. The receiver is able to correct simple errors that may occur in the data stream using the FEC code. ARQ: The fundamental idea is to use acknowledgments (ACKs) sent from the receiver to the sender for data frames sent from the sender to the receiver. We introduce concepts used in ARQ here: Timers: Sender keeps a timer, if an ACK is not received before the timer expires, it resends the frame. How large should the timer value be? Need for sequence numbers for the frames: If a frame is properly received, but the ACK is lost, then the sender will time-out and retransmit. This will result in the receiver receiving dupli-cate frames. Hence frames need sequence numbers to allow the receiver to detect duplicates. Need for sequence numbers in the ACKs: If a frame 0 is sent, but the timer times-out before the ACK is received, the sender will resend frame 0. If the ACK for the first frame 0 arrives soon after the sender retransmitted frame 0, the sender will assume that the ACK was for the retrans-mitted frame 0 and hence send frame 1. Now if frame 1 gets lost, but the receiver sends another ACK for the retransmitted frame 0, the sender may mistakenly think this ACK is for frame 1. If ACKs said what frames they were acknowledging (using their sequence numbers), this problem would not arise. Checkpointing: periodically sending ENQ (enquiries) to see what frames were received.
Cited by 0
Singh Satyavir · i-manager s Journal on Power Systems Engineering · 2022
In the field of power system restructuring, Flexible Alternating Current Transmission System (FACTS) technology has become indispensable for alleviating the challenges of load flow control, voltage control, transient stability, and dynamic stability. The Unified Power Flow Controller (UPFC) is the fastest, most flexible, and most capable FACTS device because it has the full advantage of providing simultaneous and independent real-time control of voltage, impedance, and phase angle, which are the main power system parameters that affect system performance. This paper uses a Newton-Raphson load flow that includes UPFC to analyze how UPFC can control the flow of power.
Cited by 0
Biswas, Priyam · Figshare · 2020
System programming languages such as C and C++ are ubiquitously used for systems software such as browsers and servers due to their flexibility and high performance. However, this flexibility comes with a price of lack of memory and type safety.<br>Control-Flow Hijacking (CFH), by taking advantage of the inherent lack of memory and type safety, has become one of the most common attack vectors against C/C++ programs. In such attacks, an attacker attempts to divert the normal control flow of the program to an attacker-controlled location. The most prominent defense against these kind of attacks is Control-Flow Integrity (CFI), which restricts the attack surface by limiting the set of possible targets for each indirect control-flow transfer. However, current analyses for the CFI target sets are highly conservative. Due to the ambiguity and imprecision in the analyses, CFI restricts adversaries to an over-approximation of the possible targets of individual indirect call sites. State-of-the-art CFI approaches fail to protect against special attack classes such as over-writing variadic function arguments. Furthermore, mitigation of control-flow attacks is not explored to its full potential in the context of language boundaries in current literature. Hence, we need effective solution to improve the precision of the CFI approaches as well as strong protection mechanisms against commonly abused corner cases.<br>We leverage the effectiveness of dynamic analysis in deriving a new approach to efficiently mitigate control-flow hijacking attacks. We present Ancile, a novel mechanism to improve the precision of the CFI mechanism by debloating any extraneous targets from the indirect control-flow transfers. We replaced the traditional static analysis approach for target discovery with seed demonstrated fuzzing. We have evaluated the effectiveness of our proposed mechanism with standard SPEC CPU benchmarks and other popular C and C++ applications.<br>To ensure complete security of C and C++ programs, we need to shield commonly exploited corners of C/C++ such as variadic functions. We performed extensive case studies to show the prevalence of such functions and their exploits. We also developed a sanitizer, HexVASAN, to effectively type-check and prevent any attack via variadic functions. CFH attacks, by abusing the difference of managed languages and their underlying system languages, are very frequent in client and server side programs. In order to safe-guard the control-flows in language boundaries, we propose a new mechanism, FitJit, to enforce type integrity. Finally, to understand the effectiveness of the dynamic analysis, we present Artemis, a comprehensive study of binary analysis on real world applications.
Cited by 0Open access