scholarly journals Strict Linearizability and Abstract Atomicity

2021 ◽  
pp. 1-35
Author(s):  
Tangliu Wen ◽  
Jie Peng ◽  
Jinyun Xue ◽  
Zhen You ◽  
Lan Song
Keyword(s):  
Consistency Condition ◽  
Abstract Data Type ◽  
Final States ◽  
Correctness Criterion ◽  
Internal States ◽  
Abstract Data ◽  
Concurrent Objects ◽  
High Level ◽  
Client Side ◽  
Client Program

Linearizability is a commonly accepted consistency condition for concurrent objects. Filipović et al. show that linearizability is equivalent to observational refinement. However, linearizability does not permit concurrent objects to share memory spaces with their client programs. We show that linearizability (or observational refinement) can be broken even though a client program of an object accesses the shared memory spaces without interleaving with the methods of the object. In this paper, we present strict linearizability which lifts this limitation and can ensure client-side traces and final-states equivalence even in a relaxed program model allowing clients to directly access the internal states of concurrent objects. We also investigate several important properties of strict linearizability. At a high level of abstraction, a concurrent object can be viewed as a concurrent implementation of an abstract data type (ADT). We also present a correctness criterion for relating an ADT and its concurrent implementation, which is the combination of linearizability and data abstraction and can ensure observational equivalence. We also investigate its relationship with strict linearizability.

Towards a New Semantic Metric for Error Detection Based on Program State Redundancy

2021 ◽  
Vol 11 (2) ◽  
pp. 1-23
Author(s):  
Dalila Amara Amara ◽  
Latifa Ben Arfa Rabai
Keyword(s):  
Fault Tolerance ◽  
Empirical Study ◽  
Error Detection ◽  
Final States ◽  
Internal States ◽  
Common Concept ◽  
Program Redundancy ◽  
Semantic Metrics

Fault tolerance techniques are generally based around a common concept that is redundancy whose measurement is required. A suite of four semantic metrics is proposed to assess program redundancy and reflect their ability to tolerate faults. Literature shows that one of these metrics, namely state redundancy, is limited to compute program redundancy only in their initial and final states and ignores their internal states. Consequently, the authors focus in this paper to overcome this shortcoming by proposing a new redundancy-based semantic metric that computes the redundancy of the different program states including internal ones. The empirical study they perform shows that the proposed metric is a measure of program redundancy in one side and is an error detection indicator in another side. Moreover, they demonstrate that it is more accurate than the basic state redundancy metric in detecting masked errors. It is useful for testers to indicate if a tested program is error-free and to pinpoint the presence of masked errors even if the final states are equal to the expected ones.

scholarly journals Towards Analysis-Driven Scientific Software Architecture: The Case for Abstract Data Type Calculus

2008 ◽  
Vol 16 (4) ◽  
pp. 329-339 ◽  
Author(s):  
Damian W.I. Rouson
Keyword(s):  
Software Architecture ◽  
Search Strategy ◽  
Object Oriented ◽  
New Physics ◽  
Data Type ◽  
Abstract Data Type ◽  
Scientific Software ◽  
Code Size ◽  
Design Metrics ◽  
Abstract Data

This article approaches scientific software architecture from three analytical paths. Each path examines discrete time advancement of multiphysics phenomena governed by coupled differential equations. The new object-oriented Fortran 2003 constructs provide a formal syntax for an abstract data type (ADT) calculus. The first analysis uses traditional object-oriented software design metrics to demonstrate the high cohesion and low coupling associated with the calculus. A second analysis from the viewpoint of computational complexity theory demonstrates that a more representative bug search strategy than that considered by Rouson et al. (ACM Trans. Math. Soft.34(1) (2008)) reduces the number of lines searched in a code with λ total lines from O(λ2) to O(λ log2λ ), which in turn becomes nearly independent of the overall code size in the context of ADT calculus. The third analysis derives from information theory an argument that ADT calculus simplifies developer communications in part by minimizing the growth in interface information content as developers add new physics to a multiphysics package.

scholarly journals Tree-Shaped Formats of Address Programming Language

