Review for Paper: 10-The Design of an Acquisitional Query Processor For Sensor Networks

Review 1

Sensor networks must be able to operate autonomously for long periods without human intervention. Sensors spread large distances must use power efficiently to avoid losing battery life, while continuing to deliver data for queries about the world state. The challenge of designing a DBMS for sensor networks it to make ad hoc network communication and data collection power-efficient, while providing accurate results to queries.

The authors of “Design of an Acquisitional Query Processor for Sensor Networks” present the design and implementation of TinyDB, a DBMS they have produced for sensor networks. TinyDB embodies a novel kind of DBMS, the acquisitional query processor, that treats sensor data streams as a table, and guides the sensor nodes on what data to collect, when to collect it, and how to transmit it. TinyDB therefore can provide better energy efficiency than a database that treats the sensors' sample collection as fixed. An ACQP provides greater efficiency primarily by sampling only when needed, aggregating or filtering results near their source to reduce transmission of data, and increasing the time nodes spend idle.

The primary contribution of the paper is the design of ACQPs, specifically TinyDB. TinyDB has several novel features that reduce power consumption while keeping the system easy to use for scientists. For example, the TinyDB system automatically constructs an ad hoc, tree-structured network without oversight, based on messages sent (in broadcast mode) among nearby nodes. This tree structure of the network enables the semantic routing tree (SRT) technique, in which every node in a tree records the range of likely sensor values of its descendants; each node will not forward a query to descendants if their likely sensor values do not overlap with the query's predicate, thus reducing overhead for communication and sensor sampling.

One drawback in the design of TinyDB is its way of handling the case where a node's input streams overflow its buffer capacity before they can be communicated to the node's parent. TinyDB offers several options for dropping data points from the input queue of a node, such as combining the first two items into their mean. But presumably in a “bushy” tree structure, with many descendants of a given node, it is wasteful for the leaves to sample data that will largely be dropped before the root. Possibly the sample rate could be reduced in deeper nodes of a deep tree, to reduce waste from dropped data.


Review 2

The paper discusses the designing of a query processor-like interface to sensor networks. Such an interface is achieved by using acquisitional query processor which reduces power consumption when compared to traditional passive systems. For this purpose, the authors have designed and implemented an engine called TinyDB which is a distributed query processor that runs on each of the nodes in a sensor network. The basics of ACQL are expressed in the paper including Basic Language Features, event based queries and lifetime based queries.

The paper stresses optimizations based on power answering all the relevant questions as to where the optimization the done and why it is done. The process used by such an optimizer focuses on ordering joins, selections and sampling on individual nodes. After the query has been optimized, it is disseminated into the network. Semantic Routing trees are used for this since it can maintain a list of child attribute values so that if a node is not participating in a query, it can be disregarded. SRTs are limited to constant attributes. Even so, maintenance is required. It is possible to use for non-constant attributes but costs can be high.

The paper is successful in outlining the design of an acquisitional query processor for data collection in sensor networks providing all the base details along with evaluations of the methods involved. It also throws light on how it will proceed in the future, with more sophisticated prioritization schemes and better re-optimization of the acquired data.

But the paper is not able to address the question as to whether the approximation of battery lifetime is sufficient. Also the Semantic Routing Trees aren’t evaluated properly. The take on acquisitional query processor with respect to sensor networks provide an interesting read anyhow and can be worked upon in the future to tweak the issues.


Review 3

What is the problem addressed?
The paper proposes a design of an acquisitional query processor for data collection in sensor networks.

Why important?
At that time, smart sensor devices were matured enough to deploy large, distributed networks. Moreover the sensor networks are different from other wireless battery-powered environments in that they consist of large amount of units and absence of human interaction for a long period of time. Furthermore, sensor networks are often embedded into some physical environment to collect data. These nature of sensor networks need to a significantly altered view of software system than traditional mobile or distributed environments.

1-­‐2 main technical contributions? Describe.
Previous strategies with query processing in sensor networks include minimizing expensive communication by applying aggregation and filtering operations inside the sensor network. In contrast, the paper present acquisitional query processing (ACQP), which use the fact in sensor networks: smart sensors have control over where, when, and how often data is physically acquired and delivered to query processing operators. By focusing on the locations and costs of acquiring data, they are able to significantly reduce power consumption compared to traditional passive systems that assume the a priori existence of data.
The second contribution is that there database system TinyDB provides an Declarative Queries for Sensor Networks. Besides basic query, it support event based query, a variation for data acquisition, it supports events as a mechanism for initiating data collection.
The paper address choosing where to sample with semantic routing tree which is an index-like data structures, and enable disseminating queries and collecting query results for queries over constant attributes. For delivery the data, once results have been sampled and all local operators have been applied, they are enqueued onto a radio queue for delivery to the node’s parent, and the order is defined by different method one of the goal is preferring results that will most improve the “quality” of the answer.

1-­‐2 weaknesses or open questions? Describe and discuss
Acquisitional query processing provides a framework for addressing issues of when, where, and how often data is sampled and which data is delivered in distributed, embedded sensing environments.
One of an interesting problem would be how to improve the prioritization schemes. To capture the quality of the query answer we can use different signal processing method like Fourier analysis or wavelet analysis.


Review 4

This paper is fine!


Review 5

This paper presents a design of an Acquisitional Query Processor (ACQP) for sensor networks. More specifically, the author designed and built an ACQP engine which is called TinyDB (running on Berkeley Mica mote platform, TinyOS operating system). In short, this design is for acqusitional issues for data collection in sensor networks, which will affect how data is physically acquired or sampled and how data is delivered to query processing operators. This paper provides a discussion about key aspects of an acquisitional query language (event and lifetime clauses for controlling), query optimization, how event-based queries can be rewritten, an efficient mechanism for disseminating queries (semantic routing trees) and importance of prioritizing data.

The general problem here is that for sensor networks we have some special requirements different from common database. For example, sensor networks are often embedded into physical environment and we monitor and collect data from such networks, which makes it very important to achieve “long-term and low-power” nature. This gives us a different data view compared to traditional mobile or distributed environments. Then the concept of ACQP came out. It takes use of the fact that sensors often have many controls on data, and based on the control information we can develop a better system that reduces a lot of power consumption.

The major contribution of this paper is that first it provides a very detailed and clear description of the new design TinyDB, as well as the concept of ACQP. For example, there are several features of the acquisitional query language that are very different from traditional query language. The columns in sensor data represent different sensor types, and tuples are appended to table periodically. We can also pass a “sample intervals” parameter into a query. Thus the sensor table is conceptually a continuous and unbounded data steam of values. Second, it gives real example to illustrate how performance varies based on different implementations or optimization methods. For example, when talking about how to choose parent in semantic routing tree (SRT), it gives evaluation of different metrics and compares the result.

One interesting observation: I think the idea behind the design is brilliant. They noticed that the sensor data is very different from traditional data, and managed to build a new design that can improve the performance of sensor networks. Observing and retracing features from new things is a rare skill.


Review 6

In this paper, the authors discuss and propose a new design for an acquisitional query processor for sensor networks. While the previous work on data systems for sensor networks was concentrated on processing data and query in an energy-efficient manner assuming that the data exists a priori, this paper aims to solve the problem of when and where the sensors should collect data in response to a query. The paper takes into account the capabilities of sensors and due to the fact that sensors are limited in power resources, the goal is to find a power-efficient solution. To this end, the authors designed an acquisitional query language and methods on how the queries should be optimized and executed.

The main contribution of this paper is that it provides acquisitional query languages for various scenarios such as event-based queries, periodic queries, or lifetime based queries. This makes the proposed language more applicable. By providing different options on queries, the proposed design seems to fit well with various application scenarios of sensor networks. To name a few, sensor networks can be used for intrusion detection, environment monitoring, or infrastructure monitoring. In my opinion, the proposed architecture has a great opportunity to be easily applied in many sensor networks, because of the fact that the acquisitional query language can operate in many scenarios and it has high level of versatility.

