221 research outputs found
A metaobject architecture for fault-tolerant distributed systems : the FRIENDS approach
The FRIENDS system developed at LAAS-CNRS is a metalevel architecture providing libraries of metaobjects for fault
tolerance, secure communication, and group-based distributed applications. The use of metaobjects provides a nice separation of concerns between mechanisms and applications. Metaobjects can be used transparently by applications and can be composed according to the needs of a given application, a given architecture, and its underlying properties. In FRIENDS, metaobjects are used recursively to add new properties to applications. They are designed using an object oriented design method and implemented on top of basic system services. This paper describes the FRIENDS software-based architecture, the object-oriented development of metaobjects, the experiments that we have done, and summarizes the advantages and drawbacks of a metaobject approach for building fault-tolerant system
Fault Tolerance as an aspect using JReplica
Reliability and availability are very important trends
in the development process of distributed systems. In order
to improve these features, object replication mechanisms
have been introduced. Programming replication policies
for a given application is not an easy task, and this is the
reason why transparency for the programmer has been one
of the most important properties offered by all replication
models. However, this transparency for the programmer is
not always desirable. In this paper we present a replication
model, JReplica, based on Aspect Oriented Programming
(AOP). JReplica allows the separated specification of the
replication code from the functional behaviour of objects,
providing not only a high degree of transparency, as done
by previous models, but also the possibility for
programmers to introduce new behaviour to specify
different fault tolerance requirements. Moreover, the
replication aspect has been introduced at design time, and
in this way, UML has been extended in order to consider
replication issues separately when designing fault tolerance
systems.ComisiĂłn Interministerial de Ciencia y TecnologĂa TIC99-1083-C02-0
On the use of a reflective architecture to augment Database Management Systems
The Database Management System (DBMS) used to be a commodity software component, with well known standard interfaces and semantics. However, the performance and reliability expectations being placed on DBMSs have increased the demand for a variety add-ons, that augment the functionality of the database in a wide range of deployment scenarios, offering support for features such as clustering, replication, and selfmanagement, among others. The effectiveness of such extensions largely rests on closely matching the actual needs of applications, hence on a wide range of tradeoffs and configuration options out of the scope of traditional client interfaces. A well known software engineering approach to systems with such requirements is reflection. Unfortunately, standard reflective interfaces in DBMSs are very limited (for instance, they often do not support the desired range of atomicity guarantees in a distributed setting). Some of these limitations may be circumvented by implementing reflective features as a wrapper to the DBMS server. Unfortunately, this solutions comes at the expense of a large development effort and significant performance penalty. In this paper we propose a general purpose DBMS reflection architecture and interface, that supports multiple extensions while, at the same time, admitting efficient implementations. We illustrate the usefulness of our proposal with concrete examples, and evaluate its cost and performance under different implementation strategies
Automating the construction of replicated objects in a cluster of workstations
This paper describes a tool that mimics the design of the remote procedure call (RPC) system to support the building of replicated objects in a cluster of workstations (COW). The tool includes an interface definition language for describing a replica group, a language preprocessor and a runtime library system. The paper also presents one example and discusses some performance issues for replicated objects. <br /
High Speed Data Cryptography Technique of Blowfish Algorithm using VHDL
Nowadays, information security is more important issue for reliable data transfer. A cryptographic method is widely used to ensure the security of data. To keep the information from being hacked by the other party, data is encoded by using this method. To meet these requirements the implementation of the Blowfish algorithm in the commercial FPGA has can be used to obtain high performance of such FPGA based reconfigurable systems. This paper presents, how such a system can be used to enhance the speed of cryptographic computation. By using FPGA design, the Blowfish computation can be increased in speed. In this, Xilinx software is used for the analysis purpose. The results will lead to the general conclusion that the use of an FPGA coprocessor is ideally suited for the execution of cryptographic algorithms regarding execution time and flexible usage. The performance is analyzed in terms of its architecture, speed, throughput, and encryption time
What is so (Un)Exceptional About Soviet Cinema? The Pragmatics of Soviet Film Exports to Germany and France in the 1920s
The article discusses Soviet efforts to export its cinematic production to Germany and France during the 1920s. Aside from advertising the USSR’s achievements abroad, cinema export was an important contribution to early Soviet fund-raising strategies. By examining the opening of the Soviet film industry to international practices and contacts, this article seeks to challenge some assumptions of Soviet particularism in the field of its film export practices. The article begins by exploring the international roots of what was about to become the Soviet film industry and demonstrates how Soviet trade practitioners sought to benefit from them. Then, the article argues that despite several country-specific organisational and material constraints, Soviet strategies and methods of film export to Germany and France paralleled in many ways those of their Western counterparts.The article discusses Soviet the efforts to export its cinematic production to Germany and France during the 1920s. Aside from advertising the USSR’s achievements abroad, cinema export was an important contribution to early Soviet fund-raising strategies. By examining the opening of the Soviet film industry to international practices and contacts, this article seeks to challenge some assumptions of Soviet particularism in the field of its film export practices. The article begins by exploring the international roots of what was about to become the Soviet film industry and demonstrates how Soviet trade practitioners sought to benefit from them. Then, the article argues that despite several country-specific organisational and material constraints, Soviet strategies and methods of film export to Germany and France paralleled in many ways those of their Western counterparts
BClean: A Bayesian Data Cleaning System
There is a considerable body of work on data cleaning which employs various
principles to rectify erroneous data and transform a dirty dataset into a
cleaner one. One of prevalent approaches is probabilistic methods, including
Bayesian methods. However, existing probabilistic methods often assume a
simplistic distribution (e.g., Gaussian distribution), which is frequently
underfitted in practice, or they necessitate experts to provide a complex prior
distribution (e.g., via a programming language). This requirement is both
labor-intensive and costly, rendering these methods less suitable for
real-world applications. In this paper, we propose BClean, a Bayesian Cleaning
system that features automatic Bayesian network construction and user
interaction. We recast the data cleaning problem as a Bayesian inference that
fully exploits the relationships between attributes in the observed dataset and
any prior information provided by users. To this end, we present an automatic
Bayesian network construction method that extends a structure learning-based
functional dependency discovery method with similarity functions to capture the
relationships between attributes. Furthermore, our system allows users to
modify the generated Bayesian network in order to specify prior information or
correct inaccuracies identified by the automatic generation process. We also
design an effective scoring model (called the compensative scoring model)
necessary for the Bayesian inference. To enhance the efficiency of data
cleaning, we propose several approximation strategies for the Bayesian
inference, including graph partitioning, domain pruning, and pre-detection. By
evaluating on both real-world and synthetic datasets, we demonstrate that
BClean is capable of achieving an F-measure of up to 0.9 in data cleaning,
outperforming existing Bayesian methods by 2% and other data cleaning methods
by 15%.Comment: Our source code is available at https://github.com/yyssl88/BClea
Étude de l'invocation entre objets dupliqués dans un système réparti tolérant aux fautes
This dissertation studies the problems to solve in order to use the invocation paradigm to express replicated object communication in fault-tolerant distributed systems. The ultimate goal is to define abstractions which achieve replication encapsulation, ie which give the illusion that replication is an internal property of objects. Thus, object communication could be always expressed using the invocation paradigm, whether objects are replicated or not. Background The invocation paradigm defines a "request-reply" communication model which matches exactly the client-server model. The latter is generally used to express service interactions in distributed systems. For this reason, the object-oriented approach is well suited to the design of distributed system services. A service can be implemented as a set of objects, located on remote computers (or nodes). Service fault-tolerance is achieved by replicating the objects which implement the service. Most of the previous works about replicated objects consider only server object replication. This study is more general: both client and server can be replicated. Furthermore, replication policies of objects can be different. Four replication policies had been studied: active replication, passive replication, semi-active replication, and coordinator-cohort replication. Replication encapsulation Replication encapsulation means both plurality encapsulation and replication policy encapsulation. Plurality encapsulation consists in hiding from other objects, that a replicated object is actually a set of replicas located on several nodes. Replication policy encapsulation consists in hiding from other objects, the communication protocol to use in order to interact with object replicas without breaking their consistency. The symmetric invocation model Most of the related works are based on an asymmetric invocation model. In this model, the invocation reply follows exactly the reverse of the request communication path. The asymmetric invocation model can not be used to achieve replication encapsulation of client objects. This dissertation proposes a symmetric invocation model which solves this problem. The symmetric invocation model considers the request transmission and the reply transmission as two instances of the same problem: the transmission of a message to a replicated object. Both the analysis of the replication encapsulation problem and the symmetric invocation model were used to define a specification of replicated object invocation. This specification is a set of generic formal properties based on parameters which values depend on replication policies. The properties include object failure semantics which is expressed using the group paradigm and the view-synchronous communication paradigm. Every replicated object is built using an object group which membership changes whenever object replicas fail or restart. The N2M invocation service The main result of this study is the design1 of N2M, an invocation service which supports replicated objects. Objects using N2M are called application objects whereas objects implementing N2M are called communication objects. Communication objects take care of every aspect related to application object replication. Thus, replicated application objects communicate using regular invocations, just as if they were not replicated. There are actually two kinds of communication objects: encapsulators and mailers. Each replicated application object is built using an encapsulator group. Each application object replica is associated with a private encapsulator which acts as an invocation filter for this replica. To communicate with a replicated application object O, every object must interact with O's local mailer. On every node, a replicated application object is represented by a mailer which is responsible for transmitting requests and replies to the application object replicas. The originality of this model is its symmetry: there are both mailers of the server on the client nodes, and mailers of the client on the server nodes. This symmetry is directly inherited from the symmetric invocation model. Each replication policy is implemented using an encapsulator class and a mailer class. These classes replicate objects according to a specific replication policy, while respecting the invocation paradigm. In other words, communication object classes achieve replication encapsulation. The GARF-v2 programming environment The N2M service has been implemented in the context of the GARF project2. The GARF project aimed to provide a programming environment which faciltates the design of fault-tolerant distributed applications. The environment prototype was implemented in Smalltalk. It is based on the group communication layer provided by ISIS toolkit. --------------------------------------- Â Â 1this logo refers to the n to m expression which usually names the interaction between n client replicas and m server replicas. Â Â 2GARF is the french acronym for automatic generation of fault-tolerant applications
- …