fbm/plot_utilization.R at master · scriptkitty/fbm · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
##### plot_utilization.R #####
# File to visualize the results

library("reshape2")  # melt
library("ggplot2")

source("Bound.R") # inverse_bound(), loads estimate_hurst.R and simulation.R

# Plots the the bound against the utilization.

csv_backlog_vs_util <- function(
  sample_length, arrival_rate, hurst, time_n, conflevel, prob, iterations,
  std_dev = 1.0, splits = 20) {
    # NOTE: all 1 / iterations have been replaced with prob
  utilizations <- (14:19) / 20

  if ((prob) < (1 - conflevel)) {
    stop(paste0("p = ", prob, " < (1 - conflevel) = ",
      1 - conflevel, ". \n
    The bound runs in an infinite loop as the stat_backlog_bound() bound can
    never be below (1-alpha)"))
  }

  simulated_backlog <- rep(NA, length(utilizations))
  snc_bound <- rep(NA, length(utilizations))
  stat_mean <- rep(NA, length(utilizations))
  stat_low <- rep(NA, length(utilizations))
  stat_up <- rep(NA, length(utilizations))
  i <- 1

  for (util in utilizations) {
    print(paste0("utilization: ", util))
    simulated_backlog[i] <- quantile((compute_distribution(
      arrival_rate = arrival_rate, hurst = hurst, sample_length = sample_length,
      time_n = time_n, server_rate = 1 / util, std_dev = std_dev,
      iterations = iterations)), probs = 1 - (prob))
    print(paste0("simulated_backlog: ", simulated_backlog[i]))

    snc_bound[i] <- inverse_bound(
      time_n = time_n, std_dev = std_dev, hurst = hurst,
      arrival_rate = arrival_rate, server_rate = 1 / util, p = prob,
      splits = splits, conflevel = conflevel, estimated_h = FALSE)
    print(paste0("snc_bound: ", snc_bound[i]))

    h_up_vec <- est_h_up_vector(
      sample_length = sample_length, arrival_rate = arrival_rate,
      hurst = hurst, std_dev = std_dev, conflevel = conflevel,
      iterations = iterations
    )

    h_up_quantile <- compute_h_up_quantile(h_vector = h_up_vec,
                                           quantile_prob = 0.95)
    print(h_up_quantile)

    stat_mean[i] <- inverse_bound(
      time_n = time_n, std_dev = std_dev,
      hurst = h_up_quantile$"Hurst_up_mean",
      arrival_rate = arrival_rate, server_rate = 1 / util, p = prob,
      splits = splits, conflevel = conflevel, estimated_h = TRUE)
    print(paste0("stat_mean: ", stat_mean[i]))

    stat_low[i] <- inverse_bound(
      time_n = time_n, std_dev = std_dev,
      hurst = h_up_quantile$"Hurst_lower_quant",
      arrival_rate = arrival_rate, server_rate = 1 / util, p = prob,
      splits = splits, conflevel = conflevel, estimated_h = TRUE)

    stat_up[i] <- inverse_bound(
      time_n = time_n, std_dev = std_dev,
      hurst = h_up_quantile$"Hurst_upper_quant",
      arrival_rate = arrival_rate, server_rate = 1 / util, p = prob,
      splits = splits, conflevel = conflevel, estimated_h = TRUE)

    i <- i + 1
  }


  backlog_bounds_df <- as.data.frame(
    cbind(utilizations, stat_up, stat_mean, stat_low, snc_bound,
          simulated_backlog))

  write.csv(backlog_bounds_df, file = "backlog_bounds.csv",
            row.names = FALSE)

  return(backlog_bounds_df)
}

plot_backlog_vs_util <- function() {
  backlog_bounds_df <- read.csv(file = "backlog_bounds.csv")

  colnames(backlog_bounds_df) <- c(
    "utilizations", "StatNC up", "Mean of StatNC bounds", "StatNC low",
    "SNC Bound", "Simulation")

  long_df <- melt(backlog_bounds_df, id = "utilizations",
                  variable.name = "type",
                  value.name = "Backlog_bound")

  p <- ggplot(long_df, aes(x = utilizations, y = Backlog_bound,
                                  group = type)) +
    geom_line(aes(color = type, linetype = type), size = 0.8) +
    geom_point(aes(color = type, shape = type), size = 2.8) +
    scale_linetype_manual(
      values = c("dashed", "solid", "dashed", "F1", "dotdash")) +
    scale_color_manual(
      values = c("aquamarine4", "black", "aquamarine4", "red", "blue")) +
    scale_shape_manual(values = c(20, 19, 20, 18, 17)) +
    ylim(0.5, max(backlog_bounds_df)) +

    geom_label(aes(x = 0.83, y = max(backlog_bounds_df[3]) * 0.85,
                   label = "Mean of StatNC bounds"),
               fill = "white", size = 5) +
    geom_label(aes(x = 0.85, max(backlog_bounds_df[5]) * 0.6,
                   label = "SNC Bound"),
               fill = "white", size = 5) +
    geom_label(aes(x = 0.93, max(backlog_bounds_df[6]) * 0.6,
                   label = "Simulation"), fill = "white", size = 5) +

    theme_set(theme_bw(base_size = 19)) +
    # theme(legend.position = c(0.25, 0.8),
    #       legend.background = element_rect(color = "black"),
    #       axis.text = element_text(size = 20)) +
    theme(legend.position = "none") +
    xlab("Utilization") +
    ylab("Backlog") +
    theme(legend.title = element_blank())

  return(p)
}

# csv_backlog_vs_util(
#   sample_length = 2 ** 16,
#   arrival_rate = 10 ** (-2), hurst = 0.7, time_n = 200, conflevel = 0.999,
#   prob = 1 / 500, iterations = 5000, std_dev = 1.0, splits = 20)

# pdf("backlog_vs_util.pdf", width = 8, height = 5)
ggsave("backlog_vs_util.pdf", width = 8, height = 5, device = cairo_pdf)

plot_backlog_vs_util()

dev.off()