QUERY AS REGION PARTITION IN MANAGING MOVING OBJECTS FOR CONCURRENT CONTINUOUS QUERY

International Journal of Research in Computer Science
eISSN 2249-8265 Volume 2 Issue 1 (2011) pp. 1-6
© White Globe Publications
www.ijorcs.org

QUERY AS REGION PARTITION IN MANAGING MOVING
OBJECTS FOR CONCURRENT CONTINUOUS QUERY
Ming Qi1, Guangzhong Sun2, Yun Xu3
*School of Computer Science and Technology
University of Science and Technology of China

Abstract: Applications in location-based services One of the most important techniques in LBS
rely on the efficient management of large scale moving applications is for managing and querying moving
objects, and one of the most important operations is objects. And much more often than not, these query is
real-time continuous query over moving objects, such continuous query [10] [13] rather than snapshot
as monitoring the objects of a certain region. In order queries, which makes one of the distinguished
to satisfy the high throughput and handle real-time characteristics of LBS [10].
updates and queries, it is a good choice to introduce
Besides, since the main memory has been much
multi-core parallel processing and managing spatial
more inexpensive and much more available in large
indices in main memory. In this paper, we propose a
capacity, the index structures used for real-time query
new scheme of processing continuous query on a novel
should be in main memory instead of in the hard disk.
spatial index based on uniform grid which is proved to
be a good indexing scheme in main memory. The So, in this paper, we mainly focus on the
novelty of our index is to manage query region as the management of massive moving objects, indexing
partition in the spatial index, which unified the index them in main memory and providing the read-time
updating and query processing. Our experiments response for location updating and continuous queries.
indicate that this sophisticated approach has better To enhance the performance, we use multi- thread
performance especially when the query is rather share memory parallelization on multi-core systems,
stationary. with effective concurrency controls. The contributions
of this paper are mainly:
Keywords: spatial data indexing, continuous query,
query as region partition, parallel computing 1. An novel index structure for moving object
management, which is using query as partition as
I. INTRODUCTION well, and unifying the updating of the location and
updating of the query result.
Nowadays, moving devices such as GPS devices,
2. Sophisticated algorithms for update and query
location- aware sensors and RFID objects are growing
operations that are especially designed for our
explosively. In the near future, computing will be
index. With these algorithms, performance of
ubiquitous, and Location- Based Service (LBS) will be
continuous query will be greatly improved.
widely used in everyday life. Many LBS applications
3. Concurrency controls especially designed for
is based on query on spatial data, and many appli-
moving object management with different lock
cations have been studied and commercialized, for
grain levels, which are designed respectively for
example, vehicle monitoring [12][13] and finding
high-throughput operations and the less-frequent
friends or services near your site[14].
structure alternation operation.
To efficiently support these LBS applications, 4. And both algorithms and concurrency controls are
several spatial/spatial-temporal indices have been analyzed and experimented with real-sized
studied [1], such as R-tree[8][9], Kd-tree[7] and grid- environments.
file[15] etc. In applications with real-time response
The rest of this paper is organized as follows:
requirement and high-throughput de- mand, because of
Section 2 reviews some related works about moving
the massive users’ updating and querying, the
objects indexing, continuous query, as well as
performance is very likely to be a problem. To meet
concurrency controls; Section 3 describes the index
with the high-performance and real-time requirement,
structure and its operations; Section 4 provides
parallel computing should be considered instead of
concurrency controls of updating and querying in
using single CPU thread. Besides, the update and
detail, with correctness proved briefly; experiments of
query requests in fact come to the server concurrently,
the update and query performance are in Section 6; and
it is more natural to process these requests in parallel
finally some conclusions and future works are
to minimize the response time.
discussed in Section 7.

www.ijorcs.org

2 Ming Qi, Guangzhong Sun, Yun Xu

