Efficient data dissemination using locale covers

Location-dependent data are central to many emerging applications, ranging from traffic information services to sensor networks. The standard pull- and push-based data dissemination models become unworkable since the data volumes and number of clients are high.We address this problem using locale covers, a subset of the original set of locations of interest, chosen to include at least one location in a suitably defined neighborhood of any client. Since location-dependent values are highly correlated with location, a query can be answered using a location close to the query point. Typical closeness measures might be Euclidean distance, or a $k$-nearest neighbor criterion.We show that location-dependent queries may be answered satisfactorily using locale covers. Our approach is independent of locations and speeds of clients, and is applicable to mobile clients.We also introduce a nested locale cover scheme that ensures fair access latencies, and allows clients to refine the accuracy of their information over time. We also prove two important results: one regarding the greedy algorithm for sensor covers and the other pertaining to randomized locale covers for $k$-nearest neighbor queries.     

Sequencing by hybridization in few rounds

Sequencing by Hybridization (SBH) is a method for reconstructing an unknown DNA string based on obtaining, through hybridization experiments, whether certain short strings appear in the target string. Following Margaritis and Skiena (1995) [12], we study the SBH in rounds problem: The goal is to reconstruct an unknown string A (over a fixed alphabet) using queries of the form “does the string S appear in A?” for some query string S. The queries are performed in rounds, where the queries in each round depend on the answers to the queries in the previous rounds. We show that almost all strings of length n can be reconstructed in ${\log }^{1}n$ rounds with $O(n)$ queries per round. We also consider a variant of the problem in which for each substring query S, the answer is whether S appears once in the string A, appears at least twice in A, or does not appear in A. For this problem, we show that almost all strings can be reconstructed in 2 rounds of $O(n)$ queries. Our results improve the previous results of Margaritis and Skiena (1995) [12] and Frieze and Halldórsson (2002) [8].     

Constructing special k-dominating sets using variations on the greedy algorithm

This paper focuses on the efficient selection of a special type of subset of network nodes, which we call a $k$-SPR set, for the purpose of coordinating the routing of messages through a network. Such a set is a special $k$-hop-connected $k$-dominating set that has an additional property that promotes the regular occurrence of routers in all directions. The distributed algorithms introduced here for obtaining a $k$-SPR set require that each node broadcast at most three messages to its $k$-hop neighbors. These transmissions can be made asynchronously. The time required to send these messages and the sizes of the resulting sets are compared by means of data collected from simulations.The main contribution is the adaptation of some variations of the distributed greedy algorithms to the problem of generating a small $k$-SPR set. These variations are much faster than the standard distributed greedy algorithm. Yet, when used with a sensible choice for a certain parameter, our empirical evidence strongly suggests that the resulting set size will generally be very close to the set size for the standard greedy algorithms.     

Uniform unweighted set cover: The power of non-oblivious local search

We are given $n$ base elements and a finite collection of subsets of them. The size of any subset varies between $p$ to $k$ ($p<k$). In addition, we assume that the input contains all possible subsets of size $p$. Our objective is to find a subcollection of minimum-cardinality which covers all the elements. This problem is known to be NP-hard. We provide two approximation algorithms for it, one for the generic case, and an improved one for the special case of $(p,k)=(2,4)$.The algorithm for the generic case is a greedy one, based on packing phases: at each phase we pick a collection of disjoint subsets covering $i$ new elements, starting from $i=k$ down to $i=p+1$. At a final step we cover the remaining base elements by the subsets of size $p$. We derive the exact performance guarantee of this algorithm for all values of $k$ and $p$, which is less than $H_k$, where $H_k$ is the $k$’th harmonic number. However, the algorithm exhibits the known improvement methods over the greedy one for the unweighted $k$-set cover problem (in which subset sizes are only restricted not to exceed $k$), and hence it serves as a benchmark for our improved algorithm.The improved algorithm for the special case of $(p,k)=(2,4)$ is based on non-oblivious local search: it starts with a feasible cover, and then repeatedly tries to replace sets of size 3 and 4 so as to maximize an objective function which prefers big sets over small ones. For this case, our generic algorithm achieves an asymptotic approximation ratio of $1.5+?$, and the local search algorithm achieves a better ratio, which is bounded by $1.458333\dots +?$.     

Bounds on the cover time of parallel rotor walks

The rotor-router mechanism was introduced as a deterministic alternative to the random walk in undirected graphs. In this model, a set of k identical walkers is deployed in parallel, starting from a chosen subset of nodes, and moving around the graph in synchronous steps. During the process, each node successively propagates walkers visiting it along its outgoing arcs in round-robin fashion, according to a fixed ordering. We consider the cover time of such a system, i.e., the number of steps after which each node has been visited by at least one walk, regardless of the initialization of the walks. We show that for any graph with m edges and diameter D, this cover time is at most $\mathrm{\Theta }(mD/\log k)$ and at least $\mathrm{\Theta }(mD/k)$, which corresponds to a speedup of between $\mathrm{\Theta }(\log k)$ and $\mathrm{\Theta }(k)$ with respect to the cover time of a single walk.     

Highly concurrent multi-word synchronization

The design of concurrent data structures is greatly facilitated by the availability of synchronization operations that atomically modify $k$ arbitrary items, such as $k$-read–modify–write ($k\text{<mi mathsize="small" is="true">RMW</mi>}$). Aiming to increase concurrency in order to exploit the parallelism offered by today’s multi-core and multi-processing architectures, we propose a highly concurrent software implementation of $k\text{<mi mathsize="small" is="true">RMW</mi>}$, with only constant space overhead. Our algorithm ensures that two operations delay each other only if they are within distance $O\left(k\right)$ in the conflict graph, induced by the operations’ data items.The algorithm uses double compare-and-swap (dcas). When dcas is not supported by the architecture, the algorithm of Attiya and Dagan (2001) [3] can be used to replace dcas with (unary) cas, with only a slight increase in the interference among operations.     

The best keying protocol for sensor networks

Many sensor networks (especially networks of mobile sensors or networks that are deployed to monitor crisis situations) are deployed in an arbitrary and unplanned fashion. Thus, any sensor in such a network can end up being adjacent to any other sensor in the network. To secure the communications between every pair of adjacent sensors in such a network, each sensor $x$ in the network needs to store $n?1$ symmetric keys that sensor $x$ shares with all the other sensors, where $n$ is an upper bound on the number of sensors in the network. This storage requirement of the keying protocol is rather severe, especially when $n$ is large and the available storage in each sensor is modest. Earlier efforts to redesign this keying protocol and reduce the number of keys to be stored in each sensor have produced protocols that are vulnerable to impersonation, eavesdropping, and collusion attacks. In this paper, we present a fully secure keying protocol where each sensor needs to store $(n+1)/2$ keys, which is much less than the $n?1$ keys that need to be stored in each sensor in the original keying protocol. We also show that in any fully secure keying protocol, each sensor needs to store at least $(n?1)/2$ keys.