阅读说明：本技术 通过参数初始化和重用来生成预定系数的线性网络编码 (Linear network coding for generating predetermined coefficients by parameter initialization and reuse ) 是由 克里姆·富利 穆里尔·梅达尔 于 2020-02-28 设计创作，主要内容包括：一种网络节点,其具有：用于接收输入的包的接收器；其中存储了用于编码的一个或更多个参数的本地节点存储器；用于使用线性网络编码从所述输入的包来创建经编码的包的编码器；以及用于发送所述经编码的包的发送器。所述线性网络编码的每个系数是所述一个或更多个参数中的参数,或者所述一个或更多个参数的预定函数。还提出了相关的方法和网络。(A network node, having: a receiver for receiving incoming packets; a local node memory having stored therein one or more parameters for encoding; an encoder for creating encoded packets from the input packets using linear network coding; and a transmitter for transmitting the encoded packet. Each coefficient of the linear network coding is a parameter of the one or more parameters, or a predetermined function of the one or more parameters. Related methods and networks are also presented.)

1. A network node, comprising:

a receiver for receiving an incoming packet;

a local node memory having stored therein one or more parameters for encoding;

an encoder for creating an encoded packet from the input packet using linear network coding, wherein each coefficient of the linear network coding is a parameter of the one or more parameters, or a predetermined function of the one or more parameters; and

a transmitter for transmitting the encoded packet.

2. The network node of claim 1, wherein the encoder is configured to create the encoded packet from a cached copy of an incoming packet or a previously encoded packet.

3. The network node of any of claims 1-2, wherein the encoder is configured to compute the linear network encoded coefficients using one or more previously generated and locally stored coefficients.

4. The network node according to any of claims 1-3, wherein the one or more parameters or the predetermined function are selected by the network node at network setup or node discovery.

5. The network node according to any of claims 1-4, wherein the one or more parameters or the predetermined function are initialized by a network management unit at network setup or node discovery and fixed thereafter.

6. The network node of any of claims 1-3, wherein the one or more parameters or the predetermined function are pre-programmed and fixed at device manufacture.

7. A network node according to any of claims 1-3, wherein the one or more parameters or the predetermined function are initialized at network setup or node discovery and may be modified or updated by the network node or a network management unit.

8. The network node of any of claims 1-7, wherein the predetermined function cycles through the limited set of one or more parameters.

9. The network node according to any of claims 1-8, wherein the predetermined function is a mathematical sequence.

10. The network node of claim 9, wherein the mathematical sequence is reinitialized for each encoding operation.

11. A method for processing packets input to a network node, comprising:

reading one or more parameters from a local memory;

determining whether an encoded packet is needed;

reusing the stored parameters to generate one or more coefficients required for linear network coding; and

creating an encoded packet from the input packet using the generated one or more coefficients,

wherein each of the one or more coefficients is a parameter of the one or more parameters or is generated from the one or more parameters by one or more predetermined functions.

12. The method of claim 11, wherein the determining is based on an external request for an encoded packet.

13. The method of claim 11, wherein the determining is based on internal factors.

14. The method of claim 13, wherein the internal factor is a periodic trigger for generating an encoded packet or a local estimate of packet loss on the network.

15. A network comprising a plurality of network nodes, wherein one or more of the network nodes is as claimed in any one of claims 1-10.

16. The network of claim 15, wherein the one or more parameters of one or more of the network nodes are pre-programmed parameters.

17. The network node of claim 9, wherein the mathematical sequence is reinitialized for each flow or batch of packets.

18. The network node according to any of claims 1-10 and 17, wherein the predetermined function is a combination of two or more sub-functions.

19. The network node of claim 18, wherein different coefficients are generated using different ones of the two or more sub-functions.

20. The network node according to any of claims 1-10 and 17-19, wherein the predetermined function generates only non-zero coefficients.

21. The network node according to any of claims 1-10 and 17-20, wherein the predetermined function generates a batch of coefficients, wherein the size of a batch depends on coding requirements.

22. The network node according to any of claims 1-10 and 17-21, wherein the network node selects coefficients to reduce or control coding complexity.

Background