A. Problem Formulation and Operations
II. RELATED WORKS
Assumptions are made toward this problem: Each
With the rapid growth of mobile devices, moving
object is abstracted to a 2-dimensional point; all the
object management and spatial access methods
index structures are in the main memory, and
become a hot research field. Paper [5] compares
additional attributes related to the specific application
uniform grid structure and structures based on R-tree
are in the secondary storage, which is not considered
for indexing moving objects in main memory, which
in this paper.
shows that “the grid can compete with R- tree in query
performance and robust to varying parameters of The moving objects management contains mainly
workloads” [5]. However, paper [5] does not involve four types of operations:
concurrency or parallel processing, which could not
A where-am-I operation is to find the given
utilize the multi-core resources.
location in the index, which is usually used in the
Besides the uniform grid and R-tree, kd-tree [6] and object location update.
KDB- tree [7] are also indices for 2-dimensional
An object location update operation is given the
points, and regional kd-tree is also a good choice for
object id and its new location coordinate, to find this
managing moving objects in main memory. However,
object, and if the old and new locations are in different
the design and analyze of a concurrent regional kd-tree
region, update the object in the structure according the
is to be studied.
new location. Traditionally, the location updating can
Concurrent location management for moving be seen as a transaction of a deletion operation
objects using Blink -tree on space-filling and R-tree or followed by an insert operation.
its variants has been studied by [11] and [12], which
A continuous region query operation is to retrieve
mainly used coarse-grain locks on regional cells and
the objects which are now inside the query.
locking coupling schemes. Paper [13] gives a
concurrent continuous query scheme on B-tree- based A query alteration operation is to create, delete or
framework with two specially designed hash tables, alter the continuous query by setting or modifying the
and delicate concurrency controls to ensure high-level location or the region of the query. In the LBS
consistency. applications, query alteration operation is much fewer
than the continuous region query operation. Each
Paper [2] studied in-memory structure for
query is a rectangle region with both sides parallel to
continuous queries, and provides a two layer grid
the coordinate axis, and to return the set of objects
scheme, which is with an optional second layer of
inside this region.
refined uniform grid to resolve the data skewness.
However, a hybrid structure with uniform grid and The update and continuous query operations should
regional kd-tree is more convenient to resolve the process concurrently in multi-thread environment, so
skewness problem and control the number of objects concurrency controls should be introduced to ensure
within a threshold; and second layer of grid may arise the data consistency. In order to achieve efficient
unnecessary partitions. Meanwhile, neither concurrent concurrent operations of the moving objects, the index
access method nor concurrency control is discussed in structure should have the following characteristics:
this paper.
1. The structure should be suitable to be in main
The previous works about continuous query, memory.
however, have a deficiency in common, that they did 2. The whole map should be divided into regions,
not use the data inside the structure itself to format the each region contains a bucket of objects.
query result but use a separate query result set. This 3. Given a location or an object id, find its region
separation causes data redundancy as well as the bucket efficiently.
complexity of data management, especially in 4. Update operations and continuous query
concurrent environments. operations in the index should have efficient
concurrent implementation.
III. NOVEL INDEX STRUCTURE 5. The query alteration operation should be
implemented in good amortized performance.
As we surveyed in the related studies, spatial
indices with regional partitioning is the primary access In this section, we use query as regional partition
method for indexing moving points in main memory. scheme on the uniform grid and kd-tree respectively,
Based on the fact that the query in LBS is rather from those we can achieve both much more efficient
continuous and stationary instead of dynamic, our continuous query as well as locate update.
approach is to also use the continuous query region as
part of the regional partition, so that the update and
query algorithms are greatly simplified.
B. Query as Regional Partition

www.ijorcs.org

Query as Region Partition in Managing Moving Objects for Concurrent Continuous Query 3

reference of the overlapping regions in maintained in
the overlapping_list in the auxiliary index.

C. Algorithms of Updating and Continuous Query
Through the spatial index and the auxiliary index,
we can then describe the algorithms for our operations.
Finding the region bucket of a given position, which is
Fig. 1. Query as Region Partition in Uniform Grid also the where-am-I operation is trivial in uniform grid
and also very straight forward in the kd-tree. And, in
To use query as partition in uniform grid is our scheme which uses make query region the same as
demonstrated in Figure 1. In every cell bucket of the region partition, the continuous query operation is just
uniform grid, the grid maintains a list of references of return the content that inside the query region. The
the query regions that are overlapping with this grid following is the algorithm of object location updating,
cell. And the region of this cell is presented as the in which we assume query region has the same
former rectangle region minus the overlapped region. behavior with other grid/kd-tree regions, except when
There may be more than one query regions which are the query regions are overlapping.
overlapping with this cell region, and one query may
OBJECTUPDATE(objectid, newpos)
be overlapping with several grid cells.
1. oldpos = getPosByAux(objectid);
2. if newpos is not in R1
3. R2 = getRegionByPos(newpos)
4. SwitchBetweenRegion(R1, R2, objectid);
5. Regions set O1 = OverlapSetInAux(objectid);
Fig. 2. Query as Region Partition in Regional Kd-tree 6. Regions set O2 = getOverlapByPos(newpos);
7. Regions set O = O1 ∩ O2;
In kd-tree, the query region can be managed the 8. for each region R in set O if O is not empty
same as in the uniform grid, instead that if the kd-tree 9. if the newpos is inside R and the oldpos is not
region is splitting or merging, the overlapping query
references list will be changed accordingly. Differently 10. insert a duplicate objectid into R
from the kd-tree regions, each query region is a 11. insert R into the O1
sustainable region that does not have overflow 12. if the oldpos is inside R and the newpos is not
threshold or any splitting strategy. 13. delete the element with objectid form R
The query region can be overlapped with each 14. delete R from O1
other. And, in our scheme, when query region is 15. setAuxPos(newPos);
overlapping each other, the objects in the intersect
subregion is to be duplicated and in each of the query The old position of the object is get form auxiliary
results. This is reasonable, because every query should index by object ID. The function getRegionByPos(pos)
has its result set. in this algorithm means to get the first query covers
pos, and if this grid cell have none query or none of the
queries covers this pos, return the cell region itself(in
this situation the pos is not in any queries but in the
cell region itself). On the contrary, the function
getOverlapByPos(pos) in this algorithm means to get
the queries that cover this pos after the first matched
query, and if no other query is matching, return empty.
So, in this algorithm, each element in the region set O1
and O2 this regions must be an overlapping query.
In the real applications, the non-overlapping is
common while the overlapping query is relatively
Fig. 3. The Auxiliary Index on Object ID
much fewer. So that the main work of object update is
The auxiliary index, which is in fact a hash table on to get two regions and switch the object from the old
object id, is like Figure 3. In the auxiliary, we can get one to the new one. If in the application system, the
the region reference (either normal region or query queries are definitely without any of the query
region) which the object is in. And, if this object has overlapping, this algorithm can be simplified.
duplicates in overlapping query regions, a list of

