Universidade Federal de Juiz de Fora

Departamento de Ciência da Computação

Teoria dos Grafos

Atribuição de Canais de Transmissão em Redes

Cognitivas

Grupo 05

Augusto Castilho Medeiros MAT 2018760044

Ian Couto de Paula - MAT 201876002

Lucas Lino do Carmo Freitas - MAT 201876034

Matheus Henique Rubio de Melo - MAT 201876036

Rodrigo Torres Rego - MAT 201876029

Wiliam Rocha dos Santos - MAT 201876031

Professor: Stênio Sã Rosário F. Soares

Relatório do trabalho final da dis-

ciplina DCC059 - Teoria dos Gra-
fos, parte integrante da avaliação
da mesma.

Juiz de Fora

Novembro de 2019
1 Introdução
Com o crescente aumento do uso de dispositivos sem fio e o constante tráfego de dados,
as redes Wi-Fi, domésticas e corporativas, tem sofrido com o problema de entrega de uma
conexão eficiente e sem interferências.
No Brasil, os dispositivos responsáveis por distribuir a conexão, atuam em sua maior
parte na banda ISM 2,4 GHz em 11 canais separando cada canal por 5 MHz e uma largura
de banda de 22 MHz [Monteiro et al., 2016].
A escassa quantidade de canais corrobora com a dificuldade em oferecer uma inter-
net de qualidade para os clientes conectados a rede visto que, a reutilização de canais é
constante e mesmo em canais diferentes, mas próximos no espectro, podem causar interfe-
rência entre si. Essa interferência pode ser resolvida por métodos mais eficazes na escolha
de canais pelos pontos de acesso.
Visto os problemas enfrentados no cenário atual, o presente Relatório Técnico tem
como objetivo central descrever o uso de algoritmos construtivos gulosos para o problema
de atribuição canais de transmissão para redes cognitivas. Considerou-se neste trabalho
as características do problema modelado sobre um grafo de conflito, não direcionado,
desconexo, onde cada vértice representa um ponto de acesso - Access Point (AP) - da
rede e cada aresta simboliza se um AP pode causar interferência a seu adjacente. Foram
desenvolvidos três algoritmos: guloso, guloso randomizado e o randomizado reativo. Os
mesmos foram avaliados sobre um conjunto de instâncias e os resultados foram comparados
com os apresentados em [Ferreira and Soares, 2017].
O restante do trabalho está assim estruturado: na Seção 2 o problema é descrito
formalmente através de um modelo em grafos; a Seção 3 descreve as abordagens propostas
para o problema, enquanto a Seção 4 apresenta os experimentos computacionais, onde se
descreve o design dos experimentos, o conjunto de instâncias (benchmarks), bem como se
apresenta a análise comparativa dos resultados dos algoritmos desenvolvidos e a literatura;
por fim, a Seção 5 traz as conclusões do trabalho e propostas de trabalhos futuros.

2 Descrição do problema
O problema pode ser modelado em um grafo de conflito, não direcionado, desconexo,
ponderado nas arestas, onde cada vértice representa um AP da rede e cada aresta é
formada se um AP pode gerar interferência a seu adjacente. O peso da aresta corresponde
a intensidade da interferência causada entre os APs.
Para gerar o grafo de conflito, é feita uma relação entre cada AP e seus clientes

1
para determinar sua potência, sendo a mesma, a distância de seu cliente mais longe. As
arestas são inseridas quando a área de potência de um AP faz interseção com uma área
de potência de outro AP e, se dentro dessa interseção, existem clientes de qualquer um
dos pontos de acesso.
Como resultado o problema se resume a uma variação do problema de coloração,
onde os canais seriam as cores. Portanto se espera a minimização na quantidade canais
distribuídos reduzindo o somatório dos pesos dos arcos de forma atender todos os clientes
da rede sendo que nós adjacentes não devem conter canais iguais.

Figura 1: Execução do algoritmo guloso na instância 11

Na imagem é possível visualizar o resultado da atribuição de canais pelo algoritmo

guloso desenvolvido. Os números brancos equivalem o id do AP, já os números em colorido
equivalem ao id do cliente. Cada AP possui uma área circular que define a potência de
transmissão do mesmo. Cada cor diferente dos círculos equivalem a um canal diferente.

3 Abordagens gulosas para o problema

