P
US7665116B2ExpiredUtilityPatentIndex 60

Network architecture for real time delivery of video over lossy networks from remote locations

Assignee: ARRIS GROUP INCPriority: Oct 27, 2004Filed: Oct 27, 2005Granted: Feb 16, 2010
Est. expiryOct 27, 2024(expired)· nominal 20-yr term from priority
Inventors:HARTUNG JOHNKRISHNAMACHARI SANTHANABAI JUNFENG
H04L 45/22H04L 65/612H04L 43/087H04L 45/3065H04N 21/64792H04N 21/6118H04L 45/28H04L 43/106H04L 47/2441H04L 47/125H04N 21/64738H04N 21/4384H04J 3/0632H04N 7/17309H04N 21/4305H04N 21/44209H04L 65/80H04L 45/125H04N 21/6125H04L 47/2416H04L 45/70H04N 21/64707
60
PatentIndex Score
6
Cited by
21
References
18
Claims

Abstract

A method for content delivery comprising transmitting content via a first network to a content aggregation point and transmitting the content from the content aggregation point via a second network to a receiver at the request of the receiver. A system for content delivery comprising a content provider, a content aggregation point operatively coupled to the content provider via a first network wherein the content aggregation point receives content from the content provider, and a receiver operatively coupled to the content aggregation point via a second network wherein the receiver is configured to request content from the content aggregation point. Also disclosed are methods for improving the network functionality through in-band measurement of network statistics, multi-constraint based QoS routing, and back up path determination.

Claims

