| Glass is a new library for distributed computing.
It’s a flexible solution, in which all functionality
is provided by plug-ins. It was designed from scratch
to be a simple, efficient solution for real time
distributed computing. This way games, scientific
and educational applications can run easily in a
graphic cluster using CAVEs, Panoramas and PowerWalls
to display the results.
Virtual Reality applications running in a graphic
cluster have specific requirements that include:
low delays, fast synchronization, high bandwidth,
etc. Not all available APIs for distributed computing
fit these requirements. And those that do are
usually too specific: they target multiprojection,
for instance, not giving much importance to the
underlying computational process — such
as physical simulation, real time computation
of geometry, etc. They usually provide good resources
for graphic rendering (such as scene graphs).
The available frameworks require rewriting the
existing code, since it has to be adapted to the
new programming paradigm. Legacy code may take
a good amount of time and effort to port, and
the result is often unsatisfactory. Glass was
designed to fulfill this gap, being based on the
following principle
· Portability and interoperability:
distributed computing is everyday more heterogeneous.
The library can not only run in different architectures
(Personal Computers, PDAs) and operating systems
(Linux, Irix, Windows), but interoperate among
them.
· Extensibility and flexibility: Glass
is easy to extend, not requiring API changes
or even recompilation. This way it can be kept
up-to-date with the latest technologies and
be able to solve specific needs of users.
· Easy to use, fast learning curve:
distributed computing APIs tend to be complicated,
requiring a lot of time to understand and master.
Most libraries provide a huge number of functions,
many of them with a high number of arguments.
They are hard to learn and remember. Frameworks
require a new approach to the programming, and
therefore have a steep learning curve. Glass
aims to be easy to use, being almost transparent
to the user: that’s where its name comes
from.
· High performance: if an application
requires distributed computing, it’s because
it has a high computational cost.
· Network protocol independency: an
abstraction of the underlying network protocol
makes Glass protocol independent. You can use
TCP, UDP, or even more high-level systems such
as MPI easily. Just instantiate the proper network
class. This is very important in a world where
applications have hugely different network requirements.
· Reliability and fault tolerance:
any distributed computing library must be reliable
and fault tolerant. It’s unacceptable
that failure of a single node crashes the entire
computational system. Glass provides fault tolerance
automatically.
· Thread safety: many APIs are note
thread safe. This forces the user to find workarounds
or use other solutions instead place of threads.
Glass works in thread applications seamlessly.
Glass is completely written in C++. The choice
was due to its wide number of compilers and spread
use, good performance, and certain features that
would make programmer’s life easier (such
as OO and templates). C++ is easy to interface
with C, Java and other languages.
A core provides all internal functionality,
such as the network system, plug-in management,
node management, etc. The developer is completely
oblivious to this core |
