UNIVERSIDADE FEDERAL DO VALE DO SÃO FRANCISCO

COLEGIADO DE ENGENHARIA DA COMPUTAÇÃO

DANILO RIBEIRO RODRIGUES

RELATÓRIO TECNICO
SIMULAÇÃO DE UMA ARQUITETURA COMPUTACIONAL
UTILIZANDO QSN-MM1-RI

Juazeiro, BA
2019
 DANILO RIBEIRO RODRIGUES

RELATÓRIO TECNICO
SIMULAÇÃO DE UMA ARQUITETURA COMPUTACIONAL
UTILIZANDO QSN-MM1-RI

Relatório realizado para a disciplina de

Avaliação e Desempenho de Sistemas,
Ministrada pelo Prof. Dr. Brauliro Gonçalves
Leal, para obtenção de nota parcial.

Juazeiro, BA
2019
 SUMÁRIO
1. INTRODUÇÃO ................................................................................................ 4
2. DESENVOLVIMENTO..................................................................................... 5
3. RESULTADOS ............................................................................................... 7
4. CONCLUSÃO ............................................................................................... 11
5. REFERÊNCIAS ............................................................................................ 12
6. ANEXOS ....................................................................................................... 13
1. Introdução
A arquitetura de componentes simulados é composta de 6 equipamentos
distintos. Simulando uma arquitetura empresarial com requisições oriundas de
colaboradores vindas da internet. O sistema computacional foi simulado utilizando o
algoritmo do LEAL (2019) QSN-MM1-RI. Com o objetivo de montar um cenário inicial
e em detrimento disso melhorá-lo em seguida, buscando uma melhor relação de custo
benefício dos equipamentos, consequentemente do sistema computacional simulado.
Foi analisada as variáveis aleatórias de utilização com objetivo de torna-la em torno
de 70% da variável de cada componente da arquitetura. Não sendo ignorada as
variáveis aleatórias relacionadas à quantidade de tarefas na fila e o tempo dessas
tarefas na fila.
2. Metodologia
A arquitetura proposta para a simulação consiste em um roteador, um firewall,
um switch, um servidor de aplicação, um servidor de backup e um computador de
mesa. Arquitetura essa, melhor exemplificada abaixo:
Figura 1 - Modelo da Arquitetura

A simulação inicial foi feita com o cenário inicial proposto para a análise técnica
do trabalho. A sequência a qual as tarefas percorrem o sistema (15 etapas) é dada
por:
S = { 0,1,2,3,2,4,2,3,2,5,2,3,2,1,0 }
Tendo em vista que o iat (igual ao primeiro valor do vector D do algoritmo) foi
previamente calculado segundo estimativa na quantidade da carga de trabalho diario
a qual seria gerenciado para a arquitetura em questão. Assim, tendo que a quantidade
de acessos diários é 2300000 acessos por dia, tem-se que o valor do iat = 0,0125.
Outra estimativa necessária para a simulação é o tamanho médio do pacote utilizado
para as requisições do sistema, utilizando a estimativa de 5,3 MB. Outros parâmetros
imprescindíveis para a simulação são os parâmetros do RI, utilizou-se R=20
(Replicações), N=5000 (Total de eventos), Ni=4500 (Início dos eventos). Tendo posse
disso os demais valores do vector D foram calculados segundo configuração dos
equipamentos de cada cenário. A configuração inicial da arquitetura é exibida na
tabela abaixo:
 Tabela 1 - Cenário Inicial
EQUIPAMENTO PERFOMANCE mi St DESCRIÇÃO PREÇO

0-Roteador 32Gbps 772,830188 0,001293945 Cisco RV160-K9-BR 1015,38

1-Firewall 1,86Gbps 44,9207547 0,022261424 Astaro Gateway Security Asg 110/120 1249,90

2-Switch 32Gbps 772,830188 0,001293945 HPE OfficeConnect 1420 16G 638,90

3-Servidor 6Gbps 144,905660 0,006901041 Dell PowerEdge T140 6500,20

4-Backup 2725tps 64,2688679 0,015559633 MySQL 5.7.4 -

5-Computador 25,6Gbps 4946,11320 0,000202178 Intel Core I7 8gb Ddr3 Hd 1tb 1610,90

TOTAL = 11015,28

Analisou-se os resultados das variáveis aleatórias U (utilização), E[w] (tempo

na fila) e E[nq] (comprimento da fila). Ao analisar o cenário inicial proposto, foi
realizado o mesmo procedimento utilizado no cenário inicial para o próximo cenário a
fim de melhorar o custo benefício da arquitetura. Assim como, o upgrade de
equipamentos a qual seu desempenho causa gargalo na arquitetura, com isso,
alterou-se na simulação apenas o vetor D do algoritmo, pois, condiz com a quantidade
de requisições por segundo (inicialmente inalterada) e o desempenho dos
equipamentos a qual foram alterados. O cenário melhorado exposto na tabela abaixo:

