Line Segment Visibility
from Origin
-Uthish Balaji
CSE-633 Parallel Algorithms
Wednesday 23rd April 2014
Problem Definition
Given a set of line segments which are perpendicular to the x axis ,
determine what piece of each line segment would be visible from origin .
Input :- A set of y coordinate values
Output :- A set of results which contain the piece of each line segement that
is visible
Illustration
Assumptions
One end of the line segment is at the x-axis.
The lines are placed unit distance apart in x-axis .
The data is arranged in ascending order with respect to the x axis values.
One cannot see through the lines
Applications
When creating a virtual reality , one would want the users to not be able to
look through walls/buildings.
Determining the length of a runway when building an airport.
What I’ve done
Developed a serial algorithm
Developed a parallel algorithm
Compared them.
Serial Algorithm
Read the data.
Currentslope=y[0]/x[0]
For i=1 to n
If y[i]>Currentslope*x[i]
out[i]=y[i]-Currentslope*x[i]
Currentslope=y[i]/x[i]
Else
out[i]=0;
Print out[i].
Parallel Solution
Parallel prefix on the maximum slope .
Perform the serial algorithm to get the results within the particular processor
Pass on the maximum slope seen within the processor to the next processor
If the value obtained is greater than maximum local slope then
pass on the value obtained to the next processor
Else pass on maximum local slope to next processor
recalculate the local values with the value obtained .
Implementation – Input Data problem
Implementation – generation of input
data
Created dataset using random function.
prevslope=0
If rand()%4==3
arr[i]=prevslope*i+.001
prevslope=arr[i]/I;
Else arr[i]=0
Implementation – distribution of data
Processor with rank=0 creates the dataset
Rank0 processor then distributes the entire dataset to all other processors
Since all processors know n(size of data) and p(number of processors) they’ll
calculate the lower limit and upper limit of the entire data they are supposed
to read
Lower limit = ((n/p)*rank)+1
Upper limit = (n/p)*(rank+1)
Running Time Serial Implementation
10,000
0.000131
100,000
0.001348
1,000,000
0.013202
10,000,000
0.129934
100,000,000
1.300618
Running Time – Parallel Implementation
10,000
100,000
1,000,000
10,000,000
100,000,000
2
0.000125
0.001257
0.012603
0.09296
0.300813
4
0.000105
0.000663
0.006354
0.031587
0.275691
8
0.000149
0.000436
0.003248
0.016084
0.135961
16
0.000303
0.00049
0.002037
0.008422
0.074135
32
0.000617
0.000742
0.00176
0.005049
0.040772
64
0.001349
0.001536
0.001824
0.003948
0.021979
128
0.003168
0.002987
0.002502
0.002737
0.01576
Results – Serial Implementation
Serial Implementation
1.4
1.2
1
0.8
1=10k 2=100k 3=1m 4=10m 5=100m
0.6
0.4
0.2
0
1
2
3
4
5
Result – parallel implementation
Data = 10,000
Data=100,000
0.0035
0.003
0.0035
0.0025
Running TIme
0.003
Running Time
0.0025
0.002
0.002
0.0015
0.0015
0.001
0.001
0.0005
0.0005
0
0
0
0
50
Processors
100
150
20
40
60
80
Processors
100
120
140
Results – parallel implementation
.
Data = 1,000,000
0.014
Data=10,000,000
0.1
0.09
0.012
0.08
0.07
Running Time
Running Time
0.01
0.008
0.006
0.06
0.05
0.04
0.03
0.004
0.02
0.01
0.002
0
0
0
0
20
40
60
80
Processors
100
120
140
20
40
60
80
Processors
100
120
140
Results – parallel implementation
.
Data=100,000,000
0.35
0.3
Running Time
0.25
0.2
0.15
0.1
0.05
0
0
20
40
60
80
Processors
100
120
140
Best Case vs Average/Worst Case
Best case scenario : In the best scenario , the very first line would be visible
and nothing beyond it will be . This is best case because all the local prefixes
will be skipped because the local maximum slope will be less than the
received slope .
Average case : In the average case , there may or may not be a local
maximum slope which is greater than the received slope .
Worst case scenario : In the worst case scenario the local maximum is always
greater than the prefix value that was received , so thus all local prefix
calculations have to be done .
Best vs Average/worst case scenario
.
Comparison between best case and average case
0.1
0.09
0.08
Running TIme
0.07
0.06
0.05
average case
0.04
best case
0.03
0.02
0.01
0
0
10
20
30
40
Processors
50
60
70
Speedup(10m data)
.
Speedup
Data=10,000,000
50
45
40
Speedup
35
30
25
20
15
10
5
0
0
20
40
60
80
Processors
100
120
140
Questions ?
0
