Efficient program tracing

A program trace lists the addresses of instructions executed and data referenced during a program's execution. Earlier approaches to collecting program traces, including abstract execution and optimal control tracing, are reviewed. Two tracing systems based on these techniques are presented. Results collected when using the later systems on several programs show significant reductions in the cost of collecting traces. Reduction in trace file sizes are also significant     

反向调试技术研究综述

在软件的开发测试部署过程中,调试工作耗费了开发人员非常多的精力和时间,有时一个很难被发现的错误会导致多次重启调试。反向调试是软件调试的一种技术,无需重启即可向后查看运行的指令及状态,这能够大大提高软件调试的速度,降低软件开发的难度,有效修复程序运行时发生的错误。该技术的核心问题是运行状态的恢复,目前针对该问题的解决方法主要有状态保存和状态重构。文中主要从反向调试的原理、学术研究、产品实现、技术应用等方面梳理其发展情况,对该技术进行分析研究,总结了基于时间和基于指令的状态保存反向调试技术以及两种反向执行重构状态的方法,并提出了有关记录重放程序执行、定位分析软件错误、反向数据流恢复这3方面的应用,可为反向调试技术的研究应用提供一定的参考。     

Moped (a portable debugger)

Moped is a portable debugger that uses enhanced tracing facilities and backtracing to discover unusual or undesirable program behaviors. It is based upon two modules — Program Probes and Program History. Program Probes is a forward tracing utility which allows Moped to dynamically examine the execution of a program. Program History is a backtracing utility which allows Moped to study the executed section of a program. Together, Program Probes and Program History enable Moped to have more control over the behavior of a program than either one of them, and consequently to provide an easier path toward program debugging. Moped is written in Common LISP with no dependencies on details of the machine implementation. Therefore, it is easily portable to any Common LISP environment.     

A system for debugging via online tracing and dynamic slicing

Dynamic slicing is a promising trace based technique that helps programmers in the process of debugging. In order to debug a failed run, dynamic slicing requires the dynamic dependence graph (DDG) information for that particular run. The two major challenges involved in utilizing dynamic slicing as a debugging technique are the efficient computation of the DDG and the efficient computation of the dynamic slice, given the DDG. In this paper, we present an efficient debugger, which first computes the DDG efficiently while the program is executing; dynamic slicing is later performed efficiently on the computed DDG, on demand. To minimize program slowdown during the online computation of DDG, we make the design decision of not outputting the computed dependencies to a file, instead, storing them in memory in a specially allocated fixed size circular buffer. The size of the buffer limits the length of the execution history that can be stored. To maximize the execution history that can be maintained, we introduce optimizations to eliminate the storage of most of the generated dependencies, at the same time ensuring that those that are stored are sufficient to capture the bug. Experiments conducted on CPU‐intensive programs show that our optimizations are able to reduce the trace rate from 16 to 0.8 bytes per executed instruction. This enables us to store the dependence trace history for a window of 20 million executed instructions in a 16‐MB buffer. Our debugger is also very efficient, yielding slicing times of around a second, and only slowing down the execution of the program by a factor of 19 during the online tracing step. Using recently proposed architectural support for monitoring, we are also able to handle multithreaded programs running on multicore processors. Copyright © 2011 John Wiley & Sons, Ltd.     

WCET可预测的Java指令集硬件实现

为能以硬件方式直接执行CISC结构的Java字节码,设计并实现适用于32位嵌入式实时Java平台的JPOR-32指令集。分析Java虚拟机规范中各Java字节码的功能和实现原理,设定执行每条指令时信号和数据在Java处理器数据通路上的变化,采用微指令方式执行复杂指令,简单指令直接执行,从而使JPOR-32的指令集具有RISC特性。实验结果验证了指令集的正确性及其最坏情况执行时间(WCET)的可预测性。     

CLPGUI: A Generic Graphical User Interface for Constraint Logic Programming

