[SensorNetArch] Fragmentation & Reassembly

[Cheng Tien Ee]

Been thinking and noting down points about this since the meeting 
yesterday, here's thoughts on frag+reassembly...

Fragmentation + reassembly

Application passes large packet to lower layers, which fragments
packet before sending. If at least one fragment gets dropped, probably
all fragments at receiver end will be dropped too. This is true unless
there is some sort of recovery mechanism to retrieve dropped fragments.
Compare with TCP, which uses ACKs, timeouts, and 3DAs to recover missing
segments. If recovery mechanism is used, this indirectly implies that
the sink mote must have some means to contact the source, that's to say
point-to-point routing would be required. If recovery mechanisms are not
implemented, it can be the case that, even though we have small fragments
at the link-layer, in effect it would be worse than transmitting large
packets at the link-layer (because of additional packet overhead),
since at the receiver end even a bit dropped from the fragments would
cause the entire large packet to be discarded. I believe that contention
may not play a significant role if the MAC layer does the appropriate
stuff, e.g. synchronization, and MACAW shuts up neighboring motes
long enough for a large data packet to be sent.

Also, fragmentation + reassembly implies that receiver has to store
and wait for rest of packet to arrive. If fragments are dropped, storage
will be required before timeout occurs. The timeout period is sensitive
to the network size, and is difficult to determine the optimal value.
If timeout is set too long, there may be insufficient memory to buffer
received fragments. If too small, existing received fragments will be
dropped too early. Lastly, the sink mote may potentially be receiving
from numerous source motes, thus ballooning the amount of state required
at any point in time.

Finally, it is likely that application may not need all the data
that was transmitted. Data in fragments received may be good enough, thus,
perhaps fragmentation should be left to the application layer. Or perhaps
the application can choose the type of service it requires
(compare with UDP, TCP), and that causes the corresponding modules to
be wired.