Improving the performance of reverse debugging

Reverse debugging is the software development technique that effectively helps fix bugs occurring at the nondeterministic program behavior. It allows one to examine the past states of the program without rerunning it. An implementation of reverse debugging based on deterministic replay in the QEMU 2.0 emulator is described. A number of techniques improving the debugging performance due to reducing the amount of saved data, optimized storage of system snapshots, indexing, and compressing of the event log are proposed. The emulator can work together with the interactive GDB debugger, which makes it possible to use the reverse-continue, reverse-nexti, reverse-stepi and reverse-finish commands in the course of debugging. The execution time of these commands depends on the frequency of recording the system’s state snapshots. An estimate of the optimal frequency for the reverse-continue command is obtained.     

RPM: a rapid prototyping engine for multiprocessor systems

RPM enables rapid prototyping of different multiprocessor architectures. It uses hardware emulation for reliable design verification and performance evaluation. The major objective of the RPM project is to develop a common, configurable hardware platform to accurately emulate different MIMD systems with up to eight execution processors. Because emulation is orders of magnitude faster than simulation, an emulator can run problems with large data sets more representative of the workloads for which the target machine is designed. Because an emulation is closer to the target implementation than an abstracted simulation, it can accomplish more reliable performance evaluation and design verification. Finally, an emulator is a real computer with its own I/O; the code running on the emulator is not instrumented. As a result, the emulator looks exactly like the target machine (to the programmer) and can run several different workloads, including code from production compilers, operating systems, databases, and software utilities     

多核DSP软件调试环境研究与设计

针对武器装备嵌入式系统向自主化、智能化、小型化、低功耗快速发展的趋势,介绍了装备研制对自主多核处理器及其软件调试环境的迫切需求,分析了嵌入式系统远程调试的基本原理和特点、JTAG标准和边界扫描技术。以自主同构8核数字信号处理器为目标平台,基于目标平台JTAG控制器之间的菊花链连接方式,提出了面向该目标平台的软件调试环境设计方案,讨论了USB接口仿真器软硬件设计和多线程调试代理软件设计等关键技术。实现的软件调试环境能够在调试主机上对目标平台进行指令级和源码级交叉调试,解决了目标平台缺乏配套软件调试手段的实际问题,为目标平台在武器装备上的推广应用提供了有力支撑,对其他面向多核处理器的调试环境设计具有参考价值。     

基于PMON的龙芯BIOS初始化及VGABIOS模拟器

阐述基于PMON扩展后的龙芯基本输入输出系统（BIOS）的初始化流程以及ATI显卡BIOS的模拟器原理,针对自检过程中PC!设备的初始化、视频图形阵列（VGA）BIOS模拟器以及北桥的地址空间分配等关键性问题,给出相应的解决办法。经过调试和测试,扩展后的龙芯BIOS已在基于龙芯2E处理器的主板上可靠运行,能稳定加载为龙芯2E移植的LinuxDebian操作系统内核。     

Visual debugging

We developed an approach that uses our innate visual pattern recognition skills as part of the debugging process. Inspired by Huang's (1996) use of color to visualize energy distributions while untangling knots, we represented the particles graphically and color-coded them by energy value. Thus far, we've applied this approach to three domains: particle systems, cluster hardware configurations, and physics codes using finite element models. This debugging paradigm differs from software or program visualization in that we don't visualize software elements such as procedures, message passing between processors, or graph-based representations of data structures. In most application domains developers that use algorithm visualization tools must make decisions about what kind of visualization would best represent their code, and they must, in effect, code this visualization in addition to their application. For many developers, the time investment is too great compared to their perceived benefit, so they return to a traditional debugging approach. We believe that restricting the application domain increases the ease of use of visual debuggers. However, we go one step further by creating a, visual tool tailored to a particular application domain that can use either captured data or simulation outputs and requires no coding effort on the part of the user.     

多单片计算机开发系统的研究

本文介绍了多机开发系统和在线仿真技术，论述了多机仿真系统的软件结构和实现方法。着重分析了多机环境中调试程序的结构、功能及实现。     

An architectural framework for supporting heterogeneousinstruction-set architectures

