Overview

What is Spacebase?

SpaceBase is a server-side, in-memory, high-performance, concurrent and distributed spatial data-store. It stores 2D and 3D spatial objects and lets you update and query them at very high rates.

SpaceBase also supports atomic multi-object transactions, and, most importantly, can be used as a basis for parallelizing your entire application.

SpaceBase is implemented in Java, and provides Java and C++ APIs.

Why Spacebase?

Modern software systems are growing more complex and are required to process more data than before, but CPUs are not getting any faster. Modern software is required to handle multiple CPU-cores and multiple machines in order to scale. New applications are making use of modern middleware that enables them to scale in order to meet requirements.

While many middleware offerings exist that target the scaling challenge for common data-processing applications, SpaceBase helps scale applications that process spatial data, like online worlds, simulations, defense systems and location-based services. These types of applications have their own set of requirements, and SpaceBase is designed especially for them.

Developers of such applications have traditionally used homegrown solutions for spatial indexing, but with scaling needs come challenges such as concurrency and distribution that make the spatial index exceptionally complex. This is where SpaceBase, as a middleware solution comes to the rescue.

Is SpaceBase For You?

SpaceBase was specifically designed for real-time or near real-time applications (requiring low latency), modifying many spatial objects at a high rate (a high write-ratio). SpaceBase is an excellent fit for interactive systems, where updates are done on many threads and/or servers, in response to concurrent network requests.

SpaceBase is especially suited for:

MMO games and online worlds. Spatial queries can be used for streaming and culling for each user. SpaceBase’s join-queries are great for broad-phase collision-detection.
Military simulation and C4I systems.
Highly dynamic location-based services, i.e. those that track many moving objects. If your LBS only occasionally queries mostly static-objects, to inform users of nearby restaurants for example, there might be other solutions that are a better fit for your needs. SpaceBase does not particularly excel at storing a high-volume of static objects.

SpaceBase Features

Stores 2D and 3D spatial objects with or without extents

(i.e. either geometric points or objects with an area or volume).

Fast insert,update and delete operations

Fast pre-built and user-made spatial queries

Pre-built queries include range queries (return all objects contained in a given region of space) and intersection queries (return all object intersecting a given region of space.

Fast join-queries

Join queries return pairs of objects that satisfy a certain condition. For example, return all pairs of objects that intersect one another, or return all pairs of objects that are within a given distance from one another.

Spatial processing parallelization

Transactions executing on groups of objects at close proximity are executed atomically, while transactions operating on different object-groups that are spatially separated are parallelized with virtually zero interference with one another. All of the application-logic handling spatial objects can be run through SpaceBase and thus parallelized by it.

Load balancing

SpaceBase can distributes its objects among different servers for efficient load-balancing. Objects that are in relative close spatial proximity will usually be kept on the same server, but SpaceBase distributes the objects in such a way that each server would hold a similar number of objects. That is, a small region of space with a very high-density of objects would be distributed across several servers, while a large region with few objects would be kept on a single server, thus ensuring a reasonable work-sharing among servers.

In-depth performance monitoring via JMX

How SpaceBase Works

R-tree data structure

SpaceBase uses a special variant of the R-Tree, a well known spatial data-structure, as an index allowing fast, concurrent spatial queries.

While spatial data-structures are generally not as fast as their one-dimensional counterparts (like the B-Tree), spatial data usually has a unique characteristic which allows for its high level of concurrency: while bank accounts participating in a financial transactions usually have no common feature – any two random accounts can participate in a transaction – spatial objects usually model real-world things, and those tend to affect one another only when close. When objects affect each other (and so their behavior needs to be modeled as an atomic transaction), they are often in close proximity, while far-away objects do not, usually, interact, and so, the processes modeling them can be carried out in parallel.

SpaceBase takes advantage of this characteristic of spatial data to allow many concurrent transactions, each operating on a group of close-proximity objects.