Query Tree Research Articles

Study on a Nearest Neighbor Algorithm for Point Clouds Based on the Space Partition Principle

In the product modeling based on the reverse engineering, the point cloud data smoothing and multi-view point cloud data registration will be related to search some nearest neighbor points. The search speed will determine the efficiency of product modeling in some cases. The paper analysis the nearest neighbor point query algorithms, KD tree and Range tree, based on the space partition principle. The tree structure creation and query method are described by pseudo-code in the paper. Finally, the experimental results involving different sizes point clouds demonstrate that KD tree and Range tree have their own advantages in space storage and time complexity. Two data strictures all meet the efficiency of the search algorithm.

Query Tree Algorithm for RFID Tag with Binary-Coded Decimal EPC

A tag-collision problem in Radio Frequency Identification (RFID) system is the event that a reader cannot identify a tag if many tags respond to a reader at the same time. Although binary Electronic Product Code (EPC) is the most natural for a computer, most people are accustomed to the decimal system. In RFID applications, we need to convert binary EPC to decimal numbers. Since converting binary-coded decimal (BCD) data into the decimal numbers is much less complex than converting binary data into decimal numbers. This motivates us to represent EPC by BCD. However, using BCD-based EPC delivers two problems: (i) Is the existing query tree algorithm suitable for identifying BCD-based EPC? (ii) How do we design a new query tree algorithm to enhance the tag-identification efficiency? In this work, we solved the problems.

Adaptive frame on binary splitting for radio frequency identification anticollision

SUMMARYIn many radio frequency identification applications, the reader must repeatedly identify the same staying tags. Existing anticollision protocols, adaptive binary splitting (ABS) and adaptive query tree, can rapidly identify the staying tags by remembering the order in which the tags were recognized in the previous identification process. This paper proposes a novel protocol called adaptive frame ABS (AFA), based on ABS. AFA utilizes the dynamic regulation approach that estimates the numbers of staying tags and newly‐arriving tags and optimally adjusts the numbers of slots allocated for them to reduce idle slots when many recognized tags leave and reduce collision slots when many newly‐arriving tags enter. Following the regulation process, multiple staying tags may share the same slot and cause a collision among them. Thus, an efficient ordering splitting is proposed to deterministically split the collided staying tags according to the order in which they were recognized. The analytical and simulation results show that AFA outperforms ABS in most of the considered environments. Copyright © 2012 John Wiley & Sons, Ltd.

RFID 시스템에서 Hybrid 방식을 이용한 효율적인 충돌 회피 기법

RFID 시스템에서 다수의 태그가 동시에 자신의 ID를 리더기에 전송하게 되면 충돌로 인해 리더기의 태그 인식시간이 지연 된다. 따라서 리더기의 태그 인식시간을 줄이기 위한 효율적인 충돌방지 기술이 필요하다. 본 논문에서는 QT(Query Tree) 방식을 기반으로 DFSA(Dynamic Framed Slotted Aloha) 방식을 추가한 hybrid 충돌 회피 방법에 대해서 제안하고 시뮬레이션을 통하여 기존의 방법과 성능을 비교한다. If multiple Tags in the RFID System transmit their IDs to the Reader at the same time, tag identification time is delayed due to collisions. Therefore, to reduce the reader's identification time, an efficient anti-collision technology is needed. In this paper, we propose a hybrid anti-collision method based on the QT and DFSA. Then, the performances of proposed method are compared with the existing method through extensive simulations.

An Adaptive Combination Query Tree Protocol for Tag Identification in RFID Systems

A reader must be able to identify tags as quickly as possible, so tag anti-collision is a significant issue for the RFID system. In this paper, we propose a novel tag anti-collision protocol (ACQT), which is suitable for a large mobile tags environment. Based on a 3-ary tree, it has the optimal capacity to identify for tree-based protocols. Using a combination query tree, it can solve the problem of not being able to generate a 3-ary tree when the length of a tag's ID is not a multiple of 3. The joining and leaving strategies can efficiently be applied for tag mobility. The simulation results show that the protocol we present can achieve better performance than previous protocols by decreasing identification delay, collision cycles and idle cycles.

