ScaleOut’s IMDG architecture uses a symmetric, peer-to-peer design. By avoiding the use of a “primary” node, common file share, or database for configuration information, this architecture scales seamlessly without bottlenecks and eliminates single points of control or failure.

ScaleOut’s IMDG automatically scales its throughput as servers are added to the server farm, compute grid, or cloud to handle additional client load. This enables ScaleOut to handle very large workloads, and it keeps response times fast under all loads.

ScaleOut’s IMDG self-organizes by automatically discovering available servers and adding them to the grid. No configuration steps are required to set up grid membership, failover mechanisms, data partitioning, or client-side caching. Once running, ScaleOut automatically load-balances objects across the grid, detects when servers are added or removed, and automatically rebalances object load after membership changes are made.

If a server or network failure occurs, the IMDG detects the outage and removes the affected server from the grid’s membership. Because ScaleOut automatically stores replicas for all grid objects, no data is lost. The IMDG self-heals by creating new object replicas as necessary to maintain high availability for stored data, and it automatically rebalances objects across the remaining servers to ensure maximum access performance.

ScaleOut’s architecture is designed to transparently scale all grid operations and make them highly available. In addition to linear performance scaling for accessing grid objects, all other features such as distributed locking, event processing, load-balancing, geographic replication, parallel computation, and backup/restore are implemented within a common architecture so that they are both scalable and highly available.

By using a fast, C-based implementation of its server architecture, ScaleOut delivers fast, predictable performance on both Linux-based and Windows operating systems. Servers and client systems running 64-bit Linux and Windows can be mixed within the same data grid. Also, a mix of 32-bit and 64-bit clients can be used within the same grid.

ScaleOut is available in public clouds. Cloud versions offer all the functionality of on-premise versions. ScaleOut’s management tools make cloud deployment easy and fast. With ScaleOut GeoServer®’s global data integration, on-premise and cloud-based data grids can be combined to operate as a single, virtual data grid spanning multiple data centers.

Integrates open-source Redis code into ScaleOut’s patented clustering architecture to provide automated cluster management and fully consistent data storage. The integration performs command processing for all popular Redis data structures (including strings, lists, sets, hashes, sorted sets, streams, hyperloglog, geospatial) and implements transactions and pubsub. Clients access the IMDG using the Redis client/server protocol.

ScaleOut’s IMDG is designed to handle live, fast-changing, operational data. Using its comprehensive APIs (see below), applications can quickly create, read, update, delete, query, and analyze objects in the IMDG to meet the needs of real-time applications. It can also store Redis data structures.

The IMDG stores native data objects as serialized data, accessed by a string-based or 256-bit numerical key value and partitioned into namespaces. It stores Redis data structures in a separate namespace alongside native objects. Objects are dynamically load-balanced across grid servers to maximize performance and eliminate “hot spots.” Rebalancing is automatic at all times, including when servers are added, removed, or fail.

The IMDG includes a fully coherent cache of recently accessed objects within the memory of client applications. This cache operates transparently to client applications and speeds up access times for repeated reads to nearly in-process latency by avoiding network transfer and deserialization delays. ScaleOut automatically maintains the coherency of all client caches with respect to changes to data hosted in the grid.

ScaleOut lets applications control the amount of memory consumed by the data grid by evicting the least recently used objects after a settable memory threshold is reached. Event notifications are delivered to the application when objects are evicted, and selected objects can be exempted from removal.

ScaleOut provides two mechanisms for authorizing access to name spaces within the IMDG. A preconfigured mechanism checks the application’s current login name against a list of authorized login names; this mechanism also authorizes either read/write access or read-only access. In addition, an extensible authorization policy, which lets an application connect to an external authorization server, can be implemented using ScaleOut’s APIs.

Web session-state objects can be transparently stored in ScaleOut’s IMDG on Linux for Java J2EE Servlets and on Windows ASP.NET Web farms using Microsoft’s standard session-state provider model. Configuration requires only a simple one-line change to the application’s web.config file. If session-state storage is your only requirement, check out ScaleOut SessionServer.

ScaleOut’s ASP.NET Output Cache Provider enables ScaleOut StateServer’s IMDG to store ASP.NET output cache data when using ASP.NET 4.0 or higher. Optional settings allow sharing output cache entries between multiple ASP.NET applications, specifying timeout values, defining exception handling, and more.

