Filip Zavoral

Semantic Web Infrastructure Using DataPile

Years of research and development of technologies and tools do not lead to expected semantic Web widespread. We consider practical nonexistence of an infrastructure for the semantic Web operation as one of the main reasons of that status. In our paper we describe a proposal of such infrastructure based on the DataPile technology and relevant developed tools and their integration with Web search engines and other tools

Bobolang: a language for parallel streaming applications

At present time, the programmers may choose from a number of streaming languages. They cover various aspects of the development process of streaming applications; however, specification of complex or runtime-dependent parts of the applications still remains a great challenge. We have analysed a large amount of requirements raised by the development of multiple data streaming parallel applications and proposed a novel language called Bobolang. It contains syntactic and semantic features which allow the programmer to naturally solve most of the problems, which we met in the design of streaming applications. The language is used to specify the structure of the whole application as well as the inner structure of each operator. Thanks to the properties of the language, Bobolang can create an optimized evaluation plan which is capable of making the best use of the available hardware resources. The language has been employed in several practical problems and it has proven itself to be a very powerful tool for the development of data-intensive parallel applications.

Data-Flow Awareness in Parallel Data Processing

The memory hierarchy affects the performance of task-scheduling strategies in task-based parallel environments. For data-intensive problems, the flow of data may be explicitly specified as a part of the algorithm, allowing the task scheduler to be aware of the data flow. In this paper, we describe such a task-based environment with explicit data-flow specification. We demonstrate the effect of data-flow awareness on the system performance. The results show that the explicit specification of data flow improves the quality of task scheduling.

Using Methods of Parallel Semi-structured Data Processing for Semantic Web

The state of the art in semi-structured data processing (and XML in particular) and Semantic Web repositories correspond to each other: the non-scalability of pilot implementations, the inability of optimizations, and the cost of the fully native implementation. Although there are successful implementations in each of the approaches, none of the methods may be considered universal. The Bobox framework proposed in this paper is a relational-like storage engine applicable both as a native XML database and as a Semantic Web repository. The main purpose of the engine is in experiments in both areas. The main stress is put to the performance of complex queries and transformations, and to the ability of parallel evaluation in particular.

Semantic Web Repository And Interfaces

The semantic Web is not widespread as it has been expected by its founders. This is partially caused by lack of standard and working infrastructure for the semantic Web. We have built a working, portable, stable, high-performance infrastructure for the semantic Web. This enables various experiments with the semantic Web in the real world.

Mapping of Dynamic Language Constructs into Static Abstract Syntax Trees

Software solutions performing automatic code analysis are very important, especially for code assistance capabilities or for extracting semantic metadata from the source code. These methods gather syntactic information from the source code and then in general they provide large set of implying semantics. With the increased focus on dynamic languages the problem emerges – the whole code semantic is known only at runtime and the analysis has to estimate larger relations. Within the project Phalanger, which is the compiler of the dynamic PHP language into a static environment, we have succeeded with converting most of dynamic constructs into the typical structures used by static code analyzers. That enables processing of most of dynamic language constructs in the classic static way. Moreover described methods simplifies source code prediction and other relevant tasks.

Locality Aware Task Scheduling in Parallel Data Stream Processing

Parallel data processing and parallel streaming systems become quite popular. They are employed in various domains such as real-time signal processing, OLAP database systems, or high performance data extraction.One of the key components of these systems is the task scheduler which plans and executes tasks spawned by the system on available CPU cores. The multiprocessor systems and CPU architecture of the day become quite complex, which makes the task scheduling a challenging problem. In this paper, we propose a novel task scheduling strategy for parallel data stream systems, that reflects many technical issues of the current hardware. We were able to achieve up to 3× speed up on a NUMA system and up to 10% speed up on an older SMP system with respect to the unoptimized version of the scheduler. The basic ideas implemented in our scheduler may be adopted for task schedulers that focus on other priorities or employ different constraints.

Syntactic and Semantic Prediction in Dynamic Languages

In the context of computer programming, the importance of computer assistance is being understood by many developer communities. Developers are e.g. using the same well known expressions or searching method signatures in library documentations. Code sense or IntelliSense methods make most of these actions unnecessary because they serve the available useful information directly to the programmer in a completely automated way. Recently, with the increased focus of the industry on dynamic languages a problem emerges - the complete knowledge on the source code is postponed until the runtime, since there may be ambiguous semantics in the code fragment.

Schema-Based Analysis of XSLT Streamability

We present an algorithm which analyzes memory requirements of the streaming processing of a given XSLT stylesheet on the set of XML documents defined by a given XML schema. This schema-based analyzer represents an integral part of the Xord framework for the streaming processing of XSLT - it determines the most efficient streaming algorithm for a given transformation and the class of XML documents defined by a schema. We describe the implementation of the analyzer for the stack-based streaming algorithm.The analysis is performed using the W3C XSD format for schemas. We introduce a new compact structure for XSD representation used in the analysis.

Using Input Buffers for Streaming XSLT Processing

We present a buffering streaming engine for processing top-down XSLT transformations. It consists of an analyzer and a transformer.The analyzer examines given top-down XSLT and XSD, and generates fragments which identify parts of XSD need to be buffered when XSLT is applied. The fragments are passed to the transformer which processes XSLT on an input XML document conforming to XSD. It uses auxiliary memory buffers to store temporary data and buffering is controlled according to the fragments. We describe implementation of the engine within the Xord framework and provide evaluation tests which show that the new engine is much more memory-efficient comparing to the common XSLT processors.