Linear network coding is the process of applying linear coefficients to an input in order to derive a coded output. Linear network coding is a method applied to nodes of a data transmission and storage network to enable communication and improve efficiency, whereby the nodes in the data network function as encoders and decoders.

In particular, a node operating as an encoder not only forwards (i.e., relays or replicates) information received from an incoming link, it also encodes such information. Encoding at a node in a network is referred to as network encoding. The network can be modeled as a graph with directional links, one or more sources and one or more receivers, as shown in r.koetter and m.medard in "algebraic methods of network coding" (IEEE/ACM transactions on network, volume 11, phase 5, month 10 2003), which is incorporated herein by reference in its entirety. A common communication problem in networks is the multicast connectivity problem, where source data has to be transmitted to each of the sink nodes.

Network coding enables connections that are limited to forwarding only and cannot be achieved. In particular, r.ahlswede, n.cai, s. -y.r.li and r.w.yeung have been shown in "network traffic" (volume 46, page 1204-1216 (2000) of IEEE information theoretic transactions), which is incorporated herein in its entirety by reference, it is generally not optimal to simply route or copy the information to be transmitted. Instead, bandwidth can generally be saved by employing coding at the node.

The Network may be represented as a directed graph as shown in r.koetter and m.medard in "Beyond Routing: An Algebraic Approach to Network coding" (IEEE Infocom conference record 2002), which is incorporated herein by reference in its entirety. The graph includes a source node and a sink node, wherein data is transmitted from the source node to the sink node. In the above reference, an algorithm is disclosed that uses knowledge of the entire network topology to find a linear coding solution to a given multicast connectivity problem.

However, in applications where communication is limited or expensive, it may be preferable to determine the behavior of each node in a distributed manner. Determining node behavior in a distributed manner is based on information and/or minimal control signaling locally available to each node without requiring centralized coordination or knowledge of the overall network topology. T.ho, r.koetter, m.medard, d.r.karger and m.effros have shown in the "benefit of coding over routing in random environments" (international seminar of information theory (ISIT) 2003), which is incorporated herein by reference in its entirety, that the multicast connectivity problem can be solved in a distributed manner by random linear network coding.

In the above references, linear network coding uses random coefficient generation on data streams, where nodes linearly combine streams by assigning random coefficients to each stream. Coefficients are defined herein as elements from a finite field associated with a given data stream as its multiplier, wherein the addition of multiplied data streams forms a linear combination of streams (i.e., an encoded stream).

The random or arbitrary selection of coefficients may be done in a dynamic or predetermined manner. The use of a predetermined code structure may simplify network operation. The use of a predetermined code structure may simplify network operation. A predetermined code structure is proposed as a simplified code to solve the multicast connectivity problem in wireless multicast networks, see Anna H Lee, simplified random network code for multicast networks, the massachusetts institute of technology engineering thesis, month 5 2005 (Lee), which is incorporated herein by reference in its entirety.

Disclosure of Invention

In a first aspect of the disclosure, a network node is described, the network node comprising: a receiver for receiving incoming packets; a local node memory having stored therein one or more parameters for encoding; an encoder for creating an encoded packet from the input packet using linear network coding, wherein each coefficient of the linear network coding is a parameter of the one or more parameters, or a predetermined function of the one or more parameters; and a transmitter for transmitting the encoded packet.

In a second aspect of the disclosure, a method for processing packets input to a network node is described, the method comprising: reading one or more parameters from a local memory; determining whether an encoded packet is needed; the method further includes reusing the stored parameters to generate one or more parameters required for linear network coding, and creating an encoded packet from the input packet using the generated one or more coefficients, wherein each of the one or more coefficients is a parameter of the one or more parameters or is generated from the one or more parameters by one or more predetermined functions.

Drawings

The accompanying drawings, which are incorporated in and constitute a part of this specification, illustrate one or more embodiments of the disclosure and, together with the description of the example embodiments, serve to explain the principles and implementations of the disclosure.

Fig. 1 shows a prior art example of a univariate code in an inter-stream network coding setup.

Fig. 2 illustrates parameter reuse according to an embodiment of the present disclosure.

Fig. 3 shows the architecture of the node of fig. 2.

Fig. 4 illustrates parameter reuse according to yet another embodiment of the present disclosure.

Fig. 5 shows the architecture of the node of fig. 4.