ScaleOut integrates both optimistic and pessimistic distributed locking into its storage APIs to enable applications to coordinate access to cached objects. Distributed locking can be used for individual objects or enabled for automatic use across a name space of objects.

The Named Cache API is the primary way to store native objects in the in-memory data grid. This API lets developers  easily organize and manage groups of objects as collections within a single name space. It is designed to handle complex objects and provide rich functionality, such as property-oriented query, dependency relationships, timeouts, distributed locking, backing store and remote store access, bulk insert, and more. APIs are provided for Java, C#, C/C++, and REST.

The ScaleOut Client API provides the latest .NET API with support for both .NET Standard 2.0 and .NET Framework 4.6.2. This API offers new features, such as support for async operations and accessing multiple IMDGs, and a new model for creating invocation grids.

Data access and query APIs that use .NET’s async/await semantics for asynchronous programming. Enables .NET developers to integrate grid-access and query APIs into applications which make use of .NET’s asynchronous programming model and thereby take full advantage of multicore processing power. Significantly increases performance for many applications and integrates ScaleOut’s APIs with the latest .NET architectural features.

The Named Map API is designed to efficiently store large populations of very small objects, minimize the amount of metadata associated with each object, and enable fast, pipelined analysis (such as MapReduce). Objects stored in a named map can be queried in parallel and can be cached in the client using user-adjustable coherency policies. For fast loading and updating of key/value data, the Named Map provides bulk insert and bulk update functions. The Java version of the Named Map API implements Java’s Concurrent Map semantics. The .NET version of the Named Map API implements .NET’s ConcurrentDictionary with extensions for parallel query and data-parallel analysis.

ScaleOut APIs include a bulk-insert method for efficiently adding groups of objects into the data grid with maximum throughput. This API uses a heavily multithreaded implementation to enable the grid to be quickly loaded with application data.

To keep application development as simple as possible, ScaleOut automatically uses the default serializers for both Java and .NET applications. Users also can implement their own custom or third-party serializers to further optimize access performance or to add data encryption and compression.

ScaleOut provides a rich set of mechanisms for expiring cached objects. Objects can be expired based on fixed or sliding timeouts.

To help manage the lifetimes of object groups, objects can have hierarchical dependency relationships with other objects in the IMDG. If an object is configured to be dependent on a parent object, it will automatically be removed from the store when its parent is updated or removed from the IMDG.

Client applications can be asynchronously notified of object expiration  or grid updates using a scalable and highly available event handling architecture. To maximize scalability, ScaleOut’s IMDG automatically load-balances event delivery across multiple client processes and resends events as necessary if a client process unexpectedly exits.

Applications can easily integrate the data grid with a backing store, such as a database server, file system, or publish/subscribe messaging system. A rich set of capabilities let the user choose the appropriate policy for keeping the grid in sync with a backing store. Two synchronous access policies (read-through and write-through) enable tight integration, and two asynchronous access policies (periodic refresh-ahead and write-behind) provide an efficient alternative for signaling changes to grid-based data.

A source-code compatible, drop-in replacement for Microsoft’s Windows Server AppFabric (WSAF) Caching APIs. Allows enterprises using AppFabric Caching to preserve their legacy application code and switch seamlessly to ScaleOut StateServer without making code changes. Includes comprehensive PowerShell cmdlets to manage the distributed cache.

ScaleOut can be used as a second-level cache provider for NHibernate.

This ScaleOut Cache API supports storage of Java objects in ScaleOut StateServer’s IMDG using the Javax caching paradigm. This library is open source and is available on GitHub.

This Java library enables the use of ScaleOut StateServer’s IMDG for serving Java HttpSessions to Spring applications. The library is open source and is available on GitHub.

ScaleOut’s IMDG uses open-source Redis code to perform command processing for all popular Redis data structures (including strings, lists, sets, hashes, sorted sets, streams, hyperloglog, and geospatial) and to implement transactions and pubsub. Redis clients access the IMDG using the standard Redis client/server protocol.

For maximum query performance, ScaleOut performs fully parallel queries across all grid servers and employs patent-pending technology to ensure that query operations are both highly available and scalable. Java applications can structure property-based queries using composable filter methods with logical and comparison operators. A full implementation of .NET’s Language Integrated Query (LINQ) enables C# applications to structure queries using SQL-like semantics. To minimize lookup times, ScaleOut StateServer’s client libraries automatically extract selected properties, and grid servers store them as indexed, deserialized data during object updates. Parallel query is supported for both Named Cache and Named Map APIs for ScaleOut StateServer and ScaleOut Compute Server, and for the Named Map API on ScaleOut hServer.

