The GigaSpaces team is happy to announce the availability of GigaSpaces XAP R7.0. I am proud an excited to share with you few details about the release. As always you can download the product and give it a try from here.
GigaSpaces XAP R7.0 is the only platform available which was designed from the ground up to support extremely scalable applications ranging from transactional systems through large scale web applications to SaaS delivered services. By combining a state of the art in-memory data grid, the Jetty web container, and a grid-based business logic execution framework, it forms a single, easy to use platform on which you can build and run your application. Through the use of SLA driven deployment, it enables applications to grow and shrink dynamically based on real time application workloads.
- Much faster performance – dramatic performance and scalability improvements which increases utilization on multi-core machines by up to 300%.
- New monitoring and administration tools – new APIs which enable full control of the runtime environment using Groovy and Java, new SLAs for improved manageability of large clusters, and a revamped Control Center GUI.
- Powerful new data grid APIs and simpler packaging
By improving the IMDG’s raw performance and implementing lock-free data structures, R7.0 increases the scalability of applications on multi-core machines by up to 300% compared the previous release. Applications now require less hardware to run on (up to 75%!) in comparison to traditional architectures. The release focuses on improved utilization of CPU, memory and network resources.
Here are a few interesting facts related to the performance improvements:
- The IMDG’s internal data structures were refactored to support lock-free reads. These changes resulted in scalability improvements of up to 300%. Simply put, the performance of highly multi-threaded read scenarios has been significantly improved .
- Memory footprint reduction of up to 50%, which enables storing double the amount of objects in each space instance compared to the previous release. This in fact is a very positive side effect of the internal restructuring mentioned above.
- 40 times faster local read access – The local cache mechanism was completely overhauled. In addition local objects are stored by reference so they don’t occupy additional space and are faster to access. New proxy implementation now supports faster fetch times, so that reading objects by their id from local cache is almost as fast as accessing a java.util.ConcurrentHashMap (in Java) or a Dictionary (in .NET ). Raw performance of sub-microsecond.
New monitoring and administration tools
- Groovy and Java Cluster Monitoring and Administration API. This API enables to automate, monitor and control the entire GigaSpaces XAP runtime environment. With it, you can start, stop, deploy, and undeploy applications as well as monitor host level information, GigaSpaces infrastructure information and deployed application statistics. More information and code samples can be found here.
- GigaSpaces Agent. The new agent serves as a gateway to computers with GigaSpaces installation on them. GigaSpaces servers and applications can be controlled from a remote location whereas the physical location of the hosting machines may reside within the enterprise data center or even remotely on a public cloud. The agent can also guarantee various SLAs at the infrastructure level, e.g. making sure there is a minimum set of grid managers before the actual application deployment begins.
- Zones SLA. This is a new service level capability. With it users can define fine-grained redundancy constraints. For example, users may want to ensure that primary partition and its backup are not hosted on the same machine, or they may want to be safer and to ensure that they do not share the same physical rack space or data center facilities. Zone is a configurable attribute of a GigaSpaces server that is taken into account when deploying the application on the grid.
- Revamped Management Console. GigaSpaces XAP allows users to gain full control on their system, from the physical machine layer, through GigaSpaces grid infrastructure, up to the internal application components. This allows problem determination capabilities and improved overall system management experience.
Powerful New Data Grid APIs and Simpler Packaging
- Query by Id API. GigaSpaces core API now supports Id based queries in addition to template and SQL queries. This API is similar to other data access APIs and makes migration of DAOs to the GigaSpaces XAP platform smoother. This API enables a number of optimizations in the platform which result in significant performance gains specifically geared towards web application data access scenarios (.NET API).
- Standard war/jar structure. It is no longer needed to use a shared-lib directory in war/jars to store objects that are shared between processing units. With R7.0 you can simply put those objects under the standard WEB-INF/lib directory in the war or the lib directory in the processing unit jar. The GigaSpaces platform will take care of all the rest. We were able to remove this limitation by implementing a different class-loading scheme. This means that existing war files can be deployed into GigaSpaces XAP without structure changes.
- Simplified IDE experience. We have greatly simplified the experience of adding the GigaSpaces XAP libraries into the IDE’s build path. This was done by reducing the amount of jars required to compile and run GigaSpaces applications. The lib directory, where all the jar files are located, now contains 3 sub directories:
- required, which contains all th
e jars (now only 4 in number) required to compile and run your application. All you need to do is select all the jars in this directory and you’re good to go.
- optional, which contains optional jar files for extended functionality, such as our Mule integration package.
- platform, which contains libraries internal to the product’s components and need not be part of your application’s classpath.
- required, which contains all th
- Map/Reduce – Grid Task Execution API. This API was first introduced in GigaSpaces XAP 6.6, however, we’ve seen a dramatic boost in the usage of our task-based, parallel processing, remotely invoked API. The Grid Task Execution API is an implementation of the map/reduce concept in GigaSpaces XAP. The .NET implementation of Executor API was added in R7.0 as technology preview.
- Async Operations. Another important addition initially introduced in R6.6 is the ability to read data from the space asynchronously. This API provides improved call level scalability as client threads are not associated with calls and can be written for better scalability and improved resource utilization. For example, method call from a Servlet to the data grid can be called asynchronously so that the calling Servlet thread is released to return the web result back to the user. This API enables building highly scalable and extremely responsive web site (.NET API )