Modelagem e Simulação

Teste de performance – Quantum Spark 1530

Mateus de Almeida Ribeiro

Resumo: Foi feito um teste de performance para concluir se o Quantum Spark 1530
security gateway (Vazão do firewall de 1000Mbps) pode ser usado para o
processamento de 5000 pacotes de 6,19 MB e taxa de chegada de 15,229
pacotes/segundo. Os dados são referentes ao site do League of Legends da Riot
Games. Para a simulação do sistema foi usado o software SF.MM1.cpp, tendo sido
obtido um tempo de resposta médio de 0,183 segundos, tamanho médio da fila de
2,728 pacotes e utilização de 0,737. Podemos então concluir que o Quantum Spark
1530 atende a demanda, mantendo sua utilização abaixo de 75% e com tempo de
resposta menor do que os 0,8 segundos requeridos.

Introdução
O teste de performance foi realizado mediante a pedido do professor, servindo
como meio de aprendizagem e capacitação prática dos alunos ao se depararem com
situações como a proposta no trabalho. Foi solicitado a escolha de um serviço e de
um sistema computacional para realizar a simulação do sistema, sendo necessário a
pesquisa e envio dos dados referentes ao tamanho do pacote do serviço, sua taxa
de chegada e a taxa de serviço do sistema computacional escolhido.
Assim, a plataforma escolhida como serviço foi o site do League of Legends
da empresa Riot Games e o sistema computacional escolhido foi o Quantum Spark
1530 security gateway, mais especificamente, sua vazão de firewall que servirá para
os cálculos de taxa de serviço. Após a coleta dos dados, foi utilizado o software
disponibilizado pelo professor, SF.MM1.cpp, através do qual a simulação é feita e é
gerado as informações referentes ao seu funcionamento, considerando o número de
5000 pacotes.

1/8
 Para uma maior semelhança com as situações reais, foi solicitado também
um relatório que desenvolva os métodos e conclusões a cerca do que foi feito,
simulando uma prestação de serviço a uma empresa.

Metodologia
Para realizar o teste de performance foi utilizado o hardware Quantum Spark
1530 security gateway (Firewall), cuja vazão de firewall é de 1000 Mbps.

Figura 1: Imagem retirada do datasheet fornecido pela Quantum Spark

Para encontrar o tamanho do pacote foi considerado que ele seria equivalente
ao tamanho de uma página do site do League of Legends que é de 6,19 MB. O
número de visitas foi de 15,3 milhões no mês de setembro de 2023 e cada visitante
acessou 2,58 páginas em média (dados checados utilizando o site do SimilarWeb),
sendo assim, sua taxa de chegada é de 15,229 pacotes por segundo. Considerando
a vazão de 1000 Mbps do hardware escolhido, temos uma taxa de processamento
de 20,194 pacotes por segundo.

2/8
 Tamanho do pacote (MB) ƛ (p/s) µ (p/s)
6,19 15,229 20,194

Resultados
Os indicadores de desempenho necessários para concluir se o hardware
escolhido é capaz de processar o serviço estão disponíveis na imagem abaixo.

Figura 2: Imagem retirada do

html de saída do software
SF.MM1.cpp

Discussão dos resultados

O Quantum Spark 1530 apresentou tempo de resposta de 0,183 segundos
em média com desvio padrão de 0,180, uma média de 2,728 pacotes na fila com
desvio padrão de 2,982 e uma utilização média de 73,8%. Considerando os fatores
exigidos de:
1. Tempo de resposta abaixo de 0,8 segundo para humanos e 0,2 segundo para
máquina
2. Número de pacotes na fila abaixo de metade da RAM total do sistema
computacional
3. Utilização média em torno de 75%

3/8
Conclusão
Podemos concluir que o Quantum Spark 1530 atende a todos os requisitos e
pode ser considerado como uma boa solução para processamento do serviço
testado, se mantendo em uma faixa que atende a demanda mas sem apresentar um
desperdício de potencial e custo para a empresa.

Juazeiro/BA, 19/11/2023
Mateus de Almeida Ribeiro

Referências

Leal. Modelagem e Simulação Discreta. Disponivel em

<http://www.univasf.edu.br/~brauliro.leal/>. Acesso em: 18 Out 2023.

Datasheet Quantum Spark <https://www.checkpoint.com/downloads/products/1500-

security-gateway-datasheet.pdf> Acesso em: 18 Out 2023

Anexos

Cálculo de ƛ (p/s):
(15.300.000*2,58)/30/24/60/60 = 15,229 pps

Cálculo de µ (p/s):
1000 Mbps / 8 = 125 MBps / 6,19 MB = 20,194 pps

Software SF.MM1.cpp:

//-------------------------------------------------------------------------
------
#include <cmath>
#include <ctime>
#include <string>
#include <vector>

4/8
#include <algorithm>
#include <fstream>
#include <sstream>
//-------------------------------------------------------------------------
------
using namespace std;
//-------------------------------------------------------------------------
------
class clPacote{
public:
int nf;
double ic, cpf, eps, sps;
};
class clSF{
private:
double l, m, E[3], DP[3], T, U;
vector<clPacote> P;

double X ( double );
void Empacotar ( void );
void Nf ( int );
void Estatistica( void );
string Tabela ( void );
string Legenda ( void );

public:
clSF ( void );
void Iniciar ( double, double );
void Simular ( int );
string Resumo ( void );
};
clSF::clSF( void ){
srand(time(nullptr));
}
double clSF::X( double p ){
double u = (rand()+1.0)/(RAND_MAX+2.0); // u in (0,1)
return -log(u)/p;
}
void clSF::Iniciar( double l, double m ){
this->l = l;
this->m = m;
P.clear();
P.push_back({0,0,0,0,0});
}
void clSF::Empacotar( void ){
int a;
clPacote Pn, Pa;
a = P.size()-1;
Pa = P[a];
Pn.ic = X(l);
Pn.cpf = Pn.ic + Pa.cpf;
Pn.eps = Pn.cpf > Pa.sps ? Pn.cpf : Pa.sps;
Pn.sps = Pn.eps + X(m);
Pn.nf = 0;
P.push_back(Pn);
}

