Global Positioning System Reference
In-Depth Information
to a common disk space, but maintain their private main memory space.
Finally, in a shared-nothing architecture CPUs do not share any memory or
disk, and communicate with each other via a network connection.
The shared-nothing architecture is widely regarded as the most scalable
approach providing linear speed-up and scale-up to the number of CPUs
and disks in proportion to data volume. Shared-memory and shared-disk
systems are in general limited because of interference, i.e., performance
improvement slows down as more and more CPUs are added due to
memory and network contention. SciDB, for example, has adopted a shared-
nothing architecture from the start (Brown 2010). A SciDB instance can be
deployed on a network of computers, each with its own disk, which are
logically unifi ed through a central system catalog. The rasdaman system,
on the other hand, supports shared-nothing, and additionally a variant
of shared-disk to accommodate existing massive archive infrastructures;
currently, this is being evaluated by data centers like NASA and ESA.
Parallelization techniques include inter-query and intra-query
parallelization. Inter-query parallelization dispatches incoming queries in
completeness, thereby achieving good load balancing in particular when
many smaller queries come in. Intra-query parallelization splits incoming
queries and executes them in parallel on different nodes; obviously, this
needs to take query “objects” into consideration when large, complex
queries arrive. Therefore, intra-query parallelization is further subdivided
into intra- and inter-object parallelization. An “object” in this case is an array,
as opposed to single tuples in conventional databases. This calls for different
methods as the size of an array is typically orders of magnitude greater.
Intra-array parallelism splits and distributes array data as fi ner granules
based on the physical model of the data. As arrays get partitioned for storage
anyway, this partitioning may serve as a unit of distribution as well. This is
individually tailored for each array operation, and the query tree is further
adapted in such a way that data transfer within the tree as well as between
processes is minimized. Inter-array parallelism distributes a single query
to a set of peers holding their own data. This provides signifi cant speedup
especially for very complex and expensive, long-running queries.
Rasdaman implements both intra-query (Hahn et al. 2002) and inter-
query (Hahn et al. 2002) parallelism—hence, a shared-nothing architecture
is one of the paradigms that can be employed. Rasdaman can further
utilize just-in-time (JIT) compilation of queries into machine code which is
dynamically linked into the server and executed by the CPU as well as the
GPU (Baumann et al. 2009). While multi-threaded JIT code already incurs
advantages by utilizing the available cores, this improves even more in
presence of GPUs which are particularly optimized for image processing
operations as they provide hundreds of cores with built-in scheduling,
making them very cost-effi cient for exploiting hardware parallelism. In fact,
Search WWH ::




Custom Search