Em um algoritmo guloso, inicia-se uma solução como vazia, que será construída iterativa-
mente escolhendo-se elementos candidatos a entrar na solução até que esta esteja completa.
A cada iteração, uma heurística local define o critério de seleção de um novo elemento para
ser inserido ao conjunto da solução, que uma vez parte desse conjunto, nunca mais será
substituído por outro, ou seja, não há retrocesso (backtracking) de decisões já tomadas.

2
Normalmente, algoritmos gulosos são determinísticos e possuem complexidade reduzida
[Talbi, 2009].
De forma a minimizar as interferências causadas na rede, todos os algoritmos pro-
postos executam inicialmente um algoritmo base para atribuir os canais 1, 6 e 11 a todos
os nós da rede possíveis, já que os mesmos não possuem interferência entre si, como é
possível confirmar na figura 2 e na tabela 1.

Figura 2: Canais de transmissão no espectro de 2.4 GHz [Chieochan et al., 2010].

Matriz de sobreposição
Canal 1 2 3 4 5 6 7 8 9 10 11
1 1 0.77 0.54 0.31 0.09 0 0 0 0 0 0
2 0.77 1 0.77 0.54 0.31 0.09 0 0 0 0 0
3 0.54 0.77 1 0.77 0.54 0.31 0.09 0 0 0 0
4 0.31 0.54 0.77 1 0.77 0.54 0.31 0.09 0 0 0
5 0.09 0.31 0.54 0.77 1 0.77 0.54 0.31 0.09 0 0
6 0 0.09 0.31 0.54 0.77 1 0.77 0.54 0.31 0.09 0
7 0 0 0.09 0.31 0.54 0.77 1 0.77 0.54 0.31 0.09
8 0 0 0 0.09 0.31 0.54 0.77 1 0.77 0.54 0.31
9 0 0 0 0 0.09 0.31 0.54 0.77 1 0.77 0.54
10 0 0 0 0 0 0.09 0.31 0.54 0.77 1 0.75
11 0 0 0 0 0 0 0.09 0.31 0.54 0.77 1

Tabela 1: Matriz de sobreposição de canais [Monteiro et al., 2016]

O algoritmo consiste em percorrer toda a lista de vértices do grafo verificando se

é possível atribuir um dos canais 1,6 ou 11 ao mesmo. Para cada nó, um novo vetor é
gerado com todos os canais dos nós adjacentes. Só é viável definir um desses 3 canais se o
vetor de não possuir ocorrências dos mesmos. Caso não for possível determinar nenhum
dos canais, o nó sem canal é colocado em um vetor que será retornado ao fim da execução.

3
 Algorithm 1: Algoritmo Base 1,6,11
Input: listaDeN os
Output: Vetor dos APs sem canais definidos
1 for ap ← primeiroN o to ultimoNo do

2 for apAdjacente ← primeiraAresta to ultimaAresta do

3 vetCanaisAdjacentes ← canalApAdjacente
4 end
5 if vetCanaisAdjacentes nao possui 1,6 ou 11 then
6 canalDeAp ← 1,6 ou 11;
7 else
8 vetAps ← id do ap;
9 end
10 return vetAps;
11 end

3.1 Algoritmo guloso

A heurística usada no algoritmo guloso consiste em atribuir os canais 2,3,4,5,8,9,10 para

todos os APs recebidos do algoritmo base 1,6,11 1. A ordem em que os canais estão na
lista foi definida de acordo com a tabela 1 de forma a minimizar a interferência sofrida
na rede. O algoritmo percorre a lista de candidatos atribuindo um canal a todos os APs
possíveis, atendendo sempre a requisito que nenhum AP adjacente pode conter um canal
igual. Ao final, de acordo com a tabela 1 de interferências, é calculada a interferência
total da rede.

4
 Algorithm 2: Algoritmo Guloso
Output: Interferência total da rede
1 vetAps ← algoritmoBase1611

2 listaDeCandidatos ← [3,8,4,9,2,5,7,10]

3 for ap ← vetorDeAps to ultimoAp do

4 for candidato ← listaDeCandidatos to ultimoCandidato do

5 f lag = T rue
6 for apAdjacente ← primeiraAresta to ultimaAresta do
7 if apAdjacente possui o canal canditado then
8 f lag = F alse
9 break;
10 end
11 if f lag then
12 canalDeAp ← candidato;
13 break;
14 end
15 end

16 Calcula a interferência total gerada

17 return interf erenciaT otal;

3.2 Algoritmo guloso randomizado