Discrete range searching primitive for the GPU and its applications

Graphics processing units (GPUs) provide large computational power at a very low price, which position GPUs well as an ubiquitous accelerator. However, GPUs are space constrained, and hence applications developed for GPUs are space sensitive. Space-constrained computational devices such as GPUs can greatly benefit from representations that reduce space consumption drastically. One such representation is the succinct representation of trees. Succinct representation of trees generally allows for operations such as parent queries, least common ancestor queries, and so on. Mapping such a robust representation to the GPU for targeted applications can lead to substantial improvement in problem sizes that are processed at a given point of time. Space-saving methods such as succinct data structures remain largely unexplored on the GPU. In this work, a succinct representation of ordered trees on the GPU is explored, with application to discrete range searching (DRS). Based on the succinct representations found applicable, a space--saving solution for DRS is presented here. In our method, DRS is mapped to a least common ancestor query on a Cartesian tree. For space-efficient DRS queries, we store the succinct representation of the Cartesian tree of an array. Our method uses a maximum of 7.5 bits of additional space per element. Furthermore, the speed-up achieved by our method is in the range of 20--25 for preprocessing and 25--35 for batch querying over a sequential implementation. Compared to an 8-threaded implementation, our preprocessing and querying methods obtain a speed-up of 6--8. We also study the applications of the DRS on the GPU. Efficient primitives expand the range of applications performed on the GPU. DRS is one such primitive with direct applications to string processing, document and text retrieval systems, and least common ancestor queries. We suggest that graph algorithms that use the least common ancestor, can be enabled on the GPU based on DRS primitive. We also show some applications of DRS in tree queries and string querying.

SCOUT

Today's scientists are quickly moving from in vitro to in silico experimentation: they no longer analyze natural phenomena in a petri dish, but instead they build models and simulate them. Managing and analyzing the massive amounts of data involved in simulations is a major task. Yet, they lack the tools to efficiently work with data of this size. One problem many scientists share is the analysis of the massive spatial models they build. For several types of analysis they need to interactively follow the structures in the spatial model, e.g., the arterial tree, neuron fibers, etc., and issue range queries along the way. Each query takes long to execute, and the total time for executing a sequence of queries significantly delays data analysis. Prefetching the spatial data reduces the response time considerably, but known approaches do not prefetch with high accuracy. We develop SCOUT, a structure-aware method for prefetching data along interactive spatial query sequences. SCOUT uses an approximate graph model of the structures involved in past queries and attempts to identify what particular structure the user follows. Our experiments with neuro-science data show that SCOUT prefetches with an accuracy from 71% to 92%, which translates to a speedup of 4x-15x. SCOUT also improves the prefetching accuracy on datasets from other scientific domains, such as medicine and biology.

Efficient indexing and querying over syntactically annotated trees

Natural language text corpora are often available as sets of syntactically parsed trees. A wide range of expressive tree queries are possible over such parsed trees that open a new avenue in searching over natural language text. They not only allow for querying roles and relationships within sentences, but also improve search effectiveness compared to flat keyword queries. One major drawback of current systems supporting querying over parsed text is the performance of evaluating queries over large data. In this paper we propose a novel indexing scheme over unique subtrees as index keys. We also propose a novel root-split coding scheme that stores subtree structural information only partially, thus reducing index size and improving querying performance. Our extensive set of experiments show that root-split coding reduces the index size of any interval coding which stores individual node numbers by a factor of 50% to 80%, depending on the sizes of subtrees indexed. Moreover, We show that our index using root-split coding, outperforms previous approaches by at least an order of magnitude in terms of the response time of queries.

General Framework for Optimization of Distributed Queries

