To see the other types of publications on this topic, follow the link: Control Flow Graph (CFG).
Journal articles on the topic 'Control Flow Graph (CFG)'
Create a spot-on reference in APA, MLA, Chicago, Harvard, and other styles
Consult the top 50 journal articles for your research on the topic 'Control Flow Graph (CFG).'
Next to every source in the list of references, there is an 'Add to bibliography' button. Press on it, and we will generate automatically the bibliographic reference to the chosen work in the citation style you need: APA, MLA, Harvard, Chicago, Vancouver, etc.
You can also download the full text of the academic publication as pdf and read online its abstract whenever available in the metadata.
Browse journal articles on a wide variety of disciplines and organise your bibliography correctly.
1
Koppel, James, Jackson Kearl, and Armando Solar-Lezama. "Automatically deriving control-flow graph generators from operational semantics." Proceedings of the ACM on Programming Languages 6, ICFP (2022): 742–71. http://dx.doi.org/10.1145/3547648.
Full textAbstract:
We develop the first theory of control-flow graphs from first principles, and use it to create an algorithm for automatically synthesizing many variants of control-flow graph generators from a language’s operational semantics. Our approach first introduces a new algorithm for converting a large class of small-step operational semantics to an abstract machine. It next uses a technique called ”abstract rewriting” to automatically abstract the semantics of a language, which is used both to directly generate a CFG from a program (”interpreted mode”) and to generate standalone code, similar to a human-written CFG generator, for any program in a language. We show how the choice of two abstraction and projection parameters allow our approach to synthesize several families of CFG-generators useful for different kinds of tools. We prove the correspondence between the generated graphs and the original semantics. We provide and prove an algorithm for automatically proving the termination of interpreted-mode generators. In addition to our theoretical results, we have implemented this algorithm in a tool called Mandate, and show that it produces human-readable code on two medium-size languages with 60−80 rules, featuring nearly all intraprocedural control constructs common in modern languages. We then show these CFG-generators were sufficient to build two static analyses atop them. Our work is a promising step towards the grand vision of being able to synthesize all desired tools from the semantics of a programming language.
2
Qiu, Dehong, Jialin Sun, and Hao Li. "Improving Similarity Measure for Java Programs Based on Optimal Matching of Control Flow Graphs." International Journal of Software Engineering and Knowledge Engineering 25, no. 07 (2015): 1171–97. http://dx.doi.org/10.1142/s0218194015500229.
Full textAbstract:
Measuring program similarity plays an important role in solving many problems in software engineering. However, because programs are instruction sequences with complex structures and semantic functions and furthermore, programs may be obfuscated deliberately through semantics-preserving transformations, measuring program similarity is a difficult task that has not been adequately addressed. In this paper, we propose a new approach to measuring Java program similarity. The approach first measures the low-level similarity between basic blocks according to the bytecode instruction sequences and the structural property of the basic blocks. Then, an error-tolerant graph matching algorithm that can combat structure transformations is used to match the Control Flow Graphs (CFG) based on the basic block similarity. The high-level similarity between Java programs is subsequently calculated on the matched pairs of the independent paths extracted from the optimal CFG matching. The proposed CFG-Match approach is compared with a string-based approach, a tree-based approach and a graph-based approach. Experimental results show that the CFG-Match approach is more accurate and robust against semantics-preserving transformations. The CFG-Match approach is used to detect Java program plagiarism. Experiments on the collection of benchmark program pairs collected from the students’ submission of project assignments demonstrate that the CFG-Match approach outperforms the comparative approaches in the detection of Java program plagiarism.
3
Kapoor, Akshay, and Sunita Dhavale. "Control Flow Graph Based Multiclass Malware Detection Using Bi-normal Separation." Defence Science Journal 66, no. 2 (2016): 138. http://dx.doi.org/10.14429/dsj.66.9701.
Full textAbstract:
<p>Control flow graphs (CFG) and OpCodes extracted from disassembled executable files are widely used for malware detection. Most of the research in static analysis is focused on binary class malware detection which only classifies an executable as benign or malware. To overcome this issue, CFG based multiclass malware detection system that automatically classifies the malware into their respective families is proposed. The use Bi-normal separation (BNS) as a feature scoring metric. Experimental results show that proposed method using BNS outperforms compared to hitherto use technique of document Frequency for multiclass metamorphic malware detection and achieves detection accuracy of 99.5 per cent.</p><p> </p>
4
WANG, XUEXIANG, HANLAI PU, JUN YANG, and LONGXING SHI. "EXTENDED CONTROL FLOW GRAPH BASED PERFORMANCE AND ENERGY CONSUMPTION OPTIMIZATION USING SCRATCH-PAD MEMORY." Journal of Circuits, Systems and Computers 18, no. 04 (2009): 697–711. http://dx.doi.org/10.1142/s0218126609005204.
Full textAbstract:
A Scratch-Pad memory (SPM) allocation method to improve the performance of a specified application while reducing its energy consumption is presented in this paper. Integrated in the design is an extended control flow graph (ECFG) built directly from the application's instruction flow. The application of the design is transformed into a directed graph that consists of nodes and relationships. Likewise, to provide a solution in decreasing the overhead of moving nodes to SPM, the design is enhanced with a refined greedy algorithm based on ECFG. An experiment is conducted to prove the feasibility and efficiency of the method. The results indicate that the method indeed improves performance by an average of 11% and consumes lesser energy by an average of 28%. This is in comparison to previous research which based on the control flow graph (CFG) method. The latter was discovered to have disregarded the relationships of nodes. In conclusion, the application's execution time and energy consumption were reduced by an average up to 56% and 69% respectively, compared to a non-SPM environment.
5
WONG, W. ERIC, and YU LEI. "REACHABILITY GRAPH-BASED TEST SEQUENCE GENERATION FOR CONCURRENT PROGRAMS." International Journal of Software Engineering and Knowledge Engineering 18, no. 06 (2008): 803–22. http://dx.doi.org/10.1142/s0218194008003878.
Full textAbstract:
One common approach to test sequence generation for structurally testing concurrent programs involves constructing a reachability graph (RG) and selecting a set of paths from the graph to satisfy some coverage criterion. It is often suggested that test sequence generation methods for testing sequential programs based on a control flow graph (CFG) can also be used to select paths from an RG for testing concurrent programs. However, there is a major difference between these two, as the former suffers from a feasibility problem (i.e., some paths in a CFG may not be feasible at run-time) and the latter does not. As a result, even though test sequence generation methods for sequential programs can be applied to concurrent programs, they may not be efficient. We propose four methods — two based on hot spot prioritization and two based on topological sort — to effectively generate a small set of test sequences that covers all the nodes in an RG. The same methods are also applied to the corresponding dual graph for generating test sequences to cover all the edges. A case study was conducted to demonstrate the use of our methods.
6
Dong, Kwan Kim. "Enhancing code clone detection using control flow graphs." International Journal of Electrical and Computer Engineering (IJECE) 9, no. 5 (2019): 3804–12. https://doi.org/10.11591/ijece.v9i5.pp3804-3812.
Full textAbstract:
Code clones are syntactically or semantically equivalent code fragments of source code. Copy-and-paste programming allows software developers to improve development productivity, but it could produce code clones that can introduce non-trivial difficulties in software maintenance. In this paper, a code clone detection framework is presented with a feature extractor and a clone classifier using deep learning. The clone classifier is trained with true and false clones and then is tested with a test dataset to evaluate the performance of the proposed approach to clone detection. In particular, the proposed approach to clone detection uses Control Flow Graphs (CFGs) to extract features of a given code snippet. The selected features are used to compute similarity scores for comparing two code fragments. The clone classifier is trained and tested with similarity scores that quantify the degree of how similar two code fragments are. The experimental results demonstrate that using CFG features is a viable methodology in terms of the effectiveness of clone detection for both syntactic and semantic clones.
7
Qiang, Weizhong, Shizhen Wang, Hai Jin, and Jiangying Zhong. "Fine-Grained Control-Flow Integrity Based on Points-to Analysis for CPS." Security and Communication Networks 2018 (October 17, 2018): 1–11. http://dx.doi.org/10.1155/2018/3130652.
Full textAbstract:
A cyber-physical system (CPS) is known as a mix system composed of computational and physical capabilities. The fast development of CPS brings new security and privacy requirements. Code reuse attacks that affect the correct behavior of software by exploiting memory corruption vulnerabilities and reusing existing code may also be threats to CPS. Various defense techniques are proposed in recent years as countermeasures to emerging code reuse attacks. However, they may fail to fulfill the security requirement well because they cannot protect the indirect function calls properly when it comes to dynamic code reuse attacks aiming at forward edges of control-flow graph (CFG). In this paper, we propose P-CFI, a fine-grained control-flow integrity (CFI) method, to protect CPS against memory-related attacks. We use points-to analysis to construct the legitimate target set for every indirect call cite and check whether the target of the indirect call cite is in the legitimate target set at runtime. We implement a prototype of P-CFI on LLVM and evaluate both its functionality and performance. Security analysis proves that P-CFI can mitigate the dynamic code reuse attack based on forward edges of CFG. Performance evaluation shows that P-CFI can protect CPS from dynamic code reuse attacks with trivial time overhead between 0.1% and 3.5% (Copyright © 2018 John Wiley & Sons, Ltd.).
8
Gao, Hao, Tong Zhang, Songqiang Chen, Lina Wang, and Fajiang Yu. "FUSION: Measuring Binary Function Similarity with Code-Specific Embedding and Order-Sensitive GNN." Symmetry 14, no. 12 (2022): 2549. http://dx.doi.org/10.3390/sym14122549.
Full textAbstract:
Binary code similarity measurement is a popular research area in binary analysis with the recent development of deep learning-based models. Current state-of-the-art methods often use the pre-trained language model (PTLM) to embed instructions into basic blocks as representations of nodes within a control flow graph (CFG). These methods will then use the graph neural network (GNN) to embed the whole CFG and measure the binary similarities between these code embeddings. However, these methods almost directly treat the assembly code as a natural language text and ignore its code-specific features when training PTLM. Moreover, They barely consider the direction of edges in the CFG or consider it less efficient. The weaknesses of the above approaches may limit the performances of previous methods. In this paper, we propose a novel method called function similarity using code-specific PPTs and order-sensitive GNN (FUSION). Since the similarity of binary codes is a symmetric/asymmetric problem, we were guided by the ideas of symmetry and asymmetry in our research. They measure the binary function similarity with two code-specific PTLM training strategies and an order-sensitive GNN, which, respectively, alleviate the aforementioned weaknesses. FUSION outperforms the state-of-the-art binary similarity methods by up to 5.4% in accuracy, and performs significantly better.
9
Stiawan, Deris, Somame Morianus Daely, Ahmad Heryanto, Nurul Afifah, Mohd Yazid Idris, and Rahmat Budiarto. "Ransomware Detection Based On Opcode Behavior Using K-Nearest Neighbors Algorithm." Information Technology and Control 50, no. 3 (2021): 495–506. http://dx.doi.org/10.5755/j01.itc.50.3.25816.
Full textAbstract:
Ransomware is a malware that represents a serious threat to a user’s information privacy. By investigating howransomware works, we may be able to recognise its atomic behaviour. In return, we will be able to detect theransomware at an earlier stage with better accuracy. In this paper, we propose Control Flow Graph (CFG) asan extracting opcode behaviour technique, combined with 4-gram (sequence of 4 “words”) to extract opcodesequence to be incorporated into Trojan Ransomware detection method using K-Nearest Neighbors (K-NN)algorithm. The opcode CFG 4-gram can fully represent the detailed behavioural characteristics of Trojan Ransomware.The proposed ransomware detection method considers the closest distance to a previously identifiedransomware pattern. Experimental results show that the proposed technique using K-NN, obtains the best accuracyof 98.86% for 1-gram opcode and using 1-NN classifier.
10
Park, Jungsoo, and Souhwan Jung. "Android Adware Detection using Soot and CFG." Journal of Wireless Mobile Networks, Ubiquitous Computing, and Dependable Applications 13, no. 4 (2022): 94–104. http://dx.doi.org/10.58346/jowua.2022.i4.006.
Full textAbstract:
Adware is the most common type of malware. While considered not harmful in nature, it disrupts the user experience and generates unwanted revenue. Adware is also difficult to analyze and detect, therefore it is actively distributed through the Google Play Store. In the case of known adware detection, analysis takes a long time due to prolonged dynamic analysis to reveal Ads, and the result of network traffic analysis is difficult to determine traffic such as multimedia streaming, which results in a high probability of false positives. In this paper, we introduce a method to efficiently detect adware using static analysis. CFG(Control Flow Graph) analysis was performed using Soot to identify the adware signatures. 52 signatures were obtained through analysis of 1000 samples, and the optimized detection efficiency was measured while changing the depth (level) of the CFG. In addition, it achieves 91.92% of accuracy when analyzing 1380 normal and 4490 adware samples. This approach has similar detection rate in a shorter time compared to the existing dynamic analysis, and it does not require operation check as in previous dynamic analysis approaches.
11
Yu, Zeping, Rui Cao, Qiyi Tang, Sen Nie, Junzhou Huang, and Shi Wu. "Order Matters: Semantic-Aware Neural Networks for Binary Code Similarity Detection." Proceedings of the AAAI Conference on Artificial Intelligence 34, no. 01 (2020): 1145–52. http://dx.doi.org/10.1609/aaai.v34i01.5466.
Full textAbstract:
Binary code similarity detection, whose goal is to detect similar binary functions without having access to the source code, is an essential task in computer security. Traditional methods usually use graph matching algorithms, which are slow and inaccurate. Recently, neural network-based approaches have made great achievements. A binary function is first represented as an control-flow graph (CFG) with manually selected block features, and then graph neural network (GNN) is adopted to compute the graph embedding. While these methods are effective and efficient, they could not capture enough semantic information of the binary code. In this paper we propose semantic-aware neural networks to extract the semantic information of the binary code. Specially, we use BERT to pre-train the binary code on one token-level task, one block-level task, and two graph-level tasks. Moreover, we find that the order of the CFG's nodes is important for graph similarity detection, so we adopt convolutional neural network (CNN) on adjacency matrices to extract the order information. We conduct experiments on two tasks with four datasets. The results demonstrate that our method outperforms the state-of-art models.
12
M., Nandish, Jalesh Kumar, Mohan H. G., and Manjunath Sargur Krishnamurthy. "GraphConvDeep: A Deep Learning Approach for Enhancing Binary Code Similarity Detection using Graph Embeddings." International Journal of Computer Network and Information Security 17, no. 3 (2025): 72–88. https://doi.org/10.5815/ijcnis.2025.03.05.
Full textAbstract:
Binary code similarity detection (BCSD) is a method for identifying similarities between two or more slices of binary code (machine code or assembly code) without access to their original source code. BCSD is often used in many areas, such as vulnerability detection, plagiarism detection, malware analysis, copyright infringement and software patching. Numerous approaches have been developed in these areas via graph matching and deep learning algorithms. Existing solutions have low detection accuracy and lack cross-architecture analysis. This work introduces a cross-platform graph deep learning-based approach, i.e., GraphConvDeep, which uses graph convolution networks to compute the embedding. The proposed GraphConvDeep approach relies on the control flow graph (CFG) of individual binary functions. By evaluating the distance between two embeddings of functions, the similarity is detected. The experimental results show that GraphConvDeep is better than other cutting-edge methods at accurately detecting similarities, achieving an average accuracy of 95% across different platforms. The analysis shows that the proposed approach achieves better performance with an area under the curve (AUC) value of 96%, particularly in identifying real-world vulnerabilities.
13
Liu, Guangming, Xin Zhou, Jianmin Pang, Feng Yue, Wenfu Liu, and Junchao Wang. "Codeformer: A GNN-Nested Transformer Model for Binary Code Similarity Detection." Electronics 12, no. 7 (2023): 1722. http://dx.doi.org/10.3390/electronics12071722.
Full textAbstract:
Binary code similarity detection is used to calculate the code similarity of a pair of binary functions or files, through a certain calculation method and judgment method. It is a fundamental task in the field of computer binary security. Traditional methods of similarity detection usually use graph matching algorithms, but these methods have poor performance and unsatisfactory effects. Recently, graph neural networks have become an effective method for analyzing graph embeddings in natural language processing. Although these methods are effective, the existing methods still do not sufficiently learn the information of the binary code. To solve this problem, we propose Codeformer, an iterative model of a graph neural network (GNN)-nested Transformer. The model uses a Transformer to obtain an embedding vector of the basic block and uses the GNN to update the embedding vector of each basic block of the control flow graph (CFG). Codeformer iteratively executes basic block embedding to learn abundant global information and finally uses the GNN to aggregate all the basic blocks of a function. We conducted experiments on the OpenSSL, Clamav and Curl datasets. The evaluation results show that our method outperforms the state-of-the-art models.
14
Kim, Dong Kwan. "Enhancing code clone detection using control flow graphs." International Journal of Electrical and Computer Engineering (IJECE) 9, no. 5 (2019): 3804. http://dx.doi.org/10.11591/ijece.v9i5.pp3804-3812.
Full textAbstract:
Code clones are syntactically or semantically equivalent code fragments of source code. Copy-and-paste programming allows software developers to improve development productivity, but it could produce code clones that can introduce non-trivial difficulties in software maintenance. In this paper, a code clone detection framework is presented with a feature extractor and a clone classifier using deep learning. The clone classifier is trained with true and false clones and then is tested with a test dataset to evaluate the performance of the proposed approach to clone detection. In particular, the proposed approach to clone detection uses Control Flow Graphs (CFGs) to extract features of a given code snippet. The selected features are used to compute similarity scores for comparing two code fragments. The clone classifier is trained and tested with similarity scores that quantify the degree of how similar two code fragments are. The experimental results demonstrate that using CFG features is a viable methodology in terms of the effectiveness of clone detection for both syntactic and semantic clones.
15
Althunibat, Ahmed, Mustafa Mahmood, Hend Alnuhait, Sally Almanasra, and Haneen A. Al-Khawaja. "Proposed Test Case Generation Model using Fuzzy Logic (TCGMFL)." WSEAS TRANSACTIONS ON COMPUTER RESEARCH 12 (November 22, 2023): 161–72. http://dx.doi.org/10.37394/232018.2024.12.16.
Full textAbstract:
This research addresses the pressing need to enhance software testing, specifically focusing on white-box testing and basis path generation. Software testing is a linchpin in the software development process, ensuring software operates flawlessly and aligns with its intended objectives. However, this phase often incurs substantial time and resource investments. The primary aim of this study is to introduce an efficient and automated approach for basis path generation, a crucial component of white-box testing. The model commences by transforming source code into a tailored control flow graph (CFG), streamlining the automated generation of test paths. Central to this model is an algorithm for generating test paths (AGTP), meticulously traversing CFG nodes from source to destination. The algorithm’s design aims to comprehensively cover all test paths within the CFG. To enhance testing process efficiency, the model employs k-means clustering to generate and cluster inputs. Path coverage is rigorously assessed for each cluster, and fuzzy logic is used to determine the optimal path. The overarching goals of this research are to reduce time and financial costs associated with software testing while maintaining precision and efficiency. The model’s effectiveness in generating test cases is confirmed through the examination of multiple examples, underscoring its valuable contribution to software testing. This study marks a significant advancement toward more effective and cost-efficient software testing methodologies.
16
Tauner, Stefan, and Mario Telesklav. "Comparative Analysis and Enhancement of CFG-based Hardware-Assisted CFI Schemes." ACM Transactions on Embedded Computing Systems 20, no. 5s (2021): 1–25. http://dx.doi.org/10.1145/3476989.
Full textAbstract:
Subverting the flow of instructions (e.g., by use of code-reuse attacks) still poses a serious threat to the security of today’s systems. Various control flow integrity (CFI) schemes have been proposed as a powerful technique to detect and mitigate such attacks. In recent years, many hardware-assisted implementations of CFI enforcement based on control flow graphs (CFGs) have been presented by academia. Such approaches check whether control flow transfers follow the intended CFG by limiting the valid target addresses. However, these papers all target different platforms and were evaluated with different sets of benchmark applications, which makes quantitative comparisons hardly possible. For this paper, we have implemented multiple promising CFG-based CFI schemes on a common platform comprising a RISC-V within FPGA. By porting almost 40 benchmark applications to this system we can present a meaningful comparison of the various techniques in terms of run-time performance, hardware utilization, and binary size. In addition, we present an enhanced CFI approach that is inspired by what we consider the best concepts and ideas of previously proposed mechanisms. We have made this approach more practical and feature-complete by tackling some problems largely ignored previously. We show with this fine-grained scheme that CFI can be achieved with even less overheads than previously demonstrated.
17
Yang, Haixin, Zhen Li, and Xinyu Guo. "A Novel Source Code Clone Detection Method Based on Dual-GCN and IVHFS." Electronics 12, no. 6 (2023): 1315. http://dx.doi.org/10.3390/electronics12061315.
Full textAbstract:
Source code clone detection, which can identify code fragments with similar functions, plays a significant role in software development and quality assurance. Existing methods either extract single syntactic or semantic information, or ignore the associated information between code statements in different structures. It is difficult for these methods to effectively detect clone pairs with similar functions. In this paper, we propose a new model based on a dual graph convolutional network (GCN) and interval-valued hesitant fuzzy set (IVHFS), which we named DG-IVHFS. Specifically, we simplified and grouped the abstract syntax tree (AST) of source code to obtain the group representations. The group representations of the AST, as well as the control flow graph (CFG) representations, were transformed into graph structures, and then we applied GCNs on them to learn dependencies between nodes. In addition, we introduced IVHFS into the model for a more comprehensive evaluation of similarity. Our experimental results demonstrated that the precision, recall, and F1-scores of DG-IVHFS on the BigCloneBench and GoogleCodeJam datasets reached 98, 97 and 97% and 98, 93 and 95%, respectively, exceeding current state-of-the-art models. Moreover, our model performed well in terms of time consumption.
18
Lee, Sungbin, and Jeonghun Cho. "ACE-M: Automated Control Flow Integrity Enforcement Based on MPUs at the Function Level." Electronics 11, no. 6 (2022): 912. http://dx.doi.org/10.3390/electronics11060912.
Full textAbstract:
Control-flow integrity(CFI) ensures that the execution flow of a program follows the control-flow graph(CFG) determined at compile time. CFI is a security technique designed to prevent runtime attacks such as return-oriented programming (ROP). With the development of the Internet of Things (IoT), the number of embedded devices has increased, and security and protection techniques in embedded systems have become important. Since the hardware-based CFI technique requires separate hardware support, it is difficult to apply to an embedded device that is already arranged. In this paper, we propose a function-level CFI technique named ACE-M, which uses the memory protection unit (MPU) included in most embedded devices. MPU may provide attributes such as read-write-execute to the memory area. ACE-M has three steps: (1) initiate—inserts an MPU-related function into a specific position; (2) profiling—provides information for MPU configuration. After the initation step, several pieces of information can be determined; (3) set—modify the already-inserted function’s arguments. We propose a design that supports the MPU. In our model, the MPU becomes a control flow monitor that detects control flow errors(CFEs), and the inserted codes cause the MPU to act as a control flow checker. If the program deviates from the original control flow, the MPU raises an exception since its corresponding area will not be included in the executable area. This approach not only verifies the target address but also guarantees the running position. Our technique can detect any modification of the program counter (PC) to an arbitrary address.
19
Yang, Zhao Hong, Qing Xiao, Yun Zhan Gong, Da Hai Jin, and Ya Wen Wang. "The Research of an Abstract Semantic Framework for Defect Detecting." Advanced Materials Research 186 (January 2011): 536–40. http://dx.doi.org/10.4028/www.scientific.net/amr.186.536.
Full textAbstract:
This paper proposes a non-relational abstract semantic framework. It uses interval set to represent the value of numerical variables and complete lattice to represent Boolean variables and reference variables. It presents the abstract computation method of basic expressions and the nodes of control flow graph. It uses function summaries to represent the context information of function call needed by defects detecting. Based on the results of abstract computation, it uses extended state machine to define defect patterns and proposes a path-sensitive method based on dataflow analysis to detect defects. It avoids the combination explosion of full path analysis by merging the conditions of identical property state at join points in the CFG. Practical test results show that the proposed methods have features of high efficiency, low false positive and low false negative.
20
Khoshavi, Navid, Hamid Zarandi, and Mohammad Maghsoudloo. "Two control-flow error recovery methods for multithreaded programs running on multi-core processors." Facta universitatis - series: Electronics and Energetics 28, no. 3 (2015): 309–23. http://dx.doi.org/10.2298/fuee1503309k.
Full textAbstract:
This paper presents two control-flow error recovery techniques, CFE Recovery using Data-flow graph Consideration and CFE Recovery using Macro block-level Check pointing. These techniques are proposed with regards to thread interactions in the programs. These techniques try to moderate the high memory and performance overheads of conventional control-flow checking techniques. The proposed recovery techniques are composed of two phases of control-flow error detection and recovery. These phases are designed by means of inserting additional instructions into program at compile time considering dependency graph, extracted from control-flow and data-flow dependencies among basic blocks and thread interactions in the programs. In order to evaluate the proposed techniques, five multithreaded benchmarks are utilized to run on a multi-core processor. Moreover, a total of 10000 transient faults have been injected into several executable points of each program. Fault injection experiments show that the proposed techniques recover the detected errors at-least for 91% of the cases.
21
Setyawan, Moh Arsyad Mubarak, Fajar Pradana, and Bayu Priyambadha. "Pengembangan sistem otomatisasi pembangkitan kasus uji dengan algoritma genetika dan test case generation method." teknologi 10, no. 1 (2020): 1. http://dx.doi.org/10.26594/teknologi.v10i1.1912.
Full textAbstract:
Pengujian perangkat lunak merupakan salah satu bagian penting dari pembuatan perangkat lunak. Pada pengujian perangkat lunak terdapat pengujian unit. Pengujian unit merupakan proses pengujian komponen yang berfokus untuk memverifikasi unit terkecil pada perancangan perangkat lunak. Pada tahap pengujian unit terdapat proses pembangkitan kasus uji. Selama ini, pembangkitan kasus uji dari suatu kode program dilakukan secara manual se-hingga membutuhkan waktu yang lama. Hal ini dikarenakan banyaknya kemungkinan jalur pada kode sumber yang akan diuji. Dalam penelitian ini dibangun suatu sistem otomatis untuk membangkitkan kasus uji. Alur kerja sistem dimulai dari analisa kode sumber dengan Spoon Library, selanjutnya dibentuk CFG (Control Flow Graph) dan DDG (Dynamic Directed Graph). Dari DDG tersebut akan dibangkitkan jalur layak yang terdapat pada DDG, dengan menggunakan algoritma genetika diharapkan dapat mengoptimalkan penentuan jalur independen. Dari masing-masing jalur independen akan dibangkitkan kasus ujinya dengan metode test case generation. Pengujian akurasi sistem pada sistem otomatisasi pembangkit kasus uji dengan jumlah populasi 5, 10 dan 15 serta jumlah maksimum generasi 50, 100, 200 dan 250 dihasilkan jumlah populasi paling optimal yaitu 10 dan maksimum generasi optimal yaitu 200 dengan akurasi 93,33%. Pada jumlah populasi dan maksimum generasi sesudahnya tidak terjadi peningkatan akurasi yang signifikan. Tiap peningkatan jumlah populasi dan maksimum generasi dapat meningkatkan akurasi sistem. Software testing is one of the most important part of making software. On the software testing there are unit testing. Unit Testing is a process for verifying component, focusing on the smallest unit of software design. In the unit testing phase contained test case generation process. During this time, the generation of test cases of a program code is done manually. In this study, constructed an automated system to generate test cases. The workflow system starts from the analysis of the source code with the library spoon and then create CFG (Control Flow Graph) and DDG (Dynamic Directed graph). From the DDG will be raised feasible path using a genetic algorithm. Furthermore, from fea-sible path sought independenth path which is a path base d on the level of uniqueness of the path to the other path. From each independenth path raised the test case with a test case generation method. Testing accuracy of the system on the automation system generating test cases with populations of 5,10 and 15 as well as the maximum number of generations 50, 100, 200 and 250 produced the most optimal population number is 15 and the most optimal maximum generation is 200 with accuracy 93.33%. Each increase in the number of population and maximum generation can improve the accuracy of the system. Level accuracy with population number over 10 and maximum generation over 200 has no increace accuracy significant.
22
Liu, Qiang, Wei Zhu, Feng Ma, Xiyu Jia, Yu Gao, and Jun Wen. "Graph attention network-based fluid simulation model." AIP Advances 12, no. 9 (2022): 095114. http://dx.doi.org/10.1063/5.0122165.
Full textAbstract:
Traditional computational fluid dynamics (CFD) techniques deduce the dynamic variations in flow fields by using finite elements or finite differences to solve partial differential equations. CFD usually involves several tens of thousands of grid nodes, which entail long computation times and significant computational resources. Fluid data are usually irregular data, and there will be turbulence in the flow field where the physical quantities between adjacent grid nodes are extremely nonequilibrium. We use a graph attention neural network to build a fluid simulation model (GAFM). GAFM assigns weights to adjacent node-pairs through a graph attention mechanism. In this way, it is not only possible to directly calculate the fluid data but also to adjust for nonequilibrium in vortices, especially turbulent flows. The GAFM deductively predicts the dynamic variations in flow fields by using spatiotemporally continuous sample data. A validation of the proposed GAFM against the two-dimensional (2D) flow around a cylinder confirms its high prediction accuracy. In addition, the GAFM achieves faster computation speeds than traditional CFD solvers by two to three orders of magnitude. The GAFM provides a new idea for the rapid optimization and design of fluid mechanics models and the real-time control of intelligent fluid mechanisms.
23
Zhao, Jingwen, Yanxia Wu, Yan Fu, and Shuyong Liu. "ESfix: An Embedded Program Repair Tool for Effective Removal of Concurrency Defects." Entropy 27, no. 3 (2025): 294. https://doi.org/10.3390/e27030294.
Full textAbstract:
Embedded programs are not only inseparable from our daily lives but are also widely used in aerospace, medical devices, and other fields that require very high security and stability. The uncertainty and randomness of the large amount of data generated by these systems during operation can be quantified by entropy. Traditional repair methods for concurrency defects may introduce new issues such as deadlocks, original semantic destruction, and high performance overhead. To overcome the limitations of the existing methods and help developers reduce the time and effort spent on fixing software defects, this paper proposes ESfix, a defect fixing technique applied to embedded software. ESfix first utilizes the bug information reported by the defect detection tool to locate the repair region and extracts the node information corresponding to the defective code. Then, ESfix optimizes the interrupt disable/enable strategies and lock strategies to repair data race and reduce bugs in information transmission, thereby reducing system entropy and improving data certainty and reliability. Finally, ESfix repairs atomicity violation defects using the reordering repair strategy, reducing information entropy by adjusting the order of information to ensure its integrity and consistency. ESfix conducts semantic analysis by analyzing the dependency graph in the control flow graph (CFG) to ensure that no new defects are introduced during the repair process, and to maintain the efficiency and accuracy of information transmission between different parts of the code. We evaluate the effectiveness of repair strategies through information entropy, and the experimental results show that ESfix not only improves performance but also reduces potential risks and losses.
24
Wang, Zhongru, Yuntao Zhang, Zhihong Tian, et al. "Automated Vulnerability Discovery and Exploitation in the Internet of Things." Sensors 19, no. 15 (2019): 3362. http://dx.doi.org/10.3390/s19153362.
Full textAbstract:
Recently, automated software vulnerability detection and exploitation in Internet of Things (IoT) has attracted more and more attention, due to IoT’s fast adoption and high social impact. However, the task is challenging and the solutions are non-trivial: the existing methods have limited effectiveness at discovering vulnerabilities capable of compromising IoT systems. To address this, we propose an Automated Vulnerability Discovery and Exploitation framework with a Scheduling strategy, AutoDES that aims to improve the efficiency and effectiveness of vulnerability discovery and exploitation. In the vulnerability discovery stage, we use our Anti-Driller technique to mitigate the “path explosion” problem. This approach first generates a specific input proceeding from symbolic execution based on a Control Flow Graph (CFG). It then leverages a mutation-based fuzzer to find vulnerabilities while avoiding invalid mutations. In the vulnerability exploitation stage, we analyze the characteristics of vulnerabilities and then propose to generate exploits, via the use of several proposed attack techniques that can produce a shell based on the detected vulnerabilities. We also propose a genetic algorithm (GA)-based scheduling strategy (AutoS) that helps with assigning the computing resources dynamically and efficiently. The extensive experimental results on the RHG 2018 challenge dataset and the BCTF-RHG 2019 challenge dataset clearly demonstrate the effectiveness and efficiency of the proposed framework.
25
Gu, Zhenghua, Wenqing Wan, Jundong Xie, and Chang Wu. "Dependency Graph-based High-level Synthesis for Maximum Instruction Parallelism." ACM Transactions on Reconfigurable Technology and Systems 14, no. 4 (2021): 1–15. http://dx.doi.org/10.1145/3468875.
Full textAbstract:
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.
26
Kar, Santosh Kumar, Brojo Kishore Mishra, and Sanjit Kumar Acharya. "Refurbishment of object-oriented code: A methodical approach to minimize program complexity." Journal of Decision Analytics and Intelligent Computing 5, no. 1 (2025): 52–69. https://doi.org/10.31181/jdaic10018052025k.
Full textAbstract:
In order to determine software testing competence, test coverage analysis techniques are commonly implemented. The uncovered areas or statements of a program are identified using a technique that employs a set of test cases best suited for the program. Depending on the current approach or the complexity of the program, the concept of test coverage is especially useful in identifying and eliminating test cases that do not contribute significantly to achieving the desired output. In other words, this technique helps in making a program more robust and error-free. It is also useful for identifying sections of a requirement that are not covered by existing test cases. The technique is helpful in creating new test cases to enhance the coverage of a program. As a rigorous quality control practice, it supports the development of experimental test coverage metrics. Therefore, ineffective test scenarios that do not contribute to increased coverage should be tracked and eliminated, thereby reducing the overall complexity of the program. Our approach in this paper aims to create a Control Flow Graph (CFG) for randomly generated object-oriented programs in Java and assess the cyclomatic complexity for each by analyzing the nodes and edges using the traditional formula from the software engineering paradigm. We then identify the best approach to write the program by applying prioritization techniques to the calculated complexity values of the object-oriented programs. This enables us to minimize the complexity of the program during the code development process.
27
Wasiur, Rhmann*1 Gufran Ansari2. "APPLICATION OF CLONAL SELECTION ALGORITHM IN SOFTWARE TEST DATA GENERATION." INTERNATIONAL JOURNAL OF ENGINEERING SCIENCES & RESEARCH TECHNOLOGY 6, no. 7 (2017): 452–59. https://doi.org/10.5281/zenodo.829221.
Full textAbstract:
This paper presents an artificial immune system (AIS) based optimized test data generation technique. Software test data generation is a critical activity in software testing. Redundant test data impose an extra cost in form of more testing and increase in efforts. So the generation of effective test data can save time and efforts spent on extra testing of the software. Optimized test data is generated for critical paths of the program. Paths criticality is defined based on the presence of loops and decision. The clonal selection algorithm is an immune system based machine learning algorithm and generates optimized test data by the maturation of the affinity. Generated results indicate the effective application of clonal selection technique in software test data generation.
28
Xu, Luhang, Liangze Yin, Wei Dong, Weixi Jia, and Yongjun Li. "Expediting Binary Fuzzing with Symbolic Analysis." International Journal of Software Engineering and Knowledge Engineering 28, no. 11n12 (2018): 1701–18. http://dx.doi.org/10.1142/s0218194018400247.
Full textAbstract:
Fuzzing is an important method for binary vulnerability mining. It can analyze binary programs without their source codes, which is not easy to do by other technologies. But due to the blindness of input generation, binary fuzzing often falls into traps for a long time when the new mutated inputs cannot generate unexplored paths. In this paper, we propose an efficient and flexible fuzzing framework named Tinker. It defines the growth rate of path coverage to measure the current state of fuzzing. If the fuzzing falls into low-speed or blocked states, a symbolic analysis procedure is invoked to generate a new input which can help the fuzzing jump out of the trap. In the symbolic analysis procedure, we employ dynamic execution to track the traversed nodes. The untraversed branches are then identified according to the recorded data of American Fuzzy Lop (AFL) [M. Zalewski, American Fuzzy Lop (2014), http://lcamtuf.coredump.cx/afl/ ]. At last, we employ control flow graph (CFG) to construct complete paths to these branches and a new input is generated using symbolic execution. Moreover, to expedite the detection of vulnerabilities, we generate inputs which trigger more high-risk system calls first, such that the possibility of finding vulnerabilities can be improved. Tinker has been implemented and the experiments on DARPA CGC benchmark show that Tinker is more efficient in vulnerability mining than state-of-the-art binary vulnerability mining tools.
29
Liu, Chang Yun, Xue Zeng Zhao, and Fang Chen. "Application of Numerical Simulation in Analysis and Optimization of Constant Flux Blanking Plug." Materials Science Forum 532-533 (December 2006): 765–68. http://dx.doi.org/10.4028/www.scientific.net/msf.532-533.765.
Full textAbstract:
The constant flux blanking plug is a downhole flow control device used in the separate layer water injection system of oil-field, its flow characteristic and reliability are the most important matters that people care about. So these performances of the constant flux blanking plug are analyzed by numerical methods here. The dynamic model of the constant flux blanking plug is established by bond-graph, then the simulation is made by the 20-SIM software. The influence of local flow field is studied by CFD (computational fluid dynamics), with which some different valve spools and pockets are compared. The discrete particles’ trajectories are analyzed by the Lagrangian method, and the particle erosion rates of different materials are calculated with Bitter’s erosion model. All the simulation data show that the structure and material have great influence on the flow control precision and reliability which need to improve at present. The simulation results are verified through ground or field tests in the end.
30
Riyadhthusollehan Khairulfuaad, Norzelawati Asmuin, Juntakan Taweekun, Azizan Ismail, and Nabil Izzuddin Shahhidan. "CFD Analysis for Valve-Holding Camber Permanent Inhaler Spacer (AerospaAcer) with Different Valves." CFD Letters 16, no. 6 (2024): 53–67. http://dx.doi.org/10.37934/cfdl.16.6.5367.
Full textAbstract:
During the COVID-19 pandemic, data statistics showed that patients with respiratory problems become infected. One of the therapy techniques for the respiratory condition was the use of a metered-dose inhaler and spacer. The objective of this paper is to determine the flow parameters of three types of valves which is duckbill valve, cross slit valve and umbrella valve in inhaler spacer to compare fluid flow between valve Previous researchers chose the duckbill valve to control fluid flow in inhaler spacer. The flow characteristics are unaffected by the materials used in the new disposable inhaler spacers, such as paper and polylactic acid (PLA). Several design valves reduced the skewness below 0.94 by suppressing the fillet and chamfer. ANSYS Workbench Fluent 19.2 is used to calculate flow parameters such as turbulence kinetic energy (TKE), turbulence eddy dissipation (TED), velocity, particle velocity magnitude, streamline, and vector velocity. The setup input data is based on the previous researcher's specified parameters such as viscosity model, drug characteristics (salbutamol and propellant), discrete phase model (DPM) equal to 80, boundary condition model, and SIMPLE technique. For the three types of valves, the nozzle injection used a 0.50-millimetre dimension. The simulation work is cross-checked against the results of prior simulations. Within each iteration, the transient flow employed a time step size of 0.01 for 200 steps. The results show that computational analysis can distinguish between models of varying complexity. The TED, TKE, and velocity graphs showed the approximate value between the model geometries. Overall, the study was successful in achieving the desired velocity magnitude in terms of visual and graph representations of the various valve.
31
Chumpol, Surachate, Panadda Solod, Krerkchai Thongnoo, and Nattha Jindapetch. "Model-Based Design Optimization using CDFG for Image Processing on FPGA." ECTI Transactions on Computer and Information Technology (ECTI-CIT) 17, no. 4 (2023): 479–87. http://dx.doi.org/10.37936/ecti-cit.2023174.252417.
Full textAbstract:
As the automotive industry moves toward autonomous driving and ADAS (Advanced Driver Assistance Systems), Model-Based Design (MBD) is a practical design methodology. It can be used to develop rapid prototyping by using MATLAB and Simulink. The MBD method still has limitations for handling complex models. This paper uses the Control Data Flow Graph (CDFG), an intermediate representation for analyzing complex algorithms, so that suitable optimizations for image processing applications can be implemented on an FPGA. The experimental results show that the proposed CDFG method improved both the area and speed of the edge detection case study compared with the MathWorks Vision HDL toolbox.
32
Zivkovic, Vladimir, der van, Ed Deprettere, and Kock de. "A new approach for system-level architecture exploration." Facta universitatis - series: Electronics and Energetics 16, no. 1 (2003): 103–14. http://dx.doi.org/10.2298/fuee0301103z.
Full textAbstract:
In this paper, we present a new design-space exploration approach which we call the symbolic program approach. The symbolic program approach is based on both the trace driven approach and the control data flow graph approach. As expected, the trajectory of the symbolic program approach appears somewhere in-between the two extremes mentioned above. Thus, it leads to the shorter simulation time while it can still give fairly accurate performance numbers. Moreover, it produces results that can be readily taken as input for further design. Keywords: System-level, design-space exploration traces, CDFG, symbolic programs.
33
Fukuda, Kazumasa, and Haruaki Tamada. "To Prevent Reverse-Enginnering Tools by Shuffling the Stack Status with Hook Mechanism." International Journal of Software Innovation 3, no. 3 (2015): 14–25. http://dx.doi.org/10.4018/ijsi.2015070102.
Full textAbstract:
In this paper, we propose an obfuscation method to shuffle the stack status for preventing illegal analysis from crackers. Generally, crackers tries building a call flow graph of a program to clarify its behaviors. The call flow graph represents relations among methods, and helps comprehension of a program. On the other hand, a callee is fixed by a method name and the stack status in object oriented languages. Then, changing a stack status causes changing a callee when the callee is overloaded. Therefore, we focus on a hook mechanism to change a callee at runtime by changing the stack status. The program applied our method makes a fake call flow graph (CFG) from reverse-engineering tools, and the fake CFG leads misunderstanding of the program. We conducted two experiments to evaluate the proposed method. First is to evaluate the tolerance against existing reverse-engineering tools: Soot, Jad, Procyon, and Krakatau. The Procyon only succeeded decompilation, the others crashed. Second is to evaluate understandability of the program obfuscated by our method. Only one subject in the nine subjects answered the correct value. The experiments show the proposed method leads misunderstanding even if the target program is tiny and simple.
34
M, Thillai Rani, Rajkumar R, Sai Pradeep K.P, Jaishree M, and Rahul S.G. "Integrated extreme gradient boost with c4.5 classifier for high level synthesis in very large scale integration circuits." ITM Web of Conferences 56 (2023): 01005. http://dx.doi.org/10.1051/itmconf/20235601005.
Full textAbstract:
High-level synthesis (HLS) is utilized for high-performance and energy-efficient heterogeneous systems designing. HLS is assist in field-programmable gate array circuits designing where hardware implementations are refined and replaced in target device. However, the power-process-voltage-temperature-delay (PPVTD) variation in VLSI circuits undergoes many problems and reduced the performance. In order to address these problems, C4.5 with eXtreme Gradient Boosting Classification based High Level Synthesis (C4.5-XGBCHLS) Method is designed for afford better runtime adaptability (RA) with minimal error rate. VLSI circuits are designed using the behavioral input and results are measured at running condition. When VLSI circuit’s results get reduced, the language description of the circuit is considered as an input. Then, compilation process convert high level specification into Intermediate Representation (IR) in control/data flow graph (CDFG). CDFG computes data and control dependencies among operations. eXtreme Gradient Boosting (XGBoost) Classifier is exploited in C4.5-XGBCHLS method to classify the error causing functional unit (FU) with minimal error rate. XGBoost Classifier exploited C4.5 decision tree as base classifier to enhance classification of error causing FU in VLSI circuits. After that, FU gets allocated in place of error causing FU from functional library based on the design objectives and PPVTD variations. Finally, operation scheduling and binding process is executed for register transfer level (RTL) generation to form VLSI circuits with improved RA. The simulation results shows that the C4.5-XGBCHLS method enhances the performance of functional unit selection accuracy (FUSA) with minimal error rate (ER) and circuit adaptability time (CAT).
35
Vershkov, V. A., B. S. Kritsky, and R. M. Mirgazov. "FEATURES OF MODELING THE FLOW AROUND THE HELICOPTER MAIN ROTOR TAKING INTO ACCOUNT ARBITRARY BLADES MOTION." Civil Aviation High TECHNOLOGIES 22, no. 3 (2019): 25–34. http://dx.doi.org/10.26467/2079-0619-2019-22-3-25-34.
Full textAbstract:
The article considers the problem of the flow around the helicopter main rotor taking into account blades flapping in the plane of rotation and in the plane of thrust as well as the elastic blades deformation. The rotor rotation is modeled by the method of converting Navier-Stokes equations from a fixed coordinate system associated with the incoming flow into a rotating system associated with the rotor hub. For axial flow problems, this makes it possible to formulate the problem as stationary at a constant rotational speed of rotor. For a mode of skewed flow around the rotor in the terms of incident flow in this system it is necessary to solve the non-stationary problem. To solve the problem, the method of deformable grids is used, in which the equations are copied taking into account the grid nodes motion determined in accordance with the spatial blades motion, and SST turbulence model is used for closure. The results of the test calculations of the main rotor aerodynamic characteristics with and without blade flapping are presented in this paper. The coefficients of the main rotor thrust cT and the blades hinge moments mh are compared. The calculations were carried out in the CFD software ANSYS CFX (TsAGI License No. 501024). The flow around a four-bladed main rotor of a radius of 2.5 meters is modeled in the regime of skewed flow. The speed of the incoming flow came to 85 m/s under normal atmospheric conditions. The rotor was at an angle of attack of −10˚. To calculate the rotor motion without taking into account the flapping movements, we used the nonstationary system of Navier-Stokes equations with the closure with SST turbulence model. The calculation was being carried out until the change in the maximum value of the rotor thrust during one revolution became less than 1%. For modeling flapping blade movements, the control laws and equations describing the angle of blade flapping as a function from its azimuth angle obtained from the experiment were used. The procedure for reconstructing the grid according to a given law was conducted using standard grid deformation methods presented in the ANSYS CFX software. When solving the nonstationary Navier-Stokes equations, a dual time step was used. The obtained results show that accounting of the effect of flapping movements and cyclic control of the blades has an impact on the character of changing the main rotor thrust coefficient during one revolution and significantly changes the shape of the graph of the hinge moment coefficient of each blade.
36
Wang, Feng Qin, and Heng Jin Ke. "Control Flow Analyze for Procedure Blueprint." Applied Mechanics and Materials 58-60 (June 2011): 1061–66. http://dx.doi.org/10.4028/www.scientific.net/amm.58-60.1061.
Full textAbstract:
Based on the well-defined UML2.0 activity diagram, a meta-model based on Control Flow Diagram is presented. And our strategy in this article is to define an OCL-based mapping in a formal and verifiable form as consistency rules between an AISD and a CFG, so as to ensure the completeness of our meta-models and allow their verification. At last, we adopt a static analyze method to transform procedure blueprint to Control Flow diagram.
37
Gan, Vincent J. L., Han Luo, Yi Tan, Min Deng, and H. L. Kwok. "BIM and Data-Driven Predictive Analysis of Optimum Thermal Comfort for Indoor Environment." Sensors 21, no. 13 (2021): 4401. http://dx.doi.org/10.3390/s21134401.
Full textAbstract:
Mechanical ventilation comprises a significant proportion of the total energy consumed in buildings. Sufficient natural ventilation in buildings is critical in reducing the energy consumption of mechanical ventilation while maintaining a comfortable indoor environment for occupants. In this paper, a new computerized framework based on building information modelling (BIM) and machine learning data-driven models is presented to analyze the optimum thermal comfort for indoor environments with the effect of natural ventilation. BIM provides geometrical and semantic information of the built environment, which are leveraged for setting the computational domain and boundary conditions of computational fluid dynamics (CFD) simulation. CFD modelling is conducted to obtain the flow field and temperature distribution, the results of which determine the thermal comfort index in a ventilated environment. BIM–CFD provides spatial data, boundary conditions, indoor environmental parameters, and the thermal comfort index for machine learning to construct robust data-driven models to empower the predictive analysis. In the neural network, the adjacency matrix in the field of graph theory is used to represent the spatial features (such as zone adjacency and connectivity) and incorporate the potential impact of interzonal airflow in thermal comfort analysis. The results of a case study indicate that utilizing natural ventilation can save cooling power consumption, but it may not be sufficient to fulfil all the thermal comfort criteria. The performance of natural ventilation at different seasons should be considered to identify the period when both air conditioning energy use and indoor thermal comfort are achieved. With the proposed new framework, thermal comfort prediction can be examined more efficiently to study different design options, operating scenarios, and changeover strategies between various ventilation modes, such as better spatial HVAC system designs, specific room-based real-time HVAC control, and other potential applications to maximize indoor thermal comfort.
38
Jang, Hyerean, Moon Chan Park, and Dong Hoon Lee. "IBV-CFI: Efficient fine-grained control-flow integrity preserving CFG precision." Computers & Security 94 (July 2020): 101828. http://dx.doi.org/10.1016/j.cose.2020.101828.
Full text
39
Gautam, Pratiksha, and Hemraj Saini. "Non-Trivial Software Clone Detection Using Program Dependency Graph." International Journal of Open Source Software and Processes 8, no. 2 (2017): 1–24. http://dx.doi.org/10.4018/ijossp.2017040101.
Full textAbstract:
Code clones are copied fragments that occur at different levels of abstraction and may have different origins in a software system. This article presents an approach which shows the significant parts of source code. Further, by using significant parts of a source code, a control flow graph can be generated. This control flow graph represents the statements of a code/program in the form of basic blocks or nodes and the edges represent the control flow between those basic blocks. A hybrid approach, named the Program Dependence Graph (PDG) is also presented in this article for the detection of non-trivial code clones. The program dependency graph approach consists of two approaches as a control dependency graph and a data dependency graph. The control dependency graph is generated by using a control flow graph. This article proposes an approach which can easily generate control flow graphs and by using control flow graph and reduced flowgraph approach, the trivial software clone, a similar textual structure, can be detected.The proposed approach is based on a tokenization concept.
40
Jin, Da Hai, Yun Zhan Gong, Zhao Hong Yang, Qing Xiao, and Chuan Chang Liu. "A Method of Software Static Testing in the Presence of Runtime Exception." Applied Mechanics and Materials 63-64 (June 2011): 789–94. http://dx.doi.org/10.4028/www.scientific.net/amm.63-64.789.
Full textAbstract:
Control flow graph plays an important role in software static testing based on defect patterns, while the impact of runtime exception on control flow graph is not negligible. After the runtime exception control flow graph and exception pattern Finite State Machine were defined, an algorithm for fault detection in the presence of runtime exception was proposed. Basing on FSM for exception pattern, the feasible states and its condition are iterated along the node of control flow graph, while the abnormal status, which can throw a runtime exception, will be added into control flow graph as an edge automatically. Thus the static testing method can detect more defects by the control flow graph constructed dynamically. The experiment results show that, the static testing method in the presence of runtime exception can decrease defect false negative significantly.
41
Xu, Pei, Yuxiang Lei, Yulei Sui, and Jingling Xue. "Iterative-Epoch Online Cycle Elimination for Context-Free Language Reachability." Proceedings of the ACM on Programming Languages 8, OOPSLA1 (2024): 1437–62. http://dx.doi.org/10.1145/3649862.
Full textAbstract:
Context-free language reachability (CFL-reachability) is a fundamental framework for implementing various static analyses. CFL-reachability utilizes context-free grammar (CFG) to extend the expressiveness of ordinary graph reachability from an unlabeled graph to an edge-labeled graph. Solving CFL-reachability requires a (sub)cubic time complexity with respect to the graph size, which limits its scalability in practice. Thus, an approach that can effectively reduce the graph size while maintaining the reachability result is highly desirable. Most of the existing graph simplification techniques for CFL-reachability work during the preprocessing stage, i.e., before the dynamic CFL-reachability solving process. However, in real-world CFL-reachability analyses, there is a large number of reducible nodes and edges that can only be discovered during dynamic solving, leaving significant room for on-the-fly improvements. This paper aims to reduce the graph size of CFL-reachability dynamically via online cycle elimination. We propose a simple yet effective approach to detect collapsible cycles in the graph based on the input context-free grammar. Our key insight is that symbols with particular forms of production rules in the grammar are the essence of transitivity of reachability relations in the graph. Specifically, in the graph, a reachability relation to a node v_i can be "transited" to another node v_j if there is a transitive relation from v_i to v_j, and cycles formed by transitive relations are collapsible. In this paper, we present an approach to identify the transitive symbols in a context-free grammar and propose an iterative-epoch framework for online cycle elimination. From the perspective of non-parallelized CFL-reachability solving, our iterative-epoch framework is well compatible with both the standard (unordered) solver and the recent ordered solver, and can significantly improve their performance. Our experiment on context-sensitive value-flow analysis for C/C++ and field-sensitive alias analysis for Java demonstrates promising performance improvement by our iterative-epoch cycle elimination technique. By collapsing cycles online, our technique accelerates the standard solver by 17.17× and 13.94× for value-flow analysis and alias analysis, respectively, with memory reductions of 48.8% and 45.0%. Besides, our technique can also accelerate the ordered solver by 14.32× and 8.36× for value-flow analysis and alias analysis, respectively, with memory reductions of 55.2% and 57.8%.
42
Roghair, Ivo. "Advanced Numerical Tools for Chemical Process Intensification: Innovations in 3D Printing, Membrane Reactors, and Bubble Dynamics." Resúmenes de Mecánica Computacional 1, no. 3 (2024): 29. https://doi.org/10.70567/rmc.v1i3.146.
Full textAbstract:
Chemical process intensification (CPI) is concerned with making innovations for chemical processes to make them smaller and faster, and more sustainable and efficient. Typically, CPI aims for utilizing and enforcing a synergy of the different chemical-physical processes in a reactor and involves a deep understanding of the reactor behavior and being able to control the different aspects of the reactor system. We therefore work on the development of digital twins for various reactor system types, along with experimental validation and verification. In this talk, I will give an overview of the numerical and experimental technologies and innovations that were developed in our group, aiming to stimulate other researchers to identify process intensification opportunities in their research. One area of interest is 3D printing of catalysts. Catalysts speed up chemical reactions, and with 3D printing, we can create custom-designed catalysts that enhance heat transfer while keeping the pressure drop within limits, leading to more efficient reactors. We have developed a number of logpile structure designs, that outperform conventional reactors relating to the pressure drop and heat transfer.Another intensification technology concerns fluidized bed membrane reactors. These reactors use a membrane to separate and control the reaction environment, and by properly extracting the product, it drives equilibrium reactions to the product side, resulting in better performance and higher yields. Our digital twin models help to gain insight in the placement of the membranes in the reactor under reactive conditions. Finally, we dive into the realm of two-phase gas-liquid flows, from bubble column reactors to modern electrolyzers. Understanding how bubbles form, grow, release, and rise can significantly improve the efficiency and design of e.g. electrodes and reactor structures. We have set out to develop digital twins using various approaches; by traditional numerical modelling (e.g. Euler-Lagrange CFD type models), as well as by developing deep-learning based techniques e.g. novel graph neural network architectures. The latter helps us to accelerate the simulation of complex physical systems, with a focus on bubble front-tracking in multiphase flow. Besides, machine learning techniques can also assist us to perform validation experiments. We demonstrate a machine-learning based technique for bubble detection and optical bubble characterization. We will explore how we can reconstruct the 3D shapes of bubbles, providing deeper insights into their behavior and improving their role in model validation.
43
Bobrovnikova, Kira, Sergii Lysenko, Bohdan Savenko, Piotr Gaj, and Oleg Savenko. "Technique for IoT malware detection based on control flow graph analysis." RADIOELECTRONIC AND COMPUTER SYSTEMS, no. 1 (February 23, 2022): 141–53. http://dx.doi.org/10.32620/reks.2022.1.11.
Full textAbstract:
The Internet of Things (IoT) refers to the millions of devices around the world that are connected to the Internet. Insecure IoT devices designed without proper security features are the targets of many Internet threats. The rapid integration of the Internet into the IoT infrastructure in various areas of human activity, including vulnerable critical infrastructure, makes the detection of malware in the Internet of Things increasingly important. Annual reports from IoT infrastructure cybersecurity companies and antivirus software vendors show an increase in malware attacks targeting IoT infrastructure. This demonstrates the failure of modern methods for detecting malware on the Internet of things. This is why there is an urgent need for new approaches to IoT malware detection and to protect IoT devices from IoT malware attacks. The subject of the research is the malware detection process on the Internet of Things. This study aims to develop a technique for malware detection based on the control flow graph analysis. Results. This paper presents a new approach for IoT malware detection based on control flow graph analysis. Control flow graphs were built for suspicious IoT applications. The control flow graph is represented as a directed graph, which contains information about the components of the suspicious program and the transitions between them. Based on the control flow graph, metrics can be extracted that describe the structure of the program. Considering that IoT applications are small due to the simplicity and limitations of the IoT operating system environment, malware detection based on control flow graph analysis seems to be possible in the IoT environment. To analyze the behavior of the IoT application for each control flow graph, the action graph is to be built. It shows an abstract graph and a description of the program. Based on the action graph for each IoT application, a sequence is formed. This allows for defining the program’s behavior. Thus, with the aim of IoT malware detection, two malware detection models based on control flow graph metrics and the action sequences are used. Since the approach allows you to analyze both the overall structure and behavior of each application, it allows you to achieve high malware detection accuracy. The proposed approach allows the detection of unknown IoT malware, which are the modified versions of known IoT malware. As the mean of conclusion-making concerning the malware presence, the set of machine learning classifiers was employed. The experimental results demonstrated the high accuracy of IoT malware detection. Conclusions. A new technique for IoT malware detection based on control flow graph analysis has been developed. It can detect IoT malware with high efficiency.
44
Buss, Armands, Arturs Suleiko, Normunds Jekabsons, Juris Vanags, and Dagnija Loca. "Constraint Handling and Flow Control in Stirred Tank Bioreactors with Magnetically Coupled Impellers." Materials Science Forum 1071 (October 18, 2022): 189–96. http://dx.doi.org/10.4028/p-w35yei.
Full textAbstract:
In this study, Computational Fluid Dynamics (CFD), applied to a non-Newtonian fluid, was developed to characterize gas-liquid interaction and mixing process in a 15 m3 (working volume) bioreactor. The bioreactor was equipped with four arrangements of standard Rushton, Pitch-blade and Scaba® impellers. Gas-liquid hydrodynamics was estimated based on CFD results. The chosen operating conditions were defined by the settings used for production of xanthan gum via fermentation route by Xanthomonas campestris. The mixing process was simulated by using the k-epsilon turbulence model, Multiple Reference Frame and Population Balance Model approaches. The simulation results have been compared and analyzed by isosurfaces, volume fractions, velocity graphs, torques and flow analysis calculations. Obtained results revealed that for the Pitched-Pitched-Pitched arrangement to avoid the constraint-imposed overload torque limitations impeller diameter size should be reduced by 10%. The use of Rushton-Rushton-Rushton impeller arrangement was discouraged for non-Newtonian pseudoplastic fluid mixing, whereas Pitched-Rushton-Scaba and Scaba-Rushton-Pitched impeller arrangements were both acceptable.
45
Alam, Shahid, Issa Traore, and Ibrahim Sogukpinar. "Annotated Control Flow Graph for Metamorphic Malware Detection." Computer Journal 58, no. 10 (2014): 2608–21. http://dx.doi.org/10.1093/comjnl/bxu148.
Full text
46
Conrado, Giovanna Kobus, Amir Kafshdar Goharshady, and Chun Kit Lam. "The Bounded Pathwidth of Control-Flow Graphs." Proceedings of the ACM on Programming Languages 7, OOPSLA2 (2023): 292–317. http://dx.doi.org/10.1145/3622807.
Full textAbstract:
Pathwidth and treewidth are standard and well-studied graph sparsity parameters which intuitively model the degree to which a given graph resembles a path or a tree, respectively. It is well-known that the control-flow graphs of structured goto-free programs have a tree-like shape and bounded treewidth. This fact has been exploited to design considerably more efficient algorithms for a wide variety of static analysis and compiler optimization problems, such as register allocation, µ-calculus model-checking and parity games, data-flow analysis, cache management, and liftetime-optimal redundancy elimination. However, there is no bound in the literature for the pathwidth of programs, except the general inequality that the pathwidth of a graph is at most O (lg n ) times its treewidth, where n is the number of vertices of the graph. In this work, we prove that control-flow graphs of structured programs have bounded pathwidth and provide a linear-time algorithm to obtain a path decomposition of small width. Specifically, we establish a bound of 2 · d on the pathwidth of programs with nesting depth d . Since real-world programs have small nesting depth, they also have bounded pathwidth. This is significant for a number of reasons: (i) pathwidth is a strictly stronger parameter than treewidth, i.e. any graph family with bounded pathwidth has bounded treewidth, but the converse does not hold; (ii) any algorithm that is designed with treewidth in mind can be applied to bounded-pathwidth graphs with no change; (iii) there are problems that are fixed-parameter tractable with respect to pathwidth but not treewidth; (iv) verification algorithms that are designed based on treewidth would become significantly faster when using pathwidth as the parameter; and (v) it is easier to design algorithms based on bounded pathwidth since one does not have to consider the often-challenging case of merge nodes in treewidth-based dynamic programming. Thus, we invite the static analysis and compiler optimization communities to adopt pathwidth as their parameter of choice instead of, or in addition to, treewidth. Intuitively, control-flow graphs are not only tree-like, but also path-like and one can obtain simpler and more scalable algorithms by relying on path-likeness instead of tree-likeness. As a motivating example, we provide a simpler and more efficient algorithm for spill-free register allocation using bounded pathwidth instead of treewidth. Our algorithm reduces the runtime from O ( n · r 2 · tw · r + 2 · r ) to O ( n · pw · r pw · r + r + 1 ), where n is the number of lines of code, r is the number of registers, pw is the pathwidth of the control-flow graph and tw is its treewidth. We provide extensive experimental results showing that our approach is applicable to a wide variety of real-world embedded benchmarks from SDCC and obtains runtime improvements of 2-3 orders of magnitude. This is because the pathwidth is equal to the treewidth, or one more, in the overwhelming majority of real-world CFGs and thus our algorithm provides an exponential runtime improvement. As such, the benefits of using pathwidth are not limited to the theoretical side and simplicity in algorithm design, but are also apparent in practice.
47
Shao, Jun Peng, Jian Ying Li, Zhong Wen Wang, and Gui Hua Han. "Research on Electro-Hydraulic Load Simulator Based on Building Model of Flow Press Servo Valve." Advanced Materials Research 129-131 (August 2010): 213–17. http://dx.doi.org/10.4028/www.scientific.net/amr.129-131.213.
Full textAbstract:
The model of flow press servo valve is built in this paper, during building the model, the author emphatically analyses the flow equation and force (torque) balance equation of every part of the valve, at the same time, all levels sub-models are organic combined according to power flow direction, signal flow direction of elements and causality, then we get the bond graph model of the flow press servo from this way. Adapting flow press servo valve and flow servo valve to concurrently control load system has its great advantage in restraining the superfluous force of the electro-hydraulic load simulator system, the performance such as load precision of system is enhanced greatly according to this method. Based on the system bond graph model, and by comparing the simulation curves and experiment curves, we can know that the simulation curves basically tally with the experiment curves, the bond graph models are validated right, which are flow press servo valve bond graph model and double valves concurrently control the electro-hydraulic load simulator system bond graph model. Simultaneity, the bond graph models in this paper take on generality, they are can be used on other aspects, such as other valve controlling cylinder system simulation, design and control strategy theory research.
48
Sen, A. K. "Metabolic control analysis. An application of signal flow graphs." Biochemical Journal 269, no. 1 (1990): 141–47. http://dx.doi.org/10.1042/bj2690141.
Full textAbstract:
In this paper the method of signal-flow graphs is used for calculating the Control Coefficients of metabolic pathways in terms of enzyme elasticities. The method is applied to an unbranched pathway (a) without feedback or feedforward regulation and (b) with feedback inhibition of the first enzyme by the last variable metabolite. It is shown that, by using a signal-flow graph, the control structure of a metabolic pathway can be represented in a graphical manner directly from the configuration of the pathway, without the necessity of writing the governing equations in a matrix form. From a signal-flow graph the various Control Coefficients can be evaluated in an easy and straightforward fashion without recourse to matrix inversion or other algebraic techniques. A signal-flow graph also provides a visual framework for analysing the cause-effect relationships of the individual enzymes.
49
Ran, Longyan, Yunhe Cui, Jianpeng Zhao, and Hongzhen Yang. "TITAN: Combining a bidirectional forwarding graph and GCN to detect saturation attack targeted at SDN." PLOS ONE 19, no. 4 (2024): e0299846. http://dx.doi.org/10.1371/journal.pone.0299846.
Full textAbstract:
The decoupling of control and forwarding layers brings Software-Defined Networking (SDN) the network programmability and global control capability, but it also poses SDN security risks. The adversaries can use the forwarding and control decoupling character of SDN to forge legitimate traffic, launching saturation attacks targeted at SDN switches. These attacks can cause the overflow of switch flow tables, thus making the switch cannot forward benign network traffic. How to effectively detect saturation attack is a research hotspot. There are only a few graph-based saturation attack detection methods. Meanwhile, the current graph generation methods may take useless or misleading information to the attack detection, thus decreasing the attack detection accuracy. To solve the above problems, this paper proposes TITAN, a bidirecTional forwardIng graph-based saturaTion Attack detectioN method. TITAN defines flow forwarding rules and topology information, and designs flow statistical features. Based on these definitions, TITAN generates nodes of the bi-forwarding graph based on the flow statistics features and edges of the bi-forwarding graph based on the network traffic routing paths. In this way, each traffic flow in the network is transformed into a bi-directional forwarding graph. Then TITAN feeds the above bidirectional forwarding graph into a Graph Convolutional Network (GCN) to detect whether the flow is a saturation attack flow. The experimental results show that TITAN can effectively detect saturation attacks in SDNs with a detection accuracy of more than 97%.
50
Gao, Yun, Hirokazu Hasegawa, Yukiko Yamaguchi, and Hajime Shimada. "Malware Detection by Control-Flow Graph Level Representation Learning With Graph Isomorphism Network." IEEE Access 10 (2022): 111830–41. http://dx.doi.org/10.1109/access.2022.3215267.
Full text