An architectural framework that allows software applications and operating system code written for a given instruction set to migrate to different, higher performance architectures is described. The framework provides a hardware mechanism that enhances application performance while keeping the same program behavior from a user perspective. The framework is designed to accommodate program exceptions, self-modifying code, tracing, and debugging. Examples are given for IBM System/390 operating-system code and AIX utilities, showing the performance potential of the scheme using a very long instruction word (VLIW) machine as the high-performance target architecture     

基于QEMU的高效指令追踪技术

系统模拟器通过模拟处理器、内存、外设等硬件资源创建一个完整的虚拟计算机环境, 支持运行和调试不同架构的软件, 可大大缩短跨架构的软件开发周期. 模拟器的调试模块通常具有指令追踪功能, 可记录程序运行的指令序列以用于进一步分析, 如程序运行时间评估、程序行为模式分析、软硬件联合仿真等. 支持RISC-V架构的主流模拟器QEMU和Spike均具有指令追踪功能, 但其时间和空间开销过大, 在应对规模较大的应用时效率低下. 本文提出了一种基于QEMU的指令追踪技术, 将程序中的基本块、控制流图等静态信息与分支选择等动态信息解耦, 在保证指令序列不失真的同时高效追踪执行序列. 相比QEMU原生实现的指令追踪, 本文提出的指令追踪技术的时间开销平均降低了80%以上, 空间开销平均降低了95%以上. 此外, 本文面向RISC-V架构, 实现了多种场景下的指令序列离线分析, 包括指令分类统计、程序热点标记、行为模式分析等.     

A debugging and testing tool for supporting software evolution

This paper describes a tool for debugging programs which develop faults after they have been modified or are ported to other computer systems. The tool enhances the traditional debugging approach by automating the comparison of data structures between two running programs. Using this technique, it is possible to use early versions of a program which are known to operate correctly to generate values for comparison with the new program under development. The tool allows the reference code and the program being developed to execute on different computer systems by using open distributed systems techniques. A data visualisation facility allows the user to view the differences in data structures. By using the data flow of the code, it is possible to locate faulty sections of code rapidly. An evaluation is performed by using three case studies to illustrate the power of the technique.     

A protocol-centric approach to on-the-fly race detection

We present the design and evaluation of a new data-race-detection technique. Our technique executes at runtime rather than post-mortem, and handles unmodified shared-memory applications that run on top of CVM, a software distributed shared memory system. We do not assume explicit associations between synchronization and shared data, and require neither compiler support nor program source. Instead, we use a binary code re-writer to instrument instructions that may access shared memory. The most novel aspect of our system is that we are able to use information from the underlying memory system implementation in order to reduce the number of comparisons made at runtime. We present an experimental evaluation of our techniques by using our system to look for data races in five common shared-memory programs. We quantify the effect of several optimizations to the basic technique: data flow analysis, instrumentation batching, runtime code modification, and instrumentation inlining. Our system correctly found races in three of the five programs, including two from a standard benchmark suite. The slowdown of this debugging technique averages less than 2.5 for our applications.     

Tools and techniques for teaching microprocessor software development

Debugging low level language software can be a difficult business—the bare microprocessor lacks the user interface; facilities, such as simulators, provided on another machine can be tedious to use on running or partially working programs. A resolution of this difficulty lies in the harmonious use of a mainframe-based debugging system and a real microprocessor. This paper describes tools and techniques for the development of low level software for the Intel 8080 microprocessor employing both simulated and real microprocessors. The debugging system allows the user to set up a virtual microprocessor into which programs can be loaded and run and from which a flexible tracing of the executing program can be obtained. The debugging system is built into a general purpose multi-access operating system and this approach makes it possible to provide the system cheaply to a large number of users. Additionally, users have access to all the general facilities (such as editors) provided by the operating system itself. The system has been implemented on a minicomputer with 60 VDU terminals all of which can be used for interaction with the 8080 simulator or for general interactions with the mainframe operating system. The system has also been implemented in a self-simulating version to run on a real Intel 8080 microprocessor. Many of the VDUs on the minicomputer are controlled by Intel 8080 microprocessors and it is possible to load and run large Intel 8080 programs which were assembled (and tested) on the mainframe or run the self simulator based debugging system. In this way a range of complementary debugging environments is provided: the simulator on the mainframe with its access to backing store (and, hence, the ability to save trace information), the self simulator on the microprocessor (with its better performance for the single user), and the actual Intel 8080 itself. The user can easily move a partially tested program between environments and thus use the environment which best suits his current phase of testing.     

