1. Aplica¸c˜ao do
k-NN
utilizando
Bitonic Sort
Maur´ıcio
Jourdan,
Paulo
Henrique,
Pedro
Braganick,
Vin´ıcius
Coelho
T´opicos
A aplica¸c˜ao
Codifica¸c˜ao
Estrutura
Fun¸c˜oes
Fractionary
Knapsack
Quick Sort
Bitonic Sort
Bitonic Step
Main do C´odigo
Serial
Ambiente de
teste
Resultados
Aplica¸c˜ao do k-NN utilizando Bitonic Sort
Maur´ıcio Jourdan, Paulo Henrique,
Pedro Braganick, Vin´ıcius Coelho
Instituto de Inform´atica
Universidade Federal de Goi´as (UFG)

2. Aplica¸c˜ao do
k-NN
utilizando
Bitonic Sort
Maur´ıcio
Jourdan,
Paulo
Henrique,
Pedro
Braganick,
Vin´ıcius
Coelho
T´opicos
A aplica¸c˜ao
Codifica¸c˜ao
Estrutura
Fun¸c˜oes
Fractionary
Knapsack
Quick Sort
Bitonic Sort
Bitonic Step
Main do C´odigo
Serial
Ambiente de
teste
Resultados
T´opicos
1 A aplica¸c˜ao;
2 Codifica¸c˜ao;
3 Resultados;

3. Aplica¸c˜ao do
k-NN
utilizando
Bitonic Sort
Maur´ıcio
Jourdan,
Paulo
Henrique,
Pedro
Braganick,
Vin´ıcius
Coelho
T´opicos
A aplica¸c˜ao
Codifica¸c˜ao
Estrutura
Fun¸c˜oes
Fractionary
Knapsack
Quick Sort
Bitonic Sort
Bitonic Step
Main do C´odigo
Serial
Ambiente de
teste
Resultados
Mochila fracion´aria
Porque a mochila fracion´aria?

4. Aplica¸c˜ao do
k-NN
utilizando
Bitonic Sort
Maur´ıcio
Jourdan,
Paulo
Henrique,
Pedro
Braganick,
Vin´ıcius
Coelho
T´opicos
A aplica¸c˜ao
Codifica¸c˜ao
Estrutura
Fun¸c˜oes
Fractionary
Knapsack
Quick Sort
Bitonic Sort
Bitonic Step
Main do C´odigo
Serial
Ambiente de
teste
Resultados
Mochila fracion´aria
Porque a mochila fracion´aria?
Ela utiliza de um algoritmo guloso que visa preencher a
mochila de forma a maximixar o valor. Utilizando a ordena¸c˜ao,
teremos os valores j´a agrupados, onde o n-´esimo elemento
possui maior valor por unidade de peso.

5. Aplica¸c˜ao do
k-NN
utilizando
Bitonic Sort
Maur´ıcio
Jourdan,
Paulo
Henrique,
Pedro
Braganick,
Vin´ıcius
Coelho
T´opicos
A aplica¸c˜ao
Codifica¸c˜ao
Estrutura
Fun¸c˜oes
Fractionary
Knapsack
Quick Sort
Bitonic Sort
Bitonic Step
Main do C´odigo
Serial
Ambiente de
teste
Resultados
Mochila fracion´aria
Por exemplo: entre os elementos A, B e C, com respectivos
valores e pesos (1020, 29), (340, 7) e (580, 13), qual a melhor
escolha para preencher uma mochila de capacidade 450, de
forma que maximize o valor?

6. Aplica¸c˜ao do
k-NN
utilizando
Bitonic Sort
Maur´ıcio
Jourdan,
Paulo
Henrique,
Pedro
Braganick,
Vin´ıcius
Coelho
T´opicos
A aplica¸c˜ao
Codifica¸c˜ao
Estrutura
Fun¸c˜oes
Fractionary
Knapsack
Quick Sort
Bitonic Sort
Bitonic Step
Main do C´odigo
Serial
Ambiente de
teste
Resultados
Mochila fracion´aria
Por exemplo: entre os elementos A, B e C, com respectivos
valores e pesos (1020, 29), (340, 7) e (580, 13), qual a melhor
escolha para preencher uma mochila de capacidade 450, de
forma que maximize o valor?
Como a mochila aceita valores fracionados, a melhor escolha
seria ordenar estes elementos, de forma que o de mais
importˆancia ser´a o elemento com maior valor por unidade de
peso.
Portanto a ordem ficaria: (1020, 29), (580, 13) e (340, 7).