The paper suggests the heuristic approach for selecting the optimal evaluation plan and Semi-join approach for reducing the communication cost. Calculating the cost of each evaluation plan of a query takes lots of computational efforts as well as time. Initially the heuristic approach is used to find best evaluation plan among various plans of a single query. By considering only joins, queries are divided into two: tree and cyclic. Semi-join is a useful tool to reduce the cost of joins. The communication cost in distributed database is mainly depending upon the amount of data transferred from one site to another site. Semi-join approach is sufficient to fully reduce the tree queries while semi-joins are not the full reducers for cyclic queries. Cyclic queries are therefore converted into tree queries using different approaches such as addition of vertices, elimination of vertices, decomposition of vertices and elimination of edges. After conversion of cyclic to tree query, semi-join approach can be used.

Parallelizing top-down interprocedural analyses

Modularity is a central theme in any scalable program analysis. The core idea in a modular analysis is to build summaries at procedure boundaries, and use the summary of a procedure to analyze the effect of calling it at its calling context. There are two ways to perform a modular program analysis: (1) top-down and (2) bottomup. A bottom-up analysis proceeds upwards from the leaves of the call graph, and analyzes each procedure in the most general calling context and builds its summary. In contrast, a top-down analysis starts from the root of the call graph, and proceeds downward, analyzing each procedure in its calling context. Top-down analyses have several applications in verification and software model checking. However, traditionally, bottom-up analyses have been easier to scale and parallelize than top-down analyses. In this paper, we propose a generic framework, BOLT, which uses MapReduce style parallelism to scale top-down analyses. In particular, we consider top-down analyses that are demand driven, such as the ones used for software model checking. In such analyses, each intraprocedural analysis happens in the context of a reachability query. A query Q over a procedure P results in query tree that consists of sub-queries over the procedures called by P . The key insight in BOLT is that the query tree can be explored in parallel using MapReduce style parallelism -- the map stage can be used to run a set of enabled queries in parallel, and the reduce stage can be used to manage inter-dependencies between queries. Iterating the map and reduce stages alternately, we can exploit the parallelism inherent in top-down analyses. Another unique feature of BOLT is that it is parameterized by the algorithm used for intraprocedural analysis. Several kinds of analyses, including may analyses, mustanalyses, and may-must-analyses can be parallelized using BOLT. We have implemented the BOLT framework and instantiated the intraprocedural parameter with a may-must-analysis. We have run BOLT on a test suite consisting of 45 Microsoft Windows device drivers and 150 safety properties. Our results demonstrate an average speedup of 3.71x and a maximum speedup of 7.4x (with 8 cores) over a sequential analysis. Moreover, in several checks where a sequential analysis fails, BOLT is able to successfully complete its analysis.

Collision Reduction Using Modified Q-Algorithm with Moving Readers in LED-ID System

LED-ID (Light Emitting Diode - Identification) is one of the key technologies for identification, data transmission, and illumination simultaneously. This is the new paradigm in the identification technology environment. There are many issues are still now challenging to achieve high performance in LED-ID system. Collision issue is one of them. Actually this is the most significant issue in all identification system. LED-ID system also suffers from collision problem. In our system, collision occurs when two or more readers transmit data to tag at the same time or vice versa. There are many anti-collision protocols to resolve this problem; such as: Slotted ALOHA, Basic Frame Slotted ALOHA, Query Tree, Tree Splitting, and Q-Algorithm etc. In this paper, we propose modified Q-Algorithm to resolve collision at tag. The proposed protocol is based on Q-Algorithm and used the information of arrived readers to a tag from neighbor. The information includes transmitting slot number of readers and the number of readers that can be arrived in next slot. Our proposed protocol can reduce the numbers of collision slot and the successful time to identify all readers. In this paper our simulation and theoretical results are presented.

Optimizing XML twig queries with full-text predicates

