1. Latest GridGain releases have had a big focus on remote grid clients, or as we like to call them remote drivers. We have recently added Java/Android and C#/.NET clients with C++ and Objective-C clients right around the corner.  The goal of remote drivers is to provide ability to use Grid API from environments where it does not make sense to start a node and join the grid, but yet it is still needed to access objects from cache or execute a MapReduce task on remote grid.

    The real trick when designing clients is to make sure that the API's are feature rich, but yet portable between different languages. We used Google Protocol Buffers to ensure portability. This way an object can be stored in cache using .NET C# client and retrieved, for example, using Java or C++ clients.

    Another real important feature for remote drivers is data affinity, especially when working with partitioned caches. Partition caches have a concept of data ownership where every node owns a certain chunk of data. This way data can be split across many nodes and the whole grid becomes one shared RAM storage. However, such approach only works well with collocation of computations and data. All client requests to data should come exactly to the node where the data is cached - otherwise there will be lots of redundant data movement (a.k.a. data noise) which will have adverse effect on scalability.

    At GridGain we took specific effort to make sure that all remote GridGain drivers have an embedded notion of affinity - this way you can store an object in cache using Java and then retrieve it using C# client which will know exactly where to go to get it.

    Here is an example of how you would use GridGain remote Java or .NET C# clients for basic data and compute operations:
    // Get all remote grid nodes
    for (GridClientNode node: client.compute().nodes())
        System.out.println("External IP addresses: " + node.externalAddresses())
    
    // Connect to partitioned cache.
    GridClientData rmtCache = client.data("partitioned")
    
    // Get and update 10 keys. All cache operations 
    // will go exactly to the node where data is cached.
    for (int key = 0; key < 10; key++) {
        // Get data.
        String val = rmtCache.get(key);
    
        // Update data if it is equal to the one we just got.
        rmtCache.cas(key, val + i, val);
    
        // Asynchronously remove data.
        rmtCache.removeAsync(key);
    }
    
    // Connect to remote grid.
    GridClientCompute rmtCompute = client.compute();
    
    // Execute map-reduce task on remote grid.
    GridClientFuture fut = rmtCompute.executeAsync("MyTask", "myarg");
    
    // Wait for completion.
    fut.get();
    
    ...
    
    using X = System.Console;
    
    // Get all remote grid nodes.
    foreach (IGridClientNode node in client.Compute().Nodes())
        X.WriteLine("External IP addresses: " + node.ExternalIpAddresses);
    
    // Connect to partitioned cache.
    IGridClientData rmtCache = client.Data("partitioned");
    
    // Get and update 10 keys. All cache operations 
    // will go exactly to the node where data is cached.
    for (int key = 0; key < 10; key++) {
        // Get data.
        String val = rmtCache.GetItem(key);
    
        // Update data if it is equal to the one we just got.
        rmtCache.Cas(key, val + i, val);
    
        // Asynchronously remove data.
        rmtCache.RemoveAsync(key);
    }
    
    // Connect to remote grid.
    IGridClientCompute rmtCompute = client.Compute();
    
    // Execute map-reduce task on remote grid.
    IGridClientFuture fut = rmtCompute.ExecuteAsync("MyTask", "myarg");
    
    // Wait for completion.
    fut.Result;
    
    ...
    
    Note how almost identical the client API's for Java and C# look. Also note that both, C# and Java clients use key affinity and send data operations exactly to the nodes where the data is.

    To try GridGain and it's new remote drivers, download GridGain 4.0.2 here.
    0

    Add a comment

  2. GridGain 4.0.2 has been released today. This is a point release that includes several bug fixes as well as number of new features.













    With 4.0.1 we are introducing native support for .NET with our C# Client. C# Client provides native .NET/C# APIs for accessing both GridGain’s In-Memory Data Grid and Compute Grid from outside of the GridGain topology context. Internally it’s deferring to the REST protocol. Check out examples on GitHub.

    C# Client is one of many native clients we’ll be releasing shortly including Objective-C, C++, PHP, Scala, Ruby, and some others we’re already working on.

    Improved Support for 32-bit and 64-bit Systems


    We’ve modified our scripts for better out-of-the-box support for 32-bit and 64-bit systems. We’ve had several clients complaint that additional configuration properties were required and specifically GridGain Visor didn’t work fully on 32-bit system with default configuration. All these issues have been resolved.

    Enhancements to GridGain Visor

    We are continuing making rapid improvements to GridGain Visor that is part of GridGain Enterprise and OEM editions.

    We’ve added ability to specific the time span for chart views:




















    We’ve added nice in-place filtering for events in Dashboard:












    You can now double click on event and to see its details:


































    You can download GridGain 4.0.2 here.
    0

    Add a comment









  3. Come and see me talk about Streaming Map Reduce on GridGain and do some live coding of famous Hadoop’s example of counting popular words… but in Real Time context on GridGain. As always – live coding from scratch in Scala is never dull!
    See you there.
    0

    Add a comment

About me
About me
- Antoine de Saint-Exupery -
- Antoine de Saint-Exupery -
"A designer knows he has achieved perfection not when there is nothing left to add, but when there is nothing left to take away."
Blog Archive
Blogs I frequent
Loading
Dynamic Views theme. Powered by Blogger.