Present Data Structures Research Articles

MEGA: a real-time visualisation framework for large-scale terrain

Real-time simulation and rendering of large-scale terrain model is a hot research topic in fields such as 3D computer games, cartoon movies and flight simulation, etc. This paper presents mechanism of terrain data organisation and real-time (MEGA) rendering, a GPU-oriented, hybrid quantree-based large terrain visualisation framework. The present terrain data structure based on hybrid quadtree, which combines static full resolution and dynamic variable resolution quadtree to organise the whole terrain scene and reduce the level of detail at need. Another feature is taking advantage of GPU to achieve view-frustum culling and terrain blocks updating. We also introduce a GPU-based error metric method. At run time, screen space error is projected from geometric error and compared with error threshold according to view- point to select terrain blocks by GPU. This error metric method can improve the rendering efficiency of graphic hardware. MEGA shows a maximal speed increment of 38% for high-quality terrain rendering compare with other similar solutions.

Redistributing time-based rights between consumer devices for content sharing in DRM system

Device-based digital rights management (DRM) systems tightly bind rights for content to a device. However, it can decrease the consumers’ convenience because it disturbs consumers who want to use the already purchased content with their other devices freely. Previous research into solving this problem still have burdens such as restricting the number of devices that a consumer can use and requiring a special device that manages content sharing. In this paper, we propose a new rights sharing scheme which does not restrict the number of devices that a consumer can use and does not require a specialized device. In our scheme, the right to use content is represented as the right to use the content for a certain amount of time. Consumers can use the content with any of their devices by redistributing the usage amount of time between devices. The redistribution process only requires local synchronization among participating devices. To prevent illegal content sharing and to detect illegally increased content usage time, the amount of time that a consumer can have is limited and the rights for each unit of time has a unique number to prevent illegal duplications. We present data structures and protocols, analyze security properties of our scheme, compare our scheme with related work, and evaluate our scheme through implementation.

BMQ-Processor: A High-Performance Border-Crossing Event Detection Framework for Large-Scale Monitoring Applications

In this paper, we present BMQ-Processor, a high-performance border-crossing event (BCE) detection framework for large-scale monitoring applications. We first characterize a new query semantics, namely, border monitoring query (BMQ), which is useful for BCE detection in many monitoring applications. It monitors the values of data streams and reports them only when data streams cross the borders of its range. We then propose BMQ-Processor to efficiently handle a large number of BMQs over a high volume of data streams. BMQ-Processor efficiently processes BMQs in a shared and incremental manner. It develops and operates over a novel stateful query index, achieving a high level of scalability over continuous data updates. Also, it utilizes the locality embedded in data streams and greatly accelerates successive BMQ evaluations. We present data structures and algorithms to support 1D as well as multidimensional BMQs. We show that the semantics of border monitoring can be extended toward more advanced ones and build region transition monitoring as a sample case. Lastly, we demonstrate excellent processing performance and low storage cost of BMQ-Processor through extensive analysis and experiments.

Information filtering and query indexing for an information retrieval model

In the information filtering paradigm, clients subscribe to a server with continuous queries or profiles that express their information needs. Clients can also publish documents to servers. Whenever a document is published, the continuous queries satisfying this document are found and notifications are sent to appropriate clients. This article deals with the filtering problem that needs to be solved efficiently by each server: Given a database of continuous queries db and a document d , find all queries q ∈ db that match d . We present data structures and indexing algorithms that enable us to solve the filtering problem efficiently for large databases of queries expressed in the model AWP . AWP is based on named attributes with values of type text, and its query language includes Boolean and word proximity operators.

A data structure for graph to facilitate hiding of information in a graph's segments – a graph theoretic approach to steganography

In this paper, we present a data structure that is suitable for graph representation that can be used as a cover object in steganography. Steganography is a science of hiding information with the purpose of making the information unreadable by a third party. The information is placed in the cover object in such a way that the distortion introduced in the cover object is as minimal as possible and to the extent not recognisable by the human eye. To accomplish the task, redundancy in the representation of the cover object is identified before placing the information in it. There exists a number of data structure for graph representation e.g., adjacency matrix, incidence matrix, adjacency list, etc. These classical data structures allow little scope of finding redundancy in graph. The data structure presented in this paper is file based. It divides a graph into three components: node, segment and intermediate points that constitute a segment. Under the scheme, only planar graph is being considered to maintain clarity in spatial representation of a graph. The presented data structure is aimed to facilitate graph theoretic approach to steganography.

