In-Memory Database™

A New Execution Platform for Enterprise Redis®* Users

  • Enable automatic cluster management and seamless scaling
  • Ensure reliable data storage with fully consistent updates
  • Eliminate shards to lower both licensing costs and TCO

Experience Automatic Cluster Management and Fully Consistent Data Storage

Watch our new animated video to see ScaleOut In-Memory Database in action!

Redis offers a compelling set of APIs that allow it to store complex data structures (like sorted sets) in addition to serialized objects. However, it has two big drawbacks for enterprise users: highly complex cluster management and weak (“eventual”) consistency for stored data.

To overcome these limitations, ScaleOut Software introduces a breakthrough new execution platform for Redis applications that integrates open-source Redis code into ScaleOut’s industry-leading, patented clustering architecture. ScaleOut In-Memory Database enables enterprise Redis users to now benefit from automated cluster management and fully consistent data storage that dramatically lower total cost of ownership (TCO). In addition, it uses multi-threaded execution to automatically take advantage of all processing cores.

ScaleOut In-Memory Database incorporates open-source Redis code that delivers native behavior and performance for all popular Redis data structures (including strings, lists, sets, hashes, sorted sets, streams, hyperloglog, and geospatial), transactions, pubsub, and the Redis client/server protocol. Applications also can access ScaleOut’s cutting-edge features, such as data-parallel execution, streaming analytics, and global, coherent data storage.

ScaleOut In-Memory Database runs on both Linux and Windows. Check out the full production release today. See how ScaleOut’s automated clustering saves the day in this new animated video.


It Runs Actual Redis Code!

ScaleOut In-Memory Database incorporates actual Redis open-source code (version 6.2.5) to implement its popular Redis data structures and pubsub. This ensures that Redis commands return identical results as an open-source Redis server. Clients connect to ScaleOut In-Memory Database exactly as they would to any Redis deployment using the same wire protocol.

No More Hashslots and Shards

ScaleOut’s powerful clustering architecture automates the management of hashslots so that you can seamlessly scale just by adding servers. Since ScaleOut’s service process runs on all available processing cores, you don’t have to deploy multiple “shards” per server to boost throughput and host replicated data. This lowers licensing costs and TCO.

Learn More

Automatic Cluster Management

Stop Tracking Hashlots and Manually Load-Balancing Redis Clusters

Developers need to focus on developing applications, and system administrators are too busy to track the intricacies of a distributed caching architecture, like hashslots, shards, and replicas. To maximize ease of use, especially during membership changes and network outages, ScaleOut In-Memory Database’s cluster architecture was designed to fully automate management.

Users just need to deploy one ScaleOut In-Memory Database service process on each server (“node”) in a cluster; ScaleOut In-Memory Database takes care of the rest. The service processes work together to manage all aspects of cluster operations, including hashslots. They automatically create a Redis database with all 16K Redis hashslots and distribute the hashslots across the cluster’s nodes to achieve optimal load-balancing. The service processes automatically migrate hashslots between nodes when servers are added or removed or after recovery from server failures. They also maintain replicas for all hashslots on different nodes to ensure that data is never lost if a server fails or suffers a network outage.

Redis clients can connect to any ScaleOut In-Memory Database server in a cluster using the standard RESP protocol. Most popular Redis client libraries then internally obtain the mapping of hashslots to servers using either the CLUSTER SLOTS or CLUSTER NODES commands and then direct Redis access requests to the appropriate ScaleOut server.

The following diagram shows Redis clients connecting to a ScaleOut In-Memory Database cluster:

Unlike when configuring open-source Redis clusters, you can start with one node and add more nodes as your throughput and availability demands grow. Most enterprise deployments will use at least two nodes to provide data replication and protect against server failures. Here’s an example of adding a node to a ScaleOut In-Memory Database cluster:


You just add one service process per node, and ScaleOut In-Memory Database takes care of the rest. There’s no need to create primary and replica shards and reconfigure existing shards, as would be needed in an open-source Redis cluster. Note how existing replica 2 has to be migrated to a different node to maintain a balanced workload when adding a node in a Redis cluster:

ScaleOut In-Memory Database hosts both primary and replica hashslots within its service process and handles all aspects of load-balancing when there are changes to the cluster’s membership:

For example, the following diagram shows how ScaleOut In-Memory Database automatically redistributes the hashslots across two servers when a second server is added to a single-server cluster:

For each hashslot, ScaleOut In-Memory Database maintains at least one replica on a separate node. For example, in the above diagram showing a two-node cluster, both nodes have copies of each other’s hashslots to ensure full redundancy. When additional servers are added, ScaleOut In-Memory Database automatically redistributes both the primary and replica hashslots to maintain both load-balance and redundancy.

ScaleOut In-Memory Database uses a coherent cluster membership with built-in, adaptive heart-beating that adjusts to the speed of the network. When it detects a missing server due to a failure or network outage, it automatically “self-heals” by creating a new cluster membership, promoting and duplicating replicas as needed, and rebalancing the workload on the surviving servers. It also detects and recovers from network subnetting (sometimes called a “split brain” configuration).

Fully Consistent Data Storage

Rely on Fully Consistent Updates to Enterprise Data

Distributed caches keep replicas for all stored objects to maintain high availability. If a server goes down or gets disconnected from the network, one or more other servers have a copy of the data and can step in to serve client requests. To make this work reliably, the distributed cache needs to keep all replicas of each stored object consistent after an update. Otherwise, a failure could occur and cause the latest updates to be permanently lost.

Redis clusters use an eventual consistency algorithm for updating stored objects. This approach is relatively simple and it allows for the maximum possible throughput. However, it is susceptible to data loss because it does not guarantee that all replicas are consistently updated.

To avoid this problem and ensure reliable data storage, ScaleOut In-Memory Database uses a patented quorum algorithm to implement fully consistent updates to stored objects using a sequential consistency algorithm.  (For applications that need to maximize throughput at the expense of data consistency, ScaleOut In-Memory Database can optionally be configured for eventual consistency.) When a server receives a Redis command, it executes this command on a quorum containing the primary hashslot and its replicas (one or two in the current implementation) prior to returning to the client. Redis transactions are processed in the same manner.

To illustrate the importance of fully consistent updates, the following diagram shows a Redis command updating a primary and replica copy of a stored object using Redis’s eventual consistency algorithm:

If the primary server (or the network link to its replica server) fails while sending the update to its replica but after it replies to the client, the update will be lost, and the client will be unaware of the problem.

ScaleOut In-Memory Database avoids this problem by awaiting completion of updates to a quorum (i.e., majority) of copies of the data prior to replying to the client. This ensures that updates survive the failure of any server, and the cluster reliably stores the data. The following diagram shows how this algorithm awaits a response from the replica prior to responding to the client when one replica is used:

ScaleOut’s patented quorum algorithm for updating replicas was designed to deliver the best combination of data consistency and throughput to meet the needs of enterprise applications. It ensures that updates to mission-critical data are always reliably stored while providing high throughput using quorum-based processing.

Automatic Sharding for High Performance and Lower TCO

Eliminate Shards to Boost Throughput and Lower TCO

Redis uses a single-threaded, event-loop software architecture to execute commands. While this approach eliminates locking, it constrains throughput to that provided by a single processing core. To overcome this limitation and enable the use of multiple cores per server, Redis lets system administrators deploy multiple “shards” (service processes) per node and distribute the hashslots across them. This approach can be complex to manage and can increase costs.

ScaleOut In-Memory Database uses multi-threaded execution for Redis commands to automatically take advantage of all processing cores and eliminate the need for multiple primary shards on each server. As commands flow in to each service process for different hashslots, ScaleOut In-Memory Database executes them independently and in parallel on all available processing cores. ScaleOut’s multi-threaded architecture delivers the maximum possible throughput combined with reliable data storage using a single, self-managed service process on each node.

The following diagram shows the difference between Redis’s event-loop design and ScaleOut’s multi-threaded design:

ScaleOut In-Memory Database’s highly integrated design enables each service process to automatically perform all clustering functions while delivering multi-threaded speedup for Redis commands. Designed for enterprise users, it enables system administrators to minimize management costs and lower TCO.



Try ScaleOut for free

Use the power of in-memory computing in minutes on Windows or Linux.

Try for Free

Not ready to download?