Invoke filter methods extend property-based query APIs for both Java and C# to enable applications to run data-parallel methods which can perform advanced analysis to select objects within a parallel query. Invokable “filter” methods eliminate the restrictions imposed by standard query techniques and harness the power of data-parallel computation to implement much deeper query analysis. In C#, invoke filters are integrated into Microsoft LINQ as extension methods which simplify program structure.

Distributed merging accelerates the delivery of analysis results to a requesting client. This mechanism spans the IMDG and rapidly combines the results of a parallel analysis performed on all grid servers and makes use of a specified merge algorithm supplied by the application.

SimpleMR APIs implement highly efficient MapReduce semantics that take full advantage of ScaleOut’s data-parallel computation. These APIs are integrated directly into the in-memory compute engine and in-memory data grid to deliver extremely fast execution times. These APIs are available for both Java and C#.

ScaleOut StateServer Pro provides a powerful API for analyzing grid-based data in parallel across all grid servers to deliver fast results. Based on the standard, data-parallel programming model developed for high performance computing, ScaleOut StateServer Pro executes a user-defined analysis method in parallel on a queried set of objects and then combines the results using a user-defined merge method. Called “parallel method invocation,” this technique automatically harnesses the computing power of the grid’s multiple servers, processors, and cores and minimizes data motion between grid servers. The user-defined methods also are simple to write because no special code is needed, and data is automatically retrieved from the IMDG for analysis.

ScaleOut StateServer Pro also provides a powerful .NET API for data-parallel computing modeled after the Parallel.ForEach API in the .NET Task Parallel Library. Instead of just operating on a local, in-process data collection, this operator transparently runs in parallel across a distributed, in-memory data grid to handle much larger data sets than otherwise possible. This API delivers fast, scalable performance and minimizes garbage collection. Integration with LINQ query allows selected data to be processed. ScaleOut’s in-memory compute engine ships assemblies containing application logic to all servers.

To complement parallel method invocation, ScaleOut StateServer Pro includes the capability to analyze specific data objects within the IMDG. Called “single method invocation,” this mechanism lets C# and Java applications invoke user-defined methods on specified objects, supply parameters to the invocation, and efficiently receive the method’s analysis results. SMI also can be used to implement analyses of column-oriented data with minimum data motion.

ScaleOut’s integrated IMDG and streaming engine enable stateful stream-processing using the powerful digital twin model. Benefits include the ability to simultaneously track large numbers of live data sources, automatic event correlation by data source using IMDG objects that host digital twins, simplified application design, and deeper introspection on streaming data.

ScaleOut offers a cloud-based streaming service for digital twin models hosted on Microsoft Azure and integrated with the Azure IoT ecosystem of components. It also offers the option to host digital twin models on-premises. Integration with Azure Digital Twins
ScaleOut’s Azure Digital Twins integration combines ScaleOut’s in-memory computing platform with the Azure Digital Twins cloud service to provide fast message processing and stateful real-time analytics for Azure digital twin models with many data sourcesThis integration opens up new use cases for Azure Digital Twins.

Digital twin models can integrate machine learning features from Microsoft’s machine learning library called ML.NET.. Using the ScaleOut Model Development Tool, users can select, train, evaluate, deploy, and test ML algorithms that separately track and analyze telemetry for each digital twin.

Digital twin models can be implemented using business tules with simple IF THEN and DO statements when more complex logic is not needed. Rules can also extend the automatic analysis performed by ML. These features make it possible for non-programmers to build powerful digital twin models.

ScaleOut’s digital twin execution platform continuously aggregates data stored in digital twins and visualizes the results with user-defined charts and graphs. Aggregated results also can be exported to external visualization tools, such as Microsoft Power BI.

The platform’s UI lets users query state information held in digital twins and view the results in either a table or map. The map refreshes query results every few seconds to provide valuable insights about geospatial relationships and their dynamic changes.

Comprehensive Java and C# time-windowing libraries enable easy management of incoming events in time-ordered collections within digital twin models. APIs offer access to elements using windowed transformations and automatic, policy-driven eviction. These libraries are available on GitHub:
– Java
– C#