Generalized and Customizable Sets inR

We present data structures and algorithms for sets and some generalizations thereof (fuzzy sets, multisets, and fuzzy multisets) available for <b>R</b> through the <b>sets</b> package. Fuzzy (multi-)sets are based on dynamically bound fuzzy logic families. Further extensions include user-definable iterators and matching functions.

Algorithms and Data Structures for Multi-Adaptive Time-Stepping

Multi-adaptive Galerkin methods are extensions of the standard continuous and discontinuous Galerkin methods for the numerical solution of initial value problems for ordinary or partial differential equations. In particular, the multi-adaptive methods allow individual and adaptive time steps to be used for different components or in different regions of space. We present algorithms for efficient multi-adaptive time-stepping, including the recursive construction of time slabs and adaptive time step selection. We also present data structures for efficient storage and interpolation of the multi-adaptive solution. The efficiency of the proposed algorithms and data structures is demonstrated for a series of benchmark problems.

EFFICIENT AUTOMATA CONSTRUCTIONS AND APPROXIMATE AUTOMATA

In this paper, we present data structures and algorithms for efficiently constructing approximate automata. An approximate automaton for a regular language L is one which accepts at leastL. Such automata can be used in a variety of practical applications, including network security pattern matching, in which false-matches are only a performance nuisance. The construction algorithm is particularly efficient, and is tunable to yield more or less exact automata.

HpGEM---A software framework for discontinuous Galerkin finite element methods

hpGEM, a novel framework for the implementation of discontinuous Galerkin finite element methods (FEMs), is described. We present data structures and methods that are common for many (discontinuous) FEMs and show how we have implemented the components as an object-oriented framework. This framework facilitates and accelerates the implementation of finite element programs, the assessment of algorithms, and their application to real-world problems. The article documents the status of the framework, exemplifies aspects of its philosophy and design, and demonstrates the feasibility of the approach with several application examples.

A hierarchic sparse matrix data structure for large‐scale Hartree‐Fock/Kohn‐Sham calculations

A hierarchic sparse matrix data structure for Hartree-Fock/Kohn-Sham calculations is presented. The data structure makes the implementation of matrix manipulations needed for large systems faster, easier, and more maintainable without loss of performance. Algorithms for symmetric matrix square and inverse Cholesky decomposition within the hierarchic framework are also described. The presented data structure is general; in addition to its use in Hartree-Fock/Kohn-Sham calculations, it may also be used in other research areas where matrices with similar properties are encountered. The applicability of the data structure to ab initio calculations is shown with help of benchmarks on water droplets and graphene nanoribbons.

Distributed disk-based algorithms for model checking very large Markov chains

In this paper we present data structures and distributed algorithms for CSL model checking-based performance and dependability evaluation. We show that all the necessary computations are composed of series or sums of matrix-vector products. We discuss sparse storage structures for the required matrices and present efficient sequential and distributed disk-based algorithms for performing these matrix-vector products. We illustrate the effectivity of our approach in a number of case studies in which continuous-time Markov chains (generated in a distributed way from stochastic Petri net specifications) with several hundreds of millions of states are solved on a workstation cluster with 26 dual-processor nodes. We show details about the memory consumption, the solution times, and the speedup. The distributed message-passing algorithms have been implemented in a tool called PARSECS, that also takes care of the distributed Markov chain generation and that can also be used for distributed CTL model checking of Petri nets.

Glift

