Terminology


Basic Components

Space

term_space.gif

The GigaSpaces cache instance that holds data objects in memory.

Execute, Read, Write, Take and Notify

term_verbs.jpg

A set of methods used to read, write, take, and register for notification on objects that are stored in the space. Execute allows sending Tasks to be executed within the space. Read and Take criteria can be specified via a query or a template (an example object).

Service Bean

term_service_bean.gif

An application component that interacts with the space (using the read, write, take and notify operations), and implements a certain functionality.

Processing Unit

term_empty_pu.gif

A combination of service beans and/or an embedded space instance. This is the fundamental unit of deployment in GigaSpaces XAP. The Processing Unit itself runs within a Processing Unit Container, and is typically deployed onto the Service Grid. Once a Processing Unit is deployed, a Processing Unit instance is the actual runtime entity.

Processing Unit configured with an embedded space

term_pu_with_space.gif

A deployable package which instantiates an embedded space instance, also called a data grid instance. A set of embedded space instances that run within the processing units typically form a Data Grid.

Processing Unit configured with one or more services

term_pu_with_bean.gif

A deployable package containing one or more services. In the GigaSpaces context, it usually acts as a client that interacts with other Processing Units by utilizing the messaging capabilities of the space.

Processing Unit configured with embedded space and embedded services

term_pu_with_space_and_bean.gif

A deployable, independent, scalable unit, which is the building block of Space-Based Architecture. Client application (which can also be other processing units) write objects to the space, and the processing unit which contains this space consumes these objects or is notified about them and triggers a related services.

Data Grid

In Memory Data Grid - IMDG, or Enterprise Data Grid - EDG

term_populated_data_grid.gif

A set of space instances, typically running within their respective processing unit instances. The space instances are connected to each other to form a space cluster. The relations between the spaces define the Data Grid Topology.

Data Grid Topologies

Primary Backup Data Grid

term_primary_backup_text_data_grid.gif

A Data Grid with a primary instance and one or more backup instances. Destructive operations (write, update and take) are applied to the primary instance, and are replicated to the backup instance either synchronously or asynchronously.

Partitioned Data Grid

term_partitioned_data_grid.gif

Each Data Grid instance (partition) holds a different subset of the objects in the Data Grid. When the objects are written to this Data Grid, they are routed to the proper partition, according to a predefined attribute in the object that acts as the routing index.

Routing

term_routing.gif

The mechanism that is in charge of routing the objects into and out of the corresponding partitions. The routing is based on a designated attribute inside the objects that are written to the space, and is termed Routing Index.

Primary Backup Partitioned Data Grid

term_partitioned_primary_backup_data_grid.gif

A partitioned Data Grid, with one or more backup instances for each partition. Each of the Data Grid instances (partitions) holds a different subset of the objects in the Data Grid, and replicates this subset to its backup instance/s.

See also:

For details about scaling a running space cluster in runtime, refer to the Elastic Processing Unit section.

Runtime Components

Processing Unit Container

term_puc.gif

A container that hosts a Processing Unit. The Processing Unit can run only inside a hosting Processing Unit Container.

Types of Processing Unit Containers

Integrated Processing Unit Container

term_ipuc.gif

A container that runs the Processing Unit inside an IDE (e.g. IntelliJ IDEA, Eclipse).

Service Grid Processing Unit Container (SLA Driven Container)

term_gscnet.gif

A Processing Unit Container which runs within a Grid Service Container. It enables running the processing unit within a service grid, which provides self-healing and SLA capabilities to components deployed on it.

Service Grid

term_empty_service_grid.gif

A set of GigaSpaces Containers (GSC) managed by a GigaSpaces Manager. The containers host various deployments of Processing Units and Data Grids. Each container can be run on a separate physical machine.

GigaSpaces Container (GSC)

term_gsc.jpg

A Service Grid component which hosts Processing Unit instances. A machine can run one or more GSC processes. Each GSC communicates with a manager component GSM. The GSC receives requests to start/stop a processing unit instance, and sends information about the machine which runs it (OS, processor architecture, current memory and CPU stats), the software installed on it and the status of processing unit instances currently running on it.

GigaSpaces Manager (GSM)

term_gsm.gif

The GSM is a Service Grid component which manages a set of GigaSpaces Containers (GSC). A GSM has an API for deploying/un deploying processing units. When a GSM is instructed to deploy a Processing Unit, it finds an appropriate, available GSC and tells that GSC to run an instance of that processing unit. It then continuously monitors that processing unit instance to verify that it’s alive, and that the SLA is not breached.

Management Component

term_management_ui.gif

The GigaSpaces Management Center, also known as the GigaSpaces UI or GS-UI. A monitoring, management and deployment console. Enables the user to view and interact with the runtime components running in the network.