嵌入式系统开发环境目标监控器技术研究*

嵌入式系统开发环境中,目标监控器对嵌入式软件的开发和调试有至关重要的意义。从实现方式的角度介绍和分析了当前主流嵌入式系统开发环境目标监控器技术,如软件监控器、硬件监控器、软件仿真器和软件模拟监控器等,并对比了各种实现技术的差异和优缺点。     

Extension Language Automation of Embedded System Debugging

Embedded systems contain several layers of target processing abstraction. These layers include electronic circuit, binary machine code, mnemonic assembly code, and high-level procedural and object-oriented abstractions. Physical and temporal constraints and artifacts within physically embedded systems make it impossible for software engineers to operate at a single layer of processor abstraction. The Luxdbg embedded system debugger exposes these layers to debugger users, and it adds an additional layer, the extension language layer, that allows users to extend both the debugger and its target processor capabilities. Tcl is Luxdbg's extension language. Luxdbg users can apply Tcl to automate interactive debugging steps, to redirect and to interconnect target processor input-output facilities, to schedule multiple processor execution, to log and to react to target processing exceptions, to automate target system testing, and to prototype new debugging features. Inclusion of an extension language like Tcl in a debugger promises additional advantages for distributed debugging, where debuggers can pass extension language expressions across computer networks.     

Hybrid Approach to Faster Functional Verification with Full Visibility

For functional verification, software simulation provides full controllability and observability, whereas hardware emulation offers speed. This article describes a new platform that leverages the advantages of both. This platform implements an efficient scheme to record the internal behavior of an FPGA emulator and replay the relevant segment of a simulation in a software environment for debugging. Experimental results show an order-of-magnitude savings in debugging time compared to a software-only simulation approach.     

Tracing the executions of concurrent programs

Checking the reliability of software is an ever growing challenge. Fully automatic tools that attempt to cover the entire state space often fail because of state explosion. We present instead a toolset that employs some less-ambitious but useful methods to assist in software debugging. The toolset provides an automatic translation of the code into visual flowcharts, allowing the user to interactively select execution paths. It assists the user by calculating path conditions and exploring the neighborhood of the paths. It also allows the user to interactively step through the execution of the program, directed by temporal formulas interpreted over finite sequences. We will show several different ways of using these capabilities for debugging sequential and concurrent programs.     

BUSTER：一个可移植的并行调试器

软件可移植性问题研究对提高工作站机群系统的通用性具有重要意义。并行调试器通常对于平台的依赖性强,可移植性较差。为此,本文提出了一种层次结构的设计方案,通过通用源代码信息表,较好地解决了并行调试系统的平台独立性问题,该方案已经实际应用于并行调试工具BUSTER系统,成功地实现了该系统在不同运行平台的移植。     

Experience with a portable debugging tool

Debugging tools are usually highly machine and compiler dependent programs that are either impossible to move or require a tremendous effort to move to another machine. This paper describes Ctrace, a portable debugging tool for the C language that provides the same, easy-to-use debugging environment on all machines. A similar debugger can be written for any language. Ctrace is a preprocessor that inserts source language debugging code into the program before compilation that, at execution time, prints the text of each source language statement along with the values of variables it uses and modifies. Redundant trace output from program loops is detected and eliminated. Tracing can be limited to selected statements or functions. Ctrace has shown its usefulness and popularity by its installation on over 200, computers at Bell Laboratories. It has proven its portability by being used to test software on four different operating systems and nine different processors.     

一种新的高速嵌入式系统软件调试技术

随着嵌入式系统速度的显著提高,系统设计越来越复杂,对软件调试提出了新的挑战。传统的调试技术,仿真工具无法满足高速嵌入式系统的调试要求。该文介绍了一种综合式软件调试技术和方法,通过使用逻辑分析仪软件调试功能,结合嵌入式系统开发时使用的编译器,仿真器,调试器,进行高速嵌入式系统的功能验证,代码诊断,软件优化,分析子程序模块的执行效率。最后针对PPC8260处理器的软件调试提供了综合的软件调试方法。