Tools and strategies for debugging distributed stream processing applications

Distributed data stream processing applications are often characterized by data flow graphs consisting of a large number of built‐in and user‐defined operators connected via streams. These flow graphs are typically deployed on a large set of nodes. The data processing is carried out on‐the‐fly, as tuples arrive at possibly very high rates, with minimum latency. It is well known that developing and debugging distributed, multi‐threaded, and asynchronous applications, such as stream processing applications, can be challenging. Thus, without domain‐specific debugging support, developers struggle when debugging distributed applications. In this paper, we describe tools and language support to support debugging distributed stream processing applications. Our key insight is to view debugging of stream processing applications from four different, but related, perspectives. First, debugging the semantics of the application involves verifying the operator‐level composition and inspecting the flows at the logical level. Second, debugging the user‐defined operators involves traditional source‐code debugging, but strongly tied to the stream‐level interactions. Third, debugging the deployment details of the application require understanding the runtime physical layout and configuration of the application. Fourth, debugging the performance of the application requires inspecting various performance metrics (such as communication rates, CPU utilization, etc.) associated with streams, operators, and nodes in the system. In light of this characterization, we developed several tools such as a debugger‐aware compiler and an associated stream debugger, composition and deployment visualizers, and performance visualizers, as well as language support, such as configuration knobs for logging and tracing, deployment configurations such as operator‐to‐process and process‐to‐node mappings, monitoring directives to inspect streams, and special sink adapters to intercept and dump streaming data to files and sockets, to name a few. We describe these tools in the context of Spade —a language for creating distributed stream processing applications, and System S —a distributed stream processing middleware under development at the IBM Watson Research Center. Published in 2009 by John Wiley & Sons, Ltd.     

Relative Debugging of Automatically Parallelized Programs

We describe a system that simplifies the process of debugging programs produced by computer-aided parallelization tools. The system uses relative debugging techniques to compare serial and parallel executions in order to show where the computations begin to differ. If the original serial code is correct, errors due to parallelization will be isolated by the comparison.One of the primary goals of the system is to minimize the effort required of the user. To that end, the debugging system uses information produced by the parallelization tool to drive the comparison process. In particular, the debugging system relies on the parallelization tool to provide information about where variables may have been modified and how arrays are distributed across multiple processes. User effort is also reduced through the use of dynamic instrumentation. This allows us to modify the program execution without changing the way the user builds the executable. The use of dynamic instrumentation also permits us to compare the executions in a fine-grained fashion and only involve the debugger when a difference has been detected. This reduces the overhead of executing instrumentation.     

Managing Information in a Co-operative Object Database System

The paper describes a software infrastructure that was built to manage information in a co-operative environment for the design of control systems. The architecture of the environment, the organization of the design database and a suite of information management tools are presented. The paper suggests that the distributed client–server architecture and object database technology meet the requirements of managing information in the environment. The following issues related to information management are examined in more detail: support for version control, maintenance of information integrity by means of object access control and consistency control, support for user co-operation based on object sharing and change notification, graphical user interfaces, and design tool interfaces. Problems encountered during the implementation of the environment using a commercial object database management system are also discussed.     

Enabling the generation of web applications from mockups

Mockups are widely used to elicit and validate user requirements in web applications, and several intuitive tools have been developed in recent years, actively involving the end user in the requirements solicitation process. However, most current web development approaches and tools discard mockups after the information‐gathering process, abandoning the opportunity to exploit underlying information in them for autogenerating functional web applications. To overcome this limitation, we have devised a method for deriving the database schema and the logic of the web application from the information contained within mockups. In particular, the method gathers clues on how to organize the data and the control flow of the web application by analyzing the structure and relationships of the widgets in the mockup. Based on the proposed method, we have implemented a tool supporting the generation of web applications abiding by the model‐view‐controller architectural pattern. The tool has been evaluated by involving several end users in the development of web applications for different domains.     

支持多种并行程序设计模式的可移植并行调试器设计与实现