This article presents Glift, an abstraction and generic template library for defining complex, random-access graphics processor (GPU) data structures. Like modern CPU data structure libraries, Glift enables GPU programmers to separate algorithms from data structure definitions; thereby greatly simplifying algorithmic development and enabling reusable and interchangeable data structures. We characterize a large body of previously published GPU data structures in terms of our abstraction and present several new GPU data structures. The structures, a stack, quadtree, and octree, are explained using simple Glift concepts and implemented using reusable Glift components. We also describe two applications of these structures not previously demonstrated on GPUs: adaptive shadow maps and octree three-dimensional paint. Last, we show that our example Glift data structures perform comparably to handwritten implementations while requiring only a fraction of the programming effort.

Variable-scale Topological Data Structures Suitable for Progressive Data Transfer: The GAP-face Tree and GAP-edge Forest

This paper presents the first data structure for a variable scale representation of an area partitioning without redundancy of geometry. At the highest level of detail, the areas are represented using a topological structure based on faces and edges; there is no redundancy of geometry in this structure as the shared boundaries (edges) between neighbor areas are stored only once. Each edge is represented by a Binary Line Generalization (BLG)-tree, which enables selection of the proper representation for a given scale. Further, there is also no geometry redundancy between the different levels of detail. An edge at a higher importance level (less detail) does not contain copies of the lower-level edges or coordinates (more detail), but it is represented by efficiently combining their corresponding BLG trees. Which edges have to be combined follows from the generalization computation, and this is stored in a data structure. This data structure turns out to be a set of trees, which will be called the (Generalized Area Partitioning) GAP-edge forest. With regard to faces, the generalization result can be captured in a single tree structure for the parent-child relationships—the GAP face-tree. At the client side there are no geometric computations necessary to compute the polygon representations of the faces, merely following the topological references is sufficient. Finally, the presented data structure is also suitable for progressive transfer of vector maps, assuming that the client maintains a local copy of the GAP-face tree and the GAP-edge forest.

Scalable Session Locking for a Distributed File System

File systems provide an interface for applications to obtain exclusive access to files, in which a process holds privileges to a file that cannot be preempted and restrict the capabilities of other processes. Local file systems do this by maintaining information about the privileges of current file sessions, and checking subsequent sessions for compatibility. Implementing exclusive access in this manner for distributed file systems degrades performance by requiring every new file session to be registered with a lock server that maintains global session state. We present two techniques for improving the performance of session management in the distributed environment. We introduce a distributed lock for managing file access, called a i>semi-preemptible lock, that allows clients to cache privileges. Under a semi-preemptible lock, a file system creates new sessions without messages to the lock manager. This improves performance by exploiting locality – the affinity of files to clients. We also present data structures and algorithms for the i>dynamic evaluation of locks that allow a distributed file system to efficiently manage arbitrarily complex locking. In this case, complex means that an object can be locked in a large number of unique modes. The combination of these techniques results in a distributed locking scheme that supports fine-grained concurrency control with low memory and message overhead and with the assurance that their locking system is correct and avoids unnecessary deadlocks.

Efficient implementation of progressive meshes

In earlier work, we introduced the progressive mesh (PM) representation, a new format for storing and transmitting arbitrary triangle meshes. For a given mesh, the PM representation defines a continuous sequence of level-of-detail approximations, allows smooth visual transitions (geomorphs) between these approximations, supports progressive transmission, and makes an effective compression scheme. In this paper, we present data structures and algorithms for efficient implementation of the PM representation and its applications. Also, we report quantitative results using a variety of computer graphics models.

Computing Envelopes in Four Dimensions with Applications

Let ${\cal F}$ be a collection of nd-variate, possibly partially defined, functions, all algebraic of some constant maximum degree. We present a randomized algorithm that computes the vertices, edges, and 2-faces of the lower envelope (i.e., pointwise minimum) of ${\cal F}$ in expected time $O(n^{d+\epsilon})$ for any $\epsilon > 0$. For d = 3, by combining this algorithm with the point-location technique of Preparata and Tamassia, we can compute, in randomized expected time $O(n^{3+\epsilon})$, for any $\epsilon > 0$, a data structure of size $O(n^{3+\epsilon})$ that, for any query point q, can determine in O(log2n) time the function(s) of ${\cal F}$ that attain the lower envelope at q. As a consequence, we obtain improved algorithmic solutions to several problems in computational geometry, including (a) computing the width of a point set in 3-space, (b) computing the "biggest stick" in a simple polygon in the plane, and (c) computing the smallest-width annulus covering a planar point set. The solutions to these problems run in randomized expected time $O(n^{17/11+\epsilon})$, for any $\epsilon > 0$, improving previous solutions that run in time $O(n^{8/5+\epsilon})$. We also present data structures for (i) performing nearest-neighbor and related queries for fairly general collections of objects in 3-space and for collections of moving objects in the plane and (ii) performing ray-shooting and related queries among n spheres or more general objects in 3-space. Both of these data structures require $O(n^{3+\epsilon})$ storage and preprocessing time, for any $\epsilon > 0$, and support polylogarithmic-time queries. These structures improve previous solutions to these problems.

