654 research outputs found
Maintaining consistency in distributed systems
In systems designed as assemblies of independently developed components, concurrent access to data or data structures normally arises within individual programs, and is controlled using mutual exclusion constructs, such as semaphores and monitors. Where data is persistent and/or sets of operation are related to one another, transactions or linearizability may be more appropriate. Systems that incorporate cooperative styles of distributed execution often replicate or distribute data within groups of components. In these cases, group oriented consistency properties must be maintained, and tools based on the virtual synchrony execution model greatly simplify the task confronting an application developer. All three styles of distributed computing are likely to be seen in future systems - often, within the same application. This leads us to propose an integrated approach that permits applications that use virtual synchrony with concurrent objects that respect a linearizability constraint, and vice versa. Transactional subsystems are treated as a special case of linearizability
Atomic-SDN: Is Synchronous Flooding the Solution to Software-Defined Networking in IoT?
The adoption of Software Defined Networking (SDN) within traditional networks
has provided operators the ability to manage diverse resources and easily
reconfigure networks as requirements change. Recent research has extended this
concept to IEEE 802.15.4 low-power wireless networks, which form a key
component of the Internet of Things (IoT). However, the multiple traffic
patterns necessary for SDN control makes it difficult to apply this approach to
these highly challenging environments. This paper presents Atomic-SDN, a highly
reliable and low-latency solution for SDN in low-power wireless. Atomic-SDN
introduces a novel Synchronous Flooding (SF) architecture capable of
dynamically configuring SF protocols to satisfy complex SDN control
requirements, and draws from the authors' previous experiences in the IEEE EWSN
Dependability Competition: where SF solutions have consistently outperformed
other entries. Using this approach, Atomic-SDN presents considerable
performance gains over other SDN implementations for low-power IoT networks. We
evaluate Atomic-SDN through simulation and experimentation, and show how
utilizing SF techniques provides latency and reliability guarantees to SDN
control operations as the local mesh scales. We compare Atomic-SDN against
other SDN implementations based on the IEEE 802.15.4 network stack, and
establish that Atomic-SDN improves SDN control by orders-of-magnitude across
latency, reliability, and energy-efficiency metrics
System Support for Bandwidth Management and Content Adaptation in Internet Applications
This paper describes the implementation and evaluation of an operating system
module, the Congestion Manager (CM), which provides integrated network flow
management and exports a convenient programming interface that allows
applications to be notified of, and adapt to, changing network conditions. We
describe the API by which applications interface with the CM, and the
architectural considerations that factored into the design. To evaluate the
architecture and API, we describe our implementations of TCP; a streaming
layered audio/video application; and an interactive audio application using the
CM, and show that they achieve adaptive behavior without incurring much
end-system overhead. All flows including TCP benefit from the sharing of
congestion information, and applications are able to incorporate new
functionality such as congestion control and adaptive behavior.Comment: 14 pages, appeared in OSDI 200
์ฌ์ด๋ฒ ๋ฌผ๋ฆฌ ์์คํ ์ ์ํ PALSware ์์คํ ์๋ฐ ๊ฒ์ฆ ํ๋ ์์ํฌ
ํ์๋
ผ๋ฌธ(๋ฐ์ฌ) -- ์์ธ๋ํ๊ต๋ํ์ : ๊ณต๊ณผ๋ํ ์ ๊ธฐยท์ปดํจํฐ๊ณตํ๋ถ, 2021.8. ๊น์ค์น.Achieving high-level safety guarantees for cyber-physical systems has always been
a key challenge, since many of those systems are safety-critical so that their failures
in the actual operation may bring catastrophic results. Many cyber-physical systems
have real-time and distributed features, which increase the complexity of the system
an order of magnitude higher.
In order to tame the complexity, a middleware called PALSware has been pro-
posed. It provides a logically synchronous environment to the application layer on
top of physically asynchronous underlying network and operating systems. The com-
plexity of a system can be significantly reduced in a synchronous environment.
However, a bug in PALSware may have destructive effects since it exposes every
application system to runtime failures. Moreover, finding bugs in PALSware can be
very challenging in some cases, for various reasons.
To solve this problem, we present VeriPALS, a formally verified C implementation
of PALSware together with a verification framework for application systems. Espe-
cially, the framework provides an executable model as an efficient random testing
tool. As case studies, we developed two application systems, and applied VeriPALS
to demonstrate effectiveness of the framework in both testing and formal verification.์ฌ์ด๋ฒ ๋ฌผ๋ฆฌ ์์คํ
์ ์์ ์ฑ์ ๋์ด๋ ์ผ์ ํญ์ ์ค์ํ ์ฐ๊ตฌ ์ฃผ์ ๊ฐ ๋์ด์๋ค. ๊ทธ ์ด์
๋ ๋ง์ ์ฌ์ด๋ฒ ๋ฌผ๋ฆฌ ์์คํ
์ด ์์ ์ฐ์ ์์คํ
์ด๊ธฐ ๋๋ฌธ์ธ๋ฐ, ์ด๋ ์ค์ ์์คํ
๊ตฌ๋
์ค์ ์ค๋ฅ๊ฐ ๋ฐ์ํ ๊ฒฝ์ฐ ํฐ ์ฌ๊ณ ๋ก ์ง๊ฒฐ๋ ์ ์์์ ์๋ฏธํ๋ค. ๋์ฑ์ด, ์ฌ์ด๋ฒ ๋ฌผ๋ฆฌ
์์คํ
์ด ๊ฐ์ง๋ ์ค์๊ฐ์ฑ, ๋ถ์ฐ์ฑ์ด ์์คํ
์ ๋ณต์ก๋๋ฅผ ๋์ฌ ์ํ์ฑ์ ์ฆ๊ฐ์ํค๋ฏ๋ก
์์ ์ฑ์ ๋์ด๋ ์ผ์ ๋งค์ฐ ์ค์ํ๋ค.
์์คํ
์ ๋ณต์ก๋ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด, PALSware๋ผ๋ ๋ฏธ๋ค์จ์ด๊ฐ ๊ณ ์๋์๋ค. ์ด
๋ฏธ๋ค์จ์ด๋ ๋น๋๊ธฐ์์ผ๋ก ๋์ํ๋ ๋คํธ์ํฌ์ ์ด์์ฒด์ ํ๊ฒฝ ์์์ ๊ฐ์์ ๋๊ธฐ์ ํ
๊ฒฝ์ ์ ํ๋ฆฌ์ผ์ด์
์ธต์ ์ ๊ณตํ๋ ์ญํ ์ ํ๋ค. PALSware๋ฅผ ์ฌ์ฉํ๋ฉด ์์คํ
์ ๋๊ธฐ์
ํ๊ฒฝ์์ ๋์์ธํ ์ ์๊ฒ ๋์ด, ์์คํ
์ ๋ณต์ก๋๋ฅผ ํฌ๊ฒ ๋ฎ์ถ๋ ๊ฒ์ด ๊ฐ๋ฅํด์ง๋ค.
ํ์ง๋ง, PALSware์ ๋ฒ๊ทธ๊ฐ ์์ ๊ฒฝ์ฐ ๊ทธ ์
์ํฅ์ด ๋งค์ฐ ํฌ๊ฒ ๋ํ๋ ์ ์๋ค. ์ฐ์
์ด ๋ฏธ๋ค์จ์ด๋ฅผ ์ฌ์ฉํ๋ ๋ชจ๋ ์ ํ๋ฆฌ์ผ์ด์
์์คํ
์ ๋ฒ๊ทธ๊ฐ ์กด์ฌํ๊ฒ ๋๋ค. ๋ํ, ๋ฏธ๋ค
์จ์ด์ ๋ฒ๊ทธ๋ฅผ ์ฐพ๋ ์ผ์ ์ผ๋ฐ ํ๋ก๊ทธ๋จ์ ๋ฒ๊ทธ๋ฅผ ์ฐพ๋ ๊ฒ๋ณด๋ค ๋งค์ฐ ์ด๋ ค์ด ๋ฌธ์ ๊ฐ ๋
์ ์๋ค.
์ด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด, ์ฐ๋ฆฌ๋ VeriPALS๋ผ๋ ํ๋ ์์ํฌ๋ฅผ ๊ฐ๋ฐํ์๋ค. ์ด ํ๋
์์ํฌ๋ ์ํ์ ์ผ๋ก ์๋ฐํ๊ฒ ๊ฒ์ฆํ PALSware์ C ๊ตฌํ์ฒด๋ฅผ ํฌํจํ๊ณ ์์ด ์์ ํ
์์คํ
๊ตฌํ์ ๋๋๋ค. ๋ํ, ์ ํ๋ฆฌ์ผ์ด์
์์คํ
์ Coq ์์์ ์ํ์ ์ผ๋ก ์๋ฐํ
๊ฒ์ฆํ ์ ์๋ ๊ธฐ๋ฅ์ ์ง์ํ๋ค. ๋ ๋์๊ฐ์, ์ด ํ๋ ์์ํฌ๋ ์คํ ๊ฐ๋ฅํ ๋ชจ๋ธ์
ํจ์จ์ ์ธ ๋๋ค ํ
์คํ
ํด๋ก์ ์ ๊ณตํ๋ค. ์ฐ๋ฆฌ๋ ์ด ํ๋ ์์ํฌ ์์์ ๋ ์ข
๋ฅ์ ์ ํ๋ฆฌ
์ผ์ด์
์์คํ
์ ๊ฐ๋ฐํ๊ณ ํ
์คํ
๋ฐ ์๋ฐ ๊ฒ์ฆํ์ฌ ์ด ํ๋ ์์ํฌ์ ์ ์ฉ์ฑ์ ๋ณด์๋ค.Chapter 1 Introduction 1
Chapter 2 Preliminaries 8
2.1 PALSware 8
2.1.1 PALSware in A Distributed System 9
2.1.2 Correctness of Synchronization on Reliable Network 10
2.1.3 Implementation of PALSware 11
2.2 Interaction Trees 14
Chapter 3 Overview 16
3.1 Framework 16
3.2 Key Ideas 21
3.2.1 Concurrent Executions of Nodes 21
3.2.2 Global Clock vs. Local Clock 22
3.2.3 Real-time Local Executions of Node Model 23
3.2.4 Time Constraint on Network Transmission Times 24
3.2.5 Time Constraint on Program Executions 25
3.2.6 Observable Behaviors of a Real-Time Distributed System 26
Chapter 4 Formalization 28
4.1 General Definitions 28
4.2 Application System of the Framework 31
4.3 Real-World Model 34
4.3.1 Network Model 34
4.3.2 Generic System Model On Network 35
4.3.3 Operating System Model 37
4.4 Executable Abstract Synchrous Model 41
4.5 Result 42
Chapter 5 Refinement Proof using Intermediate Models 44
5.1 Refinement 1: Abstraction of C programs 44
5.2 Refinement 2: Abstract PALSware 47
5.3 Refinement 3: Abstraction of Network 48
5.4 Refinement 4: Synchronous Execution 51
5.5 Refinement 5: Making It Executable 54
Chapter 6 Case Study 1: Active-Standby Resource Scheduling System 55
6.1 High-Level Description 56
6.2 Implementation 59
6.3 Formally Verified Properties 62
6.3.1 Correctness of Implementation 62
6.3.2 Abstraction To Single-Controller System 63
Chapter 7 Case Study 2: Synchronous Work Assignment System 68
7.1 High-Level Description 69
7.2 Implementation 70
Chapter 8 Results 75
8.1 Development 75
8.2 Experimental Results 77
Chapter 9 Related Work 80
9.1 PALS Pattern and PALSware Verification 80
9.2 Verification Frameworks for Distributed Systems 81
9.3 Verifying C Programs 83
Chapter 10 Conclusion and Future Work 85
Bibliography 88
์ด๋ก 92
Acknowledgements 93๋ฐ
Distributed Programming with Shared Data
Until recently, at least one thing was clear about parallel programming: tightly coupled (shared memory) machines were programmed in a language based on shared variables and loosely coupled (distributed) systems were programmed using message passing. The explosive growth of research on distributed systems and their languages, however, has led to several new methodologies that blur this simple distinction. Operating system primitives (e.g., problem-oriented shared memory, Shared Virtual Memory, the Agora shared memory) and languages (e.g., Concurrent Prolog, Linda, Emerald) for programming distributed systems have been proposed that support the shared variable paradigm without the presence of physical shared memory. In this paper we will look at the reasons for this evolution, the resemblances and differences among these new proposals, and the key issues in their design and implementation. It turns out that many implementations are based on replication of data. We take this idea one step further, and discuss how automatic replication (initiated by the run time system) can be used as a basis for a new model, called the shared data-object model, whose semantics are similar to the shared variable model. Finally, we discuss the design of a new language for distributed programming, Orca, based on the shared data-object model. 1
Programming Languages for Distributed Computing Systems
When distributed systems first appeared, they were programmed in traditional sequential languages, usually with the addition of a few library procedures for sending and receiving messages. As distributed applications became more commonplace and more sophisticated, this ad hoc approach became less satisfactory. Researchers all over the world began designing new programming languages specifically for implementing distributed applications. These languages and their history, their underlying principles, their design, and their use are the subject of this paper. We begin by giving our view of what a distributed system is, illustrating with examples to avoid confusion on this important and controversial point. We then describe the three main characteristics that distinguish distributed programming languages from traditional sequential languages, namely, how they deal with parallelism, communication, and partial failures. Finally, we discuss 15 representative distributed languages to give the flavor of each. These examples include languages based on message passing, rendezvous, remote procedure call, objects, and atomic transactions, as well as functional languages, logic languages, and distributed data structure languages. The paper concludes with a comprehensive bibliography listing over 200 papers on nearly 100 distributed programming languages
Towards formal models and languages for verifiable Multi-Robot Systems
Incorrect operations of a Multi-Robot System (MRS) may not only lead to
unsatisfactory results, but can also cause economic losses and threats to
safety. These threats may not always be apparent, since they may arise as
unforeseen consequences of the interactions between elements of the system.
This call for tools and techniques that can help in providing guarantees about
MRSs behaviour. We think that, whenever possible, these guarantees should be
backed up by formal proofs to complement traditional approaches based on
testing and simulation.
We believe that tailored linguistic support to specify MRSs is a major step
towards this goal. In particular, reducing the gap between typical features of
an MRS and the level of abstraction of the linguistic primitives would simplify
both the specification of these systems and the verification of their
properties. In this work, we review different agent-oriented languages and
their features; we then consider a selection of case studies of interest and
implement them useing the surveyed languages. We also evaluate and compare
effectiveness of the proposed solution, considering, in particular, easiness of
expressing non-trivial behaviour.Comment: Changed formattin
- โฆ