Loading in 2 Seconds...

Efficient Dissemination of Personalized Information Using Content-Based Multicast (CBM)

Loading in 2 Seconds...

- 77 Views
- Uploaded on

Download Presentation
## Efficient Dissemination of Personalized Information Using Content-Based Multicast (CBM)

**An Image/Link below is provided (as is) to download presentation**

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript

### Efficient Dissemination of Personalized Information Using Content-Based Multicast (CBM)

Rahul Shah* Ravi Jain* Farooq Anjum

Dept. Computer Science Autonomous Comm. Lab Applied Research

Rutgers University NTT DoCoMo USA Labs Telcordia

sharahul@paul.rutgers.edujain@docomolabs-usa.comfanjum@telcordia.com

*Work performed while at Applied Research, Telcordia

Outline

- Motivation and background
- Problem definition
- Simulation results
- Concluding remarks

Mobile Filters for Efficient Personalized Information Delivery

- Users want targeted, personalized information, particularly
- as the amount and diversity of information increases,
- the capabilities of end devices are limited and resources are scarce
- Applications like personalized information delivery to large numbers of users rely on multicast to conserve resources
- Traditional network multicast (e.g. IP multicast)
- does not consider the content or semantics of the information sent
- Management difficult as number of groups increase
- Content-Based Multicast (CBM) filters the information being sent down the multicast tree in accordance with the interests of the recipients
- Problem: how to place software information filters in response to
- the location and interests of the users, and how these change
- the additional cost and complexity of the filters

Related work

- Multicast
- Application layer multicast
- Assumes only unicast at the IP layer, while CBM assumes a multicast tree (either at the IP or the application layer)
- Examples: Francis, Yoid, 2000; Chu et al., End System Multicast, Sigmetrics 2000; Chawathe et al., Scattercast, 2000
- Publish-subscribe systems
- Many-many distribution with matching done by brokers in the network
- In CBM the brokers form the underlying multicast tree
- Examples: Aguilera, 1998; Banavar, 1998; Carzaniga, 1998
- Modifications to IP multicast
- Opyrchal, Minimizing number of multicast groups, Middleware 2000
- Wen et al., Use active network approaches, OpenArch 2001
- Theoretical work
- Classical k-median and facility location problems

Content

Source

3

6

1

2

5

8

4

7

Items

1, 3, 4, 5, 6, 7, 8

1, 3, 5, 6, 7, 8

1, 3, 5

3, 6, 7, 8

1, 3, 5, 8

4, 6, 7, 8

Users

3, 5

1, 8

3, 8

6, 7, 8

4

3, 6

7,8

1, 5

Items desired

1, 3

Multicast filtering example- Without filters, all 8 items are sent on all 15 links = 120 traffic units
- With filters at all internal nodes, traffic = 47 units
- With filters at 3 internal nodes, traffic = 63 units

Mobile code problem definition

- Problem 1: Bandwidth optimization problem
- Criterion: Find optimal placement to minimize total bandwidth
- Cost model: k-Filters: Allow at most k filters to be used
- Problem 2: Delay optimization problem
- Criterion: Find optimal placement to minimize mean delivery delay
- Cost model: Delay:
- Each filter adds a delay D for processing
- The reduction in link utilization also results in reduction in link delay:
- Optimal placement changes as users move or change interests
- the filtering code should or could be mobile and
- the placement algorithm should be fast
- Results:
- optimal centralized off-line algorithm for bandwidth optimization. Time = O(k n2)
- optimal centralized off-line algorithm for delay optimization. Time = O(n2)
- Two centralized O(n) heuristics that restrict filter moves
- Evaluation using simulations

Filtering algorithm framework

- For simplicity, we assume the following framework
- 1: The multicast tree has previously been constructed and is known
- 2: Filters can be placed at all internal nodes of the multicast tree
- If not, simply consider the subtree where filters are permitted
- 3: Subscriptions propagate from the users to the source
- There is a simple list of information items that users can request
- Subscription changes are batched at the source
- At every batch (time slice) x% of the users change subscription
- 4. The source calculates filter placements
- 5: The source dispatches filters to the (new) placement
- Currently we ignore signaling costs of subscriptions and filter movement because negligible for the applications considered (news clips, video clips, music, etc)
- Alternatively could consider that filters are available at all nodes and are only activated/deactivated by signaling messages

Bandwidth minimization problemOptimal centralized algorithm

f(p)

Child of

Lowest filtering

ancestor, p

Model of multicast tree at source

- Dynamic programming recurrence relations
- Traffic in the subtree rooted at v, with a filter at v:

T(v, i, p) = f(l) + f(r) + min[ j: 0 j i: T(l, j, l) + T(r, i - j - 1, r) ]

- Traffic with no filter at v:

S(v, i, p) = 2 f(p) + min[ j: 0 j i: T(l, j, p) + T(r, i - j, p) ]

- Traffic at a leaf node v: T(v, i, p) = S(v, i, p) = 0
- Minimum traffic is min[ T(v, k, p), S(v, k, p) ]

f(p)

- f(x) = Traffic required at node x
- Execution time = O(k n2)
- n = number of nodes in tree
- Time complexity calculated
- using Tamir (1996)

T(v, i, p)

Node v

i filters,

max

f(l)

f(r)

j

filters

i - (j -1)

filters

Simulation results: Filters can be very effective

- Seven-level complete binary tree (n = 127), with 64 leaves
- m = 64 messages
- Uniform subscription: p(i, j) = Prob [ User i subscribes to message j ] = p

Locality model: P(i, j) = 1/N if i = j

- = qr /N else, where r = LCA(i, j)
- q is a skew parameter inversely proportional to locality

Node v

k filters,

max

f(l)

f(r)

z(l)

affected

edges

z(r)

affected

edges

Bandwidth minimization problemHeuristic centralized algorithm- Node importance, I

= amount by which total

traffic changes by

placing a filter there

- Execution time = O(n)

- Importance of node v:

I(v) = (f(v) - f(l)) z(l) + (f(v) - f(r)) z(r), where

z(x) = 1, if x has a filter

1 + z(left-child of x) + z(right-child of x), otherwise

- z(x) is number of edges in the subtree rooted at x affected by a filter at x

Centralized heuristic

- Subscriptions propagate up to the source, which
- calculates the required flow amount at each edge and the Importance value of each node
- tries the Importance Flip
- Imax(v) = max[ v: v does not have a filter: I(v)]
- Imin(u) = min[ u: u has a filter, I(u)]
- If Imax(v) > Imin(u), move the filter from u to v
- If the most Important non-filtering node is more important than the least Important filtering node, swap the filter location
- otherwise, tries the Parent-child flip
- is allowed to make at most one filter move
- The source dispatches one new filter, or a move instruction to one existing filter

Code mobility is not useful with uniform subscriptions and static users

- opt = optimal placement at each trial
- heu = heuristic re-run at each trial
- Init = initial placement, kept unchanged

p = 0.3 - q

Mobility model- User mobility: Users gradually move from the left subtree to the right subtree
- Subscription skew, q
- At t = 0, users in left subtree have

p = 0.3 + q, users in right p = 0.3 - q

- At t = i, swap probabilities of user i in left

subtree with user i in right subtree

Further work

- Theoretical improvements:
- More efficient algorithms
- Achieves O(n logn) time complexity
- Prototype and obtain actual bandwidth costs and delays for filter movement using Aglets technology
- A distributed filtering algorithm, where the filters are agents that coordinate with minimal involvement of the source
- How to avoid thrashing and loops
- How to ensure semi-autonomous agent movements do not degrade performance
- Investigate different application domains

Download Presentation

Connecting to Server..