Easy integration with open-source Apache Kafka enables streaming events to be received from Kafka pipelines and messages to be sent to Kafka. Kafka partitioning can be used to automatically scale event handling and minimize network overhead within the IMDG.

ScaleOut StreamServer integrates an IMDG with a stream-processing engine to reduce event-processing latency, eliminate network bottlenecks when accessing in-memory state information, automatically scale throughput, and ensure high availability.

Applications can reduce event handling latency while scaling application throughput by using the popular ReactiveX library to dispatch events to associated IMDG objects.

With its graphical interface, the Windows-based ScaleOut Management Console is designed to simplify management operations while providing a comprehensive view of all servers within the data grid. The management console can be used to remotely configure and control each grid server and perform global management operations. Access by remote clients and access to remote stores can be configured and managed. Membership and status reporting provide instant notification of server failures or membership changes, and graphical tools chart the grid’s performance and identify hot spots in grid accesses. When the ScaleOut Management Pack option is licensed, the management console can be used to control parallel backup and restore operations. A Web-based management console also is available for use on Linux systems. Both the Windows and the Web-based consoles can be used to manage Windows and Linux deployments.

A command-line control program and scripting tool enables system administrators to perform all control operations and track the configuration and status of ScaleOut’s IMDG.

Developers and administrators can interact with ScaleOut StateServer’s IMDG using .NET’s PowerShell scripting environment on Windows systems. IT administrators familiar with .NET’s PowerShell can easily create scripts to automate deployment and management of an in-memory data grid. PowerShell cmdlets can perform all functions provided by the ScaleOut Management Console and command-line management tool.

Using the ScaleOut Management Console, Web-based console, and command-line control program, all grid servers can be managed from any workstation which has network access to the in-memory data grid.

A grid server can be added or removed at any time without interrupting grid operations or loss of data. After membership changes, the IMDG automatically rebalances objects stored on each grid server to redistribute the workload and data replicas.

The ScaleOut Management Console contains a visualization tool that provides a graphical picture of the grid’s status so that administrators can instantly determine the availability of stored data on a region-by-region basis. This tool instantly shows how access to data is affected by high request rates, dynamic load-balancing, and server outages.

The ScaleOut Management Console includes real-time performance charting that graphs key performance metrics for the IMDG on both a grid-wide and a per-server basis. This charting capability enables IT managers and developers to quickly pinpoint performance issues. These performance metrics are also available as performance counters displayed by the Perfmon utility on Microsoft Windows systems.

The ScaleOut Object Browser provides a graphical tool for analyzing and managing objects stored in the IMDG. The Object Browser lets users view IMDG data, including both metadata and serialized data for individual Java and .NET objects, as well as deserialized data for .NET objects. The Object Browser is highly useful as an aid to development by enabling developers to verify the contents of the IMDG. It also can perform management operations such as searching the grid and clearing objects.

Using the Parallel Backup and Restore Utility, users can quickly backup or restore all or a selected portion of the IMDG’s contents or a Redis database to the file system. The utility’s fully parallel architecture can make use of the file systems on all grid servers in parallel to deliver the fastest possible backup/restore times. Backups can be performed while the grid is active, enabling snapshots of the grid’s contents to be captured for later analysis. A graphical user interface integrated into the ScaleOut Management Console makes backups and restores easy to initiate and monitor.

Using ScaleOut GeoServer DR, updates to stored objects automatically can be replicated to in-memory data grids at up to eight remote sites. This enables multiple data centers to share fast-changing workloads and stay fully protected against site-wide failures. ScaleOut GeoServer DR employs all grid servers when replicating data to transparently scale its replication bandwidth as servers are added to the data grid and to maintain high availability after server failures.

The ScaleOut GeoServer option enables applications to transparently access stored objects hosted on remote ScaleOut in-memory data grids. ScaleOut GeoServer’s “pull access mode” allows objects to be shared across a wide area network of in-memory data grids as a single, virtual, globally accessible data grid. User definable coherency policies enable applications to minimize WAN accesses as needed. ScaleOut GeoServer also implements distributed locking and automatic object migration across multiple IMDGs to enable applications to globally synchronize access to data objects. Pull access mode optionally can be configured to use integrated data replication for disaster recovery.

The ISO 19770 standard assists with IT asset management in organizations incorporating the ISO/IEC 19770-2 for identifying software assets using software tags. ScaleOut Software’s Windows installer now incorporates an ISO 19770-2 software tag. Integrates with standardized software inventory tracking and management systems.