Dependence-Based Source Level Tracing and Replay for Networked Embedded Systems

Error detection and diagnosis for networked embedded systems remain challenging and tedious due to issues such as a large number of computing entities, hardware resource constraints, and non-deterministic behaviors. The run-time checking is often necessitated by the fact that the static verification fails whenever there exist conditions unknown prior to execution. Complexities in hardware, software and even the operating environments can also defeat the static analysis and simulations. Record-and-replay has long been proposed for distributed systems error diagnosis. Under this method, assertions are inserted in the target program for run-time error detection. At run-time, the violation of any asserted property triggers actions for reporting an error and saving an execution trace for error replay. This dissertation takes wireless sensor networks, a special but representative type of networked embedded systems, as an example to propose a dependence-based source-level tracing-and-replay methodology for detecting and reproducing errors. This work makes three main contributions towards making error detection and replay automatic. First, SensorC, a domain-specific language for wireless sensor networks, is proposed to specify properties at a high level. This property specification approach can be not only used in our record-replay methodology but also integrated with other verification analysis approaches, such as model checking. Second, a greedy heuristic method is developed to decompose global properties into a set of local ones with the goal of minimizing the communication traffic for state information exchanges. Each local property is checked by a certain sensor node. Third, a dependence-based multi-level method for memory-efficient tracing and replay is proposed. In the interest of portability across different hardware platforms, this method is implemented as a source-level tracing and replaying tool. To test our methodology, we have built different wireless sensor networks by using TelosB motes and Zolertia Z1 motes separately. The experiments\u27 results show that our work has made it possible to instrument several test programs on wireless sensor networks under the stringent program memory constraint, reduce the data transferring required for error detection, and find and diagnose realistic errors

Formal Generation of Executable Assertions for Application-Oriented Fault Tolerance

Executable assertions embedded into a distributed computing system can provide run-time assurance by ensuring that the program state, in the actual run-time environment, is consistent with the logical stage specified in the assertions; if not, then an error has occurred and a reliable communication of this diagnostic information is provided to the system such that reconfiguration and recovery can take place. Application- oriented fault tolerance is a method that provides fault detection using executable assertions based on the natural constraints of the application. This paper focuses on giving application-oriented fault tolerance a theoretical foundation by providing a mathematical model for the generation of executable assertions which detect faults in the presence of arbitrary failures. The mathematical model of choice was axiomatic program verification. A method was developed that translates a concurrent verification proof outline into an error-detecting concurrent program. This paper shows the application of the developed method to several applications

Android skin cancer detection and classification based on MobileNet v2 model

The latest developments in the smartphone-based skin cancer diagnosis application allow simple ways for portable melanoma risk assessment and diagnosis for early skin cancer detection. Due to the trade-off problem (time complexity and error rate) on using a smartphone to run a machine learning algorithm for image analysis, most of the skin cancer diagnosis apps execute the image analysis on the server. In this study, we investigate the performance of skin cancer images detection and classification on android devices using the MobileNet v2 deep learning model. We compare the performance of several aspects; object detection and classification method, computer and android based image analysis, image acquisition method, and setting parameter. Skin cancer actinic Keratosis and Melanoma are used to test the performance of the proposed method. Accuracy, sensitivity, specificity, and running time of the testing methods are used for the measurement. Based on the experiment results, the best parameter for the MobileNet v2 model on android using images from the smartphone camera produces 95% accuracy for object detection and 70% accuracy for classification. The performance of the android app for object detection and classification model was feasible for the skin cancer analysis. Android-based image analysis remains within the threshold of computing time that denotes convenience for the user and has the same performance accuracy with the computer for the high-quality images. These findings motivated the development of disease detection processing on android using a smartphone camera, which aims to achieve real-time detection and classification with high accuracy

Discrete Markov Chain Based Spectrum Sensing for Cognitive Radio

Spectrum sensing is one of the functionalities of cognitive radios to exploit spectrum holes without interrupting primary users transmission. The more efficient of the spectrum sensing, the highest the throughput of secondary and primary network. This paper presents spectrum sensing method based on phase type modelling that is simple to do for secondary users to conclude about the channel state (idle or busy) under collision constraint. The parameters of phase type model can be adjusted based on desired operating point of the receiver sensor in its ROC curve. The presented approach can run a trade off between sensing time and the two error probabilities of sensor false alarm and miss-detection

