Software Modularity Coupling Resolution by the Laplacian of a Bipartite Dependency Graph

2019 ◽  
Author(s):  
Iaakov Exman ◽  
Netanel Ohayon
Keyword(s):  
Dependency Graph ◽  
Software Modularity

scholarly journals UPR: deadlock-free dynamic network reconfiguration by exploiting channel dependency graph compatibility

2021 ◽  
Author(s):  
Juan-José Crespo ◽  
José L. Sánchez ◽  
Francisco J. Alfaro-Cortés ◽  
José Flich ◽  
José Duato
Keyword(s):  
Dynamic Network ◽  
Dependency Graph ◽  
Network Reconfiguration ◽  
Free Dynamic

Dependency Graph-based High-level Synthesis for Maximum Instruction Parallelism

2021 ◽  
Vol 14 (4) ◽  
pp. 1-15
Author(s):  
Zhenghua Gu ◽  
Wenqing Wan ◽  
Jundong Xie ◽  
Chang Wu
Keyword(s):  
Performance Optimization ◽  
Directed Acyclic Graph ◽  
Scheduling Algorithm ◽  
Dependency Graph ◽  
High Level Synthesis ◽  
Limiting Factor ◽  
Circuit Performance ◽  
State Transition Graph ◽  
High Level ◽  
Basic Blocks

Performance optimization is an important goal for High-level Synthesis (HLS). Existing HLS scheduling algorithms are all based on Control and Data Flow Graph (CDFG) and will schedule basic blocks in sequential order. Our study shows that the sequential scheduling order of basic blocks is a big limiting factor for achievable circuit performance. In this article, we propose a Dependency Graph (DG) with two important properties for scheduling. First, DG is a directed acyclic graph. Thus, no loop breaking heuristic is needed for scheduling. Second, DG can be used to identify the exact instruction parallelism. Our experiment shows that DG can lead to 76% instruction parallelism increase over CDFG. Based on DG, we propose a bottom-up scheduling algorithm to achieve much higher instruction parallelism than existing algorithms. Hierarchical state transition graph with guard conditions is proposed for efficient implementation of such high parallelism scheduling. Our experimental results show that our DG-based HLS algorithm can outperform the CDFG-based LegUp and the state-of-the-art industrial tool Vivado HLS by 2.88× and 1.29× on circuit latency, respectively.

spaceAPPS – A modular approach for on-board software

2021 ◽  
Vol 0 (0) ◽  
Author(s):  
Juergen Herpel ◽  
Friedrich Schoen ◽  
Harald Selegrad
Keyword(s):  
Success Factors ◽  
Third Party ◽  
Ground Testing ◽  
Modular Concept ◽  
Failure Propagation ◽  
Software Modularity ◽  
Cost Efficient ◽  
Space Separation ◽  
Target Platform ◽  
Efficient Software

Abstract Software modularity and partial qualification capabilities are key enablers to produce cost efficient software in highly regulated domains. The modular concept (called spaceAPPS) described in this paper has been developed in the frame of the OPS-SAT project aiming at missions where flexibility is one of the success factors. spaceAPPS implements a novel software architecture for satellites inspired by the Apps concept of modern smartphones. In the European space domain the operation of a satellite is based on a set of 18 services. Accordingly, in spaceApps these services are mapped to individual Apps. This is not a one-to-one mapping which means that one App implements one or more services. During OPS-SAT ground testing it was demonstrated that functionality could be easily added through a new App or updated through replacing an existing App. Also during OPS-SAT ground testing it could be shown that a failing UserApp did not impact the basic apps to operate the satellite. Thus, it is possible to run applications of different criticality on the same platform. With operating systems supporting time and space separation the risk of failure propagation can be further reduced. The implementation of a partial validation approach, i. e. testing of third-party Apps in a representative environment and not running the validation on the target platform is feasible but was not demonstrated.

Exploring the Relationship between Software Modularity and Technical Debt

2018 ◽  
Author(s):  
Peggy Skiada ◽  
Apostolos Ampatzoglou ◽  
Elvira-Maria Arvanitou ◽  
Alexander Chatzigeorgiou ◽  
Ioannis Stamelos
Keyword(s):  
Technical Debt ◽  
Software Modularity ◽  
The Relationship

scholarly journals Partially observable Markov Decision Process to prioritize software defects

2021 ◽  
Author(s):  
Shirin Akbarinasaji
Keyword(s):  
Markov Decision Process ◽  
Decision Process ◽  
Tracking System ◽  
Dependency Graph ◽  
Relative Importance ◽  
Bug Reports ◽  
Markov Decision ◽  
Partially Observable Markov ◽  
Partially Observable ◽  
Issue Tracking System

Background: Bug tracking systems receive many bug reports daily. Although the software quality team aims to identify and resolve these bugs, they are never able to fix all of the reported bugs in the issue tracking system before the release deadline. However, postponing the bug fixing may have some consequences. Prioritization of bug reports will help the software manager decide which bugs to fix and which bugs to postpone. Typically, bug reports are prioritized based on the severity, priority, time and effort for fixing, customer pressure, etc. Aim: Previous studies have shown that these factors may not be appropriate for prioritization. Therefore, relying on them to automate bug prioritization might be misleading. In this dissertation, we aim to prioritize bug reports with respect to the consequence of not fixing the bugs in terms of their relative importance in the issue tracking system. Method: In order to measure the relative importance of bugs in the issue tracking system, we propose the construction of a dependency graph based on the reported dependency-blocking information in the issue tracking system. Two metrics, namely depth and degree, are used to measure the relative importance of the bugs. However, there is uncertainty in the dependency graph structure as the dependency information is discovered manually and gradually. Owing to this uncertainty, prioritization of bugs in the descending order of depth and degree may be misleading. To handle the uncertainty, we propose a novel approach of a partially observable Markov decision process (POMDP) and partially observable Monte Carlo planning (POMCP). Result: To check the feasibility of the proposed approach, we analyzed seven years of data from an open source project, Firefox, and a commercial project. We compared the proposed policy with the developer policy, maximum policy, and random policy. Conclusion: The results suggest that software practitioners do not consider the relative importance of bugs in their current practice. The proposed framework can be combined with practitioners’ expertise to prioritize bugs more effectively and take the depth and degree of bugs into account. In practice, the POMDP framework with the POMCP planner can help practitioners sequentially select bugs to minimize the connectivity of the dependency graph.

Sign in / Sign up

Export Citation Format

Share Document