5,883 research outputs found
Type-based Dependency Analysis for JavaScript
Dependency analysis is a program analysis that determines potential data flow
between program points. While it is not a security analysis per se, it is a
viable basis for investigating data integrity, for ensuring confidentiality,
and for guaranteeing sanitization. A noninterference property can be stated and
proved for the dependency analysis. We have designed and implemented a
dependency analysis for JavaScript. We formalize this analysis as an
abstraction of a tainting semantics. We prove the correctness of the tainting
semantics, the soundness of the abstraction, a noninterference property, and
the termination of the analysis.Comment: Technical Repor
DeltaImpactFinder: Assessing Semantic Merge Conflicts with Dependency Analysis
In software development, version control systems (VCS) provide branching and
merging support tools. Such tools are popular among developers to concurrently
change a code-base in separate lines and reconcile their changes automatically
afterwards. However, two changes that are correct independently can introduce
bugs when merged together. We call semantic merge conflicts this kind of bugs.
Change impact analysis (CIA) aims at estimating the effects of a change in a
codebase. In this paper, we propose to detect semantic merge conflicts using
CIA. On a merge, DELTAIMPACTFINDER analyzes and compares the impact of a change
in its origin and destination branches. We call the difference between these
two impacts the delta-impact. If the delta-impact is empty, then there is no
indicator of a semantic merge conflict and the merge can continue
automatically. Otherwise, the delta-impact contains what are the sources of
possible conflicts.Comment: International Workshop on Smalltalk Technologies 2015, Jul 2015,
Brescia, Ital
Dependency analysis in ontology-driven content-based systems
Ontology-driven content-based systems are content-based systems (ODCBS) that are built to provide a better access to information by semantically annotating the content using ontologies. Such systems contain ontology layer, annotation layer and content layer. These layers contain semantically interrelated and interdependent entities. Thus, a change in one layer causes many unseen and undesired changes and impacts that propagate to other entities. Before any change is implemented in the ODCBS, it is crucial to understand the impacts of the change on other ODCBS entities. However, without getting these dependent entities, to which the change propagates, it is difficult to understand and analyze the impacts of the requested changes. In this paper we formally identify and define relevant dependencies, formalizing them and present a dependency analysis algorithm. The output of the dependency analysis
serves as an essential input for change impact analysis process that ensures the desired evolution of the ODCBS
Dynamic Trace-Based Data Dependency Analysis for Parallelization of C Programs
Writing parallel code is traditionally considered a difficult task, even when it is tackled from the beginning of a project. In this paper, we demonstrate an innovative toolset that faces this challenge directly. It provides the software developers with profile data and directs them to possible top-level, pipeline-style parallelization opportunities for an arbitrary sequential C program. This approach is complementary to the methods based on static code analysis and automatic code rewriting and does not impose restrictions on the structure of the sequential code or the parallelization style, even though it is mostly aimed at coarse-grained task-level parallelization. The proposed toolset has been utilized to define parallel code organizations for a number of real-world representative applications and is based on and is provided as free source
Partial dependency parsing for Irish
In this paper we present a partial dependency parser for Irish, in which Constraint Grammar (CG) rules are used to annotate dependency relations and grammatical functions in unrestricted Irish text. Chunking is performed using a regular-expression grammar which operates on the dependency tagged sentences. As this is the first implementation of a parser for unrestricted Irish text (to our knowledge), there were no guidelines or precedents available. Therefore deciding what constitutes a syntactic unit, and how it should be annotated, accounts for a major part of the early development effort. Currently, all tokens in a sentence are tagged for grammatical function and local dependency. Long-distance dependencies, prepositional attachments or coordination are not handled, resulting in a partial dependency analysis. Evaluations show that the partial dependency analysis achieves an f-score of 93.60% on development data and 94.28% on unseen test data, while the chunker achieves an f-score of 97.20% on development data and 93.50% on unseen test data
Improving dependency label accuracy using statistical post-editing: A cross-framework study
We present a statistical post-editing method for modifying the dependency labels in a dependency analysis. We test the method using two English datasets, three parsing systems and three labelled dependency schemes. We demonstrate how it can be used both to improve dependency label accuracy in parser output and highlight problems with and differences between constituency-to-dependency conversions
A Fast and Scalable Graph Coloring Algorithm for Multi-core and Many-core Architectures
Irregular computations on unstructured data are an important class of
problems for parallel programming. Graph coloring is often an important
preprocessing step, e.g. as a way to perform dependency analysis for safe
parallel execution. The total run time of a coloring algorithm adds to the
overall parallel overhead of the application whereas the number of colors used
determines the amount of exposed parallelism. A fast and scalable coloring
algorithm using as few colors as possible is vital for the overall parallel
performance and scalability of many irregular applications that depend upon
runtime dependency analysis.
Catalyurek et al. have proposed a graph coloring algorithm which relies on
speculative, local assignment of colors. In this paper we present an improved
version which runs even more optimistically with less thread synchronization
and reduced number of conflicts compared to Catalyurek et al.'s algorithm. We
show that the new technique scales better on multi-core and many-core systems
and performs up to 1.5x faster than its predecessor on graphs with high-degree
vertices, while keeping the number of colors at the same near-optimal levels.Comment: To appear in the proceedings of Euro Par 201
- …