MPDG是为高性能并行巨型机系统设计的调试工具,其设计指导思想是：1．采用Client/Server结构,实现系统的可移植性,具体表现为将用户界面,并行调试管理与调试监控服务分离,调试监控采用目标系统支持的调试器;2．以同一的使用方式支持多种并行程序设计模式应用,针对共享内存的并行目标应用（如OpenMP程序)和基．于水息传递的分布式目标应用（如PVM或MPI程序）,提供风格完全一致的调试手段;3．实现图形用户界面,MPDG的GUI分为3级,即主界面,进程集,单个进程,进程集控制特别适合具有相同执行流和用户视图的并行进程的调试。     

PACKTER: implementation of internet traffic visualizer and extension for network forensics

Traffic visualization tools help network operators to maintain awareness of the status of a network, including anomalous activities. Unfortunately, the network operator may look away from the visualizer when beginning network forensics, such as launching a terminal application, logging into a server, and analyzing log files. Thus, the eyesight of the network operator will move from the visual screen even if valuable information is displayed. Our motivation is to develop the ability to use visualization tools as a network operation console. Whereas previous tools focused on outputting packet information, we herein extend the visualizer to accept inputting for operators to start their operations. Since little such software exists for our intent, we develop PACKTER, which is able to visualize traffic based on per-packet information in real time. We also extend PACKTER to have a function of negotiating to a network forensic system, which allows the operator to select an individual packet using a mouse, to start network forensics using a keyboard, and to receive results without looking away from the PACKTER viewer.     

The PROMPT suite: interactive tools for ontology merging and mapping

Researchers in the ontology-design field have developed the content for ontologies in many domain areas. This distributed nature of ontology development has led to a large number of ontologies covering overlapping domains. In order for these ontologies to be reused, they first need to be merged or aligned to one another. We developed a suite of tools for managing multiple ontologies. These suite provides users with a uniform framework for comparing, aligning, and merging ontologies, maintaining versions, translating between different formalisms. Two of the tools in the suite support semi-automatic ontology merging: P is an interactive ontology-merging tool that guides the user through the merging process, presenting him with suggestions for next steps and identifying inconsistencies and potential problems. A P uses a graph structure of ontologies to find correlation between concepts and to provide additional information for P .     

A development environment for complex distributed real-timeapplications

Engineering of complex distributed real-time applications is one of the hardest tasks faced by the software profession today. All aspects of the process, from design to implementation, are made more difficult by the interaction of behavioral and platform constraints. Providing tools for this task is likewise not without major challenges. In this paper, we discuss a tool suite which supports the development of complex distributed real-time applications in a suitable high-level language (CRL). The suite's component tools include a compiler, a transformer-optimizer, an allocator-migrator, a schedulability analyzer, a debugger-monitor, a kernel, and a (simulated) network manager. The overall engineering approach supported by the suite is to provide as simple and natural an integrated development paradigm as possible. The suite tools address complexity due to distribution, scheduling, allocation and other sources in an integrated manner (largely) transparent to the developer. To reflect the needs of propagation of functional and nonfunctional requirements throughout the development process, a number of robust code transformation and communication mechanisms have been incorporated into the suite. To facilitate practical use of the suite, the developed programs compile-transform to a safe subset of C++ with appropriate libraries and runtime support. (In this safe subset (C++) the use of pointers is minimized. Aliases are not allowed     

Volta: Developing Distributed Applications by Recompiling

Mainstream languages and tools are tailored for sequential, nondistributed applications, with support for distributed computing provided only in library APIs. Such programming environments force developers to make decisions early in the application life cycle about where the code should run, structuring the entire application around partitioning decisions. Performance measurement might reveal that the original partitioning was wrong, but redistributing the application is expensive because redistributing is restructuring. This article describes a new kind of tool suite that recompiles executables into a distributed form on the basis of declarative user annotations, inserting most of the necessary remoting and synchronization boilerplate code and facilitating post hoc instrumentation to drive quantitative redistribution. Because the tools operate on the intermediate language CIL (.NET Common Intermediate Language), they're compatible with a wide variety of .NET programming languages and eventual execution environments, even those that don't support CIL directly, such as JavaScript.     

Foundations of distributed interaction systems