FIG. 6 shows a flow diagram of a possible sequence set of operations performed by the nodes in the previous figures.

Fig. 7 illustrates multi-parameter reuse according to yet another embodiment of the present disclosure.

Fig. 8 illustrates an example network with different parameters across network nodes in accordance with this disclosure.

Fig. 9 shows an example of parsimonious code in a network.

Fig. 10 shows a sequence of packets transmitted by some of the nodes of fig. 9.

Detailed Description

Embodiments of the present disclosure are directed to simplifying mass-produced nodes (e.g., sensor nodes) by including simple code in a pre-programmed routine of the node or by node initialization. This simplifies both the node operation (e.g., by eliminating random coefficient generation) and the node design process (e.g., by pre-programming code).

The methods described herein are not limited by a single variable or coefficient. Rather, they are characterized by a limited number of variables that are pre-programmed (hardwired or programmed) or initially distributed to the nodes. Another feature of them is that there is no randomness in the selection of the network coding coefficients, so they are qualified in advance.

Linear coding may be applied to streams or data units, where streams are sequences of data units having the same routing characteristics (e.g., they typically have similar addressing information).

Each data unit is a set of bits. Linear coding is generally applied to sets of bits of equal size called symbols. The symbol size depends on the field size in which the coding is applied. This document assumes that there is sufficient conversion between data units and symbols, a process that resides in the encoding and decoding modules, and typically involves padding, segmentation, and header generation. The method described herein is independent of field size.

Although this disclosure may use the terms "data unit" and "packet" interchangeably, the methods described herein are applicable to data units of any layer, including physical and data link frames, network layer packets, transport layer segments, or application layer data units and bitstream subdivision. In storage applications, a data unit typically represents a file block or a disk sector. Furthermore, the methods described herein may be applied by software or hardware.

Inter-stream network coding is the application of inter-stream network coding, in which coefficients are assigned to a stream, rather than its constituent data units. Inter-stream network coding is the application of intra-stream network coding, where coefficients are assigned to individual data units. In inter-linear coding, coefficients are defined as elements from a finite field associated with a given data unit (e.g., a packet) as its multiplier, where the addition of multiplied data units forms a linear combination of data units (i.e., a coded data unit).

The methods described herein cover inter-stream coding with a limited number of parameters that may need to be reused by the node in order to generate coefficients for each data unit. And reusing the parameters on the nodes through the coefficient generating function. The parameters and coefficient generation functions are pre-programmed at the time of device manufacture or input to the nodes during node or network initialization. Code that employs a limited set of parameters and functions is described herein as parsimonious code.

Parsimony codes are linear network codes that avoid the use of an online pseudo-random number generator in coefficient generation. Instead, the coefficients are generated at the nodes using the parameters and a predetermined function. Parsimony codes reduce the complexity of the encoding process that a node needs to perform by reducing the number of operations required to generate the encoded coefficients. This reduces the energy usage of the node.

Frugal code can be deployed on individual communication nodes as a simple means to implement Random Linear Network Coding (RLNC). Applications include all systems that transmit or store data, including backbone communication and Wide Area Networks (WANs), optical networks, satellite networks, access and Metropolitan Area (MAN) networks, wireless cellular and mobile networks, Local Area Networks (LANs), home networks, Personal Area Networks (PANs), body area networks, Storage Area Networks (SANs), cloud networks, enterprise storage networks, data center systems, and server arrays, among others. In particular, the reduction in complexity and energy usage has prompted the deployment of parsimonious code in systems and networks that use small-sized devices, as described below.

The term "node" denotes any communication element of a wireless or wired communication infrastructure, including bluetooth, WiFi, cellular (e.g., LTE), server and data center systems, backbone and access routers, cloud computing nodes, and Network Interface Cards (NICs) for vehicular, industrial, satellite, and computer networks. In particular, the nodes may be implemented in various consumer electronics devices, such as personal computers, computer products, laptops, telephones, tablets, and the like. The methods described herein are particularly attractive for small-sized devices produced on a large scale due to the sensitivity of such devices to cost, power consumption and complexity. Such devices include devices used in: sensor systems, home networks, internet of things (IoT) networks, embedded systems, mesh networks, mobile ad hoc networks (MANETs), mobile systems, cellular networks, Small Form Factor (SFF) systems, and any device that requires low power consumption, uses a low cost transceiver microchip, or has low computing power. Thus, in the present disclosure, the term "node" refers to a base station, a mobile terminal, a personal computer, or similar electronic device capable of processing data, wherein the devices are capable of networking and communicating with each other.