Önellenőrzés és futásidejű verifikáció számítógépes programokban = Self-checking and run-time verification in computer programs

A kutatás eredménye egy olyan, futásidejű hibadetektálásra alkalmas módszerkészlet kidolgozása számítógépes programokhoz, amely formálisan megalapozott és illeszkedik a modell alapú tervezési folyamathoz. A futásidejű verifikáció matematikai alapja egy általunk definiált, UML állapottérképekhez illesztett temporális logikai nyelv (SC-LTL) valamint az ehhez kidolgozott gyors és kis erőforrásigényű ellenőrzési algoritmus. Az ellenőrzést megvalósító forráskód részletek (assertions) generálására automatikus kódgenerátort fejlesztettünk. A módszerkészlet alapján a futásidejű verifikáció két szinten végezhető el: (1) A fejlesztés korai fázisaiban (a követelményanalízis után) a tervező a program biztonságos működéséhez tartozó követelményeket formalizálja az SC-LTL temporális logika segítségével. Ezeket futásidőben a programba illesztett kódrészletek segítségével ellenőrizzük. Így a későbbi fejlesztési fázisokban előforduló tervezési hibák következményei is kimutathatók. (2) A fejlesztés előrehaladtával rendelkezésre álló részletes viselkedési modell mint referencia alapján történik a program állapot- és akciószekvenciáinak teljes ellenőrzése, a modellből szintén automatikusan generált, futásidejű monitorozást biztosító úgynevezett watchdog kód segítségével. Ennek célja elsősorban az implementációs hibák és a működési hibák (tranziens hardver hibák) felderítése. A hibadetektálás módszerkészletét kiegészítettük a hibakezelés modellezésére és verifikációjára szolgáló eljárásokkal. | The main result of the research is the elaboration of a set of methods that can be applied for the run-time verification of computer programs. These methods are formally proven and fit well to the model based software development process. The mathematical basis of run-time verification is our temporal logic language (SC-LTL) that is based on UML statechart diagrams, and the corresponding fast and low resource-demanding checker algorithm. To derive the assertions (i.e., the program code snippets that implement the checking), we have developed an automatic source code generator. On the basis of this set of methods, run-time checking of program execution is supported at two levels: (1) In the early phases of development the designer can formalize the program safety and liveness requirements using SC-LTL. These requirements are checked in run-time by the automatically generated assertions. This way design errors introduced in later design phases can also be detected. (2) The full checking of the state- and action sequences of program execution is based on a detailed design model constructed in the last development phases. The run-time monitoring is performed by a so-called watchdog code that is generated from the fully elaborated statechart model automatically. This is able to detect both implementation and operational errors. To complete the error detection framework, we proposed a statechart based method for the modeling and verification of run-time exception handling

Using Temporal Subsumption for Developing Efficient Error-Detecting Distributed Algorithms

Distributed algorithms can use executable assertions derived from program verification to detect errors at run-time. However, a complete verification proof outline contains a large number of assertions, and embedding all of them into the program to be checked at run-time would make error-detection very inefficient. The technique of temporal subsumption examines the dependencies between the individual assertions along program execution paths. In contrast to classical subsumption, where all logical expressions to be examined are true simultaneously, an assertion need only be true when the corresponding statement in the distributed program has been executed. Thus, temporal subsumption based on the set of assertions derived from a verification proof and in combination with the set of all legal states in the system, allows for the removal of (partial) assertions along execution sequences. We assume a fault model of Byzantine (malicious) behavior, and therefore an individual process cannot check itself for faults. We assume that a non-faulty process will always perform the correct computation so that once external data (obtained through communication) has been verified, the local computation does not need to be checked. A non-faulty process can thus detect faults produced by a faulty process based on the information it receives from it

Compositional Probabilistic Analysis of Temporal Properties over Stochastic Detectors

