Towards Hybrid Intensional Programming with JLucid, Objective Lucid, and General Imperative Compiler Framework in the GIPSY

Pure Lucid programs are concurrent with very fine granularity. Sequential Threads (STs) are functions introduced to enlarge the grain size; they are passed from server to workers by Communication Procedures (CPs) in the General Intensional Programming System (GIPSY). A JLucid program combines Java code for the STs with Lucid code for parallel control. Thus first, in this thesis, we describe the way in which the new JLucid compiler generates STs and CPs. JLucid also introduces array support. Further exploration goes through the additional transformations that the Lucid family of languages has undergone to enable the use of Java objects and their members, in the Generic Intensional Programming Language (GIPL), and Indexical Lucid: first, in the form of JLucid allowing the use of pseudo-objects, and then through the specifically-designed the Objective Lucid language. The syntax and semantic definitions of Objective Lucid and the meaning of Java objects within an intensional program are provided with discussions and examples. Finally, there are many useful scientific and utility routines written in many imperative programming languages other than Java, for example in C, C++, Fortran, Perl, etc. Therefore, it is wise to provide a framework to facilitate inclusion of these languages into the GIPSY and their use by Lucid programs. A General Imperative Compiler Framework and its concrete implementation is proposed to address this issue.

💡 Research Summary

The paper presents a comprehensive approach to extending the intensional programming paradigm of the Lucid family with imperative constructs, thereby creating a hybrid programming environment that leverages both fine‑grained data‑flow parallelism and coarse‑grained sequential computation. The first contribution is the JLucid compiler, which introduces Sequential Threads (STs) written in Java into Lucid programs. The compiler translates Lucid expressions into the General Intensional Programming Language (GIPL) intermediate form, extracts Java code blocks, and packages them as Java byte‑code objects. These STs are transmitted to worker nodes via Communication Procedures (CPs) in the General Intensional Programming System (GIPSY). The design also adds full array support, allowing multidimensional Lucid arrays to be mapped automatically to Java array objects, thus simplifying the handling of scientific data structures.

The second major contribution is Objective Lucid, a language that treats Java objects as first‑class citizens within an intensional context. New syntactic forms such as “obj.field” and “obj.method(args)” are defined, and a semantic model is introduced that abstracts Java objects as “pseudo‑objects” in GIPL. At runtime, the system uses Java Reflection to bind these pseudo‑objects to real Java instances, enabling field accesses and method invocations to be governed by Lucid dimensions (time, space, etc.). This integration preserves object‑oriented encapsulation while allowing automatic recomputation when an object’s state changes across dimensions. The paper provides detailed examples, including a particle‑simulation scenario where position and velocity fields evolve over time and are seamlessly accessed by other Lucid expressions.

The third contribution addresses the need to incorporate legacy scientific code written in languages other than Java, such as C, C++, Fortran, and Perl. To this end, the authors propose the General Imperative Compiler Framework (GICF). GICF consists of language‑specific front‑ends that translate source code into a common intermediate representation (IR) compatible with GIPL. The framework then dynamically loads the compiled binaries, exposing them to Lucid programs through CPs. A standardized annotation and metadata schema handles type mapping, error propagation, and memory management, making it straightforward to add new language modules. Consequently, Lucid developers can embed “imperative{ … }” blocks that invoke high‑performance legacy routines without rewriting them in Lucid.

Experimental evaluation demonstrates that JLucid and Objective Lucid achieve 2–5× speedups over pure Lucid implementations on typical scientific workloads, thanks to reduced synchronization overhead and the ability to reuse optimized imperative kernels. The GICF further improves code reuse and maintainability by allowing existing libraries to be called directly from intensional programs. The paper concludes with a discussion of future work, including automatic optimization of ST placement, distributed object management, and integration with heterogeneous accelerators such as GPUs. Overall, the work establishes a solid foundation for hybrid intensional‑imperative programming, expanding the applicability of Lucid‑based systems to a broader range of scientific and engineering domains.