Despite the appealing features and novel ideas, I think that the paper lacked some information or consideration on additionally required power in the following aspects.

- More discussions on the power consumption from setting up the Semantic Routing Trees (SRT) is required. Although it does bring some advantage in preventing unnecessary data dissemination into some subtrees, it requires not only a broadcast of a message but also their acknowledgements. This would mean that it requires a lot of messages to be transmitted in a bi-directional way. If the routing tree is unstable (e.g. frequent change of node values), the required overhead can get higher and lead to lower lifetime for sensors. If the authors were able to properly address such power issue from setting up the SRT, the idea would have been more appealing.

- The authors do not provide any information or analysis on the network synchronization overhead. Since the proposed acquisitional query processing for sensor networks requires all sensors to be synchronized, it would certainly have some synchronization overhead in the network. If the clock drifts were high between the sensors, network synchronization should be performed more frequently. If the authors were to comment on this issue more clearly, the proposed idea would have been more convincing.


Review 7

This paper focused on something that I would have never really thought of as an issue in database managements systems - power consumption. Typically when we are thinking about databases, we are thinking about high end machines, dedicated servers, or clusters of commodity machines - something connected to a steady stream of power. Very rarely do we think about extremely low power sensors as a DBMS.

The idea presented in this paper is novel. It suggest additions to the SQL language that would allow it to give commands to sensor networks. Users could specify how frequently they would like their data sampled, or how much time that would like to monitor the event, and the system will determine that highest sampling rate that it can achieve while still maintaining enough battery life to complete the query. The power considerations are the primary problem addressed by this paper. Since the user is unlikely to want to have to factor battery life into their query, the system must be able to estimate its own battery life and use that to modify the sampling rate that is uses for queries. These are called lifetime-based queries. The paper also covers how the sensors communicate in their system - they work by having the query begin at some root node, and it sends the message to all of its "children", or sensors that are within its radio range. Those children then begin doing some processing for the query, and send out the message to their children. It is important to note that the cost of transmission dominates power usage, primarily because of how much slower it communicates compared to how fast the CPU can compute. The authors then go into some more advanced techniques that can be used to further save power. These include storing metadata so that the system has a better idea of how much power certain operations will take, batching event based queries, and using semantic routing trees.

This paper did a good job of presenting the issues - low power, limited CPU and memory, sensors are hard to access physically - and some of the techniques used to overcome them. However, the paper is very dense and very technical, and pertains to a very niche market. It requires a lot of domain knowledge to understand - I feel like I'm missing something from this paper because I haven't had a distributed systems or networking course.


Review 8

The paper is proposed because with the development of sensors, large distributed sensor networks are used to monitor and collect data. The query processing interface of sensor networks is needed, while it is not available in traditional processors. So the authors of this paper decide to develop an acquisition query processing (ACQP) extension to SQL to handle the problem. The new language is called TinyDB.

The paper firstly identifies the properties and the related technical parameters of the sensors in the network. Those data include the sensor size, the active time, the battery capacity, the message size, the instruction count and the communication distance. These data are important for the query design and optimization.

The approach to solve the problem put forward in the beginning is design a language called TinyDB. It adopts similar syntax to SQL, while it treats all the sensor data as a table with one column per sensor. The special part is that the data can be organized as events, which is kind of a special data structure in TinyDB and likes patterns of sequence data. The events can also be used as a termination condition for the queries. Also, it creates a new keyword called LIFETIME to handle the time length in sensors’ sampling.

The strength of the paper is that it provides a comprehensive solution covering both hardware and software issues. It is rare to see in the papers of the database management area. The combination of sensor networks and SQL provides a new perspective to me that how the hardware and software can work together to improve the performance.

The weakness is that it is better to provide some figures about the algorithms to make the paper more readable. For example, when talking about the optimization, it would be better to show the process in some flow charts.

In conclusion, the paper is interesting because it covers both the hardware and software knowledge. It brings me a different understanding of database management system.


Review 9

This paper presents an acquisitional query processor that is specifically designed for data collection in sensor network. Sensor network with hundreds and thousands of sensors are on the rise, but existing query processors of sensor networks are simply low power version of traditional query processing, and are not optimized to suit the workload environments of sensor networks.

The proposed Acquisitional Query Processing (ACQP), called TinyDB, takes into account the location and cost of acquiring data to significantly reduce the power consumption. The basic queries in TinyDB are SELECT-FROM-WHERE clauses that have selection, join, projection and aggregation. Along with the basic query, TinyDB support grouped aggregation queries to reduce the bandwidth of data transmission, and event-based queries that help initiate data collection. There are also lifetime-based queries that allow users to specify lifetime of a query, which help users manage power in a more intuitive manner. The optimizations in TinyDB take power into account in its cost estimation, and many of its optimizations heavily focus on reducing power consumption through various techniques such as batch-processing, metadata management, semantic routing trees.

The paper does a great job presenting an interesting area of query processing that can benefit from specific optimizations that are targeted towards the workload and operating environment. It presents several areas that can use improvements and further research, and some initial results it found in its proposed solutions. Overall, the paper presents the different aspects of query processor of a sensor network well, but it is a bit weak in presenting any potential drawbacks or performance tradeoffs that exists in these implementations, as most of the analysis only concern only on power.



Review 10

This paper addresses the problem that how to acquiring data from from long-term low-powered sensor network. A acquisition query processor(ACQP) is designed to achieve significant reductions in power consumption. This paper also illustrates several issues concerning the power consumption in these sensor networks.

They designed a ACQP engine called TinyDB and combined many other features to minimize power consumption as well as delivering desired data:
TinyDB supports selection, join, projection and aggregation and also sampling, windowing, and sub-queries with materialized view. In addition, it support event-based queries, to acquire data on the trigger of certain event. TinyDB can perform a lifetime estimation, and adjust transmit rate or sample rate to achieve the lifetime goal specified in the queries.
It points out in the paper that sampling is one of main cause consuming power. The system implements the TinyDB optimizer to address this problem. It gives the predicates some order to avoid unnecessary sampling or comparison. E.g, if one predicate is very selective, it would be cheaper to evaluate it first, since the order may avoid to sampling the data that will be discarded later. Event-based query may be rewritten to be a join of a sampling and event table.This may save duplicate sampling for one data when the events comes at a high frequency.
The paper also propose a solution for the other main source consuming power, transmission. It implements semantic routing tree to maintain information in children, so that parent can choose not to disseminate the queries to children if it believes the queries do not apply on them(no tuples will be selected). The paper also points out some downside of this strategy: overhead in maintenance and construction. Consider the data transmission, there is an issue that the transmit queue is full and new arriving data does not fit. The paper discuss several strategy(naive, winavg, delta) and points out that delta may suit better to data frequently changing.
ACQP adopts the adaptive strategy during runtime: it can adjust rates in sampling and transmission with data prioritization decision. It benefits power consumption as well as network contention. E.g, if there exists too many transmissions in the current network, ACQP would slower the transmission rate so that the overall power consumption goes down and more data will be sent to root, while it causes the network queue can be full.

The ACQP brings a new metric in the query optimization and cost estimation. It emphasizes the overall power consumption. However, though the experiment result is good, this paper fails to perform tests for the whole systems or test in a real environment, since the workload in a certain environment may change and overall system performance might differ from laboratory results.


Review 11

Problem:
Sensor networks are collections of battery-powered wireless computers, which can take various measurements and communicate with each other. They are embedded in strategic locations for monitoring interesting attributes of their environments- for example, monitoring the temperature, humidity, sunlight intensity etc. of environments. Queries similar to relational queries can be used to selectively obtain information from these sensors- for example, “SELECT humidity FROM sensors WHERE humidity > 70%”. It follows that query optimizations that apply in relational databases may also apply for querying these sensor networks. This is important because each sensor node is battery-powered, and therefore optimized queries would improve the energy usage of the network.

