PEARD: A Prototype Environment for Active Rule Debugging

This research has investigated dynamic, execution-based rule analysis through the development of a Prototype Environment for Active Rule Debugging, called PEARD. PEARD simulates the execution of active database rules, supporting the Event-Condition-Action rule paradigm. Rule definition is flexible, where changes to rules can be applied immediately during a debugging session without recompiling the system. A breakpoint debugging tool allows breakpoints to be set so that the state of variables may be inspected and changed anytime a breakpoint is reached during rule execution. A rule visualization tool displays the rule triggering process in graph form, supporting different visualization granularities to help the user to understand rule execution. Color coding is also used as part of the visualization tool to help the user see where the different parts of an ECA rule are executed due to deferred coupling modes. Users can examine different parts of the rule graph display to inspect the state of a transaction at different rule execution points. Other debugging features include a means for detecting potential cycles in rule execution and a utility to examine different rule execution paths from the same point in the rule triggering process. Our experience with PEARD has helped to identify some of the useful functional components of an active rule debugging tool and to identify research directions for future active rule development environments.This research was partially supported by NSF Grant No. IRI-9410993.     

一个基于Eclipse的通用Java程序插桩工具

插桩技术作为一种有效理解程序动态行为的手段,已经被广泛应用于程序分析、测试和验证中。然而,由于缺少通用的插桩工具,各种具体的应用往往需要从头开发特定的插桩程序,存在着大量的重复性工作。此外,由于在原始程序中插入了大量额外代码,致使调试过程变得更加复杂和困难。针对这些问题,提出了一个基于Eclipse的通用Java代码插桩工具,即通过规则定义匹配程序的执行点,从而定制针对各种分析、测试和验证插桩需求的支持。通过对插桩代码片段的显式/隐式切换实现其可见性管理,从而确保程序的理解和调试过程不受插桩代码影响。通过使用该工具,可以更好地将插桩技术应用于Java程序开发中。     

Net-dbx: a web-based debugger of MPI programs over low-bandwidthlines

This paper describes Net-dbx, a tool that utilizes Java and other World Wide Web tools for the debugging of MPI programs from anywhere in the Internet. Net-dbx is a source-level interactive debugger with the full power of gdb (the GNU Debugger) augmented with the debug functionality of the public-domain MPI implementation environments. The main effort was on a low overhead, yet powerful, graphical interface supported by low-bandwidth connections. The portability of the tool is of great importance as well because it enables the tool to be used on heterogeneous nodes that participate in an MPI multicomputer. Both needs are satisfied a great deal by the use of WWW browsing tools and the Java programming language. The user of our system simply points his/her browser to the Net-dbx page, logs in to the destination system, and starts debugging by interacting with the tool, just as with any GUI environment. The user can dynamically select which MPI processes to view/debug. A special WWW-based environment has been designed and implemented to host the system prototype     

On the use of diagnostic dependence-analysis tools in parallel programming: Experiences using PTOOL

Although considerable technology has been developed for debugging and developing sequential programs, producing verifiably correct parallel code is a much harder task. In view of the large number of possible scheduling sequences, exhaustive testing is not a feasible method for determining whether a given parallel program is correct; nor have there been sufficient theoretical developments to allow the automatic verification of parallel programs. PTOOL, a tool being developed at Rice University in collaboration with users at Los Alamos National Laboratory, provides an alternative mechanism for producing correct parallel code. PTOOL is a semi-automatic tool for detecting implicit parallelism in sequential Fortran code. It uses vectorizing compiler techniques to identify dependences preventing the parallelization of sequential regions. According to the model supported by PTOOL, a programmer should first implement and test his program using traditional sequential debugging techniques. Then, using PTOOL, he can select loop bodies that can be safely executed in parallel. At Los Alamos, we have been interested in examining the role of dependence-analysis tools in the parallel programming process. Therefore, we have used PTOOL as a static debugging tool to analyze parallel Fortran programs. Our experiences using PTOOL lead us to conclude that dependence-analysis tools are useful to today's parallel programmers. Dependence-analysis is particularly useful in the development of asynchronous parallel code. With a tool like PTOOL, a programmer can guarantee that processor scheduling cannot affect the results of his parallel program. If a programmer wishes to implement a partially parallelized region through the use of synchronization primitives, however, he will find that dependence analysis is less useful. While a dependence-analysis tool can greatly simplify the task of writing synchronization code, the ultimate responsibility of correctness is left to the programmer.This work was performed under the auspices of the U.S. Department of Energy.     

TigerSHARC多处理器阵列的诊断工具软件

TigerSHARC DSP多处理器阵列的拓扑结构是非常灵活的,可以满足多种不同应用的需要,但这种灵活性同时也给硬件调试和设备检测带来了极大的障碍.为解决这个问题,本文成功设计了一套功能强大的诊断工具软件,可以探测处理器和Link连接等信息,并提供良好的人机交互界面,以列表或图形报告的方式,让开发人员快速地进行故障定位.     

