A model for parallel programming over CORBA

D. Janaki Ram, A. Vijay Srinivas, P. Manjula RaniJ. Parallel Distributed Comput 2004 · DOI

TL;DR

This paper introduces P-CORBA, a novel model for parallel programming over CORBA that specifically addresses the challenges of Network of Workstations (NOWs), such as dynamic load fluctuations and node availability. P-CORBA brings concurrency to CORBA, enables efficient load balancing through object migration, and offers a more unified approach to handling objects compared to previous CORBA-based parallel programming models.

What Problem Does This Paper Address?

Parallel programming on Network of Workstations (NOWs) is inherently difficult due to factors like fluctuating node loads, dynamic node availability, heterogeneous architectures, and varying network speeds. While CORBA is a standard for distributed object computing, it's not inherently suited for parallel programming because it lacks built-in concurrency and services to manage NOW complexities. Existing CORBA-based parallel programming models often struggle with these issues, either by requiring developers to manage object distribution or by handling multiple object types, leading to middleware complexity. This paper aims to bridge this gap by proposing a CORBA-centric model that tackles these NOW-specific challenges.

Methods

The core of P-CORBA lies in its innovative approach to concurrency and system support:

  • Meta-object and Subcontract Mechanism: P-CORBA introduces a "meta-object" which acts as an aggregator for objects of the same class. Developers interact with this meta-object, invoking a "subcontract" operation. This mechanism allows a method to be invoked concurrently on all objects aggregated within the meta-object, effectively achieving parallel execution at the method level.
  • Translator: A crucial component is the translator, which bridges the gap between the application developer's view and the CORBA infrastructure. It converts the developer's program, including meta-objects, into CORBA objects and client calls. This ensures CORBA uniformly handles objects and abstracts away CORBA details from the application developer.
  • Kernel and Load Balancing: A distributed kernel resides on each node, monitoring local load conditions. It interacts with other kernel entities to identify the least loaded machines. P-CORBA employs an adaptive load-balancing strategy that combines sender-initiated and receiver-initiated approaches, dynamically migrating objects to available nodes to ensure optimal resource utilization.
  • Object Migration: P-CORBA addresses the challenge of object migration in CORBA by using message filters as location brokers. When an object migrates, its filter is updated with the new location. This filter transparently redirects client requests, and a "Rebind" exception mechanism allows clients to directly connect to the new location, improving efficiency over other approaches.

Datasets

Not discussed in the paper. The paper focuses on performance studies using implemented prototypes for specific computational problems.

Key Insights and Ideas

  • Concurrency in CORBA: The paper demonstrates that CORBA can be extended to support parallel programming by introducing a novel concurrency model based on meta-objects and subcontracts, rather than relying solely on existing CORBA features.
  • Unified Object Handling: By translating meta-objects into CORBA objects and the application developer's program into CORBA client calls, P-CORBA simplifies the middleware by ensuring CORBA uniformly handles only one kind of object.
  • Adaptive Load Balancing for NOWs: The adaptive load-balancing strategy, combining sender and receiver initiation, is shown to be effective in handling dynamic load fluctuations inherent in NOW environments, outperforming static approaches.
  • Filter as Location Broker for Migration: The use of filters as location brokers for object migration offers an efficient mechanism to handle object movement in CORBA, overcoming limitations of traditional CORBA implementations.
  • CORBA's Adaptability: The paper highlights CORBA's inherent adaptability, suggesting that with extensions like load balancing and object migration services, it can become a powerful platform for parallel computing, even though it wasn't its primary design goal.

Key Results

The paper presents performance studies comparing P-CORBA with MPI on two case studies: Genetic Clustering Algorithm (GCA) for the Traveling Salesman Problem (TSP) and an iterative grid computation problem.

  • Overheads: CORBA generally exhibits higher overheads than MPI for simple method calls and message sends, especially on slower networks. However, on a 100 Mbps network, the gap narrows significantly.
  • Load Balancing Performance: P-CORBA significantly outperforms MPI under average and heavy load conditions. While MPI performs similarly to P-CORBA under light loads, it struggles with dynamic load fluctuations, leading to poorer performance. P-CORBA's ability to dynamically migrate tasks to less loaded machines provides better adaptability and increased speedup.
  • Speedup: For the iterative grid computation problem, P-CORBA achieved linear speedup up to six machines and super-linear speedups for problem sizes beyond a certain point, even on a loaded cluster. This demonstrates its effectiveness in handling coarse-grained parallel problems.
  • Service Overheads: The load-balancing and object migration services introduce overheads (200-300 ms for load balancing, 2-3 s for object migration), but these are offset by the gains in performance due to effective load management.

Limitations and Future Work

  • CORBA Overheads: The paper acknowledges that CORBA's inherent overheads are higher than those of MPI. While efforts are being made to reduce these (e.g., real-time CORBA specifications), they remain a factor.
  • Service Implementation: The authors note that some CORBA vendors do not fully implement services like Concurrency, requiring custom implementations.
  • AMI Support: The Asynchronous Method Invocation (AMI) specification, which could further enhance client-side concurrency, is noted as being recently drafted, with limited ORB support.
  • Future Work:
    • Exploring the possibility of wide-area parallel computing over real-time CORBA.
  • Investigating the integration of DCOM for Windows clusters and CORBA for heterogeneous clusters.
  • Exploring the integration of eXtensible Markup Language (XML) with CORBA for data distribution.
  • Further research into reducing message sending overheads in CORBA.

Summary updated

BibTeX
@article{ram2004model,
  author = {D. Janaki Ram and A. Vijay Srinivas and P. Manjula Rani},
  title = {{A model for parallel programming over CORBA}},
  journal = {J. Parallel Distributed Comput.},
  year = {2004},
  doi = {10.1016/j.jpdc.2004.06.002},
}
Figure