7. Aplica¸c˜ao do
k-NN
utilizando
Bitonic Sort
Maur´ıcio
Jourdan,
Paulo
Henrique,
Pedro
Braganick,
Vin´ıcius
Coelho
T´opicos
A aplica¸c˜ao
Codifica¸c˜ao
Estrutura
Fun¸c˜oes
Fractionary
Knapsack
Quick Sort
Bitonic Sort
Bitonic Step
Main do C´odigo
Serial
Ambiente de
teste
Resultados
Mochila fracion´aria
Com a ideia dos k-vizinhos mais pr´oximos, o objetivo ´e: dada
uma mochila de capacidade x, uma posi¸c˜ao n em um vetor e
um n´umero m´aximo k de elementos adjacentes a n, qual a
escolha que maximiza o valor e utiliza a maior capacidade
poss´ıvel da mochila?

8. Aplica¸c˜ao do
k-NN
utilizando
Bitonic Sort
Maur´ıcio
Jourdan,
Paulo
Henrique,
Pedro
Braganick,
Vin´ıcius
Coelho
T´opicos
A aplica¸c˜ao
Codifica¸c˜ao
Estrutura
Fun¸c˜oes
Fractionary
Knapsack
Quick Sort
Bitonic Sort
Bitonic Step
Main do C´odigo
Serial
Ambiente de
teste
Resultados
Estrutura
1 #i n c l u d e <c s t d i o>
2 #i n c l u d e <c s t d l i b >
3 #i n c l u d e <cmath>
4 #i n c l u d e <u t i l i t y >
5 #i n c l u d e <iostream>
6 #d e f i n e THREADS 512 // 2ˆ9
7 #d e f i n e BLOCKS 32768 // 2ˆ15
8 #d e f i n e NUM VALS 2∗THREADS∗BLOCKS
9 #d e f i n e CAPACITY 67108864
10 #d e f i n e CUT 100000
11 #d e f i n e mp make pair
12
13 using namespace std ;
14
15 typedef pair<int , pair<double , double> > idd ;
16
17 s t r u c t kNN{
18 double value , weight ;
19 kNN( double v a l u e = 0.0 , double weight = 0.0 ) : v a l u e ( v a l u e ) ,
weight ( weight ) {}
20 };

9. Aplica¸c˜ao do
k-NN
utilizando
Bitonic Sort
Maur´ıcio
Jourdan,
Paulo
Henrique,
Pedro
Braganick,
Vin´ıcius
Coelho
T´opicos
A aplica¸c˜ao
Codifica¸c˜ao
Estrutura
Fun¸c˜oes
Fractionary
Knapsack
Quick Sort
Bitonic Sort
Bitonic Step
Main do C´odigo
Serial
Ambiente de
teste
Resultados
Fun¸c˜oes
1 void p r i n t e l a p s e d ( c l o c k t s t a r t , c l o c k t stop ){
2 double e l a p s e d = (( double ) ( stop − s t a r t ) ) / CLOCKS PER SEC ;
3 p r i n t f ( ” Elapsed time : %.3 f s n” , e l a p s e d ) ;
4 }
5
6 /∗Gera¸c˜ao a l e a t ´o r i a dos elementos que compoem o a r r a y ∗/
7 double random (){
8 double r = f a b s ( rand () + rand () ) /CUT;
9 i f ( r < 1.0 ) r += 1 . 0 ;
10 return r ;
11 }
12
13 void a r r a y f i l l (kNN ∗arr , i n t l e n g t h ){
14 srand ( time (NULL) ) ;
15 f o r ( i n t i = 0; i < l e n g t h ; ++i ){
16 a r r [ i ] . v a l u e = 2∗ c e i l ( random () ) ;
17 a r r [ i ] . weight = c e i l ( random () ) ;
18 }
19 }