CLPGUI is a generic graphical user interface for visualizing and controlling the execution of constraint logic programs. CLPGUI has been designed to be used in different contexts: initially for teaching purposes, then for debugging complex programs of real-world scale, and recently for developing end-user interfaces. The challenge of developing a tool which is generic w.r.t. both the constraint logic programming system and the visualizers, is addressed by a client-server architecture for connecting a CLP process to a Java-based GUI process, and by a non-intrusive tracing and control method based on annotations in the CLP program. Arbitrary constraints and goals can be posted incrementally from the GUI in an interactive manner, and arbitrary states can be recomputed. We describe several generic 2D and 3D viewers of the variables and of the search tree, and argue that the 3D representation is best-suited to apprehend the shape of large search trees. We also illustrate the use of CLPGUI for developing application-oriented end-user interfaces on two placement problems, one in virtual reality.     

Moped (a portable debugger)

Moped is a portable debugger that uses enhanced tracing facilities and backtracing to discover unusual or undesirable program behaviors. It is based upon two modules — Program Probes and Program History. Program Probes is a forward tracing utility which allows Moped to dynamically examine the execution of a program. Program History is a backtracing utility which allows Moped to study the executed section of a program. Together, Program Probes and Program History enable Moped to have more control over the behavior of a program than either one of them, and consequently to provide an easier path toward program debugging. Moped is written in Common LISP with no dependencies on details of the machine implementation. Therefore, it is easily portable to any Common LISP environment.This work supported in part by Hewlett-Packard Company, the National Science foundation Under Grant Number MCS81-21750 and the Defense Advanced Research Projects Agency under contract number DAAK11-84-K-0017.     

Debugging with dynamic slicing and backtracking

Programmers spend considerable time debugging code. Symbolic debuggers provide some help but the task remains complex and difficult. Other than breakpoints and tracing, these tools provide little high-level help. Programmers must perform many tasks manually that the tools could perform automatically, such as finding which statements in the program affect the value of an output variable for a given test case, and what was the value of a given variable when the control last reached a given program location. If debugging tools provided explicit support for these tasks, the debugging process could be automated to a significant extent. In this paper we present a debugging model, based on dynamic program slicing and execution backtracking techniques, that easily lends itself to automation. This model is based on experience with using these techniques to debug software. We also present a prototype debugging tool, SPYDER, that explicitly supports the proposed model, and with which we are performing further debugging research.     

一种Runahead执行的改进算法

Runahead执行技术能够显著地提高计算机系统的存储级并行,而无需对处理器结构做出较大改动。但Runahead执行处理器要比传统处理器多执行很多指令,最多是正常执行指令数的三倍以上,大大增加了处理器的功耗。本文通过分析发现Runahead执行在预执行阶段会执行大量的无效指令,据此提出一种减少无效指令的方法来提高Runa-head执行处理器的效率。通过实验分析,在性能影响较小的情况下,该方法最多可以减少50%的Runahead执行处理器在预执行阶段执行的无效指令。     

PIGS—A system for programming with interactive graphical support

This paper describes an implementation of a system for programming using structured charts with interactive graphical support. It provides a graphical editor for the user to interactively build and edit programs using Nassi-Shneiderman diagrams (NSD)¹ as the structured control constructs of logic flow. It can interpret a program in NSD chart form, and the execution sequence of the NSD is displayed at a graphical terminal. On-line debugging and testing facilities are available which allow the user to examine and modify the program under execution. The system has been designed with the aim of supporting the development, debugging, testing, documentation and maintenance of programs in the same environment.     

Studying the fault-detection effectiveness of GUI test cases for rapidly evolving software

Software is increasingly being developed/maintained by multiple, often geographically distributed developers working concurrently. Consequently, rapid-feedback-based quality assurance mechanisms such as daily builds and smoke regression tests, which help to detect and eliminate defects early during software development and maintenance, have become important. This paper addresses a major weakness of current smoke regression testing techniques, i.e., their inability to automatically (re)test graphical user interfaces (GUIs). Several contributions are made to the area of GUI smoke testing. First, the requirements for GUI smoke testing are identified and a GUI smoke test is formally defined as a specialized sequence of events. Second, a GUI smoke regression testing process called daily automated regression tester (DART) that automates GUI smoke testing is presented. Third, the interplay between several characteristics of GUI smoke test suites including their size, fault detection ability, and test oracles is empirically studied. The results show that: 1) the entire smoke testing process is feasible in terms of execution time, storage space, and manual effort, 2) smoke tests cannot cover certain parts of the application code, 3) having comprehensive test oracles may make up for not having long smoke test cases, and 4) using certain oracles can make up for not having large smoke test suites.     

