Jana Katreniakova

Visual Exploration of RDF Data

We have developed and implemented [1,2] infrastructure and RDF storage for the Semantic Web. When we filled it with data the need for some tool that could explore the data became evident. Unfortunately, none of existing solutions fulfills requirements imposed by the data and users expectations. This paper presents our RDF visualizer that was designed specifically to handle large RDF data by means of incremental navigation. A detailed description of the algorithm is given as well as actual results produced by the visualizer.

Edge Routing with Fixed Node Positions

The two basic problems of graph drawing - drawing of nodes and drawing of edges - are often handled by one algorithm that finds suitable positions for both nodes and edges. However, there are situations where positions of nodes are fixed, for instance if they were defined by the user or the exact position of the nodes is somehow significant. In these cases we need an algorithm that draws only the edges no matter what the positions of the nodes are. This paper presents one such algorithm. We present the very basic version of the algorithm followed by two ways of improving it to produce better looking and clearer results.

Online bandwidth allocation

The paper investigates a version of the resource allocation problem arising in the wireless networking, namely in the OVSF code reallocation process. In this setting a complete binary tree of a given height n is considered, together with a sequence of requests which have to be served in an online manner. The requests are of two types: an insertion request requires to allocate a complete subtree of a given height, and a deletion request frees a given allocated subtree. In order to serve an insertion request it might be necessary to move some already allocated subtrees to other locations in order to free a large enough subtree. We are interested in the worst case average number of such reallocations needed to serve a request. In [4] the authors delivered bounds on the competitive ratio of online algorithm solving this problem, and showed that the ratio is between 1.5 and O(n). We partially answer their question about the exact value by giving an O(1)-competitive online algorithm. In [3], authors use the same model in the context of memory management systems, and analyze the number of reallocations needed to serve a request in the worst case. In this setting, our result is a corresponding amortized analysis.

Visualization of Large Schemaless RDF Data

Since many XML documents do not contain any schema definition, we expected that there will be also RDF documents without RDF schema or ontology. Then the data can only be viewed as a general labeled directed graph and the idea to present the data to the user by drawing the graph seems natural. Because the data can be extremely large, it is impossible to display the whole graph at one time. Only a suitable start node is displayed and the rest of the graph can be explored by incremental navigation.To conserve space and show possible directions of further navigation to the user we have come up with a technique called node merging. By combining suitable graph drawing and navigation techniques we get a tool that can give the user good idea about structure and content of the data.Since many XML documents do not contain any schema definition, we expected that there will be also RDF documents without RDF schema or ontology. Then the data can only be viewed as a general labeled directed graph and the idea to present the data to the user by drawing the graph seems natural. Because the data can be extremely large, it is impossible to display the whole graph at one time. Only a suitable start node is displayed and the rest of the graph can be explored by incremental navigation.To conserve space and show possible directions of further navigation to the user we have come up with a technique called node merging. By combining suitable graph drawing and navigation techniques we get a tool that can give the user good idea about structure and content of the data.

Navigation in RDF Data

There are already several tools available that are capable of visualizing RDF data. The problem with RDF data is that they tend to be very large. To handle the data, the visualizers cannot display the whole data but rather need to use some kind of navigation. We have designed and implemented such visualizer. This paper describes our approach to the navigation, which was designed specifically with the preservation of the users mental map in mind. We also compare our approach to the other visualizers.

RDF Visualization - Thinking Big

Graph visualization is one of the popular ways to present RDF data. But all practical RDF visualizers have to somehow deal with the problem of the size of the data. Not only can the total number of triples in RDF data be very large, but even degrees of the nodes of the graph can be very high. This article discusses some problems and solution related to visualization and exploration of such data, usually in relation to the RDF node merging technique.

RDF Query Generator

There have been many attempts to create software that would allow the users to design SQL queries visually, even though it is not very natural to handle relations and relational algebra (the theoretical background of SQL) this way. But the RDF data format is based on directed labeled graphs, whose visual representation is very natural. We have created an RDF visualizer and tried to extend it to support query construction. It turned out that the nature of current RDF query languages only allows some basic support but prevents creation of a more sophisticated system. This articles describes our query generator and discusses the limiting factors.

Automatic Detection of Synchronization Errors in Codes that Target the Open Community Runtime

The complexity of writing and debugging parallel programs makes tools that can support this effort very important. In the case of the Open Community Runtime, one major problem is ensuring that the program manages runtime objects correctly. For example, when one task uses an object and another task is responsible for deleting the object, the tasks need to be synchronized to ensure that the object is only destroyed once it is no longer being used. In this paper, we present a tool which observes program execution and analyzes it in order to find cases where the required synchronization is missing.

Visualization of Open Community Runtime Task Graphs

The emergence of new types of high performance hardware also drives the need for new programming models. The Open Community Runtime (OCR) proposal uses a task-based programming model to target some of these architectures. In OCR, the whole program from start to end needs to be expressed using tasks and synchronized using task-to-task dependences, significantly limiting the applicability and usefulness of existing approaches to application development and debugging. In this paper, we present our approach to visualizing tasks and their synchronization, based on trace data from application execution. This way, the application developer may compare the intended organization of the tasks with the actual dependences as they are seen by the OCR runtime system.

Mental Map Models for Edges

When drawing a graph, the users actions on the graph may lead to a drawing which is very different from the drawing before the interaction. The established aesthetic criteria are not sufficient to allow the users to fully track the changes to the graph. The mental map of nodes and edges is lost. We have taken the existing work, which focused on mental maps for nodes, and extended it naturally to the edges. This may be useful in applications where the nodes are stable and only the edges are redrawn. We present two models that allow edges to be drawn to preserve the mental map as much as possible. Our preliminary tests indicate that the produced edge drawing is similar to the original one and the other aesthetic criteria have mostly been preserved.