Buddy tracking — efficient proximity detection among mobile friends

Abstract

Global positioning systems (GPS) and mobile phone networks make it possible to track individual users with an increasing accuracy. It is natural to ask whether this information can be used to maintain social networks. In such a network each user wishes to be informed whenever one of a list of other users, called the user’s friends, appears in the user’s vicinity. In contrast to more traditional positioning based algorithms, the computation here depends not only on the user’s own position on a static map, but also on the dynamic position of the user’s friends. Hence it requires both communication and computation resources. The computation can be carried out either between the individual users in a peer-to-peer fashion or by centralized servers where computation and data can be collected at one central location. In the peer-to-peer model, a novel algorithm for minimizing the number of location update messages between pairs of friends is presented. We also present an efficient algorithm for the centralized model, based on region hierarchy and quadtrees. The paper provides an analysis of the two algorithms, compares them with a naive approach, and evaluates them on user motions generated by the IBM City Simulator system.

Introduction

Global positioning systems and mobile phone networks make it possible to track individual users with an increasing accuracy. One attractive application of knowing the geographic location of users is to compute and maintain social networks. In these networks, each user may specify or be associated with a group of other users, called the user’s friends. Whenever a friend moves into the user’s vicinity, both users are notified by a proximity alert message. In a more general context, a social group is one that is predefined by enrollment or by matching the personal profiles of users. A group may refer to a list of individuals but also to other groups of individuals [4], [7].

We use the term vicinity to refer to a region around the user. In this paper, a vicinity is represented by a circle of a pre-specified radius, which can be uniform for all users, or defined for each pair of friends. The proposed algorithm for the peer-to-peer model can naturally accommodate a different vicinity radius for each pair of friends, as well as other convex vicinities. Other definitions of vicinity, and even dynamically changing definitions, are possible. For example, the radius might change between daytime and night time, it might depend on the user’s location, and it might be a non-circular shape.

The problem of maintaining social networks is a form of a dynamic, continuous query into a database of multiple moving entities. In some applications this could as well be part of a “find” query, coupled with other properties, such as profession, employer, user profile or calendar scheduling constraint. A natural example is of a traveling businessman who attends a large conference and would like to be alerted and possibly meet other colleagues if they happen to be around. Other examples could be a road side service, where service cars need to be dynamically assigned to new customers, or a surveillance system which tracks multiple suspects and directs security personnel. Note, however, that if one would try to implement such a query in a traditional database, this would require continuous updating of the locations of all moving entities, or users, as well as a repetitive computation of all friend’s distances after each such location update. This would be a very inefficient process.

Maintaining social networks based on user locations is an interesting problem from the aspect of computational geometry and from a database perspective. It is also interesting from the point of view of a distributed system; the process is computationally expensive, but there is an efficient way to split the computational task among different geographic locations.

We distinguish between two different computational frameworks. In the centralized computation model, users send their location information to a centralized server which keeps track of each user’s location and list of friends and is responsible for computing and sending the alert messages to all pairs of friends. The second, peer-to-peer computation model involves no central server. Instead, each pair of friends is responsible for keeping each other informed about their location, detecting vicinity events, and transmitting alert messages.

The peer-to-peer model suggests several benefits, including:

Privacy. This model ensures that a user’s location is only known by the user and its friends. At any time, a user may exchange location update messages with only those specific users it wishes to.

Energy efficiency. In general, battery drainage of small mobile devices resulting from communications is far more significant than the energy needed for computing. For example, it was shown [18] that under Rayleigh fading and fourth power distance loss, the energy cost of transmitting 1 KB a distance of 100 m is approximately the same as executing three million instructions on a 100 MIPS/W processor. The peer-to-peer model minimizes the number of location update messages sent by the user, at the expense of a much-less-costly increase in computation.

Localization, flexibility. The peer-to-peer algorithm may be implemented by a group of mobile device users without any need to modify the infrastructure of the communication provider. All they need is to agree upon a protocol to exchange location messages and to apply the proposed algorithm. This approach is best suited to ad-hoc networks.

Under both frameworks there is a need for communication resources as well as for computational resources. Communication is required to deliver location updates and alerts. We characterize the amount of communication by the number of messages being exchanged, assuming that all the messages are of fixed length (i.e., a location update sent to $k$ users, for example, would require $O\left(k\right)$ messages). A message between two users is assumed to cost the same as a message from a user to a centralized server, although some implementations might have a constant factor between them. In addition, computational resources are needed, either on the server or on the participating moving devices, to keep and maintain data structures and to generate proximity alerts. In this paper we consider both the communication and the computation resources. We focus, however, on reducing the communication complexity, as air time and battery life seem to be the more expensive and restrictive implications in building a real system.

There are several considerations that impact both computational and communication complexities. A major consideration is the maximum expected velocity of users and the desired time/distance accuracy of alerts. Let us consider two users who wish to get an alert when the distance between them becomes smaller than $R$. Obviously, one cannot guarantee such an exact alert, as this would require an infinitely large number of location updates and distance computations to find the exact moment at which the users reach a separation of $R$. To overcome this problem we introduce a distance tolerance into the task. An alert needs to be sent before they are within a distance $R$ of each other, but not earlier than a distance of $R+\epsilon$. This model allows us to compute how many messages would be required to achieve any desired alert accuracy. Last, it is assumed that messages are transferred with no delay. This is equivalent to the assumption $v\cdot t_{\mathrm{delay}}<\epsilon$, for $v$ representing the velocity and thus a distance tolerance at the time of receiving the alert, $R-\epsilon$, can naturally incorporate such practically small delays.

