| 6TiSCH | T. Chang, Ed. |
| Internet-Draft | M. Vucinic |
| Intended status: Standards Track | Inria |
| Expires: April 19, 2020 | X. Vilajosana |
| Universitat Oberta de Catalunya | |
| S. Duquennoy | |
| RISE SICS | |
| D. Dujovne | |
| Universidad Diego Portales | |
| October 17, 2019 |
6TiSCH Minimal Scheduling Function (MSF)
draft-ietf-6tisch-msf-07
This specification defines the 6TiSCH Minimal Scheduling Function (MSF). This Scheduling Function describes both the behavior of a node when joining the network, and how the communication schedule is managed in a distributed fashion. MSF builds upon the 6TiSCH Operation Sublayer Protocol (6P) and the Minimal Security Framework for 6TiSCH.
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in [RFC2119].
This Internet-Draft is submitted in full conformance with the provisions of BCP 78 and BCP 79.
Internet-Drafts are working documents of the Internet Engineering Task Force (IETF). Note that other groups may also distribute working documents as Internet-Drafts. The list of current Internet-Drafts is at https://datatracker.ietf.org/drafts/current/.
Internet-Drafts are draft documents valid for a maximum of six months and may be updated, replaced, or obsoleted by other documents at any time. It is inappropriate to use Internet-Drafts as reference material or to cite them other than as "work in progress."
This Internet-Draft will expire on April 19, 2020.
Copyright (c) 2019 IETF Trust and the persons identified as the document authors. All rights reserved.
This document is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents (https://trustee.ietf.org/license-info) in effect on the date of publication of this document. Please review these documents carefully, as they describe your rights and restrictions with respect to this document. Code Components extracted from this document must include Simplified BSD License text as described in Section 4.e of the Trust Legal Provisions and are provided without warranty as described in the Simplified BSD License.
The 6TiSCH Minimal Scheduling Function (MSF), defined in this specification, is a 6TiSCH Scheduling Function (SF). The role of an SF is entirely defined in [RFC8480]. This specification complements [RFC8480] by providing the rules of when to add/delete cells in the communication schedule. This specification satisfies all the requirements for an SF listed in Section 4.2 of [RFC8480].
MSF builds on top of the following specifications: the Minimal IPv6 over the TSCH Mode of IEEE 802.15.4e (6TiSCH) Configuration [RFC8180], the 6TiSCH Operation Sublayer Protocol (6P) [RFC8480], and the Minimal Security Framework for 6TiSCH [I-D.ietf-6tisch-minimal-security].
MSF defines both the behavior of a node when joining the network, and how the communication schedule is managed in a distributed fashion. When a node running MSF boots up, it joins the network by following the 6 steps described in Section 4. The end state of the join process is that the node is synchronized to the network, has mutually authenticated to the network, has identified a preferred routing parent, and has scheduled one default negotiated cell (defined in Section 5.1) to/from its preferred routing parent. After the join process, the node can continuously add/delete/relocate cells, as described in Section 5. It does so for 3 reasons: to match the link-layer resources to the traffic, to handle changing parent, to handle a schedule collision.
MSF is designed to operate in a wide range of application domains. It is optimized for applications with regular upstream traffic (from the nodes to the root).
This specification follows the recommended structure of an SF specification, given in Appendix A of [RFC8480], with the following adaptations:
A node implementing MSF SHOULD implement the Minimal 6TiSCH Configuration [RFC8180], which defines the "minimal cell", a single shared cell providing minimal connectivity between the nodes in the network. The MSF implementation provided in this specification is based on the implementation of the Minimal 6TiSCH Configuration. However, an implementor MAY implement MSF without implementing Minimal 6TiSCH Configuration.
MSF uses the minimal cell to exchange the following packets:
To ensure there is enough bandwidth available on the minimal cell, a node implementing MSF SHOULD enforce some rules for limiting the traffic of broadcast frames. For example, a Trickle Timer defined in [RFC6550] MAY be applied on DIOs. However, this behavior is implementation-specific which is out of the scope of MSF.
MSF RECOMMENDS the use of 3 slotframes. MSF schedules autonomous cells at Slotframe 1 (Section 3) and 6P negotiated cells at Slotframe 2 (Section 5) , while Slotframe 0 is used for the bootstrap traffic as defined in the Minimal 6TiSCH Configuration. It is RECOMMENDED to use the same slotframe length for Slotframe 0, 1 and 2. Thus it is possible to avoid the scheduling collision between the autonomous cells and 6P negotiated cells (Section 3). The default slotframe length (SLOTFRAME_LENGTH) is RECOMMENDED for Slotframe 0, 1 and 2, although any value can be advertised in the EBs.
MSF nodes initialize Slotframe 1 with a set of default cells for unicast communication with their neighbors. These cells are called 'autonomous cells', because they are maintained autonomously by each node without negotiation through 6P. Cells scheduled by 6P transaction are called 'negotiated cells' which are reserved on Slotframe 2. How to schedule negotiated cells is detailed in Section 5. There are two types of autonomous cells:
To compute a [slotOffset,channelOffset] from an EUI64 address, nodes MUST use the hash function SAX [SAX-DASFAA]. The coordinates are computed to distribute the cells across all channel offsets, and all but the first time offsets of Slotframe 1. The first time offset is skipped to avoid colliding with the minimal cell in Slotframe 0. The slot coordinates derived from a given EUI64 address are computed as follows:
The second input parameter defines the maximum return value of the hash function. Other optional parameters defined in SAX determine the performance of SAX hash function. Those parameters could be broadcasted in EB frame or pre-configured. For interoperability purposes, an example how the hash function is implemented is detailed in Appendix B.
AutoTxCell is not permanently installed in the schedule but added/deleted on demand when there is a frame to sent. Throughout the network lifetime, nodes maintain the autonomous cells as follows:
Because of hash collisions, there will be cases that the AutoTxCell and AutoRxCell are scheduled at the same slot offset and/or channel offset. In such cases, AutoTxCell always take precedence over AutoRxCell. In case of conflicting with a negotiated cell, autonomous cells take precedence over negotiated cell, which is stated in [IEEE802154-2015]. However, when the Slotframe 0, 1 and 2 use the same length value, it is possible for negotiated cell to avoid the collision with AutoRxCell.
This section details the behavior the node SHOULD follow from the moment it is switched on, until it has successfully joined the network. Section 4.1 details the start state; Section 4.9 details the end state. The other sections detail the 6 steps of the joining process. We use the term "pledge" and "joined node", as defined in [I-D.ietf-6tisch-minimal-security].
A node implementing MSF SHOULD implement the Minimal Security Framework for 6TiSCH [I-D.ietf-6tisch-minimal-security]. As a corollary, this means that a pledge, before being switched on, may be pre-configured with the Pre-Shared Key (PSK) for joining, as well as any other configuration detailed in ([I-D.ietf-6tisch-minimal-security]). This is not necessary if the node implements a security solution not based on PSKs, such as ([I-D.ietf-6tisch-dtsecurity-zerotouch-join]).
When switched on, the pledge SHOULD randomly choose a frequency among the available frequencies, and start listening for EBs on that frequency.
Upon receiving the first EB, the pledge SHOULD continue listening for additional EBs to learn:
While the exact behavior is implementation-specific, it is RECOMMENDED that after having received the first EB, a node keeps listen for at most MAX_EB_DELAY seconds until it has received EBs from NUM_NEIGHBOURS_TO_WAIT distinct neighbors, which is defined in [RFC8180].
During this step, the pledge SHOULD NOT synchronize until it received enough EB from the network it wishes to join. How to decide whether an EB originates from a node from the network it wishes to join is implementation-specific, but MAY involve filtering EBs by the PAN ID field it contains, the presence and contents of the IE defined in [I-D.richardson-6tisch-join-enhanced-beacon], or the key used to authenticate it.
The decision of which neighbor to use as a JP is implementation-specific, and discussed in [I-D.ietf-6tisch-minimal-security].
After selected a JP, a node generates a Join Request and installs an AutoTxCell to the JP. The Join Request is then sent by the pledge to its JP over the AutoTxCell. The AutoTxCell is removed by the pledge when the Join Request is sent out. The JP receives the Join Request through its AutoRxCell. Then it forwards the Join Request to the JRC, possibly over multiple hops, over the 6P negotiated Tx cells. Similarly, the JRC sends the Join Response to the JP, possibly over multiple hops, over AutoTxCells or the 6P negotiated Tx cells. When JP received the Join Response from the JRC, it installs an AutoTxCell to the pledge and sends that Join Response to the pledge over AutoTxCell. The AutoTxCell is removed by the JP when the Join Response is sent out. The pledge receives the Join Response from its AutoRxCell, thereby learns the keying material used in the network, as well as other configurations, and becomes a "joined node".
When 6LoWPAN Neighbor Dicovery ([RFC8505]) (ND) is implemented, the unicast packets used by ND are sent on the AutoTxCell. The specific process how the ND works during the Join process is detailed in [I-D.ietf-6tisch-architecture].
Per [RFC6550], the joined node receives DIOs, computes its own Rank, and selects a preferred parent.
After selected a preferred parent, the joined node MUST generate a 6P ADD Request and install an AutoTxCell to that parent. The 6P ADD Request is sent out through the AutoTxCell with the following fields:
The joined node removes the AutoTxCell to parent when the 6P Request is send out. Its parent receives the 6P ADD Request from its AutoRxCell. Then it generates a 6P ADD Response and installs an AutoTxCell to the joined node. When the parent sends out the 6P ADD Response, it MUST remove that AutoTxCell. The joined node receives the 6P ADD Response from its AutoRxCell and completes the 6P transcation. In case the 6P ADD transaction failed, the node MUST issue another 6P ADD Request and repeat until the Tx cell is installed to the parent.
The node SHOULD start sending EBs and DIOs on the minimal cell, while following the transmit rules for broadcast frames from Section 2.
The node SHOULD send some form of keep-alive messages to all its neighbors it has negotiated cell with. The node sends a keep-alive message to the neighbor if no frames is received from that neighbor within a period, which is defined as KA_PERIOD. This mechanism is used to poll its children to ensure the child is still reachable. If the keep-alive message to a child fails at the link layer (i.e. the maximum number of link-layer retries is reached), the node SHOULD declare the child as unreachable. This can happen for example when the child node is switched off.
When a neighbor is declared unreachable, the node MUST remove all negotiated cells with that neighbor from its own schedule. In addition, it MAY issue a 6P CLEAR to that neighbor (which can fail at the link-layer). The node MAY be removed from the neighbor table.
For a new node, the end state of the joining process is:
Once a node has joined the 6TiSCH network, it adds/deletes/relocates cells with its preferred parent for three reasons:
Those cells are called 'negotiated cells' as they are scheduled through 6P, negotiated with their parents. Without specific declaring, all cells mentioned in this section are negotiated cells and they are installed at Slotframe 2.
A node implementing MSF MUST implement the behavior described in this section.
The goal of MSF is to manage the communication schedule in the 6TiSCH schedule in a distributed manner. For a node, this translates into monitoring the current usage of the cells it has to its preferred parent:
The node MUST maintain the following counters for its preferred parent:
The cell option of the cell listed CellList in 6P Request SHOULD be either Tx=1 only or Rx=1 only. Both NumCellsElapsed and NumCellsUsed counters can be used to both type of negotiated cells.
As there is no negotiated Rx Cell installed at initial, the AutRxCell is taken into account as well for downstream traffic adaptation. Hence by default, each node at least has one Rx cell in schedule for counting the NumCellsElapsed and NumCellsUsed of dwonstream traffic.
Implementors MAY choose to create the same counters for each neighbor, and add them as additional statistics in the neighbor table.
The counters are used as follows:
The value of MAX_NUMCELLS is chosen according to the traffic type of the network. Generally speaking, the larger the value MAX_NUMCELLS is, the more accurate the cell usage is calculated. The 6P traffic overhead using a larger value of MAX_NUMCELLS could be reduced as well. Meanwhile, the latency won't increaase much by using a larger value of MAX_NUMCELLS for periodic traffic type. For burst traffic type, larger value of MAX_NUMCELLS indeed introduces higher latency. The latency caused by slight changes of traffic load can be absolved by the additional scheduled cells. In this sense, MSF is a scheduling function trading latency with energy by scheduling more cells than needed. It is recommended to set MAX_NUMCELLS value at least 4 times than the maximum link traffic load of the network in packets per slotframe. For example, a 2 packets/slotframe traffic load results an average 4 cells scheduled, using the value of double number of scheduled cells (which is 8) as MAX_NUMCELLS gives a good resolution on cell usage calculation.
A node implementing MSF SHOULD implement the behavior described in this section.
Part of its normal operation, the RPL routing protocol can have a node switch preferred parent. The procedure for switching from the old preferred parent to the new preferred parent is:
A node implementing MSF SHOULD implement the behavior described in this section. The "MUST" statements in this section hence only apply if the node implements schedule collision handling.
Since scheduling is entirely distributed, there is a non-zero probability that two pairs of nearby neighbor nodes schedule a negotiated cell at the same [slotOffset,channelOffset] location in the TSCH schedule. In that case, data exchanged by the two pairs may collide on that cell. We call this case a "schedule collision".
The node MUST maintain the following counters for each managed unicast cell to its preferred parent:
Implementors MAY choose to maintain the same counters for each negotiated cell in the schedule.
Since both NumTx and NumTxAck are initialized to 0, we necessarily have NumTxAck <= NumTx. We call Packet Delivery Ratio (PDR) the ratio NumTxAck/NumTx; and represent it as a percentage. A cell with PDR=50% means that half of the frames transmitted are not acknowledged (and need to be retransmitted).
Each time the node switches preferred parent (or during the join process when the node selects a preferred parent for the first time), both NumTx and NumTxAck MUST be reset to 0. They increment over time, as the schedule is executed and the node sends frames to its preferred parent. When NumTx reaches MAX_NUMTX, both NumTx and NumTxAck MUST be divided by 2. That is, for example, from NumTx=256 and NumTxAck=128, they become NumTx=128 and NumTxAck=64. This operation does not change the value of the PDR, but allows the counters to keep incrementing. The value of MAX_NUMTX is implementation-specific.
The key for detecting a schedule collision is that, if a node has several cells to the same preferred parent, all cells should exhibit the same PDR. A cell which exhibits a PDR significantly lower than the others indicates than there are collisions on that cell.
Every HOUSEKEEPINGCOLLISION_PERIOD, the node executes the following steps:
The 6P SIGNAL command is not used by MSF.
The Scheduling Function Identifier (SFID) of MSF is IANA_6TISCH_SFID_MSF.
MSF uses 2-step 6P Transactions exclusively. 6P Transactions are only initiated by a node towards its preferred parent. As a result, the cells to put in the CellList of a 6P ADD command, and in the candidate CellList of a RELOCATE command, are chosen by the node initiating the 6P Transaction. In both cases, the same rules apply:
As a consequence of randomly cell selection, there is a non-zero chance that nodes in the vicinity installed cells with same slotOffset and channelOffset. An implementer MAY implement a strategy to monitor the candidate cells before adding them in CellList to avoid collision. For example, a node MAY maintain a candidate cell pool for the CellList. The candidate cells in the pool are pre-configured as Rx cells to promiscuously listen to detect transmissions on those cells. If IEEE802.15.4 transmissions are observed on one cell over multiple iterations of the schedule, that cell is probably used by a TSCH neighbor. It is moved out from the pool and a new cell is selected as a candidate cell. The cells in CellList are picked from the candidate pool directly when required.
It is calculated for the worst case that a 6P response is received, which means the 6P response is sent out successfully at the very latest retransmission. And for each retransmission, it backs-off with largest value. Hence the 6P timeout value is calculated as ((2^MAXBE)-1)*MAXRETRIES*SLOTFRAME_LENGTH, where:
Cells are ordered slotOffset first, channelOffset second.
The following sequence is correctly ordered (each element represents the [slottOffset,channelOffset] of a cell in the schedule):
[1,3],[1,4],[2,0],[5,3],[6,0],[6,3],[7,9]
The Metadata field is not used by MSF.
Section 6.2.4 of [RFC8480] lists the 6P Return Codes. Figure 1 lists the same error codes, and the behavior a node implementing MSF SHOULD follow.
+-----------------+----------------------+
| Code | RECOMMENDED behavior |
+-----------------+----------------------+
| RC_SUCCESS | nothing |
| RC_EOL | nothing |
| RC_ERR | quarantine |
| RC_RESET | quarantine |
| RC_ERR_VERSION | quarantine |
| RC_ERR_SFID | quarantine |
| RC_ERR_SEQNUM | clear |
| RC_ERR_CELLLIST | clear |
| RC_ERR_BUSY | waitretry |
| RC_ERR_LOCKED | waitretry |
+-----------------+----------------------+
Figure 1: Recommended behavior for each 6P Error Code.
The meaning of each behavior from Figure 1 is:
The behavior when schedule inconsistency is detected is explained in Figure 1, for 6P Return Code RC_ERR_SEQNUM.
Figure 2 lists MSF Constants and their RECOMMENDED values.
+------------------------------+-------------------+
| Name | RECOMMENDED value |
+------------------------------+-------------------+
| NUM_CH_OFFSET | 16 |
| KA_PERIOD | 1 min |
| LIM_NUMCELLSUSED_HIGH | 75 % |
| LIM_NUMCELLSUSED_LOW | 25 % |
| HOUSEKEEPINGCOLLISION_PERIOD | 1 min |
| RELOCATE_PDRTHRES | 50 % |
| SLOTFRAME_LENGTH | 101 slots |
| QUARANTINE_DURATION | 5 min |
| WAITDURATION_MIN | 30 s |
| WAITDURATION_MAX | 60 s |
+------------------------------+-------------------+
Figure 2: MSF Constants and their RECOMMENDED values.
Figure 3 lists MSF Statistics and their RECOMMENDED width.
+-----------------+-------------------+
| Name | RECOMMENDED width |
+-----------------+-------------------+
| NumCellsElapsed | 1 byte |
| NumCellsUsed | 1 byte |
| NumTx | 1 byte |
| NumTxAck | 1 byte |
+-----------------+-------------------+
Figure 3: MSF Statistics and their RECOMMENDED width.
MSF defines a series of "rules" for the node to follow. It triggers several actions, that are carried out by the protocols defined in the following specifications: the Minimal IPv6 over the TSCH Mode of IEEE 802.15.4e (6TiSCH) Configuration [RFC8180], the 6TiSCH Operation Sublayer Protocol (6P) [RFC8480], and the Minimal Security Framework for 6TiSCH [I-D.ietf-6tisch-minimal-security]. In particular, MSF does not define a new protocol or packet format.
MSF relies entirely on the security mechanisms defined in the specifications listed above.
This document adds the following number to the "6P Scheduling Function Identifiers" sub-registry, part of the "IPv6 over the TSCH mode of IEEE 802.15.4e (6TiSCH) parameters" registry, as defined by [RFC8480]:
+----------------------+-----------------------------+-------------+ | SFID | Name | Reference | +----------------------+-----------------------------+-------------+ | IANA_6TISCH_SFID_MSF | Minimal Scheduling Function | RFC_THIS | | | (MSF) | | +----------------------+-----------------------------+-------------+
Figure 4: IETF IE Subtype '6P'.
| [SAX-DASFAA] | Ramakrishna, M. and J. Zobel, "Performance in Practice of String Hashing Functions", DASFAA , 1997. |
Beshr Al Nahas (Chalmers University, beshr@chalmers.se) Olaf Landsiedel (Chalmers University, olafl@chalmers.se) Yasuyuki Tanaka (Inria-Paris, yasuyuki.tanaka@inria.fr)
For the consideration of interoperability, this section provides an example of implemention SAX hash function [SAX-DASFAA]. The input parameters of the function are:
In MSF, the T is replaced by the length slotframe 1. String s is replaced by the mote EUI64 address. The characters of the string c0, c1, ..., c7 are the 8 bytes of EUI64 address.
The SAX hash function requires shift operation which is defined as follow:
The steps to calculate the hash value of SAX hash function are:
The value of variable h the hash value of SAX hash function.
For interoperability purposes, the values of h0, l_bit and r_bit in Step 1 and 2 are configured as:
The appropriate values of l_bit and r_bit could vary depending on the the set of motes' EUI64 address. How to find those values is out of the scope of this specification.