2021 ◽  
Vol 4 ◽  
pp. 78-87
Author(s):  
Yury Yuschenko
Keyword(s):  
Programming Languages ◽  
Programming Language ◽  
Theoretical Research ◽  
Direct Access ◽  
Complex Data ◽  
Abstract Data Types ◽  
Data Types ◽  
Abstract Data ◽  
The One ◽  
High Level

In the Address Programming Language (1955), the concept of indirect addressing of higher ranks (Pointers) was introduced, which allows the arbitrary connection of the computer’s RAM cells. This connection is based on standard sequences of the cell addresses in RAM and addressing sequences, which is determined by the programmer with indirect addressing. Two types of sequences allow programmers to determine an arbitrary connection of RAM cells with the arbitrary content: data, addresses, subroutines, program labels, etc. Therefore, the formed connections of cells can relate to each other. The result of connecting cells with the arbitrary content and any structure is called tree-shaped formats. Tree-shaped formats allow programmers to combine data into complex data structures that are like abstract data types. For tree-shaped formats, the concept of “review scheme” is defined, which is like the concept of “bypassing” trees. Programmers can define multiple overview diagrams for the one tree-shaped format. Programmers can create tree-shaped formats over the connected cells to define the desired overview schemes for these connected cells. The work gives a modern interpretation of the concept of tree-shaped formats in Address Programming. Tree-shaped formats are based on “stroke-operation” (pointer dereference), which was hardware implemented in the command system of computer “Kyiv”. Group operations of modernization of computer “Kyiv” addresses accelerate the processing of tree-shaped formats and are designed as organized cycles, like those in high-level imperative programming languages. The commands of computer “Kyiv”, due to operations with indirect addressing, have more capabilities than the first high-level programming language – Plankalkül. Machine commands of the computer “Kyiv” allow direct access to the i-th element of the “list” by its serial number in the same way as such access is obtained to the i-th element of the array by its index. Given examples of singly linked lists show the features of tree-shaped formats and their differences from abstract data types. The article opens a new branch of theoretical research, the purpose of which is to analyze the expe- diency of partial inclusion of Address Programming in modern programming languages.

The Formal Design Model of a File Management System (FMS)

2013 ◽  
pp. 193-213
Author(s):  
Yingxu Wang ◽  
Cyprian F. Ngolah ◽  
Xinming Tan ◽  
Yousheng Tian ◽  
Phillip C.Y. Sheu
Keyword(s):  
Real Time ◽  
Management System ◽  
Data File ◽  
Abstract Data Type ◽  
Behavioral Models ◽  
Software Modeling ◽  
File Management ◽  
Abstract Data ◽  
Data Objects ◽  
Formal Design

Files are a typical abstract data type for data objects and software modeling, which provides a standard encapsulation and access interface for manipulating large-volume information and persistent data. File management systems are an indispensable component of operating systems and real-time systems for file manipulations. This paper develops a comprehensive design pattern of files and a File Management System (FMS). A rigorous denotational mathematics, Real-Time Process Algebra (RTPA), is adopted, which allows both architectural and behavioral models of files and FMS to be rigorously designed and implemented in a top-down approach. The conceptual model, architectural model, and the static/dynamic behavioral models of files and FMS are systematically presented. This work has been applied in the design and modeling of a real-time operating system (RTOS+).

Modeling and Language Support for the Pattern Management

2017 ◽  
pp. 86-106 ◽  
Author(s):  
Zdenka Telnarova
Keyword(s):  
Query Language ◽  
General Pattern ◽  
Specific Pattern ◽  
Data Type ◽  
Abstract Data Type ◽  
Crucial Issue ◽  
Simple Scheme ◽  
Language Support ◽  
Abstract Data ◽  
Query Patterns

Patterns are mentioned usually in the extraction context. Little stress is posed in their representation and management. This chapter is focused on the representation of the patterns, manipulation with patterns and query patterns. Crucial issue can be seen in systematic approach to pattern management and specific pattern query language which takes into consideration semantics of patterns. In the background we discuss two different approaches to the pattern store and manipulation (based on inductive database and PANDA project). General pattern model is illustrated using abstract data type implemented in Oracle. In the following chapters the introduction to querying patterns and simple scheme of the architecture PBMS is shown.

Sign in / Sign up

Export Citation Format

Share Document