Apesar do algoritmo guloso executar de forma rápida ele apenas retorna uma solução para
o problema e esse resultado muitas vezes não é o melhor para o cenário. Para resolver
essa adversidade o algoritmo guloso randomizado, para cada iteração, aleatoriza a lista
de candidatos a partir de um alfa passado como parâmetro na função. Isso permite gerar
diversas outras soluções e assim compara-las afim de retornar o melhor resultado.

5
 Algorithm 3: Algoritmo Guloso Randomizado
Input: quantIteracoes, alf a
Output: Melhor Solução
1 vetAps ← algoritmoBase1611

2 listaDeCandidatos ← [3,8,4,9,2,5,7,10]

3 melhorResultado ← ∞

4 for i ← 0 to i<quantIteracoes do

5 listaRadomizada ← randomizaListaDeCandidatos(alfa)
6 for ap ← vetAps to ultimoAp do
7 for candidato ← listaRadomizada to ultimoCandidato do
8 f lag = T rue
9 for apAdjacente ← primeiraAresta to ultimaAresta do
10 if apAdjacente possui o canal canditado then
11 f lag = F alse
12 break;
13 end
14 if f lag then
15 canalDeAp ← candidato;
16 break;
17 end
18 end
19 Calcula a interferência total gerada
20 if interf erenciaT otal < melhorResultado then
21 melhorResultado ← interferenciaTotal;
22 end

23 return melhorResultado;

3.3 Algoritmo guloso randomizado reativo

A partir do guloso randomizado é possível gerar diversas soluções, mas o algoritmo ainda
fica limitado ao alfa passado como parâmetro. Para contornar esse problema, o guloso
randomizado reativo recebe um vetor de alfas como parâmetro.
A cada iteração o vetor de custos guarda na posição correspondente de alfa a soma
dos resultados. O vetor de contador guarda a quantidade de vezes que os alfas foram
escolhidos. Já o vetor de medias guarda a media dos resultados para cada alfa.
Um novo alfa é escolhido toda vez que a quantidade de iterações atinge 10% do
total. Para definir qual a chance de que um alfa ser escolhido, um vetor de probabilidades
é utilizado. Esse vetor é atualizado toda vez que um alfa é escolhido a partir do vetor de

6
médias e da melhor solução gerada até o momento.
Algorithm 4: Algoritmo Guloso Randomizado Reativo
Input: quantIteracoes, vetAlf as
Output: Melhor Solução
1 vetAps ← algoritmoBase1611

2 listaDeCandidatos ← [3,8,4,9,2,5,7,10]

3 vetCustos ← 0

4 vetM edias ← 0

5 vetP robabilidades ← 0.1

6 melhorResultado ← ∞

7 alf a ← randomizaAlf a

8 for i ← 0, k ← 0 to i<quantIteracoes do

9 k++
10 listaRadomizada ← randomizaListaDeCandidatos(alfa)
11 for ap ← vetAps to ultimoAp do
12 for candidato ← listaRadomizada to ultimoCandidato do
13 f lag = T rue
14 for apAdjacente ← primeiraAresta to ultimaAresta do
15 if apAdjacente possui o canal canditado then
16 f lag = F alse
17 break
18 end
19 if f lag then
20 canalDeAp ← candidato
21 break
22 end
23 end
24 Calcula a interferência total gerada
25 if interf erenciaT otal < melhorResultado then
26 melhorResultado ← interferenciaTotal
27 vetContador ← atualizaContador
28 vetCustos ← atualizaCustos
29 vetM edias ← atualizaM edia
30 if k = 10% da quantidade de iteracoes then
31 alf a ← randomizaAlf a
32 k=0
33 end

34 return melhorResultado;

7
4 Experimentos computacionais

4.1 Descrição das instâncias

Para realizar os testes comparativos, foi utilizado o mesmo conjunto de 30 instâncias

utilizadas em [Ferreira and Soares, 2017], sendo as 9 primeiras consideradas pequenas (10
APs e 50 clientes); as instâncias de 10 a 21 consideradas médias (40 APs e 200 clientes);
e as 9 últimas, numeradas de 22 a 30, consideradas grandes (70 APs e 350 clientes).
As instâncias com os dados necessários para execução do algoritmo são compostas
simplesmente de pontos no plano cartesiano que definem a posição geográfica dos Pontos
de Acesso da rede controlada e dos dispositivos móveis existentes naquele momento. Para
diferenciar as entidades representadas pelos pontos, a primeira linha do arquivo de entrada
é composta pela quantidade de APs e pela quantidade de clientes que serão apontados
nas linhas posteriores [Ferreira and Soares, 2017].

