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

acm sigplan NOTICES 2016年第6期51卷 369-385页

作者： McClurg, Jedidiah Hojjat, Hossein Foster, Nate Cerny, Pavol CU Boulder Boulder CO 80309 USA Cornell Univ Ithaca NY 14853 USA

Software-defined networking (SDN) programs must simultaneously describe static forwarding behavior and dynamic updates in response to events. Event-driven updates are critical to get right, but difficult to implement correctly due to the high degree of concurrency in networks. Existing SDN platforms offer weak guarantees that can break application invariants, leading to problems such as dropped packets, degraded performance, security violations, etc. This paper introduces event-driven consistent updates that are guaranteed to preserve well-defined behaviors when transitioning between configurations in response to events. We propose network event structures (NESs) to model constraints on updates, such as which events can be enabled simultaneously and causal dependencies between events. We define an extension of the NetKAT language with mutable state, give semantics to stateful programs using NESs, and discuss provably-correct strategies for implementing NESs in SDNs. Finally, we evaluate our approach empirically, demonstrating that it gives well-defined consistency guarantees while avoiding expensive synchronization and packet buffering.

关键词： network update consistent update event structure software-defined networking SDN NetKAT

来源：评论

学校读者我要写书评

暂无评论

Load-reuse analysis: design and evaluation

Proceedings of the ACM SIGPLAN Conference on Programming Lan...

引用

Proceedings of the acm sigplan conference on programming language design and implementation (PLDI) 1999年 64-76页

作者： Bodik, Rastislav Gupta, Rajiv Soffa, Mary Lou Univ of Pittsburgh Pittsburgh United States

Load-reuse analysis finds instructions that repeatedly access the same memory location. This location can be promoted to a register, eliminating redundant loads by reusing the results of prior memory accesses. This paper develops a load-reuse analysis and designs a method for evaluating its precision. In designing the analysis, we aspire for completeness - the goal of exposing all reuse that can be harvested by a subsequent program transformation. For register promotion, a suitable transformation is partial redundancy elimination (PRE). To approach the ideal goal of PRE-completeness, the load-reuse analysis is phrased as a data-flow problem on a program representation that is path-sensitive, as it detects reuse even when it originates in a different instruction along each control flow path. Furthermore, the analysis is comprehensive, as it treats scalar, array and pointer-based loads uniformly. In evaluating the analysis, we compare it with an ideal analysis. By observing the run-time stream of memory references, we collect all PRE-exploitable reuse and treat it as the ideal analysis performance. To compare the (static) load-reuse analysis with the (dynamic) ideal reuse, we use an estimator algorithm that computes, given a data-flow solution and a program profile, the dynamic amount of reuse detected by the analysis. We developed a family of estimators that differ in how well they bound the profiling error inherent in the edge profile. By bounding the error, the estimators offer a precise and practical method for determining the run-time optimization benefit. Our experiments show that about 55% of loads executed in Spec95 exhibit reuse. Of those, our analysis exposes about 80%.

关键词： Computer programming languages

来源：评论

学校读者我要写书评

暂无评论

Reactive Imperative programming with Dataflow Constraints

引用

acm sigplan NOTICES 2011年第10期46卷 407-426页

作者： Demetrescu, Camil Finocchi, Irene Ribichini, Andrea Sapienza Univ Rome Dept Comp & Syst Sci Rome Italy Sapienza Univ Rome Dept Comp Sci Rome Italy

Dataflow languages provide natural support for specifying constraints between objects in dynamic applications, where programs need to react efficiently to changes of their environment. Researchers have long investigated how to take advantage of dataflow constraints by embedding them into procedural languages. Previous mixed imperative/dataflow systems, however, require syntactic extensions or libraries of ad hoc data types for binding the imperative program to the dataflow solver. In this paper we propose a novel approach that smoothly combines the two paradigms without placing undue burden on the programmer. In our framework, programmers can define ordinary statements of the imperative host language that enforce constraints between objects stored in special memory locations designated as "reactive". Differently from previous approaches, reactive objects can be of any legal type in the host language, including primitive data types, pointers, arrays, and structures. Statements defining constraints are automatically re-executed every time their input memory locations change, letting a program behave like a spreadsheet where the values of some variables depend upon the values of other variables. The constraint solving mechanism is handled transparently by altering the semantics of elementary operations of the host language for reading and modifying objects. We provide a formal semantics and describe a concrete embodiment of our technique into C/C++, showing how to implement it efficiently in conventional platforms using off-the-shelf compilers. We discuss common coding idioms and relevant applications to reactive scenarios, including incremental computation, observer design pattern, and data structure repair. The performance of our implementation is compared to ad hoc problem-specific change propagation algorithms, as well as to language-centric approaches such as self-adjusting computation and subject/observer communication mechanisms, showing that the proposed approa

关键词： Algorithms design experimentation languages Reactive programming dataflow programming imperative programming constraint solving incremental computation observer design pattern data structure repair

来源：评论

学校读者我要写书评

暂无评论

A Distributed OpenCL Framework using Redundant Computation and Data Replication