Debugging DVM Programs

Facilities for debugging FORTRAN-DVM and C-DVM programs are described. The following approach is used to debug a DVM program. At the first stage, the program is debugged as an ordinary sequential program with the help of conventional debugging facilities. At the second stage, the program is executed on the same computer in a special mode of checking DVM directives. At the third stage, the program can be executed in a special mode when intermediate results of parallel execution are compared with reference results (e.g., those obtained during a sequential execution).     

Fast Ray Sorting and Breadth‐First Packet Traversal for GPU Ray Tracing

We present a novel approach to ray tracing execution on commodity graphics hardware using CUDA. We decompose a standard ray tracing algorithm into several data‐parallel stages that are mapped efficiently to the massively parallel architecture of modern GPUs. These stages include: ray sorting into coherent packets, creation of frustums for packets, breadth‐first frustum traversal through a bounding volume hierarchy for the scene, and localized ray‐primitive intersections. We utilize the well known parallel primitives scan and segmented scan in order to process irregular data structures, to remove the need for a stack, and to minimize branch divergence in all stages. Our ray sorting stage is based on applying hash values to individual rays, ray stream compression, sorting and decompression. Our breadth‐first BVH traversal is based on parallel frustum‐bounding box intersection tests and parallel scan per each BVH level. We demonstrate our algorithm with area light sources to get a soft shadow effect and show that our concept is reasonable for GPU implementation. For the same data sets and ray‐primitive intersection routines our pipeline is ～3x faster than an optimized standard depth first ray tracing implemented in one kernel.     

基于region的动态重用技术

1.引言指令之间的依赖使超标量计算机的处理器每个时钟周期只能执行平均1.7到2.1条指令。同时指令的运行带有很大的重复性。指令重复是指一条静态指令多次动态执行得到的结果是一样的。通常的情况下,对一条计算指令,如果它的输入是相同的,那么其结果也是相同的。但是,也存在输入不同、但结果相同的情况;例如两个数做布尔运算,在很多种情况下,结果都是一样的。在本文中我们说一条指令被重复当且仅     

语法制导生成的虚拟仪器开发平台

如何以一种与特殊的图形用户接口无关的形式一致地描述数据流可视化编程语言及其开发平台,成为虚拟仪器开发平台自动生成的主要问题。该文以自主研制的开发平台LabScene为例,形式化地描述其中最主要的3个部分：编辑,运行,调试,把这些形式化的描述翻译成C#语言,卖现自动生成,为以非数据流为核心的虚拟仪器开发平台的自动生成提供参考依据。     

多核处理器YHFT-QDSP的调试系统

YHFT-QDSP是一款多核处理器。为满足其并发调试和实时调试的需要,在原有单核调试系统的基础上设计实现了多核同步调试系统和片上实时追踪系统（片上Trace）。多核同步调试提供了命令广播和断点同步触发等并发程序协同调试的功能;片上Trace通过专用硬件记录程序执行路径和数据读写等信息实现非入侵实时调试。本文从原理、结构和
软硬件实现等方面介绍了该调试系统。     

Event associations in SNOBOL4 for program debugging

An event association facility for the SNOBOL4 programming language is described. This facility permits the execution of a programmer-defined function to be associated with the occurrence of a specified event. The events with which associations can be made are those applicable to program debugging. Associations can be made with events such as variable referencing, statement execution, program interruption, function call and return, and execution-time errors. By making event associations available at the source-language level, debugging aids can be written in SNOBOL4 itself, using the full capabilities of that language. As illustrated by several examples, this approach facilitates the implementation of simple yet powerful debugging aids written in the same language as the programs to be debugged. Event associations provide a mechanism for the unification of the existing SNOBOL4 debugging facilities, and a basis for the addition of other events. The implementation of event associations is also described.     

