Browse Prior Art Database

A mechanism to handle large data / payload embedded in XML without memory overload

IP.com Disclosure Number: IPCOM000239284D
Publication Date: 2014-Oct-27
Document File: 5 page(s) / 118K

Publishing Venue

The IP.com Prior Art Database

Abstract

XML parsers are extensively used in the enterprise environments where (large) data (payload) from disparate systems are exchanged in the form of XML data. Since the XML data arrives to enterprise runtime from several external sources, the size of the payload is unpredictable, parsing such a data can lead to memory exhaustion situations. Applications and business requirements often prefer using the XML Processors as it represents the object model. But there is a challenge to accommodate unpredictable large payload in XML Processors without allocating proportionate memory to it. The proposed mechanism involves setting the unpredictable payloads as streamable during design time, XML processors creates references. XML Processors include DOM / JAXB

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

Page 01 of 5

A mechanism to handle large data / payload embedded in XML without memory overload

Potential Problems:

XML Processors are extensively used for parsing XML data, undermining threat of memory overrun in case of large data (embedded payload) handling.

Usage of XML Processors with large data drives the runtime into the state of limbo, enforcing customer to restart.

Customer receiving an XML with large payload often crashes runtime while DOM parser loads them up. (One example, IBM WebSphere Cast Iron runtime has few PMR's in this front triggers this solution)

Figure 1

Protecting integration runtime failures while handling unpredictable payload embedded in XML.

Handling large data under JAXB framework without encountering OOM.

Enabling DOM parser to handle large payload in XML.

The proposed approach addresses above challenges.

Aim


The proposed mechanism involves setting the unpredictable payloads as streamable during design time, XML processors creates references for such nodes.

User marks the element with large data to be streamable and communicates the same to XML processors.

XML Processor recognizes the streamable nodes and creates references rather loading entire content into memory

XML processor writes the contents of streamable elements to appropriate resource ( can be

Challenge:


1.


2.


3.

1


Page 02 of 5


4.

file / DB / other storage mechanisms) and associate the handle to its object tree.

XML processors provides input stream to the caller, when he requests for streamable elements contents.

With the proposed approach outlined above, XML processors avoids loading of unpredictably large payloads into memory with the help of references.

Thus avoiding the memory exhaustion while building object / DOM tree. Proposed solution won't alter the face of existing XML API (DOM / JAXB) , which gives more power to handle large data.

Figure

The above figure 2 demonstrates the typical integration scenario.

Why mark a node as streamable ?

In most of the integration scenarios, integration runtime requires only routing information from the XML data without loading entire payload which are usually meant for back-end system processing.

This helps to

represent large content within an XML DOM tree using references.

facilitate the user to designate any element as a streamable during design or runtime for XML Processors to handle appropriately.
avoid cascadi...