The evaluation of an algorithm for maintaining social networks is an important issue. The number of messages would depend not only on the number of users, $n$, the distances between them, the vicinity radius $R$ and the desired tolerance $\epsilon$, but also on the nature of their motion trajectories and relations between them. In the computational geometry literature, the kinetic model (see [8], [9], [13]) is a common paradigm for evaluating the efficiency of algorithms for maintaining dynamic structures. In this paradigm, the role of the evaluated algorithm is to maintain some geometric properties for sets of moving elements, where each element moves along a low-degree algebraic curve. From time to time, an event occurs, in which new elements may be inserted and existing elements may be deleted or may change their trajectories. The number of changes in the data structure is evaluated as a function of the number of events in the dynamic input data set. This part of our analysis is not shown here due to space constraints, and is found in [6].

In cellular networks (e.g. mobile phone networks), a partial approach for maintaining social networks is to try to take advantage of the natural cells structure imposed by the network. If $R$ is approximately the radius of a cell, then one needs to keep track of friends registered to the user’s own cell and neighboring cells. However, in general this approach may be unsatisfactory because the cell sizes vary greatly, ranging from large macro cells in rural areas to tiny pico cells in metropolitan areas and buildings. Different users might as well define different vicinity radii for different friends, and these might even change when they move from one place to another. For example, a marketing manager does not want to be alerted in his office of all his colleagues who are close by in the office, but may want such alerts when the same colleagues are within a city block distance on an overseas trip, as this is a chance encounter. Also note that not all wireless communication is based on cellular networks in the first place.

Algorithms for tracking moving objects are found in the mobile computing literature, both in the database community and in the mobile communications community. Much of the work assumes that moving objects are represented by simple point objects whose locations are continuously updated in an index. This however requires continuous updating of the locations of all users, which would necessitate a huge number of location messages. Trajectory-based algorithms are becoming increasingly popular [19], [20]. Storing and indexing trajectories facilitates not only efficient spatial range queries, but also time-and-space range queries [2]. See also [1], [21]. The paper [22] discusses time-parameterized bounding rectangles and extends trajectory information with expiration information.

There is a large body of literature on maintaining a specific property of moving objects. For example, a randomized algorithm for maintaining the binary space partition of moving objects is discussed in [3], and the maintenance of the dynamic Voronoi diagram of a set of moving points in a plane is presented in [14]. For maintaining and querying a database of moving objects, see [27]. The paper [17] suggested the method of safety zones, in a method similar to the one suggested in our paper. The idea is to divide the plane into regions with the property that as long as points do not enter safety zone, no message need to be exchanged between the points.

Various algorithms have been provided for indexing moving points. A quadtree based algorithm for indexing is given by [26]. Their main idea is to use a linear function of time for each of the dynamic attributes of the object, and to provide methods to regenerate the quadtree. An $R^{\ast }$-tree based algorithm is given by [23]. Their algorithm provides indexing of objects moving in 1, 2 or 3 dimensions. For other work in query processing for moving points, see e.g. [12], which proposes algorithms for range query and $k$ nearest neighbors.

While the dynamic data structures or databases mentioned above may be efficient for other types of queries, the task in hand is not efficiently handled by any of them. For example, some of these data structures might be used for querying which of a user’s friends are in his vicinity a particular time. Consider that today there are hundreds of millions of mobile phone users in the world. Continuously tracking all users and querying their vicinities in such a large population requires a huge number of messages to be exchanged as well as a lot of computation and is very inefficient. To the best of our knowledge, the problem of maintaining social networks has not been addressed before. The algorithms and data structures proposed in this paper are designed to efficiently handle this task. However they might not be as efficient for other, traditional types of spatial queries, thus being complementary to the above previous work. This work is also complementary to the problem of finding people whose personal profiles match. For this problem, commercial solutions have been offered (see e.g. [15]).

We present a novel distributed algorithm, denoted as the strips algorithm, in which a pair of moving friends make an agreement about a static buffer region between them. After the agreement is made, they do not need to track each others location until one of them enters the buffer region for the first time. By doing so, the agreement is terminated. Hence they exchange a location update message between them, check if they are within the $R$-vicinity of each other, and otherwise make a new agreement on a new static buffer region. We provide both an exact and an approximate strips algorithm, supported by analytical and empirical results that show their efficiency.

When analyzing an algorithm for such a problem, one has to consider both communication and computation complexity. For this distributed algorithm we focus on reducing the communication complexity, or the required “air time”, which has a significant impact on the battery lifetime of a mobile communication device. It is shown that the number of messages is logarithmic in the distance between the users when they start to approach each other from far away. It is also logarithmic in $1/\epsilon$ when they are getting closer, where $\epsilon$ is the desired tolerance for producing the proximity alert. Hence we consider it to be a very efficient algorithm.

A second, quadtree based algorithm is presented for the centralized approach. This algorithm aims at reducing the computational cost, assuming that all users periodically update the server with their location as they move. Somewhat surprisingly, we found that the quadtree based centralized algorithm is inferior to a centralized implementation of the strips algorithm on such a central server.