Dynamic Instruction Scheduling in a Trace-based Multi-threaded Architecture

Simulation results are presented using the hardware-implemented, trace-based dynamic instruction scheduler of our single process DTSVLIW architecture to schedule instructions from several processes into multiple streams of VLIW instructions for execution by a wide-issue, simultaneous multi-threading (SMT) execution engine. The scheduling process involves single instruction execution of each process, dynamically scheduling executed instructions into blocks of VLIW instructions cached for subsequent SMT execution: SMT provides a mechanism to reduce the impact of horizontal and vertical waste, and variable memory latencies, seen in the DTSVLIW. Preliminary experiments explore this extended model. Results achieve PE utilization of up to 87% on a 4-thread, 1-scalar, 8 PE design, with speed-ups of up to 6.3 that of a single processor. Noticeably it only needs a single scalar process to be scheduled at any time, with main memory fetches being 1–4% that of a single processor.     

The impact of incorrectly speculated memory operations in a multithreaded architecture

The speculated execution of threads in a multithreaded architecture, plus the branch prediction used in each thread execution unit, allows many instructions to be executed speculatively, that is, before it is known whether they actually needed by the program. In this study, we examine how the load instructions executed on what turn out to be incorrectly executed program paths impact the memory system performance. We find that incorrect speculation (wrong execution) on the instruction and thread-level provides an indirect prefetching effect for the later correct execution paths and threads. By continuing to execute the mispredicted load instructions even after the instruction or thread-level control speculation is known to be incorrect, the cache misses observed on the correctly executed paths can be reduced by 16 to 73 percent, with an average reduction of 45 percent. However, we also find that these extra loads can increase the amount of memory traffic and can pollute the cache. We introduce the small, fully associative wrong execution cache (WEC) to eliminate the potential pollution that can be caused by the execution of the mispredicted load instructions. Our simulation results show that the WEC can improve the performance of a concurrent multithreaded architecture up to 18.5 percent on the benchmark programs tested, with an average improvement of 9.7 percent, due to the reductions in the number of cache misses.     

基于录制重放的区块链交易执行追溯方法

区块链上运行的智能合约具有一经部署难以修改、调用执行需经过共识等特点, 现有的需要修改智能合约代码或打断其执行过程的调试方法难以直接应用到智能合约上. 由于智能合约的运行过程由区块链交易顺序执行过程组成, 实现对区块链交易执行过程的追溯是提升智能合约可调试性的一个有效途径. 对区块链交易执行过程进行追溯主要目标是找出一条已经出块的区块链交易是如何得到当前的执行结果的. 区块链交易的执行依赖于区块链内部状态, 且该状态取决于之前区块链交易的执行结果, 因此存在着传递性依赖. 区块链交易的依赖性和区块链所提供的执行环境的特点给区块链交易执行追溯带来了挑战. 区块链交易执行追溯面临的挑战主要有3方面, 即如何从智能合约部署的生产环境中获取足够追溯的信息、如何获取区块链交易之间的依赖关系, 以及如何保证追溯结果与实际在线执行过程一致. 提出了一种基于录制重放的区块链交易执行追溯方法, 在合约容器中建立录制重放机制, 无需修改合约代码即可支持交易执行中对状态读写操作的录制, 并且不会打断智能合约运行; 提出了基于状态读写的交易依赖分析算法, 支持对存在依赖关系的前序交易进行按需回溯; 此外, 设计了录制读写操作记录的验证机制, 确保重放的执行过程与真实执行过程之间的一致性可被验证. 所提出的方法能够追溯区块链交易调用智能合约的执行过程, 可用于智能合约调试, 并且当智能合约异常造成损失时可用于举证. 在实验中对比了将录制的读写操作记录存储于链上和存储于链下之间的性能差异, 通过案例研究展示了所提方法在追溯区块链交易执行方面的有效性和优点.