# Benchmarking dolospy

The results (8x times faster indexing, 10,000 faster reporting) are obtained through the following methodology.
Given a bundle of sufficient size (probably around 1 MB), we index it multiple separate times and then analyze the similarity of the first pair.

## Benchmark Script dolospy

The used benchmark script is roughly the following Python script

```py
import dolospy

index = dolospy.Index(27, 15)
bundle = open("bundle.js").read()
iter = 3

start = time.perf_counter()
for i in range(iter): index.addToGroup(f"f{i}", bundle)
end = time.perf_counter()

print("Time for indexing (secs)", (end - start) / iter)

start = time.perf_counter()
for i in range(iter): index.getPair("f0", "f1")
end = time.perf_counter()

print("Time for reporting (secs)", (end - start) / iter)
```

The original data was obtained using dolospy compiled with gcc 14.2.0-19 and CPython 3.14.2 on Debian.

## Benchmark Script dolos

```js
import {File, FingerprintIndex, LanguagePicker} from "@dodona/dolos-lib";

import fs from "node:fs/promises";
import { performance } from "node:perf_hooks";

const languagePicker = new LanguagePicker();
const javascript = await languagePicker.findLanguage("javascript");

const tokenizer = await javascript.createTokenizer();
const index = new FingerprintIndex(27, 15);
const bundle = await fs.readFile("bundle.js", "utf8");
const iter = 3;

let start, end;

const tokenizedFiles = [];

start = performance.now();
for (let i = 0; i < iter; i++)
  tokenizedFiles.push(tokenizer.tokenizeFile(new File(`f${i}`, bundle)));
index.addFiles(tokenizedFiles);
end = performance.now();
  
console.log("Time for indexing (secs)", (end - start) / 1000 / iter);

start = performance.now();
for (let i = 0; i < iter; i++)
  index.getPair(tokenizedFiles[0], tokenizedFiles[1]);
end = performance.now();
  
console.log("Time for reporting (secs)", (end - start) / 1000 / iter);
```

The original data was obtained using Node.js v22.4.0 and @dodona/dolos-lib 3.3.1 on Debian.