Product

Overview Key Features Download

TESTIMONIALS ...Users Say

DOCUMENTATION Online Resources

Overview

GridGain is the first 100% integrated distributed software middleware that combines compute and data grid technology with unique auto-scaling capabilities on any managed infrastructure - from a single laptop to a large hybrid cloud consisting of thousands of nodes. GridGain provides native support for both Java and Scala programming languages.

Using GridGain you can quickly build distributed applications in Java or Scala that work natively in the grid or cloud environment:

GridGain can work standalone but also integrates natively with the many projects in Java and Scala eco-system like servlet containers, JEE servers, DI and web frameworks, JMS middleware, etc.

GridGain 3.0 comes in two editions:

• Community Edition, open source and free.
• Enterprise Edition, many additional features.

 Top   Wiki

key features

Although the product effectively doubled in size from GridGain 2.0 and most of its APIs have been significantly enhanced, it is largely backward compatible and in majority of cases the migration from the previous version only requires a simple recompilation. Such longevity of the design is a sound testament to GridGain core design principles.

Some of the key features of GridGain 3.0 are:

Functional Programming

To support functional programming GridGain 3.0 introduced two new features:


• Java-based functional programming framework built from the ground up in GridGain 3.0 providing its users with the most comprehensive functional programming capabilities for Java programming language.
• Scalar - Scala-based internal Domain Specific Language (DSL) built on top of GridGain 3.0 Java-based functional core allowing Scala developers native access to GridGain functionality.

 Top   Wiki

Native Java & Scala Support

New Java and Scala functional APIs (additionally to object-oriented and AOP-based) enable developers to significantly simplify many often used distributed operations - yet gain in readability and expressiveness of their business logic build on top of GridGain 3.0.

Consider the following example of the method that calculates the number of non-whitespace characters in a string.

In Java:

public int length(String msg) {
    return msg.replaceAll("\\s", "").length();
}
                

In Scala:


def length(msg: String) = msg.replaceAll("\\s", "").length
                

In order to grid-enable it (for the sake of this example) we would split input string into substrings separated by whitespaces, distribute the calculation of length for each string to the remote nodes and finally aggregate all sub-lengths from remote nodes to a final value of non-whitespace length for the input string.

Here is how this could be coded in Java using GridGain 2.0 AOP-based approach:

@Gridify(taskClass = Task.class)
public int length(String msg) {
    return msg.replaceAll("\\s", "").length();
}

class Task extends GridifyTaskSplitAdapter<Integer> {
    @Override
    protected Collection<? extends GridJob> split(int gridSize,
        GridifyArgument arg) throws GridException {
        String msg = (String)arg.getMethodParameters()[0];
        String[] words =  msg.split("\\w", 0);
        Collection<GridJob> jobs = new ArrayList<GridJob>();
        for (final String word : words) {
            jobs.add(new GridJobAdapter() {
                @Override
                public Object execute() throws GridException {
                    return word.length();
                }
            });
        }
        return jobs;
    }

    @Override
    public Integer reduce(List<GridJobResult> results) throws GridException {
        int length = 0;
        for (GridJobResult res : results) {
            length += (Integer)res.getData();
        }
        return length;
    }
}

The boilerplate code for such task, however, can in most cases be eliminated since the actual logic consists of just two simple functions:


• One that produces a collection of closures based on the input string,
• and second one that sums up collection of integers.

With GridGain 3.0 this problem can be solved more effectively using functional APIs. Instead of AOP we will simply modify the original code to work in a distributed fashion. This usage paradigm is central to new GridGain 3.0 functional design.

In Java (using GridGain 3.0 functional APIs):

public int length(String msg) {
    return G.grid().reduce(SPREAD, F.yield(msg.split(“\\s”, 0),
        F.<String, Integer>c1("length")), F.sumIntReducer());
}
                

In Scala (using GridGain 3.0 and Scalar DSL):

def length(msg: String) = grid !!< (
    for (w < msg.split(“\\s”, 0)) yield () => w.length(),
    (s: Seq[Int]) => (0 /: s)(_+_)
)
                

Another important point is that distribution logic is brought onto language level in Java and even more so in Scala. In Java, closures and typedefs significantly reduce the boilerplate code, and in Scala the distributed operations brought completely on an operator syntax level via internal Scalar DSL making complex distributed cloud operations no different syntactically or semantically from the standard Scala code.

 Top   Wiki

100% Integrated Platform

GridGain 3.0 is the first version of GridGain software that delivers on its original vision: to provide highly integrated, cohesive and easy to use distributed middleware that combines computational grid, data grids and auto-scaling on any managed infrastructure.