Efficient query processing has been a critical issue for XML repositories. In this paper, we consider the XML query which can be represented as a query tree with twig patterns, and also consists of full-text constraints. Previously, the structure-first approach and the keyword-first approach have been proposed to process such kind of queries. The main focus of this paper is constructing an integrated system to support these two approaches and find the best execution plan. To achieve this goal, we first analyze the components of these two approaches and design a set of operators. We then derive the corresponding cost model and rewriting rules to perform costbased optimization. We also propose several heuristic rules by observing the behaviors of the two approaches. Via an extensive experimental study, we demonstrate that our cost-based system and heuristic system are both effective.

Optimization of spatial join using constraints based- clustering techniques

Spatial joins are used to combine the spatial objects. The efficient processing depends upon the spatial queries. The execution time and input/output (I/O) time of spatial queries are crucial, because the spatial objects are very large and have several relations. In this article, we use several techniques to improve the efficiency of the spatial join; 1. We use R*-trees for spatial queries since R*-trees are very suitable for supporting spatial queries as it is one of the efficient member of R-tree family; 2. The different shapes namely point, line, polygon and rectangle are used for isolating and clustering the spatial objects; 3. We use scales with the shapes for spatial distribution. We also present several techniques forimproving its execution time with respect to the central processing unit (CPU) and I/O-time. In the proposed constraints based spatial join algorithm, total execution time is improved compared with the existing approach in order of magnitude. Using a buffer of reasonable size, the I/O time is optimal. The performance of the various approaches is investigated with the synthesized and real data set and the experimental results are compared with the large data sets from real applications. Key words: Spatial data mining, spatial clustering, spatial queries, spatial join

Heuristic Query Tree Protocol: Use of Known Tags for RFID Tag Anti-Collision

†SUMMARY Existing query tree protocols deal with RFID tags in a blind manner. They query tags in a fixed bit order based on the assumption that the tag ID numbers are uniformly distributed throughout the range of the entire ID space because readers have no prior knowledge of the tags. This paper attempts to distinguish RFID applications where readers are already aware of all tags used by the application. We propose a heuristic query tree (H-QT) protocol that uses heuristic to select effective bits from known tags for the best queries in a divide and conquer approach. The performance evaluation shows that the proposed protocol is superior to original query tree protocols because it significantly reduces the number of tag collisions and no tag response.

Minimal Query Algorithm of XML Document Based on Unconstrained Tree Pattern

XML document structure uses the tree structure to express the document structure model that is different from the traditional two-dimensional relational table structure and XML query patterns mainly for tree query. Tree pattern always divided into constrained type and unconstrained type. This paper based on unconstrained tree pattern query, provide a mini algorithm of unconstrained tree pattern query, and prove the correctness of algorithm theoretically.

Efficiency of TreeMatch Algorithm in XML Tree Pattern Matching

In Recent days exchange XML data more often in organizations and business sectors, so there is an increasing need for effective and efficient processing of queries on XML data. This paper presents a wide analysis to identify the efficiency of XML tree pattern matching algorithms. Previous years many methods have been proposed to match XML tree queries efficiently. In particularly TwigStack, OrderedTJ, TJFast and TreeMatch algorithms. All algorithms to achieve something through these own ways like structural relationship including Parent - Child (P-C) relationship (denoted as '/') and Ancestor-Descendent (A-D) relationships (denoted as '//') and more. Finally, we report our results to show that which algorithm is superior to previous approaches in terms of the performance. Keywords - Efficient TPQ, Efficiency of Tree pattern, XML Tree pattern

Effective Processing of Constraints based Spatial Join using R-Trees

