| 1. |
- Ciccozzi, Federico, 1983-, et al.
(författare)
-
A Comprehensive Exploration of Languages for Parallel Computing
- 2023
-
Ingår i: ACM Computing Surveys. - : ASSOC COMPUTING MACHINERY. - 0360-0300 .- 1557-7341. ; 55:2
-
Tidskriftsartikel (refereegranskat)abstract
- Software-intensive systems in most domains, from autonomous vehicles to health, are becoming predominantly parallel to efficiently manage large amount of data in short (even real-) time. There is an incredibly rich literature on languages for parallel computing, thus it is difficult for researchers and practitioners, even experienced in this very field, to get a grasp on them. With this work we provide a comprehensive, structured, and detailed snapshot of documented research on those languages to identify trends, technical characteristics, open challenges, and research directions. In this article, we report on planning, execution, and results of our systematic peer-reviewed as well as grey literature review, which aimed at providing such a snapshot by analysing 225 studies.
|
|
| 2. |
- Helali Moghadam, Mahshid, et al.
(författare)
-
An autonomous performance testing framework using self-adaptive fuzzy reinforcement learning
- 2022
-
Ingår i: Software quality journal. - : Springer. - 0963-9314 .- 1573-1367. ; , s. 127-159
-
Tidskriftsartikel (refereegranskat)abstract
- Test automation brings the potential to reduce costs and human effort, but several aspects of software testing remain challenging to automate. One such example is automated performance testing to find performance breaking points. Current approaches to tackle automated generation of performance test cases mainly involve using source code or system model analysis or use-case-based techniques. However, source code and system models might not always be available at testing time. On the other hand, if the optimal performance testing policy for the intended objective in a testing process instead could be learned by the testing system, then test automation without advanced performance models could be possible. Furthermore, the learned policy could later be reused for similar software systems under test, thus leading to higher test efficiency. We propose SaFReL, a self-adaptive fuzzy reinforcement learning-based performance testing framework. SaFReL learns the optimal policy to generate performance test cases through an initial learning phase, then reuses it during a transfer learning phase, while keeping the learning running and updating the policy in the long term. Through multiple experiments in a simulated performance testing setup, we demonstrate that our approach generates the target performance test cases for different programs more efficiently than a typical testing process and performs adaptively without access to source code and performance models. © 2021, The Author(s).
|
|
| 3. |
- Helali Moghadam, Mahshid
(författare)
-
Intelligence-Driven Software Performance Assurance
- 2022
-
Doktorsavhandling (övrigt vetenskapligt/konstnärligt)abstract
- Software performance assurance is of great importance for the success of software products, which are nowadays involved in many parts of our life. Performance evaluation approaches such as performance modeling, testing, as well as runtime performance control methods, all can contribute to the realization of software performance assurance. Many of the common approaches to tackle challenges in this area involve relying on performance models or using system models and source code. Although modeling provides a deep insight into the system behavior, developing a detailed model is challenging. Furthermore, software artifacts such as models and source code might not be readily available at all times in the development lifecycle. This thesis focuses on leveraging the potential of machine learning (ML) and evolutionary search-based techniques to provide viable solutions for addressing the challenges in different aspects of software performance assurance efficiently and effectively.In this thesis, we first investigate the capabilities of model-free reinforcement learning to address the objectives in robustness testing problems. We develop two self-adaptive reinforcement learning-driven test agents called SaFReL and RELOAD. They generate effective platform-based test scenarios and test workloads, respectively. The output scenarios and workloads help testers and software engineers meet their objectives efficiently without relying on models or source code. SaFReL and RELOAD learn the optimal policies (ways) to meet the test objectives and can reuse the learned policies adaptively in other testing settings. Policy reuse can lead to higher test efficiency and cost savings, for example, when testing similar test objectives or software systems with comparable performance sensitivity.Next, we leverage the potential of evolutionary computation algorithms, i.e., genetic algorithms, evolution strategies, and particle swarm optimization, to generate failure-revealing test scenarios for robustness testing of AI systems. In this part, we choose autonomous driving systems as a prevailing example of contemporary AI systems. We study the efficacy of the proposed evolutionary search-based test generation techniques and evaluate primarily to what extent they can trigger failures. Moreover, we investigate the diversity of those failures and compare them to existing baseline solutions. Finally, we again use the potential of model-free reinforcement learning to develop adaptive ML-driven runtime performance control approaches. We present a response time preservation method for a sample type of industrial applications and a resource allocation technique for dynamic workloads in a data grid application. The proposed ML-driven techniques learn how to adjust the tunable parameters and resource configuration at runtime to keep the performance continually compliant with the requirements and to further optimize the runtime performance. We evaluate the efficacy of the approaches and show how effectively they can improve the performance and keep the performance requirements satisfied under varying conditions such as dynamic workloads and the occurrence of runtime events that lead to substantial response time deviations.
|
|
| 4. |
- Helali Moghadam, Mahshid
(författare)
-
Machine Learning-Assisted Performance Assurance
- 2020
-
Licentiatavhandling (övrigt vetenskapligt/konstnärligt)abstract
- With the growing involvement of software systems in our life, assurance of performance, as an important quality characteristic, rises to prominence for the success of software products. Performance testing, preservation, and improvement all contribute to the realization of performance assurance. Common approaches to tackle challenges in testing, preservation, and improvement of performance mainly involve techniques relying on performance models or using system models or source code. Although modeling provides a deep insight into the system behavior, drawing a well-detailed model is challenging. On the other hand, those artifacts such as models and source code might not be available all the time. These issues are the motivations for using model-free machine learning techniques such as model-free reinforcement learning to address the related challenges in performance assurance.Reinforcement learning implies that if the optimal policy (way) for achieving the intended objective in a performance assurance process could instead be learnt by the acting system (e.g., the tester system), then the intended objective could be accomplished without advanced performance models. Furthermore, the learnt policy could later be reused in similar situations, which leads to efficiency improvement by saving computation time while reducing the dependency on the models and source code.In this thesis, our research goal is to develop adaptive and efficient performance assurance techniques meeting the intended objectives without access to models and source code. We propose three model-free learning-based approaches to tackle the challenges; efficient generation of performance test cases, runtime performance (response time) preservation, and performance improvement in terms of makespan (completion time) reduction. We demonstrate the efficiency and adaptivity of our approaches based on experimental evaluations conducted on the research prototype tools, i.e. simulation environments that we developed or tailored for our problems, in different application areas.
|
|
| 5. |
- Helali Moghadam, Mahshid, et al.
(författare)
-
Machine Learning Testing in an ADAS Case Study Using Simulation-Integrated Bio-Inspired Search-Based Testing
- 2022
-
Rapport (övrigt vetenskapligt/konstnärligt)abstract
- This paper presents an extended version of Deeper, a search-based simulation-integrated test solution that generates failure-revealing test scenarios for testing a deep neural network-based lane-keeping system. In the newly proposed version, we utilize a new set of bio-inspired search algorithms, genetic algorithm (GA), (μ+ λ) and (μ,λ) evolution strategies(ES), and particle swarm optimization (PSO), that leverage a quality population seed and domain-specific crossover and mutation operations tailored for the presentation model used for modeling the test scenarios. In order to demonstrate the capabilities of the new test generators within Deeper, we carry out an empirical evaluation and comparison with regard to the results of five participating tools in the cyber-physical systems testing competition at SBST 2021. Our evaluation shows the newly proposed test generators in Deeper not only represent a considerable improvement on the previous version but also prove to be effective and efficient in provoking a considerable number of diverse failure-revealing test scenarios for testing an ML-driven lane-keeping system. They can trigger several failures while promoting test scenario diversity, under a limited test time budget, high target failure severity, and strict speed limit constraints.
|
|
| 6. |
- Helali Moghadam, Mahshid, et al.
(författare)
-
Machine learning testing in an ADAS case study using simulation-integrated bio-inspired search-based testing
- 2024
-
Ingår i: Journal of Software. - : John Wiley and Sons Ltd. - 2047-7473 .- 2047-7481. ; :5
-
Tidskriftsartikel (refereegranskat)abstract
- This paper presents an extended version of Deeper, a search-based simulation-integrated test solution that generates failure-revealing test scenarios for testing a deep neural network-based lane-keeping system. In the newly proposed version, we utilize a new set of bio-inspired search algorithms, genetic algorithm (GA), (Formula presented.) and (Formula presented.) evolution strategies (ES), and particle swarm optimization (PSO), that leverage a quality population seed and domain-specific crossover and mutation operations tailored for the presentation model used for modeling the test scenarios. In order to demonstrate the capabilities of the new test generators within Deeper, we carry out an empirical evaluation and comparison with regard to the results of five participating tools in the cyber-physical systems testing competition at SBST 2021. Our evaluation shows the newly proposed test generators in Deeper not only represent a considerable improvement on the previous version but also prove to be effective and efficient in provoking a considerable number of diverse failure-revealing test scenarios for testing an ML-driven lane-keeping system. They can trigger several failures while promoting test scenario diversity, under a limited test time budget, high target failure severity, and strict speed limit constraints.
|
|
| 7. |
- Helali Moghadam, Mahshid, et al.
(författare)
-
Performance Testing Using a Smart Reinforcement Learning-Driven Test Agent
- 2021
-
Ingår i: 2021 IEEE Congress on Evolutionary Computation (CEC). - 9781728183930 ; , s. 2385-2394
-
Konferensbidrag (refereegranskat)abstract
- Performance testing with the aim of generating an efficient and effective workload to identify performance issues is challenging. Many of the automated approaches mainly rely on analyzing system models, source code, or extracting the usage pattern of the system during the execution. However, such information and artifacts are not always available. Moreover, all the transactions within a generated workload do not impact the performance of the system the same way, a finely tuned workload could accomplish the test objective in an efficient way. Model-free reinforcement learning is widely used for finding the optimal behavior to accomplish an objective in many decision-making problems without relying on a model of the system. This paper proposes that if the optimal policy (way) for generating test workload to meet a test objective can be learned by a test agent, then efficient test automation would be possible without relying on system models or source code. We present a self-adaptive reinforcement learning-driven load testing agent, RELOAD, that learns the optimal policy for test workload generation and generates an effective workload efficiently to meet the test objective. Once the agent learns the optimal policy, it can reuse the learned policy in subsequent testing activities. Our experiments show that the proposed intelligent load test agent can accomplish the test objective with lower test cost compared to common load testing procedures, and results in higher test efficiency.
|
|
| 8. |
- Helali Moghadam, Mahshid, et al.
(författare)
-
Poster : Performance Testing Driven by Reinforcement Learning
- 2020
-
Ingår i: 2020 IEEE 13th International Conference on Software Testing, Validation and Verification (ICST). - : Institute of Electrical and Electronics Engineers (IEEE). - 9781728157771 ; , s. 402-405
-
Konferensbidrag (refereegranskat)abstract
- Performance testing remains a challenge, particularly for complex systems. Different application-, platform- and workload-based factors can influence the performance of software under test. Common approaches for generating platform- and workload-based test conditions are often based on system model or source code analysis, real usage modeling and use-case based design techniques. Nonetheless, creating a detailed performance model is often difficult, and also those artifacts might not be always available during the testing. On the other hand, test automation solutions such as automated test case generation can enable effort and cost reduction with the potential to improve the intended test criteria coverage. Furthermore, if the optimal way (policy) to generate test cases can be learnt by testing system, then the learnt policy can be reused in further testing situations such as testing variants, evolved versions of software, and different testing scenarios. This capability can lead to additional cost and computation time saving in the testing process. In this research, we present an autonomous performance testing framework which uses a model-free reinforcement learning augmented by fuzzy logic and self-adaptive strategies. It is able to learn the optimal policy to generate platform- and workload-based test conditions which result in meeting the intended testing objective without access to system model and source code. The use of fuzzy logic and self-adaptive strategy helps to tackle the issue of uncertainty and improve the accuracy and adaptivity of the proposed learning. Our evaluation experiments show that the proposed autonomous performance testing framework is able to generate the test conditions efficiently and in a way adaptive to varying testing situations.
|
|
| 9. |
- Lisper, Björn, et al.
(författare)
-
HERO-ML : A Very High-Level Array Language for Executable Modelling of Data Parallel Algorithms
- 2023
-
Ingår i: ARRAY - Proc. ACM SIGPLAN Int. Workshop Libr., Lang. Compil. Array Program., Co-located PLDI. - : Association for Computing Machinery, Inc. - 9798400701696 ; , s. 13-21
-
Konferensbidrag (refereegranskat)abstract
- HERO-ML is an array language, on very high level, which is intended for specifying data parallel algorithms in a concise and platform-independent way where all the inherent data parallelism is easy to identify. The goal is to support the software development for heterogeneous systems with different kinds of parallel numerical accelerators, where programs tend to be very platform-specific and difficult to develop. In this paper we describe HERO-ML, and a proof-of-concept implementation.
|
|
| 10. |
- Malm, Jean, et al.
(författare)
-
An Evaluation of General-Purpose Static Analysis Tools on C/C++ Test Code
- 2022
-
Ingår i: Proc. - Euromicro Conf. Softw. Eng. Adv. Appl., SEAA. - : Institute of Electrical and Electronics Engineers Inc.. - 9781665461528 ; , s. 133-140
-
Konferensbidrag (refereegranskat)abstract
- In recent years, maintaining test code quality has gained more attention due to increased automation and the growing focus on issues caused during this process. Test code may become long and complex, but maintaining its quality is mostly a manual process, that may not scale in big software projects. Moreover, bugs in test code may give a false impression about the correctness or performance of the production code. Static program analysis (SPA) tools are being used to maintain the quality of software projects nowadays. However, these tools are either not used to analyse test code, or any analysis results on the test code are suppressed. This is especially true since SPA tools are not tailored to generate precise warnings on test code. This paper investigates the use of SPA on test code by employing three state-of-the-art general-purpose static analysers on a curated set of projects used in the industry and a random sample of relatively popular and large open-source C/C++ projects. We have found a number of built-in code checking modules that can detect quality issues in the test code. However, these checkers need some tailoring to obtain relevant results. We observed design choices in test frameworks that raise noisy warnings in analysers and propose a set of augmentations to the checkers or the analysis framework to obtain precise warnings from static analysers.
|
|
| 11. |
- Malm, Jean, et al.
(författare)
-
Automated analysis of flakiness-mitigating delays
- 2020
-
Ingår i: Proceedings - 2020 IEEE/ACM 1st International Conference on Automation of Software Test, AST 2020. - New York, NY, USA : Association for Computing Machinery. - 9781450379571 ; , s. 81-84
-
Konferensbidrag (refereegranskat)abstract
- During testing of parallel systems, which allow asynchronous communication, test flakiness is sometimes avoided by explicitly inserting delays in test code. The choice of delay approach can be a trade-off between short-term gain and long-term robustness. In this work, we present an approach for automatic detection and classification of delay insertions, with the goal of identifying those that could be made more robust. The approach has been implemented using an open-source compiler tooling framework and validated using test code from the telecom industry. © 2020 Association for Computing Machinery.
|
|
| 12. |
- Marković, Filip, 1992-
(författare)
-
Preemption-Delay Aware Schedulability Analysis of Real-Time Systems
- 2020
-
Doktorsavhandling (övrigt vetenskapligt/konstnärligt)abstract
- Schedulability analysis of real-time systems under preemptive scheduling may often lead to false-negative results, deeming a schedulable taskset being unschedulable. This is the case due to the inherent over-approximation of many time-related parameters such as task execution time, system delays, etc., but also, in the context of preemptive scheduling, a significant over-approximation arises from accounting for task preemptions and corresponding preemption-related delays. To reduce false-negative schedulability results, it is highly important to as accurately as possible approximate preemption-related delays. Also, it is important to obtain safe approximations, which means that compared to the approximated delay, no higher corresponding delay can occur at runtime since such case may lead to false-positive schedulability results that can critically impact the analysed system. Therefore, the overall goal of this thesis is:To improve the accuracy of schedulability analyses to identify schedulable tasksets in real-time systems under fixed-priority preemptive scheduling, by accounting for tight and safe approximations of preemption-related delays.We contribute to the domain of timing analysis for single-core real-time systems under preemptive scheduling by proposing two novel cache-aware schedulability analyses: one for fully-preemptive tasks, and one for tasks with fixed preemption points. Also, we propose a novel method for deriving safe and tight upper bounds on cache-related preemption delay of tasks with fixed preemption points. Finally, we contribute to the domain of multi-core partitioned hard real-time systems by proposing a novel partitioning criterion for worst-fit decreasing partitioning, and by investigating the effectiveness of different partitioning strategies to provide task allocation which does not jeopardize the schedulability of a taskset in the context of preemptive~scheduling.
|
|
| 13. |
- Masud, Abu Naser, et al.
(författare)
-
On the Computation of Interprocedural Weak Control Closure
- 2022
-
Ingår i: CC 2022 - Proceedings of the 31st ACM SIGPLAN International Conference on Compiler Construction. - New York, NY, USA : Association for Computing Machinery, Inc. - 9781450391832 ; , s. 65-76
-
Konferensbidrag (refereegranskat)abstract
- Many program analysis techniques depend on capturing the control dependencies of the program. Most existing control dependence algorithms either compute intraprocedural control dependencies only, or they compute control dependence relations that are not precise in general including nonterminating systems. Weak control closure (WCC) subsumes all known nontermination insensitive control dependence relations, including those that are appropriate for nonterminating systems. In this paper, we provide the first formal development of an algorithm to compute the WCC for interprocedural programs capturing the weak form of interprocedural control dependencies. The method is widely applicable due to the generality of WCC. Theorems on the theoretical results of soundness, precision, and the worst-case complexity of our method are also included. We have compared our algorithm with a WCC computation algorithm based on a state-of-The-Art interprocedural control dependence computation algorithm. The latter algorithm loses soundness, and we improve the precision by 15.21% on all our experimental benchmarks. This empirical evidence suggests that our algorithm is more effective for any client application of WCC requiring interprocedural program analysis.
|
|
| 14. |
- Masud, Abu Naser, et al.
(författare)
-
Semantic Correctness of Dependence-based Slicing for Interprocedural, Possibly Nonterminating Programs
- 2021
-
Ingår i: ACM Transactions on Programming Languages and Systems. - : ASSOC COMPUTING MACHINERY. - 0164-0925 .- 1558-4593. ; 42:4
-
Tidskriftsartikel (refereegranskat)abstract
- Existing proofs of correctness for dependence-based slicing methods are limited either to the slicing of intraprocedural programs [2, 39], or the proof is only applicable to a specific slicing method [4, 41]. We contribute a general proof of correctness for dependence-based slicing methods such as Weiser [50, 51], or Binkley et al. [7, 8], for interprocedural, possibly nonterminating programs. The proof uses well-formed weak and strong control closure relations, which are the interprocedural extensions of the generalised weak/strong control closure provided by Danicic et al. [13], capturing various nonterminating-insensitive and nontermination-sensitive control-dependence relations that have been proposed in the literature. Thus, our proof framework is valid for a whole range of existing control-dependence relations. We have provided a definition of semantically correct (SC) slice. We prove that SC slices agree with Weiser slicing, that deterministic SC slices preserve termination, and that nondeterministic SC slices preserve the nondeterministic behavior of the original programs.
|
|
| 15. |
- Riazati, Mohammad, et al.
(författare)
-
Adjustable self-healing methodology for accelerated functions in heterogeneous systems
- 2020
-
Ingår i: Proceedings - Euromicro Conference on Digital System Design, DSD 2020. - : Institute of Electrical and Electronics Engineers Inc.. - 9781728195353 ; , s. 638-645
-
Konferensbidrag (refereegranskat)abstract
- Self-healing is a promising approach for designing reliable digital systems. It refers to the ability of a system to detect faults and automatically fixing them to avoid total failure. With the development of digital systems, heterogeneous systems, in which some parts of the system are executed on the programmable logic, and some other parts run on the processing elements (CPU), are becoming more prevalent. In this work, we propose an adjustable self-healing method that is applicable to heterogeneous systems with accelerated functions and enables the designers to add the self-healing feature to the design. In this method, by manipulating the software codes that are being executed on the processing element, we add the ability to verify the accelerated functions on the programmable logic and heal the possible failures to the system. This is done not only in a straightforward manner but also without being forced to choose a specific reliability-overhead point. The designer will have the option to select the optimum configuration for a desired reliability level. Experimental results on a large design including several accelerated functions are provided and show 42% improvement of reliability by having 27% overhead, as an example of the reliability-overhead point.
|
|
| 16. |
- Riazati, Mohammad, et al.
(författare)
-
AutoDeepHLS : Deep Neural Network High-level Synthesis using fixed-point precision
- 2022
-
Ingår i: 2022 IEEE INTERNATIONAL CONFERENCE ON ARTIFICIAL INTELLIGENCE CIRCUITS AND SYSTEMS (AICAS 2022). - : IEEE. - 9781665409964 ; , s. 122-125
-
Konferensbidrag (refereegranskat)abstract
- Deep Neural Networks (DNN) have received much attention in various applications such as visual recognition, self-driving cars, health care, etc. Hardware implementation, specifically using FPGA and ASIC due to their high performance and low power consumption, is considered an efficient method. However, implementation on these platforms is difficult for neural network designers since they usually have limited knowledge of hardware. High-Level Synthesis (HLS) tools can act as a bridge between high-level DNN designs and hardware implementation. Nevertheless, these tools usually need implementation at the C level, whereas the design of neural networks is usually performed at a higher level (such as Keras or TensorFlow). In this paper, we propose a fully automated flow for creating a C-level implementation that is synthesizable with HLS Tools. Various aspects such as performance, minimal access to memory elements, data type knobs, and design verification are considered. Our results show that the generated C implementation is much more HLS friendly than previous works. Furthermore, a complete flow is proposed to determine different fixed-point precisions for network elements. We show that our method results in 25% and 34% reduction in bit-width for LeNet and VGG, respectively, without any accuracy loss.
|
|
| 17. |
- Riazati, Mohammad, et al.
(författare)
-
DeepFlexiHLS : Deep Neural Network Flexible High-Level Synthesis Directive Generator
- 2022
-
Ingår i: 2022 IEEE Nordic Circuits and Systems Conference, NORCAS 2022 - Proceedings. - : Institute of Electrical and Electronics Engineers Inc.. - 9798350345506
-
Konferensbidrag (refereegranskat)abstract
- Deep Neural Networks (DNNs) are now widely adopted to solve various problems ranging from speech recognition to image classification. Since DNNs demand a large amount of processing power, their implementation on hardware, i.e., FPGA or ASIC, has received much attention. High-level synthesis is widely used since it significantly boosts productivity and flexibility and requires minimal hardware knowledge. However, when HLS transforms a C implementation to a Register-Transfer Level one, the high parallelism capability of the FPGA is not well-utilized. HLS tools provide a feature called directives through which designers can guide the tool using some defined C pragma statements to improve performance. Nevertheless, finding appropriate directives is another challenge, which needs considerable expertise and experience. This paper proposes DeepFlexiHLS, a two-stage design space exploration flow to find a set of directives to achieve minimal latency. In the first stage, a partition-based method is used to find the directives corresponding to each partition. Aggregating all these directives leads to minimal latency. Experimental results show 54% more speed-up than similar work on VGG neural network. In the second stage, an estimator is implemented to find the latency and resource utilization of various combinations of the found directives. The results form a Pareto-frontier from which the designer can choose if FPGA resources are limited or are not to be entirely used by the DNN module.
|
|
| 18. |
- Riazati, Mohammad, et al.
(författare)
-
DeepHLS : A complete toolchain for automatic synthesis of deep neural networks to FPGA
- 2020
-
Ingår i: ICECS 2020 - 27th IEEE International Conference on Electronics, Circuits and Systems, Proceedings. - : Institute of Electrical and Electronics Engineers Inc.. - 9781728160443
-
Konferensbidrag (refereegranskat)abstract
- Deep neural networks (DNN) have achieved quality results in various applications of computer vision, especially in image classification problems. DNNs are computational intensive, and nowadays, their acceleration on the FPGA has received much attention. Many methods to accelerate DNNs have been proposed. Despite their performance features like acceptable accuracy or low latency, their use is not widely accepted by software designers who usually do not have enough knowledge of the hardware details of the proposed accelerators. HLS tools are the major promising tools that can act as a bridge between software designers and hardware implementation. However, not only most HLS tools just support C and C++ descriptions as input, but also their result is very sensitive to the coding style. It makes it difficult for the software developers to adopt them, as DNNs are mostly described in high-level languages such as Tensorflow or Keras. In this paper, an integrated toolchain is presented that, in addition to converting the Keras DNN descriptions to a simple, flat, and synthesizable C output, provides other features such as accuracy verification, C level knobs to easily change the data types from floating-point to fixed-point with arbitrary bit width, and latency and area utilization adjustment using HLS knobs.
|
|
| 19. |
- Riazati, Mohammad
(författare)
-
DeepKit: a multistage exploration framework for hardware implementation of deep learning
- 2023
-
Doktorsavhandling (övrigt vetenskapligt/konstnärligt)abstract
- Deep Neural Networks (DNNs) are widely adopted to solve different problems ranging from speech recognition to image classification. DNNs demand a large amount of processing power, and their implementation on hardware, i.e., FPGA or ASIC, has received much attention. However, it is impossible to implement a DNN on hardware directly from its DNN descriptions, usually in Python language, libraries, and APIs. Therefore, it should be either implemented from scratch at Register Transfer Level (RTL), e.g., in VHDL or Verilog, or be transformed to a lower level implementation. One idea that has been recently considered is converting a DNN to C and then using High-Level Synthesis (HLS) to synthesize it on an FPGA. Nevertheless, there are various aspects to take into consideration during the transformation. In this thesis, we propose a multistage framework, DeepKit, that generates a synthesizable C implementation based on an input DNN architecture in a DNN description (Keras). Then, moving through the stages, various explorations and optimizations are performed with regard to accuracy, latency, resource utilization, and reliability. The framework is also implemented as a toolchain consisting of DeepHLS, AutoDeepHLS, DeepAxe, and DeepFlexiHLS, and results are provided for DNNs of various types and sizes.
|
|
| 20. |
- Riazati, Mohammad, et al.
(författare)
-
SHiLA : Synthesizing High-Level Assertions for High-Speed Validation of High-Level Designs
- 2020
-
Ingår i: Proceedings - 2020 23rd International Symposium on Design and Diagnostics of Electronic Circuits and Systems, DDECS 2020. - : Institute of Electrical and Electronics Engineers Inc.. - 9781728199382
-
Konferensbidrag (refereegranskat)abstract
- In the past, assertions were mostly used to validate the system through the design and simulation process. Later, a new method known as assertion synthesis was introduced, which enabled the designers to use the assertions for high-speed hardware emulation and safety and reliability insurance after tape-out. Although the synthesis of the assertions at the register transfer level is proposed and implemented in several works, none of them can be adopted for high-level assertions. In this paper, we propose the SHiLA framework and a detailed implementation guide by which assertion synthesis can also be applied to the high-level design processes. The proposed method, which is fully tool independent, is not only an enabler to highspeed assertion-Assisted simulation but can also be used in other scenarios that need assertion synthesis, as it has the minimum possible effect on the main design's performance.
|
|
| 21. |
- Sitompul, Taufik Akbar
(författare)
-
Information Visualization Using Transparent Displays in Mobile Cranes and Excavators
- 2022
-
Doktorsavhandling (övrigt vetenskapligt/konstnärligt)abstract
- Operating heavy machinery, such as mobile cranes and excavators, is a complex task. While driving the machine, operators are also performing industrial tasks, e.g. lifting or digging, monitoring the machine’s status, and observing the surroundings. Modern heavy machinery is increasingly equipped with information systems that present supportive information to operators, so that they could perform their work safely and productively. Supportive information in heavy machinery is generally presented visually using head-down displays, which are placed in lower positions inside the cabin in order to avoid obstructing operators’ view. However, this placement makes visual information presented using head-down displays tend to be overlooked by operators, as the information is presented outside their field of view.This dissertation investigates the possible use of transparent mediums for presenting visual information on the windshield of mobile cranes and excavators. By presenting information on the windshield, operators are expected to acquire visual information without diverting their attention away from the operational area. The design process includes (1) observing heavy machinery operators in natural settings through available videos on the Internet, (2) conducting an empirical study on the impact of different information placements, (3) reviewing the state of the art of display technologies that could be used to visualize information around the windshield of heavy machinery, (4) reviewing relevant safety guidelines to determine what kinds of critical information that operators should know, (5) conducting design workshops to generate visualization designs that represent critical information in operations of mobile cranes and excavators, (6) involving professional operators to evaluate and improve the proposed visualization designs, and (7) developing a functioning transparent display prototype that visualizes one kind of critical information that professional operators considered as the most important one.The main finding from the observation using online videos suggested that heavy machinery operators spent considerable amount of time looking through the front windshield, and thus the front windshield could be used as a potential space for presenting visual information. The main finding of the empirical study also indicated that presenting information closer to the line of sight produced higher information acquisition and lower workload, compared to when information was presented farther from the line of sight. Based on the evaluation with professional operators, there seemed to be a good match between the proposed visualization designs and the operators' way of thinking, since the operators were able to understand and use the proposed visualization designs with little explanations. On the basis of the three most important findings above, there is a strong indication that placing the developed transparent display on the front windscreen of heavy machinery would make it easier for operators to perceive and process the presented information.
|
|
| 22. |
- Taheri, M., et al.
(författare)
-
DeepAxe : A Framework for Exploration of Approximation and Reliability Trade-offs in DNN Accelerators
- 2023
-
Ingår i: Proceedings - International Symposium on Quality Electronic Design, ISQED. - : IEEE Computer Society. - 9798350334753
-
Konferensbidrag (refereegranskat)abstract
- While the role of Deep Neural Networks (DNNs) in a wide range of safety-critical applications is expanding, emerging DNNs experience massive growth in terms of computation power. It raises the necessity of improving the reliability of DNN accelerators yet reducing the computational burden on the hardware platforms, i.e. reducing the energy consumption and execution time as well as increasing the efficiency of DNN accelerators. Therefore, the trade-off between hardware performance, i.e. area, power and delay, and the reliability of the DNN accelerator implementation becomes critical and requires tools for analysis.In this paper, we propose a framework DeepAxe for design space exploration for FPGA-based implementation of DNNs by considering the trilateral impact of applying functional approximation on accuracy, reliability and hardware performance. The framework enables selective approximation of reliability-critical DNNs, providing a set of Pareto-optimal DNN implementation design space points for the target resource utilization requirements. The design flow starts with a pre-trained network in Keras, uses an innovative high-level synthesis environment DeepHLS and results in a set of Pareto-optimal design space points as a guide for the designer. The framework is demonstrated on a case study of custom and state-of-the-art DNNs and datasets.
|
|
