Browse Prior Art Database

An Apparatus for leveraging General Purpose Graphics Processing Units for JSON Acceleration in Front-End Cache

IP.com Disclosure Number: IPCOM000234730D
Publication Date: 2014-Jan-31
Document File: 5 page(s) / 144K

Publishing Venue

The IP.com Prior Art Database

Abstract

Disclosed is a middleware apparatus that uses Graphic Processing Units (GPUs) to encode JavaScript* Object Notation (JSON) documents into a query format that can be used by in-memory object-based front-end caches, as well as into an index structure that can be used when the front-end cache supports dynamic indexes.

This text was extracted from a PDF file.
This is the abbreviated version, containing approximately 36% of the total text.

Page 01 of 5

An Apparatus for leveraging General Purpose Graphics Processing Units for JSON Acceleration in Front -

-End Cache

End Cache

JavaScript* Object Notation (JSON) is lightweight data interchange format designed to be minimal, portable, and textual. Most languages have features that map easily to JSON. Hence, JSON has been rapidly becoming the language of the web. JavaScript plays a key role for mobile system of engagement applications, and JSON is the predominant technology leveraged by Not Only Structured Query Language (NoSQL) stores to provide schema flexibility and development agility. These NoSQL stores tend to be schema-less, hence minimizing the overhead for schema design. JSON supports the embedding of documents and arrays within other documents and arrays.

Although these NoSQL database systems claim to be very fast, such systems need to

process each field of the JSON document multiple times, which can become Central

Processing Unit (CPU)-intensive, as the data must be replicated over multiple instances. In addition, in memory front-end caches have been used to provide higher speed in writes. These in-memory caches use giant hash tables distributed across multiple machines. When the hash table is full, subsequent inserts cause older ordered data to be purged, or fall back to slower backing stores, such as a database.

In order to convert JSON documents in a format that can be serialized, a front-end cache, a NoSQL store, or a middleware system has to serialize the JSON Object (or binary JSON format, BSON). Moreover, when performing queries, a middleware system has to decode the query, inflate the object, and construct a query in format understandable by the cache. Finally, it has to also understand whether a key value pair corresponds to an index. This can be even more complicated, as indexes can be included in embedded documents; therefore, path navigation might be needed. For example, in an Object Map cache, each document has to be stored in an Object Map. However, serializing JSON Objects is CPU-intensive because each key-value has to be parsed, there are embedded or encapsulated JSON Objects (i.e. parent-child relation), and some values can contain text or Regular Expression (REGEX) operations.

Therefore, while in memory Object Maps can be fast, encoding the JSON Objects can become a processing bottleneck even for multi-processor machines. There are two potential approaches to this problem. The first is to use Field Programmable Gate

Arrays (FPGAs), which have shown processing advantages over traditional

multi-threaded architectures. However, FPGAs are limited by small resources and expensive programming time. The second solution is the use of Graphic Processing Units (GPUs), which offer the flexibility of reprogramming. In other words, use the General-Purpose (GP) computing on GPU (GPGPU) to leverage the CPU, which

typically handles computation for computer graphics, to perform a JSON query and index development, and seri...