Problem statement: This study focuses on the spatial join effects with the constraints-based spatial data without any extra cost and Finding the minimum execution time of the spatial query and spatial selection method. Approach: Spatial joins are used to combine the spatial objects. The efficient processing depends upon the spatial queries. The execution time and I/O time of spatial queries are crucial, because the spatial objects are very large and have several relations. In this article, we use several techniques to improve the efficiency of the spatial join. (1) We use R*-trees for spatial queries since R*-trees are very suitable for supporting spatial queries as it is one of the efficient member of R-tree family. (2) The different shapes namely point, line, polygon and rectangle are used for isolating and clustering the spatial onjects. (3) We use scales with the shapes for spatial distribution. We also present several techniques for improving its execution time with respect to the CPU and I/O-time. In the proposed constraints based spatial join algorithm, total execution time is improved compared with the existing approach in order of magnitude. Using a buffer of reasonable size, the I/O time is optimal. The performance of the various approaches is investigated with the synthesized and real data set and the experimental results are compared with the large data sets from real applications. Results: The R*-tree concept reduce the number of search pages to combine spatial objects. By using this, CPU utilization time increases, the number of comparisons of spatial objects can be reduced and also reduces the I/O time. Conclusion/Recommendations: The performance of the various approaches is investigated with the synthesized and real data set and the experimental results are compared with the large data sets from real applications.

An Approach for Optimizing Relational Provenance Storage

Modern data management has to deal with data from different sources with different quality, therefore, supporting data provenance in the system level and allowing users to know where data comes from and how it was derived have become a critical research topic. Annotation is one of approaches to track provenance. However, storing fine-grained annotations can be expensive as the complete annotations for the data may outsize the storage space required for the data itself. In this paper, we propose a framework for storing provenance information relating to data derived via relational queries, using provenance trees which match the query structure to avoid redundant storage of information about the derivation process. Within this framework, we come up with a series of storage optimization methods against the relational queries to make good choices of query tree nodes where provenance information should be stored. Our optimization algorithms run in time polynomial in the query size and linear in the size of the provenance, thus enabling provenance tracking and optimization without incurring large overheads. This framework is a new idea for the data tracing study and has a wide range of applications.

Enhanced Anti-Collision Protocol for Identification Systems: Binary Slotted Query Tree Algorithm

An anti-collision protocol which tries to minimize the collision probability and identification time is the most important factor in all identification technologies. This paper focuses on methods to improve the efficiency of tag's process in identification systems. Our scheme, Binary Slotted Query Tree (BSQT) algorithm, is a memoryless protocol that identifies an object's ID more efficiently by removing the unnecessary prefixes of the traditional Query Tree (QT) algorithm. With enhanced QT algorithm, the reader will broadcast 1 bit and wait the response from the tags but the difference in this scheme is the reader will listen in 2 slots (slot 1 is for 0 bit Tags and slot 2 is for 1 bit Tags). Base on the responses the reader will decide next broadcasted bit. This will help for the reader to remove some unnecessary broadcasted bits which no tags will response. Numerical and simulation results show that the proposed scheme decreases the tag identification time by reducing the overall number of request.

S 3: Processing tree-pattern XML queries with all logical operators

XML is a tree-based data representation format which combines data and structure. Therefore, XML queries not only contain predicates to filter data but also refer to relationships between document elements searched. The existing elements in an XML query are connected to each other using a tree-pattern structure, called Query Tree Pattern (QTP). Finding elements of a document, which satisfy the given QTP, is the main task during query execution. To optimize this processing, we presented two methods in [13]. Instead of directly executing the QTP against the document, our methods first evaluate a guidance structure, called QueryGuide. Using the extracted information, called match pattern, we provided a focused document access and minimized the required I/O. However, we only supported the logical operator AND (called AND-QTPs). In this paper, we use a new structure, called Evaluation Tree, to execute QTPs. We also extend our method to support QTPs having logical operators OR, XOR, and NOT. Parsing QTPs into some AND-QTPs is typically assumed non-efficient. To process QTPs having logical operators OR and NOT, we therefore parse them but we use an efficient method to prevent redundant I/O and QTP matching. This is done by optimizing the selection of match patterns which were derived from the QueryGuide during QTP parsing. As a result, QTP execution is not inefficient anymore.