Misplaced Pages

GigaSpaces

Article snapshot taken from Wikipedia with creative commons attribution-sharealike license. Give it a read and then ask your questions in the chat. We can research this topic together.

This is an old revision of this page, as edited by Shar1R (talk | contribs) at 07:28, 30 August 2012 (Added citations, removed internal link references, improved neutrality and style). The present address (URL) is a permanent link to this revision, which may differ significantly from the current revision.

Revision as of 07:28, 30 August 2012 by Shar1R (talk | contribs) (Added citations, removed internal link references, improved neutrality and style)(diff) ← Previous revision | Latest revision (diff) | Newer revision → (diff)
This article, GigaSpaces, has recently been created via the Articles for creation process. Please check to see if the reviewer has accidentally left this template after accepting the draft and take appropriate action as necessary.
Reviewer tools: Inform author
This article, GigaSpaces, has recently been created via the Articles for creation process. Please check to see if the reviewer has accidentally left this template after accepting the draft and take appropriate action as necessary.
Reviewer tools: Inform author
This article, GigaSpaces, has recently been created via the Articles for creation process. Please check to see if the reviewer has accidentally left this template after accepting the draft and take appropriate action as necessary.
Reviewer tools: Inform author



GigaSpaces Technologies
Developer(s)GigaSpaces Technologies, Inc.
Initial release2000
Stable releaseCloudify 2.1.1 & XAP 9.0
Preview releaseCloudify 2.2.0 M2 / August 6, 2012 (2012-08-06)
Written inJava
Operating systemCross-platform
Available inEnglish
TypeJava Platform
LicenseApache2 / Commercial
Websitehttp://www.gigaspaces.com/

GigaSpaces Technologies Inc., is a privately held Israeli middleware technology company, established in 2000, with its headquarters located in New York City, New York, with additional offices in Europe, and Asia.

GigaSpaces was founded in 2000 by Nati Shalom, the company's CTO, who is also a co-founder member of the Israeli Grid consortium, the Israeli non-profit organization focused on Grid, Virtualization, and Cloud technology.

GigaSpaces initially focused on the data scaling industry with its XAP products that provide distributed computing solutions for Extreme Transaction Processing, and in February 2012, it launched an additional open source PaaS product called Cloudify, a cloud computing technology.


Products & Technology

Until recently, GigaSpaces focused on application platforms for Java, and .Net environments based on the software architecture pattern “Space-based architecture", borrowing concepts from the Jini and JavaSpaces specifications, providing linear Scalability for stateful, high-performance applications using the Tuple space paradigm. This approach enables scalability while retaining data and logic consistency, latency, and the application code. This approach was developed to solve the scalability barriers present in tier-based applications.

GigaSpaces eXtreme Application Platform (XAP) is a practical implementation of Space-based architecture (SBA) that partitions applications into self-sufficient processing units. GigaSpaces XAP is a memory-based technology at its core, providing data storage and computation within the boundaries of a single process (i.e., co-location), without any inter-process communication or file-system access. The alternate approach of tier-based architecture integrates between application servers and relational databases.

The built-in data partitioning on top of grid deployment and management capabilities within a single clustering model is what enables linear scalability. In alternative tier-based architecture, the need to use a specific server implementation, such as a database, application server and messaging server, and integrate them into a single system, results in complexity and the inability to scale the entire system linearly. The fact that each server has a different scaling and high-availability (clustering) policy makes it difficult, and in many cases impossible, to support scaling beyond a certain size.

The Space capabilities are also at the core of GigaSpaces XAP. This combination, plus the addition of the basic APIs, allow synchronous and asynchronous applications to be built as the models for which first generation application servers apply. In addition, these models can be used in a wider range of applications, such as: real-time analytics, real-time batch processing, complex event-driven applications, caching scenarios, parallel processing and more.

GigaSpaces Cloudify is an open source PaaS stack that abstracts the application from the underlying infrastructure or IaaS through a recipe-based model to enable the deployment of any application onto any cloud without having to change the application’s code or architecture. The recipe provides the execution plans for installing, starting, orchestrating, and monitoring an application stack.

GigaSpaces has also been an active participant in other open source projects, such as the Compass Project.


Core Concepts in Space-based Architecture

A Space is a logical in-memory service, which can store entries of information. An entry is a domain object. In Java, an entry can be as simple as a Java POJO.

The space is accessed through a programmatic interface that supports the following main verbs:

  • Write – the semantics of writing a new entry of information into the space.
  • Read – read the contents of a stored entry into the client side.
  • Take – get the value from the space and delete its content.
  • Notify – alert when the contents of an entry of interest have registered changes.

The power of the space model is that the combination of the various basic APIs creates a very powerful set of interaction semantics:

  • Write + Read – this combination creates caching semantics. As entries are stored within the application, memory storing and retrieving of entries is done rapidly, making space technology perfect for caching solutions.
  • Write + Take – this combination is perfect for parallel processing paradigms. By having a single (or few) writer/s who write tasks into a shared space, and multiple consumers who take entries for execution from the shared location, it is very easy to create a parallel processing application. In fact, the Master/Worker pattern was invented originally in the context of Tuple Spaces, the origins behind JavaSpaces.
  • Write/Take + Notify – this is a messaging paradigm. Clients are informed of information changes asynchronously once these occur.


The GigaSpaces Application of Space-Based Architecture

