Features & Benefits
Features and Benefits
The ScaleOut StateServer® product line is designed with a central goal in mind: offer the best and easiest to use products on the market by using breakthrough technology. As a result, our products are packed with powerful capabilities that distinguish ScaleOut Software as a leader in distributed data grid products. Please take a moment to look over the following features and benefits. Also, you can read more about what's new in our latest release here.
Performance
Fast Response Time
SOSS incorporates several internal mechanisms that automatically accelerate access requests and minimize response times. ScaleOut StateServer can deliver read access times which are very close to the performance of "in process" memory-based storage and significantly faster than access times for "out of process" stores such as database servers and file systems.
Linear Scalability
SOSS automatically scales its throughput as servers are added to the server farm or compute grid to handle additional client load. This enables SOSS to handle very large client loads, and it keeps response times fast under all loads.
Architecture
Fully Peer-to-Peer
To ensure maximum scalability, SOSS's architecture uses a symmetric, peer-to-peer design. By avoiding the use of "master" nodes, common files or databases for configuration information, this architecture scales seamlessly without bottlenecks and eliminates single points of control or failure.
Self Organizing, Fully Integrated, Easy to Use
SOSS was designed from the ground up to eliminate complexity and keep management costs to a minimum. SOSS self-organizes the distributed data grid 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, SOSS automatically load-balances objects across the grid, detects when servers are added or removed, and automatically rebalances object load after membership changes are made.
Auto Detect/Recovery with High Availability
If a server or network failure occurs, SOSS detects the outage and removes the affected server from the distributed data grid. Because SOSS automatically stores replicas for all grid objects, no data is lost. To "self-heal" the distributed data grid, SOSS creates new object replicas as necessary to maintain high availability for object data, and it automatically rebalances objects across the remaining servers to ensure maximum access performance.
Scalable, Highly Available "Everything"
SOSS's architecture is designed to transparently scale all grid operations and complete them with high availability. In addition to linear performance scaling for accessing grid objects, all other features such as distributed locking, event processing, load-balancing, geographic replication, and backup/restore are implemented within a common architecture so that they are both scalable and highly available.
Intelligent Remote Clients
SOSS's distributed data grid can be accessed by clients running on remote systems. Remote clients optimize access performance by maintaining knowledge of grid membership and object placement. This ensures that access requests are delivered to the grid servers which can most quickly respond with authoritative data.
Geographic Replication
Using ScaleOut GeoServer™, stored objects automatically can be replicated between SOSS distributed data grids running on server farms at different sites. This enables multiple data centers to share fast-changing workloads and stay fully protected against site-wide failures. ScaleOut GeoServer is designed to transparently scale its replication bandwidth as servers are added to the distributed data grid and to maintain high availability after server failures.
Multi-Platform Support
SOSS was designed from the ground up to deliver native performance on both Unix-based and Windows operating systems. Servers and client systems running Linux, Open Solaris, and Windows can be mixed within the same distributed data grid. Also, a mix of 32-bit and 64-bit clients and servers can be used within the same grid.
Distributed Caching Features
Object Storage and Load Balancing
ScaleOut StateServer stores data objects as serialized data accessed by a 256-bit key value and partitioned into name spaces. Objects are dynamically balanced across grid servers to eliminate "hot spots." Rebalancing is automatic at all times, including when servers are added, removed, or fail.
Client-side ("Near") Caching
SOSS automatically implements an internal cache of recently accessed objects within the memory of client applications. This client cache operates transparently to client applications and speeds up repeated reads to nearly in-process access times. SOSS automatically maintains the coherency of all client caches with the distributed data grid.
Storage APIs
ScaleOut StateServer includes comprehensive APIs for accessing the distributed data grid. APIs allow developers to easily organize and manage groups of cached objects as collections within a single name space. APIs are provided for Java, Microsoft .NET languages, and C/C++.
Distributed Locking
SOSS integrates 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 within a name space.
Object Timeouts and Dependencies
SOSS provides a rich set of mechanisms for expiring cached objects. Objects individually can be expired based on fixed or sliding timeouts, and they can be expired in groups based on dependency relationships.
Scalable Event Handling
Client applications can be asynchronously notified of object expiration using a scalable and highly available event handling architecture. SOSS automatically load-balances event delivery across multiple client processes and resends events as necessary if a client process unexpectedly exits.
Bulk Insertion of Objects
SOSS APIs include a bulk-insert method for efficiently adding groups of objects into the distributed data grid with maximum throughput. This API enables the grid to be quickly loaded with application data.
Database Integration
Applications can easily integrate the distributed data grid with a backing store, such as a database server or file 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 managing slowly changing data.
Memory Management
SOSS controls the amount of memory consumed by the distributed data grid by evicting the least recently used objects after a settable memory threshold is reached. Event notifications are delivered to the client application when objects are evicted, and selected objects can be exempted from removal.
Custom Serialization
To keep application development as simple as possible, SOSS automatically uses the standard binary formatters for both Java and .NET applications. Users also can implement their own custom serializers to further optimize access performance or to add data encryption and compression.
Language Interoperability
Java, C/C++, and .NET objects can be stored within the same distributed cache, and parallel queries can select objects from multiple applications. Third party tools can be used to convert objects stored in different serialization formats as needed.
Transparent Session-State Storage
Web session-state objects can be transparently stored in SOSS on Windows ASP.NET Web farms using Microsoft's standard session-state provider interface. Configuration requires only a simple one-line change to the web.config file.
Multiple Application Support for .NET
SOSS automatically separates object and session-state storage for multiple .NET applications by using different application namespaces. Applications also can select the use of a common namespace so that objects can be shared.
NHibernate Support
SOSS can be used as a second-level cache provider for NHibernate.
Distributed Data Grid Features
Parallel Query
For maximum performance, ScaleOut StateServer performs fully parallel queries across all grid servers and employs patent-pending technology to ensure that query operations are both highly available and scalable. To avoid deserialization overhead, queries use deserialized metadata values assigned by applications to match objects in the grid.
Parallel Method Invocation (Map/Reduce)
ScaleOut StateServer Grid Computing Edition™ provides a powerful mechanism for analyzing grid data in parallel across all grid servers to deliver fast results. Based on the popular "map/reduce" programming model, SOSS 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 without moving objects between servers. The user-defined methods also are very simple to write because no special code is needed, and explicit grid accesses are avoided.
Object Browser
The ScaleOut StateServer Management Pack™ adds a unique graphical tool for analyzing and managing the contents of a distributed data grid. The ScaleOut StateServer Management Pack Object Browser lets users view cache contents, including both metadata and serialized data for individual Java and .NET objects, as well as deserialized data for .NET objects. The object browser also can perform management operations such as searching the grid and clearing objects.
Parallel Backup/Restore APIs
Another key management tool in the ScaleOut StateServer Management Pack is the Parallel Backup and Restore Utility. Using this utility, users can quickly backup or restore all or a selected portion of the distributed data grid to the file system. The utility's fully parallel architecture uses all grid servers to deliver the fastest possible data transfer rates. Backups can be made 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.
Management
GUI Management Console / Command-line Control Program
The ScaleOut Management Console is designed to simplify management operations while providing a comprehensive view of all servers within the distributed data grid. The management console can be used to remotely configure and control each grid server and to perform global management operations. Membership and status reporting provide instant notification of server failures or membership changes. SOSS also includes a command-line control program which can be used to perform all control operations within management scripts.
Remote Management
Using the ScaleOut Management Console, all servers and remote clients in a given SOSS distributed cache can be managed from any workstation which can remotely access the distributed data grid.
Automatic On-the-fly Adding/Removing of Servers
Grid servers can be added or removed at any time without interruption grid operations or loss of data. After membership changes, SOSS automatically rebalances objects stored on each grid server to ensure that all servers have a balanced share of the total load.
Performance Charting / Performance Counters
The ScaleOut Management Console includes real-time performance charting that graph key performance metrics for the distributed data grid 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.