8
Instâncias #APs #Clientes
instance_1 10 50
instance_2 10 50
instance_3 10 50
instance_4 10 50
instance_5 10 50
instance_6 10 50
instance_7 10 50
instance_8 10 50
instance_9 10 50
instance_10 40 200
instance_11 40 200
instance_12 40 200
instance_13 40 200
instance_14 40 200
instance_15 40 200
instance_16 40 200
instance_17 40 200
instance_18 40 200
instance_19 40 200
instance_20 40 200
instance_21 40 200
instance_22 70 350
instance_23 70 350
instance_24 70 350
instance_25 70 350
instance_26 70 350
instance_27 70 350
instance_28 70 350
instance_29 70 350
instance_30 70 350

Tabela 2: Instancias

9
4.2 Ambiente computacional do experimento e conjunto de pa-
râmetros

Para desenvolvimento dos algoritmos e realização os experimentos a linguagem de progra-

mação utilizada foi C++, munido do compilador MinGw. As configurações da máquina
incluem um processador Intel Core i5-5200U 2.2Ghz , 8 GB de memória RAM, placa de
vídeo NVIDEA GeForce GTX 960M e sistema operacional Ubuntu 18.04.
O guloso foi executado apenas uma vez, já que o mesmo gera apenas uma mesma
solução não importando a quantidade de vezes que for executado.
O guloso randomizado foi executado para os alfas 0.2, 0.4 e 0.5, 30 vezes com 5
iterações cada.
Já no guloso randomizado reativo foi executado 30 vezes com 100 iterações cada. A
faixa de valores de alfa compreendem valores de 0.1 a 1 e a cada 10% da total quantidade
de iterações, o alfa era randomizado.

4.3 Resultados quanto à qualidade e tempo

As heurísticas de construção foram executadas para cada instância em três diferentes

formas: gulosas e gulosas randomizadas e gulosas randomizadas reativas. A tabela 3
exibe os resultados gerados pelos algoritmos de construção guloso (colunas 2 e 3), guloso
randomizado (colunas 4 e 5) e guloso randomizado reativo (colunas 6 e 7). Os valores
destacados em negrito indicam os melhores resultados.
Nos resultados apresentados na Tabela 2, a primeira coluna indica o número da
instância utilizada seguida pela quantidade de APs e Clientes.
As demais colunas da tabela fornecem detalhadamente as métricas resultantes das
execuções de cada abordagem, como o RDI das soluções de cada algoritmo, e o tempo
médio de execução, dado em segundos. Em casos onde o tempo foi 0, o algoritmo executou
em um tempo menor que 0,001 segundos.
Para comparação, foi proposto o uso da métrica denominada Índice de Desvio Rela-
tivo (RDI, do inglês Relative Deviation Index ), cujo cálculo é apresentado pela Equação
1 e define a qualidade da solução de uma dado algoritmo a [Ferreira and Soares, 2017]:

M edia(a) − b
RDI(a) = × 100 (1)
c−b

Onde M edia(a) é o valor médio das soluções obtidas pelo algoritmo a, b é o valor da
melhor média obtida dentre todos os algoritmos comparados e c é o valor da pior solução
dentre os algoritmos utilizados, e nesse caso específico, a pior média encontrada. Note

10
que RDI(a) ∈ [0, 100] e quanto menor o valor resultante, maior é a qualidade da solução
do algoritmo a [Ferreira and Soares, 2017].
Segue a análise de resultados a partir de uma tabela:

Guloso Randomizado Reativo

