We argued in Section 3 that it is important for sensor networks to have access to synchronized time. However, in Section 4, we described a wide variety of methods for synchronizing time. Is something new needed?
To answer this question, we it is important to first consider what sort of synchronization a sensor network needs. Because of the highly application-specific nature of a given network, it is hard to make generalizations--but even within a single application, time sync is needed at many layers, each with its on requirements. For example, consider all the potential uses of time-sync in an object tracking system:
sec but could be limited in
lifetime and local in scope.
Of course, underlying all of these requirements it the ever-present need for energy-efficiency. Ignorance of this requirement, while entirely justified in traditional contexts, is the Achilles' heel of most existing time synchronization methods. Although protocols such as NTP are conservative in their use of bandwidth, they are extremely inefficient in this new context where radios consume significant power even by passively listening for messages [PK00].
Cost and form-factor are also important restrictions. The smallest nodes in a network will, perhaps, be disposable and small enough to be attached directly to the phenomena that they are monitoring. These are unlikely to have room in their packaging or budgets that allows anything more than a local oscillator and a short-range radio.
We conclude, therefore, that no existing method meets a sensor net application's diverse synchronization requirements while still being compatible with the network's energy budget, cost structure, and form factor.
Something new is needed. But what?
While our earlier discussion highlights the inadequacy of current methods, it also gives structure to solutions. In this section, we outline the general design principles under which we plan to develop new methods of time synchronization for sensor networks.
The heterogeneity in the synchronization requirements across and within sensor network applications is daunting. Even without the constraints of limited energy, cost, and form-factor, no single method is likely to meet every one of these requirements. With these extra constraints, finding such a method seems a completely lost cause.
Because it is impossible for any single synchronization method to appropriate in all situations, sensors should have multiple methods available. By modifying existing methods, developing new ones, and even composing them into derivative methods, we hope to provide an entire palette of time sync methods that, taken together, covers a good portion of the parameter space we described in Section 2.
A multi-modal solution is also a good choice for building a system that is energy-efficient. If a node can dynamically trade error for energy, or scope for convergence time, it can avoid ``paying'' for something that it doesn't need. Ideally, the algorithms should also be tunable--allowing finer control over an algorithm than simply turning it on or off. Our goal is to implement and characterize a set of methods rich enough so that all applications will have one available that is necessary and sufficient for its needs.
Although Moore's law predicts that hardware for sensor networks will inexorably become smaller, cheaper, and more powerful, technological advances will never prevent the need to make tradeoffs. Even as our notions of metrics such as ``fast'' and ``small'' evolve, there will always be compromises: nodes will need to be faster or more energy-efficient, smaller or more capable, cheaper or more durable.
Instead of choosing a single hardware platform that makes a particular set of compromises, we believe an effective design is one that uses a tiered platform consisting of a heterogeneous collection of hardware. Larger, faster, and more expensive hardware (beacons, aggregation points) can be used more effectively by also using smaller, cheaper, and more limited nodes (sensors, tags). An analogy can be made to the memory hierarchy commonly found in desktop computer systems. CPUs typically have extremely expensive, fast on-chip cache, backed by slower but larger L2 cache, main memory, and ultimately on-disk swap space. This organization, combined with a tendency in computation for locality of reference, results in a memory system that appears to be as large and as cheap (per-byte) as the swap space, but as fast as the on-chip cache memory. In sensor networks, where localized algorithms are a primary design goal, similar benefits can be realized by creating the network from a spectrum of hardware ranging from small, cheap, and numerous, to large, expensive, and powerful.
The smallest nodes are unlikely to have little more than a local oscillator and a short-range radio. However, they can be supported by other nodes in the network that are better endowed, with longer-range radios capable of synchronizing with more remote parts of the network, or in some cases with external time sources such as GPS or WWVB.
Using these principles as a guide, we are building new time synchronization services for sensor networks. Specifically, we are
Starting down this path, we have developed a technique called post-facto synchronization to reconcile the need of many applications for accurate sensor event timestamps with the desire to keep the node off in order to conserve energy. In the next section, we describe this technique and an experiment that characterizes its performance.