There are numerous applications where a variety of human and software participants interactively pursue a given task (play a game, engage in a simulation, etc.). In this paper, we define a basic architecture for a distributed, interactive system (DIS for short). We then formally define a mathematical construct called a DIS abstraction that provides a theoretical basis for a software platform for building distributed interactive systems. Our framework provides a language for building multiagent applications where each agent has its own behaviors and where the behavior of the multiagent application as a whole is governed by one or more “master” agents. Agents in such a multiagent application may compete for resources, may attempt to take actions based on incorrect beliefs, may attempt to take actions that conflict with actions being concurrently attempted by other agents, and so on. Master agents mediate such conflicts. Our language for building agents (ordinary and master) depends critically on a notion called a “generalized constraint” that we define. All agents attempt to optimize an objective function while satisfying such generalized constraints that the agent is bound to preserve. We develop several algorithms to determine how an agent satisfies its generalized constraints in response to events in the multiagent application. We experimentally evaluate these algorithms in an attempt to understand their advantages and disadvantages. This revised version was published online in June 2006 with corrections to the Cover Date.     

Multiagent systems and information retrieval our experience with X.MAS

Autonomous agents and multiagent systems have been successfully applied to a number of problems and have been largely used in different application fields. In particular, in this paper we are interested in information retrieval. In fact, in this field multiagent solutions are very useful and effective since they decouple the problem in a network of software agents that interact to solve problems that are beyond the individual capabilities or knowledge. In so doing, multiagent systems allow to overwhelm typical problems of single agent and centralized approaches. To discuss the lesson learnt in using the multiagent technology in the field of information retrieval, in this paper, we present our experience in using X.MAS, a generic multiagent architecture aimed at retrieving, filtering and reorganizing information according to user interests. To this end, after presenting X.MAS, we illustrate six applications built upon it. Our conclusion is that multiagent technology is quite effective to design and realize concrete information retrieval applications.     

Visualization and debugging in a heterogeneous environment

The authors' experiences with visualization and debugging of parallel virtual machine (PVM) applications and two of the tools they have devised to facilitate these tasks are described. One of the tools is a graphical monitoring package called Xab that can visually display PVM activities inside an application running across a network. The other is a graphical programming environment called Hence, which helps the user write, compile, execute, and trace heterogeneous distributed programs. The authors discuss their early work, the present research, and the future directions of these experimental projects     

基于机群操作系统的并行调试器

并行调试工具的设计，是并行计算环境工具研究开发中的一个突出难点。介绍了一个在曙光3000上实现的并行调试器DCDB3．0。该调试器是未来曙光4000机群操作系统的一部分，是曙光3000上的第1个可运行版本，采用典型的客户／服务器模式。客户端的用户界面可将冗繁的调试信息与操作可视化。客户端可以远离提供服务的大型机，其远程通信依赖的是机群操作系统中的DRPC和任务管理，前者提供远程方法调用，后者使得客户端能够在服务器上启动相应的任务。DCDB3．0的服务器端负责处理调试任务和同客户端进行信息交互。DCDB3．0的功能具有可扩放性，使得可以在此平台上研究一些高级并行调试技术的实现。改进了已有的方式，实现了重放技术，并计划进一步添加其他高级并行调试技术。     

虚拟组织信息系统动态集成研究

虚拟组织信息系统是一种分布性、柔性、开放性能够快速适应组织变化与发展的动态集成系统。提出了基于SOA体系框架来构建虚拟组织信息系统,分析了虚拟组织从组建到解散的动态集成过程框架。应用Web Services技术设计了一个虚拟组织信息系统动态集成应用系统,具有了用户访问系统、动态业务构建器、UDDI注册服务系统和信息管理工具等功能。最后给出了虚拟组织信息系统动态集成在图书馆信息资源共享服务项目中的应用实例。     

Interaction styles in tools for developing virtual environments

This article discusses and compares interaction styles in development tools for virtual environments (VE). The comparison relies on a qualitative empirical study of two development processes where a command language and a direct manipulation based tool were used to develop the same virtual environment application. The command language tool proved very flexible and facilitated an even distribution of effort and progress over time, but debugging and identification of errors was very difficult. Contrasting this, the direct manipulation tool enabled faster implementation of a first prototype but did not facilitate a shorter implementation process as a whole. On the basis of these findings, the strength and weaknesses of direct manipulation for developing virtual environment applications are explored further through a comparison with a successful direct manipulation tool for developing interactive multimedia applications. The comparisons are used to identify and emphasize key requirements for virtual environment development tool interface design.     

A graphical development and debugging environment for parallel programs

