Multi-Cloud deployment becomes the standard with every mission critical system. Financial services, IoT , Telecommunications , Logistics , Gaming , E-commerce, Healthcare and others moving into a deployment architecture that involves multi-geo deployment across on-premise data center and one or more cloud platforms. In this post we will take a closer look at multi-cloud caching as a service with XAP Memcached vs. AWS ElastiCache Benchmark.

Caching in the Cloud Era

A critical ingredient of any Multi-Cloud deployment is its caching fabric. This dynamic and elastic layer stores both static data and transactional data. Its ability to deliver fast response time, while ensuring reliability, consistency, high-availability & durability is critical. This allows the application to deliver deterministic blazing fast user response time even on peak load ensuring happy customers. A classic caching fabric usually expose a standard Memcached API, allowing the application to access items using their key.

A typical system that requires basic caching functionality will use Memcached fabric to front-end a database avoiding the need to perform database access for any application read operation. It will first try to access the caching fabric looking for the desired item based on its key within the cache, if cannot be found , a database search performed , once read by the application the cache , a write operation performed to store the item(s) for a later reuse. This makes the caching read , update and write operations speed and reliability extremely important.  

For more advanced scenarios such as compute grid and database full offload , an In-Memory Data-Grid will be used as it will be the system of record. This is XAP sweet spot.

GigaSpaces XAP Memcached API 

GigaSpaces XAP expose among its various APIs a robust and mature Memcached API allowing users to deploy scalable, cost effective, multi-cloud in-memory data-grid that support the classic key/value data access API. This allows any application to have a true no-lock in caching fabric that is unbound to the specific cloud the application deployed into.  

GigaSpaces XAP support both read-mostly and write-read scenarios, on-heap and off-heap data storage , and native persistence optimized for SSD file system delivering vast caching capacity. XAP comes with rich interactive monitoring , alerting and telemetry that allows you to inspect system behavior in real-time while also getting historic reports on system behavior.

XAP WAN Replication Gateway allows users to deploy any type of multi-geo architecture (multi-master , master-slave) where on-prem data center running master caching cluster that is seeded by feeds running within the enterprise data center , while remote caching cluster(s) (slaves) running in one or more public clouds such as AWS , Azure , etc. This allows the applications running on the cloud having their data near-by delivering excellent performance avoiding feeds running on the cloud. XAP WAN Gateway support selective replication , where each remote each replica may be getting specific desired items based on some business oriented logic. Data compression and encryption is also available for maximum security and fast replication. XAP support multi-cloud deployment via Cloudify.

XAP Memcached vs. AWS ElastiCache Benchmark

XAP Memcached vs. AWS ElastiCache Benchmark Specification

The benchmark conducted comparing GigaSpaces XAP memcached API vs AWS ElastiCache where both running in identical configuration on exact compute node setup. The benchmark testing all typical Memcached operations including set , get, cas , add , replace , append , prepend , incr , decr with 1,2,4 & 8 clients.

The payload used is 5K. The results been calculated based on 100,000 calls per client. XAP had a single instance running on a m3.large AWS instance , AWS ElastiCache was running on cache.m3.large instance both with 6 GB max capacity. The Client in both benchmarks was mcperf running on AWS m4.2xlarge instance.


DOWNLOAD XAP 12.0.1 NOW


XAP Memcached vs. AWS ElastiCache Results

The results illustrating XAP superiority with every operation. In fact , while increasing the concurrency level with increased load , XAP behaves much better than AWS ElastiCache.

Overall XAP delivers 150% to 350% better performance than ElastiCache.

On the very basic fundamental operations – with set operation XAP delivering 174% better performance with a single client than ElastiCache (3.9 ops/sec vs 2.2K ops/sec) where with 8 clients XAP delivering 260% better performance (21K ops/sec vs 8K ops/sec).

With the get operation XAP delivering 173% better performance with a single client than ElastiCache (3.9K ops/sec vs 2.2 ops/sec) where with 8 clients XAP delivering 374% better performance (24K ops/sec vs 7K ops/sec). As we can see XAP scales also much better both with set and get operations.

Such a difference will make every application twice faster on average when using XAP while compared to ElasticCache. In fact the more load on the system XAP will be delivering better performance.

XAP Memcached vs. AWS ElastiCache Benchmark results

XAP Memcached vs. AWS ElastiCache Cost Difference

These results proves that in terms of cloud usage costs , since XAP is much faster , your AWS monthly bill can be lower when compared to ElastiCache. You may use a cheaper instance type with XAP while getting an excellent performance when compared to ElastiCache. For a typical system running a XAP cluster across 12 instances of 8XL type , XAP can save $100K on yearly bases in terms of AWS bill.

The full results:

XAP Memcached vs. AWS ElastiCache Benchmark full results

The Benchmark Script

The benchmark script expects GNU parallel to be present. GNU parallel can be built and installed in /usr/local/bin with the following commands:

  • XAP can be started in the usual way:

$ gs-agent.sh

  • XAP Memcached can be started using the following command:

$ gs-memcached.sh

Test Script

The script (mcperftest.sh) used for testing is as follows:

  runmcperf() {
         job_no=$1
         echo “mcperf –server=$SERVER –num-conns=1 –num-calls=$NUM_CALLS –method=$METHOD –sizes=d$PAYLOAD_SIZE 2>$SERVER-c$NUM_CONNS-$METHOD-$job_no.txt”
         mcperf –server=$SERVER –num-conns=1 –num-calls=$NUM_CALLS –method=$METHOD –sizes=d$PAYLOAD_SIZE 2>$SERVER-c$NUM_CONNS-$METHOD-$job_no.txt
   }

   export -f runmcperf

   SERVER=$1
   NUM_CALLS=$2
   PAYLOAD_SIZE=$3
   NUM_CONNS=$4
   METHOD=$5

   x=1
   JOB_ARG=””
   while [ $x -le $NUM_CONNS ]
   do
         JOB_ARG=”$JOB_ARG $x”
         x=$(( $x + 1 ))
   done
   export SERVER NUM_CONNS NUM_CALLS PAYLOAD_SIZE METHOD JOB_ARG

   echo parallel -j$NUM_CONNS runmcperf ::: $JOB_ARG
   parallel -j$NUM_CONNS runmcperf ::: $JOB_ARG

   grep -H “Request rate” $SERVER-c$NUM_CONNS-$METHOD*.txt

   awk -v method=$METHOD ‘
         $0 ~ /^.*Request rate.*$/ {
               numConn++;
               total += $3;
         }
         END {
               printf “%s operation: total throughput for %d connections = %d requests/second\n”, method, numConn, total;
         }
   ‘ $SERVER-c$NUM_CONNS-$METHOD*.txt

An example usage:

mcperftest.sh 10.8.1.215 100000 5120 1 set

Where Can I Download XAP 12.0.1?

Want to know more about XAP 12.0.1? Reach out via e-mail or meet us in person at one of our upcoming event in Spark Summit in Brussels. We’d also love for you to join our 451 Group Webinar on October 5th. 

Multi-Cloud Caching as a Service: XAP Memcached vs. AWS ElastiCache Benchmark
Shay Hassidim
Deputy CTO @ GigaSpaces
Shay joined GigaSpaces in 2003, and has more than 20 years of experience in the software industry. Shay is part of the product leadership team and oversees the technical activities of the US operations, serving as Deputy CTO Distinguished engineer, escorting the pre-sale and post-sale activities.