The CIAO Multi-Dialect Compiler and System: An Experimentation Workbench for Future (C)LP Systems

CIAO is an advanced programming environment supporting Logic and Constraint programming. It offers a simple concurrent kernel on top of which declarative and non-declarative extensions are added via librarles. Librarles are available for supporting the ISOProlog standard, several constraint domains, functional and higher order programming, concurrent and distributed programming, internet programming, and others. The source language allows declaring properties of predicates via assertions, including types and modes. Such properties are checked at compile-time or at run-time. The compiler and system architecture are designed to natively support modular global analysis, with the two objectives of proving properties in assertions and performing program optimizations, including transparently exploiting parallelism in programs. The purpose of this paper is to report on recent progress made in the context of the CIAO system, with special emphasis on the capabilities of the compiler, the techniques used for supporting such capabilities, and the results in the áreas of program analysis and transformation already obtained with the system

Statechart Slicing

The paper discusses how to reduce a statechart model by slicing. We start with the discussion of control dependencies and data dependencies in statecharts. The and-or dependence graph is introduced to represent control and data dependencies for statecharts. We show how to slice statecharts by using this dependence graph. Our slicing approach helps systems analysts and system designers in understanding system specifications, maintaining software systems, and reusing parts of systems models

Safe Concurrency Introduction through Slicing

Traditional refactoring is about modifying the structure of existing code without changing its behaviour, but with the aim of making code easier to understand, modify, or reuse. In this paper, we introduce three novel refactorings for retrofitting concurrency to Erlang applications, and demonstrate how the use of program slicing makes the automation of these refactorings possible

Distributed memory compiler methods for irregular problems: Data copy reuse and runtime partitioning

Outlined here are two methods which we believe will play an important role in any distributed memory compiler able to handle sparse and unstructured problems. We describe how to link runtime partitioners to distributed memory compilers. In our scheme, programmers can implicitly specify how data and loop iterations are to be distributed between processors. This insulates users from having to deal explicitly with potentially complex algorithms that carry out work and data partitioning. We also describe a viable mechanism for tracking and reusing copies of off-processor data. In many programs, several loops access the same off-processor memory locations. As long as it can be verified that the values assigned to off-processor memory locations remain unmodified, we show that we can effectively reuse stored off-processor data. We present experimental data from a 3-D unstructured Euler solver run on iPSC/860 to demonstrate the usefulness of our methods

Ticket to Work and Self-Sufficiency Program: Overview and Current Issues

[Excerpt] Title I of the Ticket to Work and Work Incentives Improvement Act of 1999 (P.L. 106-170) established the Ticket to Work and Self-Sufficiency program (hereafter referred to as the Ticket to Work or Ticket program), which is administered by the Social Security Administration (SSA). The purpose of this program is to enhance work incentives for Social Security Disability Insurance (SSDI) and Supplemental Security Income (SSI) beneficiaries. The legislation created a “ticket” system to expand choices in the numbers and types of providers that SSDI and SSI beneficiaries may choose to assist them in receiving employment services. The legislation also expanded Medicare and Medicaid coverage for individuals with a disability who are working or could work. Most notably, the Ticket to Work program created a market for public and private providers of support services known as employment networks (ENs) to which Social Security disability beneficiaries can voluntarily assign their tickets in exchange for a range of employment support services. The goal of the Ticket program is to reduce dependence on disability benefits and help Social Security disability beneficiaries enter or reenter the workforce. ENs would then be eligible to receive payments from SSA based on ticket holders achieving employment “milestones” or outcomes. This report provides an overview of how the Ticket to Work program operates and addresses several issues related to the Ticket program. First, it provides a brief background on the SSDI and SSI programs and a legislative history on how the Ticket program evolved. Second, this report provides an in-depth explanation on the various components and regulations of the Ticket to Work program in its current form and prior to major regulatory changes in July 2008. Third, it examines other work incentive programs created by Ticket to Work legislation and concludes with a discussion on the issues surrounding implementation of the Ticket program

Multi-level Visualization of Concurrent and Distributed Computation in Erlang

This paper describes a prototype visualization system for concurrent and distributed applications programmed using Erlang, providing two levels of granularity of view. Both visualizations are animated to show the dynamics of aspects of the computation. At the low level, we show the concurrent behaviour of the Erlang schedulers on a single instance of the Erlang virtual machine, which we call an Erlang node. Typically there will be one scheduler per core on a multicore system. Each scheduler maintains a run queue of processes to execute, and we visualize the migration of Erlang concurrent processes from one run queue to another as work is redistributed to fully exploit the hardware. The schedulers are shown as a graph with a circular layout. Next to each scheduler we draw a variable length bar indicating the current size of the run queue for the scheduler. At the high level, we visualize the distributed aspects of the system, showing interactions between Erlang nodes as a dynamic graph drawn with a force model. Speci?cally we show message passing between nodes as edges and lay out nodes according to their current connections. In addition, we also show the grouping of nodes into “s_groups” using an Euler diagram drawn with circles