Performance enhancement with speculative execution based parallelism for processing large-scale xml-based application data

Abstract

We present the design and implementation of a toolkit for processing large-scale XML datasets that utilizes the capabilities for parallelism that are available in the emerging multi-core architectures. Multi-core processors are expected to be widely available in research clusters and scientific desktops, and it is critical to harness the opportunities for parallelism in the middleware, instead of passing on the task to application programmers. An emerging trend is the use of XML as the data format for many distributed/grid applications, with the size of these documents ranging from tens of megabytes to hundreds of megabytes. Our earlier benchmarking results revealed that most of the widely available XML processing toolkits do not scale well for large sized XML data. A significant transformation is necessary in the design of XML processing for distributed applications so that the overall application turn-around time is not negatively affected by XML processing. We discuss XML processing using PiXiMaL, a parallel processing library for large-scale XML datasets. The parallelization approach is to build a DFA-based parser that recognizes a useful subset of the XML specification, and convert the DFA into an NFA that can be applied to an arbitrary subset of the input. Speculative NFAs are scheduled on available cores in a node to effectively utilize the processing capabilities and achieve overall performance gains. We evaluate the efficacy of this approach in terms of potential speedup that can be achieved for representative XML datasets. We also evaluate the effect of two different memory allocation libraries to quantify the memory-bottleneck as different cores access shared data structures.

Parallel and distributed approach for processing large-scale XML datasets

“…Our past work demonstrates that the level of speedup obtainable using micro-parallelization techniques is limited: other system resources, such as memory bandwidth become bottlenecks [21]. We present some new experimental results here to quantify the gains and limitations of the microparallelism approach.…”

SOAP Processing Performance and Enhancement

“…In addition to single-node parallelism, a.k.a. microparallelism (achieved on a single computer system, with multiple processing units connected via the same bus and sharing the same memory), recent XML-related studies [23,30,31] have addressed cluster computing, a.k.a. macroparallelism (i.e., distributed computing on large datasets of computer clusters).…”

“…In a related project by Head et al, the Piximal toolkit [23,30,31] presents a parallelized SAX parsing solution, focusing on a different class of applications than the DOM-absed Meta-DFA project, tailored around event-streams and fast sequential access of XML-based data. Piximal conducts parsing work dynamically, and generates as output a sequence of SAX events.…”

“…This results in a larger number of parser states and state transitions, underlining more opportunities for parallelization optimization, and scaling well with increasing numbers of processing cores. Experimental results demonstrate that the level of speedup obtainable using Piximal's micro-level parallelization techniques can be limited due to: i) memory bandwidth, which could become a bottleneck [31], and ii) the amount of computation required to parse the input, which would induce little performance gain if the computation required is small in comparison to the time required to access the bytes of the input in memory [23]. Hence, the authors in [23,30,31]also address macro-level parallelism.…”

Compiler support for effective XSL transformation

“…The drawback of this approach is that an XSLT stylesheet is parsed and analyzed whenever an XSLT processor is executed, which requires considerable time and memory; in addition, few optimizations can be applied in an interpreter. The second implementation approach is a compiler‐based approach , whereby an XSLT stylesheet is first translated into the corresponding target program, which is subsequently compiled into an executable code. In this approach, an XSLT stylesheet is parsed and analyzed only once, and many compiler‐optimization techniques can be used to improve the performance.…”