commit 66474d34ad189d7ab6e6f0ad6359452bbed77e89
Author: Karsten Loesing <karsten.loesing(a)gmx.net>
Date: Tue Apr 19 21:21:05 2011 +0200
Add code to generate the #1991 graphs.
---
task-1991/.gitignore | 6 ++
task-1991/Aggregate.java | 131 ++++++++++++++++++++++++++++
task-1991/Merge.java | 104 ++++++++++++++++++++++
task-1991/README | 46 ++++++++++
task-1991/torperf-guard-bandwidths-ranks.R | 40 +++++++++
task-1991/torperf-guard-quantiles.R | 57 ++++++++++++
6 files changed, 384 insertions(+), 0 deletions(-)
diff --git a/task-1991/.gitignore b/task-1991/.gitignore
new file mode 100644
index 0000000..a0fc089
--- /dev/null
+++ b/task-1991/.gitignore
@@ -0,0 +1,6 @@
+*.mergedata
+*.class
+*.png
+*.csv
+Rplots.pdf
+
diff --git a/task-1991/Aggregate.java b/task-1991/Aggregate.java
new file mode 100644
index 0000000..682a553
--- /dev/null
+++ b/task-1991/Aggregate.java
@@ -0,0 +1,131 @@
+import java.io.*;
+import java.util.*;
+
+public class Aggregate {
+ public static void main(String[] args) throws Exception {
+ BufferedReader br = new BufferedReader(new FileReader(
+ "torperf-guard-bandwidths-ranks.csv"));
+ String line = br.readLine();
+ List<String> sortedByBandwidth = new ArrayList<String>(),
+ sortedByRank = new ArrayList<String>();
+ while ((line = br.readLine()) != null) {
+ sortedByBandwidth.add(line);
+ sortedByRank.add(line);
+ }
+ br.close();
+ Collections.sort(sortedByBandwidth, new Comparator<String>() {
+ public int compare(String a, String b) {
+ return Integer.parseInt(a.split(",")[0]) -
+ Integer.parseInt(b.split(",")[0]);
+ }
+ });
+ Collections.sort(sortedByRank, new Comparator<String>() {
+ public int compare(String a, String b) {
+ return (int) (100.0 * (Double.parseDouble(a.split(",")[1]) -
+ Double.parseDouble(b.split(",")[1])));
+ }
+ });
+
+ List<Integer> percentiles = new ArrayList<Integer>();
+ for (int percentile = 1; percentile < 100; percentile += 1) {
+ percentiles.add(percentile);
+ }
+
+ BufferedWriter bw = new BufferedWriter(new FileWriter(
+ "torperf-guard-rank-quantiles.csv"));
+ bw.write("filesize,rank");
+ for (int percentile : percentiles) {
+ bw.write(",p" + percentile);
+ }
+ bw.write(",len\n");
+ for (String filesize : Arrays.asList("50kb,1mb,5mb".split(","))) {
+ double rankPercentInterval = 0.02;
+ double rankPercent = rankPercentInterval;
+ List<Integer> times = new ArrayList<Integer>();
+ for (int i = 0; i <= sortedByRank.size(); i++) {
+ double rank = -1.0;
+ int completionTime = -1;
+ if (i < sortedByRank.size()) {
+ String[] parts = sortedByRank.get(i).split(",");
+ rank = Double.parseDouble(parts[1]);
+ completionTime = Integer.parseInt(parts[2]);
+ if (!parts[4].equals(filesize)) {
+ continue;
+ }
+ }
+ if (i == sortedByRank.size() || rank > rankPercent) {
+ String rankString = String.format("%.3f",
+ rankPercent - 0.5 * rankPercentInterval);
+ bw.write(filesize + "," + rankString);
+ if (times.size() > 1) {
+ Collections.sort(times);
+ for (int percentile : percentiles) {
+ bw.write("," + times.get(times.size() * percentile / 100));
+ }
+ } else {
+ for (int percentile : percentiles) {
+ bw.write(",NA");
+ }
+ }
+ bw.write("," + times.size() + "\n");
+ times.clear();
+ rankPercent += rankPercentInterval;
+ }
+ if (i == sortedByRank.size()) {
+ break;
+ }
+ times.add(completionTime);
+ }
+ }
+ bw.close();
+
+ bw = new BufferedWriter(new FileWriter(
+ "torperf-guard-bandwidth-quantiles.csv"));
+ bw.write("filesize,bandwidth");
+ for (int percentile : percentiles) {
+ bw.write(",p" + percentile);
+ }
+ bw.write(",len\n");
+ for (String filesize : Arrays.asList("50kb,1mb,5mb".split(","))) {
+ int bandwidthInterval = 2500;
+ int curBandwidth = bandwidthInterval;
+ List<Integer> times = new ArrayList<Integer>();
+ for (int i = 0; i <= sortedByBandwidth.size(); i++) {
+ int bandwidth = -1;
+ int completionTime = -1;
+ if (i < sortedByBandwidth.size()) {
+ String[] parts = sortedByBandwidth.get(i).split(",");
+ bandwidth = Integer.parseInt(parts[0]);
+ completionTime = Integer.parseInt(parts[2]);
+ if (!parts[4].equals(filesize)) {
+ continue;
+ }
+ }
+ if (i == sortedByBandwidth.size() || bandwidth > curBandwidth) {
+ String bandwidthString = String.format("%d",
+ curBandwidth - (bandwidthInterval / 2));
+ bw.write(filesize + "," + bandwidthString);
+ if (times.size() > 1) {
+ Collections.sort(times);
+ for (int percentile : percentiles) {
+ bw.write("," + times.get(times.size() * percentile / 100));
+ }
+ } else {
+ for (int percentile : percentiles) {
+ bw.write(",NA");
+ }
+ }
+ bw.write("," + times.size() + "\n");
+ times.clear();
+ curBandwidth += bandwidthInterval;
+ }
+ if (i == sortedByBandwidth.size()) {
+ break;
+ }
+ times.add(completionTime);
+ }
+ }
+ bw.close();
+ }
+}
+
diff --git a/task-1991/Merge.java b/task-1991/Merge.java
new file mode 100644
index 0000000..622cbf6
--- /dev/null
+++ b/task-1991/Merge.java
@@ -0,0 +1,104 @@
+import java.io.*;
+import java.text.*;
+import java.util.*;
+
+public class Merge {
+ public static void main(String[] args) throws Exception {
+
+ System.out.println("Reading guard node bandwidths...");
+ SortedMap<String, String> bandwidthRanks =
+ new TreeMap<String, String>();
+ BufferedReader br = new BufferedReader(new FileReader(
+ "bandwidths-sql.csv"));
+ String line = br.readLine(), lastDateTime = null;
+ List<String> currentRelays = new ArrayList<String>();
+ while ((line = br.readLine()) != null) {
+ if (line.startsWith("fingerprint") || line.startsWith("(")) {
+ continue;
+ }
+ String[] parts = line.split(",");
+ String fingerprint = parts[0], dateTime = parts[1],
+ bandwidth = parts[2];
+ if (lastDateTime != null && !dateTime.equals(lastDateTime)) {
+ Collections.sort(currentRelays, new Comparator<String>() {
+ public int compare(String a, String b) {
+ return Integer.parseInt(a.split(",")[2]) -
+ Integer.parseInt(b.split(",")[2]);
+ }
+ });
+ for (int i = 0; i < currentRelays.size(); i++) {
+ String relay = currentRelays.get(i);
+ String relayParts[] = currentRelays.get(i).split(",");
+ String relayFingerprint = relayParts[0];
+ String relayBandwidth = relayParts[2];
+ bandwidthRanks.put(relayFingerprint + "," + lastDateTime,
+ String.format("%s,%.6f", relayBandwidth, (double) i /
+ (double) (currentRelays.size() - 1)));
+ }
+ currentRelays.clear();
+ }
+ lastDateTime = dateTime;
+ currentRelays.add(line);
+ }
+ br.close();
+
+ System.out.println("Reading .mergedata file and writing completion "
+ + "time, guard bandwidth, and rank to disk...");
+ SortedMap<Integer, List<Long>> aggregatedResults =
+ new TreeMap<Integer, List<Long>>();
+ BufferedWriter bw = new BufferedWriter(new FileWriter(
+ "torperf-guard-bandwidths-ranks.csv"));
+ bw.write("bandwidth,rank,completiontime,guards,filesize\n");
+ SimpleDateFormat dateTimeFormat =
+ new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+ dateTimeFormat.setTimeZone(TimeZone.getTimeZone("UTC"));
+ for (File mergedataFile : new File(".").listFiles()) {
+ String filename = mergedataFile.getName();
+ if (!filename.endsWith(".mergedata")) {
+ continue;
+ }
+ String guards = filename.substring(0, filename.indexOf("80cbt"));
+ String filesize = filename.split("-")[1].split("\\.")[0];
+ br = new BufferedReader(new FileReader(mergedataFile));
+ while ((line = br.readLine()) != null) {
+ String path = null;
+ long started = 0L, completed = 0L;
+ for (String part : line.split(" ")) {
+ String key = part.substring(0, part.indexOf("="));
+ String value = part.substring(part.indexOf("=") + 1);
+ if (key.equals("PATH")) {
+ path = value;
+ } else if (key.equals("STARTSEC")) {
+ started += Long.parseLong(value) * 1000L;
+ } else if (key.equals("STARTUSEC")) {
+ started += Long.parseLong(value) / 1000L;
+ } else if (key.equals("DATACOMPLETESEC")) {
+ completed += Long.parseLong(value) * 1000L;
+ } else if (key.equals("DATACOMPLETEUSEC")) {
+ completed += Long.parseLong(value) / 1000L;
+ } else if (key.equals("DIDTIMEOUT")) {
+ if (value.equals("1")) {
+ continue;
+ }
+ }
+ }
+ if (path == null || started == 0L || completed == 0L) {
+ continue;
+ }
+ String dateTime = dateTimeFormat.format(started);
+ String fingerprint = path.split(",")[0].substring(1).toLowerCase();
+ String guardKey = fingerprint + "," + dateTime;
+ String previousGuardKey = bandwidthRanks.headMap(guardKey).lastKey();
+ if (previousGuardKey.startsWith(fingerprint)) {
+ String bandwidthRank = bandwidthRanks.get(previousGuardKey);
+ long completionTime = completed - started;
+ bw.write(bandwidthRank + "," + completionTime + "," + guards
+ + "," + filesize + "\n");
+ }
+ }
+ }
+ br.close();
+ bw.close();
+ }
+}
+
diff --git a/task-1991/README b/task-1991/README
new file mode 100644
index 0000000..8cf5548
--- /dev/null
+++ b/task-1991/README
@@ -0,0 +1,46 @@
+Visualize influence of guard bandwidth on Torperf completion time
+
+ - Generate one or more .mergedata files, e.g.,
+
+ $ ./consolidate_stats.py 50kb.data 50kb.extradata
+ regular80cbt-50kb.mergedata
+
+ - Extract consensus bandwidths of all relays and write them to a CSV
+ file. The easiest way to do this is to run an SQL query on the metrics
+ database:
+
+ => \f ','
+ => \a
+ => \t
+ => \o bandwidths-sql.csv
+ => SELECT fingerprint, validafter, bandwidth FROM statusentry
+ WHERE validafter >= '2011-02-23' ORDER BY validafter, fingerprint;
+ => \o
+ => \t
+ => \a
+
+ - Merge the .mergedata file with the consensus bandwidth file to have a
+ single CSV file that contains Torperf completion times and Guard node
+ consensus bandwidths and ranks:
+
+ $ javac Merge.java && java -Xmx2048m Merge
+
+ The result is a file torperf-guard-bandwidths-ranks.csv.
+
+ - Aggregate the results to obtain percentiles:
+
+ $ javac Aggregate.java && java Aggregate
+
+ The result are two files torperf-guard-bandwidth-quantiles.csv and
+ torperf-guard-rank-quantiles.csv.
+
+ - Plot Torperf results by guard consensus bandwidth and ranks for each
+ guard selection strategy separately:
+
+ $ R --slave -f torperf-guard-bandwidths-ranks.R
+
+ - Plot Torperf results by guard consensus bandwidth and ranks for all
+ guard selection strategies and including quantile lines:
+
+ $ R --slave -f torperf-guard-quantiles.R
+
diff --git a/task-1991/torperf-guard-bandwidths-ranks.R b/task-1991/torperf-guard-bandwidths-ranks.R
new file mode 100644
index 0000000..8e7eb0a
--- /dev/null
+++ b/task-1991/torperf-guard-bandwidths-ranks.R
@@ -0,0 +1,40 @@
+library(ggplot2)
+
+# Read data
+data <- read.csv("torperf-guard-bandwidths-ranks.csv",
+ stringsAsFactors = FALSE)
+
+data <- data[(data$filesize == "50kb" & data$completiontime < 60000) |
+ (data$filesize == "1mb" & data$completiontime < 120000) |
+ (data$filesize == "5mb" & data$completiontime < 300000), ]
+
+data[data$guards == "slow", "guards"] <- "a) slowest overall"
+data[data$guards == "slowratio", "guards"] <- "b) slowest ratio"
+data[data$guards == "regular", "guards"] <- "c) default"
+data[data$guards == "fastratio", "guards"] <- "d) fastest ratio"
+data[data$guards == "fast", "guards"] <- "e) fastest overall"
+data[data$filesize == "50kb", "filesize"] <- "a) 50 KB"
+data[data$filesize == "1mb", "filesize"] <- "b) 1 MB"
+data[data$filesize == "5mb", "filesize"] <- "c) 5 MB"
+
+ggplot(data, aes(x = bandwidth / 1000, y = completiontime / 1000)) +
+geom_point(alpha = 0.05) +
+scale_x_continuous("\nGuard consensus bandwidth in MB/s") +
+scale_y_continuous("Torperf completion time in seconds\n") +
+facet_grid(filesize ~ guards, scale = "free_y") +
+opts(legend.position = "none")
+ggsave(filename = "torperf-guard-bandwidths.png",
+ width = 8, height = 5, dpi = 150)
+
+ggplot(data, aes(x = as.numeric(rank), y = completiontime / 1000)) +
+geom_point(alpha = 0.05) +
+scale_x_continuous(paste("\nGuard rank by consensus bandwidth from",
+ "slowest (0) to fastest (1)"), limits = c(0, 1),
+ breaks = c(0.25, 0.5, 0.75)) +
+scale_y_continuous("Torperf completion time in seconds\n") +
+facet_grid(filesize ~ guards, scale = "free_y") +
+opts(legend.position = "none")
+ggsave(filename = "torperf-guard-ranks.png",
+ width = 8, height = 5, dpi = 150)
+
+
diff --git a/task-1991/torperf-guard-quantiles.R b/task-1991/torperf-guard-quantiles.R
new file mode 100644
index 0000000..2554c34
--- /dev/null
+++ b/task-1991/torperf-guard-quantiles.R
@@ -0,0 +1,57 @@
+library(ggplot2)
+
+# Read data
+data <- read.csv("torperf-guard-bandwidths-ranks.csv",
+ stringsAsFactors = FALSE)
+data <- data[(data$filesize == "50kb" & data$completiontime < 60000) |
+ (data$filesize == "1mb" & data$completiontime < 600000) |
+ (data$filesize == "5mb" & data$completiontime < 1500000), ]
+data[data$filesize == "50kb", "filesize"] <- "a) 50 KB"
+data[data$filesize == "1mb", "filesize"] <- "b) 1 MB"
+data[data$filesize == "5mb", "filesize"] <- "c) 5 MB"
+
+percentiles <- paste("p", seq(90, 90, 1), sep = "")
+
+rq <- read.csv("torperf-guard-rank-quantiles.csv",
+ stringsAsFactors = FALSE)
+rq[(rq$len < 30 & rq$filesize == "50kb") |
+ (rq$len < 10 & rq$filesize == "1mb") |
+ (rq$len < 5 & rq$filesize == "5mb"), percentiles] <- NA
+rq <- rq[, c("filesize", "rank", percentiles)]
+rq <- melt(rq, id = c("filesize", "rank"))
+rq[rq$filesize == "50kb", "filesize"] <- "a) 50 KB"
+rq[rq$filesize == "1mb", "filesize"] <- "b) 1 MB"
+rq[rq$filesize == "5mb", "filesize"] <- "c) 5 MB"
+ggplot(data, aes(x = as.numeric(rank), y = completiontime / 1000)) +
+geom_point(alpha = 0.05) +
+scale_x_continuous(paste("\nGuard rank by consensus bandwidth from",
+ "slowest (0) to fastest (1)"), limits = c(0, 1)) +
+scale_y_continuous("Torperf completion time in seconds\n") +
+geom_line(data = rq, aes(x = as.numeric(rank), y = value / 1000,
+ colour = variable)) +
+facet_grid(filesize ~ ., scale = "free_y") +
+opts(legend.position = "none")
+ggsave(filename = "torperf-guard-rank-quantiles.png",
+ width = 8, height = 5, dpi = 150)
+
+bq <- read.csv("torperf-guard-bandwidth-quantiles.csv",
+ stringsAsFactors = FALSE)
+bq[(bq$len < 30 & bq$filesize == "50kb") |
+ (bq$len < 10 & bq$filesize == "1mb") |
+ (bq$len < 5 & bq$filesize == "5mb"), percentiles] <- NA
+bq <- bq[, c("filesize", "bandwidth", percentiles)]
+bq <- melt(bq, id = c("filesize", "bandwidth"))
+bq[bq$filesize == "50kb", "filesize"] <- "a) 50 KB"
+bq[bq$filesize == "1mb", "filesize"] <- "b) 1 MB"
+bq[bq$filesize == "5mb", "filesize"] <- "c) 5 MB"
+ggplot(data, aes(x = bandwidth / 1000, y = completiontime / 1000)) +
+geom_point(alpha = 0.05) +
+scale_x_continuous("\nGuard consensus bandwidth in MB/s") +
+scale_y_continuous("Torperf completion time in seconds\n") +
+geom_line(data = bq, aes(x = bandwidth / 1000, y = value / 1000,
+ colour = variable)) +
+facet_grid(filesize ~ ., scale = "free_y") +
+opts(legend.position = "none")
+ggsave(filename = "torperf-guard-bandwidth-quantiles.png",
+ width = 8, height = 5, dpi = 150)
+