This application may be directed to U.S. patent No. 9,699,104 and U.S. patent No. 9,258,084, both of which are incorporated herein by reference in their entirety. Although US9,699,104 does not specify a method of generating coefficients at a node, the present application provides specific embodiments of generating coefficients and generating encoded data units at a node.

In contrast to US9,258,084, in the present application no codebook is generated or used at system start-up. Furthermore, unlike US9,258,084, the present application does not require nodes to use a single function well known throughout the network. Instead, different functions may be used and no coordination in function definition is required between the nodes. Furthermore, the present application requires the use and reuse of a limited number of parameters to generate a function of coefficients at a node.

Lee, already briefly described in the background section of this application, proposes a single coefficient ("univariate") code construction for network coding in a distributed multicast wireless setting. The term "univariate" refers to code that uses a single variable. In Lee, the single variable required for encoding is the coefficient α; the principle is that all nodes use the same (pre-programmed) coefficients (a) for network coding. In practice, Lee proposes to use a unity coefficient (1) for locally generated streams and a pre-programmed coefficient α for all incoming streams, thereby creating a measure of coefficient diversity. (see, e.g., FIG. 1).

Lee explicitly identifies coefficient diversity as a limiting factor for univariate codes, as the lack of coefficient diversity leads to linear correlation and inability to decode at the receiver, resulting in infeasible codes. Lee discusses other diversity paradigms. For example, code diversification is explored by introducing a second parameter (f) that represents a portion of the stream to which the unit coefficients are to be assigned. Lee also discusses the code efficiency for different coefficient values for different parity finite field sizes.

Lee is only focused on solving the multicast connectivity problem, where the network is modeled as a set of multicast sources, sinks, and intermediate nodes that transmit information streams. Thus, the model only considers inter-stream network coding, where nodes combine incoming (and local) streams to form outgoing streams and apply network coding at the stream level.

In particular, fig. 1 (replicated from Lee) shows an example of a univariate code in an inter-stream network coding setup. In this example, the node combines the input signal and the local signal or stream using linear coding. The table in fig. 1 shows the coefficients used in the linear combination. The coefficients for the input signal and the local signal are alpha and 1, respectively.

Lee does not consider inter-stream network coding, i.e., the process of encoding individual data units (e.g., packets) of the same stream.

Inter-stream network coding has shown significant efficiency and performance advantages, particularly for packet erasure/error correction, delay reduction, multicasting, multi-path operation, and mesh networks.

Inter-stream network coding has wide applications and benefits in networks involving small devices, ranging from power saving to network efficiency and robustness.

The approach described herein extends the "univariate" concept described by Lee to inter-stream network coding. They present embodiments that are also motivated by the simplicity of code that is easy to bulk program and more suitable for smaller devices (e.g., sensors) and devices with computational constraints.

Parameter initialization and reuse

Parameters are members of a finite field stored in node memory at node initialization, where initialization is defined as the process by which a node becomes operational in a network.

The number of parameters and functions should be limited to simplify node production and reduce memory usage and complexity of coefficient computation. It would be desirable to use one parameter and one function. However, for coefficient diversity, it may be desirable to provide more than one of each.

Initialization includes pre-programming all nodes with a limited number of parameters. Initialization also includes pre-programming each node with a limited number of functions for generating coefficients from the parameters. In various embodiments, a central authority (e.g., a network controller or network management unit) may distribute/propagate parameters and functions to nodes prior to communication (e.g., network setup, node discovery, etc.). Alternatively, all nodes may be programmed to select their own parameters from information available to the node at initialization (e.g., using some or all of the hardwired node parameters such as serial number, network address, etc.).

Parameter reuse refers to the repeated use of the same one or more parameters to generate multiple coefficients. Each encoding operation results in the creation of one encoded packet. The node will reuse its parameters in each encoding operation to generate encoding coefficients for each data unit (e.g., packet) to be encoded, where each coefficient is a parameter or a function thereof.