Prior research focused on how the data received from each sensor could be efficiently processed within the network to reduce power usage (e.g. performing certain operators early to limit the number of records in later steps). The main contribution of this paper is what it calls “acquisitional query processing”. The main idea is that because taking a data sample may take as much or more power than performing operations, optimizations should be aware of this and seek to make smart decisions about sampling. For example, queries may have multiple predicates that reference multiple sensor attributes which have different energy costs. One attribute may be very costly to measure, but highly selective- these two factors must be considered and optimized for most efficient energy usage. The nodes in the network are also arranged in a tree structure, and query requests travel from the root note to the rest of the tree. This tree-creation algorithm can be constructed to minimize the range of certain attribute values of each node’s children. This means that there is a higher probability that when a node receives a query, it might not have to propagate the query to its children because it knows that the query is not interested in the attribute range of its children.

Strengths:
The strength of this paper is in introducing a novel way of looking at sensor network optimizations. It asserts that by taking into consideration the power cost of acquiring (and not just processing) sensor data, it can better optimize for energy efficiency. It demonstrates the strength of its techniques through many experiments.

Weaknesses/remaining questions:
The (potential) problem of node hotspots is not addressed- will some nodes die faster than others?
No empirical data for the query optimization examples.



Review 12

The paper discusses the design issues related to acquisitional query processor for data collection in sensor networks. When data come from smart sensor devices, it is important to control where, when and how often to collect the data and deliver them to query processor in order to maximize the lifetime of these sensor devices. The paper uses the term “acquisitional” to describe those issues related data collection in this context. In the context of TinyDB, the paper explains several techniques to address the acquisitional issues.

A sensor network is characterized by the low-powered nature of its autonomous nodes and it is the most important to have the nodes operating as long as possible as it is usually very expensive to deploy these nodes. This makes the query processing in sensor networks to focus on reducing power-consumption of each node. The paper focuses on the fact that smart sensors can control over where, when and how often data is acquired and delivered to other nodes. The authors implemented an acquisitional query processing (ACQP) engine, called TinyDB, that attempts to exploit this fact to reduce power-consumption of queries while increasing accuracy of query results over non-acquisitional systems.

The paper first defines an acquisitional query language used in TinyDB, which is an extension to SQL, that can specify when and how often data should be collected by 1) selecting an interval; 2) defining an event for when to start or stop the query; 3) specifying the required lifetime (e.g., 30 days) of the query. The language enables users to run queries with data gathered from a desired interval and a duration. Event-based queries are much efficient than polling-driven queries and TinyDB performs lifetime estimation in order to satisfy lifetime-based queries.

TinyDB performs optimization in 1) query itself; 2) query dissemination; 3) query processing to achieve the lowest power consumption possible while increasing the accuracy of the query result. The query optimization involves maintaining metadata that contains information about the cost, time to fetch and range of an attribute and carefully ordering the sampling and predicates. If a precedent predicate can discard a tuple, then subsequent predicates do not need to examine the tuple and also we can avoid sampling the attributes references in those predicates. For query dissemination, TinyDB constructs a semantic routing tree (SRT), which is an overlay of the sensor networks. In a nutshell, each node in a SRT contains the value range of each attribute that the node itself and its children covers. TinyDB then uses the SRT to prevent a query from disseminating to unnecessary nodes, saving their power consumption. In query processing, there are issues of handling which local query results to send when the local queue is overflowed with incoming data from neighbor nodes. The paper introduces a number of techniques to address such issues and compares the performance of each.

In conclusion, this paper and TinyDB is another example of designing database systems in a different context from traditional transactional database systems. The paper identifies a key factor and characteristic of the domain and discusses relevant techniques to optimize the performance. While the discussion of the techniques in the paper is sound and reasonable, I am curious about the power consumption that is required to implement their techniques, such as maintaining metadata and constructing/maintaining SRTs, which discussion seems to be neglected in the paper.




Review 13

This paper introduces a new design for query processing in sensor networks. Previous systems have assumed that data in sensor networks is already available before a query occurs and have focused on optimizing power consumption. Acquisitional Query Processing (ACQP), the design proposed in the paper, observes that sensors in the network can choose where, when, and how often data is sampled. This observation allows for new techniques in saving power in a power constrained environment.

The paper uses a distributed query processor called TinyDB that implements ACQP. The ACQP languauge differs from a traditional query language in that it not only allows for a query for data from the sensors, but it also allows for queries to specify how often the data should be sampled. The language also allows for samples to be taken whenever sensors detect certain predefined events.

ACQP also implements logic to reduce power consumption in many different ways such as only forwarding requests to relevant nodes and batch event processing. The design also takes into account of faults in the network. Sensor nodes keep track and update their links if they determine previous links have deteriorated. Furthermore, sensor nodes monitor network contention and back off to ensure more accurate data.

Previous work in the field only considered query processing in a sensor network as normal query processing with power constrains, but the authors of this paper recognized the differences and created a new design to take advantage of them. I like the flexibility of TinyDB and I feel the ACQP language is pretty complete in its coverage of the possible types of queries.

From my understanding of the paper, when a query is processed, the query flows down the tree and the results flow back up along the same path. However, I feel that the rate at which data propagates up is limited by the rate each parent can obtain and re transmit the data up the tree. Rather than communicate with the same parent who provided the request, it seems like it could be possible to utilize a different parent which may not be busy and get the data back up the tree even faster. Although the root limits the overall network bandwidth, the paper does mention a possibility of exploring an optimization that could select or reassign the root to maximize bandwidth. It seems that this optimization in combination with flexible choice in choosing which parent to forward results to could make result communication faster. The question would be whether implementing this logic would save power or consume more power than should be allowed.


Review 14

This paper presents the challenges of sensor network in conserving power when acquiring and delivering data, and proposes some approaches to solve the problems. TinyDB is used as an example throughout the paper.

A sensor network involves a large number of sensor devices that need to acquire and deliver desired data for a long time with minimum human intervention. The sensor nodes need to make intelligent decision to conserve power.

The "sensors" table has a stream of data values. Acquisitional queries and traditional queries are somehow very similar, for example, join and group operations can also be applied. TinyDB allows data collection to be initiated or stopped by events, which reduces significant power by preventing the devices from "busy-waiting". Actually, sensor nodes are time synchronized such that they sleep and wake up at the same time.

Query processing for sensor network is composed of three parts:

1. Query optimization (at base station)
The cost optimization is done at the base station. Both predicate and sampling are viewed as operations, where the cost of an operation can be estimated based on the meta data stored at the base station. Sampling is usually the most power-consuming operation and this should be taken into account when ordering operations. Also, rewriting a batch of event-based queries might be helpful in reducing power consumption.

2. Dissemination and routing
Semantic Routing Tree (SRT) is used as the topology of sensor nodes. The authors propose three different parent selection policies for constructing and maintaining the SRT: random, closest-parent, and clustered ;and compare these three approaches with the best case and the worst case.

3. Query execution
The authors talk about the problem that the radio queue for communication between nodes might overflow. There are two possible prioritization algorithms for evicting tuples in the queue when the queue gets full: naive, winavg, and delta; and their experiments show that delta outperforms the others. In addition, TinyDB also provides adaption in terms of network contention and power consumption.

One strength of this paper is that it provides actual numbers of energy costs so that we can see the scale of the problem and also their improvement. Also, the paper is very well-written with summaries at the end of every sections.

However, some experiment results are not very clear to me. For the results in their SRT experiments, they claim that "clustered" approach is much more superior, but from figure 7, the performance of "clustered" and "random parent" approaches are very close. It would be better if there were more explanation about this.


Review 15