It is also the first distributed middleware of any kind to provide such fully integrated platform for developing applications that work and scale natively on any managed infrastructure. The benefits of such integration are obvious and plentiful for the end users: from dramatically shorten learning curve and development cycle to unique technical capabilities not found in any other products such system-wide zero deployment, full functional APIs, unified configuration and management, etc.

 Top   Wiki

Advanced Data Grid

• Expiration policies (LFU, LRU, time-based)
• Named caches
• Read-through and write-through logic with pluggable cache store
• Synchronous and asynchronous cache operations
• Pluggable data overflow storage via new swap space SPI
• Pessimistic, optimistic and eventually consistent transactions
• JTA/JCA integration
• Data replication and data invalidation in synchronous and asynchronous modes
• Partitioned cache with active replicas
• Advanced distributed query capability including SQL based, Lucene based, H2 text based and predicate based scanning with support for pagination, local and remote filtering, transformation and reduction
• Full integration for compute grid for non-trivial affinity based routing
• Functional and object-oriented APIs

 Top   Wiki

Advanced Compute Grid

GridGain provides the most advanced implementation of MapReduce paradigm with the following features:

• Direct API support for split and aggregation
• Pluggable failover and topology resolution
• Distributed task session
• AOP, OOP-based, FP-based, synch/asynch execution models
• Cron-based scheduling
• Redundant mapping
• Zero deployment with peer-to-peer class loading
• Partial asynchronous reduction
• Support for weighted and adaptive split
• Checkpoints for long running tasks
• Early and late load balancing
• Affinity routing with data grids

Seamless Cloud Enabling

 Top   Wiki

GridGain Shell

• Allows to “script” various operations on GridGain deployment
• Interactive and command modes
• Fully extensible via user defined pluggable commands
• Seamless connectivity to the running GridGain deployment
• Some of the available out-of-the-box commands:
  • Review and monitor topology
  • Execute grid tasks
  • Monitor status
  • Get statistics
  • Query data grid
  • Query distributed events

Pay-Per-Usage Pricing Model

GridGain 3.0 also incorporates a unique built-in idle-detection technology that prevents charging for an active and running node if it is idling for more than hour. Idling is defined as not performing any user operations and not storing any user data as part of the data grid. 


This technology allows GridGain customers to safely over-provision yet pay for the actual use only. This removes the cost penalty for such frequent over-provisioning scenarios such as planned over-capacity for anticipated load spikes, staging and QA environments, hot standbys, scheduled builds, disaster recovery sites, etc.

 Top   Wiki

Hybrid Cloud Support

These new discovery and communication implementations support following non-trivial hybrid deployments:


• Multiple private/public clouds with no direct connectivity
• Multiple private/public cloud with out-connectivity or in-connectivity only
• Geographically distributed hybrid cloud
• Single cloud with WAN/LAN/VPN connectivity between nodes

API-Level Cloud Control

• Starting, stopping and managing virtual instances
• Querying cloud resources such as images, storage devices, network quotas, etc.
• Changing virtual instance profile (where supported)

GridGain 3.0 also provides cloud strategies and policies that enable automated elasticity as well as automated SLA/QoS control capabilities. Both are completely pluggable and are managed by GridGain runtime.

 Top   Wiki

SPI-Based Architecture

Unified configuration of SPIs enables LEGO-like approach to assembling your GridGain framework with specific set of SPI implementations. In the same time grid task implementations (the actual business logic that is running on the grid) or data grid access logic are kept unaffected by different SPIs running underneath.

 Top   Wiki

Zero Deployment

Zero deployment technology enables users to simply bring up default GridGain nodes online and they immediately become part of the data and compute grid topology and can store any user objects or perform any user tasks without any need for explicit deployment of user’s classes or resources.

 Top   Wiki

Advanced Load Balancing

In fact, grid environment is often heterogeneous and non-static, tasks can change their complexity profiles dynamically at runtime and external resources can affect execution of the task at any point. All these factors underscore the need for proactive load balancing during initial mapping operation as well as on destination node where jobs can be in waiting queues.

 Top   Wiki

Pluggable Fault Tolerance

With grid task being the atomic unit of execution on the grid the fully customizable failover logic enables developer to choose specific policy much the same way as one would choose concurrency policy in RDBMS transactions.

This allows to fine tune how grid task reacts to the failure, for example:

• fail entire task immediately upon failure of any of its jobs (fail-fast approach)
• failover any failed job to other nodes until all nodes are exhausted for this job (fail-slow approach)

REST APIs for GridGain Access

This addition allows non-Java environments such as browser’s JavaScript or Flex applications access GridGain functionality.

 Top   Wiki

Management and Monitoring

GridGain also comes pre-integrated with NewRelic RPM technology for advanced SaaS-based monitoring capabilities.

 Top   Wiki