Tabela 2 - Cenário Final

EQUIPAMENTO PERFOMANCE mi St DESCRIÇÃO PREÇO

0-Roteador 32 772,830188 0,001293945 Cisco RV160-K9-BR 1015,38

1-Firewall 6,2 149,735849 0,006678427 Check Point P210 12200 Appliance 1970,00

2-Switch 32 772,830188 0,001293945 HPE OfficeConnect 1420 16G 638,90

3-Servidor 6 144,905660 0,006901041 Dell PowerEdge T140 6500,20

4-Backup 2725 2725 0,000366972 MySQL 5.7.4 -

5-Computador 8 1545,66037 0,000646972 Intel Core i3 4gb Ddr3 HD 500Gb 717,00

TOTAL= 10841,48

As simulações foram conduzidas de acordo com o algoritmo LEAL (2019) QNS-

MM1-RI anexado neste relatório. Todas as análises feitas posteriormente nesse
relatório, são de acordo com os resultados das simulações.
3. Resultados
Após feita simulação com os parâmetros do cenário inicial proposto, analisou-
se e posteriormente foram feitos os upgrades desde equipamentos a quantidade de
requisições para a arquitetura. Os primeiros resultados obtidos do cenário inicial foram
organizados em forma de tabela utilizando as médias das replicações e exposto a
seguir:

Tabela 3 - Resultado Cenário Inicial

EQUIPAMENTO E[nq] E[w] U

0-Roteador 0,0849 0 0,07185

1-Firewall 1696,2547 39,95365 0,9999

2-Switch 0,0727 0 0,05475

3-Servidor 0,562 0,003 0,29155

4-Backup 0,0157 0 0,01515

5-Computador 0,0089 0 0,00855

Notou-se que a arquitetura inicial o gargalo se encontrava apenas no Firewall,

ficando assim os demais equipamentos em sua boa parte do tempo ocioso. Ao fazer
o Upgrade do firewall do cenário inicial para o do final, constatou-se que a arquitetura
continha equipamentos que ainda ficavam boa parte do tempo ociosos. Foram
observados os equipamentos a qual tinham um custo de aquisição consideráveis para
um possível upgrade, como também, aqueles com um custo considerável pequeno e
pudessem ser trocados por um de custo menor, sem perder muito o seu desempenho.
Então, notou-se que o Computador de mesa poderia ser trocado por um de custo
menor, logo, trocou-se o Computador de mesa com processador i7, por um com
processador i3, diminuindo assim o orçamento da arquitetura. Os demais
equipamentos foram notados que não era vantajoso a troca por mais que estivessem
ociosos, a troca por equipamentos de menor preço e também qualidade, já que os
preços dos mesmos não eram relativamente significantes para o valor final do projeto.
Tendo assim, mantendo a quantidade de requisições do cenário inicial, os resultados
obtidos na simulação pelas médias das replicações das variáveis aleatórias e exibidos
na tabela abaixo, denominado de cenário intermediário:
 Tabela 4 - Resultado Cenário Intermediário
EQUIPAMENTO E[nq] E[w] U

0-Roteador 0,11665 0 0,10415

1-Firewall 1,26025 0,00765 0,53395

2-Switch 0,13955 0 0,1031

3-Servidor 1,5355 0,00825 0,54875

4-Backup 0,0297 0 0,0291

5-Computador 0,0528 0 0,0516

Fazendo o upgrade do firewall, pode-se notar que as utilizações dos

equipamentos aumentaram pelo simples fato da eliminação do gargalo do firewall.
Com a troca do firewall também se notou que a utilização do servidor ficou por volta
de 55% e o roteador com utilização de 53% aproximadamente, com tamanho e tempo
de fila considerados desprezíveis para o usuário. Com isso, notando-se a folga entre
a utilização da arquitetura para o melhor custo benefício (em torno de 70%) pode-
se aumentar o número de requisições para a nova configuração da arquitetura.
Passou-se então, de 2300000 para 3000000 de requisições diárias, passando o iat
para o valor de 0,0096. Melhorando assim, o custo benefício da arquitetura
proposta. Cuja simulação do novo cenário, foi organizada com a média das
replicações independentes das variáveis aleatórias e sintetizada na tabela abaixo:

Tabela 5 - Resultado Cenário Final

