A Functional Architecture Approach to Neural Systems

The technology for the design of systems to perform extremely complex combinations of real-time functionality has developed over a long period. This technology is based on the use of a hardware architecture with a physical separation into memory and processing, and a software architecture which divides functionality into a disciplined hierarchy of software components which exchange unambiguous information. This technology experiences difficulty in design of systems to perform parallel processing, and extreme difficulty in design of systems which can heuristically change their own functionality. These limitations derive from the approach to information exchange between functional components. A design approach in which functional components can exchange ambiguous information leads to systems with the recommendation architecture which are less subject to these limitations. Biological brains have been constrained by natural pressures to adopt functional architectures with this different information exchange approach. Neural networks have not made a complete shift to use of ambiguous information, and do not address adequate management of context for ambiguous information exchange between modules. As a result such networks cannot be scaled to complex functionality. Simulations of systems with the recommendation architecture demonstrate the capability to heuristically organize to perform complex functionality

Software-based fault-tolerant routing algorithm in multidimensional networks

Massively parallel computing systems are being built with hundreds or thousands of components such as nodes, links, memories, and connectors. The failure of a component in such systems will not only reduce the computational power but also alter the network's topology. The software-based fault-tolerant routing algorithm is a popular routing to achieve fault-tolerance capability in networks. This algorithm is initially proposed only for two dimensional networks (Suh et al., 2000). Since, higher dimensional networks have been widely employed in many contemporary massively parallel systems; this paper proposes an approach to extend this routing scheme to these indispensable higher dimensional networks. Deadlock and livelock freedom and the performance of presented algorithm, have been investigated for networks with different dimensionality and various fault regions. Furthermore, performance results have been presented through simulation experiments

Modeling and sizing of large PV-diesel hybrid systems without energy storage

This paper describes the modelling of components and control strategies for PV-diesel hybrid systems without energy storage, which have been implemented in an online and free-software simulator of PV systems called SISIFO, which is publicly available at www.sisifo.info. Among other features, this software tool allows the prediction of fuel savings for different sizes and types of PV generators, the comparison of selected control strategies and the evaluation of the spinning reserve requirements in systems with multiple diesel generators operating in parallel

Reliability Estimation Model for Software Components Using CEP

This paper presents a graphical complexity measure based approach with an illustration for estimating the reliability of software component. This paper also elucidates how the graph-theory concepts are applied in the field of software programming. The control graphs of several actual software components are described and the correlation between intuitive complexity and the graph-theoretic complexity are illustrated. Several properties of the graph theoretic complexity are presented which shows that the software component complexity depends only on the decision structure. A symbolic reliability model for component based software systems from the execution path of software components connected in series, parallel or mixed configuration network structure is presented with a crisp narration of the factors which influence computation of the overall reliability of component based software systems. In this paper, reliability estimation model for software components using Component Execution Paths (CEP) based on graph theory is elucidated

Instructional Software for Reliability Estimation and Fault Tree Analysis

This paper describes a software tool to introduce fundamental concepts of reliability and fault tree analysis to engineering students.  Students can fit common failure distributions to failure data.  The data can be complete, singly censored, or multiply censored.  The software computes distribution and goodness-of-fit parameters.  The students can use the tool to validate hand calculations.  Failure distributions and reliability values for various components can be identified and stored in a database.  Various components and sub-systems can be used to build series- parallel or complex systems.  The components data can also be used to build fault trees.  The software tool can compute reliability of complex state independent and state dependent systems.  The tool can also be used to compute failure probability of the top node of a fault tree.  The software was implemented in Visual Basic with SQL as the database.  It operates on the Windows 7 platform

Edgar : a platform for hardware/software codesign

Codesign is a unified methodology to develop complex systems with hardware and software components. EDgAR, a platform for hardware/software codesign is described, which is intended to prototype complex digital systems. It employs programmable logic devices (MACHs and FPGAs) and a transputer-based parallel architecture. This platform and its associated methodology reduce the systems production cost, decreasing the time for the design and the test of the prototypes. The EDgAR supporting tools are introduced, which were conceived to specify systems at an high-level of abstraction, with a standard language and to allow a high degree of automation on the synthesis process. This platform was used to emulate an integrated circuit for image processing purposes

Fault-Tolerant Adaptive Parallel and Distributed Simulation

Discrete Event Simulation is a widely used technique that is used to model and analyze complex systems in many fields of science and engineering. The increasingly large size of simulation models poses a serious computational challenge, since the time needed to run a simulation can be prohibitively large. For this reason, Parallel and Distributes Simulation techniques have been proposed to take advantage of multiple execution units which are found in multicore processors, cluster of workstations or HPC systems. The current generation of HPC systems includes hundreds of thousands of computing nodes and a vast amount of ancillary components. Despite improvements in manufacturing processes, failures of some components are frequent, and the situation will get worse as larger systems are built. In this paper we describe FT-GAIA, a software-based fault-tolerant extension of the GAIA/ART\`IS parallel simulation middleware. FT-GAIA transparently replicates simulation entities and distributes them on multiple execution nodes. This allows the simulation to tolerate crash-failures of computing nodes; furthermore, FT-GAIA offers some protection against byzantine failures since synchronization messages are replicated as well, so that the receiving entity can identify and discard corrupted messages. We provide an experimental evaluation of FT-GAIA on a running prototype. Results show that a high degree of fault tolerance can be achieved, at the cost of a moderate increase in the computational load of the execution units.Comment: Proceedings of the IEEE/ACM International Symposium on Distributed Simulation and Real Time Applications (DS-RT 2016

State machines for large scale computer software and systems

A method for specifying the behavior and architecture of discrete state systems such as digital electronic devices and software using deterministic state machines and automata products. The state machines are represented by sequence maps $f:A^*\to X$ where $f(s)=x$ indicates that the output of the system is $x$ in the state reached by following the sequence of events $s$ from the initial state. Examples provided include counters, networks, reliable message delivery, real-time analysis of gates and latches, and producer/consumer. Techniques for defining, parameterizing, characterizing abstract properties, and connecting sequence functions are developed. Sequence functions are shown to represent (possibly non-finite) Moore type state machines and general products of state machines. The method draws on state machine theory, automata products, and recursive functions and is ordinary working mathematics, not involving formal methods or any foundational or meta-mathematical techniques. Systems in which there are levels of components that may operate in parallel or concurrently are specified in terms of function composition

Emulating Digital Logic using Transputer Networks (Very High Parallelism = Simplicity = Performance)

Modern VLSI technology has changed the economic rules by which the balance between processing power, memory and communications is decided in computing systems. This will have a profound impact on the design rules for the controlling software. In particular, the criteria for judging efficiency of the algorithms will be somewhat different. This paper explores some of these implications through the development of highly parallel and highly distributable algorithms based on occam and transputer networks. The major results reported are a new simplicity for software designs, a corresponding ability to reason (formally and informally) about their properties, the reusability of their components and some real performance figures which demonstrate their practicality. Some guidelines to assist in these designs are also given. As a vehicle for discussion, an interactive simulator is developed for checking the functional and timing characteristics of digital logic circuits of arbitrary complexity