5/8
void clSF::Simular( int N ){
for( int p = 1; p < N; p++ ){
Empacotar();
Nf(p);
}
Estatistica();
}
void clSF::Nf( int p ){
P[p].nf = 0;
for( int a = p-1; a > 0; a-- ){
if( P[p].cpf < P[a].eps ) P[p].nf++;
else break;
}
}
void clSF::Estatistica( void ){
int N = P.size();
double Sx[3]={0,0,0}, Sxx[3]={0,0,0};
for( int p = 0; p < N; p++ ){
double x;
x = P[p].sps-P[p].eps; Sx[0] += x; Sxx[0] += x*x; // ts
x = P[p].sps-P[p].cpf; Sx[1] += x; Sxx[1] += x*x; // tsf
x = P[p].nf; Sx[2] += x; Sxx[2] += x*x;
}
T = P[N-1].sps;
U = Sx[0]/T;
for( int e = 0; e < 3; e++ ){
E [e] = Sx[e]/N;
DP[e] = sqrt( Sxx[e]/N-E[e]*E[e] );
}
}
string clSF::Tabela( void ){
stringstream htm;
htm << fixed;
htm.precision(5);
htm << "Simulacao de Sistema de Fila M/M/1<hr>"
<< "Tabela<hr>"
<< "<table border='1' cellpadding='4' cellspacing='0'>"
<< "<tr><th>p<th>ic(s)<th>cpf(s)<th>eps(s)<th>sps(s)<th>nf(p)";
for( int p = 0; p < P.size(); p++ ){
htm << "<tr>"
<< "<td>" << p+1
<< "<td>" << P[p].ic
<< "<td>" << P[p].cpf
<< "<td>" << P[p].eps
<< "<td>" << P[p].sps
<< "<td>" << P[p].nf;
}
htm << "</table><br><br><br>";
return htm.str();
}
string clSF::Resumo( void ){
stringstream htm;
htm << "<html>"
<< "<style>body { background-color: #d6e7f8}"
<< " table{ background-color: #f7e8d9}</style>"
<< "<body><br><br><br>";

6/8
 htm << fixed;
htm.precision(5);
htm << Tabela();
htm << "Resumo<hr>"
<< "<table border='1' cellpadding='4' cellspacing='0'>"
<< "<tr><td> l <td>=<td>" << l << "<td> p/s"
<< "<tr><td> m <td>=<td>" << m << "<td> p/s"
<< "<tr><td> N <td>=<td>" << P.size() << "<td> p "
<< "<tr><td> T <td>=<td>" << T << "<td> s "
<< "<tr><td> E [tsf] <td>=<td>" << E [1] << "<td> s "
<< "<tr><td> E [nf] <td>=<td>" << E [2] << "<td> p "
<< "<tr><td> DP[tsf] <td>=<td>" << DP[1] << "<td> s "
<< "<tr><td> DP[nf] <td>=<td>" << DP[2] << "<td> p "
<< "<tr><td> U <td>=<td>" << U << "<td> - "
<< "</table><br><br><br>";
htm << Legenda();
htm << "</body></html>";
return htm.str();
}
string clSF::Legenda( void ){
stringstream htm;
htm << "Legenda<hr>"
<< "<table border='1' cellpadding='4' cellspacing='0'>"
<< "<tr><th> VA <th> Descricao
<th>Unidade"
<< "<tr><td> cpf <td> tempo de chegada de pacote na Fila <td> s
"
<< "<tr><td> DP[x]<td> desvio padrao de x <td> -
"
<< "<tr><td> E[x] <td> media aritmetica de x <td> -
"
<< "<tr><td> eps <td> tempo de entrada de pacote no Servidor <td> s
"
<< "<tr><td> ic <td> intervalo entre chegadas de pacotes na Fila <td> s/p
"
<< "<tr><td> l <td> taxa de chegada de pacotes na Fila <td> p/s
"
<< "<tr><td> m <td> taxa de servico do Servidor <td> p/s
"
<< "<tr><td> N <td> numero de pacotes simulados <td> p
"
<< "<tr><td> nf <td> comprimento da Fila <td> p
"
<< "<tr><td> P <td> vetor de pacotes <td> p
"
<< "<tr><td> p <td> ordem dos pacotes <td> p
"
<< "<tr><td> sps <td> tempo de saida de pacote do Servidor <td> s
"
<< "<tr><td> T <td> duracao da simulacao <td> s
"
<< "<tr><td> ts <td> tempo de servico do Servidor <td> s
"
<< "<tr><td> tf <td> tempo na Fila <td> s
"
<< "<tr><td> ts <td> tempo no Servidor <td> s
"
<< "<tr><td> tsf <td> tempo no Sistema de Fila <td> s
"

7/8
 << "<tr><td> U <td> utilizacao do Servidor <td> -
"
<< "</table><br><br>";
return htm.str();
}
void Salvar( string fn, string str ){
ofstream fs;
fs.open(fn);
replace(str.begin(), str.end(),'.',',');
fs << str;
fs.close();
}
int main( void ){
int N = 3000;
double l = 1000.0,
m = 1474.6;
clSF SF;
SF.Iniciar(l,m);
SF.Simular(N);
Salvar("MS.T-1.out.html", SF.Resumo() );
return 0;
}

8/8