10. Aplica¸c˜ao do
k-NN
utilizando
Bitonic Sort
Maur´ıcio
Jourdan,
Paulo
Henrique,
Pedro
Braganick,
Vin´ıcius
Coelho
T´opicos
A aplica¸c˜ao
Codifica¸c˜ao
Estrutura
Fun¸c˜oes
Fractionary
Knapsack
Quick Sort
Bitonic Sort
Bitonic Step
Main do C´odigo
Serial
Ambiente de
teste
Resultados
Fractionary Knapsack
1 idd f r a c t i o n a r y k n a p s a c k ( kNN ∗values , i n t pos , i n t k , double
a t u a l c a p a c i t y ){
2 i n t s t a r t p o s = pos + k − 1 , q t d i t e m s = 0;
3 double max value = 0.0 , cap reached = 0 . 0 ;
4 i f ( s t a r t p o s >= NUM VALS ) s t a r t p o s = NUM VALS−1;
5 f o r ( i n t i = s t a r t p o s ; i >= 0 && i >= pos ; i−− ){
6 i f ( v a l u e s [ i ] . weight == 0.0 ) continue ;
7 i f ( a t u a l c a p a c i t y == 0.0 ) break ;
8 double aux = a t u a l c a p a c i t y − v a l u e s [ i ] . weight ; /∗Get the amount of ’ i ’
capable to f i l l the sack ∗/
9 i f ( aux < 0.0 ){
10 double v a l u e u s e d = ( v a l u e s [ i ] . v a l u e / v a l u e s [ i ] . weight )∗ a t u a l c a p a c i t y ;
11 cap reached += a t u a l c a p a c i t y ;
12 a t u a l c a p a c i t y = 0 . 0 ;
13 max value += v a l u e u s e d ;
14 v a l u e s [ i ] . weight −= a t u a l c a p a c i t y ;
15 q t d i t e m s++;
16 }
17 e l s e {
18 a t u a l c a p a c i t y −= v a l u e s [ i ] . weight ;
19 cap reached += v a l u e s [ i ] . weight ;
20 max value += v a l u e s [ i ] . v a l u e ;
21 v a l u e s [ i ] . weight = 0 . 0 ;
22 q t d i t e m s++;
23 }
24 }
25 return mp( qtd items , mp( cap reached , max value ) ) ;
26 }

11. Aplica¸c˜ao do
k-NN
utilizando
Bitonic Sort
Maur´ıcio
Jourdan,
Paulo
Henrique,
Pedro
Braganick,
Vin´ıcius
Coelho
T´opicos
A aplica¸c˜ao
Codifica¸c˜ao
Estrutura
Fun¸c˜oes
Fractionary
Knapsack
Quick Sort
Bitonic Sort
Bitonic Step
Main do C´odigo
Serial
Ambiente de
teste
Resultados
Quick Sort
1 void swap (kNN ∗a , kNN ∗b ) {
2 kNN tmp = ∗a ;
3 ∗a = ∗b ;
4 ∗b = tmp ;
5 }
6
7 i n t p a r t i t i o n (kNN ∗vec , i n t l e f t , i n t r i g h t ){
8 i n t i , j ;
9 i = l e f t ;
10 f o r ( j = l e f t + 1; j <= r i g h t ; ++j ){
11 i f ( vec [ j ] . v a l u e / vec [ j ] . weight > vec [ l e f t ] . v a l u e / vec [ l e f t ] . weight ) {
12 ++i ;
13 swap(&vec [ i ] , &vec [ j ] ) ;
14 }
15 }
16 swap(&vec [ l e f t ] , &vec [ i ] ) ;
17 return i ;
18 }
19
20 void q u i c k s o r t (kNN ∗vec , i n t l e f t , i n t r i g h t ) {
21 i n t r ;
22 i f ( r i g h t > l e f t ){
23 r = p a r t i t i o n ( vec , l e f t , r i g h t ) ;
24 q u i c k s o r t ( vec , l e f t , r −1) ;
25 q u i c k s o r t ( vec , r +1, r i g h t ) ;
26 }
27 }

