https://github.com/ipeagit/geocode_benchmark
https://github.com/ipeagit/geocode_benchmark
Last synced: 10 months ago
JSON representation
- Host: GitHub
- URL: https://github.com/ipeagit/geocode_benchmark
- Owner: ipeaGIT
- Created: 2024-04-10T19:20:43.000Z (about 2 years ago)
- Default Branch: main
- Last Pushed: 2024-05-10T15:51:08.000Z (about 2 years ago)
- Last Synced: 2025-02-28T23:46:38.359Z (about 1 year ago)
- Language: R
- Size: 156 KB
- Stars: 0
- Watchers: 2
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.Rmd
Awesome Lists containing this project
README
---
output: github_document
---
```{r, include = FALSE}
knitr::opts_chunk$set(
collapse = TRUE,
comment = "#>",
fig.path = "figures/README-",
out.width = "100%"
)
```
# Geocode benchmark
Teste feito para analisar o efeito do número de threads sobre o tempo de processamento da geolocalização usando o `{geocodepro}`. Foram geolocalizados 100.000 endereços aleatórios retirados do CNES. Cinco testes foram feitos com cada opção de número de threads (i.e. cinco com 10 threads, cinco com 15, etc), e o tempo reportado nas figuras a seguir é a média dessas cinco observações. Quatro cenários foram analisados:
- Cenário 1: Hardware Dell 940 comprado em 2017. Repositório estava salvo na rede. Havia a opção de rodar com até 60 cores, mas causava hyperthreading. Número de threads limitado em 28.
- Cenário 2: Hardware Dell 940 comprado em 2017. Repositório salvo em pasta local. Configuração do servidor foi mudada, havia a opção de rodar com até 40 cores. Número de threads limitado em 30.
- Cenário 3: Hardware Dell 940 comprado em 2017. Repositório estava salvo na rede. Configuração do servidor foi novamente mudada, havia a opção de rodar com até 30 cores. Número de threads limitado em 28.
- Cenário 4: Hardware HCI Lenovo VX630V3, modelo 2023. Repositório salvo em pasta local. Número de threads limitado em 28.
```{r, echo = FALSE, warning = FALSE}
library(ggplot2)
library(targets)
old_server_timings <- readRDS(tar_read(old_server_timings_path))
old_server_timings[, server := "old"]
new_server_timings <- readRDS(tar_read(new_server_timings_path))
new_server_timings[, server := "new"]
third_server_timings <- readRDS(tar_read(third_server_timings_path))
third_server_timings[, server := "third"]
fourth_server_timings <- readRDS(tar_read(fourth_server_timings_path))
fourth_server_timings[, server := "fourth"]
timings <- rbind(
old_server_timings,
new_server_timings,
third_server_timings,
fourth_server_timings
)
timings <- timings[n_threads <= 30]
timings[, server := factor(server, levels = c("old", "new", "third", "fourth"))]
timings <- timings[
,
.(avg_time = mean(time)),
by = .(n_threads, n_rows, server)
]
timings[, expected_speedup := n_threads / n_threads[1], by = .(n_rows, server)]
timings[, actual_speedup := avg_time[1] / avg_time, by = .(n_rows, server)]
ggplot(timings) +
geom_line(aes(x = n_threads, y = avg_time / 60, color = server, group = server)) +
geom_point(aes(x = n_threads, y = avg_time / 60, color = server)) +
scale_y_continuous(
"Tempo de processamento (minutos)",
labels = scales::label_number(),
limits = c(0, 5)
) +
scale_x_continuous(
"Número de threads",
labels = scales::label_number(),
limits = c(10, 30)
) +
scale_color_discrete("Cenário", labels = paste0("Cenário ", 1:4)) +
ggtitle("Tempo de processamento por número de threads")
```
No gráfico abaixo, o speed-up esperado foi calculado como a razão entre o número de threads dividido por 10 (que é o menor número de threads que foi analisado no teste). O speed-up realizado foi calculado como o tempo de processamento usando 10 threads dividido pelo tempo de processamento usando os demais números de threads analisados.
```{r, echo = FALSE}
melted_timings <- data.table::melt(
timings,
id.vars = c("n_threads", "n_rows", "server"),
measure.vars = c("expected_speedup", "actual_speedup"),
variable.name = "type",
value.name = "speedup"
)
ggplot(melted_timings) +
geom_line(
aes(
x = n_threads,
y = speedup,
linetype = type,
group = type
)
) +
geom_point(aes(x = n_threads, y = speedup)) +
facet_wrap(
~ server,
nrow = 1
,
labeller = as_labeller(
c(
"old" = "Cenário 1",
"new" = "Cenário 2",
"third" = "Cenário 3",
"fourth" = "Cenário 4"
)
)
) +
scale_y_continuous(
"Speed-up (referência: tempo de processamento com 10 threads)",
labels = scales::label_number(suffix = "x"),
limits = c(1, 3)
) +
scale_x_continuous(
"Número de threads",
labels = scales::label_number(),
limits = c(10, 40)
) +
scale_color_discrete("Servidor", labels = c("Novo", "Antigo")) +
scale_linetype_discrete("Speed-up", labels = c("Esperado", "Realizado")) +
ggtitle("Speed-up: esperado vs realizado")
```