To see the other types of publications on this topic, follow the link: Debugging tools.
Dissertations / Theses on the topic 'Debugging tools'
Create a spot-on reference in APA, MLA, Chicago, Harvard, and other styles
Consult the top 38 dissertations / theses for your research on the topic 'Debugging tools.'
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 dissertations / theses on a wide variety of disciplines and organise your bibliography correctly.
1
Müller, Thomas. "OpenAFS: Debugging-Methoden und -Tools." Universitätsbibliothek Chemnitz, 2002. http://nbn-resolving.de/urn:nbn:de:bsz:ch1-200201181.
Full textAbstract:
Unterlagen zu einem Vortrag im Rahmen des AFS-Workshops 2002 an der ETH Zürich.
Gegenstand der Vortrags sind Tools zum Debugging und zur Analyse des Verhaltens von AFS-Servern und -Clients. Die meisten dieser Tools sind im Source-Baum von OpenAFS enthalten, jedoch kaum dokumentiert.
2
Brickner, Hans. "A research on debugging tools’ platform independency." Thesis, KTH, Skolan för informations- och kommunikationsteknik (ICT), 2011. http://urn.kb.se/resolve?urn=urn:nbn:se:kth:diva-37231.
Full textAbstract:
Debugging of embedded systems is costly and time consuming,but imperative to system design. There are many different requirements on embedded systems and complying with these requirements has lead to many different kinds, and different configurations of embedded systems. The vast array of embedded systems, and the ever increasing complexity of the systems make debugging a growing challenge. Different domains impose different requirements on the systems and as embedded system pervade in our society, new requirement are introduced. ENEA’s products target various domains as: telecom, medical and the automotive domain. Targeting these three domains means that ENEA’s products need to comply with various, and stringent requirements. A debugging tool used in a tool chain like the tool chain developed in the iFEST project, as intended for ENEA’s debugging tool Optima, needs to support various debugging methods, ranging from software debugging methods to methods utilizing embedded hardware for debugging. The need for debugging tools in a tool chain to support various debugging methods lead to this master’s thesis, at and for ENEA. This thesis investigates methods to debug embedded systems in order to define enhancements of the debugging tool Optima that enables Optima to debug various systems and to debug all systems in ENEA’s target domains. The thesis is divided into two parts: a pre-study and a development part. The pre-study covers debugging of embedded systems by studying articles and ENEA’s operating system OSE and debugging tool Optima. Conclusion drawn from the study of methods to debug embedded systems and the study of the debugging support in Optima, show that Optima needs to utilize embedded hardware for debugging. Updates for Optima that enable utilization of embedded hardware for debugging are designed and implemented in the development part of the thesis. Hardware debugging facilities in the development platform targeted in this thesis are not fully incorporated. The lack of hardware debugging support in the platform makes it infeasible to debug the platform from software running on the processor core, and thus infeasible to improve Optima’s debugging capability by enhancing standard OSE debugging facilities to utilize embedded hardware for debugging. An external debugging tool, JTAG, is required to access the embedded debugging hardware in the target platform and to enable non-intrusive debugging.
3
Searle, Aaron James. "Automatic relative debugging." Queensland University of Technology, 2006. http://eprints.qut.edu.au/16445/.
Full textAbstract:
Relative Debugging is a paradigm that assists users to locate errors in programs that have been corrected or enhanced. In particular, the contents of key data structures in the development version are compared with the contents of the corresponding data structures, in an existing version, as the two programs execute. If the values of two corresponding data structures differ at points where they should not, an error may exist and the user is notified. Relative Debugging requires users to identify the corresponding data structures within the two programs, and the locations at which the comparisons should be performed. To quickly and effectively identify useful data structures and comparison points requires that users have a detailed knowledge of the two programs under consideration. Without a detailed knowledge of the two programs, the task of locating useful data structures and comparison points can quickly become a difficult and time consuming process. Prior to the research detailed in this thesis, the Relative Debugging paradigm did not provide any assistance that allowed users to quickly and effectively identify suitable data structures and program points that will help discover the source of an error. Our research efforts have been directed at enhancing the Relative Debugging paradigm. The outcome of this research is the discovery of techniques that empower Relative Debugging users to become more productive and allow the Relative Debugging paradigm to be significantly enhanced. Specifically, the research has resulted in the following three contributions: 1. A Systematic Approach to Relative Debugging. 2. Data Flow Browsing for Relative Debugging. 3. Automatic Relative Debugging. These contributions have enhanced the Relative Debugging paradigm and allow errors to be localized with little human interaction. Minimizing the user's involvement reduces the cost of debugging programs that have been corrected or enhanced, and has a significant impact on current debugging practices.
4
Woods, John Heath. "AN ASSESSMENT OF TOOLS TO ASSIST NEW C PROGRAMMERS IN FINDING BUGS." OpenSIUC, 2019. https://opensiuc.lib.siu.edu/theses/2541.
Full textAbstract:
The C programming language offers a high degree of control and freedom to programmers. This makes it a powerful tool, but it also gives the language a steep learning curve. One difficulty that many new C programmers face is in figuring out how to analyze and debug their code, as well as the output. There exists a variety of tools that can be used to assist in debugging. They can offer aid by identifying certain types of errors and by providing meaningful output that helps the user understand and correct those errors. The following seven debugging tools have been tested and analyzed in order to ascertain when and how each one of them might be most useful: Valgrind, GCC Address Sanitizer, Clang Address Sanitizer, Mtrace, Memwatch, Electric Fence, and Dmalloc. They have been tested using anonymous code submitted by actual students for C programming labs in order to see how many errors, and of which sort, each tool catches. The results of these tests, as well as their implications, are presented here.
5
Schöne, Robert, Joseph Schuchart, Thomas Ilsche, and Daniel Hackenberg. "Scalable Tools for Non-Intrusive Performance Debugging of Parallel Linux Workloads." Saechsische Landesbibliothek- Staats- und Universitaetsbibliothek Dresden, 2015. http://nbn-resolving.de/urn:nbn:de:bsz:14-qucosa-156199.
Full textAbstract:
There is a variety of tools to measure the performance of Linux systems and the applications running on them. However, the resulting performance data is often presented in plain text format or only with a very basic user interface. For large systems with many cores and concurrent threads, it is increasingly difficult to present the data in a clear way for analysis. Moreover, certain performance analysis and debugging tasks require the use of a high-resolution time-line based approach, again entailing data visualization challenges. Tools in the area of High Performance Computing (HPC) have long been able to scale to hundreds or thousands of parallel threads and help finding performance anomalies. We therefore present a solution to gather performance data using Linux performance monitoring interfaces. A combination of sampling and careful instrumentation allows us to obtain detailed performance traces with manageable overhead. We then convert the resulting output to the Open Trace Format (OTF) to bridge the gap between the recording infrastructure and HPC analysis tools. We explore ways to visualize the data by using the graphical tool Vampir. The combination of established Linux and HPC tools allows us to create an interface for easy navigation through time-ordered performance data grouped by thread or CPU and to help users find opportunities for performance optimizations.
6
Schöne, Robert, Joseph Schuchart, Thomas Ilsche, and Daniel Hackenberg. "Scalable Tools for Non-Intrusive Performance Debugging of Parallel Linux Workloads." Ottawa Linux Symposium Comittee, 2014. https://tud.qucosa.de/id/qucosa%3A28410.
Full textAbstract:
There is a variety of tools to measure the performance of Linux systems and the applications running on them. However, the resulting performance data is often presented in plain text format or only with a very basic user interface. For large systems with many cores and concurrent threads, it is increasingly difficult to present the data in a clear way for analysis. Moreover, certain performance analysis and debugging tasks require the use of a high-resolution time-line based approach, again entailing data visualization challenges. Tools in the area of High Performance Computing (HPC) have long been able to scale to hundreds or thousands of parallel threads and help finding performance anomalies. We therefore present a solution to gather performance data using Linux performance monitoring interfaces. A combination of sampling and careful instrumentation allows us to obtain detailed performance traces with manageable overhead. We then convert the resulting output to the Open Trace Format (OTF) to bridge the gap between the recording infrastructure and HPC analysis tools. We explore ways to visualize the data by using the graphical tool Vampir. The combination of established Linux and HPC tools allows us to create an interface for easy navigation through time-ordered performance data grouped by thread or CPU and to help users find opportunities for performance optimizations.
7
Shofahi, Masoud. "Evaluation And Analysis Of Dynamic Memory Debugging Tools For C/C++." Thesis, Umeå universitet, Institutionen för datavetenskap, 2018. http://urn.kb.se/resolve?urn=urn:nbn:se:umu:diva-155402.
Full textAbstract:
Memory error can cause a program to behave not as expected or worse, causing the program to halt. The time put into looking for memory errors can instead be invested in solving other project related problems. Developers use dynamic memory debugging tools to save both time and energy, since discovering memory errors could cause costly and time consuming execution errors or faulty results that could be nearly impossibleto discover. This thesis analyzes and evaluates three different open source dynamic memory debugging tools. The study mainly focuses on what type of memory errors the tools are capable of finding and what algorithms and techniques are used by the tools to find the errors.
8
Tammana, Praveen Aravind Babu. "Software-defined datacenter network debugging." Thesis, University of Edinburgh, 2018. http://hdl.handle.net/1842/31326.
Full textAbstract:
Software-defined Networking (SDN) enables flexible network management, but as networks evolve to a large number of end-points with diverse network policies, higher speed, and higher utilization, abstraction of networks by SDN makes monitoring and debugging network problems increasingly harder and challenging. While some problems impact packet processing in the data plane (e.g., congestion), some cause policy deployment failures (e.g., hardware bugs); both create inconsistency between operator intent and actual network behavior. Existing debugging tools are not sufficient to accurately detect, localize, and understand the root cause of problems observed in a large-scale networks; either they lack in-network resources (compute, memory, or/and network bandwidth) or take long time for debugging network problems. This thesis presents three debugging tools: PathDump, SwitchPointer, and Scout, and a technique for tracing packet trajectories called CherryPick. We call for a different approach to network monitoring and debugging: in contrast to implementing debugging functionality entirely in-network, we should carefully partition the debugging tasks between end-hosts and network elements. Towards this direction, we present CherryPick, PathDump, and SwitchPointer. The core of CherryPick is to cherry-pick the links that are key to representing an end-to-end path of a packet, and to embed picked linkIDs into its header on its way to destination. PathDump is an end-host based network debugger based on tracing packet trajectories, and exploits resources at the end-hosts to implement various monitoring and debugging functionalities. PathDump currently runs over a real network comprising only of commodity hardware, and yet, can support surprisingly a large class of network debugging problems with minimal in-network functionality. The key contributions of SwitchPointer is to efficiently provide network visibility to end-host based network debuggers like PathDump by using switch memory as a "directory service" - each switch, rather than storing telemetry data necessary for debugging functionalities, stores pointers to end hosts where relevant telemetry data is stored. The key design choice of thinking about memory as a directory service allows to solve performance problems that were hard or infeasible with existing designs. Finally, we present and solve a network policy fault localization problem that arises in operating policy management frameworks for a production network. We develop Scout, a fully-automated system that localizes faults in a large scale policy deployment and further pin-points the physical-level failures which are most likely cause for observed faults.
9
Renieris, Emmanuel. "A research framework for software-fault localization tools /." View online version; access limited to Brown University users, 2005. http://wwwlib.umi.com/dissertations/fullcit/3174662.
Full text
10
Sjölund, Martin. "Tools for Understanding, Debugging, and Simulation Performance Improvement of Equation-based Models." Licentiate thesis, Linköpings universitet, Programvara och system, 2013. http://urn.kb.se/resolve?urn=urn:nbn:se:liu:diva-90096.
Full textAbstract:
Equation-based object-oriented (EOO) modelling languages provide a convenient, declarative method for describing models of cyber-physical systems.Because of the ease of use of EOO languages, large and complex models can be built with limited effort.However, current state-of-the-art tools do not provide the user with enough information when errors appear or simulation results are wrong.It is paramount that the tools give the user enough information to correct errors or understand where the problems that lead to wrong simulation results are located.However, understanding the model translation process of an EOO compiler is a daunting task that not only requires knowledge of the numerical algorithms that the tool executes during simulation, but also the complex symbolic transformations being performed. In this work, we develop and explore methods where the EOO tool records the transformations during the translation process in order to provide better diagnostics, explanations, and analysis.This information can be used to generate better error-messages during translation.It can also be used to provide better debugging for a simulation that produces unexpected results or where numerical methods fail. Meeting deadlines is particularly important for real-time applications.It is usually important to identify possible bottlenecks and either simplify the model or give hints to the compiler that enables it to generate faster code.When profiling and measuring execution times of parts of the model the recorded information can also be used to find out why a particular system is slow.Combined with debugging information, it is possible to find out why this system of equations is slow to solve, which helps understanding what can be done to simplify the model. Finally, we provide a method and tool prototype suitable for speeding up simulations by compiling a simulation executable for a parallel platform by partitioning the model at appropriate places.
11
Thun, Julia, and Rebin Kadouri. "Automating debugging through data mining." Thesis, KTH, Data- och elektroteknik, 2017. http://urn.kb.se/resolve?urn=urn:nbn:se:kth:diva-203244.
Full textAbstract:
Contemporary technological systems generate massive quantities of log messages. These messages can be stored, searched and visualized efficiently using log management and analysis tools. The analysis of log messages offer insights into system behavior such as performance, server status and execution faults in web applications. iStone AB wants to explore the possibility to automate their debugging process. Since iStone does most parts of their debugging manually, it takes time to find errors within the system. The aim was therefore to find different solutions to reduce the time it takes to debug. An analysis of log messages within access – and console logs were made, so that the most appropriate data mining techniques for iStone’s system would be chosen. Data mining algorithms and log management and analysis tools were compared. The result of the comparisons showed that the ELK Stack as well as a mixture between Eclat and a hybrid algorithm (Eclat and Apriori) were the most appropriate choices. To demonstrate their feasibility, the ELK Stack and Eclat were implemented. The produced results show that data mining and the use of a platform for log analysis can facilitate and reduce the time it takes to debug.<br>Dagens system genererar stora mängder av loggmeddelanden. Dessa meddelanden kan effektivt lagras, sökas och visualiseras genom att använda sig av logghanteringsverktyg. Analys av loggmeddelanden ger insikt i systemets beteende såsom prestanda, serverstatus och exekveringsfel som kan uppkomma i webbapplikationer. iStone AB vill undersöka möjligheten att automatisera felsökning. Eftersom iStone till mestadels utför deras felsökning manuellt så tar det tid att hitta fel inom systemet. Syftet var att därför att finna olika lösningar som reducerar tiden det tar att felsöka. En analys av loggmeddelanden inom access – och konsolloggar utfördes för att välja de mest lämpade data mining tekniker för iStone’s system. Data mining algoritmer och logghanteringsverktyg jämfördes. Resultatet av jämförelserna visade att ELK Stacken samt en blandning av Eclat och en hybrid algoritm (Eclat och Apriori) var de lämpligaste valen. För att visa att så är fallet så implementerades ELK Stacken och Eclat. De framställda resultaten visar att data mining och användning av en plattform för logganalys kan underlätta och minska den tid det tar för att felsöka.
12
Sjölund, Martin. "Tools and Methods for Analysis, Debugging, and Performance Improvement of Equation-Based Models." Doctoral thesis, Linköpings universitet, Programvara och system, 2015. http://urn.kb.se/resolve?urn=urn:nbn:se:liu:diva-116346.
Full textAbstract:
Equation-based object-oriented (EOO) modeling languages such as Modelica provide a convenient, declarative method for describing models of cyber-physical systems. Because of the ease of use of EOO languages, large and complex models can be built with limited effort. However, current state-of-the-art tools do not provide the user with enough information when errors appear or simulation results are wrong. It is of paramount importance that such tools should give the user enough information to correct errors or understand where the problems that lead to wrong simulation results are located. However, understanding the model translation process of an EOO compiler is a daunting task that not only requires knowledge of the numerical algorithms that the tool executes during simulation, but also the complex symbolic transformations being performed. As part of this work, methods have been developed and explored where the EOO tool, an enhanced Modelica compiler, records the transformations during the translation process in order to provide better diagnostics, explanations, and analysis. This information is used to generate better error-messages during translation. It is also used to provide better debugging for a simulation that produces unexpected results or where numerical methods fail. Meeting deadlines is particularly important for real-time applications. It is usually essential to identify possible bottlenecks and either simplify the model or give hints to the compiler that enable it to generate faster code. When profiling and measuring execution times of parts of the model the recorded information can also be used to find out why a particular system model executes slowly. Combined with debugging information, it is possible to find out why this system of equations is slow to solve, which helps understanding what can be done to simplify the model. A tool with a graphical user interface has been developed to make debugging and performance profiling easier. Both debugging and profiling have been combined into a single view so that performance metrics are mapped to equations, which are mapped to debugging information. The algorithmic part of Modelica was extended with meta-modeling constructs (MetaModelica) for language modeling. In this context a quite general approach to debugging and compilation from (extended) Modelica to C code was developed. That makes it possible to use the same executable format for simulation executables as for compiler bootstrapping when the compiler written in MetaModelica compiles itself. Finally, a method and tool prototype suitable for speeding up simulations has been developed. It works by partitioning the model at appropriate places and compiling a simulation executable for a suitable parallel platform.
13
Song, Myoungkyu. "Supporting Software Development Tools with An Awareness of Transparent Program Transformations." Thesis, Virginia Tech, 2013. http://hdl.handle.net/10919/78140.
Full textAbstract:
Programs written in managed languages are compiled to a platform-independent intermediate representation, such as Java bytecode. The relative high level of Java bytecode has engendered a widespread practice of changing the bytecode directly, without modifying the maintained version of the source code. This practice, called bytecode engineering or enhancement, has become indispensable in transparently introducing various concerns, including persistence, distribution, and security. For example, transparent persistence architectures help avoid the entanglement of business and persistence logic in the source code by changing the bytecode directly to synchronize objects with stable storage. With functionality added directly at the bytecode level, the source code reflects only partial semantics of the program. Specifically, the programmer can neither ascertain the program's runtime behavior by browsing its source code, nor map the runtime behavior back to the original source code.
This research presents an approach that improves the utility of source-level programming tools by providing enhancement specifications written in a domain-specific language. By interpreting the specifications, a source-level programming tool can gain an awareness of the bytecode enhancements and improve its precision and usability. We demonstrate the applicability of our approach by making a source code editor and a symbolic debugger enhancements-aware.<br>Master of Science
14
Coleman, Maribeth Gandy. "Creating augmented reality authoring tools informed by designer workflow and goals." Diss., Georgia Institute of Technology, 2012. http://hdl.handle.net/1853/45845.
Full textAbstract:
In a 20-year period, AR has gone from being viewed as a heavyweight technology to a new medium for a variety of applications. As a result there has been an increasing need for tools to support AR design and development that fully address the needs of non-technologists. From my AR research, I learned that three critical components for these authoring tools are support for an established content pipeline, rapid prototyping, and user experience testing. The history of media teaches us that AR also shares underlying technologies with a variety of more mature media such as film, VR, and the web with existing workflows and tools. Therefore, we created an AR authoring tool that supported these three critical components, and whose design was informed by established approaches in these related domains, allowing developers with a range of technical expertise to explore the AR medium.
In this dissertation I present four main contributions. The first was an exploration of the AR design space focused on close collaboration with designers. This work resulted in guidelines for AR authoring tools, and informed the development of the Designer's Augmented Reality Toolkit (DART). These guidelines were validated via internal and external projects. A qualitative study of long term DART use that provided insight into the successes and failures of DART as well as additional understanding of AR authoring needs. Lastly, I trace two main threads to highlight the impact of this work, the development of the AR Second Life system and the creation of the Argon AR web browser.
15
Choksey, Sanket Dinesh. "Developing an affordable authoring tool for intelligent tutoring systems." Link to electronic thesis, 2004. http://www.wpi.edu/Pubs/ETD/Available/etd-0825104-161218/.
Full textAbstract:
Thesis (M.S.)--Worcester Polytechnic Institute.<br>Keywords: Model Tracing; Intelligent Tutoring Systems; JESS production system; Debugging Tool; Cognitive Tutor Authoring Tools. Includes bibliographical references (p. 58-60).
16
Mendonça, José Lucas Lemos. "Behaviours for simulated humanoid robots." Master's thesis, Universidade de Aveiro, 2014. http://hdl.handle.net/10773/14699.
Full textAbstract:
Mestrado em Engenharia de Computadores e Telemática<br>This thesis in inserted in the FC Portugal 3D team, which competes in the
humanoid simulation league 3D from RoboCup. The objectives of this thesis
are to improve the behaviours already created and to develop tools to support
the development and debugging of the robotic agent.
With this in mind, the process of optimization was improved to make it more efficient
and adapted to include the new heterogeneous models. Executing the
optimization process, using the state of the art algorithm CMA-ES, the time of
the getup was reduced by half. Afterwards, the agent was put running in sync
mode, which allows the simulations to run as fast as the computer in use can
process, and not the simulation speed of the competion with cycles of 20ms.
In the agent posture, it is now used the information from the gyroscope and the
euler angles are calculated to get a better estimative of the robot orientation.
On the other hand, the agent architecture was updated and new behaviours
were created and optimized to support the new heterogeneous models. In relation
to the standard model, some behaviours execute faster because of their
physical difference.
In the slot behaviours, it is now possible to defined preconditions in each step,
so the agent can abort the behaviour when any condition does not comply.
This change reduces the time wasted executing all the behaviour in situations
in which the success is improbable.
In terms of tools, a Agent Monitor Window was created for each agent which
can: present in runtime variables from the agent code; interact with the code
trough widgets; and if the simulation is in sync mode, defined the simulation
cycle time, with the possibility to pause it and execute step by step, which
gives a great advantage in terms of analysing the agent execution. The second
tool was a behaviour testes for behaviours defined in XML, which allows,
in runtime, to change the behaviour to test, edit its content, aggregate different
files in sequence and finally the tolls can execute various agents in parallel.
The last tools is Log Analyser of the logs generated by the agents and the
server, which allows: exporting in different formats, see in form of plots the
variables parsed, filtrate the simulation information; and create a server simulation
which can be used to analyse, in parallel, the plots of chosen variables
and the simulation in a monitor.<br>Esta tese está inserida na equipa FC Portugal 3D, que compete na liga de
futebol robótico simulado 3D. Os objetivos da tese são melhorar os comportamentos
já existentes e desenvolver ferramentas de suporte ao desenvolvimento
e depuração para o agente robótico.
Nesse sentido, foi melhorado o processo de optimização de comportamentos
de forma a torná-lo mais eficiente e adaptado para incluir os novos modelos
heterogéneos disponibilizados. Ao executar o processo de optimização,
usando o algoritmo de estado de arte CMA-ES, foi obtido reduções para metade
do tempo nos comportamentos de levantar-se. Seguidamente o agente
foi colocado a correr em modo síncrono, o que permite que as simulações
corram à velocidade de processamento do computador em uso, e não à velocidade
da simulação da competição em que cada ciclo demora 20ms. Assim
é possível executar simulações e consequentemente inferir conclusões muito
mais rapidamente.
Passou-se a usar a informação de giroscópio e o cálculo dos ângulos de euler
para obter uma melhor estimativa da rotação do robô. Por outro lado, devido
ao lançamento de novos tipos de robôs, a arquitectura do agente teve de ser
atualizada e novos comportamentos foram criados e optimizados para estes
novos modelos. Em relação ao modelo original, alguns comportamentos são
executados mais rapidamente e melhor pelos modelos novos, devido às suas
alterações físicas. Por fim, nos comportamentos foi dada a possibilidade de
definir pré condições em etapa do mesmo, para que possa ser abortado caso
as condições não se verifiquem. Esta alteração veio reduzir o tempo desperdiçado
a executar a totalidade do comportamento em situações em que não
é provável o seu sucesso .
Em termos de ferramentas, foi colocada uma Janela de Monitor de Agente
para cada agente que, apresenta em tempo de simulação variáveis que o
código do agente disponibiliza, interage com código através de widgets de
seleção ou preenchimento, e se a simulação estiver a correr em modo síncrono,
permite definir o tempo de ciclo da simulação, pausá-la e executar ciclo
a ciclo, o que permite vantagens óbvias em termos de análise de execução
dos agentes. Seguidamente, foi criada uma ferramenta de teste para comportamentos
definidos em XML, que permite, em tempo de execução, alterar o
ficheiro a testar, alterar o seu conteúdo, agrupar vários ficheiros em sequências
e executar vários agentes em paralelo. Por fim, a última ferramenta é
um Analizador de Logs gerados pelos agentes e pelo simulador que permite,
entre outras funcionalidades, ver em forma de gráficos variáveis da simulação,
exportar para diferentes formatos, filtrar a simulação usando informação
da mesma e correr um servidor de forma a ser possível analizar em paralelo,
gráficos de variáveis escolhidas e a simulação num visualizador.
17
Chen, Yan. "A tool for auralized debugging." Online access for everyone, 2005. http://www.dissertations.wsu.edu/Thesis/Summer2005/y%5Fchen%5F063005.pdf.
Full text
18
Hansson, Falkenby Jesper. "Debugging Tool for a Distributed Streaming Application." Thesis, Uppsala universitet, Institutionen för informationsteknologi, 2017. http://urn.kb.se/resolve?urn=urn:nbn:se:uu:diva-394011.
Full textAbstract:
Debugging is a fundamental tool for software developers, it is therefore included in the majority of modern integrated development environments available today. When the capabilities of such debuggers are to be implemented in a debugging tool for a clustered, real-time stream processing system, the task becomes very complex. Knowledge on how to build debuggers for such systems is missing, and there is a need for these types of tools in the emerging real-time data stream processing industry. This thesis explores ways to implement and find usages of a debugging tool in a clustered, real-time processing environment. In previous research two papers were of particular interest as to form a basis for this thesis. However, these papers do not target real-time stream processing systems, so the knowledge gap still persists. It was found that these types of systems have extended requirements in addition to the functionality debuggers of today that has to be fulfilled. The first requirement found was that shared states has to be represented in some way in the tool, and multiple solutions were proposed. The second problem found was that the real-time data stream had to be integrated into the tool in one or more ways. This thesis has brought up two ways to solve it; stream generation and stream sampling. The last problem brought up came from the need for users to be able to debug fatal bugs that has crashed the system. Three solutions were proposed, and the concluded Monte Carlo solution builds upon the previous two problems. The thesis presents a special debugging protocol and a blueprintof a debugging tool, with implementation details included, forothers to take inspiration from. Thus it fills in the missingknowledge gap and successfully achieves the goal of answering thequestion of how to implement a debugging tool for a clustered,real-time data stream processing system.
19
Cowen, Peter. "An extensible debugging tool that supports data abstraction." Thesis, University of Nottingham, 1991. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.291886.
Full text
20
Tsai, Pedro T. H. "Re-targeting the Graze performance debugging tool for Java threads and analyzing the re-targeting to automatically parallelized (FORTRAN) code." Thesis, Monterey, Calif. : Springfield, Va. : Naval Postgraduate School ; Available from National Technical Information Service, 2000. http://handle.dtic.mil/100.2/ADA377839.
Full text
21
Sestorp, Isak. "Requirements Elicitation for the User Experience in Troubleshooting and Debugging of Microservice Networks : A Study of how Visualization of Call Paths can be Utilized in a Software Tool." Thesis, Linköpings universitet, Institutionen för datavetenskap, 2020. http://urn.kb.se/resolve?urn=urn:nbn:se:liu:diva-170303.
Full text
22
Konečný, Jiří. "Ladicí nástroj pro shadery." Master's thesis, Vysoké učení technické v Brně. Fakulta informačních technologií, 2013. http://www.nusl.cz/ntk/nusl-236361.
Full textAbstract:
This thesis deals with implementation of a debugging and development tool for GLSL shader programming. In the text, you will find design of the application and it's implementation in Qt library. The thesis also includes performance testing with GLSL shaders. Experiments were focused on commands of application control flow in GLSL and texturing commands used in shaders. In the thesis, you will find explanation of the functionality of some shaders used in OpenGL. Application developed in this thesis, is meant to help with implementation of graphic programs programmed in OpenGL 3.3 or higher.
23
Bendedouch, Faouzia Boulfekhar. "Conception et réalisation d'un système d'apprentissage des protocoles de communication assisté par ordinateur : système d'aide à la mise au point des protocoles." Toulouse 3, 1987. http://www.theses.fr/1987TOU30010.
Full textAbstract:
Le systeme developpe constitue un outil pedagogique permettant a des etudiants de tester et de mettre au point des protocoles. Il autorise une experimentation simulee de ces derniers dans un cas de figure choisi par l'utilisateur et offre en outre, dans un contexte graphique, une assistance a la recherche d'erreurs comportant notammant, la possibilite d'une execution pas a pas. L'aspect mise au point des protocoles est aborde et un certain nombre de fonctions assistant l'utilisateur dans la recherche d'erreurs sont decrites
24
Záplata, Filip. "Algoritmy zpracování signálu na platformě AVR32." Master's thesis, Vysoké učení technické v Brně. Fakulta elektrotechniky a komunikačních technologií, 2011. http://www.nusl.cz/ntk/nusl-219102.
Full textAbstract:
Master‘s thesis reviews the characteristics of the AVR32 architecture, AVR32UC microarchitecture, and especially AT32UC3A0512 microcontroller. This microcontroller is mounted on the board EVK1100, which is used for debugging applications. The entire analysis is focused on the ability to process audio signals on this board. For the board is created AD/DA interface and its control library. Follows necessary description of used DSP-lib library. The last part is a description of the theory and implementation of two sound effects and implementation of operating system FreeRTOS.
25
Dang, Bao Minh. "Methodology and tools for distributed debugging." Thesis, 1989. http://spectrum.library.concordia.ca/3678/1/ML56041.pdf.
Full text
26
Chun-WeiLin and 林俊瑋. "A FPGA-based Platform and Debugging Tools for Many-core OpenRISC System." Thesis, 2016. http://ndltd.ncl.edu.tw/handle/99208752468539461276.
Full textAbstract:
碩士<br>國立成功大學<br>資訊工程學系<br>104<br>For most programmers, the behavior of hardware level is like a black-box. It usually brings difficulties in developing and debugging circuit designs. Therefore, this work proposes a FPGA-based platform for observing the signal or behavior of hardware while execution.
In this thesis, the proposed platform is divided into 2 parts, hardware and software parts. In the software part, we defined several APIs to manage many cores on hardware level and observe the signals while execution in real-time. In the hardware part, on FPGA development board, we built a many-core system based on OpenRISC and used the mailbox method for communication among cores. The data transmission between hardware and software is through an USB interface which is requested to follow our defined protocol called Baton protocol.
Although we temporarily used OpenRISC as CPU in our current platform, the components of software and hardware parts (e.g. CPU, memory and peripherals) could be replaced in demand as long as they followed our defined Baton protocol and Baton APIs. The proposed platform and tools provide the flexibility and convenience for programmers in developing their circuit designs.
27
Havlíček, Jan. "Nástroje pro tvorbu chování virtuálních agentu v POSHi." Master's thesis, 2013. http://www.nusl.cz/ntk/nusl-330276.
Full textAbstract:
Goal of the work is to improve the SPOSH planner and its developement tools. SPOSH is a reactive planner of virtual agents similar to behavior trees that is used in the Pogamut platform, which is used to develop virtual agents. SPOSH itself suffers from several problems, especially excessive duplication of primitives (actions and senses) in different agents and unnatural execution of primitives. This work aims to remove these problems. Nearly all behavior tree planners are not public and developement tools are not usually available. Absence of such tools, especially of debugger, is major problem for users. Part of this work are tools for easy creation and debugging of SPOSH plans. Improved planner and created tools are demonstrated using an agent in game Unreal Tournament 2004.
28
Gutierrez, De Lara Felipe. "Retrospect on contemporary Internet organization and its challenges in the future." Thesis, 2011. http://hdl.handle.net/2152/ETD-UT-2011-05-3003.
Full textAbstract:
The intent of this report is to expose the audience to the contemporary organization of the Internet and to highlight the challenges it has to deal with in the future as well as the current efforts being made to overcome such threats. This report aims to build a frame of reference for how the Internet is currently structured and how the different layers interact together to make it possible for the Internet to exist as we know it. Additionally, the report explores the challenges the current Internet architecture design is facing, the reasons why these challenges are arising, and the multiple efforts taking place to keep the Internet working. In order to reach these objectives I visited multiple sites of organizations whose only reason for existence is to support the Internet and keep it functioning. The approach used to write this report was to research the topic by accessing multiple technical papers extracted from the IEEE database and network conferences reviews and to analyze and expose their findings. This report utilizes this
vii
information to elaborate on how network engineers are handling the challenges of keeping the Internet functional while supporting dynamic requirements. This report exposes the challenges the Internet is facing with scalability, the existence of debugging tools, security, mobility, reliability, and quality of service. It is explained in brief how each of these challenges are affecting the Internet and the strategies in place to vanquish them. The final objectives are to inform the reader of how the Internet is working with a set of ever changing and growing requirements, give an overview of the multiple institutions dedicated to reinforcing the Internet and provide a list of current challenges and the actions being taken to overcome them.<br>text
29
Tiraboschi, Andrés Agustín. "Sistema de instrumentación estática de código fuente para mocking de funciones y objetos." Bachelor's thesis, 2018. http://hdl.handle.net/11086/11762.
Full textAbstract:
Tesis (Lic. en Ciencias de la Computación)--Universidad Nacional de Córdoba, Facultad de Matemática, Astronomía, Física y Computación, 2018.<br>Este trabajo consiste en el desarrollo de una herramienta de unit testing para el lenguaje de programación C.
Los principales problemas que poseen este tipo de herramientas es la intrusión en el código de producción y el impacto en el rendimiento del programa a la hora de testear. Este último punto hace que, por ejemplo en sistemas embebidos los test no sean lo suficientemente confiables ya que una pequeña diferencia en el rendimiento puede tener un gran impacto en el programa. Por ello, se busca desarrollar un sistema de test que utilice mocking, es decir que cree módulos que simulan el comportamiento de módulos complejos, y además:
-Sea plataforma independiente tanto de la arquitectura como del sistema operativo.
-Requiera cero intrusión del código fuente por parte de los usuarios.
-Mínimo impacto en desempeño de la aplicación (menor o igual al de otros sistemas de mocking como google mock, gmock).
-Provea absoluto control del comportamiento a mockear (en contraposición al conjunto de funcionalidades provisto por gmock).
-Que permita mockear tanto funciones definidas por el usuario como funciones de librerías externas (por ejemplo, las del sistema).
-Que su uso no implique grandes modificaciones en el build system del proyecto.
La herramienta desarrollada en este trabajo fue creada como un plugin de GCC y requirió introducir modificaciones en el compilador. Estás modificaciones fueron verificadas y aceptadas quienes están a cargo del desarrollo del compilador y ya vienen integradas desde la versión 6.0.0 de GCC. El parche con esas modificaciones tiene como autor a Andrés Tiraboschi, fue aceptado y puede encontrarse en el siguiente link: http://permalink.gmane.org/gmane.comp.gcc.patches/342255.<br>This work consists of the development of a unit testing tool for the programming language C.
The main problems that this type of tool has is the intrusion into the production code and the impact on the program's performance when it comes to testing. This last point makes that, for example in embedded systems the tests are not reliable enough since a small difference in performance can have a great impact on the program. For this reason, it is sought to develop a test system that uses mocking, that is to say that creates modules that simulate the behavior of complex modules, and in addition:
-Be independent platform of both the architecture and the operating system.
-Require zero intrusion of the source code by users.
-Minimal impact on application performance (less than or equal to that of other mocking systems such as google mock, gmock).
-Provide absolute control of the behavior to mock (as opposed to the set of features provided by gmock).
-Allowing you to mock both user-defined functions and functions of external libraries (for example, those of the system).
-That its use does not imply big modifications in the project's build system.
The tool developed in this work was created as a GCC plugin and required to introduce modifications in the compiler. These modifications were verified and accepted by those in charge of the development of the compiler and are already integrated from version 6.0.0 of GCC. The patch with these modifications has Andrés Tiraboschi as author, it was accepted and can be found in the following link: http://permalink.gmane.org/gmane.comp.gcc.patches/342255
30
Hung, Chih-Chung, and 洪志忠. "A Debugging Tool based on Debugging History Management and Test Case Selection." Thesis, 2008. http://ndltd.ncl.edu.tw/handle/4w7q8k.
Full textAbstract:
碩士<br>國立臺北科技大學<br>資訊工程系研究所<br>96<br>Running automated test case to ensure that every modification will not cause new defects is a well-known software best practice. This approach can also be applied to debugging activities so that reduces the verification time. But with the growth of software system, the complexity of programs and the number of test cases are also increased. It may lead to: (1) developers may loss focus by unrelated test cases because of too many test cases; (2) developers need to endure longer test time, and therefore decrease performance; (3) During the debugging activity, developers often need to repeatedly modify programs, and many of the modifications may be finally proved that they have nothing to do with the bug, so we need to spend time to rollback; (4) because the debugging process and experience are usually not retained, the other members of the development team are difficult to learn the experience. In view of this, this paper presents debugging history and focus group concepts, storing modification history and using a test case selection technique to selects test cases related to the bug, in order to resolve the above issues. We have developed an Eclipse plug-ins, Reg4J2, to implement the concepts. By integrating with the Eclipse platform, Reg4J2 will be easier to be integrated with development activities and help developers to debug.
31
龍驥. "High-Level Computer-Aided Debugging Tool." Thesis, 2004. http://ndltd.ncl.edu.tw/handle/76874272314519464821.
Full textAbstract:
碩士<br>國立臺灣師範大學<br>資訊教育研究所<br>92<br>Nowadays, debuggers are a standard part of every programming environment. Typically debugging functionality includes setting breakpoints, stepping line by line, watching variable values, etc.. Moreover, most debuggers also provide graphical user interface (GUI) which allows users to use mouse and invoke these functionalities. However, the basic of debugging techniques have changed little. A typical routine is to repeat steps such as set breakpoints, run the program to hit the breakpoints, and print variable values until the cause of defect is found.
HILCADT is a state-of—the—art debugging tool which is implemented in java. It provides a high-level debugging language that is more expressive and flexible than the primitive language of debuggers. HILCADT sets breakpoints and continues programs automatically according to a given expressive query. HILCADT can be used to explore the temporal relation of variable’s values in a period of time and for further analysis. In addition, HILCADT can displays the debugging information on the HILCADT’s panel or uses DIVINE[11] to display debugging information in a 3D environment, which helps users to understand complicated data structure easily.
32
Rinard, Martin C. "Acceptability-Oriented Computing." 2003. http://hdl.handle.net/1721.1/3846.
Full textAbstract:
We discuss a new approach to the construction of software systems. Instead of attempting to build a system that is as free of errors as possible, the designer instead identifies key properties that the execution must satisfy to be acceptable to its users. Together, these properties define the acceptability envelope of the system: the region that it must stay within to remain acceptable. The developer then augments the system with a layered set of components, each of which enforces one of the acceptability properties. The potential advantages of this approach include more flexible, resilient systems that recover from errors and behave acceptably across a wide range of operating environments, an appropriately prioritized investment of engineering resources, and the ability to productively incorporate unreliable components into the final software system.<br>Singapore-MIT Alliance (SMA)
33
Sampaio, Carlos Eduardo. "Development and evaluation of a spreadsheet debugging tool." Thesis, 1991. http://hdl.handle.net/1911/13509.
Full textAbstract:
In four experiments, the utility of a spreadsheet debugging tool was assessed as spreadsheet users interacted with experimental spreadsheets. Experiments 1 and 2 showed that although subjective reactions to the tools were favorable, the performance advantage offered by them was not statistically significant. Experiment 3 assessed the applicability of these tools' with respect to understanding a spreadsheet's structure and data flow. Again, although no performance advantage was shown with the use of the tools, subjective reactions to them were still favorable. Experiment 4 evaluated a more sophisticated version of the tool. The time needed to debug spreadsheets with this tool was shown to be significantly faster than the control condition. Subjective reactions continued to be very positive. Given the interactive nature of working with spreadsheets, the potential utility offered by these interactive tools will hopefully attract the attention of software developers for incorporation into future spreadsheet packages.
34
Wang, Kuan-Hsun, and 王冠勛. "EcoDB: A Lightweight Debugging Tool for Resource Constrained Wireless Sensor Platforms." Thesis, 2011. http://ndltd.ncl.edu.tw/handle/67934251719118796087.
Full textAbstract:
碩士<br>國立清華大學<br>資訊工程學系<br>99<br>In this thesis, we propose a lightweight debugging tool named EcoDB for resource-constrained wireless sensor platforms. EcoDB runs a simulator and a source-level debugger simultaneously. We use both the simulator and the source-level debugger to provide the information that the developer of the system needs to diagnose the problem, and we provide the option to save the traced output to a Micro-SD card to eliminate the overhead of data communication. EcoDB minimize its side effects on the program being debugged. As a result, EcoDB requires 689 bytes of data memory and 135 bytes of program memory and does not alter functional behavior or energy usage of the original WSN
application program.
35
Chang, Wen Ying, and 張妏瑛. "Design and implementation of an aspect-based debugging tool for database applications." Thesis, 2009. http://ndltd.ncl.edu.tw/handle/92991918806706052522.
Full textAbstract:
碩士<br>國立政治大學<br>資訊科學學系<br>97<br>When using a large database application which is jointly designed by different teams, the administrators are often confronted with a problem that the application handles the exception spontaneously and often fails to report back the result of user’s execution. Therefore, the administrator can’t be informed of the details of the calling flow in case of exceptions. This will make it not only difficult to find which part of the application goes wrong, but also hard to fix. To resolve this problem, this thesis designs and implements an aspect-based debugging tool for such database applications. The key idea behind the tool is that, instead of adapting the large application for logging database access activities, we target at the JDBC driver and make JDBC driver capable of saving access log. This tool works for any JAVA applications that use JDBC interface to access database. Without any modification to the user-level application, this tool can save the access log obtained by application which use JDBC driver to connect the database, and the administrator can customize the access log. By analyzing the access records and duplicating the access behavior, this tool provides more information to further assist in application debugging.
36
Yang, Chuan, and 楊權. "A Testing and Debugging Tool for Arbitrary Interleaving on Multithreaded Programs Based on Debugger." Thesis, 2016. http://ndltd.ncl.edu.tw/handle/z4n9n5.
Full textAbstract:
碩士<br>國立中央大學<br>資訊工程學系<br>104<br>Applying multithreading techniques is an inevitable trend in software development nowadays. However, writing correct multi-threaded programs remains a difficult challenge to most of developers in practice, due to the lack of debugging and testing support from tools. Such nondeterminism has seriously hindered the reproduction of concurrency errors, making debugging and testing a concurrent program a difficult task in practice.
Although the primary tool for fixing a bug is a debugger, debugging support for multi-threaded program is poorly provided by existing debuggers. On the other hand, solutions provided by previous researches often suffer from different kinds of assumptions and limitations. These limitations and assumptions are, O.S., high-level programming language, virtual machine dependency, or the programming language dependency for costly static analysis
In this paper, a flexible debugging and testing tool is proposed. First of all, This tool helps programmers on testing and debugging concurrency errors by providing the capability of reproducing and generating arbitrary interleavings. Where interleaving space can be reduced by heuristics, including bounding the locations of context switches and using thread pairwise testing. In addition, assertions for two common synchronization intentions, atomicity and order, are provided to help developers detecting concurrency errors from a different perspective, which offer an additional opportunity to make debugging easier by reducing the distance between the execution of the concurrency error and its manifestation. Finally, this approach is protentially easy to port to other debuggers to support more programming languages.
37
Wei-ChengLiu and 劉惟成. "Codepecker:A Debugging Tool for Detecting Abnormal Threads of Parallel Programs on Shared Memory Multi-core Systems." Thesis, 2010. http://ndltd.ncl.edu.tw/handle/82480788103909350028.
Full textAbstract:
碩士<br>國立成功大學<br>電腦與通信工程研究所<br>98<br>Due to the popularity of multi-core processors in the computer market with their features of high performance and low power consumption, programmers begin to develop parallel programs for various applications with multiple threads. However, using traditional debugging tools to locate the abnormal threads is a heavy and complicated procedure and costs considerable time.
In this thesis, Codepecker is proposed to automatically locate the abnormal threads in a parallel program that contains multiple threads performing similar activities on shared memory multi-core systems. Codepecker locates the abnormal threads by identifying threads that behave differently from others and possesses multiple advantages such as high transparency, high portability and low overhead. Programmers can use the Codepecker to locate the abnormal threads rapidly, and further exploit the debugger to figure out the root cause of bug.
38
Menninghaus, Mathias. "Automated Performance Test Generation and Comparison for Complex Data Structures - Exemplified on High-Dimensional Spatio-Temporal Indices." Doctoral thesis, 2018. https://repositorium.ub.uni-osnabrueck.de/handle/urn:nbn:de:gbv:700-20180823528.
Full textAbstract:
There exist numerous approaches to index either spatio-temporal or high-dimensional data. None of them is able to efficiently index hybrid data types, thus spatio-temporal and high-dimensional data. As the best high-dimensional indexing techniques are only able to index point-data and not now-relative data and the best spatio-temporal indexing techniques suffer from the curse of dimensionality, this thesis introduces the Spatio-Temporal Pyramid Adapter (STPA). The STPA maps spatio-temporal data on points, now-values on the median of the data set and indexes them with the pyramid technique. For high-dimensional and spatio-temporal index structures no generally accepted benchmark exists. Most index structures are only evaluated by custom benchmarks and compared to a tiny set of competitors. Benchmarks may be biased as a structure may be created to perform well in a certain benchmark or a benchmark does not cover a certain speciality of the investigated structures. In this thesis, the Interface Based Performance Comparison (IBPC) technique is introduced. It automatically generates test sets with a high code coverage on the system under test (SUT) on the basis of all functions defined by a certain interface which all competitors support. Every test set is performed on every SUT and the performance results are weighted by the achieved coverage and summed up. These weighted performance results are then used to compare the structures. An implementation of the IBPC, the Performance Test Automation Framework (PTAF) is compared to a classic custom benchmark, a workload generator whose parameters are optimized by a genetic algorithm and a specific PTAF alternative which incorporates the specific behavior of the systems under test. This is done for a set of two high-dimensional spatio-temporal indices and twelve variants of the R-tree. The evaluation indicates that PTAF performs at least as good as the other approaches in terms of minimal test cases with a maximized coverage. Several case studies on PTAF demonstrate its widespread abilities.