To provide high-level graphical support for PVM (Parallel Virtual Machine) based program development, a complex programming environment (GRADE) is being developed. GRADE currently provides tools to construct, execute, debug, monitor and visualize message-passing parallel programs. It offers a high-level graphical programming abstraction mechanism to construct parallel applications by introducing a new graphical language called GRAPNEL. GRADE also provides the programmer with the same graphical user interface during the program design and debugging stages. A distributed debugging engine (DDBG) assists the user in debugging GRAPNEL programs on distributed memory computer architectures. Tape/PVM and PROVE support the performance monitoring and visualization of parallel programs developed in the GRADE environment.     

A Library for Developing PHIGS Programming Tools in a PEX Environment

The merger of three-dimensional graphics with the X Window System has recently been standardized by adapting PHIGS, the Programmer's Hierarchical Interactive Graphics System, to the X Window System with PEX, the PHIGS Extension to X. The standard programming library for PEX has been defined to be identical to PHIGS PLUS allowing PHIGS programs to port directly to the X environment. X uses a client server model to run applications as client processes which communicate with a server to perform graphical display and input. For improved performance, the PEX extension defines new server resources to reduce network traffic and to take advantage of graphics hardware existing on high-end servers. A side effect of this distributed model of computation is a distribution of PHIGS structures leading to a relaxation of the exclusive access which a PHIGS application usually maintains over its Central Structure Store. We exploit the distributed nature of a PEX/PHIGS client's Central Structure Store to provide access to it for other applications besides the originating PEX/PHIGS client. We refer to these other applications as tools since one of our primary goals is to create development tools for PHIGS programmers. Rather than concentrate on particular debugging tools, we focus upon easing the process of actually developing tools. Our goal is to supply a collection of routines which can be used by PHIGS programmers to create custom tools or other programs which require access to the graphics data of remote PHIGS processes. Our Tool Development Library provides the PHIGS programmer a small number of management routines which orchestrate the connection and mapping to the data of one or more remote PHIGS applications. Manipulation of remote PHIGS structures is accomplished just as easily as local operations and is performed using standard PHIGS calls. The remote application being accessed requires no changes to its source code. Obvious uses for the Tool Development Library are in the construction of PHIGS tools such as structure browsers, editors and debugging aids. Less obvious is the potential for developing collections of cooperating graphics applications which share graphics data.     

Self-organization and multiagent systems: II. Applications and the development technology

Major trends in the development of modern information technologies are to a large extend determined by important practical problems that arise in economics, ecology, safety of society and individuals, and in other fields. Even though these problems seem to be quite different and the requirements for their software implementation are also different, they have many common features, which imply the most stringent requirements for modern information technologies. These features were analyzed in the first part of the present paper. That analysis showed that the new requirements for the model and software implementation of such problems are best met by the multiagent self-organizing system model. In this paper, we consider examples of using this model in various applications and describe their architectures and software implementation; in particular, multiagent self-organization models as applied for flood forecasting and planning and operational enterprise management are described. New capabilities of multiagent self-organizing systems are demonstrated using a self-learning system for detecting intrusions into computer networks as an example. Here, the problem of self-configuration of an overlay network is actually solved. The capabilities of a multiagent self-organizing system in large-scale control in real time are demonstrated using adaptive traffic control in large cities. For the software implementation of multiagent self-organizing systems, special development tools that are different from the existing ones are needed because the conventional top-down development paradigm is inappropriate for self-organizing architectures. The cause is that the global behavior of a multiagent self-organizing system emerges due to local interactions; therefore, it cannot be predicted in advance. For that reason, the bottom-up development model is more appropriate for such systems. In this paper, we give a brief review of the models and approaches proposed for this purpose. One of the promising approaches based on the use of the so-called self-organization design patterns is described in more detail. Results of using the multiagent self-organization model are discussed and prospects of its practical application are estimated.     

GCG Stacks: a friendly interface for the GCG programs.

A 'PLUS' stack which provides a friendly user interface for the GCG suite of programs is presented. The interface takes advantage of the whole set of programming tools available in a graphical and object-oriented environment and its major features include: (i) an efficient management of the on-line help documents, and (ii) a flexible editor for macrocommands. The former facilitates finding specific information in the huge documentation bundled with the GCG suite, and the latter is useful whenever several GCG programs must be run in sequence with automatic piping of the intermediate results.