7,516 research outputs found
Control and Debugging of Distributed Programs Using Fiddle
The main goal of Fiddle, a distributed debugging engine, is to provide a
flexible platform for developing debugging tools. Fiddle provides a layered set
of interfaces with a minimal set of debugging functionalities, for the
inspection and control of distributed and multi-threaded applications.
This paper illustrates how Fiddle is used to support integrated testing and
debugging. The approach described is based on a tool, called Deipa, that
interprets sequences of commands read from an input file, generated by an
independent testing tool. Deipa acts as a Fiddle client, in order to enforce
specific execution paths in a distributed PVM program. Other Fiddle clients may
be used along with Deipa for the fine debugging at process level. Fiddle and
Deipa functionalities and architectures are described, and a working example
shows a step-by-step application of these tools.Comment: In M. Ronsse, K. De Bosschere (eds), proceedings of the Fifth
International Workshop on Automated Debugging (AADEBUG 2003), September 2003,
Ghent. cs.SE/030902
Statistical Assertions for Validating Patterns and Finding Bugs in Quantum Programs
In support of the growing interest in quantum computing experimentation,
programmers need new tools to write quantum algorithms as program code.
Compared to debugging classical programs, debugging quantum programs is
difficult because programmers have limited ability to probe the internal states
of quantum programs; those states are difficult to interpret even when
observations exist; and programmers do not yet have guidelines for what to
check for when building quantum programs. In this work, we present quantum
program assertions based on statistical tests on classical observations. These
allow programmers to decide if a quantum program state matches its expected
value in one of classical, superposition, or entangled types of states. We
extend an existing quantum programming language with the ability to specify
quantum assertions, which our tool then checks in a quantum program simulator.
We use these assertions to debug three benchmark quantum programs in factoring,
search, and chemistry. We share what types of bugs are possible, and lay out a
strategy for using quantum programming patterns to place assertions and prevent
bugs.Comment: In The 46th Annual International Symposium on Computer Architecture
(ISCA '19). arXiv admin note: text overlap with arXiv:1811.0544
To parallelize or not to parallelize, bugs issue
Program correctness is one of the most difficult challenges in parallel
programming. Message Passing Interface MPI is widely used in writing parallel
applications. Since MPI is not a compiled language, the programmer will be
enfaced with several programming bugs.This paper presents the most common
programming bugs arise in MPI programs to help the programmer to compromise
between the advantage of parallelism and the extra effort needed to detect and
fix such bugs. An algebraic specification of an MPI-like programming language,
called Simple MPI (SMPI), to be used in writing MPI programs specification has
also been proposed. In addition, both nondeterminacy and deadlocks arise in
SMPI programs have been verified using Maud system
Efficient System-Enforced Deterministic Parallelism
Deterministic execution offers many benefits for debugging, fault tolerance,
and security. Running parallel programs deterministically is usually difficult
and costly, however - especially if we desire system-enforced determinism,
ensuring precise repeatability of arbitrarily buggy or malicious software.
Determinator is a novel operating system that enforces determinism on both
multithreaded and multi-process computations. Determinator's kernel provides
only single-threaded, "shared-nothing" address spaces interacting via
deterministic synchronization. An untrusted user-level runtime uses distributed
computing techniques to emulate familiar abstractions such as Unix processes,
file systems, and shared memory multithreading. The system runs parallel
applications deterministically both on multicore PCs and across nodes in a
cluster. Coarse-grained parallel benchmarks perform and scale comparably to -
sometimes better than - conventional systems, though determinism is costly for
fine-grained parallel applications.Comment: 14 pages, 12 figures, 3 table
Inspector: A Data Provenance Library for Multithreaded Programs
Data provenance strives for explaining how the computation was performed by
recording a trace of the execution. The provenance trace is useful across a
wide-range of workflows to improve the dependability, security, and efficiency
of software systems. In this paper, we present Inspector, a POSIX-compliant
data provenance library for shared-memory multithreaded programs. The Inspector
library is completely transparent and easy to use: it can be used as a
replacement for the pthreads library by a simple exchange of libraries linked,
without even recompiling the application code. To achieve this result, we
present a parallel provenance algorithm that records control, data, and
schedule dependencies using a Concurrent Provenance Graph (CPG). We implemented
our algorithm to operate at the compiled binary code level by leveraging a
combination of OS-specific mechanisms, and recently released Intel PT ISA
extensions as part of the Broadwell micro-architecture. Our evaluation on a
multicore platform using applications from multithreaded benchmarks suites
(PARSEC and Phoenix) shows reasonable provenance overheads for a majority of
applications. Lastly, we briefly describe three case-studies where the generic
interface exported by Inspector is being used to improve the dependability,
security, and efficiency of systems. The Inspector library is publicly
available for further use in a wide range of other provenance workflows.Comment: 13 page
McFly: Time-Travel Debugging for the Web
Time-traveling debuggers offer the promise of simplifying debugging by
letting developers freely step forwards and backwards through a program's
execution. However, web applications present multiple challenges that make
time-travel debugging especially difficult. A time-traveling debugger for web
applications must accurately reproduce all network interactions, asynchronous
events, and visual states observed during the original execution, both while
stepping forwards and backwards. This must all be done in the context of a
complex and highly multithreaded browser runtime. At the same time, to be
practical, a time-traveling debugger must maintain interactive speeds.
This paper presents McFly, the first time-traveling debugger for web
applications. McFly departs from previous approaches by operating on a
high-level representation of the browser's internal state. This approach lets
McFly provide accurate time-travel debugging - maintaining JavaScript and
visual state in sync at all times - at interactive speeds. McFly's architecture
is browser-agnostic, building on web standards supported by all major browsers.
We have implemented McFly as an extension to the Microsoft Edge web browser,
and core parts of McFly have been integrated into a time-traveling debugger
product from Microsoft
Spectrum-based Software Fault Localization: A Survey of Techniques, Advances, and Challenges
Despite being one of the most basic tasks in software development, debugging
is still performed in a mostly manual way, leading to high cost and low
performance. To address this problem, researchers have studied promising
approaches, such as Spectrum-based Fault Localization (SFL) techniques, which
pinpoint program elements more likely to contain faults. This survey discusses
the state-of-the-art of SFL, including the different techniques that have been
proposed, the type and number of faults they address, the types of spectra they
use, the programs they utilize in their validation, the testing data that
support them, and their use at industrial settings. Notwithstanding the
advances, there are still challenges for the industry to adopt these
techniques, which we analyze in this paper. SFL techniques should propose new
ways to generate reduced sets of suspicious entities, combine different spectra
to fine-tune the fault localization ability, use strategies to collect
fine-grained coverage levels from suspicious coarser levels for balancing
execution costs and output precision, and propose new techniques to cope with
multiple-fault programs. Moreover, additional user studies are needed to
understand better how SFL techniques can be used in practice. We conclude by
presenting a concept map about topics and challenges for future research in
SFL.Comment: Submitted to Software Testing, Verification and Reliabilit
On Failure Diagnosis of the Storage Stack
Diagnosing storage system failures is challenging even for professionals. One
example is the "When Solid State Drives Are Not That Solid" incident occurred
at Algolia data center, where Samsung SSDs were mistakenly blamed for failures
caused by a Linux kernel bug. With the system complexity keeps increasing, such
obscure failures will likely occur more often. As one step to address the
challenge, we present our on-going efforts called X-Ray. Different from
traditional methods that focus on either the software or the hardware, X-Ray
leverages virtualization to collects events across layers, and correlates them
to generate a correlation tree. Moreover, by applying simple rules, X-Ray can
highlight critical nodes automatically. Preliminary results based on 5 failure
cases shows that X-Ray can effectively narrow down the search space for
failures
Scientific Software Engineering in a Nutshell
Writing complex computer programs to study scientific problems requires
careful planning and an in-depth knowledge of programming languages and tools.
In this chapter the importance of using the right tool for the right problem is
emphasized. Common tools to organize computer programs, as well as to debug and
improve them are discussed, followed by simple data reduction strategies and
visualization tools. Furthermore, some useful scientific libraries such as
boost, GSL, LEDA and numerical recipes are outlined.Comment: lecture at the second international summer school "Modern Computation
Science", 9 - 20 August 2010, Oldenburg (Germany), see
http://www.mcs.uni-oldenburg.d
SONATA: Service Programming and Orchestration for Virtualized Software Networks
In conventional large-scale networks, creation and management of network
services are costly and complex tasks that often consume a lot of resources,
including time and manpower. Network softwarization and network function
virtualization have been introduced to tackle these problems. They replace the
hardware-based network service components and network control mechanisms with
software components running on general-purpose hardware, aiming at decreasing
costs and complexity of implementing new services, maintaining the implemented
services, and managing available resources in service provisioning platforms
and underlying infrastructures. To experience the full potential of these
approaches, innovative development support tools and service provisioning
environments are needed. To answer these needs, we introduce the SONATA
architecture, a service programming, orchestration, and management framework.
We present a development toolchain for virtualized network services, fully
integrated with a service platform and orchestration system. We motivate the
modular and flexible architecture of our system and discuss its main components
and features, such as function- and service-specific managers that allow fine-
grained service management, slicing support to facilitate multi-tenancy,
recursiveness for improved scalability, and full-featured DevOps support
- …