Net2WG/Notes/20070301
Present: Phil, Om, Sukun, Rodrigo Notes: Rodrigo
Discussion on transmission queue interface
P: So Om sent a proposed interface for controlling the queue in CTP (reproduced in [1] below). What do you think, Sukun? Can you implement something like Flush using that?
R: Sukun sent interfaces yesterday (reproduced in [2] below) that are practically the same.
S: Yes, we can implement Flush on that.
R: The only addition in these in relation to what's in Flush is the event that signals a change in the queue size. We used the getQueueOccupancy command. This is because we only need to know the queue length at specific times (when sending packets), and do not respond to specific queue sizes.
P: If you want to respond to something like 'I want to send a beacon packet when my queue is above some threshold' you need the event. If you are polling, a queue may fill up between two queries.
R: The event interface can give you complete information. What about the overhead, if you don't need?
P: Not too great.
O: The semantics should not be to signal every queue change.
P: This may not be possible, and would impose some problematic assumptions on the concurrency model.
R: We should definitely have both then. If you can't get all changes, then the event must have the absolute size of the queue, relative (+1, -1) changes don't mean much.
R: I think the name should not be CTP..., rather QueueControl, or something. It's not specific to CTP.
P: Right.
P: How about ForwardingQueueControl?
R: Not only forwarding
P: TransmitQueue? This gives the idea that it's not only a queue, but also talks about how to transmit packets (timing, etc)
P: Tep 111 message_t was finalized.
R: Any major changes?
P: No, clarification of packet payload offset.
R: Meeting times?
O: The only intersection is Friday 12:00 - 1:00.
P: Send mail to David Gay to set up the conference calls
O: Zigbee. I contacted people at ISEP/IPP in Portugal, who are doing a ZigBee implementation in TinyOS, and there seems to be interest in the group. We will talk more. What is the licensing situation in T2?
[ This group is doing http://www.open-ZB.net - Open Source Toolset for IEEE 802.15.4 and ZigBee ]
P: [N.B.: Please check with the Core/Alliance group for accurate information] For the core, there are two licenses approved: the new BSD license (used by Stanford, ArchRock, Crossbow) and the academic license (used by Berkeley code). For contrib, it is more lenient, ant most OSI approved licenses are allowed. I say most because there is a set that is approved, and any other not in the set must be approved of individually. GPL is not allowed.
P: If they are willing to participate in Net2, that would be great!
P: Looks like 2.1 is going to have software acknowledgments in the CC2420.
O: There is another person who sent mail to TinyOS-help. He is doing any to any routing, and asked whether any of the things we are doing would help him. I told him to take a look at the interfaces and code, and come back.
P: I know Rodrigo would love to get traction on getting NLA implemented.
R: I think a lot of what we are doing can help, even if not directly today. For example, some of the forwarding and the link estimator can be used. Some is hidden, like the UnicastAddressFreeRouting interface. What it does is it has a getNextHop command, with implicit address.
O: We didn't get a lot of response. I think the strategy is going to be: encourage everyone.
S: some people might be afraid of sending to the list
O: I'll solicit email to me or to list stress that
P: next step, what protocols people would like to include. Other people to ask: Andreas Terzis at Johns Hopkins, he is looking at Deluge.
O: would that be in core or net2?
P: that would be split: part in core (storage), part in net2.
P: Another one: Kaisen, at UCSD, doing good work on dissemination.
O: Ok, talk to you next week then.
[1] . Om's sent interface for controlling the queue {{{ interface CtpConfig {
/* Packet interval is defined as the minimum time * between two successful packet transmissions */
/* Set the packet interval to 'interval' ms */ command void setPacketInterval(uint16_t interval);
/* Returns the current inter packet interval in ms */ command uint16_t getPacketInterval();
/* The size of the forwarding queue */ command uint8_t getQueueSize();
/* The number of packets in the forwarding queue */ command uint8_t getNumPacketsQueued();
/* Signals if a packet is enqueued or dequeued from the * forwarding queue. * The queue occupancy has changed by 'change' number of * of packets and the new queue occupancy is 'numpackets' */ event void QueueUpdated(int8_t change, uint8_t numpackets);
} }}}
[2]. Sukun and Rodrigo's version (from Flush, with a few changes) {{{ interface QueueInfo {
/* Returns the size of queue. */ command uint8_t getQueueSize();
/* Returns the number of items in the queue. * When the queue is empty, the return value is 0. * When the queue is full, the return value is the size of queue. */ command uint8_t getQueueOccupancy();
/* The occupancy of the queue is changed */ event error_t queueOccupancyChanged(uint8_t newOccupancy);
}
interface RateControl {
/* Disables rate control on the queue. Idempotent */ command void disable();
/* Enables rate control on the queue. Idempotent */ command void enable();
/* Check if the rate control is enabled. */ command bool isEnabled();
/* Returns the minimum inter packet transmission interval. */ command uint16_t getInterval();
/* Sets the minimum inter packet transmission interval.
* Returns FAIL if the interval can't be set.
* Can be called even if disabled, and changes the state
* so that if control is enabled again the new value will
* be in effect
*/
command error_t setInterval(uint16_t newInterval);
} }}}
