GridGain and Apache Ignite on IBM Power: In-Memory Computing Meets Enterprise Hardware

GridGain — the enterprise in-memory computing platform built on Apache Ignite — runs beautifully on IBM Power. Whether you need to accelerate database queries by 1,000x, build real-time analytics pipelines, or offload your mainframe, IBM Power’s massive RAM capacity and multi-threading make it the ideal hardware for in-memory workloads. Here’s how LibrePower is making this easier.

---

There’s a quiet irony in the enterprise computing world. IBM Power servers — machines designed from the ground up for massive memory, extreme I/O bandwidth, and hardware-level reliability — are often still running the same disk-bound database architectures they ran twenty years ago.

Meanwhile, in-memory computing platforms like GridGain and Apache Ignite have been transforming how organizations handle data: moving it from slow disks into RAM, distributing it across clusters, and delivering query times measured in milliseconds instead of seconds.

The hardware was always there. The software is ready. The gap was in bringing them together cleanly on IBM Power. That’s where LibrePower comes in.

What Is GridGain (and Apache Ignite)?

Let’s start with the basics. Apache Ignite is an open-source distributed database and computing platform that uses RAM as its primary storage tier. It was created by GridGain Systems and donated to the Apache Software Foundation in 2014, where it quickly became one of the top 5 most active ASF projects.

GridGain is the commercial enterprise edition built on top of Apache Ignite, adding multi-datacenter replication, enterprise security (RBAC, encryption, LDAP/OpenID), rolling upgrades, monitoring tools, and SLA-backed support from the engineers who literally built Ignite in the first place.

Think of it this way: Apache Ignite is the engine. GridGain is the whole car — with airbags, GPS, and roadside assistance.

What makes the platform compelling:

• In-memory speed: Data lives in RAM across a distributed cluster. Queries that took seconds on disk run in milliseconds.
• ANSI-99 SQL support: You don’t need to learn a new query language. Standard SQL works, including JOINs, DDL, and DML.
• ACID transactions: Full transactional guarantees — pessimistic, optimistic, read committed, repeatable read, serializable. The works.
• Hybrid storage: RAM for speed, disk for durability. You can keep 100% in memory or let the platform manage hot/cold data automatically.
• Distributed computing: Execute code where the data lives instead of moving data to your application. This collocated processing is what unlocks the real performance gains.
• Multi-language APIs: Java, C++, .NET, Python, Node.js, plus JDBC/ODBC drivers for everything else.
• Streaming and ML: Built-in support for real-time data streaming, continuous queries, and machine learning model execution on live data.

Companies like American Airlines, ING, Societe Generale, American Express, and UnitedHealthcare use GridGain/Ignite for mission-critical workloads. American Airlines alone uses it as a real-time data hub powering 14 applications, achieving single-digit millisecond latency that helps save 1.4 million gallons of jet fuel annually.

Why IBM Power Is the Perfect Home for In-Memory Computing

Here’s where things get interesting. In-memory computing platforms need three things above all else:

1. Lots of RAM — the more you can fit in memory, the better
2. Lots of cores — distributed parallel processing scales with available compute
3. Lots of memory bandwidth — moving data between cores and RAM fast is critical

IBM Power systems deliver all three in ways that x86 hardware simply can’t match at the same scale:

• POWER10 processors support up to 4 TB of RAM per socket, with systems scaling to 16 TB or more. That’s enough to hold entire operational databases in memory.
• SMT-8 multi-threading gives you 8 hardware threads per core. A 15-core POWER10 chip provides 120 threads — all with independent execution pipelines.
• Memory bandwidth on POWER10 is 409 GB/s per socket with Open Memory Interface (OMI), dramatically more than comparable x86 platforms.
• Hardware reliability with 99.9999% uptime, Live Partition Mobility, and micro-partitioning means your in-memory cluster can run continuously without planned outages.

For Apache Ignite specifically, there’s another advantage: Java runs exceptionally well on Power. OpenJDK has had native ppc64le and AIX support since 2014, with both IBM and SAP contributing optimizations. IBM’s Semeru Runtime (built on Eclipse OpenJ9) is specifically tuned for Power hardware, with large page support, NUMA awareness, and JIT compiler optimizations that take advantage of Power ISA instructions.

In-memory computing on POWER isn’t just viable — it’s arguably the platform’s ideal workload. You have the RAM, the cores, the bandwidth, and the JVM quality to make it sing.

The IBM Connection: GridGain Already Knows Mainframes

This isn’t GridGain’s first dance with IBM. In 2019, GridGain released GridGain for z/OS — an optimized version of the platform for IBM’s mainframe operating system, running on zIIPs (z Integrated Information Processors). Major banks and insurance companies have been running trials with it.