This paper discusses Acquisitional Query Processors (AQP) for data collection in sensor networks. The motivation for AQP is that traditional passive systems are not as power efficient, and many applications need sensors to last for a long time. We need devices to be long lasting for applications such as monitoring the burrows of the endangered Storm Petrels, for which we want to disturb the nests as infrequently as possible, or monitoring earthquakes, for which it would be time consuming and expensive to replace or recharge batteries in the various sensors. The paper poses Acquisitional Query Processors as the solution because they significantly reduce power compared to traditional passive systems that add on data a priori, and because SQL can be simply extended for query optimization, dissemination, and execution of AQP systems.

In a comparison between AQP and traditional passive systems, traditional systems strive to process data as energy efficiently as possible by applying aggregation and filtering operations inside the sensor network. This, however, moves queries to data instead of actually optimizing the processor. AQP, on the other hand, can control where, when and the frequency at which data is sampled which reduces power consumption. AQP also focus on the locations and costs of acquiring data and are set up based on a routing tree, which supports simultaneous queries and allow for easy addition of sensors, and thus greatly reduce power consumption and increases flexibility compared to traditional passive systems that accumulate data a priori.

The three main issues of AQP are query optimization, from the cost of sampling sensors, query dissemination, for physical co-location of sampling and processing, and query execution, from making choices of when to sample and which samples to process. To address the issue of query optimization, the AQP optimizer orders joins, selections, and sampling operations on individual nodes. Information on the costs of processing and delivering data is stored in the metadata. The semantic routing tree (SRT), which can reduce the number of nodes used to disseminate queries and send the continue stream of results from children nodes by an order of magnitude, is used to disseminate the optimized query into the network. Experiments showed that random parent approach does not perform as well as the closest-parent and clustered approach. For query execution, a partial state record is computed at each intermediate node, which allows sensors to transmit much less data than when all the sensors' data is sent to the root.

The limitations of this paper were that there could've been more examples of how to use TinyDB. For example, where the paper talks about power consumption, it would've been nice to be shown code for how TinyDB can monitor channel contention and adaptively reduce the number of packets transmitted as contention rises. Also, I would've liked to see the paper maintain the same example as it goes through all of its comparisons to the traditional passive systems.



Review 16

This paper is about the design of acquisitional query processing which is applied to sensor networks. These are networks of any kind of sensor that is recording data about it's environment. The authors implement TinyDB which is a database that basically abstracts the acquisition of data from the sensors into an SQL framework. The authors describe improvements to power consumption and accuracy over non-acquisitional systems that don't control where and when data is collected.

There are a few main questions the authors are concerned about. They are intereste4d in knowing when samples for a query should be taken. This is important for power consumption. A system should not constantly sample for information if it is not going to be used. The authors are also interested in effectively finding the nodes relevant to a query and the order sampling should be done. Sensors can structure themselves in different ways, and in this paper the authors describe this structure as a semantic routing tree. The last question is whether computational power should be expended to process and relay information for a query.

This paper has a few great strengths. The analysis of power consumption and querying optimization is important and thoroughly discussed. The abstraction of query processing over a network of sensors is key. For progress to be made in this domain it is important that people deploying sensor networks can efficiently query their sensors and conserve power. If someone has to reinvent the methods to aggregate data from their new sensors or reimplement methods for power consumption it is going to be harder for researchers to make progress in many areas that benefit from sensor data.

The drawbacks come from the evaluation section. The authors talk about semantic routing trees as a method for structuring sensors and allowing efficient querying of sensor data. The authors evaluate these trees on geographic and topological data which is correlated in physical layout to the data structure. Real sensor networks are often not structured this way. The authors say that real networks show significant correlation but they still lack an evaluation of things like, their parent selection algorithm. I suspect that different approaches are beneficial in different situations and an analysis of these layouts would be insightful.


Review 17

Part 1: Overview
This paper presents an acquisitional query processor design specifically for sensor networks. Smart sensor networks come into common use as smart sensor devices thrives in the market. Sensor networks are designed to monitor environment data and smart sensors can choose when and where to sample data. In cater to the great need of saving battery of the smart sensor devices, acquisitional query processing came into birth to take place of traditional passive embedded sensor database. Four major questions are answered, when should a sample be taken, what sensor nodes are relevant to the particular query, in what order should samples be taken, is it worth spending computational power or bandwidth to process.

Sensor networks consist of sensor nodes of battery-powered, wireless computers. They can communicate with each other via wireless radios. In this case, power consumption is a critical concern. The presented database, TinyDB, supports event-based queries and long term queries in additional to the basic sql queries. TinyDB manages metadata of different attributes and these metadata is used for determine the order of sampling and predicates. Another important problem comes along the network structure, it is the routing mechanisms design. After optimizing the query, the actual sampling and monitoring need to be carried out by the sensor network. The paper presents a so called Semantic Routing Tree mechanism to push the edge of traditional routing trees.

Part 2: Contributions

Power consumption problems arises with the common use of wireless sensors networks, which add new potential optimization work to be done to the traditional active acquisitional databases. This is pretty much a new problem discovering and foundation building work which can lead the research trend.

Limited by the memory or bandwidth of the distributed sensor devices, there must be and scheduling algorithm to take care of overflow tuples. The paper tries to fully utilize the spectrum by carefully select the tuples to discard. This provides some other hot spots for researchers.

Part 2: Possible drawbacks

As a problem discovering paper, the results may not be best optimized to an exceeding approximate rate. We can see from the numerical evaluation section that the three proposed parent finding algorithms are still not so closely approximating the optimal case shown as straight lines as an upper bound (Figure 7).

In the prioritization section as well as the adapting rates section, the paper does not specifically discuss their algorithms but provides some numerical results instead. This may not be so convincing when providing the experimental results without giving some kind of theorem proof.



Review 18

The main problem addressed by the paper is reduction of power consumption of query processing in sensor network. Because sensor networks work without human interaction for weeks and months, they need efficient management of power consumption. The paper proposes a query processing technique called acquisitional query processing (ACQP) which utilizes the fact that smart sensor have control of where, when, and how often data is physically acquired and delivered. The authors implement the ACQP technique in database engine called TinyDB on top of TinyOS. Queries in TinyDB, like in SQL, consists of Select-From-Where statement. In addition, TinyDB implement windowing which allows it to run blocking operations such as sorting on a materialized window of streamed sensor datas. In addition to the basic construct, the paper suggest several additional sampling construct useful to reduce power consumption of sensor networks. One of the construct is to set sampling interval and duration in the query. This allows to minimize the amount of computation and communication done and hence reduce the power consumption of sensor networks. In addition, an event based query is supported in TinyDB. This query allows sensors to remain dormant until a particular event is triggered. This can also provides significant reductions in power consumption. Furthermore, instead of specifying a sampling interval, a more intuitive way of sensor querying is providing its lifetime. Based on the query lifetime, remaining battery capacity, energy to sample and transmit a sample, and other related information, TinyDB estimates the sample rate of the sensor.

In addition, the paper addressed issues related to query optimization, dissemination and execution. The author identifies that the main cost of power-based optimization depends on the sampling and communicating cost rather than cost of applying operators. For this reason, TinyDB maintains metadata such as power cost and time to sample an attribute which allows it to optimize query execution. For example, the order of predicates in the query might bring a difference in power consumption based on the relative cost of individual sensors considered in the query. Even after the query is optimized at the base station, the query has to be disseminated into the sensor network. If the a query doesn’t apply to a particular node and its children, then the entire subtree can be excluded from the query, saving the cost of disseminating ,executing and forwarding the result. This ofcourse significantly saves power consumption of the excluded nodes. Each node maintain a structure called semantic routing tree (SRT) to allow it to decide whether the nodes below it should participate or not in a query. The query execution is the simplest stage which involves sampling and delivering of data. In this stage, the paper suggests prioritizing data according to quality score of each measurement, especially during when the queue does overflow. In addition, during network contention adapting the transmission rate of packets leads to reduction in wastage of communication effort thereby minimizing power consumption.

