<!--
 ▄▄▄       ██▓███   ▄▄▄       ▄████▄   ██░ ██ ▓█████     ██▓  ▄████  ███▄    █  ██▓▄▄▄█████▓▓█████
▒████▄    ▓██░  ██▒▒████▄    ▒██▀ ▀█  ▓██░ ██▒▓█   ▀    ▓██▒ ██▒ ▀█▒ ██ ▀█   █ ▓██▒▓  ██▒ ▓▒▓█   ▀
▒██  ▀█▄  ▓██░ ██▓▒▒██  ▀█▄  ▒▓█    ▄ ▒██▀▀██░▒███      ▒██▒▒██░▄▄▄░▓██  ▀█ ██▒▒██▒▒ ▓██░ ▒░▒███
░██▄▄▄▄██ ▒██▄█▓▒ ▒░██▄▄▄▄██ ▒▓▓▄ ▄██▒░▓█ ░██ ▒▓█  ▄    ░██░░▓█  ██▓▓██▒  ▐▌██▒░██░░ ▓██▓ ░ ▒▓█  ▄
 ▓█   ▓██▒▒██▒ ░  ░ ▓█   ▓██▒▒ ▓███▀ ░░▓█▒░██▓░▒████▒   ░██░░▒▓███▀▒▒██░   ▓██░░██░  ▒██▒ ░ ░▒████▒
 ▒▒   ▓▒█░▒▓▒░ ░  ░ ▒▒   ▓▒█░░ ░▒ ▒  ░ ▒ ░░▒░▒░░ ▒░ ░   ░▓   ░▒   ▒ ░ ▒░   ▒ ▒ ░▓    ▒ ░░   ░░ ▒░ ░
  ▒   ▒▒ ░░▒ ░       ▒   ▒▒ ░  ░  ▒    ▒ ░▒░ ░ ░ ░  ░    ▒ ░  ░   ░ ░ ░░   ░ ▒░ ▒ ░    ░     ░ ░  ░
  ░   ▒   ░░         ░   ▒   ░         ░  ░░ ░   ░       ▒ ░░ ░   ░    ░   ░ ░  ▒ ░  ░         ░
      ░  ░               ░  ░░ ░       ░  ░  ░   ░  ░    ░        ░          ░  ░              ░  ░
-->

<!--
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements.  See the NOTICE file
distributed with this work for additional information
regarding copyright ownership.  The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"); you may not use this file except in compliance
with the License.  You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied.  See the License for the
specific language governing permissions and limitations
under the License.
-->

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Apache Ignite - Features</title>
    <link media="all" rel="stylesheet" href="css/all.css">
    <link href="http://netdna.bootstrapcdn.com/font-awesome/4.2.0/css/font-awesome.css" rel="stylesheet">
    <link media="all" rel="stylesheet" href="css/syntaxhighlighter.css">
    <link href='https://fonts.googleapis.com/css?family=Open+Sans:400,300,300italic,400italic,600,600italic,700,700italic,800,800italic' rel='stylesheet' type='text/css'>