www.ijorcs.org


D. Query Creating, Deleting and Altering most common ways to synchronize a multi-thread
program is lock-based synchronization. Concurrency
If we are to create a new query into a uniform grid or
controls with mutexes, critical sections or semaphores
kdtree, there are generally three steps. can be seen as lock-based concurrency. There are
1. Step 1, initialize the new query with a query region technically two types of lock implementation: one is
and bucket. spin-lock, which is spinning in a loop, waiting for
2. Step 2, to get the region cells in the spatial index certain conditional status; the other one is to be
which are intersecting with the query region. In scheduled by kernel or mutex libraries with a signal
uniform grid, this step is trivial; and in kd-tree this waiting and waking up. Mutex locks and semaphores
step is a typical recursively region search, which are supported in operating systems, some
may be with multiple search paths. programming languages and thread libraries. In
3. Step 3, For each of these cells in Step 2, insert the paper[11], locks are implemented by Java
reference of this query into the query lists of this synchronized objects. In our paper, we use spin lock
cell, then move the objects of this cell whose and pthread_rwlock functions as synchronizing locks.
location is in the query region. The spin lock this paper used can be described as
If this new query is intersecting with another query, pseudocode:
then duplicate the objects of this query whose location 1. while (status ≠ condition) {
is in the query region. However, if this new query is 2. _asm PAUSE
somehow overlapping with more than one previous 3. sleep(0)
queries, objects should be duplicated from previous 4. }
queries but with same object only once.
PAUSE instruction here is to indicate the CPU to
When a query is ceased to exist, the deleting stop instruction prefetching, which can reduce the cost
processing is straightforward, which is to delete the of instruction emptying. sleep(0) can give CPU
query reference from correspondence grid or kd-tree ownership to other thread once while there is an
cells, and reinsert the objects this query contained into another ready thread, and keep running while there is
the correspondence grid or kd-tree cells. And, if one no other threads, so that this spin lock do not block any
object is to be reinsert into a overlapping query region, other ready threads, and the whole system running
check should be down to notify if this object has smoothly although the CPU load is 100%.
already have a object in it, and do nothing if so.
The auxiliary index is accessed only by object id,
Query altering, which is to alter the size and/or whose structure only change when the an object is
location of the query region, can be down by query creating or deleting; so, it is convenient to be
deleting and creating. However, as a more implemented by a threadsafe hash map. So in this
sophisticated process is as the follow steps, alike query paper, we do not pay much attention to the
creating: concurrency control of the auxiliary index.
1. Step 1, to get the region cells in the spatial index There is an optional implementation that using two
which are affected by this alternation, and modify different phrases for updating: during the querying
the query list when necessary. phrase all update requests are buffered and during the
2. Step 2, check the objects in these cells, move the executing phrase all the buffered requests are executed
object to the query bucket if the object is inside the in a batch. This is the simplified implementation many
new query region. system uses. However, in our concurrency controls,
3. Step 3, check the objects in the alternating query, if the reads and writes are mixed together, because the
one is to be ousted, reinsert it to other latest location should be provided to the query user,
corresponding cells. Similarly, object duplication and this is especially important when the updating is
should be checked if overlapping queries exist. very frequent and query is in realtime.
IV. CONCURRENT CONTROL Another idea is that managing the moving objects
in a proper transactional system such as Berkeley DB.
Now most commercial computer systems are multi- However, there is no proper database systems
core computer, mostly with 4 or 8 CPU cores, support specifically suit for the high frequent moving object
8 or 16 threads. To utilize the multi-core resource and management and continuous query, for which we
access our index concurrently with data consistent, we concern this paper.
should design the concurrent controls.
B. Fine-grain Lock on Updating and Querying
A. Concurrent Control Techniques
If the buckets in the index are implemented as a
To maintain data consistence of parallel accesses to
linked list, as we do in our paper, we can moving
the index, we introduce our concurrency controls. The
objects (linked list node) between different linked lists