Each encoding operation (i.e., creation of one encoded packet) typically requires multiple coefficients. If the function used to create the coefficients is a sequence (e.g., an arithmetic or geometric sequence), it may be reinitialized or continued (e.g., to the next multiple or power of the parameter) at each new encoding operation. In one embodiment, the function may be reinitialized for each different packet stream (e.g., video).

Coefficients are generated from the parameters using a predetermined function. The predetermined function is a mathematical function or algorithm that may be stored in the node memory (e.g., as part of its programming software). The node knows it since the node was initialized.

Both functions and parameters may have been received from the network (e.g., central node) or selected locally. Parameters and functions may be modified later, but this happens occasionally as a network management event (i.e., not at the frequency of incoming packets).

Reuse is shown in fig. 2 (200), where node n1(210) generates encoded packets c1 and c2(230) from the input packets p1, p2 and p3 (220). The parameters (212) are stored in a local memory of the node.

Each time a new coefficient is needed, the node (210) reuses the stored parameters (212) to generate new coefficients (213).

The coefficients (213) may take the form of a sequence of mathematical numbers generated by a function using the parameters. For example, each coefficient (except for the initial set of one or more coefficients) may be a function of one or more previous coefficients. Therefore, it may be necessary to temporarily store the previous coefficient (213) required for generating the next coefficient until the next coefficient is generated.

Fig. 3 shows a possible embodiment (300) of an architecture of a node (310) reusing one or more parameters for the purpose of linear network coding. The parameters are stored in a local memory (315) of the node.

Incoming packets (320) arrive at the node from different input ports via receiver units (RX) (311). They are then buffered at a buffer unit (313) for encoding and retransmission. When encoding is required, coefficients (316) are generated from the stored parameters (315) and the coefficients (316) are used at an encoding unit (314) to generate encoded packets. The encoded packets are then buffered at a buffer unit (313) for transmission to an output port via a transmission unit (TX) (312). Outgoing packets (330) may include both encoded packets and unencoded packets.

The received packets may be sent directly from the receiver unit to the encoding unit or from the encoding unit to the transmission unit without buffering. Further, although not shown, mapping (i.e., switching or multicasting) of each outgoing packet to one or more output ports may be performed at the transmission unit (TX).

An example of a sensor node may be used to illustrate the architecture of fig. 3. In addition to their power supplies and sensors, the sensor nodes also contain a central controller unit, which is typically implemented using a microcontroller, although some sensor designs use a general purpose microprocessor, digital signal processor, FPGA or ASIC. The sensor nodes also communicate using radio, infrared, or optical transceivers. Their external memory is typically flash memory (i.e., electronic solid state non-volatile computer memory). Referring to fig. 3, the encoding unit (314) may be implemented at a controller unit of the sensor node. The local memory containing the parameters (315) and coefficients (316) may correspond to an on-chip microcontroller memory of the sensor node. The cache unit (313) may be part of an external memory of the node. The transceiver combines the functions of the transmitter (312) and receiver (311) units.

Examples of parameter reuse

Examples of parameter reuse are given in fig. 4 and 5. In fig. 4(400), node n1(410) generates encoded packets c1 and c2(430) from input packets p1, p2 and p3 (420). Node n1 uses α as a predetermined parameter, where α is a finite field F_qQ is the domain size. The parameter a is stored in a local memory (411) of the node.

To generate the coefficients (413), n1 may be passed through the function g listed below₁From F_qA sequence of numbers c (i) is generated.

g₁:c(i)＝iα[q]

Where i > -1 is the index and [ ] is the modulo operator.

In this disclosure, it is assumed that the function skips the zero coefficient. This can be done by automatically replacing zeros with fixed numbers (e.g., ones) in the coefficient calculations.

Fig. 5(500) shows a possible embodiment of the architecture. The parameter a is stored in the local memory (515) of the node. Incoming packets (520) arriving at a node from different input ports via receiver units (RX) (511) are buffered at a buffer unit (513) for encoding and retransmission. When encoding is required, a batch of encoded coefficients is generated from the stored parameters (515) and previous coefficients (516) using a function g 1. These coefficients are used at an encoding unit (514) to generate an encoded packet.