</head>
<body>
<div id="wrapper">
    <header id="header" class="affix" data-spy="affix" data-offset-top="0">
        <div class="container">
            <div class="row">
                <div class="col-md-3 col-sm-3 col-xs-8">
                    <div class="logo"><a href="index.html"><img src="images/logo.png" alt="ApacheIgnite"></a></div>
                </div>
                <div class="col-md-9 col-sm-9 col-xs-4">
                    <nav id="nav" class="navbar navbar-default" role="navigation">
                        <div class="container-fluid">
                            <div class="navbar-header">
                                <button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#navbar">
                                    <span class="sr-only">Toggle navigation</span>
                                    <span class="icon-bar"></span>
                                    <span class="icon-bar"></span>
                                    <span class="icon-bar"></span>
                                </button>
                            </div>
                            <div class="collapse navbar-collapse" id="navbar">
                                <ul class="nav navbar-nav">
                                    <li><a href="index.html#overview">Overview</a></li>
                                    <li><a href="features.html">Features</a></li>
                                    <li><a href="index.html#documentation">Documentation</a></li>
                                    <li><a href="index.html#community">Community</a></li>
                                    <li><a href="index.html#download">Download</a></li>
                                </ul>
                            </div>
                        </div>
                    </nav>
                </div>
            </div>
        </div>
    </header>
    <main id="main" role="main" class="container key-features">
        <section id="features">
            <h2>Key In-Memory Fabric Features</h2>
            <p align="center">
                Apache Ignite In-Memory Data Fabric is a high-performance,
                integrated and distributed in-memory platform for computing
                and transacting on large-scale data sets in real-time, orders
                of magnitude faster than possible with traditional disk-based
                or flash technologies.
            </p>
            <table cellspacing="5px" cellpadding="5px">
                <tbody>
                    <tr>
                        <td class="datagrid"><a href="#datagrid">Data Grid</a></td>
                        <td class="computegrid"><a href="#computegrid">Compute Grid</a></td>
                        <td class="servicegrid"><a href="#servicegrid">Service Grid</a></td>
                        <td class="streaming"><a href="#datastreaming">Streaming</a></td>
                        <td class="hadoop"><a href="#hadoop">Hadoop Acceleration</a></td>
                    </tr>
                    <tr>
                        <td class="filesystem"><a href="#filesystem">Distributed File System</a></td>
                        <td class="clustering"><a href="#clustering">Advanced Clustering</a></td>
                        <td class="messaging"><a href="#messaging">Distributed Messaging</a></td>
                        <td class="events"><a href="#events">Distributed Events</a></td>
                        <td class="datastructures"><a href="#datastructures">Distributed Data Structures</a></td>
                    </tr>
                </tbody>
            </table>
        </section>

        <section id="datagrid" class="feature-section">
            <h2>Data Grid</h2>
            <p>
                Ignite In-Memory Data Fabric stores their data in-memory as opposed to traditional
                Database Management Systems that utilize disk as their primary storage mechanism.
                By utilizing system memory rather than disk, Ignite In-Memory Data Fabric is orders
                of magnitude faster than traditional DBMS systems.
            </p>
            <img src="images/in_memory_data.png"/>
            <div class="features-heading">Features:</div>
            <ul class="features-list">
                <li>Distributed In-Memory Caching</li>
                <li>Lightning Fast Performance</li>
                <li>Elastic Scalability</li>
                <li>Distributed In-Memory Transactions</li>
                <li>Distributed In-Memory Queue and Other Data Structures</li>
                <li>Web Session Clustering</li>
                <li>Hibernate L2 Cache Integration</li>
                <li>Tiered Off-Heap Storage</li>
                <li>Distributed SQL Queries with Distributed Joins</li>
            </ul>

            <div class="code-examples">
                <div class="examples-heading">Examples:</div>
                <!-- Nav tabs -->
                <ul id="datagrid-examples" class="nav nav-tabs">
                    <li class="active"><a href="#datagrid-example-basic" aria-controls="home" data-toggle="tab">Put and Get</a></li>
                    <li><a href="#datagrid-example-transactions" aria-controls="profile" data-toggle="tab">Transactions</a></li>
                    <li><a href="#datagrid-example-locks" aria-controls="profile" data-toggle="tab">Locks</a></li>
                    <li><a href="#datagrid-example-sqlquery" aria-controls="profile" data-toggle="tab">SQL Query</a></li>
                    <li><a href="#datagrid-example-sqljoin" aria-controls="profile" data-toggle="tab">SQL Join</a></li>
                </ul>

                <!-- Tab panes -->
                <div class="tab-content">
                    <div class="tab-pane active" id="datagrid-example-basic">
                        <br/>
                        <p>
                            Basic cache operations example.
                        </p>
                        <pre class="brush:java">
                            try (Ignite ignite = Ignition.start("examples/config/example-cache.xml")) {
                                final IgniteCache&lt;Integer, String&gt; cache = ignite.jcache("cacheName");

                                // Store keys in cache.
                                for (int i = 0; i < 10; i++)
                                    cache.put(i, Integer.toString(i));

                                // Retrieve values from cache.
                                for (int i = 0; i < 10; i++)
                                    System.out.println("Got [key=" + i + ", val=" + cache.get(i) + ']');

                                // Remove objects from cache.
                                for (int i = 0; i < 10; i++)
                                    cache.remove(i);

                                // Atomic put-if-absent.
                                cache.putIfAbsent(1, "1");

                               // Atomic replace.
                               cache.replace(1, "1", "2");
                            }
                        </pre>
                    </div>
                    <div class="tab-pane" id="datagrid-example-transactions">
                        <br/>
                        <p>
                            Transaction example demonstrating multiple reads and puts done atomically.
                        </p>
                        <pre class="brush:java">
                            // Clone every object we get from cache, so we can freely update it.
                            IgniteCache&lt;Integer, Account&gt; cache = Ignition.ignite().jcache("cacheName");

                            try (IgniteTx tx = Ignition.ignite().transactions().txStart(PESSIMISTIC, REPEATABLE_READ)) {
                                Account acct = cache.get(acctId);

                                assert acct != null;

                                // Deposit $20 into account.
                                acct.setBalance(acct.getBalance() + 20);

                                // Store updated account in cache.
                                cache.put(acctId, acct);

                                tx.commit();
                            }
                        </pre>
                    </div>
                    <div class="tab-pane" id="datagrid-example-locks">
                        <br/>
                        <p>
                            Synchronously acquire and release lock by key.
                        </p>
                        <pre class="brush:java">
                            final GridCache&lt;String, Integer&gt; cache = Ignition.ignite.jcache("cacheName");

                            cache.lock("Hello");

                            try {
                                cache.put("Hello", 11);
                                cache.put("World", 22);
                            }
                            finally {
                                cache.unlock("Hello");
                            }
                        </pre>
                    </div>
                    <div class="tab-pane" id="datagrid-example-sqlquery">
                        <br/>
                        <p>
                            Person class definition.
                        </p>
                        <pre class="brush:java">
                            private static class Person implements Serializable {
                                /** Person ID (indexed). */
                                @CacheQuerySqlField(index = true)
                                private long id;

                                /** Organization ID (indexed). */
                                @CacheQuerySqlField(index = true)
                                private long orgId;

                                /** First name (not-indexed). */
                                @CacheQuerySqlField
                                private String firstName;

                                ...
                            }
                        </pre>
                        <br/>
                        <p>
                            Simple distributed SQL query.
                        </p>
                        <pre class="brush:java">
                            try (Ignite ignite = Ignition.start("examples/config/example-cache.xml")) {
                                GridCache&lt;Long, Person&gt; cache = ignite.jcache("cacheName");

                                // Create query which selects salaries based on range.
                                CacheQuery&lt;Map.Entry&lt;Long, Person&gt;&gt; qry =
                                    cache.queries().createSqlQuery(Person.class, "salary > ? and salary <= ?");

                                // Execute queries for salary ranges.
                                print("People with salaries between 0 and 1000: ", qry.execute(0, 1000).get());

                                print("People with salaries between 1000 and 2000: ", qry.execute(1000, 2000).get());

                            }
                        </pre>
                    </div>
                    <div class="tab-pane" id="datagrid-example-sqljoin">
                        <br/>
                        <p>
                            Person class definition.
                        </p>
                        <pre class="brush:java">
                            private static class Person implements Serializable {
                                /** Person ID (indexed). */
                                @CacheQuerySqlField(index = true)
                                private long id;

                                /** Organization ID (indexed). */
                                @CacheQuerySqlField(index = true)
                                private long orgId;

                                /** First name (not-indexed). */
                                @CacheQuerySqlField
                                private String firstName;

                                ...
                            }
                        </pre>
                        <br/>
                        <p>
                            Distributed query with SQL join between Person and Organization.
                        </p>
                        <pre class="brush:java">
                            try (Ignite ignite = Ignition.start("examples/config/example-cache.xml")) {
                                GridCache&lt;Long, Person&gt; cache = ignite.jcache("cacheName");

                                // Create query which joins on 2 types to select people for a specific organization.
                                CacheQuery&lt;Map.Entry&lt;Long, Person&gt;&gt; qry =
                                    cache.queries().createSqlQuery(Person.class, "from Person, Organization " +
                                        "where Person.orgId = Organization.id " +
                                        "and Organization.name = ?");

                                // Execute queries for find employees for different organizations.
                                print("Following people are 'Ignite' employees: ", qry.execute("Ignite").get());

                                print("Following people are 'Other' employees: ", qry.execute("Other").get());

                            }
                        </pre>
                    </div>
                </div>
            </div>

            <div class="feature-links">
                <a target=wiki href="http://doc.gridgain.org/latest/Data+Grid">Learn More <i class="fa fa-angle-double-right"></i></a>
                <a href="#features">Top <i class="fa fa-angle-double-up"></i></a>
            </div>
        </section>

        <section id="computegrid" class="feature-section">
            <h2>Compute Grid</h2>
            <p>
                Compute Grid provides the means for parallel processing of CPU
                or otherwise resource intensive tasks including traditional High Performance Computing (HPC) and
                Massively Parallel Processing (MPP).
            </p>
            <img src="images/in_memory_compute.png"/>
            <div class="features-heading">Features:</div>
            <ul class="features-list">
                <li>Dynamic Clustering</li>
                <li>Fork-Join & MapReduce Processing</li>
                <li>Distributed Closure Execution</li>
                <li>Load Balancing and Fault Tolerance</li>
                <li>Distributed Messaging and Events</li>
                <li>Linear Scalability</li>
                <li>ExecutorService</li>
            </ul>

            <div class="code-examples">
                <div class="examples-heading">Examples:</div>
                <!-- Nav tabs -->
                <ul id="compute-examples" class="nav nav-tabs">
                    <li class="active"><a href="#compute-example-broadcast" aria-controls="home" data-toggle="tab">Broadcast</a></li>
                    <li><a href="#compute-example-runnable" aria-controls="profile" data-toggle="tab">Runnable</a></li>
                    <li><a href="#compute-example-closure" aria-controls="profile" data-toggle="tab">Distributed Closure</a></li>
                </ul>

                <!-- Tab panes -->
                <div class="tab-content">
                    <div class="tab-pane active" id="compute-example-broadcast">
                        <br/>
                        <p>
                            Print out hello message on all nodes.
                        </p>
                        <pre class="brush:java">
                            try (Ignite ignite = Ignition.start("examples/config/example-compute.xml")) {
                                // Print out hello message on all nodes.
                                ignite.compute().broadcast(
                                    new IgniteRunnable() {
                                        @Override public void run() {
                                            System.out.println(">>> Hello Node! :)");
                                        }
                                    }
                                );
                            }
                        </pre>
                    </div>
                    <div class="tab-pane" id="compute-example-runnable">
                        <br/>
                        <p>
                            Iterate through all words in a sentence and print each word on different nodes in the cluster.
                        </p>
                        <pre class="brush:java">
                            try (Ignite ignite = Ignition.start("examples/config/example-compute.xml")) {
                                Collection&lt;IgniteFuture&gt; futs = new ArrayList<>();

                                // Enable asynchronous mode.
                                IgniteCompute compute = ignite.compute().withAsync();

                                // Iterate through all words in the sentence and create runnable jobs.
                                for (final String word : "Print words using runnable".split(" ")) {
                                    // Execute runnable on some node.
                                    compute.run(new IgniteRunnable() {
                                        @Override public void run() {
                                            System.out.println("Printing '" + word + "' on this node from ignite job.");
                                        }
                                    });

                                    futs.add(compute.future());
                                }

                                // Wait for all futures to complete.
                                for (IgniteFuture&lt;?&gt; f : futs)
                                f.get();
                            }
                        </pre>
                    </div>
                    <div class="tab-pane" id="compute-example-closure">
                        </br>
                        <p>
                            This example splits a phrase into collection of words, computes their length on different
                            nodes and then computes total amount of non-whitespaces characters in the phrase.
                        </p>
                        <pre class="brush:java">
                            try (Ignite ignite = Ignition.start() {
                                // Execute closure on all cluster nodes.
                                Collection&lt;Integer&gt; res = ignite.compute().apply(
                                    new IgniteClosure&lt;String, Integer&gt;() {
                                        @Override public Integer apply(String word) {
                                            System.out.println("Printing '" + word + "' on this node from Ignite job.");

                                            // Return number of letters in the word.
                                            return word.length();
                                        }
                                    },

                                    // Job parameters. Ignite will create as many jobs as there are parameters.
                                    Arrays.asList("Count characters using closure".split(" "))
                                );

                                int sum = 0;

                                // Add up individual word lengths received from remote nodes.
                                for (int len : res)
                                sum += len;
                            }
                        </pre>
                    </div>
                </div>
            </div>

            <div class="feature-links">
                <a target=wiki href="http://doc.gridgain.org/latest/Distributed+Computations">Learn More <i class="fa fa-angle-double-right"></i></a>
                <a href="#features">Top <i class="fa fa-angle-double-up"></i></a>
            </div>
        </section>

        <section id="servicegrid" class="feature-section">
            <h2>Service Grid</h2>
            <p>
                Ignite Service Grid allows you to have complete control over services being deployed on the
                cluster. It allows you to control how many instances of your service should be deployed on each cluster
                node, ensuring proper deployment and fault tolerance. Service Grid guarantees continuous availability
                of all deployed services in case of node failures. </br><br/>
            </p>
            <div class="features-heading">Features:</div>
            <ul class="features-list">
                <li>Automatically Deploy Multiple Instances of a Service</li>
                <li>Automatically Deploy a Service as Singleton</li>
                <li>Automatically Deploy Services on Node Start-Up</li>
                <li>Fault Tolerant Deployment</li>
                <li>Un-Deploy Any of the Deployed Services</li>
                <li>Get Service Deployment Topology Information</li>
                <li>Access Remotely Deployed Service via Service Proxy</li>
            </ul>

            <div class="code-examples">
                <div class="examples-heading">Examples:</div>
                <!-- Nav tabs -->
                <ul id="service-examples" class="nav nav-tabs">
                    <li class="active"><a href="#service-example" aria-controls="home" data-toggle="tab">Service Deployment</a></li>
                </ul>

                <!-- Tab panes -->
                <div class="tab-content">
                    <div class="tab-pane active" id="service-example">
                        <br/>
                        <p>
                            An example of how a distributed service may be implemented

                        </p>
                        <pre class="brush:java">
                            // Simple service implementation.
                            public class MyIgniteService implements Service {
                                // Example of ignite resource injection. All resources are optional.
                                // You should inject resources only as needed.
                                @IgniteInstanceResource
                                private Ignite ignite;
                                ...

                                @Override public void cancel(ServiceContext ctx) {
                                    // No-op.
                                }

                                @Override public void execute(ServiceContext ctx) {
                                    // Loop until service is cancelled.
                                    while (!ctx.isCancelled()) {
                                        // Do something.
                                        ...
                                    }
                                }
                            }
                        </pre>
                        <br/>
                        <p>
                            and deployed.
                        </p>
                        <pre class="brush:java">
                            ...

                            IgniteServices svcs = ignite.services();

                            IgniteFuture&lt;?&gt; fut = svcs.deployClusterSingleton("myClusterSingleton", new MyIgniteService());

                            // Wait for deployment to complete.
                            fut.get();
                        </pre>
                    </div>
                </div>
            </div>
            <div class="feature-links">
                <a target=wiki href="http://doc.gridgain.org/latest/Distributed+Services">Learn More <i class="fa fa-angle-double-right"></i></a>
                <a href="#features">Top <i class="fa fa-angle-double-up"></i></a>
            </div>
        </section>

        <section id="datastreaming" class="feature-section">
            <h2>Streaming</h2>
            <p>
                Streaming processing addresses a large family of applications for which traditional processing methods
                and disk-based storages, like databases or file systems, fall short. Such applications are pushing
                the limits of traditional data processing infrastructures.
            </p>
            <img src="images/in_memory_streaming.png"/>
            <p>
                Streaming support allows to query into rolling windows of coming data, and enable users to answer
                such questions as “What are the 10 most popular products over last 2 hours?”, or “What is the average
                product price in a certain category for the past day?”.<br/><br/>
                Another most common use case for stream processing is the ability to control and properly pipeline
                distributed events workflow. As events are coming into the system at high rates, the processing of
                events is split into multiple stages and each stage has to be properly routed within a
                cluster for processing.
            </p>

            <div class="features-heading">Features:</div>
            <ul class="features-list">
                <li>Programmatic Querying</li>
                <li>Customizable Event Workflow</li>
                <li>At-Least-Once Guarantee</li>
                <li>Sliding Windows</li>
                <li>Data Indexing</li>
                <li>Distributed Streamer Queries</li>
                <li>Co-Location With In-Memory Data Grid</li>

            </ul>
            <div class="feature-links">
                <a target=wiki href="http://doc.gridgain.org/latest/Data+Streaming">Learn More <i class="fa fa-angle-double-right"></i></a>
                <a href="#features">Top <i class="fa fa-angle-double-up"></i></a>
            </div>
        </section>

        <section id="hadoop" class="feature-section">
            <h2>Hadoop Acceleration</h2>
            <p>
                Hadoop Accelerator enhances existing Hadoop technology to enable fast data processing using the tools
                and technology your organization is already using today.<br/><br/>
                Ignite’s in-memory accelerator for Hadoop is based on the industry’s first dual-mode,
                high-performance in-memory file system that is 100% compatible with Hadoop HDFS, and an in-memory
                optimized MapReduce implementation. In-memory HDFS and in-memory MapReduce provide easy to use
                extensions to disk-based HDFS and traditional MapReduce, delivering up to 100x faster performance.<br/><br/>
                In-memory accelerator for Hadoop requires minimal to no integration and works with any commercial or
                open source version of Hadoop, including Cloudera, HortonWorks, MapR, Apache, Intel, AWS, as well
                as any other Hadoop 1.x and Hadoop 2.x distributions.
            </p>
            <div class="features-heading">Features:</div>
            <ul class="features-list">
                <li>100x Faster Performance</li>
                <li>In-Memory MapReduce</li>
                <li>Highly Optimized In-Memory Processing</li>
                <li>Dual Mode - Standalone File System/Primay Caching Layer for HDFS </li>
                <li>Highly Tunable Read-Through and Write-Through Behavior</li>
            </ul>
            <div class="feature-links">
                <a target=wiki href="http://hadoop.gridgain.org/latest/Hadoop+Accelerator">Learn More <i class="fa fa-angle-double-right"></i></a>
                <a href="#features">Top <i class="fa fa-angle-double-up"></i></a>
            </div>
        </section>

        <section id="filesystem" class="feature-section">
            <h2>Distributed File System</h2>
            <p>
                One of the unique capabilities of Ignite is a file system interface to its in-memory data called
                Ignite File System (IFS). IFS delivers similar functionality to Hadoop HDFS, including the ability to
                create a fully functional file system in memory. In fact, IFS is at the core of
                Ignite’s In-Memory Hadoop Accelerator. <br/><br/>
                The data from each file is split on separate data blocks and stored in cache.
                Developers can access each file’s data with a standard Java streaming API. Moreover, for each part
                of the file a developer can calculate an affinity and process the file’s content on corresponding
                nodes to avoid unnecessary networking.
            </p>
            <div class="features-heading">Features:</div>
            <ul class="features-list">
                <li>Provides Typical File System “View” on In-Memory Caches</li>
                <li>List Directories or Get Information for a Single Path</li>
                <li>Create/Move/Delete Files or Directories</li>
                <li>Write/Read Data Streams into/from Files</li>
            </ul>
            <div class="feature-links">
                <a target=wiki href="http://doc.gridgain.org/latest/GGFS">Learn More <i class="fa fa-angle-double-right"></i></a>
                <a href="#features">Top <i class="fa fa-angle-double-up"></i></a>
            </div>
        </section>

        <section id="clustering" class="feature-section">
            <h2>Advanced Clustering</h2>
            <p>
                Ignite In-Memory Data Fabric provides one of the most sophisticated clustering technologies on
                Java Virtual Machine (JVM). In Ignite nodes can automatically discover each other.
                This helps to scale the cluster when needed, without having to restart the whole cluster. Developers
                can also leverage from Ignite’s hybrid cloud support that allows establishing connection
                between private cloud and public clouds such as Amazon Web Services, providing them
                with best of both worlds. <br/><br/>
            </p>
            <div class="features-heading">Features:</div>
            <ul class="features-list">
                <li>Dynamic Topology Management</li>
                <li>Automatic Discovery on LAN, WAN, and AWS</li>
                <li>Automatic “Split-Brain” (i.e. Network Segmentation) Resolution</li>
                <li>Unicast, Broadcast, and Group-Based Message Exchange</li>
                <li>On-Demand and Direct Deployment</li>
                <li>Support for Virtual Clusters and Node Groupings</li>
            </ul>

            <div class="code-examples">
                <div class="examples-heading">Examples:</div>
                <!-- Nav tabs -->
                <ul id="clustering-examples" class="nav nav-tabs">
                    <li class="active"><a href="#clustering-example-broadcast" aria-controls="home" data-toggle="tab">Broadcast</a></li>
                    <li><a href="#clustering-example-unicast" aria-controls="profile" data-toggle="tab">Unicast</a></li>
                </ul>

                <!-- Tab panes -->
                <div class="tab-content">
                    <div class="tab-pane active" id="clustering-example-broadcast">
                        <br/>
                        <p>
                            Broadcast message to multiple nodes in the cluster.
                        </p>
                        <pre class="brush:java">
                            try (Ignite ignite = Ignition.start("examples/config/example-compute.xml")) {
                                IgniteRunnable r = new IgniteRunnable() {
                                    @Override
                                    public void run() {
                                        System.out.println("Hello World");
                                    }
                                };

                                // Broadcast to all cluster nodes.
                                ignite.compute().broadcast(r);

                                // Broadcast to all remote nodes.
                                ignite.compute(ignite.cluster().forRemotes()).broadcast(r);
                            }
                        </pre>
                    </div>

                    <div class="tab-pane" id="clustering-example-unicast">
                        <br/>
                        <p>
                            Unicast message to a node in the cluster.
                        </p>
                        <pre class="brush:java">
                            try (Ignite ignite = Ignition.start("examples/config/example-compute.xml")) {
                                IgniteRunnable r = new IgniteRunnable() {
                                    @Override
                                    public void run() {
                                        System.out.println("Hello World");
                                    }
                                };

                                // Unicast to some random node picked by load balancer.
                                ignite.compute(ignite.cluster().forRandom()).run(r);

                                // Unicast to some node with CPU load less than 50%.
                                ignite.compute(ignite.cluster().forPredicate(new IgnitePredicate&lt;ClusterNode&gt;() {
                                    @Override
                                    public boolean apply(ClusterNode n) {
                                        return n.metrics().getCurrentCpuLoad() <0.5;
                                    }
                                })).run(r);
                            }
                        </pre>
                    </div>
                </div>
            </div>

            <div class="feature-links">
                <a target=wiki href="http://doc.gridgain.org/latest/Basic+Concepts">Learn More <i class="fa fa-angle-double-right"></i></a>
                <a href="#features">Top <i class="fa fa-angle-double-up"></i></a>
            </div>
        </section>

        <section id="messaging" class="feature-section">
            <h2>Distributed Messaging</h2>
            <p>
                Apache Ignite provides high-performance cluster-wide messaging functionality to exchange data
                via publish-subscribe and direct point-to-point communication models.
            </p>
            <div class="features-heading">Features:</div>
            <ul class="features-list">
                <li>Support for Topic-Based Publish-Subscribe Model</li>
                <li>Support for Direct Point-to-Point Communication</li>
                <li>Pluggable Communication Transport Layer</li>
                <li>Support for Message Ordering</li>
                <li>Cluster-Aware Message Listener Auto-Deployment </li>
            </ul>

            <div class="code-examples">
                <div class="examples-heading">Examples:</div>
                <!-- Nav tabs -->
                <ul id="messaging-examples" class="nav nav-tabs">
                    <li class="active"><a href="#messaging-example-ordered" aria-controls="home" data-toggle="tab">Ordered Messaging</a></li>
                    <li><a href="#messaging-example-unordered" aria-controls="profile" data-toggle="tab">Unordered Messaging</a></li>
                </ul>

                <!-- Tab panes -->
                <div class="tab-content">
                    <div class="tab-pane active" id="messaging-example-ordered">
                        <br/>
                        <p>
                            Send and receive ordered messages
                        </p>
                        <pre class="brush:java">
                            try (Ignite ignite = Ignition.start("examples/config/example-compute.xml")) {
                                // Add listener for ordered messages on all nodes.
                                ignite.message().remoteListen("MyOrderedTopic", new IgniteBiPredicate&lt;UUID, String&gt;() {
                                    @Override public boolean apply(UUID nodeId, String msg) {
                                        System.out.println("Received ordered message [msg=" + msg + ", fromNodeId=" + nodeId + ']');

                                        return true; // Return true to continue listening.
                                    }
                                });

                                // Send ordered messages to remote nodes nodes.
                                for (int i = 0; i < 10; i++)
                                    ignite.message(ignite.cluster().forRemotes()).sendOrdered("MyOrderedTopic", Integer.toString(i), 0);
                            }
                        </pre>
                    </div>
                    <div class="tab-pane" id="messaging-example-unordered">
                        <br/>
                        <p>
                            Send and receive unordered messages
                        </p>
                        <pre class="brush:java">
                            try (Ignite ignite = Ignition.start("examples/config/example-compute.xml")) {
                                // Add listener for unordered messages on all nodes.
                                ignite.message().remoteListen("MyUnOrderedTopic", new IgniteBiPredicate&lt;UUID, String&gt;() {
                                    @Override public boolean apply(UUID nodeId, String msg) {
                                        System.out.println("Received unordered message [msg=" + msg + ", fromNodeId=" + nodeId + ']');

                                        return true; // Return true to continue listening.
                                    }
                                });

                                // Send unordered messages to remote nodes.
                                for (int i = 0; i < 10; i++)
                                    ignite.message(ignite.cluster().forRemotes()).send("MyUnOrderedTopic", Integer.toString(i));
                            }
                        </pre>
                    </div>
                </div>
            </div>

            <div class="feature-links">
                <a target=wiki href="http://doc.gridgain.org/latest/Distributed+Messaging">Learn More <i class="fa fa-angle-double-right"></i></a>
                <a href="#features">Top <i class="fa fa-angle-double-up"></i></a>
            </div>
        </section>

        <section id="events" class="feature-section">
            <h2>Distributed Events</h2>
            <p>
                Distributed events functionality allows applications to receive notifications about cache events
                occurring in distributed grid environment. Developers can use this functionality to get notified
                about remote tasks executions or any cache data changes within the cluster.<br/><br/>
                In Ignite, event notifications can be grouped together and sent in batches and/or timely intervals.
                Batching notifications help attain high cache performance and low latency.

            </p>
            <div class="features-heading">Features:</div>
            <ul class="features-list">
                <li>Subscribe Local and Remote Listeners</li>
                <li>Enable and Disable any Event</li>
                <li>Provide Local and Remote Filters for Fine-Grained Control Over Notifications</li>
                <li>Automatic Batching of Notifications for Enhanced Performance</li>
            </ul>

            <div class="code-examples">
                <div class="examples-heading">Examples:</div>
                <!-- Nav tabs -->
                <ul id="events-examples" class="nav nav-tabs">
                    <li class="active"><a href="#events-example-cache" aria-controls="home" data-toggle="tab">Cache Events</a></li>
                </ul>

                <!-- Tab panes -->
                <div class="tab-content">
                    <div class="tab-pane active" id="events-example-cache">
                        <br/>
                        <p>
                            Subscribe to remote notifications for cache data updates.
                        </p>
                        <pre class="brush:java">
                            try (Ignite ignite = Ignition.start("examples/config/example-cache.xml")) {
                                final IgniteCache&lt;Integer, String&gt; cache = ignite.jcache("cacheName");

                                // sample remote filter which only accepts events for keys
                                // that are greater than or equal to 10.
                                IgnitePredicate&lt;CacheEvent&gt; rmtLsnr = new IgnitePredicate&lt;CacheEvent&gt;() {
                                    @Override public boolean apply(CacheEvent evt) {
                                        System.out.println("Cache event: " + evt);

                                        int key = evt.key();

                                        return key >= 10;
                                    }
                                };

                                // Subscribe to specified cache events on all nodes that have cache running.
                                ignite.events(ignite.cluster().forCacheNodes("cacheName")).remoteListen(null, rmtLsnr,
                                    EVT_CACHE_OBJECT_PUT, EVT_CACHE_OBJECT_READ, EVT_CACHE_OBJECT_REMOVED);

                                // Generate cache events.
                                for (int i = 0; i < 20; i++)
                                    cache.put(i, Integer.toString(i));
                            }
                        </pre>
                    </div>
                </div>
            </div>

            <div class="feature-links">
                <a target=wiki href="http://doc.gridgain.org/latest/Distributed+Events">Learn More <i class="fa fa-angle-double-right"></i></a>
                <a href="#features">Top <i class="fa fa-angle-double-up"></i></a>
            </div>
        </section>

        <section id="datastructures" class="feature-section">
            <h2>Distributed Data Structures</h2>
            <p>
                Ignite allows for most of the data structures from java.util.concurrent framework to be used
                in a distributed fashion. For example, you can take java.util.concurrent.BlockingDeque and add something
                to it on one node and poll it from another node. Or have a distributed Primary Key generator,
                which would guarantee uniqueness on all nodes.
            </p>
            <div class="features-heading">Features:</div>
            <ul class="features-list">
                <li>Concurrent Map</li>
                <li>Distributed Queues and Sets</li>
                <li>AtomicLong</li>
                <li>AtomicSequence</li>
                <li>AtomicReference</li>
                <li>CountDownLatch</li>
            </ul>

            <div class="code-examples">
                <div class="examples-heading">Examples:</div>
                <!-- Nav tabs -->
                <ul id="datastructures-examples" class="nav nav-tabs">
                    <li class="active"><a href="#datastructures-example-queues" aria-controls="home" data-toggle="tab">Queues</a></li>
                    <li><a href="#datastructures-example-sets" aria-controls="profile" data-toggle="tab">Sets</a></li>
                    <li><a href="#datastructures-example-sequence" aria-controls="profile" data-toggle="tab">Atomic Sequence</a></li>
                </ul>

                <!-- Tab panes -->
                <div class="tab-content">
                    <div class="tab-pane active" id="datastructures-example-queues">
                        <br/>
                        <p>
                            Distributed Queue example.
                        </p>
                        <pre class="brush:java">
                            try (Ignite ignite = Ignition.start("examples/config/example-cache.xml")) {
                                CollectionConfiguration colCfg = new CollectionConfiguration();

                                colCfg.setCacheName("cacheName");

                                // Non-colocated queue which will be distributed
                                // across all data nodes.
                                IgniteQueue&lt;String&gt; queue = ignite.queue("queueName", 20, colCfg);

                                // Add queue elements.
                                for (int i = 0; i < 20; i++)
                                    queue.add("Value " + Integer.toString(i));

                                // Poll queue elements.
                                for (int i = 0; i < 20; i++)
                                    System.out.println("Polled value: " + queue.poll());
                            }
                        </pre>
                    </div>
                    <div class="tab-pane" id="datastructures-example-sets">
                        <br/>
                        <p>
                            Distributed Set example.
                        </p>
                        <pre class="brush:java">
                            // Initialize new set.
                            IgniteSet&lt;String&gt; set = Ignition.ignite().set("setName", null);

                            // Add set elements.
                            for (int i = 0; i < 10; i++)
                                set.add(Integer.toString(i));

                            // Iterate over set.
                            for (String item : set)
                                System.out.println("Set item: " + item);
                        </pre>
                    </div>
                    <div class="tab-pane" id="datastructures-example-sequence">
                        <br/>
                        <p>
                            Distributed AtomicSequence example.
                        </p>
                        <pre class="brush:java">
                            // Initialize atomic sequence.
                            IgniteAtomicSequence seq = Ignition.ignite().atomicSequence("seqName", 0, true);

                            for (int i = 0; i < 100; i++)
                                System.out.println("Next sequence value: " + seq.incrementAndGet());
                        </pre>
                    </div>
                </div>
            </div>

            <div class="feature-links">
                <a target=wiki href="http://doc.gridgain.org/latest/Distributed+Data+Structures">Learn More <i class="fa fa-angle-double-right"></i></a>
                <a href="#features">Top <i class="fa fa-angle-double-up"></i></a>
            </div>
        </section>
    </main>
    <footer id="footer">
        <div class="container">
            <div class="row">
                <div class="col-md-4 col-sm-5">
                    <div class="logo"><a href="#wrapper"><img src="images/logo2.png" alt="Crowley Marine serving boalers for over years."></a></div>
                </div>
                <nav class="col-md-4 col-sm-3 footer-nav">
                    <ul class="list-unstyled">
                        <li><a href="#overview">Overview</a></li>
                        <li><a href="#documentation">Documentation</a></li>
                        <li><a href="#community">Community</a></li>
                        <li><a href="#download">Download</a></li>
                    </ul>
                </nav>
                <div class="col-md-4 col-sm-4">
                    <p align="right">&copy; 2014 Copyright <a href="#"><b>Apache Ignite</b></a></p>
                    <ul class="social-networks list-unstyled">
                        <li><a href="https://www.linkedin.com/company/249196" class="icon-linkedin"></a></li>
                        <li><a href="https://www.twitter.com/gridgain" class="icon-twitter"></a></li>
                        <li><a href="https://plus.google.com/101084158514011491168/posts" class="icon-google-plus"></a></li>
                        <li><a href="https://www.vimeo.com/gridgain" class="icon-youtube"></a></li>
                    </ul>
                </div>
            </div>
        </div>
    </footer>
</div>
<script src="http://crux-framework-tools.googlecode.com/svn/trunk/misc/highlight/highlightLoader.js"></script>
<script type="text/javascript" src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js"></script>
<script type="text/javascript">window.jQuery || document.write('<script src="js/jquery-1.11.1.min.js"><\/script>')</script>
<script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.0/js/bootstrap.min.js"></script>
<script type="text/javascript" src="js/jquery.main.js"></script>
<script type="text/javascript">
    if (navigator.userAgent.match(/IEMobile\/10\.0/)) {
        var msViewportStyle = document.createElement('style');
        msViewportStyle.appendChild(
            document.createTextNode(
                '@-ms-viewport{width:auto!important}'
            )
        );
        document.querySelector('head').appendChild(msViewportStyle)
    }
</script>
<script type="text/javascript">
    $('ul#compute-examples a[href="compute-example-basic"]').click(function (e) {
        e.preventDefault();

        $(this).tab('show')
    });

    $('ul#compute-examples a[href="compute-example-transactions"]').click(function (e) {
        e.preventDefault();

        $(this).tab('show')
    });

    $('ul#compute-examples a[href="compute-example-locks"]').click(function (e) {
        e.preventDefault();

        $(this).tab('show')
    });

    $('ul#compute-examples a[href="compute-example-sqlquery"]').click(function (e) {
        e.preventDefault();

        $(this).tab('show')
    });

    $('ul#compute-examples a[href="compute-example-sqljoin"]').click(function (e) {
        e.preventDefault();

        $(this).tab('show')
    });

    $('ul#compute-examples a[href="compute-example-broadcast"]').click(function (e) {
        e.preventDefault();

        $(this).tab('show')
    });

    $('ul#compute-examples a[href="compute-example-runnable"]').click(function (e) {
        e.preventDefault();

        $(this).tab('show')
    })

    $('ul#compute-examples a[href="compute-example-closure"]').click(function (e) {
        e.preventDefault();

        $(this).tab('show')
    })

    $('ul#compute-examples a[href="service-example"]').click(function (e) {
        e.preventDefault();

        $(this).tab('show')
    })

    $('ul#compute-examples a[href="messaging-example-ordered"]').click(function (e) {
        e.preventDefault();

        $(this).tab('show')
    })

    $('ul#compute-examples a[href="messaging-example-unordered"]').click(function (e) {
        e.preventDefault();

        $(this).tab('show')
    })

    $('ul#compute-examples a[href="events-example-cache"]').click(function (e) {
        e.preventDefault();

        $(this).tab('show')
    })

    $('ul#compute-examples a[href="clustering-example-broadcast"]').click(function (e) {
        e.preventDefault();

        $(this).tab('show')
    })

    $('ul#compute-examples a[href="clustering-example-unicast"]').click(function (e) {
        e.preventDefault();

        $(this).tab('show')
    })

    $('ul#compute-examples a[href="datastructures-example-queues"]').click(function (e) {
        e.preventDefault();

        $(this).tab('show')
    })

    $('ul#compute-examples a[href="datastructures-example-sets"]').click(function (e) {
        e.preventDefault();

        $(this).tab('show')
    })

    $('ul#compute-examples a[href="datastructures-example-sequence"]').click(function (e) {
        e.preventDefault();

        $(this).tab('show')
    })
</script>
</body>
</html>