IBM itself has presented at GridGain’s Ignite Summit about how they use Apache Ignite for core application modernization — specifically, an event-driven “Digital Core” pattern that uses Ignite as the speed layer for unlocking data trapped in legacy systems of record.

The message is clear: IBM and GridGain already have a working relationship at the enterprise level. Extending that to IBM Power — for the thousands of organizations running AIX and Linux on Power — is a natural next step.

LibrePower: Bringing GridGain to the Power Ecosystem

LibrePower is a community-driven project that brings modern open-source tools to IBM Power — across AIX, IBM i, and Linux on Power (ppc64le). The project maintains a curated package repository with tools that have been compiled, patched, and tested specifically for IBM Power.

The GridGain / Apache Ignite package for Power is available in the LibrePower GitLab repository, with build scripts, configuration guides, and documentation tailored to the Power environment.

On Linux on Power (ppc64le)

Apache Ignite is a Java application, which means it runs anywhere a JVM runs — and OpenJDK on ppc64le is mature and well-optimized. To get started:

# Download Apache Ignite
curl -O https://dlcdn.apache.org/ignite/2.16.0/apache-ignite-2.16.0-bin.zip
unzip apache-ignite-2.16.0-bin.zip
cd apache-ignite-2.16.0-bin

# Start a node
./bin/ignite.sh

For production deployments, you’ll want to configure persistence, cluster discovery, and memory regions:

<bean class="org.apache.ignite.configuration.IgniteConfiguration">
    <property name="dataStorageConfiguration">
        <bean class="org.apache.ignite.configuration.DataStorageConfiguration">
            <property name="defaultDataRegionConfiguration">
                <bean class="org.apache.ignite.configuration.DataRegionConfiguration">
                    <property name="maxSize" value="#{4L * 1024 * 1024 * 1024}"/>
                    <property name="persistenceEnabled" value="true"/>
                </bean>
            </property>
        </bean>
    </property>
</bean>

On AIX

AIX has had robust Java support for decades — IBM’s own JDK for AIX is one of the most mature JVM implementations in existence. Apache Ignite runs on the AIX JVM with the standard Java NIO and networking stack.

Check the LibrePower GridGain page for AIX-specific installation notes and any patches needed for optimal performance.

Docker on Power

If you’re running containers on ppc64le, the Ignite Docker image supports multi-architecture builds:

docker run -d \
    -p 10800:10800 \
    -p 47100:47100 \
    -p 47500:47500 \
    apacheignite/ignite

Real-World Use Cases on IBM Power

1. Accelerating DB2 and Oracle Workloads

The most common pattern: deploy an Ignite cluster between your application layer and your existing DB2 or Oracle database. Ignite caches hot data in RAM across the cluster and handles all reads and writes, while keeping the underlying database synchronized.

Your application code barely changes — just swap the JDBC connection string. But query performance improves by orders of magnitude, and your database server’s CPU utilization drops dramatically.

This is particularly powerful on Power, where you might be running DB2 on the same physical machine. You can allocate LPARs for the Ignite cluster that share the same high-speed interconnect, eliminating network latency entirely.

2. Real-Time Risk Analytics for Financial Services

Banks and insurance companies on IBM Power are already using GridGain for real-time risk calculations. The pattern: stream market data into the Ignite cluster, execute risk models as distributed compute tasks collocated with the data, and produce real-time P&L and VaR numbers.

On Power hardware with 4+ TB of RAM per node, you can hold your entire portfolio in memory. SMT-8 gives you the parallel compute capacity to run Monte Carlo simulations across thousands of scenarios simultaneously.

3. Mainframe Offload and Modernization

Many organizations want to reduce mainframe costs but can’t afford a “rip and replace” approach. GridGain on Power provides a middle path: move the speed layer off the mainframe while keeping the system of record where it is.

The pattern:

• Mainframe remains the authoritative data source
• GridGain on Power provides in-memory speed for reads and real-time analytics
• Change Data Capture (CDC) keeps the in-memory layer synchronized
• Applications gradually migrate to the GridGain-backed APIs

This is essentially the “Digital Core” pattern that IBM itself advocates, deployed on Power hardware where it can take advantage of the platform’s enterprise features.

4. IoT and Streaming on the Edge

For industrial organizations running Power at the edge (utilities, manufacturing, telecom), Ignite’s streaming capabilities let you ingest millions of events per second, apply business rules in real time, and trigger actions based on continuous queries.

Combine this with Power’s hardware reliability (no planned downtime for firmware updates, live partition mobility), and you have an edge computing platform that doesn’t need a maintenance window.