Dependence analysis for outer loop parallelization of existing Fortran-77 programs

We have used six static parallelization tools on four Fortran-77 programs used in physics simulations. We indicate areas where current tools have difficulties in recognizing parallelism, and illustrate these issues with simple examples. We suggest that a dynamic dependency analysis tool is needed to aid the user in the parallelization of dusty decks.     

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.     

PAST: accurate instrumentation on fully optimized program

Instrumentation is a powerful technique for monitoring, profiling, debugging, logging and tracing the software. In order to determine the instrumentation location, the user needs to know where the current executed location is in the source code. Previous instrumentation approaches rely on debugging information to find the location in the source code. For fully optimized programs, debugging information is not complete, which limits the application of those approaches. In this paper, we present pattern‐based abstract syntax tree (PAST) instrumentation, an ideal instrumentation methodology that accurately instruments the fully optimized program. The instrumentation location is specified in an intuitive way that matches the source code at the abstract syntax tree level. The program can be instrumented either at the compile time using the ordinary compiling or when it is running using the just‐in‐time compiling. Experimental results show that PAST can accurately instrument the target program. There is negligible run time overhead when the running program is instrumented without any operation. We have implemented PAST on both x86‐32 and x86‐64 to show that PAST is easily portable across different architecture. Copyright © 2015 John Wiley & Sons, Ltd.     

渐进式智能回溯向量化代码调优方法

为了充分发挥高性能计算机的计算能力,缓解程序员设计和编写并行程序的压力,扩充可用软件集合,设计并实现了利用交互界面深入挖掘程序中的可向量化语句,优化生成代码中的向量化语句,提高生成代码的执行效率.该方法对充分发挥高性能计算机的计算能力,增强系统可用性和扩展应用范围具有重要的意义,同时能够提供有效的辅助手段和工具支持.渐进式智能回溯向量化代码调优架构通过对用户提交的串行程序进行程序分析和变换,采用串行程序分析、数据依赖分析、向量化分析等技术手段,根据分析结果对程序进行变换和优化,自动生成最终的向量化代码.该方法通过分析串行程序中潜在的并行性,将其自动变换为等价的向量化代码形式,大大简化了程序员的工作.     

Event-enabled intelligent asset selection and grouping for photobook creation

The process of creating a photo product, such as a photobook, calendar or collage, from a large personal image collection requires intensive user effort. The primary goal of the current research was to develop an end-to-end solution to the problem of photo product generation that enables the user to complete the process with minimal edits, where the system intelligently selects assets and groups them before presenting the output to the user. The automation is driven by metadata extracted both from individual images as well as from sets of assets in a collection. In particular, we use an automatically detected event hierarchy to establish meaningful groupings in the assets, and to determine an appropriate grouping and pagination for the final product. We propose a novel intermediate construct, called a storyboard, which can be translated to different product types without recomputing the underlying metadata. In addition to chronological storyboards, we also describe a novel hybrid storyboard that joins chronological image presentation with groups of images of a common theme. A pagination algorithm uses the information in the storyboard and the product constraints to generate a product. Finally, the user is provided with a metadata-driven editing mechanism that makes it easy to change the auto-populated product. Given that the proposed system envisions user interaction in creating the final product, user studies are conducted to judge the usefulness of the system, where consumers use the system to generate a photobook with their own images.     

Visualization and debugging of distributed multiagent systems

Visualizing the behavior of systems with distributed data, control, and process is a notoriously difficult task. Each component in the distributed system has only a local view of the whole setup, and the onus is on the user to integrate, into a coherent whole, the large amounts of limited information they provide. In this article, we describe an architecture and an implemented system for visualizing and controlling distributed multiagent applications. The system comprises a suite of tools, with each tool providing a different perspective of the application being visualized . Each tool interrogates the components of the distributed application, collates the returned information, and presents this information to users in an appropriate manner. This in essence, shifts the burden ofinference from the user to the visualizer. Our visualizer has been evaluated on four distributed multiagent systems: a travel management application, a telecommunications network management application, a business process management demonstrator, and an electronic commerce application. Lastly, we briefly show how the suite of tools can be used together for debugging multiagent applications - a process we refer to as debugging via corroboration.     

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.     

Reducing the Overhead of Dynamic Analysis

Dynamic analysis (instrumenting programs with code to detect and preven errors during program execution) can be an effective approach to debugging, as well as an effective means to prevent harm being caused by malicious code. One problem with this approach is the runtime overhead introduced by the instrumentation. We define several techniques that involve using the results of static analysis to identify some cases where instrumentation can safely be removed. While we have designed the techniques with a specific dynamic analysis in mind (that used by the Runtime Type-Checking tool), the ideas may be of more general applicability.     

Using Static Analysis to Reduce Dynamic Analysis Overhead