EQUIPAMENTO E[nq] E[w] U

0-Roteador 0,15845 0 0,13585

1-Firewall 2,5127 0,0159 0,70115

2-Switch 0,184 0 0,13505

3-Servidor 3,00385 0,0175 0,721

4-Backup 0,0431 0 0,039

5-Computador 0,0751 0 0,068

Com finalidade de sintetizar de forma mais objetiva e clara a diferença entre os

cenários, foram plotados os gráficos das variáveis aleatórias em questão analisadas.
 Gráfico 1 - Diferença entre os Cenários da Variável E[nq]

Gráfico 2 - Diferença entre os Cenários da Variável E[w]

Gráfico 3 - Diferença entre os Cenários da Variável U

O proposito da plotagem de dois gráficos para cada variável aleatória, dar-se

pelo fato do cenário inicial ter um grande gargalo no firewall, tendo valores muitos
discrepantes inibindo assim a discrepância menor entre os outros equipamentos por
cenário. Ao analisar os gráficos se percebesse que a discrepância entre os
equipamentos se encontra maiores no servidor e firewall. No firewall pois foi feito o
upgrade dele, e no servidor pois quando o gargalo se encontrava no firewall o mesmo
passava mais tempo ocioso, com isso sua utilização ficava reduzida. E no cenário final
como a quantidade de requisições que foram aumentadas, consequentemente
aumentou-se a utilização dos equipamentos em geral, consideravelmente no firewall
e servidor. Que trabalham na sua melhor faixa de custo benefício (utilização em torno
de 70%), e o tempo e comprimento da fila considerados desprezíveis (menos de 1
milésimo de segundo e menos que 3 tarefas, respectivamente).
4. Conclusão
Pode-se concluir que a arquitetura suporta bem a quantidade de requisições
inicial, trabalhando com folga no sistema. Como também, para quantidade de
requisições do cenário final (três milhões) o sistema suporta bem a esta demanda,
tendo um cenário com um melhor custo benefício. Alguns componentes trabalham
com folga ainda no seu cenário final, más não se torna vantajoso a troca por um de
menor valor, tendo em vista que a troca tem uma significância monetária pequena
para a perca de desempenho de equipamento. Sendo o Cenário Final a melhor
configuração para a arquitetura em questão.
5. Referências

LEAL, B. G. Avaliação de Desempenho de Sistemas. 2016a. Disponível em:

http://www.univasf.edu.br/~brauliro.leal/#. Acesso em: 14 Ago. 2019.
ASSOCIAÇÃO BRASILEIRA DE NORMAS TÉCNICAS. NBR 10719:
Informação e documentação - Relatório técnico e/ou científico - Apresentação. Rio de
Janeiro. 2011.
CISCO. Cisco RV160 VPN Router and RV160W Wireless-AC VPN Router Data
Sheet. Disponível em:
https://www.cisco.com/c/en/us/products/collateral/routers/rv160-vpn-
router/datasheet-c78-741410.html. Acesso em: 14 Ago. 2019.
ASTARO. Astaro Security Gateway 110. Disponível em:
http://www.astaro.hu/products/hardware-appliances/astaro-security-gateway-
110.html. Acesso em: 14 Ago. 2019.
HPE. Switch HPE OfficeConnect 1420 16G. Disponível em:
https://www.hpe.com/br/pt/product-catalog/networking/networking-
switches/pip.specifications.hpe-officeconnect-1420-16g-switch.7091191.html. Acesso
em: 14 Ago. 2019.
DELL. PowerEdge T140. Disponível em: https://www.dell.com/pt-
br/work/shop/cty/pdp/spd/poweredge-t140/pe_t140_13161_bcc_3. Acesso em: 14
Ago. 2019.
INTEL. PROCESSADOR INTEL® CORE™ i3. Disponível em:
https://www.intel.com.br/content/www/br/pt/products/processors/core/i3-
processors/i3-9300t.html. Acesso em: 14 Ago. 2019.
INTEL. Intel® Core™ i7 Processor Series Datasheet. Disponível em:
https://www.intel.com.br/content/www/br/pt/products/docs/processors/core/core-i7-
900-ee-and-desktop-processor-series-datasheet-vol-1.html. Acesso em: 14 Ago.
2019.
FIREWALLS, Check. Check Point 12200 Appliance. Disponível em:
http://www.checkfirewalls.com/12200.asp. Acesso em: 14 Ago. 2019.
6. Anexos
Tabela utilizada para plotagem dos gráficos.