Instâncias
RDI Tempo RDI Tempo RDI Tempo
I1_10AP_50C 100,00 0 43,49 0 0,00 0
I2_10AP_50C 0,00 0 0,00 0 0,00 0
I3_10AP_50C 100,00 0 72,62 0 0,00 0
I4_10AP_50C 83,75 0 100,00 0 0,00 0
I5_10AP_50C 100,00 0 80,39 0 0,00 0,001
I6_10AP_50C 100,00 0 38,40 0 0,00 0
I7_10AP_50C 0,00 0 0,00 0 0,00 0
I8_10AP_50C 92,55 0 100,00 0 0,00 0,001
I9_10AP_50C 0,00 0 0,00 0 0,00 0
I10_40AP_200C 79,54 0 100,00 0 0,00 0,003
I11_40AP_200C 100,00 0 41,30 0 0,00 0,006
I12_40AP_200C 100,00 0 58,50 0 0,00 0,004
I13_40AP_200C 100,00 0 17,80 0,001 0,00 0,005
I14_40AP_200C 100,00 0 24,66 0,001 0,00 0,006
I15_40AP_200C 100,00 0 32,30 0,001 0,00 0,006
I16_40AP_200C 100,00 0 46,01 0 0,00 0,004
I17_40AP_200C 100,00 0 19,31 0 0,00 0,003
I18_40AP_200C 100,00 0 43,37 0 0,00 0,003
I19_40AP_200C 100,00 0 5,69 0,001 0,00 0,005
I20_40AP_200C 100,00 0 2,39 0,001 0,00 0,006
I21_40AP_200C 100,00 0 11,99 0 0,00 0,003
I22_70AP_350C 100,00 0 14,20 0,003 0,00 0,003
I23_70AP_350C 100,00 0 51,86 0,003 0,00 0,019
I24_70AP_350C 100,00 0 31,99 0,003 0,00 0,02
I25_70AP_350C 74,71 0 100,00 0,002 0,00 0,021
I26_70AP_350C 100,00 0 36,16 0,002 0,00 0,015
I27_70AP_350C 100,00 0 16,92 0,002 0,00 0,012
I28_70AP_350C 100,00 0 2,37 0,001 0,00 0,01
I29_70AP_350C 100,00 0 32,35 0,002 0,00 0,013
I30_70AP_350C 100,00 0 10,13 0,003 0,00 0,019

Tabela 3: Resultados obtidos para cada algoritmo

11
 Instâncias onde o RDI foi igual a zero em todos os algoritmos se deve ao fato de que
o algoritmo de base conseguiu atribuir apenas os canais 1,6,11 a todos os nós do grafo.
Analisando a tabela 3 é possível verificar que o algoritmo guloso randomizado reativo foi
melhor do que os demais, já que a mesma verifica uma gama muito maior de soluções,
apesar de necessitar de mais tempo de execução. Vale ressaltar que, no decorrer dos
testes, em nenhuma instância foi necessário atribuir todos os canais disponíveis para uso.

5 Conclusões e trabalhos futuros

Com o surgimento de diversas formas de consumo de redes sem fio, esse trabalho tem o
intuito de apresentar formas de melhorar a eficiência e eficácia rede por meio de algoritmos
gulosos, atribuindo canais aos pontos de acesso de forma minimizar a interferência total.
Depois dos experimentos realizados, conclui-se que o melhor algoritmo foi o guloso
randomizado reativo, com uma melhora considerável em algumas instancias em relação
ao pior algoritmo.
Para trabalhos futuros, pode-se considerar um pré-processamento das instâncias de
forma a calibrar a potência dos APs, ou seja, aumentar ou diminuir as potências para que
haja o mínimo de sobreposições do raio de atuação de cada ponto de acesso de mas ainda
atendendo a todos os clientes.
Outra melhora seria o uso de instâncias de problemas reais visto que, foi constatado
nos testes, em nenhum momento foi usado todos os canais disponíveis. No cenário real,
muitas vezes um local possui mais APs que a quantidade de canais disponíveis, vide
exemplo de um prédio residencial onde cada apartamento possui um AP próprio.

Referências
Surachai Chieochan, Ekram Hossain, and Jeffrey Diamond. Channel assignment schemes
for infrastructure-based 802.11 wlans: A survey. IEEE Communications Surveys &
Tutorials, 12(1):124–136, 2010.

Lucas Rossini Ferreira and Stênio Sã Rosário Furtado Soares. Abordagens heurísticas para
o problema de atribuição de potência e de canais de transmissão em redes cognitivas.
Relatórios Técnicos do DCC/UFJF, 2017.

Alex Monteiro, Eduardo Souto, Richard Pazzi, and Jussi Kiljander. Atribuição dinâmica
de canais em redes sem fio não coordenadas ieee 802. 11, baseada em fatores de sobre-
posição e intensidade de sinal. XXXIV Simpósio Brasileiro de Redes de Computadores
e Sistemas Distribuídos, pages 704–717, 2016.

12
EG Talbi. Metaheuristics: from design to implementation. 2009, hoboken, 2009.

13