www.ijorcs.org

Query as Region Partition in Managing Moving Objects for Concurrent Continuous Query 5

using a fine-grain lock. This fine grain lock only locks V. EXPERIMENTS AND RESULTS
the deleting list node and two involving list nodes
To evaluate the performance of our query-as-
which indicate the deleting and inserting position:
partition index and concurrency controls, we introduce
First, find the deleting list node by lock coupling, and a series of comparison experiments. The data set we
lock the deleting node while its predecessor node is mainly used is moving object set on the road network
also locked; in the new bucket, lock the insert position. in the city of Oldenburg [17]. In our experiments we
Beware of the order of locking to avoid deadlock. have compared between uniform and kd-tree index
Then, switch the next pointers so that delete the structures, various query/alteration ratio, and different
moving object from one list and insert into another. concurrent thread number.
Finally, unlock all the three nodes after pointers
In our experiment, the Oldenburg data set we use
switching. An example of fine-grain locked updating
contains 200,000 objects with coordinate (x; y) in the
of linked list bucket is shown in Figure 4(moving obj2
area about 30_30km2. The queries we use is random
from bucket1 to bucket2).
generated queries with random size within 6 _ 6km2.
In our experiment, we used a common 2-CPU server
with shared memory; each CPU is 4-core Intel Xeon
E5430 2.66GHz. The reason why we use a commercial
server rather a super computer is that, for most moving
objects management applications, a commercial server
is enough, and using a cluster of common servers
usually receives higher cost-effectiveness. Our
programs are implemented by gcc with POSIX pthread,
using spin-lock and pthread rwlock.

Fig. 4. The fine-grain locked update

The fine-grain lock scheme generally has better
concurrent performance, due to its refined lock and
higher concurrency. And, through the fine-grain lock,
the object moving between regions can be seen as
atomic operation, so that the inconsis- tent status is
Fig. 5. Update Performances on Grid and Kd-tree
avoided using the fine-grain lock.
C. Coarse-grain Lock on Structure Alteration We compare the performance on uniform grid and
kd-tree on various data volume in Figure 5. Generally,
For the operations of query creating, deleting and
uniform grid outperforms kd-tree in updating, because
altering, as well as region splitting/merging in kd-tree,
in grid, given a new position, where-am-I operation is
the coarse grain lock should be used to protect the
in O(1), while in kd-tree the where-am-I complexity is
whole area that the operation is affected.
O(lgB) (B is the bucket number all over this index ).
We use a read-lock, SIX-lock, and exclusive-lock
semaphore to implement the coarse-grain lock. Before
the altering operation, SIX-locks on these regions are
acquired, so that other operations cannot proceed.
Then, for every region should be locked, upgrade the
SIX-lock to exclusive-lock when all readlocks of this
region is released. Finally, after the alteration
operation, all the exclusive-locks are released.
Since there is nothing done to make sure a thread is
eventually get the lock, this coarse-grain lock is
deadlock-free but not starvation-free.
Fig. 6. Query Throughput on Various Query/Alteration
Ratio

www.ijorcs.org