INICIAL
EQUIPAMENTO E[nq] E[w] U
0-Roteador 0,0849 0 0,07185
1-Firewall 1696,2547 39,95365 0,9999
2-Switch 0,0727 0 0,05475
3-Servidor 0,562 0,003 0,29155
4-Backup 0,0157 0 0,01515
5-Computador 0,0089 0 0,00855

INTERMEDIARIO
EQUIPAMENTO E[nq] E[w] U
0-Roteador 0,11665 0 0,10415
1-Firewall 1,26025 0,00765 0,53395
2-Switch 0,13955 0 0,1031
3-Servidor 1,5355 0,00825 0,54875
4-Backup 0,0297 0 0,0291
5-Computador 0,0528 0 0,0516

FINAL
EQUIPAMENTO E[nq] E[w] U
0-Roteador 0,15845 0 0,13585
1-Firewall 2,5127 0,0159 0,70115
2-Switch 0,184 0 0,13505
3-Servidor 3,00385 0,0175 0,721
4-Backup 0,0431 0 0,039
5-Computador 0,0751 0 0,068
 Algoritmo QNS-MM1-RI Brauliro Leal
#include <iostream> void Statistic( int );
#include <cstdlib> }; Xa = QS[f].Event[
#include <cmath> //---------------------------------- QS[f].Event.size()-1 ];
#include <ctime> void clQSN::Config( int qs, X.at = Xa.at + X.iat;
#include <string> vector<real> D, int s, X.bs = X.at > Xa.es ?
#include <vector> vector<size_t> S ){ X.at : Xa.es;
#include <algorithm> this->s = s; X.es = X.bs + X.st;
#include <fstream> this->S = S; X.idt = X.es - Xa.es;
#include <sstream> QS.clear();
//---------------------------------- for( int i = 0; i < qs; i++ ){ QS[f].Event.push_back(X);
using namespace std; clQS x; // Nq(f);
//---------------------------------- x.l = 0.0; }
typedef long double real; if( i == 0 ) x.l = D[i]; void clQSN::Close( size_t i,
//---------------------------------- x.m = D[i+1]; size_t f ){
class clEvent{ QS.push_back(x); clEvent X, Xa;
public: }
int nq; } Xa = QS[i].Event[
real iat, st, at, bs, es, idt; real clQSN::F( real p ){ QS[i].Event.size()-1 ];
}; real u = X.iat = Xa.idt;
//---------------------------------- (rand()+1.0)/(RAND_MAX+ X.st = F( QS[f].m );
class clQS{ 2.0); // u in (0,1)
public: return -p*log(u); Xa = QS[f].Event[
real l, m, T, U, E[7], V[7]; } QS[f].Event.size()-1 ];
vector<clEvent> Event; void clQSN::Open( size_t i, X.at = Xa.at + X.iat;
}; size_t f ){ X.bs = X.at > Xa.es ?
//---------------------------------- clEvent X, Xa; X.at : Xa.es;
class clQSN{ Xa = QS[i].Event[ X.es = X.bs + X.st;
private: QS[i].Event.size()-1 ]; X.idt = X.es - Xa.es;
size_t s; if( i == 0 ){
vector<size_t> S; X.iat = F( QS[i].l ); QS[f].Event.push_back(X);
real F ( real ); X.st = F( QS[i].m ); // Nq(f);
void Open ( size_t, X.at = Xa.at + X.iat; }
size_t ); X.bs = X.at > Xa.es ? void clQSN::Nq( void ){
void Close ( size_t, X.at : Xa.es; for( size_t qs = 0; qs <
size_t ); X.es = X.bs + X.st; QS.size(); qs++ ){
void Nq ( void ); X.idt = X.es - Xa.es; for( size_t e = 1; e <
QS[qs].Event.size(); e++ ){
public: QS[i].Event.push_back(X); size_t c = e-1;
vector<clQS> QS; // Nq(i); QS[qs].Event[e].nq
} = 0;
void Config ( int, Xa = QS[i].Event[ while(
vector<real>, int, QS[i].Event.size()-1 ]; QS[qs].Event[e].at <
vector<size_t> ); X.iat = Xa.idt; QS[qs].Event[c].es ){
void Simulate ( int ); X.st = F( QS[f].m );
 for( int s = 0; s < 7; for( int r = 0; r < R; r++ ){
QS[qs].Event[e].nq += 1; s++ ){ cout << " Calculando
c--; Sx [s] += x[s]; RI: " << r << endl;
} Sxx[s] += srand(
} x[s]*x[s]; time(NULL)/(r+1) );
} }
} } QSN[r].Config(qs,D,s,S);
void clQSN::Simulate( int N QS[qs].T = QSN[r].Simulate(N);
){ QS[qs].Event[N-1].es- QSN[r].Statistic(Ni);
for( size_t i = 0; i < s; i++ ) QS[qs].Event[Ni-1].bs; }
QS[ S[i] QS[qs].U =
].Event.push_back({0,0,0,0 Sx[1]/QS[qs].T; str << "<html><body>"
,0,0,0}); for( int s = 0; s < 7; s++ << "<br>QSN Table"
for( int e = 1; e < N; e++ ){ ){ << "<br>QS Number:"
for( size_t i = 1; i < s; QS[qs].E[s] = Sx << qs
i++ ){ [s]/(N-Ni); << "<br>Sequence:";
Open(S[i-1],S[i]); QS[qs].V[s] =
//Close(S[i-1],S[i]); Sxx[s]/(N-Ni)- for( int i = 1; i < s; i++ ){
} QS[qs].E[s]*QS[qs].E[s]; str << S[i-1] << "-" <<
} } S[i] << ";";
} } }
void clQSN::Statistic( int Ni } str << "</table>"
){ string RI( void ){ "<br><br><table
Nq(); int R = 20, border='1' cellpadding='0'
for( size_t qs = 0; qs < N = 5000, cellspacing='0'>"
QS.size(); qs++ ){ Ni = 0.9*N,
size_t N = qs = 6, "<tr><td>QSN<td>l<td>m";
QS[qs].Event.size(); s = 15; for( int q = 0; q < qs; q++
real x[7], Sx[7], vector<size_t> S = { ){
Sxx[7]; 0,1,2,3,2,4,2,3,2,5,2,3,2,1, str << "<tr><td>" << q;
for( size_t s = 0; s < 7; 0 }; if( q == 0) str << "<td>"
s++ ) vector<real> D = { << D[q];
Sx[s] = Sxx[s] = 0.0125, else str << "<td>-
0.0; 0.001293945313,0.006678 ";
for( size_t e = Ni; e < 427419,0.001293945313,0 str << "<td>" <<
N; e++ ){ .006901041667,0.0003669 D[q+1];
clEvent X = 724771,0.0006469726563 }
QS[qs].Event[e]; }; str << "</table>"
x[0] = X.iat ; << "<br><br><table
x[1] = X.st ; clQSN QSN[R]; border='1' cellpadding='0'
x[2] = X.nq ; stringstream str; cellspacing='0'>"
x[3] = X.idt ; << "<tr><td>r";
x[4] = X.bs-X.at; //w str << fixed; for( int q = 0; q < qs; q++
x[5] = X.es-X.bs; //s str.precision(3); ){
x[6] = X.es-X.at; //r str << "<td>QS"
 << "<td>T" // << "<td>" << // << "<td>" <<
// << "<td>E[iat]" QSN[r].QS[qs].E[1] // QSN[r].QS[qs].V[5]
// << "<td>E[st]" st // << "<td>" <<
<< "<td>E[nq]" << "<td>" << QSN[r].QS[qs].V[6]
// << "<td>E[idt]" QSN[r].QS[qs].E[2] // << "<td>" <<
<< "<td>E[w]" nq QSN[r].QS[qs].U;
// << "<td>E[s]" // << "<td>" << // << "<td>" <<
// << "<td>E[r]" QSN[r].QS[qs].E[3] // 1.0-QSN[r].QS[qs].U;
// << idt }
"<td>V[iat]<td>V[st]<td>V[n << "<td>" << }
q]<td>V[idt]<td>V[w]<td>V[ QSN[r].QS[qs].E[4] // return str.str();
s]<td>V[r]" w }
<< "<td>U"; // << "<td>" << int main( void ){
// << "<td>p0"; QSN[r].QS[qs].E[5] // string str = RI();
} s
// << "<td>" << ofstream fo;
for( int r = 0; r < R; r++ ){ QSN[r].QS[qs].E[6] // fo.open("out.QSN.MM1-
str << "<tr><td>" << r RI-C++.html");
r+1; // << "<td>" << replace(str.begin(),
for( size_t qs = 0; qs < QSN[r].QS[qs].V[0] str.end(),'.',',');
QSN[r].QS.size(); qs++ ){ // << "<td>" << fo << str;
str << "<td>" << qs QSN[r].QS[qs].V[1] fo.close();
<< "<td>" << // << "<td>" <<
QSN[r].QS[qs].T QSN[r].QS[qs].V[2] return 0;
// << "<td>" << // << "<td>" << }
QSN[r].QS[qs].E[0] // QSN[r].QS[qs].V[3] //----------------------------------
iat // << "<td>" << ------------------------------------
QSN[r].QS[qs].V[4] --------