scholarly journals Efficient algorithms for dynamic bidirected Dyck-reachability

2022 ◽  
Vol 6 (POPL) ◽  
pp. 1-29
Author(s):  
Yuanbo Li ◽  
Kris Satya ◽  
Qirun Zhang
Keyword(s):  
Program Analysis ◽  
Transitive Closure ◽  
Dynamic Graph ◽  
Alias Analysis ◽  
Worst Case ◽  
Dynamic Algorithm ◽  
Dynamic Algorithms ◽  
Incremental Computation ◽  
Deterministic Dynamic ◽  
Bidirected Graphs

Dyck-reachability is a fundamental formulation for program analysis, which has been widely used to capture properly-matched-parenthesis program properties such as function calls/returns and field writes/reads. Bidirected Dyck-reachability is a relaxation of Dyck-reachability on bidirected graphs where each edge u → ( i v labeled by an open parenthesis “( i ” is accompanied with an inverse edge v → ) i u labeled by the corresponding close parenthesis “) i ”, and vice versa. In practice, many client analyses such as alias analysis adopt the bidirected Dyck-reachability formulation. Bidirected Dyck-reachability admits an optimal reachability algorithm. Specifically, given a graph with n nodes and m edges, the optimal bidirected Dyck-reachability algorithm computes all-pairs reachability information in O ( m ) time. This paper focuses on the dynamic version of bidirected Dyck-reachability. In particular, we consider the problem of maintaining all-pairs Dyck-reachability information in bidirected graphs under a sequence of edge insertions and deletions. Dynamic bidirected Dyck-reachability can formulate many program analysis problems in the presence of code changes. Unfortunately, solving dynamic graph reachability problems is challenging. For example, even for maintaining transitive closure, the fastest deterministic dynamic algorithm requires O ( n 2 ) update time to achieve O (1) query time. All-pairs Dyck-reachability is a generalization of transitive closure. Despite extensive research on incremental computation, there is no algorithmic development on dynamic graph algorithms for program analysis with worst-case guarantees. Our work fills the gap and proposes the first dynamic algorithm for Dyck reachability on bidirected graphs. Our dynamic algorithms can handle each graph update ( i.e. , edge insertion and deletion) in O ( n ·α( n )) time and support any all-pairs reachability query in O (1) time, where α( n ) is the inverse Ackermann function. We have implemented and evaluated our dynamic algorithm on an alias analysis and a context-sensitive data-dependence analysis for Java. We compare our dynamic algorithms against a straightforward approach based on the O ( m )-time optimal bidirected Dyck-reachability algorithm and a recent incremental Datalog solver. Experimental results show that our algorithm achieves orders of magnitude speedup over both approaches.

scholarly journals Semi-dynamic algorithms for strongly chordal graphs

2020 ◽  
pp. 2150049
Author(s):  
Md Zamilur Rahman ◽  
Asish Mukhopadhyay
Keyword(s):  
Practical Importance ◽  
Chordal Graphs ◽  
Query Complexity ◽  
Extensive Literature ◽  
Dynamic Graph ◽  
Edge Deletion ◽  
Dynamic Algorithm ◽  
Dynamic Algorithms ◽  
Shortest Path Problems ◽  
Strongly Chordal Graphs

Within the broad ambit of algorithm design, the study of dynamic graph algorithms continues to be a thriving area of research. Commensurate with this interest is an extensive literature on the topic. Not surprisingly, dynamic algorithms for all varieties of shortest path problems, in view of their practical importance, occupy a preeminent position. Relevant to this paper are fully dynamic algorithms for chordal graphs. Surprisingly, to the best of our knowledge, there seems to be no reported results for the problem of dynamic algorithms for strongly chordal graphs. To redress this gap, in this paper, we propose a semi-dynamic algorithm for edge-deletions and a semi-dynamic algorithm for edge-insertions in a strongly chordal graph, [Formula: see text]. The query complexity of an edge-deletion is [Formula: see text], where [Formula: see text] and [Formula: see text] are the degrees of the vertices [Formula: see text] and [Formula: see text] of the candidate edge [Formula: see text], while the query complexity of an edge-insertion is [Formula: see text], where [Formula: see text] is the number of vertices of [Formula: see text].

scholarly journals Lower Bounds for Dynamic Transitive Closure, Planar Point Location, and Parentheses Matching