In a simple implementation, the node cycles through the finite field F by using the parameter α (515) as the first coefficient and creating a new coefficient by adding α to the previous coefficient_q. The coefficients generated are members of the set { α,2 α,3 α. Previously describedMay be stored in a coefficient module (516).

The encoded packets are then buffered at a buffer unit (513) for transmission to an output port via a transmission unit (TX) (512).

In the examples of fig. 4 and 5, the fixed parameter a is reused by the nodes to generate the coefficients.

Sample flow diagram

The flowchart (600) in fig. 6 shows a possible embodiment of the operations performed by the node.

Upon initialization of the node, the node reads (610) parameters from its memory to prepare for the encoding process. The node then waits for an incoming packet.

Each time a new packet is received, buffered (620) and (optionally) sent (630), a decision step (640) is triggered, wherein the node determines whether a new encoded packet is needed. If the encoded packet is not needed, the node returns to waiting for an incoming packet.

If an encoded packet is needed, the node reuses (650) the stored parameters and previous coefficients (if any) to generate the next coefficient. In other words, the first coefficient is a function of the parameter of the node. All subsequent coefficients may be a function of the previous coefficients as well as the node parameters (e.g., the sequence code of fig. 5).

The creation of one encoded packet typically requires more than one coefficient, since the creation of an encoded packet requires one coefficient for each original/local packet input to the encoding unit. For example, if a set of B buffered packets is selected for encoding, then B coefficients are required to create each encoded packet from the input set of packets.

Thus, the process of generating one or more coefficients (650) is repeated as long as new coefficients (660) are needed to create the encoded packet. Once a sufficient number of coefficients are generated, the encoded packet is created, buffered (670) and optionally transmitted (680). The node then returns to waiting for the incoming packet.

In alternative embodiments, the decision step (640) may be triggered by factors internal to the node other than packet arrival, such as timing constraints (e.g., periodic triggering of rules), estimation of packet loss on the network, or external factors such as protocol feedback (e.g., request for encoded packets, information about packet loss).

For example, the embodiments of fig. 3, 5 and 6 may be a fully software-based node implemented using a Field Programmable Gate Array (FPGA) or a soft radio. Alternatively, hardware-based node designs (e.g., implemented using a dedicated application-specific integrated circuit (ASIC)) or a combination of dedicated and programmable chips are also possible.

Other examples

A node may have more than one parameter. This is shown in fig. 7 (700). Node n1(710) generates encoded packets c1 and c2(730) from the input packets p1, p2 and p3 (720). Node n1 uses two parameters α and κ (712), where α and κ are finite fields F_qQ is the domain size. The parameters α and κ are stored in the local memory (711) of the node. To generate the coefficients, n1 may be passed through the function g listed below₂From F_qA sequence of numbers c (i) is generated.

g₂:C(1)＝α

C(i+1)＝{C(i)+κ}[q],

Where i > -1 is the index and [ ] is the modulo operator.

Thus, function g₂Cycling through the finite field by adding the constant k to the previous coefficient from alpha. The resulting coefficients are members of the set { α, α + κ, α +2 κ, α +3 κ. In other words, g₂:c(i)＝α+(i-1)k[q]，i>＝1。

Thus, the parameters (α, κ) are reused by the nodes to generate coefficients. Fig. 8 is a diagram illustrating an example where parameters and functions may differ at a network node. Fig. 8 shows a mesh network (800) in which four nodes n1(810), n2(820), n3(830) and n4(840) use different parameters. Although n1 and n4 are initialized using the parameter α (811,841), n2 and n3 are initialized using the parameter β (821,831).

The functions may also be different. In FIG. 8, n2 may use the function g₁Resulting in coefficients { β,2 β,3 β, … }, and n3 may use the function g₂And κ is 1, resulting in coefficients { β, β +1, β +2, … }.

Example of "economical" code

Single coefficient code: single-coefficient code is the simplest and parsimonious code to implement. It uses a single parameter a as the only coefficient for any encoding operation, as shown in fig. 4. Unlike fig. 5, however, for each new encoded packet to be created, it may assign a single coefficient α to all packets to be encoded. The applicability of this code may be limited due to the lack of diversity expected (i.e., the likelihood of linear correlation between encoded packets is high).

Coefficient set code: in this parsimonious code, the parameters are treated as predetermined coefficients, requiring no further computation. The function assigns coefficients selected directly from a parameter set (e.g., fig. 7, where a node has two parameters). For example, the function may allocate coefficients from a stored list of parameters in a round-robin fashion, select the next parameter as the coefficient for the next packet to be encoded, and return to the beginning of the list of parameters each time the list is traversed, but more coefficients are needed. Alternatively, the function may map the parameters based on the definition of the subset between packets to be encoded. For example, the function within a node with parameters α and κ (as shown in fig. 7) may classify packets to be encoded into two classes: the arriving packets and the previously buffered packets. The function may then use the coefficient α for incoming packets and the coefficient κ for buffered packets.

Sequence code: sequence codes use one or more parameters as input to a mathematical sequence (e.g., an arithmetic or geometric sequence). For example, a single parameter function may assign α (1, α) to the packet to be encoded²,α³Etc.) or multiples of alpha (1, alpha, 2 alpha, 3 alpha, etc.). (the latter sequence code is shown in fig. 5.) in the flow chart of fig. 6, a sequence code is given as an example of the parameter reuse step (650). Naturally, more than one parameter may be used to define the sequence (see, e.g., FIG. 7, above which function g is defined)₂)。