exact text as granted — not AI-modified
1. A method for multi-constraints based QoS routing for content distribution over a network comprising:
 filtering a network topology with a first set of QoS constraints resulting in a filtered network topology; 
 determining a least cost path that satisfies a second set of QoS constraints by performing Dijkstra's least cost path routing algorithm, wherein at each searching step in Dijkstra's least cost path routing algorithm, checking 
 
       
         
           
             
               
                 
                   if 
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   
                     ( 
                     
                       
                         
                           ∑ 
                           
                             ( 
                             
                               
                                 ( 
                                 
                                   u 
                                   , 
                                   v 
                                 
                                 ) 
                               
                               ∈ 
                               P 
                             
                             ) 
                           
                         
                         ⁢ 
                         
                           
                             W 
                             i 
                           
                           ⁡ 
                           
                             ( 
                             
                               u 
                               , 
                               v 
                             
                             ) 
                           
                         
                       
                       < 
                       
                         L 
                         i 
                       
                     
                     ) 
                   
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   for 
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   each 
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   i 
                 
                 = 
                 
                   1 
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   … 
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   m 
                 
               
               , 
             
           
         
          wherein L i  is the total end-to-end cost constraint that needs to be satisfied, over the filtered network topology, and using PATH_LOAD, (P)=MAX (u,v)εP (Link_load (u,v)), as a cost index to find the least-cost path; and 
         balancing a network load according to the least cost path. 
       
     
     
       2. The method of  claim 1  wherein the first set of QoS constraints are min(max) QoS constraints. 
     
     
       3. The method of  claim 1  wherein the second set of QoS constraints are additive QoS constraints. 
     
     
       4. The method of  claim 1  wherein PATH_LOAD is updated with 
       
         
           
             
               Cost_Index 
               = 
               
                 { 
                 
                   
                     
                       
                         max 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         
                           ( 
                           
                             Old_Index 
                             , 
                             Link_Load 
                           
                           ) 
                         
                       
                     
                     
                       
                         
                           
                             if 
                             ⁢ 
                             
                               
                                   
                               
                               ⁢ 
                               
                                   
                               
                             
                             ( 
                             
                               
                                 
                                   ∑ 
                                   
                                     ( 
                                     
                                       
                                         ( 
                                         
                                           u 
                                           , 
                                           v 
                                         
                                         ) 
                                       
                                       ∈ 
                                       P 
                                     
                                     ) 
                                   
                                 
                                 ⁢ 
                                 
                                   
                                     W 
                                     i 
                                   
                                   ⁡ 
                                   
                                     ( 
                                     
                                       u 
                                       , 
                                       v 
                                     
                                     ) 
                                   
                                 
                               
                               < 
                               
                                 L 
                                 i 
                               
                             
                             ) 
                           
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           for 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           each 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           i 
                         
                         = 
                         
                           1 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           … 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           m 
                         
                       
                     
                   
                   
                     
                       ∞ 
                     
                     
                       
                         
                           
                             if 
                             ⁢ 
                             
                               
                                   
                               
                               ⁢ 
                               
                                   
                               
                             
                             ( 
                             
                               
                                 
                                   ∑ 
                                   
                                     ( 
                                     
                                       
                                         ( 
                                         
                                           u 
                                           , 
                                           v 
                                         
                                         ) 
                                       
                                       ∈ 
                                       P 
                                     
                                     ) 
                                   
                                 
                                 ⁢ 
                                 
                                   
                                     W 
                                     i 
                                   
                                   ⁡ 
                                   
                                     ( 
                                     
                                       u 
                                       , 
                                       v 
                                     
                                     ) 
                                   
                                 
                               
                               < 
                               
                                 L 
                                 i 
                               
                             
                             ) 
                           
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           for 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           any 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           i 
                         
                         = 
                         
                           1 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           … 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           m 
                         
                       
                     
                   
                 
               
             
           
         
         at each searching step in Dijkstra's algorithm. 
       
     
     
       5. The method of  claim 1 , wherein the network load comprises video applications. 
     
     
       6. The method of  claim 5 , wherein the least cost path has residual resource that satisfies the set of QoS constraints and is used to tolerate dynamic change in a network. 
     
     
       7. A network apparatus for multi-constraints based QoS routing for content distribution over a network comprising:
 a router, coupled to a network, wherein the router is configured for
 filtering a network topology with a first set of QoS constraints resulting in a filtered network topology; 
 determining a least cost path that satisfies a second set of QoS constraints by performing Dijkstra's least cost path routing algorithm, wherein at each searching step in Dijkstra's least cost path routing algorithm, checking if 
 
 
       
         
           
             
               
                 
                   if 
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   
                     ( 
                     
                       
                         
                           ∑ 
                           
                             ( 
                             
                               
                                 ( 
                                 
                                   u 
                                   , 
                                   v 
                                 
                                 ) 
                               
                               ∈ 
                               P 
                             
                             ) 
                           
                         
                         ⁢ 
                         
                           
                             W 
                             i 
                           
                           ⁡ 
                           
                             ( 
                             
                               u 
                               , 
                               v 
                             
                             ) 
                           
                         
                       
                       < 
                       
                         L 
                         i 
                       
                     
                     ) 
                   
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   for 
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   each 
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   i 
                 
                 = 
                 
                   1 
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   … 
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   m 
                 
               
               , 
             
           
         
          wherein L i  is the total end-to-end cost constraint that needs to be satisfied, over the filtered network topology, and using PATH_LOAD, (P)=MAX (u,v)εP (Link_load(u,v)), as a cost index to find the least-cost path; and
 balancing a network load according to the least cost path. 
 
       
     
     
       8. The network apparatus of  claim 7 , wherein the first set of QoS constraints are min(max) QoS constraints. 
     
     
       9. The network apparatus of  claim 7 , wherein the second set of QoS constraints are additive QoS constraints. 
     
     
       10. The network apparatus of  claim 7 , wherein PATH_LOAD is updated with 
       
         
           
             
               Cost_Index 
               = 
               
                 { 
                 
                   
                     
                       
                         max 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         
                           ( 
                           
                             Old_Index 
                             , 
                             Link_Load 
                           
                           ) 
                         
                       
                     
                     
                       
                         
                           
                             if 
                             ⁢ 
                             
                               
                                   
                               
                               ⁢ 
                               
                                   
                               
                             
                             ( 
                             
                               
                                 
                                   ∑ 
                                   
                                     ( 
                                     
                                       
                                         ( 
                                         
                                           u 
                                           , 
                                           v 
                                         
                                         ) 
                                       
                                       ∈ 
                                       P 
                                     
                                     ) 
                                   
                                 
                                 ⁢ 
                                 
                                   
                                     W 
                                     i 
                                   
                                   ⁡ 
                                   
                                     ( 
                                     
                                       u 
                                       , 
                                       v 
                                     
                                     ) 
                                   
                                 
                               
                               < 
                               
                                 L 
                                 i 
                               
                             
                             ) 
                           
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           for 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           each 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           i 
                         
                         = 
                         
                           1 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           … 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           m 
                         
                       
                     
                   
                   
                     
                       ∞ 
                     
                     
                       
                         
                           
                             if 
                             ⁢ 
                             
                               
                                   
                               
                               ⁢ 
                               
                                   
                               
                             
                             ( 
                             
                               
                                 
                                   ∑ 
                                   
                                     ( 
                                     
                                       
                                         ( 
                                         
                                           u 
                                           , 
                                           v 
                                         
                                         ) 
                                       
                                       ∈ 
                                       P 
                                     
                                     ) 
                                   
                                 
                                 ⁢ 
                                 
                                   
                                     W 
                                     i 
                                   
                                   ⁡ 
                                   
                                     ( 
                                     
                                       u 
                                       , 
                                       v 
                                     
                                     ) 
                                   
                                 
                               
                               < 
                               
                                 L 
                                 i 
                               
                             
                             ) 
                           
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           for 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           any 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           i 
                         
                         = 
                         
                           1 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           … 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           m 
                         
                       
                     
                   
                 
               
             
           
         
         at each searching step in Dijkstra's algorithm. 
       
     
     
       11. The network apparatus of  claim 7 , wherein the network load comprises video applications. 
     
     
       12. The network apparatus of  claim 11 , wherein the least cost path has residual resource that satisfies the set of QoS constraints and is used to tolerate dynamic change in a network. 
     
     
       13. A computer readable storage medium having computer executable instructions embodied thereon for multi-constraints based QoS routing for content distribution over a network comprising:
 filtering a network topology with a first set of QoS constraints resulting in a filtered network topology; 
 determining a least cost path that satisfies a second set of QoS constraints by performing Dijkstra's least cost path routing algorithm, wherein at each searching step in Dijkstra's least cost path routing algorithm, checking 
 
       
         
           
             
               
                 
                   if 
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   
                     ( 
                     
                       
                         
                           ∑ 
                           
                             ( 
                             
                               
                                 ( 
                                 
                                   u 
                                   , 
                                   v 
                                 
                                 ) 
                               
                               ∈ 
                               P 
                             
                             ) 
                           
                         
                         ⁢ 
                         
                           
                             W 
                             i 
                           
                           ⁡ 
                           
                             ( 
                             
                               u 
                               , 
                               v 
                             
                             ) 
                           
                         
                       
                       < 
                       
                         L 
                         i 
                       
                     
                     ) 
                   
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   for 
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   each 
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   i 
                 
                 = 
                 
                   1 
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   … 
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   m 
                 
               
               , 
             
           
         
          wherein L i  is the total end-to-end cost constraint that needs to be satisfied, over the filtered network topology, and using PATH_LOAD, (P)=MAX (u,v)εP (Link_load(u,v)), as a cost index to find the least-cost path; and 
         balancing a network load according to the least cost path. 
       
     
     
       14. The computer readable storage medium of  claim 13 , wherein the first set of QoS constraints are min(max) QoS constraints. 
     
     
       15. The computer readable storage medium of  claim 13 , wherein the second set of QoS constraints are additive QoS constraints. 
     
     
       16. The computer readable storage medium of  claim 13 , wherein PATH_LOAD is updated with 
       
         
           
             
               Cost_Index 
               = 
               
                 { 
                 
                   
                     
                       
                         max 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         
                           ( 
                           
                             Old_Index 
                             , 
                             Link_Load 
                           
                           ) 
                         
                       
                     
                     
                       
                         
                           
                             if 
                             ⁢ 
                             
                               
                                   
                               
                               ⁢ 
                               
                                   
                               
                             
                             ( 
                             
                               
                                 
                                   ∑ 
                                   
                                     ( 
                                     
                                       
                                         ( 
                                         
                                           u 
                                           , 
                                           v 
                                         
                                         ) 
                                       
                                       ∈ 
                                       P 
                                     
                                     ) 
                                   
                                 
                                 ⁢ 
                                 
                                   
                                     W 
                                     i 
                                   
                                   ⁡ 
                                   
                                     ( 
                                     
                                       u 
                                       , 
                                       v 
                                     
                                     ) 
                                   
                                 
                               
                               < 
                               
                                 L 
                                 i 
                               
                             
                             ) 
                           
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           for 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           each 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           i 
                         
                         = 
                         
                           1 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           … 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           m 
                         
                       
                     
                   
                   
                     
                       ∞ 
                     
                     
                       
                         
                           
                             if 
                             ⁢ 
                             
                               
                                   
                               
                               ⁢ 
                               
                                   
                               
                             
                             ( 
                             
                               
                                 
                                   ∑ 
                                   
                                     ( 
                                     
                                       
                                         ( 
                                         
                                           u 
                                           , 
                                           v 
                                         
                                         ) 
                                       
                                       ∈ 
                                       P 
                                     
                                     ) 
                                   
                                 
                                 ⁢ 
                                 
                                   
                                     W 
                                     i 
                                   
                                   ⁡ 
                                   
                                     ( 
                                     
                                       u 
                                       , 
                                       v 
                                     
                                     ) 
                                   
                                 
                               
                               < 
                               
                                 L 
                                 i 
                               
                             
                             ) 
                           
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           for 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           any 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           i 
                         
                         = 
                         
                           1 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           … 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           m 
                         
                       
                     
                   
                 
               
             
           
         
         at each searching step in Dijkstra's algorithm. 
       
     
     
       17. The computer readable storage medium of  claim 13 , wherein the network load comprises video applications. 
     
     
       18. The computer readable storage medium of  claim 17 , wherein the least cost path has residual resource that satisfies the set of QoS constraints and is used to tolerate dynamic change in a network.

Cited by (0)

No later patents cite this yet.

References (0)

No backward citations on record.