• Refine Query
  • Source
  • Publication year
  • to
  • Language
  • 15
  • 1
  • 1
  • Tagged with
  • 21
  • 21
  • 12
  • 11
  • 7
  • 7
  • 5
  • 5
  • 4
  • 4
  • 4
  • 4
  • 4
  • 4
  • 3
  • About
  • The Global ETD Search service is a free service for researchers to find electronic theses and dissertations. This service is provided by the Networked Digital Library of Theses and Dissertations.
    Our metadata is collected from universities around the world. If you manage a university/consortium/country archive and want to be added, details can be found on the NDLTD website.
1

Graph layout using subgraph isomorphisms

Hofton, Antony Edward January 2000 (has links)
Today, graphs are used for many things. In engineering, graphs are used to design circuits in very large scale integration. In computer science, graphs are used in the representation of the structure of software. They show information such as the flow of data through the program (known as the data flow graph [1]) or the information about the calling sequence of programs (known as the call graph [145]). These graphs consist of many classes of graphs and may occupy a large area and involve a large number of vertices and edges. The manual layout of graphs is a tedious and error prone task. Algorithms for graph layout exist but tend to only produce a 'good' layout when they are applied to specific classes of small graphs. In this thesis, research is presented into a new automatic graph layout technique. Within many graphs, common structures exist. These are structures that produce 'good' layouts that are instantly recognisable and, when combined, can be used to improve the layout of the graphs. In this thesis common structures are given that are present in call graphs. A method of using subgraph isomorphism to detect these common structures is also presented. The method is known as the ANHOF method. This method is implemented in the ANHOF system, and is used to improve the layout of call graphs. The resulting layouts are an improvement over layouts from other algorithms because these common structures are evident and the number of edge crossings, clusters and aspect ratio are improved.
2

µProfiler: A Concurrent Profiler for Concurrent C++ (µC++)

Gidzinski, Justyna Jay January 2007 (has links)
A concurrent program, unlike a sequential program, has multiple threads of execution, resulting in numerous advantages (e.g., faster execution), but also in complex and unpredictable interaction. As a consequence, a concurrent program can easily underutilize available parallelism, and performance can be extremely difficult for users to predict and analyze on their own. A profiler is a tool that can help a user identify as well as locate potential performance problems in a program. Profiling is accomplished through monitoring of the program execution, and analyzing and visualizing the collected performance data. A profiler must display useful information in a way that allows a user to effectively and efficiently understand and analyze a program's behaviour. This thesis describes the advancement in design and implementation of µProfiler, a profiler for sequential and concurrent programs written in µC++. µC++ is a concurrent dialect of the C++ programming language, which executes in uni-processor and multi-processor shared-memory environments. Major advancements to three µProfiler metrics are presented: the Execution State, the Exact Routine Call-Graph and the Statistical Routine Call-Graph. The Execution State metric charts each state for every thread over the entire execution of the program. With high overhead and perfect accuracy, the Exact Routine Call-Graph metric provides an exact call-graph profile of the program's dynamic execution, describing the control flow among routines. With low overhead and less accuracy, the Statistical Routine Call-Graph metric provides a statistical call-graph profile of the program's dynamic execution. For each metric, advancements were made throughout the profiling process (i.e., monitoring, analysis and visualization), addressing goals such as scalability, functionality, usability and performance. The metrics provide reasonable memory overhead and, based on the comparison to related work, are state-of-the-art in functionality and provide similar run-time performance.
3

µProfiler: A Concurrent Profiler for Concurrent C++ (µC++)

Gidzinski, Justyna Jay January 2007 (has links)
A concurrent program, unlike a sequential program, has multiple threads of execution, resulting in numerous advantages (e.g., faster execution), but also in complex and unpredictable interaction. As a consequence, a concurrent program can easily underutilize available parallelism, and performance can be extremely difficult for users to predict and analyze on their own. A profiler is a tool that can help a user identify as well as locate potential performance problems in a program. Profiling is accomplished through monitoring of the program execution, and analyzing and visualizing the collected performance data. A profiler must display useful information in a way that allows a user to effectively and efficiently understand and analyze a program's behaviour. This thesis describes the advancement in design and implementation of µProfiler, a profiler for sequential and concurrent programs written in µC++. µC++ is a concurrent dialect of the C++ programming language, which executes in uni-processor and multi-processor shared-memory environments. Major advancements to three µProfiler metrics are presented: the Execution State, the Exact Routine Call-Graph and the Statistical Routine Call-Graph. The Execution State metric charts each state for every thread over the entire execution of the program. With high overhead and perfect accuracy, the Exact Routine Call-Graph metric provides an exact call-graph profile of the program's dynamic execution, describing the control flow among routines. With low overhead and less accuracy, the Statistical Routine Call-Graph metric provides a statistical call-graph profile of the program's dynamic execution. For each metric, advancements were made throughout the profiling process (i.e., monitoring, analysis and visualization), addressing goals such as scalability, functionality, usability and performance. The metrics provide reasonable memory overhead and, based on the comparison to related work, are state-of-the-art in functionality and provide similar run-time performance.
4

Construction of GCCFG for Inter-procedural Optimizations in Software Managed Manycore (SMM)