The code may borrow elements from sequence and coefficient set codes. For example, the function may use 1 for an incoming packet and compute the next element of the sequence as the coefficient for a cached packet (e.g., a packet located in the node's cache unit (313)).

The allocation of coefficients may be affected by coding complexity or node caching strategy. For example, a node may only cache (313) encoded packets because the encoded packets provide a more diverse representation of data than unencoded packets. In the re-encoding of an encoded packet (i.e., re-encoding of an encoded packet), a function may select coefficients for the encoded packet based on the number of uncoded packets (i.e., their densities) that are combined to create the encoded packet. The goal herein may be to reduce the encoding complexity (e.g., the number of field operations required for the encoding process). For example, dense packets are more likely to be assigned a coefficient of 1 than sparse packets or uncoded packets. Thus, nodes that cache (313) both encoded and unencoded packets may use different sets of coefficients when choosing packets from one class or the other, based on considerations such as complexity.

The compound function code: the most general description of parsimony codes is codes that employ pre-programmed functions and a limited number of pre-programmed parameters (713) to generate coefficients (714) for linear encoding, where the function definition may vary with the generation of each coefficient. For each encoded packet to be created, the function generates a coefficient for each packet to be encoded based on the parameters. In complex function code, the function itself may be reused as a sequence element. Furthermore, it may be defined by different parameters or operations for each generated coefficient. The following example illustrates a complex function.

Function reuse: the node (210) may reuse its functions (i.e., use a combination of its functions) by a combination of functions to generate the coefficients (213). For example, a univariate code with a parameter α (see, e.g., fig. 4) and a function g may be in the sequence (g (α), g)²(α),g³(. alpha.) or to increase the diversity (1, g (. alpha.), g.)²(α),g³A.generating coefficient (413), wherein g²(α)＝g(g(α))。

A number of parameters: a node may alternate between a set of parameters,while moving to higher order combinations of functions. For example, a node with a function g and a parameter set { α, κ } (see, e.g., fig. 7) may use a coefficient sequence (1, g (α), g (κ), g)²(α),g²(κ),g³(α),g³(κ),..) as its coefficient (713).