12. Aplica¸c˜ao do
k-NN
utilizando
Bitonic Sort
Maur´ıcio
Jourdan,
Paulo
Henrique,
Pedro
Braganick,
Vin´ıcius
Coelho
T´opicos
A aplica¸c˜ao
Codifica¸c˜ao
Estrutura
Fun¸c˜oes
Fractionary
Knapsack
Quick Sort
Bitonic Sort
Bitonic Step
Main do C´odigo
Serial
Ambiente de
teste
Resultados
Bitonic Sort
1 void b i t o n i c s o r t (kNN ∗ v a l u e s ){
2 kNN ∗ d e v v a l u e s ;
3 s i z e t s i z e = NUM VALS ∗ s i z e o f (kNN) ;
4
5 cudaMalloc (( void ∗∗) &dev values , s i z e ) ;
6 cudaMemcpy( dev values , values , s i z e , cudaMemcpyHostToDevice ) ;
7
8 dim3 b l o c k s (BLOCKS, 1) ; /∗ Number of b l o c k s ∗/
9 dim3 t h r e a d s (THREADS, 1) ; /∗ Number of t h r e a d s ∗/
10
11 /∗ Major step ∗/
12 f o r ( i n t k = 2; k <= NUM VALS; k <<= 1 ){
13 /∗ Minor step ∗/
14 f o r ( i n t j = k>>1; j > 0; j = j>>1 ){
15 b i t o n i c s o r t s t e p<<<blocks , t h r e a d s>>>( dev values , j , k ) ;
16 }
17 }
18 cudaMemcpy( values , dev values , s i z e , cudaMemcpyDeviceToHost ) ;
19 cudaFree ( d e v v a l u e s ) ;
20 }

13. Aplica¸c˜ao do
k-NN
utilizando
Bitonic Sort
Maur´ıcio
Jourdan,
Paulo
Henrique,
Pedro
Braganick,
Vin´ıcius
Coelho
T´opicos
A aplica¸c˜ao
Codifica¸c˜ao
Estrutura
Fun¸c˜oes
Fractionary
Knapsack
Quick Sort
Bitonic Sort
Bitonic Step
Main do C´odigo
Serial
Ambiente de
teste
Resultados
Bitonic Step
1 g l o b a l void b i t o n i c s o r t s t e p (kNN ∗dev values , i n t j , i n t k ){
2 unsigned i n t i , i x j ; /∗ S o r t i n g p a r t n e r s : i and i x j ∗/
3 i = t h r e a d I d x . x + blockDim . x ∗ b l o c k I d x . x ;
4 i x j = i ˆ j ;
5
6 /∗ The t h r e a d s with the lo west i d s s o r t the a r r a y . ∗/
7 i f ( i x j > i ){
8 i f ( ( i & k ) == 0 ){
9 /∗ Sort ascending ∗/
10 i f ( d e v v a l u e s [ i ] . v a l u e / d e v v a l u e s [ i ] . weight <
d e v v a l u e s [ i x j ] . v a l u e / d e v v a l u e s [ i x j ] . weight ){
11 /∗ exchange ( i , i x j ) ; ∗/
12 kNN temp = d e v v a l u e s [ i ] ;
13 d e v v a l u e s [ i ] = d e v v a l u e s [ i x j ] ;
14 d e v v a l u e s [ i x j ] = temp ;
15 }
16 }
17 i f ( ( i & k ) != 0 ){
18 /∗ Sort descending ∗/
19 i f ( d e v v a l u e s [ i ] . v a l u e / d e v v a l u e s [ i ] . weight >
d e v v a l u e s [ i x j ] . v a l u e / d e v v a l u e s [ i x j ] . weight ){
20 /∗ exchange ( i , i x j ) ; ∗/
21 kNN temp = d e v v a l u e s [ i ] ;
22 d e v v a l u e s [ i ] = d e v v a l u e s [ i x j ] ;
23 d e v v a l u e s [ i x j ] = temp ;
24 }
25 }
26 }
27 }