GridGain vs. Redis vs. Hazelcast: A Quick Comparison

Feature	GridGain/Ignite	Redis	Hazelcast
Distributed SQL (JOINs)	Full ANSI-99 SQL	Limited (RedisSearch)	Limited
ACID transactions	Full support	Limited	Full support
Persistence	Native + third-party	AOF/RDB snapshots	Hot restart
Collocated compute	Yes (Java/.NET/C++)	Lua scripting	Yes (Java)
ML/AI integration	Built-in framework	Separate (RedisAI)	Jet pipelines
IBM z/OS support	Yes (GridGain)	No	No
Multi-language	Java, C++, .NET, Python, Node.js	Most languages	Java, Python, .NET, Go, C++
Open source	Apache Ignite (Apache 2.0)	Redis (source-available)	Hazelcast Platform (Apache 2.0)
Enterprise edition	GridGain	Redis Enterprise	Hazelcast Enterprise

For Power environments specifically, GridGain/Ignite’s deep Java roots and IBM relationship give it a significant edge. The fact that GridGain already runs on z/OS demonstrates their commitment to the IBM ecosystem.

Tuning Ignite for IBM Power

A few Power-specific optimizations that make a real difference:

JVM Configuration

# Use large pages (Power supports 16MB and 16GB pages)
-XX:+UseLargePages -XX:LargePageSizeInBytes=16m

# Tune GC for large heaps
-XX:+UseG1GC -XX:MaxGCPauseMillis=200

# NUMA-aware allocation (critical for multi-socket Power)
-XX:+UseNUMA

# Off-heap memory (Ignite manages this separately from JVM heap)
# Allocate most RAM to off-heap, keep JVM heap modest
-Xmx4g -Xms4g

System Configuration

On AIX:

# Enable large pages
vmo -o lgpg_regions=256 -o lgpg_size=16777216

# Tune network buffers for cluster communication
no -o tcp_sendspace=262144
no -o tcp_recvspace=262144
no -o sb_max=1048576

On Linux on Power:

# Enable huge pages
echo 1024 > /proc/sys/vm/nr_hugepages

# Disable transparent huge pages (Ignite manages its own memory)
echo never > /sys/kernel/mm/transparent_hugepage/enabled

# Tune network
sysctl -w net.core.rmem_max=16777216
sysctl -w net.core.wmem_max=16777216

Ignite Configuration for Power

<!-- Leverage Power's memory bandwidth with larger page sizes -->
<property name="dataStorageConfiguration">
    <bean class="org.apache.ignite.configuration.DataStorageConfiguration">
        <property name="pageSize" value="#{8 * 1024}"/>
        <property name="defaultDataRegionConfiguration">
            <bean class="org.apache.ignite.configuration.DataRegionConfiguration">
                <property name="name" value="Default_Region"/>
                <!-- Use most of available RAM for in-memory storage -->
                <property name="maxSize" value="#{100L * 1024 * 1024 * 1024}"/>
                <property name="persistenceEnabled" value="true"/>
            </bean>
        </property>
    </bean>
</property>

Why This Matters

In-memory computing is not new technology. But deploying it on hardware that was designed for massive memory workloads — and doing so with the ease that open-source tooling should provide — has been harder than it should be on IBM Power.

GridGain and Apache Ignite represent exactly the kind of enterprise-grade, Java-based, distributed platform that Power systems excel at running. The combination of Power’s hardware capabilities with Ignite’s software architecture is genuinely compelling: terabytes of in-memory data, hundreds of threads for parallel processing, and hardware reliability that keeps it all running.

LibrePower’s role is to smooth the edges — providing tested packages, Power-specific configuration guides, and community support for anyone who wants to run this stack on their Power infrastructure.

Get Involved

• Try it: Install Apache Ignite from the LibrePower repository and run your first cluster
• Report issues: Found something Power-specific? Open an issue on GitLab
• Request packages: Need a specific version or configuration? Let us know
• Subscribe: Join the LibrePower newsletter for release announcements and technical articles
• Contribute: PRs welcome — whether it’s code, documentation, or benchmark results on your Power hardware

Useful Links

• GridGain Official Website
• Apache Ignite Documentation
• Apache Ignite on GitHub
• GridGain Documentation
• GridGain for z/OS Announcement
• IBM on Apache Ignite for Application Modernization
• LibrePower Website
• LibrePower AIX Repository
• LibrePower GitLab — GridGain Package
• OpenJDK PowerPC/AIX Port
• OpenPOWER Foundation

---

LibrePower is a community-driven open-source project building modern tools for the IBM Power ecosystem — AIX, IBM i, and Linux on Power (ppc64le).