FACULDADE MERIDIONAL IMED BADALOTTI...In this work we present a parallel implementation of the...
46
FACULDADE MERIDIONAL – IMED SISTEMAS DE INFORMAÇÃO Mateus Badalotti Petkovicz Otimização do algoritmo de agrupamento K-means através do uso de GPUs e do framework OpenCL Passo Fundo 2017
Transcript of FACULDADE MERIDIONAL IMED BADALOTTI...In this work we present a parallel implementation of the...
FACULDADE MERIDIONAL – IMED
SISTEMAS DE INFORMAÇÃO
Mateus Badalotti Petkovicz
Otimização do algoritmo de agrupamento K-means
através do uso de GPUs e do framework OpenCL
Passo Fundo
2017
Mateus Badalotti Petkovicz
Otimização do algoritmo de agrupamento K-means
através do uso de GPUs e do framework OpenCL
Trabalho de Conclusão de Curso apresentado à
Escola de Sistemas de Informação, da Faculdade
Meridional – IMED, como requisito parcial para
obtenção do grau de Bacharel em Sistemas de
Informação, sob a orientação do Prof. Esp. Ralph José
Rassweiler Filho.
Passo Fundo
2017
Mateus Badalotti Petkovicz
Otimização do algoritmo de agrupamento K-means
através do uso de GPUs e do framework OpenCL
Banca Examinadora:
Prof. Me. Suellen Spinello Sotille
Prof. Me. Ralph José Rassweiler Filho
Prof. Me. Fahad Kalil
Passo Fundo
2017
RESUMO
Neste trabalho é apresentada uma implementação paralelizada do algoritmo de agrupamento K-
means, e sua possível aplicação para clusterizar dados de rede em cenários de muitos acessos
com possíveis ataques DdoS. O sistema utilizado para testes foi um Intel Core i7
[email protected] utilizando 16GB de Memória RAM GSkill RipjawsX DDR3@2400MHZ
CL11, operando em dual channel com dois módulos de 8GB cada, em uma placa mãe de chipset
Intel Z97 (MSI Z97 GD-65). A GPU utilizada foi uma Nvidia Geforce GTX 1080 com
GPU@2GHZ e 8GB GDDR5X VRAM@10GHZ (utilizando o driver versão 381.65 WHQL).
O desenvolvimento do algoritmo foi realizado utilizando o framework OpenCL. Também são
apresentadas diferenças entre CPU e GPU, como diferenças de arquitetura, funcionamento e
componentes presentes em cada dispositivo e o funcionamento alguns tipos de ataques DdoS.
A comparação de desempenho entre CPU e GPU, utilizando o OpenCL, no algoritmo
desenvolvido, apresentou um ganho de no mínimo seis vezes superior para a placa de vídeo,
explorando os recursos que a mesma oferece.
Palavras-chave: K-means paralelo. GPU. DDoS. OpenCL. Cluster.
ABSTRACT
In this work we present a parallel implementation of the K-means clustering algorithm and its
possible application to cluster network data in many access scenarios with possible DdoS
attacks. The system used for testing was an Intel Core i7 [email protected] using 16GB of RAM
GSkill RipjawsX DDR3 @ 2400MHZ CL11, operating in dual channel with two modules of
8GB each, on an Intel Z97 chipset motherboard (MSI Z97 GD- 65). The GPU used was an
Nvidia Geforce GTX 1080 with GPU @ 2GHZ and 8GB GDDR5X VRAM @ 10GHZ (using
the driver version 381.65 WHQL). The development of the algorithm was performed using the
OpenCL framework. Differences between CPU and GPU are also presented, such as differences
in architecture, operation and components present in each device and the operation of some
types of DdoS attacks. The performance comparison between CPU and GPU, using OpenCL,
in the algorithm developed, presented a gain of at least six times higher for the video card,
exploiting the features that it offers.
Keywords: Parallel K-means. GPU. DdoS. OpenCL. Cluster.
LISTA DE ILUSTRAÇÕES
Figura 1 - Diferenças de arquitetura entre CPU e GPU ........................................................... 12
Figura 2 - Arquitetura do OpenCL .......................................................................................... 15
Figura 3 - Funcionamento do OpenCL .................................................................................... 16
Figura 4 – Exemplo de funcionamento do algoritmo de agrupamento K-means .................... 21
Figura 5 – Demonstração do estado dos dados a cada iteração do K-means .......................... 22
Figura 6 – Funcionamento básico de um ataque DdoS ........................................................... 24
Figura 7 – Demonstração de um diagrama da implementação do K-means paralelo realizado
.................................................................................................................................................. 36
LISTA DE SIGLAS
AMD: Advanced Micro Devices
API: Application Programming Interface
BGP: Border Gateway Protocol
CDN: Content Delivery Network
CL: Cas Latency
CPU: Central Processing Unit
CUDA: Compute Unified Device Architecture
DDOS: Distributed Denial-of-Service
DDR: Double Data Rate
DNS: Domain Name System
DOS: Denial-of-Service
DSP: Digital Signal Processing
GB: Gigabyte
GDDR: Graphics Double Data Rate
GHZ: Gigahertz
GPGPU: General-purpose computing on graphics processing units
GPU: Graphics Processing Unit
GTC: GPU Conference Technology
HBM: High Bandwith Memory
HHH: Hierarchical heavy hitters algorithm
HTTP: Hypertext Transfer Protocol
IMAP: Internet Message Access Protocol
MHZ: Megahertz
NTP: Network Time Protocol
OpenCL: Open Computing Language
POD: Ping of Death
RAM: Random Access Memory
RNA: Redes Neural Artifical
ROP: Render Output Unit
SIMD: Single Instruction, Multiple Data
SMTP: Simple Mail Transfer Protocol
TCP: Transmission Control Protocol
URL: Uniform Resource Locator
VRAM: Video Random Access Memory
WHQL: Windows Hardware Quality Labs
SUMÁRIO
1. INTRODUÇÃO ................................................................................................................ 9
2. PROGRAMAÇÃO EM GPU ........................................................................................ 11
2.1. OpenCL ...................................................................................................................... 15
2.2. Aprendizagem de Máquina ........................................................................................ 18
2.2.1. Algoritmos de Agrupamento ..................................................................................... 20
3. TRATAMENTO DE ATAQUES DDOS E OTIMIZAÇÃO DE ALGORITMOS DE
APRENDIZAGEM DE MÁQUINA ..................................................................................... 25
3.1. Técnicas existentes .................................................................................................... 26
3.2. Otimização de algoritmos de aprendizado de máquina utilizando GPU ................... 30
4. PROPOSTA METODOLÓGICA ................................................................................. 33
4.1. Tipo da pesquisa ........................................................................................................ 33
4.2. População e amostra .................................................................................................. 34
4.3. Coleta de dados .......................................................................................................... 34
4.4. Análise dos dados ...................................................................................................... 35
5. DETALHAMENTO E RESULTADOS ....................................................................... 36
6. CONCLUSÃO ................................................................................................................. 41
BIBLIOGRAFIA .................................................................................................................... 42
9
1. INTRODUÇÃO
Distributed Denial of Service (DDoS) têm sido uma imensa ameaça para a Internet e
tudo que se encontra na mesma. As pesquisas e desenvolvimentos de ferramentas para detecção
e defesa contra-ataques DDoS resulta em não só o avanço dos sistemas de segurança de rede,
como também resultam em ferramentas de ataques constantemente melhoradas por atacantes
comprometidos a contornar esses sistemas de segurança.
Várias ferramentas de ataques DDoS são frequentemente atualizadas, contendo
correções para os mais avançados sistemas de detecção e prevenção, tornando esse tipo de taque
um perigo constante e cada vez mais complexo de se defender deste tipo de ataque.
Neste trabalho, será abordado assuntos como, diferenças básicas entre processamento
realizado via processador (CPUs) contra processamento realizado via placas de vídeo (GPUs),
arquitetura dos mesmos, como funciona o framework OpenCL e qual sua origem, tipos de
ataque DDoS e a diferença entre DoS e DDoS, possível otimização de algoritmo de clustering,
com testes aplicados em ambiente de rede com possíveis ataques DdoS, utilizando o
processamento de uma GPU. É possível melhorar o desempenho dos algoritmos de
agrupamento utilizando GPUs, para prevenção de ataques DDoS? Para resolver o problema de
baixo desempenho de alguns algoritmos de agrupamento em CPU, passar o processamento de
algoritmos de agrupamento para uma GPU, otimizando seu uso para ambientes onde é
necessário rodar vários agrupamentos em sequência para realizar a comparação de resultados.
Os objetivos gerais deste trabalho são avaliar algoritmos de agrupamento que rodam em
CPU e avaliar possíveis gargalos de uso de CPU em certas aplicações, avaliar algoritmos de
agrupamento processados em CPU que já foram portados para GPU, portar o algoritmo K-
Means para GPU, utilizando o framework OpenCL e avaliar se o seu desempenho compensa o
esforço necessário para realizar a sua escrita de forma paralela, e por fim, seu objetivo
específico é realizar a otimização do algoritmo K-means, utilizando GPUs e o framework
OpenCL. Como novidades o trabalho busca apresentar mais clusters em menos tempo, e como
motivação para realizar o trabalho é utilizada a possibilidade de apresentar uma ferramenta com
mais desempenho e possível solução para problemas de segurança, facilitando a visibilidade
dos dados.
No capítulo 2 será abordado a programação GPGPU (General-purpose computing on
graphics processing units), diferenças entre processamento e o funcionamento de uma GPU
10
contra processamento e funcionamento de uma CPU, origem e funcionamento do OpenCL,
aprendizagem de máquina e algoritmos de agrupamento.
No capítulo 3 será abordado os tipos existentes de ataques DDoS, métodos de
prevenção, aprendizagem de máquina e algoritmos de agrupamento, e a possível otimização
utilizando OpenCL e processamento via GPU.
11
2. PROGRAMAÇÃO EM GPU
A programação paralela utilizando placas gráficas de propósito geral, faz com que os
núcleos GPGPU (General-purpose computing on graphics processing units) trabalhem em
conjunto com uma CPU (Central Processing Unit) (NVIDIA, 2016), de forma a acelerar
aplicações de diversas áreas de atuação, tanto na área científica como na área corporativa. O
alto poder computacional e a acessibilidade a unidades de processamento gráfico (GPUs)
tornaram-nas os primeiros computadores paralelos acessíveis com teraflops de capacidade. Para
notar totalmente o poder de sistemas de propósito geral baseados em GPU (GPGPU), duas
questões fundamentais precisam ser tratadas com cuidado: como paralelizar um aplicativo em
itens de trabalho simultâneos e distribuir as cargas de trabalho em uma hierarquia de thread
blocks e threads, e como utilizar eficientemente a memória da GPU, dado o seu impacto
dominante sobre o desempenho (YANG et al., [s.d.]).
Sistemas de propósito geral baseados em GPU (GPGPU) são muito interessantes e
atrativos, com um desempenho alto e um custo relativamente baixo. Tal potencial de ganho de
desempenho é um desafio, pela complexidade de programação. Os desenvolvedores
normalmente têm que identificar seções adequadas do seu código para paralelização estilo
SIMD (Single Instruction Multiple Data), que é um método de operação de computadores com
várias unidades operacionais em computação paralela. Neste modo, a mesma instrução é
aplicada simultaneamente a diversos dados para produzir mais resultados. Para conseguir um
bom desempenho, uma reescrita significativa do código pode ser necessária para ajustar o uso
da GPU ao modelo de programação. Tal complexidade de programação é uma barreira para
uma maior adoção de sistemas GPGPU. (GREWE; WANG; O’BOYLE, 2013).
As GPUs podem apresentar um desempenho elevado em comparação a CPUs de mesma
geração em certas aplicações (GREWE; WANG; O’BOYLE, 2013). Placas de vídeo são
conhecidas por seu bom processamento paralelo, derivado de suas várias unidades de
processamento. Por exemplo, as duas principais fabricantes de placas de vídeos utilizam termos
diferentes para descrever seus núcleos, no caso da NVIDIA as unidades de processamento
seriam os CUDA (Compute Unified Device Architecture) Cores (Nvidia, 2016), e no caso da
AMD as unidades de processamento seriam chamados de Stream Processors (AMD, 2016).
Técnicas de classificação ou seleção que envolvem estratégias que se fundem são
particularmente propícios para sistemas GPGPU, elas são altamente paralelizáveis e a
12
granularidade computacional de tarefas simultâneas é minúscula (MERRILL; GRIMSHAW,
2010).
A biblioteca oficial de desenvolvimento para placas de vídeo NVIDIA é o CUDA, já a
AMD oficializou o OpenCL, como principal biblioteca. Ao buscar-se um framework mais
genérico para placas de vídeo, o mais indicado é utilizar OpenCL (já que este é suportada por
ambas empresas), caso buscarmos uma implementação de aplicação mais performática, com
placas de vídeo NVIDIA, o mais indicado é usar o CUDA. Uma definição formal de OpenCL
é descrita a seguir: “Recently, OpenCL, a new open programming standard for GPGPU
programming, has become available in addition to CUDA. OpenCL can support various
compute devices due to its higher abstraction programming framework.1”(KOMATSU et al.,
2010). O OpenCL foi escolhido para este trabalho por rodar em uma ampla gama de
dispositivos, o que facilita possíveis testes multiplataformas de desempenho.
Para compreender as diferenças no processamento de uma GPU em relação a uma CPU,
é preciso entender o que compõe cada CPU e cada GPU. Uma placa de vídeo é constituída de
uma GPU, que é o chip, ou o processador da placa de vídeo, e da "memória ram", que é chamada
de VRAM (Video Random Access Memory). Para efeito de comparação, hoje nos computadores
atuais, o CPU faz uso da RAM (Random Access Memory), DDR3 (Double Data Rate) ou
DDR4, nos processadores mais recentes, já nas placas de vídeo, é mais comum vermos a
utilização de GDDR5 (Graphics Double Data Rate), que é um padrão que traz uma velocidade
muito superior (JOONYOUNG KIM, YOUNSU KIM, 2014). Uma memória DDR3, muito
comum hoje, utilizada em larga escala, tem um limite máximo de banda de 12.8GB/s, já o
padrão HBM, que está dando os seus primeiros passos na indústria de placas de vídeo, consegue
oferecer um limite máximo de banda de 256GBps (JOONYOUNG KIM, YOUNSU KIM,
2014).
No mercado atual, com recentes lançamentos de novas placas, também já é possível
citar alguns exemplos de placas de vídeo que estão trazendo padrões acima do GDDR5, como
a NVIDIA GeForce GTX 1080 que traz o padrão GDDR5X e a AMD Fury X, que traz o padrão
HBM (High Bandwidth Memory) que já está acima do padrão GDDR5 e tende a ser o padrão
mais utilizado em um futuro próximo, apresentando melhor eficiência energética e maior
largura de banda (JOONYOUNG KIM, YOUNSU KIM, 2014).
1 Tradução livre: Recentemente, OpenCL, um novo padrão de programação aberta para programação GPGPU,
tornou-se disponível, além do CUDA. OpenCL pode suportar vários dispositivos de computação, devido à sua
estrutura mais alta de programação abstração.
13
Uma GPU é construída e projetada desde o começo para desempenhar um
processamento paralelo de matrizes em alta velocidade, dividindo as tarefas para serem
processadas em todos seus CUDA Cores ou Stream Processors. Para exemplo e comparação,
uma recém lançada NVIDIA GeForce GTX 1070 tem 1920 Cuda Cores (NVIDIA, 2016) e uma
AMD R9 Fury X tem 4096 Stream Processors (AMD, 2016).
Um processador, é projetado e desenvolvido para geralmente desenvolver tarefas em
ordem sequencial, apesar de ser mais preventivo que as GPUs atuais e também conseguir
realizar processamento paralelo, porém não tão performático quanto o processamento paralelo
das GPUs. Com apenas alguns núcleos, as CPUs mais comuns contam com 4 núcleos. Para
exemplo e comparação, um processador Intel Core i7 6700K tem 4 núcleos e 8 threads (INTEL,
2016).
Apesar de usarmos o termo core para definir unidades de processamento em GPUs e
CPUs, as diferenças entre eles são inúmeras. Um CPU core possui várias ALUs (Arithmetic
Logic Units) e FPUs (Float Point Units), e também uma série de componentes de controle,
como decodificadores de instruções, cache, unidade de gerenciamento de memória e muitos
outros. Uma GPU também tem muitos desses componentes, mas são compartilhados por várias
unidades de processamento (Cuda Cores ou Stream Processors). As GPUs são constituídas de
um front-end e um back-end. No front-end acontece o recebimento de instruções, e é onde
acontece a distribuição de trabalho para os núcleos, o front-end da GPU é constituído de
decodificadores de tarefas, agendadores de tarefas, registradores, além de um hardware
dedicado a processamento geométrico, por exemplo.
Figura 1 – Diferenças de arquitetura entre CPU e GPU
Fonte: http://www.e2matrix.com/blog/cpu-vs-gpu/
14
O back-end, é responsável por juntar todas as informações processadas e salvar os pixels
na memória da GPU, ele é constituído de ROPs (Render Output Unit), Cache L2 (Cache Level
2), controladores de memória e outros. As unidades de processamento ficam entre o back-end
e front-end realizando todo o trabalho pesado. As GPUs trabalham sob o método de operação
SIMD (Single Instruction, Multiple Data) (FLYNN, 1972), que é um método de operação com
várias unidades operacionais em computação paralela. Neste método de operação, todas as
unidades de processamento recebem uma instrução que são aplicados a diversos dados para
obter mais resultados.
O SIMD é otimizado para o tratamento de conjuntos regulares de dados, como por
exemplo, vetores e matrizes. Os núcleos da GPU possuem menos memória cache, recebem
instruções mais simples e tem uma taxa de clock menor (em comparação com CPUs), no
entanto, são otimizados para fazer mais cálculos como um grupo.
Em CPUs, os cores geralmente trabalham de forma serial, com uma instrução diferente
a cada ciclo. Um núcleo de uma CPU tem que lidar com cada operação que um computador
faz, calcular, buscar memória, I/O (Inputs/Outputs), interrupções, em razão disto, tem um
enorme conjunto de instruções complexas, e para otimizar o desempenho de buscar previsão de
desvios, é utilizado branch prediction. Branch prediction refere-se à capacidade de um CPU
para determinar se um branch será utilizado ou falhará.
Normalmente sob o modelo de execução sequencial, um processador irá executar uma
instrução e, em seguida, executar diretamente a próxima instrução. Um branch é um tipo
especial de instrução que pode dar instruções ao processador para ir ou não ir para uma próxima
instrução. Ao realizar o branch prediction, ele pode adivinhar quais instruções provavelmente
serão executadas com base em se o branch é utilizado ou não é, e em seguida, executá-los.
Se o branch prediction tem uma alta probabilidade de sucesso, então é provável que o
processador será capaz de executar programas de forma mais rápida do que se não tivesse
implementado um branch prediction, porque ele vai gastar menos tempo fazendo o trabalho
que ele não deveria estar fazendo (o que seria o caso, se a predição que o branch prediction
fazer, estiver errada). Já as GPUs não utilizam o branch prediction, porque caso um Cuda Core
ou Stream Processor estiver fazendo algo que não deveria estar fazendo durante um ciclo, as
perdas serão mínimas, levando em conta a quantidade de unidades de processamento que uma
GPU tem, contra um CPU que tem em média 4 núcleos. Os CPU cores também tem uma grande
cache e velocidade de clock rápida. Em CPUs, temos um conjunto de instruções onde
precisamos mais lógica, portanto, mais transistores e mais custo por núcleo em comparação
com uma GPU. No próximo item, o assunto OpenCL será tratado.
15
2.1. OpenCL
O OpenCL (Open Computing Language) é um padrão aberto, de baixo nível, livre de
royalties, para escrita de códigos de programação paralela que funcionem em CPUs e GPUS,
ele inclui uma linguagem baseada em C, além de APIs que são utilizadas para controlar os
softwares desenvolvidos com ele. Incialmente desenvolvido pela Apple e logo após com
colaborações de equipes técnicas da NVIDIA, AMD, Intel e IBM, o grupo de parceiros enviou
uma proposta inicial ao Khronos Group, que é uma ONG americana com foco em criação de
padrões abertos de APIs (Application Programming Interface) gráficas, mídia e computação
paralela. Depois de 5 meses de trabalho do grupo formado pela Apple, o OpenCL foi revisado
por membros do Khronos Group e aprovado, teve sua primeira versão lançada em 8 de
dezembro de 2008 (KHRONOS GROUP, 2016).
OpenCL is a new open programming standard for various compute devices. OpenCL
is used to develop code not only for GPUs, but also for multi-core CPUs, Cell
Broadband Engines, and other compute devices; a programmer can use these compute
devices in a unified way. Thus, it can enable a programmer to avoid writing a vendor-
specific code, resulting in improved code portability.2 (KOMATSU et al., 2010)
A AMD tornou o OpenCL como o padrão único de framework para suas GPUs (AMD,
2016). A NVIDIA oferece a CUDA como padrão e também oferece suporte ao OpenCL
(NVIDIA, 2016). Na nossa implementação, como buscamos uma aplicação que tenha um bom
desempenho e seja compatível com a maioria das plataformas, vamos utilizar o OpenCL.
Como todas as tecnologias, frameworks, linguagens de programação e afins, o OpenCL
tem seus pontos fortes e seus pontos fracos. O ponto mais forte do processamento paralelo, e
consequentemente do OpenCL, é a capacidade de usar todo o poder de processamento de CPUs
e GPUs simultaneamente para aceleramento da computação de dados. Como desvantagem, nem
todos algoritmos são passíveis de paralelização e pode ser muito difícil escrever algoritmos que
não são paralelos e transformá-los em algoritmos paralelizados. Nos casos onde é possível
realizar a paralelização do algoritmo, o OpenCL pode acelerá-los, e o ganho de tempo, na
2 Tradução livre: OpenCL é um novo padrão de programação aberta para vários dispositivos de computação.
OpenCL é usado para desenvolver o código não só para GPUs, mas também para CPUs de vários núcleos, motores
de celulares de banda larga e outros dispositivos de computação; Um programador pode utilizar estes dispositivos
de computação de forma unificada. Assim, pode permitir que um programador evitar escrever um código
específico do fornecedor, resultando em portabilidade de código melhorada.
16
maioria dos casos é muito grande. As possibilidades são incontáveis. Alguns exemplos são:
Descobertas de raízes e otimização, processamento e filtragem de imagens, cálculos de vértice
e vetores para modelos 3D, algoritmos evolutivos como algoritmos genéticos, interação de
partículas, scripts matemáticos (compilar o código escrito no seu tempo de execução) entre
outros. (CMSOFT, 2016).
A arquitetura de funcionamento do OpenCL compreende-se do padrão OpenCL para
desenvolvimento, que é composto por uma unidade de computação, um dispositivo, uma fila
de comandos, um kernel, um item de trabalho e um grupo de trabalho. Como o nome já diz, o
padrão OpenCL é o padrão de desenvolvimento de programação paralela para processadores
modernos. Uma unidade de computação é um dispositivo que tem um ou mais unidades de
processamento, um grupo de trabalho trabalha em uma única unidade de processamento, e uma
unidade de processamento é composta de um ou mais elementos de processamento e memória
local. Uma unidade de processamento também pode ter uma unidade dedicada de filtros e
texturas que podem ser acessadas por seus elementos de processamento. (INTEL, 2016).
Um dispositivo é uma coleção de unidades de processamento. A fila de comandos é
usada para ordenar e enfileirar comandos enviados para um dispositivo. Para exemplo de
comandos podemos citar a execução de kernels ou a leitura e escrita de objetos na memória do
dispositivo. Dispositivos OpenCL geralmente correspondem a uma GPU, uma CPU com
múltiplos núcleos e outros processadores, como DSPs (Digital Signal Processing). (INTEL,
2016).
Figura 2 - Arquitetura do OpenCL.
Fonte: http://www.rastergrid.com/blog/wp-content/uploads/2010/11/opencl_platform_model.png
17
Um kernel é uma função declarada em um programa escrito em OpenCL e executada
em um dispositivo OpenCL. Um item de trabalho é um item de uma coleção de execuções
paralelas de um kernel, executados em um dispositivo por um comando, ele é executado por
um ou mais elementos de processamento e é parte de um grupo que existe em uma unidade de
processamento. Um item de trabalho é distinguido de outras execuções da coleção por seu
identificador global e seu identificador local. (INTEL, 2016).
Um grupo de trabalho é um grupo de itens de trabalho que se executam em uma unidade
de processamento. Os itens de trabalho que estão no mesmo grupo de trabalho, rodam no
mesmo kernel e dividem a mesma memória local e as mesmas barreiras de grupo de trabalho.
Cada grupo de trabalho tem compartilhamento de dados entre itens de trabalho em sua memória
local, sincronização entre itens de trabalho através de barreiras e cercas de memória e funções
especiais já inclusas a nível de grupo de trabalho, por exemplo work_group_copy. (INTEL,
2016).
Figura 3 - Funcionamento do OpenCL.
Fonte: http://i.techweb.com/ddj/images/article/2011/0711/Scarpino2.gif
Uma CPU de múltiplos núcleos ou múltiplas CPUs (em um sistema com mais de um
processador), constituem apenas um dispositivo OpenCL, os núcleos são separados e formam
as unidades de computação. Ao lançar o kernel para execução, o código host define o tamanho
da grade ou o tamanho do trabalho em seu tamanho total. O código host também pode definir
o particionamento para grupos de trabalho, ou deixar para a implementação. Durante a
execução, a implementação cria um item de trabalho para cada ponto da grade e também agrupa
a execução em unidades de processamento, de acordo com o tamanho do grupo de trabalho. A
ordem de execução de itens de trabalho dentro de um grupo de trabalho e a ordem de execução
18
de grupos de trabalhos são específicos de cada implementação realizada em OpenCL. (INTEL,
2016). No próximo item, o assunto aprendizagem de máquina será tratado.
2.2. Aprendizagem de Máquina
A inteligência artificial está diretamente ligada a vida de praticamente toda a população,
presente em todos os lugares, pois é utilizada por diversos serviços e equipamentos eletrônicos,
para realizar sugestões com base no comportamento ou preferência do usuário, entre outras
inúmeras aplicações. O aprendizado de máquina traz uma nova maneira de escrever um
algoritmo e cada vez mais desafios são superados com formas cada vez melhores de
programação (SILVA; VANDERLINDE, 2012).
A aprendizagem de máquina é uma área ligada a Inteligência Artificial, que se dedica
ao desenvolvimento de algoritmos, técnicas e formas que possibilitam que o computador
aprenda, melhorando seu desempenho em uma tarefa específica. Dentro desta área, temos duas
divisões, a aprendizagem dedutiva, que são a aprendizagem de novas informações tomando
como base, algo que já conhecemos. E também temos a aprendizagem indutiva, que é a
inferência indutiva de fatos apresentados por um professor ou um ambiente. Neste tipo de
aprendizagem, um programa aprende a classificar objetos baseados nos rótulos que o professor
ou ambiente lhe apresenta.
The field of machine learning is concerned with the question of how to construct
computer programs that automatically improve with experience. In recent years many
successful machine learning applications have been developed, ranging from data-
mining programs that learn to detect fraudulent credit card transactions, to
information-filtering systems that learn users' reading preferences, to autonomous
vehicles that learn to drive on public highways. At the same time, there have been
important advances in the theory and algorithms that form the foundations of this
field.3 (MITCHELL, 1997).
3 Tradução livre: O campo da aprendizagem de máquina está preocupado com a questão de como construir
programas de computador que melhoram automaticamente com a experiência. Nos últimos anos muitas aplicações
de aprendizagem automática bem-sucedidas têm sido desenvolvidas, desde programas de mineração de dados que
aprendem a detectar transações de cartão de crédito fraudulentas, sistemas de informação e de filtragem que
aprender preferências de leitura dos usuários, a veículos autônomos que aprendem dirigir em estradas públicas.
Ao mesmo tempo, tem havido importantes avanços na teoria e algoritmos que formam as bases deste campo.
19
Conforme Coppin (2010), existem inúmeras formas de aprendizagem de máquina. Entre
elas, a aprendizagem por hábito que tem como principal característica o programa aprender de
acordo com os dados processados anteriormente, mas o programa apenas armazena dados que
podem ser classificados, caso ele não conseguir classificar os dados, este método falhará.
Também há o método de aprendizagem por conceito, onde todas hipóteses são analisadas e a
hipótese correta é demonstrada. No método de aprendizagem por conceito, há uma subdivisão,
chamada de “hipótese mais provável”, que significa, se caso não houver nenhuma hipótese
correta, o algoritmo irá encontrar a hipótese que mais se aproxima do correto, porém estes
métodos de aprendizagem tem um problema comum, nem sempre o usuário deseja saber a
hipótese correta e sim a hipótese mais comum.
Outra forma de aprendizagem de máquina, bastante avançada, é a rede neural, onde essa
rede tem um funcionamento semelhante ao de um cérebro humano, sendo formada de uma
grande rede de neurônios. As RNAs (Redes Neurais Artificias) podem ser compostas de uma
camada ou mais, em redes neurais de apenas uma camada, os dados são mapeados diretamente
em um conjunto de padrões de saída de rede, ou seja, não é possível formar uma representação
interna. Em RNAs de mais de uma camada, a primeira é responsável por receber os dados que
devem ser classificados, usando o aprendizado supervisionado, por modificarem a forma das
conexões de acordo com o que é informado, e depois ativam os neurônios de saída (COPPIN,
2010).
A segunda camada, também chamada de camada intermediária, funcionam como uma
extratora de características, seus dados são uma codificação de características apresentadas na
forma de entrada, na primeira camada, aqui criando um novo padrão, onde permite que a rede
crie sua própria representação do dado de entrada, mais rica e complexa. A terceira camada,
também chamada de camada de saída, recebe os dados da segunda camada, ou camada
intermediária, e constrói o padrão no qual será montada a resposta (USP, 2009). Abaixo temos
uma definição formal de clustering, de acordo com JAIN; MURTY; FLYNN, 1999.
Clustering is the unsupervised classification of patterns (observations, data items, or
feature vectors) into groups (clusters). The clustering problem has been addressed in
many contexts and by researchers in many disciplines; this reflects its broad appeal
and usefulness as one of the steps in exploratory data analysis. However, clustering is
a difficult problem combinatorially, and differences in assumptions and contexts in
different communities has made the transfer of useful generic concepts and
methodologies slow to occur.4
4 Tradução livre: Clustering é a classificação não-supervisionada de padrões (observações, itens de dados, ou
vetores de características) em grupos (clusters). O problema de agrupamento foi abordado em muitos contextos e
20
Em aprendizagem de máquina, uma área de muita importância, é o clustering, ou análise
de grupos, uma análise de similaridade entre objetos, para a formação de grupos de objetos mais
similares, uma técnica comum para a análise de dados, utilizada em muitos campos de atuação,
como a aprendizagem de máquina, reconhecimento de padrões, computação gráfica,
recuperação de informações, análise de imagens, compressão de dados, bioinformática,
marketing, biologia e muitas outras áreas. No próximo item, o assunto algoritmos de
agrupamento será tratado.
2.2.1. Algoritmos de Agrupamento
Algoritmos de agrupamento são algoritmos que particionam um conjunto de objetos ou
dados em agrupamentos, onde normalmente os objetos são descritos e agrupados usando um
conjunto de atributos e valores, onde não existe nenhuma informação sobre a classe ou categoria
dos objetos. O principal objetivo dos algoritmos de agrupamento é colocar os objetos similares
no mesmo grupo e objetos não similares em grupos diferentes. Eles são utilizados em diversas
áreas, assim como a aprendizagem de máquina, são utilizados em tarefas como, agrupamento
de documentos (textos) similares, identificação de grupos em redes sociais, segmentação de
clientes identificação de plantas ou animais com características comuns (MITCHELL, 1997).
Dentro a área de algoritmos de agrupamento, podemos separar eles em dois tipos
“principais”, os não hierárquicos ou planos, e os hierárquicos. O agrupamento hierárquico ou
plano, contêm um certo número de agrupamento e a relação entre os agrupamentos é geralmente
não determinada, a maioria dos algoritmos de agrupamento não hierárquicos são iterativos. Eles
iniciam com um conjunto inicial de agrupamentos e realocam os objetos em cada agrupamento
de maneira iterativa, até determinada condição de parada. O algoritmo de agrupamento plano
utiliza-se de suas diversas iterações para realocar os objetos nos melhores agrupamentos, onde
se encaixam por similaridade. Deve ser utilizado onde a eficiência é um atributo importante e
se o conjunto de dados é muito grande, e o algoritmo K-means é o método mais simples e deve
ser usado sobre novos conjuntos de dados, porque os resultados geralmente são suficientes
(WEIKUM, 2002).
por pesquisadores em muitas disciplinas; isso reflete seu amplo apelo e utilidade como um dos passos na análise
exploratória de dados. No entanto, o agrupamento é um problema difícil combinatória, e as diferenças de
pressupostos e contextos em diferentes comunidades tem feito a transferência de conceitos genéricos úteis e
metodologias lentas para ocorrer.
21
O critério de parada do K-means é baseado na qualidade dos agrupamentos
(similaridade média e cálculo para informação comum entre agrupamentos). Também é
necessário determinar o número de agrupamentos. Além da divisão de hierárquico ou não
hierárquico, temos a divisão de abordagens entre os algoritmos, os quais podem ser soft ou
hard. Na abordagem hard, cada objeto é inserido em apenas um agrupamento, já na soft, o
mesmo objeto pode ser inserido em vários agrupamentos com diferentes níveis de pertinência.
Em agrupamentos hierárquicos, geralmente a abordagem é hard, e em agrupamentos planos ou
não hierárquicos, ambos tipos de abordagens são comuns (WEIKUM, 2002).
O agrupamento hierárquico é representado por uma árvore, onde os nós folhas são os
objetos e cada nó intermediário representa o agrupamento que contêm todos os objetos de seus
descendentes. Os algoritmos de agrupamentos hierárquicos também só fazem sentido se a
função de similaridade é monotônica decrescente das folhas para a raiz da árvore. Sendo assim,
o agrupamento hierárquico é a melhor abordagem para análise exploratória de dados, fornece
mais informação do que o método de agrupamento plano, porém ao mesmo tempo é menos
eficiente do que o método de agrupamento não hierárquico, na questão de recursos como tempo
e memória gastos(WEIKUM, 2002).
O algoritmo K-Means, que é um algoritmo plano ou não hierárquico, baseia-se na
minimização de uma medida de custo, a distância interna entre os objetos do grupo. Ele é um
método de clustering que tem como objetivo particionar n observações dentro de k grupos, onde
cada observação pertence ao grupo mais próximo da média. A sua minimização do custo
garante encontrar um mínimo local da função objetivo, que dependerá do ponto inicial do
algoritmo. O K-means pode ser chamado de um algoritmo “não-convexo”, pois a cada iteração
realizada, o valor da distorção é diminuído, visto que o resultado final do mesmo, depende do
ponto inicial utilizado pelo algoritmo. Uma derivação do algoritmo K-Means, é o ISODATA,
uma modificação do algoritmo K-means. (MAJI; PAUL, 2014). Uma definição do
funcionamento do K-means é descrita abaixo, conforme a Phonetics Science, 2014.
Initially k number of so called centroids are chosen. A centroid is a data point
(imaginary or real) at the center of a cluster. In Praat each centroid is an existing data
point in the given input data set, picked at random, such that all centroids are unique
(that is, for all centroids ci and cj, ci ≠ cj). These centroids are used to train a kNN
classifier. The resulting classifier is used to classify (using k = 1) the data and thereby
produce an initial randomized set of clusters. Each centroid is thereafter set to the
arithmetic mean of the cluster it defines. The process of classification
and centroid adjustment is repeated until the values of the centroids stabilize. The
22
final centroids will be used to produce the final classification/clustering of the input
data, effectively turning the set of initially anonymous data points into a set of data
points, each with a class identity.5
Figura 4 – Exemplo de funcionamento do algoritmo de agrupamento K-means.
Fonte: http://jblomo.github.io/datamining290/slides/img/kmeansclustering.jpg
Na figura 4, é exemplificada a forma de execução do algoritmo, onde é lido pelo
algoritmo o número requisitado de clusters (K), que serão os centróides, onde o K-means irá
calcular a distância dos objetos a cada centróide, e agrupar os objetos baseado na distância
mínima do objeto ao centróide, em caso de nenhum objeto se mover de grupo, a iteração é
finalizada, apresentando os resultados (o número requisitado de K).
Este algoritmo pode ser aplicado em diversos ambientes, onde temos muitos dados e
precisamos ter uma visão geral do que está acontecendo, uma forma rápida de separar dados,
onde é necessário ter um grupo de itens similares onde todos os itens estão desorganizados.
5 Tradução livre: Inicialmente o número k dos chamados centroides são escolhidos. Um centróide é um ponto de
dados (imaginário ou real) no centro de um agrupamento. Em Praat cada centróide é um ponto de dados existentes
no determinado conjunto de dados de entrada, escolhidos aleatoriamente, de modo que todos os centróides são
únicas (ou seja, para todos os centróides ci e cj, ci ≠ cj). Estes centróides são usados para treinar um classificador
kNN. O classificador resultante é utilizado para classificar (usando k = 1) os dados e, assim, produzir um conjunto
aleatório inicial de clusters. Cada centróide é depois ajustado para a média aritmética do conjunto que define. O
processo de classificação e centróide ajuste é repetido até que os valores dos centroides se estabilizem. Os
centroides finais serão usados para produzir a classificação final / agrupamento dos dados de entrada,
transformando de forma eficaz o conjunto de pontos de dados anónimos inicialmente num conjunto de pontos de
dados, cada um com uma identidade de classe.
23
Para exemplificar este pensamento de ordenação de dados desorganizados, ele pode ser
aplicado na área de Marketing, para encontrar grupos de clientes com comportamento similar,
na área de Biologia, para classificação de plantas e animais de acordo com suas características,
em livrarias para ordenação de livros, na internet para classificação de documentos, e
processamento de acessos para identificar padrões de acessos dos usuários, no planejamento de
cidades, para identificar grupos de casas de acordo com o tipo da casa, valor e localização
geográfica, em estudos de terremotos para observar os epicentros dos terremotos para
identificar zonas perigosas, entre outras diversas possíveis aplicações do mesmo (DEIB, 2017).
Figura 5 – Demonstração do estado dos dados a cada iteração do K-means.
Fonte: http://jblomo.github.io/datamining290/slides/img/kmeansclustering.jpg
Na figura acima temos um exemplo visual de como o K-means trata os dados a cada
iteração, calculando a distância do objeto ao centróide a cada iteração do algoritmo.
O K-means apresenta vantagens nos termos de facilidade e eficiência. É rápido para
cálculos simples, possibilitando o processamento sequencial dos dados, o que causa baixa
quantidade de informações a serem processadas, sua desvantagem é a sua dependência dos
valores de k, da ordem em que as amostras são processadas, da escolha dos primeiros centros
de agrupamento, e da geometria das amostras prontas para análise. Em alguns casos específicos,
24
a utilização do algoritmo K-means requer a experimentação com vários valores de k e várias
escolhas dos parâmetros inicias. (MAJI; PAUL, 2014). No próximo capítulo, o assunto
tratamento de ataques DdoS e algoritmos de aprendizagem de máquina será tratado.
25
3. TRATAMENTO DE ATAQUES DDOS E OTIMIZAÇÃO DE
ALGORITMOS DE APRENDIZAGEM DE MÁQUINA
Distributed denial-of-service attacks, popularmente conhecidos como DDoS, são
ataques distribuídos de negação de serviço, que tem como objetivo sobrecarregar um serviço
ou servidor, para que o mesmo fique indisponível. Eles se tornaram mais conhecidos após este
tipo de ataque ter sido utilizado para derrubar serviços muito populares, como a Playstation
Network ou o Xbox Live, afetando milhões de usuários. Este tipo de ataque representa um risco
imenso para a Internet, sendo assim, vários mecanismos de defesa têm sido utilizados para
combatê-los. Os atacantes modificam constantemente suas ferramentas para contornar esses
sistemas de segurança já existentes, e as ferramentas são frequentemente modificadas para
poder lidar com novos ataques, criando uma busca infinita por um sistema perfeito de proteção
contra-ataques de negação de serviço. (GUPTA; DHIMAN, [s.d.]). No próximo item
abordaremos as técnicas existentes para a proteção e mitigação de ataques DDoS.
Figura 6 - Funcionamento básico de um ataque DDoS.
Fonte: https://assets.paessler.com/media/scales/lightbox/common/files/blog/2017/ddos-attack-infographic.png
Na Figura 6, apresentada acima, temos uma explicação gráfica de como funciona um
ataque DdoS básico, onde muitos acessos a um serviço ou servidor ocorrem, causando uma
sobrecarga ao servidor.
26
3.1. Técnicas existentes
Ataques de negação de serviço estão sendo cada vez mais frequente, e são uma ameaça
para a produtividade e rentabilidade da internet, uma ameaça para grandes portais de comércio
eletrônico, mecanismos de busca, redes sociais, geralmente focando serviços mais famosos e
em uma época de fragilidade no sistema, como em uma Black Friday (para lojas de comércio
eletrônico), ou uma grande promoção para lojas de jogos digitais (como a Steam Summer Sales).
É um método de ataque relativamente simples, e ao mesmo tempo, uma técnica muito poderosa
para atacar recursos e serviços. (ASOSHEH; RAMEZANI, 2008)
Na internet, facilmente encontramos toolkits extremamente sofisticados, com interface
amigável facilmente entendida por um usuário comum (ou leigo), onde geralmente é necessário
apenas a inserção do endereço da vítima e o ataque é iniciado. Isso acarreta em um grande
aumento na chance de sermos vítimas de um ataque DoS ou DDoS. (DOULIGERIS;
MITROKOTSA, 2004)
Como DDoS significa ataques distribuídos de negação de serviço, significa que existem
mais do que um objeto, ou vários objetos, que são os DoS (denial-of-service), enviados a um
único destino, visando causar lentidão no acesso ao serviço, reduzindo a qualidade do serviço
oferecido ou negar o acesso ao mesmo, esse ataque pode ser tanto humano, em grande
quantidade de ataques, ou automatizado. Durante um ataque DDoS, os pacotes de ataque vêm
de dezenas ou centenas de endereços diferentes, em vez de apenas um endereço como um ataque
DoS padrão. Para realizar a proteção contra um ataque DoS, o método de proteção é
relativamente simples, é necessário apenas monitorar o volume de pacotes proveniente de um
único endereço ou rede única, então, bloquear o acesso da mesma ao serviço. (GUPTA;
DHIMAN, [s.d.])
Para conseguir realizar uma sobrecarga no servidor alvo, o atacante precisa ter um poder
relativamente alto de enviar requisições a um servidor, o que é normalmente conquistado
através de um grande número de invasão de máquinas comuns, chamadas de “máquinas
zumbis”, que integram uma rede zumbi, que é comandada por uma máquina mestre.
Posteriormente instruir todas as máquinas invadidas a atacar o servidor alvo, com intenção de
esgotar seus recursos e indisponibilizar os serviços oferecidos pelo alvo. Em fevereiro de 2000
uma série de ataques de negação de serviço ocorreram, tendo alvos populares, como a
CNN.com, yahoo.com, eBay.com, amazon.com, por várias horas. (GUPTA; DHIMAN, [s.d.])
Analistas estimam que durante o tempo em que o Yahoo ficou indisponível, houve uma
perda de receita de aproximadamente US$ 500.000. Já a Amazon, sofreu outro ataque de
27
negação de serviço e ficou off-line aproximadamente 10 horas, o que resultou em uma perda de
receita de aproximadamente US$ 600.000. Durante estes ataques DDoS, a CNN.com teve
apenas 5% do volume normal de acessos, enquanto nos outros sites, o serviço ficou
praticamente inacessível. (GUPTA; DHIMAN, [s.d.])
Os ataques DDoS podem ser divididos em três tipos, os ataques baseados em volume,
os ataques baseados em ataques de protocolo e os ataques baseados em ataques na camada de
aplicação. Ataques baseados em volume incluem floods UDP, floods ICMP, e outros floods de
pacotes falsificados. O objetivo deste ataque é saturar a banda do site, serviço ou rede atacada,
e sua magnitude é mensurada em bits por segundo (bps). Os ataques baseados em protocolo,
incluem floods SYN, ataques de pacotes fragmentados, ping da morte, Smurf DDoS e outros.
Este tipo de ataque consome os recursos do servidor, ou dos seus equipamentos de comunicação
intermediária, como firewalls, balanceadores de carga, e o ataque é mensurado em pacotes por
segundo. (INCAPSULA, 2016).
Já o terceiro tipo de ataque, o ataque baseado em camada de aplicação, incluem ataques
baixos e lentos, flood de requisições de método GET/POST, ataques direcionados a possíveis
vulnerabilidades do sistema vítima, como o Apache, Windows ou OpenBSD. Composto de
requisições aparentemente inocentes e legítimas, o objetivo deste ataque é indisponibilizar o
uso do servidor web, deixando-o off-line, e sua magnitude é mensurada em solicitações por
segundo (INCAPSULA, 2016).
Alguns específicos, populares e particulares tipos de ataques são: Flood UDP, Flood de
ping ICMP, Flood SYN, Ping da Morte, Slowloris, Amplificação NTP, Flood HTTP e o Dia
Zero. O Flood UDP, faz proveito do protocolo UDP (User Datagram Protocol), um protocolo
sem sessão de rede. Este tipo de ataque inunda portas aleatórias em um host remoto com
inúmeros pacotes UDP, fazendo com que o host pare para verificar repetidamente a aplicação,
e quando nenhuma aplicação for encontrada, deve responder com um destino do pacote ICMP
inacessível. Este processo acaba por esgotar os recursos do host vítima, e em última instância
leva a inacessibilidade do serviço (INCAPSULA, 2016).
O flood de ping ICMP (Internet Control Message Protocol), é semelhante ao Flood
UDP, ele também realiza uma inundação ICMP, que oprime o recurso de destino com uma
requisição ping ICMP, geralmente enviando pacotes o mais rápido possível sem esperar por
respostas do host vítima. Esse tipo de ataque consome a banda de entrada e saída, uma vez que
os servidores da vítima, muitas vezes tentará responder com pacotes de resposta ICMP,
resultando numa desaceleração significativa no sistema (INCAPSULA, 2016).
28
Já o Flood SYN, explora uma fraqueza conhecida na conexão TCP, o three-way
handshake, onde um pedido SYN inicia uma conexão TCP com um host e deve ser respondida
com uma resposta do tipo SYN-ACK daquele host, e então, deve ser confirmado por uma
resposta ACK do solicitante. Em um cenário de Flood SYN, o atacante envia várias solicitações
SYN, mas não responde a resposta SYN-ACK, enviada pela vítima, ou envia os pedidos SYN
de um endereço de IP spoofed. Assim, a vítima continua a aguardar por uma confirmação para
cada um dos pedidos, até que os recursos sejam esgotados, resultando em uma negação de
serviço (INCAPSULA, 2016).
O ping da morte, também conhecido como POD (Ping of Death), é onde o atacante envia
vários pings malformados e mal-intencionados para a vítima. O tamanho máximo de um pacote
IP (incluindo seu cabeçalho) é de 65.535 bytes. No entanto, a camada de enlace, geralmente
coloca limites para o tamanho máximo do quadro, por exemplo, 1500 bytes através de uma rede
ethernet. Neste caso, um grande pacote IP é divido em vários pacotes IP (também chamados de
fragmentos), e o host recipiente reagrupa os fragmentos IP, para cada pacote IP completo. Em
um cenário de ataque DDoS do tipo ping da morte, após a manipulação maliciosa do conteúdo
dos fragmentos, o destinatário acaba com um pacote IP maior do que 65.535 bytes, quando
reagrupado no host recipiente. Isso pode estourar o uso de memória alocada para o pacote,
causando negação de serviço para pacotes legítimos (INCAPSULA, 2016).
O Slowloris, é um ataque altamente segmentado, permitindo que um servidor web
derrube outro servidor web, sem afetar outros serviços ou portas na rede alvo. Ele faz isso
mantendo o maior número de conexões abertas com o servidor web alvo, mas enviando apenas
um pedido parcial. O Slowloris constantemente envia mais cabeçalhos HTTP, mas nunca
completa um pedido. O servidor de destino, mantém cada uma dessas conexões falsas abertas.
Eventualmente, o número máximo de conexões simultâneas é estourado, o que conduz a
negação de conexões adicionais de clientes legítimos (INCAPSULA, 2016).
No ataque de tipo Amplificação NTP (Network Time Protocol), o autor do ataque
explora servidores NTP publicamente acessíveis, para sobrecarregar o servidor alvo com
tráfego UDP. Em um ataque de amplificação NTP, a proporção de query para resposta é algo
entre 1:20 até 1:200 ou mais. Isso significa que qualquer atacante que obter uma lista de
servidores NTP abertos (usando uma ferramenta como Metasploit, ou dados do Open NTP
Project), pode facilmente gerar uma devastadora banda de alta largura, um ataque DDoS de alto
volume (INCAPSULA, 2016).
Em um DDoS de tipo Flood HTTP, o atacante explora o uso de requisições GET/POST,
para atacar um servidor web ou aplicativo. O Flood HTTP não usa pacotes malformados,
29
técnicas de falsificação ou de reflexão, e requerem menos banda do que outros tipos de ataques
para derrubar o servidor, serviço ou rede alvo. O ataque geralmente é mais eficaz quando se
força o servidor a responder requisições que exigem mais processamento e dados retornados do
servidor, a cada requisição efetuada. Os ataques Dia Zero (ou Zero-day), são ataques
simplesmente desconhecidos ou novos, que exploram vulnerabilidades onde nenhum patch foi
liberado com a correção. O termo Dia Zero é bem conhecido entre os membros da comunidade
hacker, onde a prática de negociação de vulnerabilidades tornou-se uma atividade popular.
(INCAPSULA, 2016).
Como o DDoS é um método de ataque relativamente simples de executar e bastante
poderoso, grandes empresas normalmente tem uma abordagem de defesa composta de várias
camadas, já que não existem contramedidas reais e totalmente eficazes contra o ataque.
Empresas menores normalmente contratam serviços eficazes de terceiros, como por exemplo,
a CloudFlare ou MaxCDN, também, dependendo do seu caso de uso, pode ser um provedor de
nuvem, uma CDN (Content Delivery Network), uma solução baseada em BGP (Border
Gateway Protocol) ou uma solução baseada em DNS (NETWORK WORLD, 2016).
Na criação de várias camadas de proteção contra DDoS, estas são algumas opções
comumente utilizadas: contrato de banda excessiva, mitigação automatizada, upstream
blackholing, provedor de terceiros e um endurecimento de sistema. Estas ações visam garantir
a escalabilidade de banda, acompanhamento de métricas de desempenho, e métodos de detecção
de ataques. O contrato de banda excessiva é bastante simples, geralmente o contrato de uma
banda bastante acima do necessário é contratado pela empresa, que irá dar conta do crescimento
da empresa, dos acessos e também do DDoS. Se o atacante for incapaz de reunir tráfego o
suficiente para sobrecarregar toda essa banda, seu ataque vai ser geralmente ineficaz
(NETWORK WORLD, 2016).
Na mitigação automatizada, muitas ferramentas monitoram os dados trafegados pela
rede, e outras fontes de dados, onde uma linha base de tráfego é determinada. Se os padrões de
tráfego saem das zonas delimitadas, as ferramentas de mitigação DDoS atraem o tráfego para
elas, utilizando BGP ou outros mecanismos para filtrar este “ruído”. Após essa limpeza nos
dados, os dados limpos são passados para a rede. Este tipo de ferramenta geralmente pode
detectar ataques volumétricos, e ataques mais insidiosos, como o Slowloris. Os métodos
Upstream Blackholing, são maneiras de filtrar o tráfego UDP utilizando um router blackholing
(NETWORK WORLD, 2016).
Há casos onde a infraestrutura da empresa não tem necessidade de receber tráfego UDP,
NTP ou DNS, para dentro de sua infraestrutura, então, uma espécie de buraco negro é criada
30
para este tipo de tráfego. Os maiores ataques volumétricos são geralmente refletidos em NTP
ou ataques de amplificação DNS. Mesmo empresas bastante grandes temem um ataque de
largura de banda muito alta, como 300Gbps. Muitas vezes, um sistema de redirecionamento
DNS é implementado, ou um serviço baseado em BGP, para a proteção, no caso de um ataque
sustentado (NETWORK WORLD, 2016).
Na parte de endurecimento de sistemas, é tratada toda a parte de configuração de
sistemas operacionais, configuração e segurança de aplicativos para serem mais resistentes a
camada de aplicação de ataques DDoS. Coisas como, garantir que o servidor Linux tenha inodes
suficientes para configurar o número correto de worker threads do Apache, o que faz com que
fique mais difícil para o atacante derrubar o serviço que está sendo protegido (NETWORK
WORLD, 2016).
Dado o aumento do tamanho, frequência e escala de ataques DDoS, o planejamento para
a detecção de ataques DDoS, sua mitigação é uma prioridade crítica de negócios. Uma vez que
é virtualmente impossível construir uma infraestrutura suficiente para a escala em resposta a
um ataque DDoS grande, normalmente as CDNs fornecem ferramentas de proteção contra-
ataques DNS, estas ferramentas mitigam os ataques DDoS, absorvendo todo o tráfego DDoS
voltado para a camada de aplicação, desviando todos ataques DDoS direcionados a camada de
rede, tais como Flood SYN ou Flood UDP, e realiza uma autenticação de tráfego válido na
borda da rede. Esta proteção interna fica "sempre ligada", e apenas o tráfego da porta 80 (HTTP)
ou da porta 443 (HTTPS) é permitido. Para proteção adicional, muitas organizações adicionam
uma camada de defesa que protege o Domain Name Server (DNS) que está sendo
sobrecarregado e comprometida por ataques de negação de serviço (AKAMAI, 2016). No
próximo item abordaremos a otimização de técnicas existentes utilizando GPU.
3.2. Otimização de algoritmos de aprendizado de máquina utilizando GPU
Muitas soluções acadêmicas concentram-se exclusivamente na questão de como tráfego
de rede de pode ser agrupado de maneira eficiente. Erman; Arlitt, 2006, examinaram alguns
algoritmos de mineração de dados existentes: Agrupamento de aplicações com ruído baseado
na densidade espacial (DBSCAN), K-Means e AutoClass. Os algoritmos são avaliados e
comparados do ponto de precisão do tráfego de cluster em classes de tráfego conhecidas, então
do ponto de algoritmo de velocidade e o número de clusters que é produzido. McGregor et al.,
2004, também aplicaram técnicas de aprendizagem de máquina para agrupar cabeçalhos de
31
pacote de rede. Os autores mostraram uma correspondência adequada entre os tipos de tráfego
conhecidas em traços, tais como HTTP, SMTP, IMAP ou TCP DNS e as classes de tráfego
obtidas pelo agrupamento dos dados.
No entanto, os algoritmos de mineração de dados comuns não são a melhor escolha para
agrupar os dados de tráfego de rede. Em primeiro lugar, os conjuntos de dados de tráfego têm
tamanho maior comparado com os conjuntos de dados comuns em mineração de dados. Em
segundo lugar, com a finalidade de defesa DDoS, o tráfego de rede muitas vezes precisa ser
examinado em tempo real, o que significa que o cluster deve ser aplicado ao fluxo de dados.
Algoritmos de mineração de dados comuns são lentos para tal tarefa, ou exigiriam tão altos
recursos que não estão disponíveis em dispositivos de rede de computação. Terceiro, as
características tais como endereços IP e URLs de tráfego, tem uma estrutura hierárquica
específica. Assim, os pesquisadores desenvolveram algoritmos específicos para realizar o
agrupamento (clustering) do tráfego de rede.
Cormode et al., 2016, desenvolveram o algoritmo de pesos pesados hierárquico (HHH
- hierarchical heavy hitters algorithm), que é uma extensão do algoritmo de pesos pesados e
leva em conta a estrutura hierárquica do tráfego de rede. Os autores também forneceram versões
aproximadas do algoritmo de HHH que são suficientemente rápidas para agrupar o fluxo de
dados. Provas teóricas sobre os limites aproximados de erro para os algoritmos são fornecidos.
Hijazi et al., desenvolveram outro algoritmo que leva em consideração as caraterísticas e
especificações do trafego de rede. O algoritmo é nomeado agrupamento aproximado de divisão
hierárquica (ADHIC). O ADHIC é um algoritmo adaptativo uma vez que os recursos utilizados
durante a aglomeração, chamada (p,n)-grams, são escolhidos em função da estrutura do
conjunto de dados particular.
(P, n) -grams são definidos como “uma cadeia de bytes de comprimento n localizado a
uma p compensado em um pacote dentro de um fluxo de dados.” Os autores do algoritmo
ADHIC também desenvolveram uma implementação do algoritmo rápido e leve destinado para
o streaming dados que é chamado de netADICT (AURA; LAUD; LUKAYENKO, 2011).
Conforme Aura; Laud; Lukayenko, 2011, os conjuntos de dados trafegados pela rede
têm um tamanho maior comparado com os conjuntos de dados comuns em mineração de dados,
precisam ser analisados em tempo real e para realizar o clustering dos mesmos, os equipamentos
de uma rede normalmente não tem poder computacional suficiente, para que o ataque DDoS
seja detectado e para realizar uma mitigação e defesa contra o ataque, antes que a rede ou
serviço fique indisponível.
32
Para contornar tal adversidade, neste trabalho é sugerido o uso de GPGPU, juntamente
com o uso de algoritmos de aprendizagem de máquina. Normalmente sistemas GPGPU tem um
poder computacional muito superior a equipamentos de rede, suprindo a necessidade de alto
poder computacional. Também, é sugerido neste trabalho o uso do framework OpenCL, no qual,
o algoritmo K-Means será portado e testado em um ambiente de rede simulado, para análise de
desempenho do algoritmo paralelizado rodando em GPU.
33
4. PROPOSTA METODOLÓGICA
Apresentaremos neste item a proposta metodológica desta pesquisa, iniciando pela
descrição do tipo de pesquisa realizado, que foi uma pesquisa exploratória de caráter
qualitativo, a forma de coleta dos dados e como eles serão analisados.
Além disso, realizaremos uma definição da ferramenta utilizada no estudo, o OpenCL,
que é um framework especializado em processamento paralelo e multiplataforma, o que
possibilita a otimização de algoritmos que podem ser paralelizados.
4.1. Tipo da pesquisa
Segundo Selltiz et. al (1967) apud Gil (2008), as pesquisas podem ser classificadas em
três grupos que são: exploratórias, descritivas e, conforme denominação do autor, explicativas.
Utilizaremos a metodologia de pesquisa exploratória que, segundo Gil (2008), tem como
principal finalidade a aproximação e familiarização do problema, bem como o esclarecimento,
desenvolvimento e modificação de conceitos. Ainda, segundo o autor, essas pesquisas
"envolvem levantamento bibliográfico e documental, entrevistas não padronizadas e estudos de
casos". Neste sentido as mesmas têm, também, como objetivo "proporcionar visão geral, de
tipo aproximativo, acerca de determinado fato" (GIL, 2008).
Ainda se faz necessário afirmar que esta pesquisa exploratória será de caráter qualitativo
que, pode “descrever a complexidade de determinado problema, analisar a interação de certas
variáveis”. As pesquisas de abordagem qualitativa se diferem das pesquisas quantitativas, que
são criticáveis, uma vez que não empregam instrumentos estatísticos como base de pesquisa.
Ainda segundo o autor, as pesquisas de caráter qualitativo têm como objeto de pesquisa
situações complexas ou particulares e este método possibilita “descrever melhor a
complexidade dos problemas” (RICHARDSON, 1999).
Sendo assim, define-se esta pesquisa como exploratória, de caráter quantitativo, onde se
visa identificar e esclarecer a influência direta do uso do framework OpenCL e processamento
em GPU dentro de cenários de rede.
34
4.2. População e amostra
Seguindo a linha de pensamento desta pesquisa, a aplicação e testes da mesma foi
realizada em um cenário simulado de ataque DDoS, com dados dimensões aleatórias em cada
item, realizando a comparação de desempenho entre CPU x GPU.
Neste caso em específico, não teremos população, já que os resultados dependem do
desenvolvimento do software que, a partir deste momento, serão realizadas as comparações e
amostras, iniciando da comparação do desempenho do próprio algoritmo desenvolvido,
rodando em plataformas diferentes, já que o OpenCL nos permite rodar o mesmo código em
diversas plataformas.
Após realizar a comparação de desempenho entre as plataformas, com foco em GPU x
CPU, foram realizadas comparações de desempenho com os resultados apresentados. Foram
analisadas características como: desempenho, viabilidade de aplicação da solução no meio
corporativo, entre outros.
4.3. Coleta de dados
A coleta de dados é formada por diversas técnicas que são a parte prática da mesma,
estas técnicas são definidas como um conjunto de regras ou processos que são utilizados pela
ciência (LAKATOS, MARCONI, 2001). O método de pesquisa consiste em uma escolha de
procedimentos sistemáticos para a descrição e explicação dos fenômenos ocorridos
(RICHARDSON, 1999). Em pesquisas exploratórias, não é comum a utilização de hipóteses,
ou, quando existem, serem pouco definidas (AAKER, 2004). De acordo com isto, este estudo
não irá buscar definir hipóteses sobre a análise a ser feita, muito menos trabalhar com dados
qualitativos, mas sim com uma análise, entendimento e esclarecimento dos dados agrupados de
acordo com o problema de pesquisa definido neste trabalho.
As pesquisas de cunho exploratório utilizam-se de métodos que buscam diagnosticar
situações, explorar alternativas ou buscar novas ideias (ZIKMUND, 2001).
De acordo com os objetivos desta pesquisa, já descritos na mesma, foram realizadas
medições sobre o software, como o tempo em que o mesmo leva para fazer todo o
processamento necessário, o processamento utilizado pelo mesmo, a viabilidade de utilização
no meio corporativo.
35
Para a captura de dados foi utilizado o software proposto neste trabalho, com dados
gerados de forma aleatória como instrução para o algoritmo, após a captura e processamento
dos dados realizados pelo software, foi utilizada a técnica da observação, que consiste em
aplicar atentamente os sentidos físicos a um amplo objeto, para dele adquirir um conhecimento
claro e preciso (CERVO, BERVIAN, 2002 apud OLIVEIRA 2011). Com isso a observação se
torna vital para o progresso da pesquisa, tornando-o válido e não apenas uma "suposição". A
observação também é considerada uma coleta de dados para conseguir informações sob
determinados aspectos da realidade (OLIVEIRA, 2011).
4.4. Análise dos dados
A análise dos dados pode ser definida como uma das fases mais importante da pesquisa,
pois é a partir dela que serão apresentados os resultados e a conclusão da pesquisa. Conforme
citado no tópico anterior, os dados serão coletados a partir da observação do desempenho da
solução pretendida neste trabalho, comparando seu desempenho sendo utilizado em GPU x
CPU, e também comparado contra soluções utilizadas hoje em dia. Após comparar
características como custo, desempenho, viabilidade, aplicabilidade no ambiente corporativo,
o resultado deste trabalho será apresentado.
A ferramenta proposta é um software desenvolvido em OpenCL, com foco em uso em
sistemas GPGPU, com proposta de melhoria de desempenho sobre softwares que rodam em
CPU e que podem ser paralelizados. Como o OpenCL é multiplataforma, diversas comparações
de desempenho se tornam possíveis, além da comparação com outras ferramentas que existem
no mercado.
Para analisar os dados, foi realizado um cluster de todos os acessos (itens) e suas
características (dimensões). Para realizar o cluster dos dados de tráfego, o algoritmo K-means
foi escolhido pela aplicabilidade em qualquer ambiente onde pode ser lidado com números,
além da relativa facilidade de implementação, outros algoritmos de agrupamento tendem a ser
mais custosos no quesito de hardware. A ferramenta trabalha com dados de tráfego simulado
de rede, a fim de testar as diferenças de desempenho em GPU com uma larga quantidade de
dados.
36
5. DETALHAMENTO E RESULTADOS
Após realizar a implementação do KMeans em OpenCL, para simular um ambiente de
rede, foram utilizadas 5 dimensões em cada item. As dimensões fazem referência as
informações encontradas nos pacotes de rede, como por exemplo a duração do acesso, o
tamanho do pacote, o protocolo do pacote, o endereço de destino, o endereço de saída, etc. No
desenvolvimento do algoritmo, foi implementada uma função que gera dados aleatórios de
acordo com a especificação (recebida pelos parâmetros), para facilitar a comparação de
desempenho. A distância entre os pontos e os clusters utilizada, foi a distância euclidiana. Na
imagem abaixo é apresentado um diagrama do código que foi desenvolvido no algoritmo.
Figura 7 – Demonstração de um diagrama da implementação do K-means paralelo realizado.
Fonte: Desenvolvido pelo autor.
37
Observando o diagrama de execução do código desenvolvido, podemos observar que os
passos que exigem mais processamento (cálculo das distâncias para cada item e processamento
de cada item para verificar qual seu cluster (K) atual) , foram paralelizados, para possibilitar a
distribuição de carga de trabalho para a GPU. Abaixo temos uma tabela com todos os
parâmetros disponíveis para realizar a execução do algoritmo.
Tabela 1 – Explicação sobre os parâmetros que podem ser utilizados no algoritmo desenvolvido
Fonte: Desenvolvido pelo Autor
Parâmetro Função
-dataset_file Arquivo de entrada (txt, csv)
-output_file Arquivo de saída (resultados)
-g1 Rodar em modo OpenCL
CPU
-d num_sample
num_dims num_clusters
Parâmetro para gerar dados
aleatórios, passando número
de itens, dimensões e clusters
-num_clusters Número de clusters
(agrupamentos).
Observando a tabela acima, são listadas todas as configurações possíveis para rodar no
algoritmo via parâmetros na chamada de execução. Os parâmetros foram desenvolvidos desta
forma, pensando em facilitar a comparação entre desempenho de GPU e CPU. Na tabela abaixo
temos a explicação do que cada dimensão significa para um item.
Tabela 2 – Explicação sobre o significado das dimensões de cada item
Fonte: Desenvolvido pelo Autor
Dimensão Significado
1 Tipo do pacote
2 Tamanho do pacote
3 Duração do acesso
4 Porta de origem
5 Porta de destino
Observando a tabela acima temos os dados que foram clusterizados de forma simulada
no algoritmo, utilizando o parâmetro –d. Para testes, foi utilizado 1 item com 5 dimensões,
simulando um pacote (ou acesso a um sistema) com suas características (listadas acima). Na
38
tabela abaixo podemos observar e comparar o desempenho obtido na solução rodando em GPU
e CPU.
Tabela 3 – Resultados da comparação da execução do algoritmo em CPU e GPU
Fonte: Desenvolvido pelo Autor
Itens Dimensões Clusters Tempo em GPU Tempo em CPU Melhoria
1.000.000 5 10 47 segundos 333 segundos 7,1x
500.000 5 10 24 segundos 168 segundos 7x
250.000 5 10 19 segundos 130 segundos 6,8x
125.000 5 10 11 segundos 73 segundos 6,6x
62.500 5 10 5 segundos 32 segundos 6,5x
31.250 5 10 2,4 segundos 16 segundos 6,3x
15.625 5 10 1,4 segundos 8 segundos 6,1x
7.812 5 10 0,75 segundos 4,5 segundos 6x
Gráfico 1 – Resultados da comparação da execução do algoritmo em CPU e GPU
Fonte: Desenvolvido pelo Autor
Para realizar as comparações, foram realizados testes com várias quantidades de itens e
com 10 clusters. O hardware utilizado foi um Intel Core i7 [email protected] utilizando 16GB
de Memória RAM GSkill RipjawsX DDR3@2400MHZ CL11, operando em dual channel com
dois módulos de 8GB cada, em uma placa mãe de chipset Intel Z97 (MSI Z97 GD-65). A GPU
4724 19 11 5 2,4 1,4 0,75
333
168
130
73
3216 8 4,5
0
50
100
150
200
250
300
350
1.000.000 500.000 250.000 125.000 62.500 31.250 15.625 7.812
Tem
po
em
seg
un
do
s
Quantidade de itens
Comparação de desempenho entre CPU e GPU
GPU CPU
39
utilizada foi uma Nvidia Geforce GTX 1080 com GPU@2GHZ e 8GB GDDR5X
VRAM@10GHZ (utilizando o driver versão 381.65 WHQL).
Observando o gráfico e a tabela apresentado acima, podemos perceber que quando
aumentamos a quantidade de itens processados, a diferença entre GPU e CPU também aumenta.
Para obter a melhoria de desempenho apresentada acima (cerca de 6 a 7 vezes, dependendo da
quantidade de itens), foi necessário o desenvolvimento do K-means de forma paralela, o teste
do K-means desenvolvido de forma sequencial, teve um desempenho igual ou pior, comparando
com o CPU, mas estes resultados já eram esperados de acordo com o que foi pesquisado neste
trabalho, as GPUs necessitam de um código paralelizado para obterem o desempenho esperado.
Nos testes realizados, também foi detectado uma melhoria de desempenho significante em
GPU, quanto maior a quantidade de clusters requisitados.
Para paralelizar o algoritmo foi necessário dividi-lo em quatro partes. A primeira parte
da execução, calcula as distâncias entre cada ponto e cada centro de cluster. Em seguida, um
segundo kernel computa a associação real de cada ponto (isto é, o cluster mais próximo), usando
a matriz anterior. As próximas duas partes da execução calculam os novos centróides,
calculando a média de cada conjunto de pontos. O algoritmo desenvolvido segue o fluxograma
apresentado na Figura 4, o SIMD foi aplicado nos passos mais trabalhosos, onde todos os itens
devem ser recalculados, ou seja, na parte onde são calculadas as distâncias (distância
euclidiana) de cada ponto a cada cluster e a que cluster cada ponto se associa.
Explorar o uso de GPU para executar o K-Means paralelo provou ser uma opção viável
(especialmente para grandes conjuntos de itens e clusters) para aplicabilidade em diversos
setores onde o processo de cluster se aplica, apresentando uma melhoria de desempenho de seis
a sete vezes melhor que o CPU, a custo de uma reescrita do algoritmo, de forma paralela. A
implementação realizada é limitada apenas pela quantidade de VRAM disponível para a GPU,
sendo assim, escalona bem.
Como o autor nunca teve experiência com desenvolvimento de software para GPUs, os
desafios encontrados durante o processo foram inúmeros, como problemas com IDEs, falta de
conhecimento de sintaxe, problemas com instalação de drivers, tanto por parte da Intel quanto
por parte da Nvidia, também houve bastante dificuldade em entender e implementar a diferença
entre o K-means otimizado e o K-means paralelo.
Para futuros trabalhos, pode ser desenvolvido um port do algoritmo para CUDA,
podendo otimizar de forma mais eficiente o algoritmo, além de estudar a possível aplicação de
outros algoritmos de agrupamentos semelhante ao K-means, ou variações do mesmo. Também
em futuros trabalhos, o K-means poderia ser usado para detectar ataques DdoS, o K-means
40
ficaria rodando na GPU, com um número X de centróides (definido a partir da necessidade de
cada rede ou ambiente), as dimensões de um item também são adaptáveis a cada ambiente onde
é necessário executar a proteção contra esse tipo de ataque. A cada vez que o algoritmo finalizar
a execução, ele guarda na memória o valor das centróides, e na próxima vez que for executado
ele calcula a diferença entre elas, caso a diferença entre elas for maior que X (que também é
adaptável a cada ambiente), um alerta é pode ser enviado para o administrador.
41
6. CONCLUSÃO
O desenvolvimento do presente estudo possibilitou uma análise de como a otimização
via GPU de um algoritmo de agrupamento (neste caso, o K-means) pode melhorar o
desempenho do algoritmo, para apresentar os dados clusterizados de forma mais rápida. Os
testes foram realizados em um ambiente simulado de rede, com uma larga quantidade de dados,
os testes variaram de 7.812 até 1.000.000 de itens clusterizados, onde o K-means paralelo
rodando em GPU provou-se ser uma opção com uma performance de 6 a 7 vezes superior em
desempenho, dependendo do número de itens e clusters necessários, assim, consolidou a
hipótese de que o uso de GPUs otimizaria o desempenho do algoritmo de agrupamento K-
means.
O uso de GPUs para trabalhar com uma grande quantidade de dados também provou ter
uma ótima relação custo x benefício, já que a GPU conseguiu ser no mínimo seis vezes mais
rápida que a CPU e os dois tem um preço bastante semelhante no mercado atualmente. A
implementação desenvolvida neste trabalho pode ser aplicada em diversas áreas e os testes
realizados foram para a proteção de redes contra ataques DdoS, onde o algoritmo provou sua
eficiência. A implementação realizada torna possível realizar mais agrupamentos em menos
tempo, assim sendo uma ótima opção em ambientes onde necessitamos realizar vários
agrupamentos para comparar os seus resultados e também permite um upgrade de hardware
mais frequente, trocando apenas um componente do computador (a GPU), a cada geração,
visando obter mais poder de processamento.
Em futuros trabalhos, podemos portar este algoritmo utilizando a CUDA, da Nvidia,
para analisar se utilizando a mesma, o desempenho apresentado pode ser superior. Também
pode ser analisado o uso do algoritmo paralelizado em GPU, para outros ambientes que
necessitem de respostas rápidas em uma grande quantidade de itens, podendo ser aplicado nas
áreas de medicina, negócios e marketing, biologia e muitos outros.
42
BIBLIOGRAFIA
AAKER, D. A; KUMAR, V.; DAY, G.S. Pesquisa de marketing. São Paulo: Atlas, 2004.
ASOSHEH, A.; RAMEZANI, N. A comprehensive taxonomy of DDoS attacks and defense
mechanism applying in a smart classification. WSEAS Transactions on Computers, v. 7, n.
4, p. 281–290, 2008.
AURA, T.; LAUD, P.; LUKAYENKO, A. Mitigating DDoS attacks with cluster-based
filtering. 2011.
CERVO, A. L. BERVIAN, P. A. Metodologia científica. 5.ed. São Paulo: Prentice Hall,
2002. Core i7 6700K. Intel Ark. Disponível em: <http://ark.intel.com/pt-
br/products/88195/Intel-Core-i7-6700K-Processor-8M-Cache-up-to-4_20-GHz>. Acesso em:
30 ago. 2016.
COPPIN, Ben. Inteligência artificial. Rio de Janeiro: LTC, 2010.
CORMODE, G. et al. Finding hierarchical heavy hitters in streaming data. ACM
Transactions on Knowledge Discovery from Data, v. 1, n. 4, p. 1–48, 2008.
DDoS Attack Types & Mitigation Methods, Imperva. Disponível em
<https://www.incapsula.com/ddos/ddos-attacks/>. Acesso em: 04 set. 2016.
DEIB - Dipartimento di elettronica, informazione e bioingegneria, Milano. Diponível em <
https://home.deib.polimi.it/matteucc/Clustering/tutorial_html/>. Acesso em: 30 mai. 2017.
DOULIGERIS, C.; MITROKOTSA, A. DDoS attacks and defense mechanisms:
Classification and state-of-the-art. Computer Networks, v. 44, n. 5, p. 643–666, 2004.
ERMAN, J.; ARLITT, M. Traffic classification using clustering algorithms. of the 2006
SIGCOMM workshop on, p. 281–286, 2006.
FLYNN, M. J. Some computer organizations and their effectiveness. IEEE Transactions on
Computers, v. C-21, n. 9, p. 948–960, 1972.
GIL, A.C; Métodos e Técnicas de Pesquisa Social. 6a edição, São Paulo, 2008.
43
GUPTA, N.; DHIMAN, M. A Study of DDOS Attacks, Tools and DDOS Defense
Mechanisms. International Journal of Engineering Research and Applications (IJERA)
www.ijera.com, v. 1, n. 3, p. 438–440, [s.d.].
GeForce GTX 1070 Graphics Card. GeForce. Disponível em:
<http://www.geforce.com/hardware/10series/geforce-gtx-1070>. Acesso em: 30 ago. 2016.
HBM. AMD. Disponível em: <http://www.amd.com/pt-br/innovations/software-
technologies/hbm >. Acesso em: 06 set. 2016.
HBM: Memory Solution for Bandwith-Hungry Processors. SK Hynix. Disponível em:
<http://doc.xdevs.com/doc/Memory/HBM/Hynix/HC26.11.310-HBM-Bandwidth-Kim-
Hynix-Hot%20Chips%20HBM%202014%20v7.pdf>. Acesso em: 27 set. 2016.
Mitchell, T. M. (1997).
Machine Learning. McGraw-Hill. How k-means clustering Works, Phonetic Sciences.
Disponóvel em: <http://www.fon.hum.uva.nl/praat/manual/k-
means_clustering_1__How_does_k-means_clustering_work_.html>. Acesso em: 27 set.
2016.
HIJAZI, A. et al. Discovering packet structure through lightweight hierarchical clustering.
IEEE International Conference on Communications, p. 33–39, 2008.
JAIN, A. K.; MURTY, M. N.; FLYNN, P. J. Data clustering: a review. ACM Computing
Surveys, v. 31, n. 3, p. 264–323, 1999.
KOMATSU, K. et al. Evaluating Performance and Portability of OpenCL Programs. Science
And Technology, v. 2, n. August 2016, p. 52, 2010.
LAKATOS, E. M.; MARCONI, M. A.; Fundamentos metodologia científica; 4. ed. São
Paulo: Atlas, 2011.
MAJI, P.; PAUL, S. Scalable pattern recognition algorithms. n. November 2008, 2014.
MCGREGOR, A. et al. Flow clustering using machine learning techniques. Lecture Notes in
Computer Science (including subseries Lecture Notes in Artificial Intelligence and
Lecture Notes in Bioinformatics), v. 3015, p. 205–214, 2004.
MERRILL, D. G.; GRIMSHAW, A. S. Revisiting sorting for GPGPU stream architectures.
44
Proceedings of the 19th international conference on Parallel architectures and
compilation techniques - PACT ’10, n. February, p. 545, 2010.
OLIVEIRA, M. F./ Metodologia científica: um manual para a realização de pesquisas em
administração; Catalão, UFG, 2011.
OpenCL. Khronos Group. Disponível em: <https://www.khronos.org/opencl/>. Acesso em:
14 set. 2016.
OpenCL. Nvidia. Disponível em: <https://developer.nvidia.com/opencl>. Acesso em: 14 set.
2016.
OpenCL Zone. AMD. Disponível em: http://developer.amd.com/tools-and-sdks/opencl-zone/.
Acesso em: 14 set. 2016.
OpenCL Capabilities and Limitations. CMSoft.. Disponível em:
<http://www.cmsoft.com.br/opencl-tutorial/capabilities-limitations/>. Acesso em: 13 set.
2016.
OpenCL Optimization Guide and Concepts. Intel. Disponível em:
<https://software.intel.com/sites/landingpage/opencl/optimization-
guide/Basic_Concepts.htm>. Acesso em 13 set. 2016.
O que é computação com aceleração em GPU? Nvidia. Disponível em:
<http://www.nvidia.com.br/object/what-is-gpu-computing-br.html>. Acesso em: 06 set. 2016.
Perceptron Multi-Camadas (MLP), USP. Disponível em
<http://conteudo.icmc.usp.br/pessoas/andre/research/neural/MLP.htm>. Acesso em: 28 set.
2016.
Placas de vídeo AMD Radeon™ série R9. AMD. Disponível em: <http://www.amd.com/pt-
br/products/graphics/desktop/r9>. Acesso em: 30 ago. 2016.
Protect against DDos Attacks, Akamai. Disponível em:
<https://www.akamai.com/us/en/resources/protect-against-ddos-attacks.jsp>. Acesso em: 09
out. 2016.
RICHARDSON, R. J./ Pesquisa social: métodos e técnicas; 3. ed. São Paulo: Atlas, 1999.
45
SELLTIZ, WRITSMAN,COOK. Métodos de pesquisa nas relações sociais. 2 ed. São Paulo,
1987
SILVA, B.; VANDERLINDE, M. Inteligência Artificial, aprendizado de máquina. p. 1–
10, 2012.
The best way to stop DDoS attacks, Network World. Disponível em:
<http://www.networkworld.com/article/2905115/network-security/the-best-way-to-stop-ddos-
attacks.html>. Acesso em: 04 set. 2016.
WEIKUM, G. Foundations of statistical natural language processing. ACM SIGMOD
Record, v. 31, n. 3, p. 37, 2002.
YANG, Y. et al. A GPGPU Compiler for Memory Optimization and Parallelism
Management. p. 86–97, [s.d.].
ZIKMUND, W. G. Business research methods. 5.ed. Fort Worth, TX: Dryden, 2000.
![FACULDADE MERIDIONAL IMED PROGRAMA DE PÓS … · Composição pelo pesquisador desta Dissertação. Categoria representa “[...] base lógica da dinâmica da Pesquisa Científica](https://static.fdocuments.net/doc/165x107/5c02c69d09d3f2156d8b86d4/faculdade-meridional-imed-programa-de-pos-composicao-pelo-pesquisador-desta.jpg)