14. Aplica¸c˜ao do
k-NN
utilizando
Bitonic Sort
Maur´ıcio
Jourdan,
Paulo
Henrique,
Pedro
Braganick,
Vin´ıcius
Coelho
T´opicos
A aplica¸c˜ao
Codifica¸c˜ao
Estrutura
Fun¸c˜oes
Fractionary
Knapsack
Quick Sort
Bitonic Sort
Bitonic Step
Main do C´odigo
Serial
Ambiente de
teste
Resultados
Main
1 i n t main (){
2 c l o c k t s t a r t , stop ;
3 i n t k , pos ;
4 double c a p a c i t y ;
5 kNN ∗ v a l u e s = (kNN∗) malloc ( NUM VALS ∗ s i z e o f (kNN) ) ;
6 a r r a y f i l l ( values , NUM VALS) ;
7 pos = rand () % NUM VALS;
8 k = rand () % NUM VALS;
9 c a p a c i t y = rand () % CAPACITY ;
10
11 p r i n t f ( ”Number of v a l u e s : %dn” , NUM VALS) ;
12 p r i n t f ( ” P o s i t i o n : %dn” , pos ) ;
13 p r i n t f ( ”k−n e a r e s t range : %dn” , k ) ;
14 p r i n t f ( ” Capacity : %.0 f n” , c a p a c i t y ) ;
15
16 s t a r t = c l o c k () ;
17 q u i c k s o r t ( values , 0 , NUM VALS−1) ; /∗Na vers˜ao p a r a l e l a , t r o c a r a chamada
por b i t o n i c s o r t ( v a l u e s )∗/
18 stop = c l o c k () ;
19
20 idd r e s p = f r a c t i o n a r y k n a p s a c k ( values , pos , k , c a p a c i t y ) ;
21 p r i n t f ( ”Numbers of items i n the sack : %dn” , r e s p . f i r s t ) ;
22 p r i n t f ( ” Capacity reached : %.0 f n” , r e s p . second . f i r s t ) ;
23 p r i n t f ( ”Maximum v a l u e reached : %.2 f n” , r e s p . second . second ) ;
24 p r i n t e l a p s e d ( s t a r t , stop ) ;
25
26 return 0;
27 }

15. Aplica¸c˜ao do
k-NN
utilizando
Bitonic Sort
Maur´ıcio
Jourdan,
Paulo
Henrique,
Pedro
Braganick,
Vin´ıcius
Coelho
T´opicos
A aplica¸c˜ao
Codifica¸c˜ao
Estrutura
Fun¸c˜oes
Fractionary
Knapsack
Quick Sort
Bitonic Sort
Bitonic Step
Main do C´odigo
Serial
Ambiente de
teste
Resultados
Ambiente de Teste
GPU: Tesla C2070
CPU: Core 2 Duo 2.4Ghz
448 cores, 1.15Ghz
14 SM (32 cores)

16. Aplica¸c˜ao do
k-NN
utilizando
Bitonic Sort
Maur´ıcio
Jourdan,
Paulo
Henrique,
Pedro
Braganick,
Vin´ıcius
Coelho
T´opicos
A aplica¸c˜ao
Codifica¸c˜ao
Estrutura
Fun¸c˜oes
Fractionary
Knapsack
Quick Sort
Bitonic Sort
Bitonic Step
Main do C´odigo
Serial
Ambiente de
teste
Resultados
Resultados
Figure: Quantidade de elementos: 524.288

17. Aplica¸c˜ao do
k-NN
utilizando
Bitonic Sort
Maur´ıcio
Jourdan,
Paulo
Henrique,
Pedro
Braganick,
Vin´ıcius
Coelho
T´opicos
A aplica¸c˜ao
Codifica¸c˜ao
Estrutura
Fun¸c˜oes
Fractionary
Knapsack
Quick Sort
Bitonic Sort
Bitonic Step
Main do C´odigo
Serial
Ambiente de
teste
Resultados
Resultados
Figure: Quantidade de elementos: 524.288
Speed up: 0.36