The GigaSpace component is a POJO driven abstraction of the JavaSpaces specification. JavaSpaces is a service specification . It provides a distributed object exchange/coordination mechanism (which might or might not be persistent) for Java objects. It can be used to store the system state and implement distributed algorithms. In a space, all communication partners (peers) communicate by sharing states. It is an implementation of the Tuple spaces idea.

JavaSpaces is used when someone wants to achieve scalability and availability, while reducing the complexity of the overall system. Processes perform simple operations to write new objects into a space, take objects from a space, or read (make a copy of) objects from a space.

The goal behind the GigaSpace abstraction is to provide a simpler interface that fits into a POJO-driven architecture such as Spring through the following principles:

  • POJO Entries - the data model in JavaSpaces is an Entry. An Entry has to inherit from a specific interface (Entry). Attributes are public, non-transient Java objects. This model is quite different from the model that was written before the POJO model, and became common by JEE frameworks such as JPA and Hibernate, which are now based on POJOs. The POJO data model is basically a Java Bean representation with annotations that extend that model with specific meta-information such as indexes definition, persistency model, etc. The new GigaSpace model uses POJO-driven Entries; defines annotations for defining indexes, persistency model, replication semantics, etc.; and follows the same logic and semantics that are used today in the JEE world. This makes the integration of Space-Based Architecture with JEE a more natural fit. Note that Entries can still be used with the GigaSpace interface.
  • Declarative transactions - the JavaSpaces API uses explicit transaction semantics, in which transactions-handling is provided as an argument per method. While this model provides a finer level of granularity, it exposes more complexity to the developer. The transaction and locking semantics that are provided in the specification, support a limited set of transaction semantics. Spring uses a declarative transaction model, which is basically an implicit transaction. Users can use annotations or XML to define specific transaction/locking semantics.
  • Generics support - users can use generics to avoid unnecessary casting and make their interaction with the space more type-safe.
  • Overloaded methods - the GigaSpace interface uses overloaded methods, that can use defaults to reduce the amount of arguments passed in read/take/write methods.


Using the GigaSpaces Component in the Context of EDA/SOA Applications

The space serves several purposes in an EDA/SOA type of application:

  • Messaging Grid - in this case, the space is used as a distributed transport that enables remote and local services to send and receive objects based on their content. In a typical Space-Based Architecture, the space is used to route requests/orders from the data source to the processing unit, based on a predefined affinity-key. The affinity-key is used to route the request/order to the appropriate processing unit. Since it is optimized to run in-memory, it is used also as a means to enable the workflow between the embedded POJO services.
  • In Memory Data Grid (IMDG) - in this case, the space is used as a distributed object repository, that provides in-memory access to distributed data. Data can be distributed in various topologies - partitioned and replicated are the main ones. In a typical Space-Based Architecture, the space instances are collocated within each processing unit and therefore provide local access to distributed data required by POJO services running under that processing unit. The domain model is also POJO-driven. Data objects are basically Java Beans with annotations, (which add specific metadata required by the Data Grid to mark indexed fields), the affinity-key, and whether the object should be persisted or not, as can be seen in the code snippet below:


@SpaceClass
public class Data {
    @SpaceId
    public Long getId() {
        return this.id;
    }
    @SpaceRouting
    public Long getType() {
        return this.type;
    }
}


  • Processing Grid - a processing grid represents a particular and common use of the space for parallel transaction processing, using a master/worker pattern. In Space-Based architecture, the processing grid is implemented through a set of POJO services that serve as the workers and event containers, that trigger events from the space into and from these services. Requests/orders are processed in parallel between the different processing units, as well as within these processing units, in case there is a pool of services handling the event.

See Also

References

  1. "Nati Shalom's Contributions - IGT Website".
  2. Pezzini, Massimo (2004-03-04). "GigaSpaces Pitches Distributed Shared Memory at Businesses" (pdf). Gartner.
  3. Pezzini, Massimo (2007-06-19). "GigaSpaces Enters Race to Deliver XTP Platforms" (pdf). Gartner.
  4. Pezzini, Massimo (2009-07-21). "GigaSpaces Focuses on Cloud-Enabled XTP With XAP 7.0" (pdf). Gartner.
  5. Pezzini, Massimo (2011-03-14). "GigaSpaces Moves Into High-Control Cloud-Enabled Application Platforms" (pdf). Gartner.
  6. Fellows, William (2011-11-17). "GigaSpaces out to Cloudify any app on any cloud". 451 Group.
  7. Michel Daydé, Jack Dongarra, Vincente Hernández, José M.L.M. Palm (2005-06-23). "High Performance Computing for Computational Science".{{cite web}}: CS1 maint: multiple names: authors list (link)
  8. "GigaSpaces updates JavaSpaces-related platform". TechTarget. 2003-08-26.
  9. Capizzi, Sirio (2008-03). "A Tuple Space Implementation for Large-Scale Infrastructures" (pdf). Universita di Bologna, Padova. {{cite web}}: Check date values in: |date= (help); line feed character in |title= at position 33 (help)
  10. "Tuple Space Implementations". SourceForge.
  11. Fulton, Scott M. (2012-02-16). "Driver for Deploying Any App to Any Cloud Available for Free". ReadWriteWeb.
  12. "Core Concepts in Space-Based Architecture".
  13. "A Typical SBA Application".


External References

External Links

Categories: