Two absolute bounds for distributed bit complexity
Download
1 / 61

Two absolute bounds for distributed bit complexity - PowerPoint PPT Presentation


  • 99 Views
  • Uploaded on

Two absolute bounds for distributed bit complexity. Yefim Dinitz , Noam Solomon, 2007. Presented by: Or Peri & Maya Shuster. Outline. Introduction Model Problems Definitions and notation 2-processor solutions & bounds Chain solutions. Model. A chain of n+1 processors and n links.

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Two absolute bounds for distributed bit complexity' - claire


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
Two absolute bounds for distributed bit complexity

Two absolute bounds for distributed bit complexity

YefimDinitz , Noam Solomon, 2007

Presented by: Or Peri & Maya Shuster


Outline
Outline

  • Introduction

    • Model

    • Problems

    • Definitions and notation

  • 2-processor solutions & bounds

  • Chain solutions


Model
Model

  • A chain of n+1 processors and n links.

  • Each processor is assigned with a unique ID from the set Zm = {0,1,…,(M-1)}, where |Zm|=M ≥ 2.

  • Each processor has knowledge of its links (up to 2).

  • All processes are running the same (deterministic) algorithm A(n,M).


Model1
Model

  • Initially, all processors are asleep and in the same initial state, except for the id and number of incident links information.

Zzz…

Zzz…

Zzz…


Model2
Model

  • When a processor receives a message on an incident link or when it wakes up spontaneously (before receiving the first message) - it is activated.

!!!

!!!

INCOMING!!!


Model3
Model

  • Upon activation, a processor processes its local information according to Algorithm.

  • Sends messages on its incident links

  • (it may send zero or more messages on each link),

  • It may also output something, then enters the waiting state...

5+3-15+132

Send Message


Model4
Model

  • All of this is done immediately.

  • We assume that a scheduler wakes each terminaleventually, if not awaken by a message previously

  • And that no internalprocessor is awaken by the scheduler.

  • For convenience of analysis, we consider a formal clock:

  • it starts from moment 0, and each processor activation step is done at the next moment 1, 2, . . . .

  • NOTE:This clock isn’t shared or synchronized by the processors, it is merely for overview analysis.


Model5
Model

  • Each message consists of a single bit.

  • Messages are assumed to arrive in a finite, yet unbounded time from the moment they are sent.

  • There may be different executions beginning from the same initial state, due to scheduling.


Example
Example

Zzz…

Zzz…

Zzz…

ID =5

ID = 2

ID = 1


Example1
Example

!!!

Zzz…

Zzz…

ID =5

ID = 2

ID = 1


Example2
Example

115+2-1=2

Zzz…

Zzz…

ID =5

ID = 2

ID = 1

1


Example3
Example

!!!

!!!

Zzz…

ID =5

ID = 2

ID = 1

1


Example4
Example

215+2-1=…

515+2-1=…

Zzz…

ID =5

ID = 2

ID = 1

0

1


Example5
Example

Zzz…

!!!

Zzz…

ID =5

ID = 2

ID = 1

1

0

Non-Leader

Non-Leader


Example6
Example

!!!

Zzz…

Zzz…

ID =5

ID = 2

ID = 1

1

Non-Leader

Non-Leader

Leader


Example7
Example

Zzz…

Zzz…

Zzz…

ID =5

ID = 2

ID = 1

Non-Leader

Non-Leader

Leader


Problem
Problem

  • The Leaderproblem requires that each processor should output (decide on) a binary value:

  • [1]“leader”/ [0]“non-leader”

  • so that there will be exactly one leader.

  • Besides, it is required that any non-leader should learn which of its incident links is in the direction to the leader.


Problem1
Problem

  • The MaxFversion of Leader requires that the terminal with the maximal id must be the elected leader.

Leader

ID =5

ID = 2

ID = 1

Non-Leader

Non-Leader


Definition
Definition

  • For a task T , Bit-C(T ) is the number of bits sent needed to solve T, in the worst case.

  • We will express bounds for it in the terms of chain length: nand Id-domain size: M.

  •  clearly, Bit-C(MaxF) ≥ Bit-C(Leader)


Lower upper bound
Lower & Upper bound

  • An upper bound must be valid for all inputs and all schedulers.

  • To obtain a lower bound L, however, it is sufficient to show that, for any algorithm, there exists some input and some scheduler, such that the execution under that scheduler with that input requires at least L bits.


Definition termination property
Definition - Termination Property

  • A distributed algorithm solving some task is said to have the termination property(or is terminating), if:

  • Each processoris eventually ensured that no more messagesconcerning this task will be sentby any processor and that there are no messages in transit, except, maybe, messages sent by itself.

  • For a distributed task T , we denote by Bit-Ct(T) its bit complexity for the case when the termination property is required.

  • clearly, Bit-Ct(T) ≥Bit-C(T).


Outline1
Outline

  • Introduction

  • 2-processor solutions & bounds

    • MaxF – Terminating algorithm in bits

    • MaxF– Algorithm inbits

    • Exactly Matching Lower Bounds

  • Chain solutions


2 processor solutions
2-processor solutions

  • Goal: solve MaxF for a chain of length 1

  • Thus, solving Leader as well…


Na ve solution
Naïve solution

Each Sends log2M -1 bits

1

0

1

1

0

0

1

0

0

1

ID = 101100b

ID = 100101b


Na ve solution1
Naïve solution

Each Sends log2M -1 bits

Why is this enough?

1

0

1

1

0

0

1

0

0

1

ID = 101100b

ID = 100101b


Na ve solution2
Naïve solution

Each Sends log2M -1 bits

Can we do better?

1

0

1

1

0

0

1

0

0

1

ID = 101100b

ID = 100101b


A terminating algorithm
A Terminating Algorithm

  • For M=2, no bits are sent.

    Processor with ID=1 is leader; other is non-leader

  • For M>2:

    • A recursive Algorithm

    • In each round we divide the ID range [0..(M-1)] to:

Lesser

Median

Greater


Round description
Round Description

Upon wake-up

(spontaneous or Message)

Lesser

0

Median

wait

Greater

1


Round description1
Round Description

Lesser

1

I’m Non-Leader

Greater

0

I’m the Leader


Round description2
Round Description

Median

1

I’m Non-Leader

Median

0

I’m the Leader


Round description3
Round Description

Lesser

0

Both are the same

GoTo next round on the sub-range

Greater

1


Example8
Example

Say M=11  ZM=[0..10]

ID = 10

ID = 8


Round i
Round I

⌊𝑀/2⌋= ⌊11/2⌋=5 < 10

 I’m greater

⌊𝑀/2⌋= ⌊11/2⌋=5 < 8

 I’m greater

1

1

ID = 10

ID = 8


Round i1
Round I

He’s the same as me!

He’s the same as me!

1

1

ID = 10

ID = 8


Round ii
Round II

 ZM=[6..10]

⌊𝑀/2⌋= ⌊(11+6)/2⌋=8 < 10

 I’m greater

⌊𝑀/2⌋= ⌊(11+6)/2⌋=8 = 8

 I’m Median

1

ID = 10

ID = 8


Round ii1
Round II

He’s greater than me!

 I’m non-Leader

1

0

ID = 10

ID = 8


Round ii2
Round II

He’s smaller than me!

 I’m the Leader

Non-Leader

0

ID = 10

ID = 8


Example outcome
Example - Outcome

  • Elected Leader is the one with maximal ID.

  • Non-leader knows it isn’t leader.

  • The algorithm terminates under any scheduler

  • Total Bits sent: 2*2=4

He’s smaller than me!

 I’m the Leader

Non-Leader

ID = 10

ID = 8


Example outcome1
Example - Outcome

What could change under different scheduling?

He’s smaller than me!

 I’m the Leader

Non-Leader

ID = 10

ID = 8


Example outcome2
Example - Outcome

Why must it terminate?

He’s smaller than me!

 I’m the Leader

Non-Leader

ID = 10

ID = 8


Worst case time analysis
Worst-case Time Analysis

  • For M=2, no bits are sent.

    Processor with ID=1 is leader; other is non-leader

  • For M>2:

    - In each round we divide the ID range [0..(M-1)], such that the next round, if needed, will have a range of size ≤.

    • We thus formalize a recurrent relation:

Greater

Lesser

Median


Worst case time analysis1
Worst-case Time Analysis

  • Lemma:If M is at most , at most 2r bits are sent by the Algorithm.

Proof – by Induction:

base: r = 0, then and no bits are sent (2∙r = 0)

Assumption: Lemma is correct for some r=k

Step: consider r=k+1, for any

 Either there is a single round with 2 bits sent, OR

the length of the next round’s id’s sub-range

 using the assumption, next step and on uses up to 2k bits

 Total bits sent ≤ 2k+2 (=2(r+1) as required)


Worst case time analysis2
Worst-case Time Analysis

  • We have a way to keep track of M between rounds:

  • Our Lemma proves that for M , no more than 2r bits are sent.

  • How many rounds are there?

  • Thus,  

    •  .

    • If M is in-between, the total amount of sent bits


Worst case time analysis3
Worst-case Time Analysis

  • We have a way to keep track of M between rounds:

  • Our Lemma proves that for M , no more than 2r bits are sent.

  • How many rounds are there?

  • Thus, M 

  • Finally, total amount of sent bits

This is roughly a 1-bit difference


Outline2
Outline

  • Introduction

  • 2-processor solutions & bounds

    • MaxF – Terminating algorithm in bits

    • MaxF– Algorithm inbits

    • Exactly matching Lower Bounds

  • Chain solutions


Another solution
Another solution

  • Goal: lowering runtime constant from to .

  • “Cost of improvement”: The algorithm may not terminate!

- In our distributed network model, messages are guaranteed to be delivered in some finite time.

- This means, a sent message will arrive,

but a processor cannot stop waiting, if there is a chance that some message is on its way.


The algorithm
The Algorithm

  • For M<6, use the former Algorithm (up to 4 bits used).

  • For any M≥6:

    • divide the ID range [0..(M-1)] to:

    • In each round, 2 bits are sent.

    • Last round is an exception: 4 bits are sent.

Max

Min

Lesser

Greater


Round description4
Round Description

Max

Decide: leader

wait

Greater

1

Lesser

0

Min

Decide: non-leader

wait


Round description5
Round Description

Greater

Both are the same

GoTo next round on sub-range

1

Lesser

0


Round description6
Round Description

Max

0/1

1/0

When Min/Max receive any bit

Respond with opposite bit

As if to say:

“we are different, let’s finish”

Min

0/1

1/0


Round description7
Round Description

Greater

Resend last bit to confirm intentions

0

1

Lesser

1

0


Round description8
Round Description

Max

0/1

1

When Min/Max receive any bit

Respond with “decision” bit

As if to say:

“no matter what you are, my decision is the final one”

Min

0/1

0


Round description9
Round Description

Greater

Got ‘0’:

Decide Leader

Got ‘1’:

Decide Non-Leader

0/1

Lesser

0/1


Correctness
Correctness

Lesser got ‘0’  go to next round

Lesser

0

0


Correctness1
Correctness

Lesser got ‘1’  This is the last round! (resend ‘0’)

Either second processor is greater / Max

 second bit will be ‘1’ and it’ll decide ‘Non-Leader’

Or, second processor is Min

 Second bit will be ‘0’ and it’ll decide ‘Leader’

Lesser

0

1

0


Correctness2
Correctness

Min element decides immediately ‘Non-leader’

Either other processor is Lesser:

 got ‘0’  sent ‘1’ [“we are different – let’s finish”]

(will get ‘0’ again) sends ‘0’ [I am Non-Leader]

Or other processor is Greater:

 got ‘1’  sent ‘0’ [“we are different – let’s finish”]

(will get ‘1’ again) sends ‘0’ [I am Non-Leader]

Min

0/1

1/0

0


Round description10
Round Description

Max

wait

But what if one is Min and one is MAX???

Min

wait


Round description11
Round Description

Max

Decide: leader

wait

The algorithm is still correct, since they both decideimmediately,

But it will not terminate, as they can’t tell when to stop waiting for a message.

Min

Decide: non-leader

wait


Worst case time analysis4
Worst-case Time Analysis

  • Similar to previous Algorithm

  • For M≥6:

    • The proper recurrent relation:

Max

Greater

Lesser

Min


Worst case time analysis5
Worst-case Time Analysis

  • Lemma:If M is at most , at most 2r bits are sent by the Algorithm.

Proof – by Induction:

base: r = 0, then and no bits are sent (2∙r = 0)

r = 1, then

and correctness is obtained by using the previous algorithm,

Assumption: Lemma is correct for some r=k

Step: consider r=k+1, for any

 Either there is a single round with 4 bits sent, OR

length next round’s id’s sub-range

 using the assumption, next step and on uses up to 2k bits

 Total bits sent ≤ 2k+2 (=2(r+1) as required)

Only difference and isn’t a problem since 2r≥4


Worst case time analysis6
Worst-case Time Analysis

  • Using exactly the same trickery as before we obtain:

  • And finally, total amount of sent bits