225,073 research outputs found
Enabling Runtime Self-Coordination of Reconfigurable Embedded Smart Cameras in Distributed Networks
Smart camera networks are real-time distributed embedded systems able to perform computer vision using multiple cameras. This new approach is a confluence of four major disciplines (computer vision, image sensors, embedded computing and sensor networks) and has been subject of intensive work in the past decades. The recent advances in computer vision and network communication, and the rapid growing in the field of high-performance computing, especially using reconfigurable devices, have enabled the design of more robust smart camera systems. Despite these advancements, the effectiveness of current networked vision systems (compared to their operating costs) is still disappointing; the main reason being the poor coordination among cameras entities at runtime and the lack of a clear formalism to dynamically capture and address the self-organization problem without relying on human intervention. In this dissertation, we investigate the use of a declarative-based modeling approach for capturing runtime self-coordination. We combine modeling approaches borrowed from logic programming, computer vision techniques, and high-performance computing for the design of an autonomous and cooperative smart camera. We propose a compact modeling approach based on Answer Set Programming for architecture synthesis of a system-on-reconfigurable-chip camera that is able to support the runtime cooperative work and collaboration with other camera nodes in a distributed network setup. Additionally, we propose a declarative approach for modeling runtime camera self-coordination for distributed object tracking in which moving targets are handed over in a distributed manner and recovered in case of node failure
An approach to compositional reasoning about concurrent objects and futures
Distributed and concurrent object-oriented systems are difficult to analyze due to the complexity of their concurrency, communication, and synchronization mechanisms. Rather than performing analysis at the code level of mainstream objectoriented languages such as Java and C++, we consider an imperative, objectoriented language with a simpler concurrency model. This language, based on concurrent objects communicating by asynchronous method calls and futures, avoids some difficulties of mainstream object-oriented programming languages related to compositionality and aliasing. In particular, reasoning about futures is handled by means of histories. Compositional verification systems facilitate system analysis, allowing components to be analyzed independently of their environment. In this paper, a compositional proof system in dynamic logic for partial correctness is established based on communication histories and class invariants. The soundness and relative completeness of this proof system follow by construction using a transformational approach from a sequential language with a non-deterministic assignment operator
Hierarchical Adaptive Control for Collaborative Manipulation of a Rigid Object by Quadrupedal Robots
Despite the potential benefits of collaborative robots, effective
manipulation tasks with quadruped robots remain difficult to realize. In this
paper, we propose a hierarchical control system that can handle real-world
collaborative manipulation tasks, including uncertainties arising from object
properties, shape, and terrain. Our approach consists of three levels of
controllers. Firstly, an adaptive controller computes the required force and
moment for object manipulation without prior knowledge of the object's
properties and terrain. The computed force and moment are then optimally
distributed between the team of quadruped robots using a Quadratic Programming
(QP)-based controller. This QP-based controller optimizes each robot's contact
point location with the object while satisfying constraints associated with
robot-object contact. Finally, a decentralized loco-manipulation controller is
designed for each robot to apply manipulation force while maintaining the
robot's stability. We successfully validated our approach in a high-fidelity
simulation environment where a team of quadruped robots manipulated an unknown
object weighing up to 18 kg on different terrains while following the desired
trajectory.Comment: Accepted to appear at IEEE/RSJ International Conference on
Intelligent Robots and Systems, IROS, 202
A semi-formal comparison between the Common Object Request Broker Architecture (COBRA) and the Distributed Component Object Model (DCOM)
The way in which application systems and software are built has changed dramatically over the past few
years. This is mainly due to advances in hardware technology, programming languages, as well as the
requirement to build better software application systems in less time. The importance of mondial (worldwide)
communication between systems is also growing exponentially. People are using network-based
applications daily, communicating not only locally, but also globally. The Internet, the global network,
therefore plays a significant role in the development of new software. Distributed object computing is one
of the computing paradigms that promise to solve the need to develop clienVserver application systems,
communicating over heterogeneous environments.
This study, of limited scope, concentrates on one crucial element without which distributed object computing
cannot be implemented. This element is the communication software, also called middleware, which allows
objects situated on different hardware platforms to communicate over a network. Two of the most important
middleware standards for distributed object computing today are the Common Object Request Broker
Architecture (CORBA) from the Object Management Group, and the Distributed Component Object
Model (DCOM) from Microsoft Corporation. Each of these standards is implemented in commercially
available products, allowing distributed objects to communicate over heterogeneous networks.
In studying each of the middleware standards, a formal way of comparing CORBA and DCOM is presented,
namely meta-modelling. For each of these two distributed object infrastructures (middleware), meta-models
are constructed. Based on this uniform and unbiased approach, a comparison of the two distributed object
infrastructures is then performed. The results are given as a set of tables in which the differences and
similarities of each distributed object infrastructure are exhibited. By adopting this approach, errors caused
by misunderstanding or misinterpretation are minimised. Consequently, an accurate and unbiased
comparison between CORBA and DCOM is made possible, which constitutes the main aim of this
dissertation.ComputingM. Sc. (Computer Science
Management of object-oriented action-based distributed programs
Phd ThesisThis thesis addresses the problem of managing the runtime behaviour of distributed
programs. The thesis of this work is that management is fundamentally
an information processing activity and that the object model, as applied to actionbased
distributed systems and database systems, is an appropriate representation
of the management information. In this approach, the basic concepts of classes,
objects, relationships, and atomic transition systems are used to form object
models of distributed programs. Distributed programs are collections of objects
whose methods are structured using atomic actions, i.e., atomic transactions.
Object models are formed of two submodels, each representing a fundamental
aspect of a distributed program. The structural submodel represents a static
perspective of the distributed program, and the control submodel represents a
dynamic perspective of it. Structural models represent the program's objects,
classes and their relationships. Control models represent the program's object
states, events, guards and actions-a transition system. Resolution of queries on
the distributed program's object model enable the management system to control
certain activities of distributed programs.
At a different level of abstraction, the distributed program can be seen as a
reactive system where two subprograms interact: an application program and a
management program; they interact only through sensors and actuators. Sensors
are methods used to probe an object's state and actuators are methods used
to change an object's state. The management program is capable to prod the
application program into action by activating sensors and actuators available at
the interface of the application program. Actions are determined by management
policies that are encoded in the management program. This way of structuring
the management system encourages a clear modularization of application and
management distributed programs, allowing better separation of concerns. Managemental
concerns can be dealt with by the management program, functional
concerns can be assigned to the application program.
The object-oriented action-based computational model adopted by the management
system provides a natural framework for the implementation of faulttolerant
distributed programs. Object orientation provides modularity and extensibility
through object encapsulation. Atomic actions guarantee the consistency of
the objects of the distributed program despite concurrency and failures. Replication
of the distributed program provides increased fault-tolerance by guaranteeing
the consistent progress of the computation, even though some of the replicated
objects can fail.
A prototype management system based on the management theory proposed
above has been implemented atop Arjuna; an object-oriented programming system
which provides a set of tools for constructing fault-tolerant distributed programs. The management system is composed of two subsystems: Stabilis, a
management system for structural information, and Vigil, a management system
for control information. Example applications have been implemented to illustrate
the use of the management system and gather experimental evidence to give
support to the thesis.CNPq (Consellho Nacional de Desenvolvimento Cientifico e Tecnol6gico, Brazil):
BROADCAST (Basic Research On Advanced Distributed Computing: from Algorithms to SysTems)
Time At Your Service: Schedulability Analysis of Real-Time and Distributed Services
The software today is distributed over several processing units. At a large scale this may span over the globe via the internet, or at the micro scale, a software may be distributed on several small processing units embedded in one device. Real-time distributed software and services need to be timely and respond to the requests in time. The Quality of Service of real time software depends on how it schedules its tasks to be executed. The state of the art in programming distributed software, like in Java, the scheduling is left to the underlying infrastructure and in particular the operating system, which is not anymore in the control of the applications. In this thesis, we introduce a software paradigm based on object orientation in which real-time concurrent objects are enabled to specify their own scheduling strategy. We developed high-level formal models for specifying distributed software based on this paradigm in which the quality of service requirements are specified as deadlines on performing and finishing tasks. At this level we developed techniques to verify that these requirements are satisfied. This research has opened the way to a new approach to modeling and analysis of a range of applications such as continuous planning in the context of logistics software in a dynamic environment as well as developing software for multi-core systems. Industrial companies (DEAL services) and research centers (the Uppsala Programming for Multicore Architectures Resrearch Center UPMARC) have already shown interest in the results of this thesis.LEI Universiteit LeidenFoundations of Software Technolog
Expert system decision support for low-cost launch vehicle operations
Progress in assessing the feasibility, benefits, and risks associated with AI expert systems applied to low cost expendable launch vehicle systems is described. Part one identified potential application areas in vehicle operations and on-board functions, assessed measures of cost benefit, and identified key technologies to aid in the implementation of decision support systems in this environment. Part two of the program began the development of prototypes to demonstrate real-time vehicle checkout with controller and diagnostic/analysis intelligent systems and to gather true measures of cost savings vs. conventional software, verification and validation requirements, and maintainability improvement. The main objective of the expert advanced development projects was to provide a robust intelligent system for control/analysis that must be performed within a specified real-time window in order to meet the demands of the given application. The efforts to develop the two prototypes are described. Prime emphasis was on a controller expert system to show real-time performance in a cryogenic propellant loading application and safety validation implementation of this system experimentally, using commercial-off-the-shelf software tools and object oriented programming techniques. This smart ground support equipment prototype is based in C with imbedded expert system rules written in the CLIPS protocol. The relational database, ORACLE, provides non-real-time data support. The second demonstration develops the vehicle/ground intelligent automation concept, from phase one, to show cooperation between multiple expert systems. This automated test conductor (ATC) prototype utilizes a knowledge-bus approach for intelligent information processing by use of virtual sensors and blackboards to solve complex problems. It incorporates distributed processing of real-time data and object-oriented techniques for command, configuration control, and auto-code generation
A Comparison of Kernel Memory Protection for Docker Containers Across Host Operating Systems
Object oriented programming concepts have been widely adopted by the modern design of enterprise applications, which relies on heap memory mapping, and re-use of pre-coded class libraries. Computing resource sharing such as containerization, is a popular way to effectively reduce operation overhead by enlarging the scale of kernel accessibility among distributed computer systems. Thus, proper isolation between processes, containers and host operating systems is a critical task to assure system wide information security. This is a study designed to compare kernel level memory management and protection effectiveness for Docker container systems maintained on top of Ubuntu Linux and Microsoft Windows as the host operating system. Literature research aims to study the fundamentals of kernel memory management designs, policies and modules in place for enforcement. As well as container architectures based on the variation of the host operating systems. The experimental design focuses on whether the discovery of unauthorized access is possible between containers, kernel spaces and file systems. Research results are targeted to determine a better approach for securing Docker container system implementations and code deployment
Implementing concurrency in a process-based language
Object-oriented programming has been very successful for general purpose programming tasks for almost two decades. It is hard to imagine another paradigm replacing it. But software systems are becoming ever more complex and hard to maintain. Adapting to new hardware will create further problems. The current combination of complex scope rules, inheritance, aspects, genericity, and multithreading cannot provide the flexibility needed for the effective implementation, maintenance, and refactoring of parallel and distributed systems. We believe it is time for a change of approach to software development. Software must be modified to match today's needs but must not place even greater strain on software developers. The prevailing software development practice makes management and maintenance of software unnecessarily difficult. We describe an approach that we believe will reduce the difficulties of software development and maintenance. The programming language Erasmus is being developed by Peter Grogono at Concordia University, Canada and Brian Shearing at The Software Factory, UK. Erasmus is based on communicating processes organized within cells that communicate through message passing. This thesis describes issues related to the implementation of concurrency in Erasmus. In particular, it explains how the meaning of a program can be separated from its deployment onto multiprocessor/distributed systems. Through this approach, software investment may be preserved when new features are added or when functionality does not change but the environment doe
- …