8 research outputs found

    Conference Series

    Get PDF
    Civl is a static verifier for concurrent programs designed around the conceptual framework of layered refinement, which views the task of verifying a program as a sequence of program simplification steps each justified by its own invariant. Civl verifies a layered concurrent program that compactly expresses all the programs in this sequence and the supporting invariants. This paper presents the design and implementation of the Civl verifier

    LNCS

    Get PDF
    This paper presents a foundation for refining concurrent programs with structured control flow. The verification problem is decomposed into subproblems that aid interactive program development, proof reuse, and automation. The formalization in this paper is the basis of a new design and implementation of the Civl verifier

    IST Austria Thesis

    Get PDF
    Designing and verifying concurrent programs is a notoriously challenging, time consuming, and error prone task, even for experts. This is due to the sheer number of possible interleavings of a concurrent program, all of which have to be tracked and accounted for in a formal proof. Inventing an inductive invariant that captures all interleavings of a low-level implementation is theoretically possible, but practically intractable. We develop a refinement-based verification framework that provides mechanisms to simplify proof construction by decomposing the verification task into smaller subtasks. In a first line of work, we present a foundation for refinement reasoning over structured concurrent programs. We introduce layered concurrent programs as a compact notation to represent multi-layer refinement proofs. A layered concurrent program specifies a sequence of connected concurrent programs, from most concrete to most abstract, such that common parts of different programs are written exactly once. Each program in this sequence is expressed as structured concurrent program, i.e., a program over (potentially recursive) procedures, imperative control flow, gated atomic actions, structured parallelism, and asynchronous concurrency. This is in contrast to existing refinement-based verifiers, which represent concurrent systems as flat transition relations. We present a powerful refinement proof rule that decomposes refinement checking over structured programs into modular verification conditions. Refinement checking is supported by a new form of modular, parameterized invariants, called yield invariants, and a linear permission system to enhance local reasoning. In a second line of work, we present two new reduction-based program transformations that target asynchronous programs. These transformations reduce the number of interleavings that need to be considered, thus reducing the complexity of invariants. Synchronization simplifies the verification of asynchronous programs by introducing the fiction, for proof purposes, that asynchronous operations complete synchronously. Synchronization summarizes an asynchronous computation as immediate atomic effect. Inductive sequentialization establishes sequential reductions that captures every behavior of the original program up to reordering of coarse-grained commutative actions. A sequential reduction of a concurrent program is easy to reason about since it corresponds to a simple execution of the program in an idealized synchronous environment, where processes act in a fixed order and at the same speed. Our approach is implemented the CIVL verifier, which has been successfully used for the verification of several complex concurrent programs. In our methodology, the overall correctness of a program is established piecemeal by focusing on the invariant required for each refinement step separately. While the programmer does the creative work of specifying the chain of programs and the inductive invariant justifying each link in the chain, the tool automatically constructs the verification conditions underlying each refinement step

    C์˜ ์ €์ˆ˜์ค€ ๊ธฐ๋Šฅ๊ณผ ์ปดํŒŒ์ผ๋Ÿฌ ์ตœ์ ํ™” ์กฐํ™”์‹œํ‚ค๊ธฐ

    Get PDF
    ํ•™์œ„๋…ผ๋ฌธ (๋ฐ•์‚ฌ)-- ์„œ์šธ๋Œ€ํ•™๊ต ๋Œ€ํ•™์› : ๊ณต๊ณผ๋Œ€ํ•™ ์ปดํ“จํ„ฐ๊ณตํ•™๋ถ€, 2019. 2. ํ—ˆ์ถฉ๊ธธ.์ฃผ๋ฅ˜ C ์ปดํŒŒ์ผ๋Ÿฌ๋“ค์€ ํ”„๋กœ๊ทธ๋žจ์˜ ์„ฑ๋Šฅ์„ ๋†’์ด๊ธฐ ์œ„ํ•ด ๊ณต๊ฒฉ์ ์ธ ์ตœ์ ํ™”๋ฅผ ์ˆ˜ํ–‰ํ•˜๋Š”๋ฐ, ๊ทธ๋Ÿฐ ์ตœ์ ํ™”๋Š” ์ €์ˆ˜์ค€ ๊ธฐ๋Šฅ์„ ์‚ฌ์šฉํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์˜ ํ–‰๋™์„ ๋ฐ”๊พธ๊ธฐ๋„ ํ•œ๋‹ค. ๋ถˆํ–‰ํžˆ๋„ C ์–ธ์–ด๋ฅผ ๋””์ž์ธํ•  ๋•Œ ์ €์ˆ˜์ค€ ๊ธฐ๋Šฅ๊ณผ ์ปดํŒŒ์ผ๋Ÿฌ ์ตœ์ ํ™”๋ฅผ ์ ์ ˆํ•˜๊ฒŒ ์กฐํ™”์‹œํ‚ค๊ฐ€ ๊ต‰์žฅํžˆ ์–ด๋ ต๋‹ค๋Š” ๊ฒƒ์ด ํ•™๊ณ„์™€ ์—…๊ณ„์˜ ์ค‘๋ก ์ด๋‹ค. ์ €์ˆ˜์ค€ ๊ธฐ๋Šฅ์„ ์œ„ํ•ด์„œ๋Š”, ๊ทธ๋Ÿฌํ•œ ๊ธฐ๋Šฅ์ด ์‹œ์Šคํ…œ ํ”„๋กœ๊ทธ๋ž˜๋ฐ์— ์‚ฌ์šฉ๋˜๋Š” ํŒจํ„ด์„ ์ž˜ ์ง€์›ํ•ด์•ผ ํ•œ๋‹ค. ์ปดํŒŒ์ผ๋Ÿฌ ์ตœ์ ํ™”๋ฅผ ์œ„ํ•ด์„œ๋Š”, ์ฃผ๋ฅ˜ ์ปดํŒŒ์ผ๋Ÿฌ๊ฐ€ ์ˆ˜ํ–‰ํ•˜๋Š” ๋ณต์žกํ•˜๊ณ ๋„ ํšจ๊ณผ์ ์ธ ์ตœ์ ํ™”๋ฅผ ์ž˜ ์ง€์›ํ•ด์•ผ ํ•œ๋‹ค. ๊ทธ๋Ÿฌ๋‚˜ ์ €์ˆ˜์ค€ ๊ธฐ๋Šฅ๊ณผ ์ปดํŒŒ์ผ๋Ÿฌ ์ตœ์ ํ™”๋ฅผ ๋™์‹œ์— ์ž˜ ์ง€์›ํ•˜๋Š” ์‹คํ–‰์˜๋ฏธ๋Š” ์˜ค๋Š˜๋‚ ๊นŒ์ง€ ์ œ์•ˆ๋œ ๋ฐ”๊ฐ€ ์—†๋‹ค. ๋ณธ ๋ฐ•์‚ฌํ•™์œ„ ๋…ผ๋ฌธ์€ ์‹œ์Šคํ…œ ํ”„๋กœ๊ทธ๋ž˜๋ฐ์—์„œ ์š”๊ธดํ•˜๊ฒŒ ์‚ฌ์šฉ๋˜๋Š” ์ €์ˆ˜์ค€ ๊ธฐ๋Šฅ๊ณผ ์ฃผ์š”ํ•œ ์ปดํŒŒ์ผ๋Ÿฌ ์ตœ์ ํ™”๋ฅผ ์กฐํ™”์‹œํ‚จ๋‹ค. ๊ตฌ์ฒด์ ์œผ๋กœ, ์šฐ๋ฆฐ ๋‹ค์Œ ์„ฑ์งˆ์„ ๋งŒ์กฑํ•˜๋Š” ๋Š์Šจํ•œ ๋™์‹œ์„ฑ, ๋ถ„ํ•  ์ปดํŒŒ์ผ, ์ •์ˆ˜-ํฌ์ธํ„ฐ ๋ณ€ํ™˜์˜ ์‹คํ–‰์˜๋ฏธ๋ฅผ ์ฒ˜์Œ์œผ๋กœ ์ œ์•ˆํ•œ๋‹ค. ์ฒซ์งธ, ๊ธฐ๋Šฅ์ด ์‹œ์Šคํ…œ ํ”„๋กœ๊ทธ๋ž˜๋ฐ์—์„œ ์‚ฌ์šฉ๋˜๋Š” ํŒจํ„ด๊ณผ, ๊ทธ๋Ÿฌํ•œ ํŒจํ„ด์„ ๋…ผ์ฆํ•  ์ˆ˜ ์žˆ๋Š” ๊ธฐ๋ฒ•์„ ์ง€์›ํ•œ๋‹ค. ๋‘˜์งธ, ์ฃผ์š”ํ•œ ์ปดํŒŒ์ผ๋Ÿฌ ์ตœ์ ํ™”๋“ค์„ ์ง€์›ํ•œ๋‹ค. ์šฐ๋ฆฌ๊ฐ€ ์ œ์•ˆํ•œ ์‹คํ–‰์˜๋ฏธ์— ์ž์‹ ๊ฐ์„ ์–ป๊ธฐ ์œ„ํ•ด ์šฐ๋ฆฌ๋Š” ๋…ผ๋ฌธ์˜ ์ฃผ์š” ๊ฒฐ๊ณผ๋ฅผ ๋Œ€๋ถ€๋ถ„ Coq ์ฆ๋ช…๊ธฐ ์œ„์—์„œ ์ฆ๋ช…ํ•˜๊ณ , ๊ทธ ์ฆ๋ช…์„ ๊ธฐ๊ณ„์ ์ด๊ณ  ์—„๋ฐ€ํ•˜๊ฒŒ ํ™•์ธํ–ˆ๋‹ค.To improve the performance of C programs, mainstream compilers perform aggressive optimizations that may change the behaviors of programs that use low-level features in unidiomatic ways. Unfortunately, despite many years of research and industrial efforts, it has proven very difficult to adequately balance the conflicting criteria for low-level features and compiler optimizations in the design of the C programming language. On the one hand, C should support the common usage patterns of the low-level features in systems programming. On the other hand, C should also support the sophisticated and yet effective optimizations performed by mainstream compilers. None of the existing proposals for C semantics, however, sufficiently support low-level features and compiler optimizations at the same time. In this dissertation, we resolve the conflict between some of the low-level features crucially used in systems programming and major compiler optimizations. Specifically, we develop the first formal semantics of relaxed-memory concurrency, separate compilation, and cast between integers and pointers that (1) supports their common usage patterns and reasoning principles for programmers, and (2) provably validates major compiler optimizations at the same time. To establish confidence in our formal semantics, we have formalized most of our key results in the Coq theorem prover, which automatically and rigorously checks the validity of the results.Abstract Acknowledgements Chapter I Prologue Chapter II Relaxed-Memory Concurrency Chapter III Separate Compilation and Linking Chapter IV Cast between Integers and Pointers Chapter V Epilogue ์ดˆ๋กDocto

    Proceedings of the 21st Conference on Formal Methods in Computer-Aided Design โ€“ FMCAD 2021

    Get PDF
    The Conference on Formal Methods in Computer-Aided Design (FMCAD) is an annual conference on the theory and applications of formal methods in hardware and system verification. FMCAD provides a leading forum to researchers in academia and industry for presenting and discussing groundbreaking methods, technologies, theoretical results, and tools for reasoning formally about computing systems. FMCAD covers formal aspects of computer-aided system design including verification, specification, synthesis, and testing

    A feasibility study for advanced technology integration for general aviation

    Get PDF
    An investigation was conducted to identify candidate technologies and specific developments which offer greatest promise for improving safety, fuel efficiency, performance, and utility of general aviation airplanes. Interviews were conducted with general aviation airframe and systems manufacturers and NASA research centers. The following technologies were evaluated for use in airplane design tradeoff studies conducted during the study: avionics, aerodynamics, configurations, structures, flight controls, and propulsion. Based on industry interviews and design tradeoff studies, several recommendations were made for further high payoff research. The most attractive technologies for use by the general aviation industry appear to be advanced engines, composite materials, natural laminar flow airfoils, and advanced integrated avionics systems. The integration of these technologies in airplane design can yield significant increases in speeds, ranges, and payloads over present aircraft with 40 percent to 50 percent reductions in fuel used
    corecore