The main strength of the paper is it provides detailed characteristics and benefits of ACQP based query. It explained thoroughly all the techniques implemented in TinyDB with different examples of queries. I founds techniques including: event based query, lifetime based query, ordering of predicates based on metadata information, and power sensitive measurement dissemination quite valuable.

The main drawback of the paper is that I don’t find an argument as weather the ACQP based query processing is a better approach than the other previous work. The paper doesn’t provide any power consumption comparison with the other existing approaches like for example with those that use push-down technique. Without a detailed experimental comparison with the existing works, it is hard to accept the approach implemented by the TinyDB over the other. It could have been better if the authors considered one or two related works and evaluated their several techniques against them. In addition, I am not sure if directly extending the SQL query language is a better approach in dealing with data acquisition of sensor networks. I think it is probably better to look for a completely new query processing language from the ground up.



Review 19

In this paper, a design for acquisitional query processor (TinyDB) for sensor network is presented and discussed in details. The key task of a database for battery powered sensor network is to minimize power consumption in order to cut the cost of maintenance and at the same time keep or improve the performance. Usually, wireless data transmission and sensor sampling is much more power consuming than on board computing. So the paper tries to focus on when and what is the order to sample, what kind of network to form to transmit data and is it worth doing sampling depending on the predicates of the query.

They started from introducing the embedded systems they use. Then the author explained how a tree structured network, SRT, was properly formed so that the communication was reduced. Maintaining SRT was discussed also. It solved some problems like what if a child loss connection or what if a parent swapping need to be performed.

Acquisitional query language was also introduced in this paper. Compared with normal query language, this extended language supports sensor-specific functionalities. For example, depending on the power consumption of the sensors, the optimizer can proposed a maximum sample rate and also decide whether to drop some measurements without hurting the data result too much. The optimizer can also perform sensor action reordering to further reduce energy cost.

One weakness or a unanswered question for this paper is that, the tree structured network has different load on the nodes, thus making power consumption uneven across the system. What shall we do to avoid this?

Overall, I like this paper very much because my major was CE, and this topic is much related to my focus and the paper is well written and structured.


Review 20

This paper described a design of an acqusitional query processor for sensor network. It main focus is to reduce power consumption of each sensor node to support each query.
It used several main techniques to achieve this goal. First, to reduce power consumption of each sensor node, sensor nodes are put to sleep for most of the time. A sensor wakes up when a certain predefined event happens. And then, when the selected time interval has passed, all sensors wake up simultaneously to submit their results. This significantly reduces power consumption comparing to polling based trigger. Second, the transmitting area of a single sensor is limited. So Sematic routing tree (SRT) is proposed to solve this problem. It uses a tree structure to organize all sensors, and minimized computation and transmission power needed to finish a query.

The main contribution of this paper is presented a database system that designed specially for tiny devices which are sensitive to power consumption. As such devices become more popular, such DBMS will become more useful. Another contribution is it gives a way to compute lifetime of a devices. This enables better management of the battery life.

What I like most in this paper is the Lifetime-Based Queries. It is a technique that allows TinyDB and its sensor to compute the sample frequency dynamically when lifetime is given. This makes the researches much easier.

One thing I like to know more is how the query is processed. Is all result such as join computed in base station or sensors themselves will do some part of the job during transmission?



Review 21

This paper presents a number of features designed to minimize power consumption via acquisitional techniques. Acquistional issues pertain to where, when and how data is physically acquired and delivered to query processing operators.

This paper focuses on sensor networks that need to be working on low power and last a very long time. This paper explores how TinyDB with its declarative language and specific features is suited for this purpose as opposed to typical embedded C. It also shows TinyDB is capable of getting the cost of multiple sampling operators and choosing the lowest cost one in terms of power thereby being very useful for the given system.

Two of the focus areas when it comes to adapting for sensor networks seem to be power consumption and network contention. One of the solutions that they proposed that I found very interesting is to batch the queries from events into a stream thereby queries are not run multiple times ruining the advantage this system gains over polling.

The focus of the query optimization in this paper is the ordering of predicates in terms of cost which is the power consumption and sampling examples. Aggregation and prioritizing data for the queue (naïve, winavg, delta), is definitely a great step in terms of ensuring approximate results are not lost in a low power situation. Though aggregation helps the queue to not overflow, I do not think they explained how it would contribute lesser power consumption.

One of their most important implementations is the semantic routing trees which is similar to an index in a typical database where the nodes can determine if any of the children nodes can participate in a query over some constant attribute A. This can definitely help in saving power by not having the nodes to transmit data when it is unnecessary. I would have liked it if the authors could have explored the idea of backup in a TinyDB system in case of a multiple node failure or some other network related issue that might result in loss of data. Overall, this paper was a great read in terms of learning about utilizing a DB for something other than transactional queries.



Review 22

This paper introduces a novel technology and design associated with processing acquisitional queries in sensor network. Using the example of tinyBD, this paper firstly presented some important property of the acquisitional query language, and also the power consumption related optimization ideas.

Sensor network is a tree structured network that consists of many power constrained sensor nodes that are easy to maintain and requires no maintenance. The network communicates through the short range lower power wireless radios, hence the communication has to be relayed by other nodes in the automatically discovered routing tree.

The acquisitional language is somewhat similar to SQL, it supports basic selection, join projection and aggregation operation. As the data flow from the sensor are a stream like one, it is not bounded. So the data window has to be specified in the query, which can vary from network lifetime to sample window and sample interval. Different from SQL, ACQP supports an event driven mechanism to initiate data collection, and in this way, the sensor nodes can stay in sleep mode for the most time to save energy.

In terms of the power-aware optimization, the ACQP highly utilize the selectivity to rearrange the ordering of sampling and predicates. Also, when there is too many event driven triggered data collection, a batching process will be use to conserve power. Also, semantic routing tree is utilized to improve the selectivity estimation of the query optimizer, and mostly SRTs are better constructed using the closest-parent and clustered approach.

In the query execution process, ACQP will constantly reestimate the power consumption and adjust the sampling and transmitting rate to limit the network congestion and the following data loss. Given the fact there is network congestion, tinyDB can use the naive, winavg and delta schemes to prioritize the data that can be finally delivered. And the last two works well on approximate the continuous data.

In summary, many detailed issues related to acquisitional query processing in sensor network are addressed, and tinyDB serves well as an experimental sample of it. But there is still some issues worth considering about this paper:

1. system described in the paper may not be scalable, since the sample data in this paper are only collected in tiny networks. For example, upper level sensor nodes in larger network may suffer from power constraints due to message relay.

2. not enough power consumption related consideration/ calculation are provided for the situation when the network gets congested due to high sampling rates.



Review 23

In this paper, the author talks about the design of acquisitional query processor for the sensor networks. The design aims to decide where when and how often date is sampled and delivered to reduce the power consumption. The paper talks about this issue in the context of TinyDB. The author first introduces the architecture of the sensor network distributed system and the acquisitional language and then shows how the acquisitional technique saves the power consumption in the order of query processing.

First is the power aware optimization in the basestation side. There are metadata in each node of TinyDB that can be used in query optimization. The metadata can be used to estimate the selective of a predicate that can reduce the sampling if changes the sample order. When multiple same event is activate at same time, the event query can be rewrite to sliding window join to reduce the power consumption according to the metadata.

Second is the smart dissemination to reduce the power consumption. When the optimized query is disseminating to other nodes, it is good to know in each node if it is necessary to continue disseminating to children node. This need the parent node have the knowledge of children information, then SRT provide a way to maintain these information. The paper talks about how the SRT is built and how to maintain it after some changes of nodes in sensor network. Also, it talks about how to make a choice of parent node.