18. Aplica¸c˜ao do
k-NN
utilizando
Bitonic Sort
Maur´ıcio
Jourdan,
Paulo
Henrique,
Pedro
Braganick,
Vin´ıcius
Coelho
T´opicos
A aplica¸c˜ao
Codifica¸c˜ao
Estrutura
Fun¸c˜oes
Fractionary
Knapsack
Quick Sort
Bitonic Sort
Bitonic Step
Main do C´odigo
Serial
Ambiente de
teste
Resultados
Resultados
Figure: Quantidade de elementos: 2.097.152

19. Aplica¸c˜ao do
k-NN
utilizando
Bitonic Sort
Maur´ıcio
Jourdan,
Paulo
Henrique,
Pedro
Braganick,
Vin´ıcius
Coelho
T´opicos
A aplica¸c˜ao
Codifica¸c˜ao
Estrutura
Fun¸c˜oes
Fractionary
Knapsack
Quick Sort
Bitonic Sort
Bitonic Step
Main do C´odigo
Serial
Ambiente de
teste
Resultados
Resultados
Figure: Quantidade de elementos: 2.097.152
Speed up: 1.77

20. Aplica¸c˜ao do
k-NN
utilizando
Bitonic Sort
Maur´ıcio
Jourdan,
Paulo
Henrique,
Pedro
Braganick,
Vin´ıcius
Coelho
T´opicos
A aplica¸c˜ao
Codifica¸c˜ao
Estrutura
Fun¸c˜oes
Fractionary
Knapsack
Quick Sort
Bitonic Sort
Bitonic Step
Main do C´odigo
Serial
Ambiente de
teste
Resultados
Resultados
Figure: Quantidade de elementos: 8.388.608

21. Aplica¸c˜ao do
k-NN
utilizando
Bitonic Sort
Maur´ıcio
Jourdan,
Paulo
Henrique,
Pedro
Braganick,
Vin´ıcius
Coelho
T´opicos
A aplica¸c˜ao
Codifica¸c˜ao
Estrutura
Fun¸c˜oes
Fractionary
Knapsack
Quick Sort
Bitonic Sort
Bitonic Step
Main do C´odigo
Serial
Ambiente de
teste
Resultados
Resultados
Figure: Quantidade de elementos: 8.388.608
Speed up: 5.91

22. Aplica¸c˜ao do
k-NN
utilizando
Bitonic Sort
Maur´ıcio
Jourdan,
Paulo
Henrique,
Pedro
Braganick,
Vin´ıcius
Coelho
T´opicos
A aplica¸c˜ao
Codifica¸c˜ao
Estrutura
Fun¸c˜oes
Fractionary
Knapsack
Quick Sort
Bitonic Sort
Bitonic Step
Main do C´odigo
Serial
Ambiente de
teste
Resultados
Resultados
Figure: Quantidade de elementos: 33.554.432

23. Aplica¸c˜ao do
k-NN
utilizando
Bitonic Sort
Maur´ıcio
Jourdan,
Paulo
Henrique,
Pedro
Braganick,
Vin´ıcius
Coelho
T´opicos
A aplica¸c˜ao
Codifica¸c˜ao
Estrutura
Fun¸c˜oes
Fractionary
Knapsack
Quick Sort
Bitonic Sort
Bitonic Step
Main do C´odigo
Serial
Ambiente de
teste
Resultados
Resultados
Figure: Quantidade de elementos: 33.554.432
Speed up: 11.78

24. Aplica¸c˜ao do
k-NN
utilizando
Bitonic Sort
Maur´ıcio
Jourdan,
Paulo
Henrique,
Pedro
Braganick,
Vin´ıcius
Coelho
T´opicos
A aplica¸c˜ao
Codifica¸c˜ao
Estrutura
Fun¸c˜oes
Fractionary
Knapsack
Quick Sort
Bitonic Sort
Bitonic Step
Main do C´odigo
Serial
Ambiente de
teste
Resultados
Perguntas?