In our scheme, continuous query processing and [2] D. Kalashnikov, S. Prabhakar, S. Hambrusch, Main
query region alteration have very different computing Memory Evaluation of Monitoring Queries Over
complexity, so the overall performance of query is Moving Objects, Distributed and Parallel Databases: An
greatly affected by the alteration ratio, Figure 6. When International Journal, Vol. 15, No. 2, pages 117-136,
2004.
the alteration ratio is 1:1, the query is not continuous at
[3] Maurice Herlihy and Nir Shavit. The Art of
all, our scheme do not have any advantage; when the Multiprocessor Programming. Elsevier 2008.
queries are rather continuous, the query operation is [4] Hector Garcia-Molina, Jeffret D. Ullman, Jennifer
just to return the content of the query bucket, which Widom. Database System: Implementation, Second
essentially reduced the complexity of the query. Edition. Pearson Education Inc. 2009.
[5] Darius ˇ Sdlauskas, Simonas ˇ Sltenis, Christian W.
Christiansen, Jan M. Johansen, Donatas ˇ Sulys. Trees
or Grids? Indexing Moving Objects in Main Memory.
In ACM GIS’09, November 4-6, 2009. Seattle, WA,
USA.
[6] Hanan Samet. Foundations of Multidimensional and
Metric Data Structures. Morgan Kaufmann Publishers,
2006.
[7] John T. Robinson. The K-D-B-Tree: A Search Structure
for Large Multideminsional Dynamic Indexes. In
Proceedings of the ACM SIGMOD International
conference on Management of data , 1981.
[8] Diane Greene. An Implementation and Performance
Fig. 7. Update Throughput Speedup Analysis of Spatial Data Access Methods. In
Proceedings. Fifth International Conference on Data
Using our concurrency control, we can access our Engineering, 1989.
index and proceed the operations concurrently. The [9] Antonin Guttman. R-trees: a dynamic index structure
update throughput scaling on various thread number is for spatial searching. SIGMOD Rec. 14, 2 (June 1984),
47-57. DOI=10.1145/971697.602266
shown in Figure 7. Since our fine-grain lock has
[10] Xiaopeng Xiong, Mohamed F. Mokbel, etc. Scalable
minimized the concurrent collision, the uniform grid Spatio-temporal Continuous Query Processing for
gains nearly linear speedup, and in the kd-tree, since Location-aware Services. In Proceedings of 16th
there are tree node splitting and merging, the speedup International Conference on Scientific and Statistical
is a little lower. Database Management 2004,(SSDBM04).
[11] Jing Dai, Chang-Tien Lu. CLAM: Concurrent Location
VI. CONCLUSIONS Management for Moving Objects. In ACM
International Symposium on Advances in Geographic
Through our designing and experimenting on our Information Systems, New York, NY, USA, 2007.
indices and concurrency controls, we can conclude [12] Chang-Tien Lu, Jing Dai, Ying Jin, Janak Mathuria.
that: using query region as spatial partition has a very GLIP: A Concurrency Control Protocol for Clipping
distinct predominance to previous continuous query Indexing, IEEE Transaction on Knowledge and Data
schemes, especially when the queries is rather Engineering, Vol.21, No.5, 2009.
stationary. Comparing the uniform grid and the kd-tree [13] Jing Dai, Chang-Tien Lu, Lien-Fu Lai. A Concurrency
used in memory for moving object management, the Control Protocol for Continuously Monitoring Moving
uniform grid outperforms kd-tree due to its simplicity. Objects. In Tenth International Conference on Mobile
And, using our concurrent control, both uniform grid Data Management: Systems, Services and Middleware
2009.
and kd-tree obtain a good parallel speedup.
[14] digu.com http://2011.digu.com/indexMap
The structures and techniques in this paper can give [15] Nievergelt, J., Hinterberger, H., and Sevcik, K. C. 1984.
us a new vision on moving object management The Grid File: An Adaptable, Symmetric Multikey File
indexing, which can also be used in other similar Structure. ACM Trans. Database Syst. 1984.
applications. Further study may focus on indexing [16] Harris, T. L., Fraser, K., and Pratt, I. A. 2002. A
Practical Multi-word Compare-and-Swap Operation. In
moving object with multiple attributes, more Proceedings of the 16th international Conference on
sophisticated concurrent continuous query and kNN Distributed Computing, 2002
query, or using more specialized index structures [17] Thomas Brinkhoff. Generating Network-Based Moving
effectively in realistic problems. Objects. In Proceedings 12th International Conference
on Scientific and Statistical Database Management,
VII.REFERENCES 2000, IEEE Computer Society Press
[1] Volker Gaede, Oliver G¨unther. Multidimensional
Access Methods. In ACM Computing Surveys (CSUR)
, Volume 30 Issue 2, June 1998.

www.ijorcs.org

QUERY AS REGION PARTITION IN MANAGING MOVING OBJECTS FOR CONCURRENT CONTINUOUS QUERY

More Related Content

What's hot (17)

Viewers also liked (6)

Similar to QUERY AS REGION PARTITION IN MANAGING MOVING OBJECTS FOR CONCURRENT CONTINUOUS QUERY (20)

More from IJORCS (20)

Recently uploaded (20)

QUERY AS REGION PARTITION IN MANAGING MOVING OBJECTS FOR CONCURRENT CONTINUOUS QUERY