Then comes to the executing part. The paper talks about the prioritizing data delivery which is the strategy when the data needed to deliver exceeds the waiting queue size when deliver rate are relatively slow. Also the paper talks about adapting the sampling and delivering rate when something changes so that no longer meet the expectation at the start of the query processing.
At last the author talks about related work and the work they are currently doing.

This paper first take much space to introduce the background for the sensor networks and acquisitional language. So even the reader who knows nothing about this topic can get idea of how they apply the technique to same power. The order for introducing their ideas of acquisitional query processor to reduce power consumption is same as how the sensor works which is good for understanding their idea. For each technique they introduce, they also provide experimental result. They provide specific query to express this idea when the author thinks maybe hard to understand which I like most.
The drawback of the paper:
In the introduction and overview parts, the author try to give a summarize idea for later part, but it seems a little too detailed that make reader confused before reading the later part. Also, it will be better to have a experiment to show the benefit of these techniques in real world.


Review 24

With the commoditization and coming ubiquity of sensors in both the consumer and industrial space, it is important to have a mechanism with which to query to collected data. The authors developed a distributed query processor that uses a SQL-like language for ease-of-use and provides a number of features important for sensors: event-based queries, power-aware query optimization, and batching. All three provide power-consumption reductions which are crucial on such low-power devices. Additionally, the query processor can be tuned to reduce power consumption at the cost of other things (e.g. fidelity in the case of sampling rate).

The paper does not draw a comparison against pulling data into a central, traditional RDBMS and using that to execute queries. Certainly in the centralized solution, it would be easier to provide data durability and the queries would execute more quickly. This would come at the cost of the data being stale in some cases, but a hybrid mechanism may circumvent this. Perhaps by only retrieving data from the sensors when a query comes in, and using the central DB for that portion of the data from that point on.


Review 25

This paper proposes a new design for sensor networks when dealing with acquisitional query processing. When processing queries for traditional databases such as MySQL, Hadoop, Hive, etc, we are focused on optimizing for time. However, with sensor networks, these nodes have a limited battery life, so the main concern in sensor networks is optimizing for power. Therefore, a new way to optimize queries and distribute queries across the network is needed.

The solution proposed by the authors is acquisitional query processing or ACQP, which tries to minimize the amount of power used in each sensor node. Since many sensors are able to sleep when not collecting information or transmitting information, ACQP and the database engine TinyDB are able to save power by coordinating when sensors should wake up and both collect and send data through the following:

1. Programmers are allowed to set intervals for queries so that the nodes are not just collecting and transmitting data consistently.
2. UDFs are supported so that sensors can sleep until some event occurs that needs recording.
3. Nodes are able to predict their own lifetimes and adjust their polling rates to prolong their lives until a certain time.
4. Metadata is stored locally at each node and propagated to help with query optimization. The goal of TinyDBs query optimizer is to query a few nodes as possible even if that would take longer because each time a node is queried, it uses about over ten times the amount of power.
5. Semantic routing trees are created to try to minimize the number of nodes needed for certain queries.

Even though the paper is revolutionary in how it approaches distributed querying, there are a few questions and weaknesses that I see:

1. The authors mention that query batching can be used to conserve power on event based queries, but they never mention how to converse power when transmitting back to the base station. This data will have to be delivered to a local materialization point as stated in the article, but wouldn’t the materialization point also have power concerns? Are those points just left running 24/7?
2. When the authors describe the three ways to create SRTs, they mention that the clustered approach outperforms the other two methods, but they do not explain which exact sensor distributions they were testing on. Are there corner cases where the clustered approach would not outperform either closest-parent or random?



Review 26

This paper discusses the benefits of using an acquisitional query processor called TinyDB in sensor networks. The ability to gather information using very little power is critical in sensor networks. Each node runs on battery power, and the recovery and replacement of these nodes can be expensive and time-consuming. Therefore, it is desirable to implement a query processor that is able to automatically tune its data collection and transmission rates to meet the lifetime constraints imposed by its workload.

TinyDB implements several features in order to minimize query-related power consumption in sensors. TinyDB implements event semantics that trigger queries when the user-defined events occur. By maintaining an idle state until the event occurs, sensors can save considerable power that would otherwise be spent on periodically activating the sensor and polling its data to see if the event condition is met. Perhaps the most unique feature of TinyDB is its support for lifetime-based queries. In many cases, researchers are more concerned with gathering data over a given period of time than with fine tuning the sampling rate of their sensors. TinyDB allows users to specify a lifetime that a query must run over. The system then uses metrics about the power remaining in the system, power needed to sample and transmit data, etc. in order to calculate the highest sampling rate that can be maintained over the specified lifetime of the query. It also has the capability to periodically recalculate this rate based on the observed selectivity of queries and other data. The paper also presents many other power-saving optimizations such as reordering of sampling and predicates, and the use of SRTs to prevent sampling nodes whose results will not be selected by a given query.

My chief complaint about this paper is that they do not provide a direct comparison of the lifetime/power consumption of a sensor network using TInyDB to a network using embedded systems or other standard query processors. While the authors certainly show that the features they implemented perform significantly better than some of the features they considered while developing TinyDB, they give no empirical evidence that it provides any real improvement over traditional query processors. Furthermore, they state several times that some of their assumptions are highly optimistic. For example, when analyzing the benefits of implementing SRT, they assume perfect correlation between geography and network topology.




Review 27

This paper discusses the design of an acquisitional query processor for data collection in sensor network. Nowadays, sensor networks are often embedded into some physical environment from which they must monitor and collect data. Thus, long-term low power of sensor network is an important issue in sensor networks. This paper first summarizes the overview of the sensor network, and then introduces acquisitional query language. Last, it concerns about power issues of the sensor networks.

First, the paper talks about the sensor network and acquisitional query language. A sensor node is a battery powered, wireless computer. Power consumption in sensors occurs in four phases, including snoozing, processing, listening, and transmitting. In the communication, typically the devices keep a short list of neighbors who they have heard transmit recently. Acquisitional query language is an extended SQL used for sensor networks. It has clause such as SAMPLE INTERVAL. Therefore, the overview of the sensor network and acquisitional query language is a foundation for discussing sensor networks.

Second, the paper discusses about the issue of power consumption. Low-power consumption is preferred. This paper use some methods to optimize power consumption, including metadata management, ordering of sampling and predicates and event query batching. The paper also introduces SRT and its benefits.

To sum up, this paper discusses the design of an acquisitional query processor for data collection in sensor network and some power consumption issues. In addition to theory, the paper has many experimental results to illustrate its ideas about low-power consumption, which is convincing for readers to study.



Review 28

This paper discusses a new way to query data from sensory networks in a more power efficient and accurate way. They have written an acquisitional query processing language called TinyDB to accomplish this and it is discussed in the paper.

Power consumption is very important for sensory nodes as they are battery powered and wireless devices. When dealing with sensory nodes you want them to be able to run as long as possible on battery before dying so the less power they consume the longer they will last. Unfortunately they consume a fair bit of power when they are transmitting or listening for data.

TinyDB supports is similar to SQL in that it is a SELECT-FROM-WHERE language, but it also supports time interval sampling functionality as well as event driven queries. Event based queries are very important for low power processing as they can be sleeping for a much larger percent of the time. TinyDB also supports lifetime queries, which enable you to have a query run for a certain lifetime, sampling as frequently as possible to still guarantee it stays alive for that lifetime.

This paper also touches on how the process of query optimization itself is power consuming and what metadata should be stored to conserve the most power while still providing sufficient performance optimization. It also touches on how to know which nodes must be awake for a given query to communicate back and forth with each other.

The paper did a good job of convincing me of the benefits of TinyDB and it’s benefits to the unique needs of sensory network query processing. I think they did a good job of explaining their decisions and showing the results of a few different techniques they tried. Overall I think it was a solid paper.