1996 ◽  
Vol 3 (9) ◽  
Author(s):  
Thore Husfeldt ◽  
Theis Rauhe ◽  
Søren Skyum
Keyword(s):  
Lower Bound ◽  
Lower Bounds ◽  
Transitive Closure ◽  
Unit Cost ◽  
Random Access ◽  
Point Location ◽  
Worst Case ◽  
Planar Point ◽  
Planar Point Location ◽  
Prefix Sums

We give a number of new lower bounds in the cell probe model<br />with logarithmic cell size, which entails the same bounds on the random access computer with logarithmic word size and unit cost operations. We study the signed prefix sum problem: given a string of length n of zeroes and signed ones, compute the sum of its ith prefix during updates. We show a<br />lower bound of  Omega(log n/log log n) time per operations, even if the prefix sums are bounded by log n/log log n during all updates. We also show that if the update time is bounded by the product of the worst-case update time and the<br />answer to the query, then the update time must be Omega(sqrt(log n/ log log n)).<br /> These results allow us to prove lower bounds for a variety of seemingly unrelated<br />dynamic problems. We give a lower bound for the dynamic planar point location in monotone subdivisions of <br />Omega(log n/ log log n) per operation. We give<br />a lower bound for the dynamic transitive closure problem on upward planar graphs with one source and one sink of <br />Omega(log n/(log logn)^2) per operation. We give a lower bound of  Omega(sqrt(log n/log log n)) for the dynamic membership problem of any Dyck language with two or more letters. This implies the same<br />lower bound for the dynamic word problem for the free group with k generators. We also give lower bounds for the dynamic prefix majority and prefix equality problems.

Layered Region Based Flow-Sensitive Demand-Driven Alias Analysis

2014 ◽  
Vol 577 ◽  
pp. 917-920
Author(s):  
Long Pang ◽  
Xiao Hong Su ◽  
Pei Jun Ma ◽  
Ling Ling Zhao
Keyword(s):  
Program Analysis ◽  
Control Flow ◽  
Alias Analysis ◽  
Reachability Problem ◽  
Analysis Algorithm ◽  
Context Free Language ◽  
Context Free ◽  
Free Language ◽  
Demand Driven Analysis

The pointer alias is indispensable for program analysis. Comparing to point-to set, it’s more efficient to formulate the alias as the context free language (CFL) reachability problem. However, the precision is limited to flow-insensitivity. To solve this problem, we propose a flow sensitive, demand-driven analysis algorithm for answering may-alias queries. First the partial single static assignment is used to discriminate the address-taken pointers. Then the order of control flow is encoded in the level linearization code to ease comparison. Finally, the query of alias in demand driven is converted into the search of CFL reachability with feasible flows. The experiments demonstrate the effectiveness of the proposed approach.

scholarly journals Deterministic Dynamic Matching in O(1) Update Time

Algorithmica ◽  
2019 ◽  
Vol 82 (4) ◽  
pp. 1057-1080 ◽  
Author(s):  
Sayan Bhattacharya ◽  
Deeparnab Chakrabarty ◽  
Monika Henzinger
Keyword(s):  
Computer Science ◽  
Vertex Cover ◽  
Approximation Ratio ◽  
Approximate Algorithm ◽  
Maximum Matching ◽  
Matching Problem ◽  
Dynamic Algorithm ◽  
Dynamic Matching ◽  
Deterministic Dynamic ◽  
Oblivious Adversary

Abstract We consider the problems of maintaining an approximate maximum matching and an approximate minimum vertex cover in a dynamic graph undergoing a sequence of edge insertions/deletions. Starting with the seminal work of Onak and Rubinfeld (in: Proceedings of the ACM symposium on theory of computing (STOC), 2010), this problem has received significant attention in recent years. Very recently, extending the framework of Baswana et al. (in: Proceedings of the IEEE symposium on foundations of computer science (FOCS), 2011) , Solomon (in: Proceedings of the IEEE symposium on foundations of computer science (FOCS), 2016) gave a randomized dynamic algorithm for this problem that has an approximation ratio of 2 and an amortized update time of O(1) with high probability. This algorithm requires the assumption of an oblivious adversary, meaning that the future sequence of edge insertions/deletions in the graph cannot depend in any way on the algorithm’s past output. A natural way to remove the assumption on oblivious adversary is to give a deterministic dynamic algorithm for the same problem in O(1) update time. In this paper, we resolve this question. We present a new deterministic fully dynamic algorithm that maintains a O(1)-approximate minimum vertex cover and maximum fractional matching, with an amortized update time of O(1). Previously, the best deterministic algorithm for this problem was due to Bhattacharya et al. (in: Proceedings of the ACM-SIAM symposium on discrete algorithms (SODA), 2015); it had an approximation ratio of $$(2+\varepsilon )$$(2+ε) and an amortized update time of $$O(\log n/\varepsilon ^2)$$O(logn/ε2). Our result can be generalized to give a fully dynamic $$O(f^3)$$O(f3)-approximate algorithm with $$O(f^2)$$O(f2) amortized update time for the hypergraph vertex cover and fractional hypergraph matching problem, where every hyperedge has at most f vertices.