January 2014 (has links)
abstract: Software Managed Manycore (SMM) architectures - in which each core has only a scratch pad memory (instead of caches), - are a promising solution for scaling memory hierarchy to hundreds of cores. However, in these architectures, the code and data of the tasks mapped to the cores must be explicitly managed in the software by the compiler. State-of-the-art compiler techniques for SMM architectures require inter-procedural information and analysis. A call graph of the program does not have enough information, and Global CFG, i.e., combining all the control flow graphs of the program has too much information, and becomes too big. As a result, most new techniques have informally defined and used GCCFG (Global Call Control Flow Graph) - a whole program representation which captures the control-flow as well as function call information in a succinct way - to perform inter-procedural analysis. However, how to construct it has not been shown yet. We find that for several simple call and control flow graphs, constructing GCCFG is relatively straightforward, but there are several cases in common applications where unique graph transformation is needed in order to formally and correctly construct the GCCFG. This paper fills this gap, and develops graph transformations to allow the construction of GCCFG in (almost) all cases. Our experiments show that by using succinct representation (GCCFG) rather than elaborate representation (GlobalCFG), the compilation time of state-of-the-art code management technique [4] can be improved by an average of 5X, and that of stack management [20] can be improved by an average of 4X. / Dissertation/Thesis / Masters Thesis Computer Science 2014
5

CodeViz - A Usability-Driven Call Graph Tool

Gustafsson, Pontus, Hazem, Ibrahim January 2023 (has links)
Since the start of software, comprehension has always been an issue solved through various methods, such as bottom-up models or visualizing code, specifically graphs. They are used to obtain a bird’s-eye view and the execution path of the software. Although these tools exist, they must include important usability features. When creating software, it is essential to prioritize usability as a crucial factor. This thesis aims to identify gaps in call graph-generating software in terms of its usability. Through this, we aim to fill the gaps by creating a new call graph-generating tool with improved usability and functionality. We conducted a literature review to identify the gaps in the understanding of software comprehension. Our findings emphasize the significance of software comprehension in enhancing maintainability, usability, and guidelines. These guidelines were used to assess the open-source tools available. The gaps found helped build a foundation for creating the tool code while following the five usability guidelines. Subsequently, we conducted a within-subject study with interviews with developers and managers using our tool (CodeViz) and an open-source tool. During the interviews, we took note of the participants' feedback and completed a form. Using this data, we created graphs for the Likert data and categorizing of the text questions. We found various improvements in these aspects through Likert data, with 31\% responding more positively to comprehending the graph. With the categorizing of the questions, we found that the participants found the interactivity very useful. The simplicity of obtaining an overview of the project helped improve its effectiveness and comprehension. Furthermore, being able to aid their comprehension helps software maintainability.
6

Object Call Graph Visualization

Tramnitzke, Danny January 2007 (has links)
<p>In this thesis an approach to visualize internal behaviour of object oriented software is developed.</p><p>The runtime information, which can be described as objects calling other objects, is displayed as a graph consisting of nodes and edges. The aim is to design an application in Java, which takes the runtime information in form of an object call graph and visualizes it as a tree and as a force directed view.</p><p>Therefore, first a data model has to be designed, holding an object call sequence. Furthermore, a discussion about graph definition languages and according tools is made. After this different graph layout algorithms are examined as well as graph displaying tools. Finally, the implementation of this visualization program deals with the combination of these three components graph data extraction, graph layout calculation and graph visualization.</p>
7

Object Call Graph Visualization

Tramnitzke, Danny January 2007 (has links)
In this thesis an approach to visualize internal behaviour of object oriented software is developed. The runtime information, which can be described as objects calling other objects, is displayed as a graph consisting of nodes and edges. The aim is to design an application in Java, which takes the runtime information in form of an object call graph and visualizes it as a tree and as a force directed view. Therefore, first a data model has to be designed, holding an object call sequence. Furthermore, a discussion about graph definition languages and according tools is made. After this different graph layout algorithms are examined as well as graph displaying tools. Finally, the implementation of this visualization program deals with the combination of these three components graph data extraction, graph layout calculation and graph visualization.
8

Zpracování grafu volání založené na dotazovacím jazyku / Query Language Based Call Graph Processing

Dudka, Kamil January 2009 (has links)
In this thesis, available tools for call graph generation, processing and visualization are analyzed. Based on this analysis, a call-graph processing tool is designed. The tool is then implemented and tested on call graphs generated from various real-world programs, including the Linux Kernel.
9

Defect Prediction using Exception Handling Method Call Structures

Sawadpong, Puntitra 09 May 2015 (has links)
The main purpose of exception handling mechanisms is to improve software robustness by handling exceptions when they occur. However, empirical evidence indicates that improper implementation of exception handling code can be a source of faults in software systems. There is still limited empirical knowledge about the relationship between exception handling code and defects. In this dissertation, we present three case studies investigating defect densities of exception handling code. The results show that in every system under study, the defect density of exception handling code was significantly higher than the defect density of overall source code and normal code. The ability to predict the location of faults can assist in directing quality enhancement efforts to modules that are likely to have faults. This information can be used to guide test plans, narrow the test space, and improve software quality. We hypothesize that complicated exception handling structure is a predictive factor that is associated with defects. To the best of our knowledge, no study has addressed the relationship between the attributes of exception handling method call structures and defect occurrence, nor has prior work addressed fault prediction. We extract exception-based software metrics from the structural attributes of exception handling call graphs. To find out whether there are patterns of relationship between exception-based software metrics and fault-proneness, we propose a defect prediction model using exception handling call structures. We apply the J48 algorithm, which is the Java implementation of the C4.5 algorithm, to build exception defect prediction models. In two out of three systems under study, the results reveal that there are logical patterns of relationships between most class level exception metrics and fault-proneness. The accuracy of our prediction models is comparable to the results of defect prediction model studies in the literature. It was observed that our approach has somewhat worse predictive accuracy when a system has low average defects per class.
10

Improving the Static Resolution of Dynamic Java Features

Sawin, Jason E. 11 September 2009 (has links)
No description available.

Page generated in 0.0729 seconds