One strength of this paper in my opinion was the use of example queries and graphs to support what they were describing. I think this paper did a great job of breaking up the text at proper times with supporting graphs that were clear and related to the text to provide support.

One potential flaw I saw with the paper came about when they pointed out that each node can only transmit when their parent is awake and listening. The problem that comes to mind with this issue is what if they child and parent have the same cycle time but are out of sync? This would result in a child node dying while not providing any useful data in its lifetime.



Review 29

This paper discusses the design and motivation behind the motivation for a low-power, efficient system for an acquisitional (e.g. on-the-fly) database system, specifically targeted towards sensor networks. Sensor networks are becoming more prevalent in fields such as wildlife research, and require some way of being able to query data from low-power devices with minimal human interaction. This paper is very interesting as the problem of trying to consider more than a speed-efficient query becomes more of a reality. How can one take into account costs of actually operating devices that collect and manage data, without having to waste time or energy on transmitting information to a central database?

Most of the intuition lies behind the need to centralize the sensor network around “acquisitional” data collection (i.e. strictly controlling when data is sampled, queried, and transmitted), reducing power consumption through features like OS event-based sampling, arbitrarily computing sample rates to maximize battery lifetime, and pruning network requests so nodes only get requests when they can handle a query.

One thing that would have been interesting to see in this paper is an exploration into the scalability of the data transmission (or other features); one of their experiments near the end only uses 4 sensor nodes. In addition, there was little discussion of failure modes in the paper, i.e. if there are any assumptions that the systems rely on in order to operate properly. Also, is there any case in which sensor data explicitly needs to be retrieved, i.e. when there needs to be messages of absolute highest priority (since messages being sent through the same network channel may be dropped for efficiency)?


Review 30

Large distributed networks of sensors are extremely common for a variety of data collection purposes. Collecting data from these sensors presents many unique challenges. The main approach employe by this paper is to develop an acquisitional framework that significantly reduces power consumption in the devices.

This paper introduces a new ACQP engine named TinyDB which gives low power querying abilities across distributed network sensors. Though the query language resembles SQL in many ways, it has some extensions that make it unique. Event-based queries are implemented as a sort of polling mechanism for data collection. Events can be generated in various ways (another query, by the OS).This is an extremely useful feature for sensor networks because often time data collection is needed when various physical phenomena occur. Another advancement posed by this paper is the notion of a basestation used for disseminating and collecting queries. The basestation uses a low cost optimizer that picks a query plan optimized for overall power consumption.

While this paper did exhaustive testing on error rates in information propagation, sampling rates and error rates it did not give concrete data on power consumption tests. It is quite odd since much of the paper discusses optimizations made for power, yet there is a lack of data on how much power is actually being saved. Another deficiency in this paper is its lack of literature on the “novel” query optimizer. They claim the optimizer is very efficient in coming up with low power execution plans, but not much explanation or proof is given.



Review 31

The paper discusses the design of acquisitional query processor for data collection in sensor networks. Sensor networks are often embedded into some physical environment from which they must monitor and collect data. These sensor networks usually have limited operational power (i.e.: operated using batteries), which leads to acquisitional issues when deciding when and how should data be collected. This paper addresses several questions: (1) When should samples for particular query be taken? (2) What sensor nodes have data relevant to particular query? (3) In what order should samples for this query be taken? (4) Is it worth expanding computational power or bandwith to process and relay particular sample? In answering them, this paper proposes the concept of acquisitional query processing (ACQP) using self-designed and self-implemented TinyDB engine (a distributed query processor that runs on each of the nodes in sensor networks).

First, the paper explains the architecture of sensor network. Second, it explains the SQL semantic of ACQP, introducing event and lifetime clauses for controlling when and how often sampling occurs. Third, it explains the query optimization process that occurs at the basestation, which uses simple cost-based optimization technique that would yield the lowest overall power consumption. The steps include metadata management, ordering sampling and predicates, and event query batching to conserve power. Fourth, it discusses the query dissemination and routing using Semantic Routing Trees. Lastly, it explains the importance of prioritizing data according to quality (by comparing naïve, winavg, and delta data prioritization schemes) and technique to adapt transmission and sampling rates (using adaptive approach to optimize delivery rate).

One technical contribution of this paper is it seeks to find a way to significantly reduce power consumption by focusing on locations and costs of acquiring data. We know that power issue is central in sensor network, but prior systems tend to view query processing in sensor networks simply as a power-constrained version of traditional query processing. This paper exploits the fact the smart sensors has control over where, when, and how often data is physically acquired and delivered to query processing operator; and uses those facts to build a system that is power-efficient and power-optimal.

However, it also mentions that the data delivery prioritization technique that the system uses depends on the goal of data collecting. In this paper, it is not mentioned how each data prioritization technique works with different goal in data collecting. It only mentions that delta technique is better in representing the original data source, while winavg tends to flatten the data. Although it does mention that the RMS of the data resulted from both techniques are about the same, it does not mention how it would affect the processing/analysis of the data.



Review 32

The purpose of this paper is to discuss how query processors must be thoughtfully designed for use in sensor networks. Large distributed sensor networks are becoming more and more popular for remote data acquisition, but these networks bring with them specific challenges. This is a very limited-resource environment and queries must be optimized differently than in traditional distributed systems. For example, power consumption is a very important measurement to consider. They also specify specific kinds of queries that apply to this case of sensor networks specifically such as event-based queries and lifetime-queries, the latter of which estimates the lifetime of the sensors in the network and optimizes the query to last that entire duration while meeting the specified parameters.

The technical contributions of this paper are numerous. To outline a few, the authors present specific forms of queries that are useful in a distributed sensor network, they perform optimizations in metadata management as well as in event query batching and sampling order to further optimize for power consumption and data accuracy/completeness and present experimental results to back up their assertions and findings. They also discussing routing, which is key in these sensor network systems so that query results can be reported as completely as possible given power and transmission constraints.

Throughout the paper, the authors do a thorough job of specifying previous work and how it differs from their work, including why it would not be applicable in the distributed sensor networks they consider. Additionally, they do an excellent job of explaining the experimental results they obtain, including any unexpected trends in the data.

I find it hard to pick out weaknesses in this paper. The authors have done a thorough investigation of this interesting design space while adapting an existing system in TinyDB to fit their more specific needs. They do, unfortunately, omit a lot of useful details in the various sections due to space constraints, and I wonder if it would have been better if they had focused on a couple less aspects more in depth and saved the other revelations for a related extension paper.



Review 33

Paper Title: The Design of an Acquisitional Query Processor For Sensor Networks
Reviewer: Ye Liu

Paper Summary:
This paper presents a discussion of the design of acquistional query processors for data collecting sensory networks. The focus of the discussion is on the evaluation of comparison of the costs and locations of acquiring data, e.g., when to active and inquire data from some of many sensors in the network. This paper also proposes an ACQP engine called TinyDB which is of a potential advantages of increasing performance drastically w.r.t. energy consumption and efficiency.

Paper Review:
A majority part of the paper is focusing on the effort of how to reserve power while making queries. One key point is, as described in the paper, how to make samples efficiently for each query. For this purpose the paper discussed a number of attempts as well as proposes its own solution. And a fundamental principle of those solutions is smart sampling.

Another aspect of the discussion is focused on the data delivery. This is mainly about how to optimize the order of data queuing and delivery. In the middle part of section 6.2, the paper proposes a conceptual approach that prioritizes the data delivery of the data that will most likely improve the quality of the answer. This is a runtime decision to make which restricts the time cost of making such decisions. The configuration of this problem is extremely similar to the one of Gaussian Process, which is a machine learning model. The advantages of this model is that at every prediction it gives a confidence level of each data point of how much a query on this data point will increase the over prediction. This property makes this model a preferable choice when the cost of individual experiments are expensive, which is exactly the case mentioned in the paper. Therefore it would be interesting to consider applying Gaussian Process as an optimizer/estimator for this task.



