Docstoc

FRM-SIGCOMM06

Document Sample
FRM-SIGCOMM06 Powered By Docstoc
					Free Riding Multicast

   Sylvia Ratnasamy (Intel Research)
   Andrey Ermolinskiy (U.C. Berkeley)
   Scott Shenker      (U.C. Berkeley and ICSI)

   ACM SIGCOMM 2006
IP Multicast
   Extensively researched, limited deployment
       Some intra-domain/enterprise usage
       Virtually no inter-domain deployment


   Why?
       Poor match with underlying economics?
       Too complex?
           PIM-SM, PIM-DM, MBGP, MSDP, BGMP, IGMP, etc.


   FRM goal: make inter-domain multicast simple
FRM Overview
   Free Riding Multicast: radical restructuring of inter-
    domain multicast

   Key design choice: decouple group membership
    discovery from multicast route construction

   Principal trade-off: avoidance of distributed route
    computation at the expense of optimal efficiency
Talk Outline

   Free Riding Multicast (FRM)
     Approach overview
     Overhead evaluation

     Design tradeoffs

     Implementation
FRM Approach
 Group membership discovery
    Extension to BGP - augment route advertisements with
     group membership information
FRM Approach
       Group membership discovery
        Extension to BGP - augment route advertisements with
         group membership information


 Multicast route construction
        Centralized computation at the origin border router
        Exploit knowledge of unicast BGP routes
        Eliminate the need for a separate routing algorithm
 Group Membership Discovery
 Augment BGP with per-prefix          AS X              AS Y
  group membership                    a.b.*.*            c.d.e.*
  information
                                                 AS P
                            AS T                                   AS Z
                            h.i.*.*                                f.g.*.*
                                          AS Q          AS R



                                                 AS V
 Group Membership Discovery
 Augment BGP with per-prefix          AS X              AS Y
  group membership                    a.b.*.*            c.d.e.*
  information
                                                 AS P
                            AS T                                   AS Z
 Domain X joins G1         h.i.*.*                                f.g.*.*
                                          AS Q          AS R



                                                 AS V
 Group Membership Discovery
                                              a.b*.*   {G1}
 Augment BGP with per-prefix              AS X                AS Y
  group membership                        a.b.*.*              c.d.e.*
  information
                                                       AS P
                                AS T                                     AS Z
 Domain X joins G1             h.i.*.*                                  f.g.*.*
                                              AS Q            AS R

 Border router at X re-advertises
  its prefix, attaches encoding of
  active groups                                        AS V
                 BGP UPDATE

  Dest     AS Path   FRM group membership
 a.b.*.*     X             {G1 }
 Group Membership Discovery
                                             a.b*.*   {G1}
 BGP disseminates                        AS X                AS Y
  membership change
                                         a.b.*.*              c.d.e.*
 Border routers maintain
  membership info. as                                 AS P
  part of per-prefix state     AS T                                     AS Z
  in BGP RIB                   h.i.*.*                                  f.g.*.*
                                             AS Q            AS R


Prefix      AS Path          Active Groups
                                                      AS V
a.b.*.*   V Q P  X
c.d.e.*   V Q P Y
f.g.*.*    V R  Z
h.i.*.*    V Q  T
 Group Membership Discovery
                                             a.b*.*   {G1}
 BGP disseminates                        AS X                AS Y
  membership change
                                         a.b.*.*              c.d.e.*
 Border routers maintain
  membership info. as                                 AS P
  part of per-prefix state     AS T                                     AS Z
  in BGP RIB                   h.i.*.*                                  f.g.*.*
                                             AS Q            AS R


Prefix      AS Path          Active Groups
                                                      AS V
a.b.*.*   V Q P  X
c.d.e.*   V Q P Y
f.g.*.*    V R  Z
h.i.*.*    V Q  T
 Group Membership Discovery
 BGP disseminates                        AS X                       AS Y
  membership change
                                         a.b.*.*                     c.d.e.*
 Border routers maintain
  membership info. as                            a.b*.*   AS{P 1}
                                                             G

  part of per-prefix state     AS T                                            AS Z
  in BGP RIB                   h.i.*.*                                         f.g.*.*
                                             AS Q                   AS R


Prefix      AS Path          Active Groups
                                                          AS V
a.b.*.*   V Q P  X
c.d.e.*   V Q P Y
f.g.*.*    V R  Z
h.i.*.*    V Q  T
 Group Membership Discovery
 BGP disseminates                        AS X               a.b*.* AS{G1}
                                                                       Y
  membership change
                                         a.b.*.*                    c.d.e.*
 Border routers maintain
  membership info. as                            a.b*.*   AS{P 1}
                                                             G

  part of per-prefix state     AS T                                               AS Z
  in BGP RIB                   h.i.*.*                                            f.g.*.*
                                      a.b*.*     {Q
                                               AS G1}             AS
                                                                 a.b*.*R   {G1}


Prefix      AS Path          Active Groups
                                                          AS V
a.b.*.*   V Q P  X
c.d.e.*   V Q P Y
f.g.*.*    V R  Z
h.i.*.*    V Q  T
 Group Membership Discovery
 BGP disseminates                        AS X                       AS Y
  membership change
                                         a.b.*.*                     c.d.e.*
 Border routers maintain
  membership info. as                                  AS P
  part of per-prefix state     AS T                                            AS Z
  in BGP RIB                   h.i.*.*                                         f.g.*.*
                                             AS Q               AS R


Prefix      AS Path          Active Groups
                                                   a.b*.* AS V G1}
                                                              {
a.b.*.*   V Q P  X            {G1}
c.d.e.*   V Q P Y
f.g.*.*    V R  Z
h.i.*.*    V Q  T
 Group Membership Discovery
 Domains Y and Z join G1                AS X              AS Y
                                        a.b.*.*            c.d.e.*

                                                   AS P
                              AS T                                   AS Z
                              h.i.*.*                                f.g.*.*
                                            AS Q          AS R


Prefix      AS Path         Active Groups
                                                   AS V
a.b.*.*   V Q P  X           {G1}
c.d.e.*   V Q P Y
f.g.*.*    V R  Z
h.i.*.*    V Q  T
 Group Membership Discovery
 Domains Y and Z join G1                AS X                  {
                                                            AS YG1}
                                                      c.d.e.*
                                        a.b.*.*            c.d.e.*

                                                   AS P
                              AS T                               f.g.*.* AS {G1}
                                                                            Z
                              h.i.*.*                                  f.g.*.*
                                            AS Q          AS R


Prefix      AS Path         Active Groups
                                                   AS V
a.b.*.*   V Q P  X           {G1}
c.d.e.*   V Q P Y
f.g.*.*    V R  Z
h.i.*.*    V Q  T
 Group Membership Discovery
 Domains Y and Z join G1                AS X                  {
                                                            AS YG1}
                                                      c.d.e.*
                                        a.b.*.*            c.d.e.*

                                                   AS P
                              AS T                               f.g.*.* AS {G1}
                                                                            Z
                              h.i.*.*                                  f.g.*.*
                                            AS Q          AS R


Prefix      AS Path         Active Groups
                                                   AS V
a.b.*.*   V Q P  X           {G1}
c.d.e.*   V Q P Y            {G1}
f.g.*.*    V R  Z             {G1}
h.i.*.*    V Q  T
Packet Forwarding
                         AS X              AS Y
                        a.b.*.*            c.d.e.*

                                   AS P
              AS T                                   AS Z
              h.i.*.*                                f.g.*.*
                            AS Q          AS R



                                   AS V

                                           Domain V:
                                           Send(G1, Pkt)
 Packet Forwarding
Dissemination tree                      AS X              AS Y
                                       a.b.*.*            c.d.e.*

                                                  AS P
                             AS T                                   AS Z
                             h.i.*.*                                f.g.*.*
                                           AS Q          AS R
             {G1 }
                        Lookup

  Prefix      AS Path       Active Groups         AS V
  a.b.*.*   V Q P  X          {G1}                     Domain V:
  c.d.e.*   V Q P Y           {G1}                     Send(G1, Pkt)
  f.g.*.*    V R  Z            {G1}
  h.i.*.*    V Q  T
 Packet Forwarding
Dissemination tree                          AS X              AS Y

            V                              a.b.*.*            c.d.e.*

     Q                                                AS P
                                 AS T                                   AS Z
     P                           h.i.*.*                                f.g.*.*
                                               AS Q          AS R
 X               {G1 }
                            Lookup

  Prefix          AS Path       Active Groups         AS V
  a.b.*.*       V Q P  X          {G1}                     Domain V:
  c.d.e.*       V Q P Y           {G1}                     Send(G1, Pkt)
  f.g.*.*        V R  Z            {G1}
  h.i.*.*        V Q  T
 Packet Forwarding
Dissemination tree                           AS X              AS Y

             V                              a.b.*.*            c.d.e.*

     Q                                                 AS P
                                  AS T                                   AS Z
     P                            h.i.*.*                                f.g.*.*
                                                AS Q          AS R
 X       Y        {G1 }
                             Lookup

  Prefix           AS Path       Active Groups         AS V
  a.b.*.*        V Q P  X          {G1}                     Domain V:
  c.d.e.*        V Q P Y           {G1}                     Send(G1, Pkt)
  f.g.*.*         V R  Z            {G1}
  h.i.*.*         V Q  T
 Packet Forwarding
Dissemination tree                              AS X              AS Y

             V                                 a.b.*.*            c.d.e.*

     Q           R                                        AS P
                                     AS T                                   AS Z
     P           Z                   h.i.*.*                                f.g.*.*
                                                   AS Q          AS R
 X       Y        {G1 }
                                Lookup

  Prefix             AS Path        Active Groups         AS V
  a.b.*.*        V Q P  X             {G1}                     Domain V:
  c.d.e.*        V Q P Y              {G1}                     Send(G1, Pkt)
  f.g.*.*            V R  Z            {G1}
  h.i.*.*            V Q  T
 Packet Forwarding
Dissemination tree                              AS X              AS Y

             V                                 a.b.*.*            c.d.e.*

     Q           R                                        AS P
                                     AS T                                   AS Z
     P           Z                   h.i.*.*                                f.g.*.*
                                                   AS Q          AS R
 X       Y        {G1 }
                                Lookup

  Prefix             AS Path        Active Groups         AS V
  a.b.*.*        V Q P  X             {G1}                     Domain V:
  c.d.e.*        V Q P Y              {G1}                     Send(G1, Pkt)
  f.g.*.*            V R  Z            {G1}
  h.i.*.*            V Q  T
    Packet Forwarding
                                           AS X                    AS Y

                V                         a.b.*.*                  c.d.e.*

        Q           R                                   AS P
                                AS T                                         AS Z
        P           Z           h.i.*.*                                      f.g.*.*
                                              AS Q                AS R
    X       Y


                                                    G1 SubtreeQ
        SubtreeQ         SubtreeR                        AS V
                                                    G1 SubtreeR

                                                                   Domain V:
   V forwards packet to its children on                           Send(G1, Pkt)
    the tree, attaches encoding the
    subtree in a “shim” header
    Packet Forwarding
                                           AS X                    AS Y

                V                         a.b.*.*                  c.d.e.*

        Q           R                                   AS P
                                AS T                                         AS Z
        P           Z           h.i.*.*                                      f.g.*.*
                                              AS Q                AS R
    X       Y


                                                    G1 SubtreeQ
                                                         AS V
                                                    G1 SubtreeR

                                                                   Domain V:
   V forwards packet to its children on                           Send(G1, Pkt)
    the tree, attaches encoding the
    subtree in a “shim” header
Packet Forwarding
                                               AS X                AS Y

                 V                            a.b.*.*              c.d.e.*

        Q            R                                   AS P
                                    AS T                                      AS Z
         P           Z              h.i.*.*                                   f.g.*.*
                                                  AS Q           AS R
    X        Y                             G1 SubtreeQ          G1 SubtreeR



                                                         AS V
       Transit routers inspect FRM header,
        forward packet to their children on the                     Domain V:
        tree                                                        Send(G1, Pkt)
Packet Forwarding
                                               AS X                AS Y

                 V                          a.b.*.*                c.d.e.*

        Q            R                                   AS P
                                    AS T                                      AS Z
         P           Z              h.i.*.*
                                          No
                                                                              f.g.*.*
                                                  AS Q           AS R
    X        Y                             G1 SubtreeQ          G1 SubtreeR



                                                         AS V
       Transit routers inspect FRM header,
        forward packet to their children on the                     Domain V:
        tree                                                        Send(G1, Pkt)
Packet Forwarding
                                               AS X                  AS Y

                 V                            a.b.*.*                c.d.e.*

        Q            R                                     AS P
                                    AS T                                        AS Z
         P           Z              h.i.*.*                                     f.g.*.*
                                                  AS Q             AS R
    X        Y                             G1 SubtreeQ            G1 SubtreeR

                                                      No
                                                           AS V
       Transit routers inspect FRM header,
        forward packet to their children on the                       Domain V:
        tree                                                          Send(G1, Pkt)
Packet Forwarding
                                               AS X                AS Y

                 V                            a.b.*.*              c.d.e.*

        Q            R                                   AS P
                                    AS T           Yes                        AS Z
         P           Z              h.i.*.*                                   f.g.*.*
                                                  AS Q           AS R
    X        Y                             G1 SubtreeQ          G1 SubtreeR



                                                         AS V
       Transit routers inspect FRM header,
        forward packet to their children on the                     Domain V:
        tree                                                        Send(G1, Pkt)
Packet Forwarding
                                               AS X                  AS Y

                 V                            a.b.*.*                c.d.e.*
                                                          1 SubtreeQ
                                                         G1 TREE_BFQ
        Q            R                                    AS P
                                    AS T                                        AS Z
         P           Z              h.i.*.*                                     f.g.*.*
                                                  AS Q             AS R
    X        Y                                                    G1 SubtreeR



                                                           AS V
       Transit routers inspect FRM header,
        forward packet to their children on the                        Domain V:
        tree                                                           Send(G1, Pkt)
Packet Forwarding
                                               AS X                AS Y

                 V                            a.b.*.*              c.d.e.*

        Q            R                                   AS P
                                    AS T                                      AS Z
         P           Z              h.i.*.*                                   f.g.*.*
                                                  AS Q           AS R
    X        Y                                                  G1 SubtreeR



                                                         AS V
       Transit routers inspect FRM header,
        forward packet to their children on the                     Domain V:
        tree                                                        Send(G1, Pkt)
Packet Forwarding
                                               AS X                AS Y

                 V                            a.b.*.*              c.d.e.*

        Q            R                                   AS P
                                    AS T                                      AS Z
         P           Z              h.i.*.*                                   f.g.*.*
                                                  AS Q           AS R
    X        Y                                                  G1 SubtreeR



                                                         AS V
       Transit routers inspect FRM header,
        forward packet to their children on the                     Domain V:
        tree                                                        Send(G1, Pkt)
    FRM Details
   Encoding group membership
       Border routers encode locally active groups using a Bloom
        filter
       Transmit encoding using a new path attribute in BGP
        UPDATE message


   Encoding the dissemination tree
       Encode edges into a shim header using a Bloom filter


   Tree computation is expensive  Border routers maintain
    shim header cache
Talk Outline

   Free Riding Multicast (FRM)
     Approach overview
     Overhead evaluation
           Router storage requirements
           Forwarding bandwidth overhead (in paper)
       Design tradeoffs
       Implementation
FRM Overhead – Router Storage
                                            AS X              AS Y
                                           a.b.*.*            c.d.e.*

                                                      AS P
Transit router                   AS T                                   AS Z
Transit forwarding state         h.i.*.*                                f.g.*.*
(per-neighbor, line card                       AS Q          AS R
memory)


Origin border router                                  AS V

 1. Source forwarding state
 (per-group, line card memory)
2. Group membership state
(per-prefix, BGP RIB)
FRM Overhead – Router Storage
                                            AS X              AS Y
                                           a.b.*.*            c.d.e.*

                                                      AS P
Transit router                   AS T                                   AS Z
Transit forwarding state         h.i.*.*                                f.g.*.*
(per-neighbor, line card                       AS Q          AS R
memory)


Origin border router                                  AS V

 1. Source forwarding state
 (per-group, line card memory)
2. Group membership state
(per-prefix, BGP RIB)
Forwarding State (Source Border Router)
                   900
                                                                         A -- number of groups with
                   800

                   700
                                                                          sources in the local domain
 Cache size (MB)




                   600

                   500
                                                                         Zipfian group popularity with
                   400
                                                                          a minimum of 8 domains per
                   300

                   200
                                                                          group
                   100

                     0
                           100     1000     10000    100000     1M
                                                                         25 groups have members in
                           Number of groups with active sources (A)
                                                                          every domain (global
                                                                          broadcast)


                         256 MB of line card memory enables fast-path forwarding
                                          for ~200000 active groups
FRM Overhead – Router Storage
                                            AS X              AS Y
                                           a.b.*.*            c.d.e.*

                                                      AS P
Transit router                   AS T                                   AS Z
Transit forwarding state         h.i.*.*                                f.g.*.*
(per-neighbor, line card                       AS Q          AS R
memory)


Origin border router                                  AS V

 1. Source forwarding state
 (per-group, line card memory)
2. Group membership state
(per-prefix, BGP RIB)
Group Membership State Requirements
    Total of A multicast
     groups
    Domains of prefix
     length p have 232-p
     users
    Each user chooses
     and joins k distinct
     groups from A
    10 false positives
     per prefix allowed



    1M simultaneously active groups and 10 groups per user require
         ~3GB of route processor memory (not on the fast path)
FRM Overhead – Router Storage
                                            AS X              AS Y
                                           a.b.*.*            c.d.e.*

                                                      AS P
Transit router                   AS T                                   AS Z
Transit forwarding state         h.i.*.*                                f.g.*.*
(per-neighbor, line card                       AS Q          AS R
memory)


Origin border router                                  AS V

 1. Source forwarding state
 (per-group, line card memory)
2. Group membership state
(per-prefix, BGP RIB)
Forwarding State (Transit Router)
   Number of forwarding entries = number of
    neighbor ASes
       Independent of number of groups!                     AS P
                                           AS T   ?      ?

       90% of ASes:  10 forwarding entries          AS Q
       99% of ASes:  100 forwarding entries                ?
       Worst case: 2400 forwarding entries
                                                             AS V
Talk Outline

   Free Riding Multicast (FRM)
     Approach overview
     Overhead evaluation

     Design tradeoffs
     Implementation
FRM Design Tradeoffs
   Protocol simplicity
       Can be implemented as a straightforward extension to BGP
       Centralized route construction (tree is computed at source
        border router from existing unicast routes)
 FRM Design Tradeoffs
   Protocol simplicity
       Can be implemented as a straightforward extension to BGP
       Centralized route construction (tree is computed at source
        border router from existing unicast routes)

 Ease of configuration
     Avoid rendezvous point selection
FRM Design Tradeoffs
   Protocol simplicity
       Can be implemented as a straightforward extension to BGP
       Centralized route construction (tree is computed at source
        border router from existing unicast routes)

   Ease of configuration
       Avoid rendezvous point selection

 Enables ISP control over sources/subscribers
       To block traffic for an undesired group, drop it from BGP
        advertisement
       Source controls dissemination tree facilitates source-based
        charging [Express].
FRM Design Tradeoffs
FRM Design Tradeoffs
 Group membership state maintenance
     Membership information disseminated more widely
 FRM Design Tradeoffs
   Group membership state maintenance
       Membership information disseminated more widely


 Nontrivial bandwidth overhead (see paper for results)
       Per-packet shim header
       Redundant packet transmissions
FRM Design Tradeoffs
   Group membership state maintenance
       Membership information disseminated more widely


   Nontrivial bandwidth overhead (see paper for results)
       Per-packet shim header
       Redundant packet transmissions


 New packet forwarding techniques
       Full scan of the BGP RIB at source border router
       Bloom filter lookups at transit routers
FRM Implementation
   A proof-of-concept prototype on top of Linux 2.4 and
    the eXtensible Open Router Platform
    (http://www.xorp.org).

   Functional components:
       FRM kernel module (3.5 KLOC of new Linux kernel code)
           Interfaces with the Linux kernel IP layer and implements the
            packet forwarding plane
       FRM user-level component (1.9 KLOC of new code)
           Extension to the XORP BGP daemon
           Implements tree construction and group membership state
            dissemination
       Configuration and management tools (1.4 KLOC of new code)
Why IP Multicast?
   Technical feasibility aside, now might be a good time
    to revisit the desirability question
       Multicast applications now more widespread
           IP-TV, MMORPG, digital conferencing
       Better understanding of ISP requirements



   Bottom line: simple multicast design might open the
    door to more widespread adoption
Backup Slides
Encoding the Dissemination Tree
                       Bloom filter  possibility of false positives
            V
                       Fix FRM header length and target false
    Q           R
                        positive rate, compute number of edges
                        per header (E)
    P           Z

X       Y
                       Large trees (>E edges)
                           Decompose into k smaller subtrees
                           Encode each subtree individually
                           transmit k copies of the packet

    Large tree  Redundant packet transmissions
FRM Overhead – Redundant Transmissions
Total number of transmissions required to transfer a single packet to all
          group members (FRM header size = 100 bytes)
                                                                                           Ideal Mcast –
                                  45000
                                                                                            precisely 1 packet is
 Number of packet transmissions




                                  40000                                                     transmitted along
                                  35000                                                     each edge
                                  30000

                                  25000                                                    Per-AS Unicast –
                                  20000
                                                                                            source unicasts to
                                                                                            each members AS
                                  15000
                                                                                            individually
                                  10000

                                  5000
                                                                                           For all group sizes,
                                     0                                                      the overall bandwidth
                                            1000    10000     100000     1M      10M
                                                                                            consumed by FRM is
                                                            Group Size                      close to that of Ideal
                                                                                            Mcast (within 2.4%).
                                          Per-AS Unicast       FRM        Ideal Mcast
FRM Overhead – Redundant Transmissions
Number of transmissions per AS-level link required to transfer a single
   packet to all group members (FRM header size = 100 bytes)
                                        Per-AS Unicast with 10M users:
                                           • 6% of links see redundant
                                           transmissions.
                                           • Worst case: 6950
                                           transmissions per link.
                                        FRM with 10M users:
                                          • Less than 0.5% of links see
                                          redundant transmissions.
                                          • Worst case: 157
                                          transmissions per link
                                          • Worst case with optimization
                                          (see paper): 2 transmissions
                                          per link
    Encoding Group Membership State
   Simple enumeration is hard to scale.

   Border routers encode the set of locally active groups
    using a constant-size Bloom filter (GRP_BF) of length L.

    {G1, G2, G3, G4, …}               011011011010…
                          K hash
                          functions      GRP_BF

   BGP speakers communicate their GRP_BF state as
    part of their regular route advertisements (BGP
    UPDATE message) using a new path attribute.
Encoding Group Membership State
   Use of Bloom filters introduces possibility of false
    positives – a domain may on occasion receive traffic
    for a group it has no interest in.

   To deal with unwanted traffic, recipient domain can
    install an explicit filter rule at the upstream provider’s
    network.

   For a given number of available upstream filters f,
    the recipient computes the maximum tolerable false
    positive rate r and chooses its filter length L
    accordingly.
                                   A = size of the group address space
         r = Min(1, f / (A – G))   G = number of groups to be encoded
Summary
   Free Riding Multicast is a very different approach to
    inter-domain multicast routing

   FRM makes use of existing unicast routing
    infrastructure for group membership discovery and
    route construction

   Reduce protocol complexity via aggressive use of
    router resources


          Might be interesting to consider the viability of this
                     approach in broader context
Group Membership Bandwidth Overhead
   For GRP_BFs with 5 hash functions and bit
    positions represented by 24-bit values, the payload
    of a membership update message for a single group
    join/leave event is approx. 15 bytes.

 Assuming 200000 prefixes in the BGP RIB and
  1 group membership event per second per prefix,
  the aggregate rate of incoming GRP_BF update
  traffic at a border router is approx. 3MBps.
 Challenges and Future Work
   Incremental Deployment
       Legacy BGP routers rate-limit their path advertisements
        (30 seconds), thus delaying dissemination of group
        membership state.

       Large group Bloom filters that exceed maximum BGP
        UPDATE message size (4KB) require fragmentation and
        reassembly.


 Explore alternative tree encoding techniques to
  reduce per-packet bandwidth overhead
Summary
   Free Riding Multicast is a very different approach to
    inter-domain multicast routing

   FRM makes use of existing unicast routing
    infrastructure for group membership discovery and
    route construction

   Reduce protocol complexity via aggressive use of
    router resources

				
DOCUMENT INFO
Shared By:
Categories:
Stats:
views:2
posted:3/5/2010
language:English
pages:61