Tolga Ovatman

An overview of model checking practices on verification of PLC software

Programmable logic controllers (PLCs) are heavily used in industrial control systems, because of their high capacity of simultaneous input/output processing capabilities. Characteristically, PLC systems are used in mission critical systems, and PLC software needs to conform real-time constraints in order to work properly. Since PLC programming requires mastering low-level instructions or assembly like languages, an important step in PLC software production is modelling using a formal approach like Petri nets or automata. Afterward, PLC software is produced semiautomatically from the model and refined iteratively. Model checking, on the other hand, is a well-known software verification approach, where typically a set of timed properties are verified by exploring the transition system produced from the software model at hand. Naturally, model checking is applied in a variety of ways to verify the correctness of PLC-based software. In this paper, we provide a broad view about the difficulties that are encountered during the model checking process applied at the verification phase of PLC software production. We classify the approaches from two different perspectives: first, the model checking approach/tool used in the verification process, and second, the software model/source code and its transformation to model checker’s specification language. In a nutshell, we have mainly examined SPIN, SMV, and UPPAAL-based model checking activities and model construction using Instruction Lists (and alike), Function Block Diagrams, and Petri nets/automata-based model construction activities. As a result of our studies, we provide a comparison among the studies in the literature regarding various aspects like their application areas, performance considerations, and model checking processes. Our survey can be used to provide guidance for the scholars and practitioners planning to integrate model checking to PLC-based software verification activities.

Cost Analysis for Embedded Systems: Experiments with Priced Timed Automata

Analysis of resource consumption of embedded systems is a major challenge in the industry since the number of components that can be included in a single chip keeps getting bigger. In this paper, we consider simple models of embedded systems and the automated analysis about timing and memory access costs of those models. In order to achieve this, a basic model is built using priced timed automata and some resource consumption scenarios are verified. Even though the experiments are performed on small and basic models, we believe we have taken a basis step in showing that it is promising to use priced timed automata and Uppaal Cora as a model checking tool in reasoning about resource consumption of embedded systems.

A new test environment for PLC based interlocking systems

Interlocking systems are the core components of railway signalization systems. They ensure the safe movement of the trains on railway tracks by being the main decision making unit of the railway signalization systems. Therefore it is crucial to predetermine the errors in interlocking systems. In this work a new environment designed to test the reliability of the PLC based interlocking systems is presented.

Exploring implicit parallelism in class diagrams

Abstract: As multicore processors are becoming more wide-spread, leveraging of parallelism is once again becoming an important concern during the software development process. Substantial refactoring is required to parallelize legacy sequential software in order to exploit the advantages offered by parallel processing. In this study, guidelines are offered to aid in parallelizing object-oriented programs by analyzing their designs as represented in UML class diagrams. We define often occurring patterns of class-dependencies and demonstrate their characteristics in class diagrams by investigating their properties. We present example instances exhibiting the usage of these patterns in class diagrams. Through analyzing the runtime aspects of these instances, we have identified how they impact the parallelization of object oriented software. Taking these lessons into account when refactoring existing object-oriented software can significantly reduce time and effort required. We have evaluated our method by applying it to three popular design patterns and a real-world case study.

Design of a Hardware and Software based Test Bed for Railway Signalization Systems

Abstract It is vital that an interlocking system is thoroughly tested before its deployment. The conduction of the tests of an interlocking system on the real field is cumbersome and expensive. It is necessary that fast and efficient methods are utilized to test the hardware and the software of interlocking systems before its final installation. In this manuscript, the design of hardware and software based test beds for a railway signalization system is presented.

Software Design Pattern Behavior in Shared Memory Multiprocessor Systems

With the emergence of multicore processors, parallel software is beginning to be used in the domain of application development in addition to high performance computing. In this work three software design patterns are chosen from each pattern category as subjects, representing reusable elements of object oriented software design. Behavior of these patterns in a shared memory parallel environment is investigated regarding different aspects of parallelization including parallelizability, scalability and workload distribution.

Improving Resource Utilization in Cloud Environments using Application Placement Heuristics

Application placement is an important concept when providing software as a service in cloud environments. Because of the potential downtime costs of application migration, most of the time additional resource acquisition is preferred over migrating the applications residing in the virtual machines(VMs). This situation results in under-utilization of resources. To overcome this problem static/dynamic estimations on the resource requirements of VMs and/or applications can be performed. A more simpler strategy is using heuristics during application placement process instead of naively applying greedy strategies like round robin. In this paper we propose a number of novel heuristics and we compare them with round robin placement strategy and a few proposed placement heuristics in the literature to explore the performance of heuristics in application placement problem. Our focus is to utilize the resources offered by the cloud environment as much as possible and also minimize the number of application migrations that provide an optimal placement when migrations are performed. Our results show that an application heuristic that relies on the difference between the maximum and minimum utilization rates of the resources not only outperforms the other application placement approaches but also significantly improves the conventional approaches present in the literature.

Investigating software design pattern behavior in multiprocessor systems: A case study on observer

With the emergence of multicore processors, parallel software is beginning to be used in the domain of application software in addition to high performance computing software. The use of parallel processing hardware with current software engineering techniques and principles, like object oriented programming, will surely produce new challenges in area and change the way we look at quality criterions. In this work, experiments on bringing a software design pattern to a parallel environment are explained regarding different aspects of parallelization like data consistency, scalability and workload distribution. All the experiments are performed by keeping the parallelization at object level in order to reason about discussions that can be made on object oriented software design for multicore systems. Discussions include adaptation of current software to multicore platforms, important points when designing software for multicore systems and possible research on quality criterions of parallel software. As a result of our initial studies we have seen that it is promising to conduct research on object-level parallelism in multicore systems.

Network-aware embedding of virtual machine clusters onto federated cloud infrastructure

A virtual machine cluster embedding algorithm for federated cloud is suggested.Suggested algorithm optimizes network delay and bandwidth allocation.A framework for modeling of resource allocation in federated cloud is presented. Federated clouds are continuously developing as the demands of cloud users get more complicated. Contemporary cloud management technologies like Open-Stack (Sefraouiźetźal., 2012) and OpenNebula (Milojicic etźal., 2011) allow users to define network topologies among virtual machines that are requested. Therefore, federated clouds currently face the challenge of network topology mapping in addition to conventional resource allocation problems. In this paper, topology based mapping of virtual machine clusters onto the federated cloud infrastructures is studied. A novel algorithm is presented to perform the mapping operation that work towards minimizing network latency and optimizing bandwidth utilization. To realize and evaluate the algorithm, a widely used cloud simulation environment, CloudSim (Calheiros etźal., 2011), is extended to support several additional capabilities in network and cost modeling. Evaluation is performed by comparing the proposed algorithm to a number of conventional heuristics such as least latency first and round-robin. Results under different request characteristics indicate that the proposed algorithm performs significantly better than the compared conventional approaches regarding various QoS parameters such as inter-cloud latency and throughput.

Subgraph Matching for Resource Allocation in the Federated Cloud Environment

Federated clouds and cloud brokering allow migration of virtual machines across clouds and even deployment of cooperating VMs in different cloud data centers. In order to fully benefit from these new opportunities, we propose a heuristic that outputs a matching between virtual machine and cloud data centers by taking resource capacities, VM topologies, performance and resource costs into account. Results of our initial evaluation using the CloudSim Framework indicate that, proposed heuristic is promising for a better optimized placement of networked VM groups onto the federated cloud topology.