Connected component and simple polygon intersection searching

Efficient data structures are given for the following two query problems: (i) preprocess a setP of simple polygons with a total ofn edges, so that all polygons ofP intersected by a query segment can be reported efficiently, and (ii) preprocess a setS ofn segments, so that the connected components of the arrangement ofS intersected by a query segment can be reported quickly. In these problems we do not want to return the polygons or connected components explicitly (i.e., we do not wish to report the segments defining the polygon, or the segments lying in the connected components). Instead, we assume that the polygons (or connected components) are labeled and we just want to report their labels. We present data structures of sizeO(n 1+e) that can answer a query in timeO(n 1+e+k), wherek is the output size. If the edges ofP (or the segments inS) are orthogonal, the query time can be improved toO(logn+k) usingO(n logn) space. We also present data structures that can maintain the connected components as we insert new segments. For arbitrary segments the amortized update and query time areO(n 1/2+e) andO(n 1/2+e+k), respectively, and the space used by the data structure isO(n 1+e. If we allowO(n 4/3+e space, the amortized update and query time can be improved toO(n 1/3+e andO(n 1/3+e+k, respectively. For orthogonal segments the amortized update and query time areO(log2 n) andO(log2 n+klogn), and the space used by the data structure isO (n logn). Some other related results are also mentioned.

An efficient implemenatation of string pattern matching machines for a finite number of keywords

This paper describes a method of implementing a static transition table of a string pattern matching machine to locate all occurrences of a finite number of keywords in a text string. The scheme combines the fast access of an array representation with the compactness of a list structure. Each transition can be computed from the present data structure in O(1) time and the storage is as small as the list structure. The construction and pattern matching programs associated with the present data structure are provided and the efficiency is evaluated by a empirical results.

DS-Viewer- interactive graphical data structure presentation facility

DS-Viewer is a tool that is the result of a research project in data structure presentation within a program state. This tool addresses two distinct issues in this area: (1) to effectively present data structures themselves for a given program state and (2) to present groups of data structures and their interrelationships as described by their pointer definitions. Graphical presentations were developed to address these issues. For the data structure presentation, the user is provided a display window for any single data structure instance formatted with its fields and field values. Flexibility in display is provided by allowing the user a choice from the various value formats for each field. For groups of data structure instances, a graphical drawing space is provided in which pictures of these data structure instances and their interrelationships are drawn as blocks and arrows. The computer assists the user in drawing such a picture by describing its components, allowing the user to choose which to draw and to construct as much of the picture as desired.

Efficient Algorithms for Geometric Graph Search Problems

In this paper, we show that many graph search problems can be solved quite efficiently for a geometric intersection graph of horizontal and vertical line segments. We first extract several basic operations for depth first search and breadth first search on a graph. Then we present data structures for the intersection graph in terms of which those operations can be implemented in an efficient manner. The data structures enable us to solve various graph search problems besides depth first search and breadth first search. Specifying the results obtained in this paper for an intersection graph of n horizontal and vertical segments with m pairs of intersecting segments, we obtain algorithms with the following complexity, where $N = \min \{ m,n\log n\} $. (i) Depth first search and breadth first search can be executed in $O(n\log n)$ time and $O(N)$ space. (ii) The biconnected components can be found in $O(n\log n)$ time and $O(N)$ space. (iii) A maximum matching and a maximum independent set can be found in $O...