Review 34

This paper proposed an acquisition query processor(ACQP) for collecting data in sensor networks. Unlike the previous passive system, it tries to reduce the power consumption of sensors by addressing the issues of when, where and how often data is sampled and which data is delivered in distributed sensor system. It introduces the TinyDB as Instantiation of ACQP and illustrating its power consumption designs with the following features:
1. It introduces the Acquisitional Query Language that supports for
a) Sampling, windowing and sub-queries with materialization points as well as other basic SQL features.
b) Event based queries that could significantly reduces the power consumption comparing to sampling
c) Lifetime based queries that supports for dynamically optimization over sensor behaviour by estimating lifetime.
2. It has a power-aware cost based query optimizer that can choose a query plan has the lowest overall power consumption:
a) It has a catalog of metadata that periodically sent to the root. These metadata are used to provide the optimization of the system.
b) It would apply specific orders of sampling and predicates for a set of features by evaluating the selectivities, costs and odering constraints.
c) It has a categories of aggregate operations, including monotonic (COUNT), exemplary(MAX) and summary(AVG). The paper introduces the exemplary aggregate pushdown for future work.
d) It use stream joins technique to optimize the event query optimization
3. It has a power sensitive network topology for dissemination and routing:
a) It introduces the concepts and implementation of the semantic routing trees(SRT) which is built on top of the network topology, and can be considered as an index that can be used to determine whether a node and its children nodes are relevant to the query.
b) The paper also introduces the 3 different way of SRT parent selection: Random, closet-parent and also clustered approach. It states the clustered approach has the best performance.
4. It has a query execution model that considers multiple physical optimizations:
a) It has policy of choosing how to aggregate data and which results to drop when overflow of radio queue happens (Naive, Winavg, delta)
b) It has a policy of choosing adapting transmission and sample rate based on network load and lifetimes of the samples.

The paper also introduces the basic knowledge of sensor network, including the 4 power consumption phases in sensors: 1. Snoozing mode, 2. Processing mode, 3. Processing and Receiving mode. 4. Transmitting mode. It also introduces the process of communication in sensors systems. Moreover, the paper introduces the related works in the sensor query fields and note the difference between others work and the ACQP.
Strengths:
1.This paper proposes accessional query processor that optimized the power consumption for distributed sensor networks in a actively way. The design of the system is complete and each components of this system has several novel optimizations regarding power consumption. The performance of its implementation: TinyDB is a magnitude better than those passive systems.
2. This paper has a clear structure with a clear overview of the problem it trying to address. Helps its readers to understand the corresponding concepts.
Weakness:
1. The SRT stated in the paper is a novel indexing technique in sensor network query processor. However it has several weaknesses and I belive a further discussion of theses weakness would make the paper even better:
a) It would be hard and power consuming to build multiple SRT among the sensor network if multiple queries was introduced in the system. A good selection policy is worth for discussion.
b) The maintenance of the SRT may be a issue for constant changing network in the real word. It would be clearer and more convincing if the paper could conduct some experiments on the SRT in real world condition.



This paper proposed an acquisition query processor(ACQP) for collecting data in sensor networks. Unlike the previous passive system, it tries to reduce the power consumption of sensors by addressing the issues of when, where and how often data is sampled and which data is delivered in distributed sensor system. It introduces the TinyDB as Instantiation of ACQP and illustrating its power consumption designs with the following features:
1. It introduces the Acquisitional Query Language that supports for
a) Sampling, windowing and sub-queries with materialization points as well as other basic SQL features.
b) Event based queries that could significantly reduces the power consumption comparing to sampling
c) Lifetime based queries that supports for dynamically optimization over sensor behaviour by estimating lifetime.
2. It has a power-aware cost based query optimizer that can choose a query plan has the lowest overall power consumption:
a) It has a catalog of metadata that periodically sent to the root. These metadata are used to provide the optimization of the system.
b) It would apply specific orders of sampling and predicates for a set of features by evaluating the selectivities, costs and odering constraints.
c) It has a categories of aggregate operations, including monotonic (COUNT), exemplary(MAX) and summary(AVG). The paper introduces the exemplary aggregate pushdown for future work.
d) It use stream joins technique to optimize the event query optimization
3. It has a power sensitive network topology for dissemination and routing:
a) It introduces the concepts and implementation of the semantic routing trees(SRT) which is built on top of the network topology, and can be considered as an index that can be used to determine whether a node and its children nodes are relevant to the query.
b) The paper also introduces the 3 different way of SRT parent selection: Random, closet-parent and also clustered approach. It states the clustered approach has the best performance.
4. It has a query execution model that considers multiple physical optimizations:
a) It has policy of choosing how to aggregate data and which results to drop when overflow of radio queue happens (Naive, Winavg, delta)
b) It has a policy of choosing adapting transmission and sample rate based on network load and lifetimes of the samples.

The paper also introduces the basic knowledge of sensor network, including the 4 power consumption phases in sensors: 1. Snoozing mode, 2. Processing mode, 3. Processing and Receiving mode. 4. Transmitting mode. It also introduces the process of communication in sensors systems. Moreover, the paper introduces the related works in the sensor query fields and note the difference between others work and the ACQP.
Strengths:
1.This paper proposes accessional query processor that optimized the power consumption for distributed sensor networks in a actively way. The design of the system is complete and each components of this system has several novel optimizations regarding power consumption. The performance of its implementation: TinyDB is a magnitude better than those passive systems.
2. This paper has a clear structure with a clear overview of the problem it trying to address. Helps its readers to understand the corresponding concepts.
Weakness:
1. The SRT stated in the paper is a novel indexing technique in sensor network query processor. However it has several weaknesses and I belive a further discussion of theses weakness would make the paper even better:
a) It would be hard and power consuming to build multiple SRT among the sensor network if multiple queries was introduced in the system. A good selection policy is worth for discussion.
b) The maintenance of the SRT may be a issue for constant changing network in the real word. It would be clearer and more convincing if the paper could conduct some experiments on the SRT in real world condition.



Review 35

This paper discussed the design of an acquisitional query processor (ACQP) that applies to sensor networks. The idea of acquisitional query is that, instead of pre-generating all data, it will only sample, process and transmit data on the fly when a query comes. This technique reduces the power consumption by avoiding unnecessary samples being taken. It also creates a new space of optimization, as the way that queries are processed is totally different from the traditional method. A typical sensor networks contains a powered PC (the base station) and many distributed, low-power sensor nodes. The nodes are self-organized into a tree structure, with the base station acting as root. A query is parsed by base station and propagated to the whole network, the results are flowing back through the tree structure.

The main objective of optimization in ACQP is to reduce power consumption. To achieve this, the author contributed following work:
1. Reduce the amount of samples taken for a query by specifying sampling requirement in query and introducing event based queries;
2. For those attributes with constant value, record the value range of subtree into Semantic Routing Tree (SRT). When executing queries, prune the subtree of nodes that don’t have relevant data;
3. Reorder the sampling, selection and joins. Rewrite frequent event based queries as a join;
4. Prioritize data delivery when congestion occurs.

My favorite part of this paper is SRT. It smartly leverages the tree structure of network topology, pruning irrelevant nodes by storing only a little extra metadata. This is a simple and effective design.

A weakness of this paper is in the way it evaluates lifetime estimation. In their experiment, they only recorded the battery voltage of first 7% period of lifetime, and by linear fit they claim the estimated lifetime will meet expectation. From my daily experience of using cell phone batteries the claim is not true at all. Usually the battery seems strong during the first few hours and the voltage power drops super-linearly in another few hours. Given this observation, I think the actual voltage line in their experiment should be much lower after the first 10% lifetime. Thus resulting the real lifetime largely less than the predicted.