scholarly journals Scenario-Aware Program Specialization for Timing Predictability

2021 ◽  
Vol 18 (4) ◽  
pp. 1-26
Author(s):  
Joscha Benz ◽  
Oliver Bringmann
Keyword(s):  
Program Analysis ◽  
Control Flow ◽  
Wcet Analysis ◽  
Specific System ◽  
Worst Case ◽  
Program Specialization ◽  
Operating Modes ◽  
Source Level ◽  
Dependent Flow ◽  
Timing Simulation

The successful application of static program analysis strongly depends on flow facts of a program such as loop bounds, control-flow constraints, and operating modes. This problem heavily affects the design of real-time systems, since static program analyses are a prerequisite to determine the timing behavior of a program. For example, this becomes obvious in worst-case execution time (WCET) analysis, which is often infeasible without user-annotated flow facts. Moreover, many timing simulation approaches use statically derived timings of partial program paths to reduce simulation overhead. Annotating flow facts on binary or source level is either error-prone and tedious, or requires specialized compilers that can transform source-level annotations along with the program during optimization. To overcome these obstacles, so-called scenarios can be used. Scenarios are a design-time methodology that describe a set of possible system parameters, such as image resolutions, operating modes, or application-dependent flow facts. The information described by a scenario is unknown in general but known and constant for a specific system. In this article, 1 we present a methodology for scenario-aware program specialization to improve timing predictability. Moreover, we provide an implementation of this methodology for embedded software written in C/C++. We show the effectiveness of our approach by evaluating its impact on WCET analysis using almost all of TACLeBench–achieving an average reduction of WCET of 31%. In addition, we provide a thorough qualitative and evaluation-based comparison to closely related work, as well as two case studies.

scholarly journals Refocusing in Reduction Semantics

2004 ◽  
Vol 11 (26) ◽  
Author(s):  
Olivier Danvy ◽  
Lasse R. Nielsen
Keyword(s):  
Transitive Closure ◽  
Operational Semantics ◽  
Sufficient Conditions ◽  
Lambda Calculus ◽  
Transition Function ◽  
Evaluation Function ◽  
Abstract Machine ◽  
Worst Case ◽  
State Transition Function ◽  
Case Basis

The evaluation function of a reduction semantics (i.e., a small-step operational semantics with an explicit representation of the reduction context) is canonically defined as the transitive closure of (1) decomposing a term into a reduction context and a redex, (2) contracting this redex, and (3) plugging the contractum in the context. Directly implementing this evaluation function therefore yields an interpreter with a worst-case overhead, for each step, that is linear in the size of the input term. <br /> <br />We present sufficient conditions over the constituents of a reduction semantics to circumvent this overhead, by replacing the composition of (3) plugging and (1) decomposing by a single ``refocus'' function mapping a contractum and a context into a new context and a new redex, if any. We also show how to construct such a refocus function, we prove the correctness of this construction, and we analyze the complexity of the resulting refocus function. <br /> <br />The refocused evaluation function of a reduction semantics implements the transitive closure of the refocus function, i.e., a ``pre-abstract machine.'' Fusing the refocus function with the trampoline function computing the transitive closure gives a state-transition function, i.e., an abstract machine. This abstract machine clearly separates between the transitions implementing the congruence rules of the reduction semantics and the transitions implementing its reduction rules. The construction of a refocus function therefore shows how to mechanically obtain an abstract machine out of a reduction semantics, which was done previously on a case-by-case basis. <br /> <br />We illustrate refocusing by mechanically constructing Felleisen et al.'s CK machine from a call-by-value reduction semantics of the lambda-calculus, and by constructing a substitution-based version of Krivine's machine from a call-by-name reduction semantics of the lambda-calculus. We also mechanically construct three one-pass CPS transformers from three quadratic context-based CPS transformers for the lambda-calculus.

Sign in / Sign up

Export Citation Format

Share Document