Dynamic analysis (instrumenting programs with code to detect and prevent errors during program execution) can be an effective approach to debugging, as well as preventing harm from being caused by malicious code. One problem with this approach is the runtime overhead introduced by the instrumentation. We define several techniques that involve using the results of static analysis to identify some cases where instrumentation can safely be removed. While we have designed the techniques with a specific dynamic analysis in mind (that used by the Runtime Type-Checking tool), the ideas may be of more general applicability.     

Kitrace: Precise interactive measurement of operating systems kernels

Kitrace is a software tool that allows dynamic interactive measurement of UNIX kernel performance to much greater precision than that available from kernel profiling. Developers can measure, to microsecond resolution, the time required by a complex kernel activity, including time spent waiting for I/O activity or user processes. Kitrace has also proven useful for debugging, especially in situations where traditional breakpointing would be undesirable or would change the behavior of the kernel.     

基于位置的社会化网络的并行化推荐算法

针对传统的协同过滤算法在利用签到记录进行兴趣点(POI)推荐时不能充分利用签到信息所隐含的偏好、位置和社交网络信息而损失准确率的问题,以及传统的单机串行算法在大数据处理能力上的弱势,提出一种基于位置和朋友关系的协同过滤(LFBCF)算法,以用户历史偏好为基础,综合考虑用户社交关系网络进行协同过滤,并以用户的活动范围作为约束实现对用户的兴趣点推荐。为了支持大数据量的实验,将算法在Spark分布式计算平台上进行了并行化实现。研究过程中使用了Gowalla和Brightkite这两个基于位置的社会化网络数据集,分析了数据集中签到数量、签到位置之间距离、社交关系等可能对推荐结果造成影响的因素,以此来支持提出的算法。实验部分通过与传统的协同过滤算法等经典算法在准确率、F-measure上的对比验证了算法在推荐效果上的优越性,并通过并行算法与单机串行算法在不同数据规模上加速比的对比验证了算法并行化的意义以及性能上的优越性。     

A CPU–GPU framework for optimizing the quality of large meshes

The automatic generation of 3D finite element meshes (FEM) is still a bottleneck for the simulation of large fluid dynamic problems. Although today there are several algorithms that can generate good meshes without user intervention, in cases where the geometry changes during the calculation and thousands of meshes must be constructed, the computational cost of this process can exceed the cost of the FEM. There has been a lot of work in FEM parallelization and the algorithms work well in different parallel architectures, but at present there has not been much success in the parallelization of mesh generation methods. This paper will present a massive parallelization scheme for re-meshing with tetrahedral elements using the local modification algorithm. This method is frequently used to improve the quality of elements once the mesh has been generated, but we will show it can also be applied as a regeneration process, starting with the distorted and invalid mesh of the previous step. The parallelization is carried out using OpenCL and OpenMP in order to test the method in a multiple CPU architecture and also in Graphics Processing Units (GPUs). Finally we present the speedup and quality results obtained in meshes with hundreds of thousands of elements and different parallel APIs.     

Interoperable Run-Time Tools for Distributed Systems—A Case Study

Tools that observe and manipulate the run-time behavior of parallel and distributed systems are essential for developing and maintaining these systems. Sometimes users would even need to use several tools at the same time in order to have a higher functionality at their disposal. Today, tools developed independently by different vendors are, however, not able to interoperate. Interoperability not only allows concurrent use of tools, but also can lead to an added value for the user. A debugger interoperating with a checkpointing system, for example, can provide a debugging environment where the debugged program can be reset to any previous state, thus speeding up cyclic debugging for long running programs.Using this example scenario, we derive requirements that should be met by the tools' software infrastructure in order to enable interoperability. A review of existing infrastructures shows that these requirements are only partially met today. In an ongoing research effort, support for all of the requirements is built into the OMIS compliant on-line monitoring system OCM.     

基于Python的新浪微博数据爬虫

目前很多的社交网络研究都是采用国外的平台数据,而国内的新浪微博没有很好的接口方便研究人员采集数据进行分析。为了快速地获取到微博中的数据,开发了一款支持并行的微博数据抓取工具。该工具可以实时抓取微博中指定用户的粉丝信息、微博正文等内容;该工具利用关键字匹配技术,匹配符合规定条件的微博,并抓取相关内容;该工具支持并行抓取,可以同时抓取多个用户的信息。最后将串行微博爬虫工具和其并行版本进行对比,并使用该工具对部分微博数据作了一个关于流感问题的分析。实验结果显示:并行爬虫拥有较好的加速比,可以快速地获取数据,并且这些数据具有实时性和准确性。     

A Performance Analysis Tool for PVM Parallel Programs

In this paper,we introduce the design and implementation of ParaVT,which is a visual performance analysis and parallel debugging tool.In ParaVT,we propose an automated instrumentation mechanism.Based on this mechanism,ParaVT automatically analyzes the performance bottleneck of parallel applications and provides a visual user interface to monitor and analyze the performance of parallel programs.In addition,it also supports certain extensions.