Run-time monitoring is a vital part of safety-critical systems. However, early-stage assurance of monitoring quality is currently limited: it relies either on complex models that might be inaccurate in unknown ways, or on data that would only be available once the system has been built. To address this issue, we propose a compositional framework for modeling and analysis of noisy monitoring systems. Our novel 3-value detector model uses probability spaces to represent atomic (non-composite) detectors, and it composes them into a temporal logic-based monitor. The error rates of these monitors are estimated by our analysis engine, which combines symbolic probability algebra, independence inference, and estimation from labeled detection data. Our evaluation on an autonomous underwater vehicle found that our framework produces accurate estimates of error rates while using only detector traces, without any monitor traces. Furthermore, when data is scarce, our approach shows higher accuracy than non-compositional data-driven estimates from monitor traces. Thus, this work enables accurate evaluation of logical monitors in early design stages before deploying them

Efficient Triangle Counting in Large Graphs via Degree-based Vertex Partitioning

The number of triangles is a computationally expensive graph statistic which is frequently used in complex network analysis (e.g., transitivity ratio), in various random graph models (e.g., exponential random graph model) and in important real world applications such as spam detection, uncovering of the hidden thematic structure of the Web and link recommendation. Counting triangles in graphs with millions and billions of edges requires algorithms which run fast, use small amount of space, provide accurate estimates of the number of triangles and preferably are parallelizable. In this paper we present an efficient triangle counting algorithm which can be adapted to the semistreaming model. The key idea of our algorithm is to combine the sampling algorithm of Tsourakakis et al. and the partitioning of the set of vertices into a high degree and a low degree subset respectively as in the Alon, Yuster and Zwick work treating each set appropriately. We obtain a running time $O \left(m + \frac{m^{3/2} \Delta \log{n}}{t \epsilon^2} \right)$ and an $\epsilon$ approximation (multiplicative error), where $n$ is the number of vertices, $m$ the number of edges and $\Delta$ the maximum number of triangles an edge is contained. Furthermore, we show how this algorithm can be adapted to the semistreaming model with space usage $O\left(m^{1/2}\log{n} + \frac{m^{3/2} \Delta \log{n}}{t \epsilon^2} \right)$ and a constant number of passes (three) over the graph stream. We apply our methods in various networks with several millions of edges and we obtain excellent results. Finally, we propose a random projection based method for triangle counting and provide a sufficient condition to obtain an estimate with low variance.Comment: 1) 12 pages 2) To appear in the 7th Workshop on Algorithms and Models for the Web Graph (WAW 2010

Virtual commissioning of industrial control systems : a 3D digital model approach

With the growing presence of industry 4.0, flexible workstations and distributed control logic, software development has become an even more important part of the automation engineering process than before. In a traditional workflow, the main commissioning part of industrial control systems is performed on the real set-up and consequently during a time critical phase of the project. Virtual commissioning can be used to reduce the real commissioning time and can allow an earlier commissioning start, reducing the overall project lead time, risk of damaging parts, amount of rework and cost of error correction. Previous research showed already a reduction potential of the real commissioning time by 73\%, when using a virtual commissioning strategy based on a 3D digital model. However, the robustness of that approach still highly depends on the human expertise to fully evaluate the correct behavior in all possible use scenarios. This paper describes an approach to further automate these virtual commissioning steps by embedding functional specifications and use scenarios through a formal notation inside the 3D digital model. Configuration steps inside the virtual environment describe the conditions, independent from the control logic but related to component states and transitions in the digital model (actuator and sensor values, time restrictions, counters, positions of objects, etc.). These conditions are continuously monitored during an extensive commissioning run of the digital model covering all possible component states and transitions. A small scale experiment will show the reduction of the virtual commissioning time and earlier detection of quality issues

Deep learning-based framework for traffic estimation for the MLK Smart Corridor in downtown Chattanooga, TN

In this Thesis we introduced a deep learning-based framework for vehicles detection, tracking, movement direction identification, and speed estimation. We chose YOLOv7 for objects detection given its ability to run up to 160 fps. We trained YOLOv7 to detect and classify vehicles into four classes with a reported mean average precision of 0.69. For re-identification, we refined the DeepSort tracker, a tracking-by-detection model. We incorporated a Siamese network in place of its default feature extractor. Both models were trained on the UA-DETRAC dataset, tested on KITTI, revealing a 71\% reduction in the IDSW rate with our revision. Movement direction classification, an offline system component, utilized a similarity-based trajectory method with specific spatial constraints. Finally we combined image perspective transformation with objects scaling to estimate speed with an error of 0.516 mph. Our comprehensive framework offers potential in applications like travel time estimation and benchmarking speed data