Distributed Data and Programs Slicing

This paper presents a new technique for data slicing of distributed programs running on a hierarchy of machines. Data slicing can be realized as a program transformation that partitions heaps of machines in a hierarchy into independent regions. Inside each region of each machine, pointers preserve the original pointer structures in the original heap hierarchy. Each heap component of the base type (e.g., the integer type) goes only to a region of one of the heaps. The proposed technique has the shape of a system of inference rules. In addition, this paper presents a simply structure type system to decide type soundness of distributed programs. Using this type system, a mathematical proof that the proposed slicing technique preserves typing properties is outlined in this paper as well.

💡 Research Summary

The paper introduces a novel data‑slicing technique designed for distributed programs that run on a hierarchy of machines. The core idea is to transform the global heap into a collection of independent “regions,” each residing on a specific machine. Within a region, all pointers preserve the exact structure they had in the original heap, and any pointer that would cross region boundaries is replaced by an explicit copy or move operation inserted by the transformation. Basic‑type values such as integers or floating‑point numbers are confined to a single region, eliminating redundant replicas and simplifying consistency management.

To formalize the transformation, the authors present a system of inference rules. These rules take program constructs (variable declarations, assignments, function calls, etc.) and the current heap configuration as input, and they output a mapping that assigns every object and pointer to a concrete region. The rule set is divided into four categories: (1) variable declaration and initialization, (2) dynamic allocation, (3) inter‑machine function invocation, and (4) region‑local garbage collection. The rules guarantee that after slicing, each region can be treated as an isolated heap while the overall program semantics remain unchanged.

A simple structural type system is defined to reason about type safety across slices. Types are annotated with a region identifier, e.g., int@M1, indicating that the value lives in the heap of machine M1. The typing rules enforce that operations only combine values whose region annotations are compatible; otherwise a static type error is reported. This annotation mechanism makes the type system aware of the distribution of data and enables static verification that the slicing transformation does not introduce type mismatches.

The authors prove type preservation for the slicing transformation. The proof proceeds by induction on the inference rules. First, they show that each rule, when applied, maintains the original pointer relationships and region annotations. Second, they demonstrate that the transformed program satisfies the same typing judgments as the original program, thereby establishing that the transformation is type‑sound. Consequently, any program that type‑checks before slicing will also type‑check after slicing, guaranteeing that no new runtime type errors are introduced.

Implementation considerations are discussed briefly. The slicing pass can be integrated into a compiler front‑end, generating a region‑mapping table as metadata. At runtime, this table guides memory accesses and copy‑on‑call operations with negligible overhead. Because each region behaves like an ordinary heap, existing garbage collectors can be reused without modification. The paper does not present empirical performance data, but the authors argue that locality of reference improves cache behavior and that network traffic is reduced because data is transferred only when explicitly required by a cross‑region call.

In summary, the work provides a rigorous, rule‑based framework for partitioning distributed heaps while preserving both program semantics and static type guarantees. It lays a theoretical foundation for future systems that aim to combine fine‑grained memory distribution with strong compile‑time safety, and it opens avenues for practical compiler implementations, performance evaluations, and extensions to richer type systems such as polymorphism or dependent types.