引用

acm sigplan NOTICES 2016年第6期51卷 553-569页

作者： Kim, Junghyun Jo, Gangwon Jung, Jaehoon Kim, Jungwon Lee, Jaejin Seoul Natl Univ Ctr Manycore Programming Dept Comp Sci & Engn Seoul 08826 South Korea

Applications written solely in OpenCL or CUDA cannot execute on a cluster as a whole. Most previous approaches that extend these programming models to clusters are based on a common idea: designating a centralized host node and coordinating the other nodes with the host for computation. However, the centralized host node is a serious performance bottleneck when the number of nodes is large. In this paper, we propose a scalable and distributed OpenCL framework called SnuCL-D for large-scale clusters. SnuCL-D's remote device virtualization provides an OpenCL application with an illusion that all compute devices in a cluster are confined in a single node. To reduce the amount of control-message and data communication between nodes, SnuCL-D replicates the OpenCL host program execution and data in each node. We also propose a new OpenCL host API function and a queueing optimization technique that significantly reduce the overhead incurred by the previous centralized approaches. To show the effectiveness of SnuCL-D, we evaluate SnuCL-D with a microbenchmark and eleven benchmark applications on a large-scale CPU cluster and a medium-scale GPU cluster.

关键词： OpenCL clusters heterogeneous computing programming models runtime systems redundant computation data replication

来源：评论

学校读者我要写书评

暂无评论

EXPLORER : Query- and Demand-Driven Exploration of Interprocedural Control Flow Properties

引用

acm sigplan NOTICES 2015年第10期50卷 520-534页

作者： Feng, Yu Wang, Xinyu Dillig, Isil Lin, Calvin Univ Texas Austin Austin TX 78712 USA

This paper describes a general framework-and its implementation in a tool called EXPLORER-for statically answering a class of interprocedural control flow queries about Java programs. EXPLORER allows users to formulate queries about feasible callstack configurations using regular expressions, and it employs a precise, demand-driven algorithm for answering such queries. Specifically, EXPLORER constructs an automaton A that is iteratively refined until either the language accepted by A is empty (meaning that the query has been refuted) or until no further refinement is possible based on a precise, context-sensitive abstraction of the program. We evaluate EXPLORER by applying it to three different program analysis tasks, namely, (1) analysis of the observer design pattern in Java, (2) identification of a class of performance bugs, and (3) analysis of inter-component communication in Android applications. Our evaluation shows that EXPLORER is both efficient and precise.

关键词： Algorithms languages Program analysis Demand-driven analysis points-to analysis query language control flow properties

来源：评论

学校读者我要写书评

暂无评论

Quipper: A Scalable Quantum programming language 13

Quipper: A Scalable Quantum Programming Language

引用

acm sigplan conference on programming language design and implementation

作者： Alexander S. Green Peter LeFanu Lumsdaine Neil J. Ross Peter Selinger Benoit Valiron Dalhousie University Institute of Advanced Studies University of Pennsylvania

ISBN: (纸本)9781450320146

The field of quantum algorithms is vibrant. Still, there is currently a lack of programming languages for describing quantum computation on a practical scale, i.e., not just at the level of toy problems. We address this issue by introducing Quipper, a scalable, expressive, functional, higher-order quantum programming language. Quipper has been used to program a diverse set of non-trivial quantum algorithms, and can generate quantum gate representations using trillions of gates. It is geared towards a model of computation that uses a classical computer to control a quantum device, but is not dependent on any particular model of quantum hardware. Quipper has proven effective and easy to use, and opens the door towards using formal methods to analyze quantum algorithms.

关键词： Quipper Quantum programming languages

来源：评论

学校读者我要写书评

暂无评论

Occurrence Typing Modulo Theories

引用

acm sigplan NOTICES 2016年第6期51卷 296-309页

作者： Kent, Andrew M. Kempe, David Tobin-Hochstadt, Sam Indiana Univ Bloomington IN 47405 USA

We present a new type system combining occurrence typing- a technique previously used to type check programs in dynamically-typed languages such as Racket, Clojure, and JavaScript-with dependent refinement types. We demonstrate that the addition of refinement types allows the integration of arbitrary solver-backed reasoning about logical propositions from external theories. By building on occurrence typing, we can add our enriched type system as a natural extension of Typed Racket, reusing its core while increasing its expressiveness. The result is a well-tested type system with a conservative, decidable core in which types may depend on a small but extensible set of program terms. In addition to describing our design, we present the following: a formal model and proof of correctness;a strategy for integrating new theories, with specific examples including linear arithmetic and bitvectors;and an evaluation in the context of the full Typed Racket implementation. Specifically, we take safe vector operations as a case study, examining all vector accesses in a 56,000 line corpus of Typed Racket programs. Our system is able to prove that 50% of these are safe with no new annotations, and with a few annotations and modifications we capture more than 70%.

关键词： languages design Verification Refinement types occurrence typing Racket

来源：评论

学校读者我要写书评

暂无评论

Session details: language design 13

Session details: Language design

引用