A plurality of functions: the node function may be defined by a combination of a plurality of sub-functions. For example, a univariate code with parameter α (see, e.g., fig. 4) may be in the sequence (1, g (α), g' (α), g [ ]²(α),g’²(α),g³(α),g’³(α), generating coefficients (413), wherein g and g' are different sub-functions. The node function may also be defined by alternating between a plurality of sub-function combinations. For example, a univariate code with parameter α (see, e.g., fig. 4) may generate coefficients (413) in the sequence (1, g (α), g '(g (α)), g (g' (g (α))),. The code may combine elements of two or more of the above methods.

Example of parsimonious code in a multihop network

A multi-hop network is a network in which a data unit needs to traverse more than one hop from a source to a destination. A wire, or daisy chain, network is commonly used to illustrate multi-hop performance. Fig. 9 shows a line network (900) formed by three nodes: a source node n1(910), an intermediate node n2(920), and a destination node n3 (930). The same parameter α ═ 3 is programmed into the memories n1(911), n2(921) and n3(931), where the field F is used₃₂(i.e., q is 32).

When performing linear coding, all nodes select the coefficients c (i) using the following function:

g₃:C(1)＝1

C(i+1)＝{C(i)+α}[q],

where i > -1 is the index and [ ] is the modulo operator.

Code: the function is thus looped in a loop manner in a finite field according to the sequence {1, α,2 α,3 α, }, where α ═ 3. The sequence is not interrupted for each new encoded packet.

Scenario and transmission strategy: 3 packet blocks containing packets (p1, p2, p3) will be transmitted from n1 to n 3. On each link, two fifths of the packets are lost due to fluctuations in channel quality. In order to protect the transmitted packets, redundant packets (code rate 3/5) are inserted after the second transmitted packet and the third transmitted packet.

Fig. 10 shows the sequence of the unencoded and encoded packets transmitted by nodes n1(912) and n2 (922).

The node n1 generates packets c1 and c2 from the input packets p1, p2 and p3, and transmits the five packets according to the above-described transmission policy (912). Packets p2 and c1 are then lost (912).

Node n2 receives packets p1, p3, and c2 (912). It uses these three incoming packets to generate and transmit two additional encoded packets, c3 and c4, according to the same transmission strategy. Thus, node n2 sends a sequence of packets { p1, p3, c3, c2, c4} (912). Subsequently, packets p1 and c2 are lost (922). Node n3 receives three of the five packets transmitted by n2 (922).

The coefficients of all encoded packets in the scenario of fig. 9 are shown in fig. 10, where any packet is represented by a triplet in F32[ a, b, c ] representing the linear combination L ═ ap1+ bp2+ cp 3. The three packets received at the destination are (p3, c3, c4) — ([0,0,1], [1,0,3], [30,12,1]), and these three independent combinations enable decoding of the three original packets. This means that frugal code can successfully generate linear independency in-stream communications.

Increasing code diversity and robustness

Various methods may be applied to increase code diversity (i.e., reduce the likelihood of receiving linearly related packets at the receiver). Here are some examples:

and (3) fractional: the packets to be encoded are divided into two subsets: the fixed fraction f of packets uses the alpha parameter as a coefficient, while the remaining 1-f use 1. This is the method described by Lee, but is applied to inter-stream settings. In the context of the present application, the score f will be part of the function definition. Determining whether to assign a coefficient alpha or 1 to a packet may be performed using a non-probabilistic method (e.g., assigning coefficients based on a permanent update of a floating score).

Score and function: the fixed fraction f of packets to be encoded is assigned g (α) and the remaining 1-f are assigned g' (α).

Node function: a single parameter/coefficient and multiple functions are propagated/programmed. Each node or group of nodes applies a different function to the coefficients. This is mentioned in the discussion of fig. 8. Other node characteristics (e.g., network address) may also be used as additional parameters to contribute diversity to the generated coefficients.

The above examples are provided to enable those of ordinary skill in the art to make and use the full disclosure and description of how the examples of the present disclosure are made and used, and are not intended to limit the scope of what the inventors regard as their disclosure.

Modifications of the above-described modes for carrying out the methods and systems disclosed herein that are obvious to those skilled in the art are intended to be within the scope of the following claims. All patents and publications mentioned in the specification are indicative of the levels of skill of those skilled in the art to which the disclosure pertains. All references cited in this disclosure are incorporated by reference to the same extent as if each reference were individually incorporated by reference.

It is to be understood that this disclosure is not limited to a particular method or system, which can, of course, vary. It is also to be understood that the terminology used herein is for the purpose of describing particular embodiments only, and is not intended to be limiting. As used in this specification and the appended claims, the singular forms "a", "an", and "the" include plural referents unless the content clearly dictates otherwise. The term "plurality" includes two or more of the referenced item unless the content clearly dictates otherwise. Unless defined otherwise, all technical and scientific terms used herein have the same meaning as commonly understood by one of ordinary skill in the art to which this disclosure belongs.