deno bench for benchmarking - Step-by-Step Execution

Concept Flow - deno bench for benchmarking

Write benchmark function

↓

Use Deno.bench() to register

↓

Run: deno bench command

↓

Deno runs benchmark function

↓

Measure time and ops/sec

↓

Display results in console

You write a function to test, register it with Deno.bench(), run 'deno bench', and see timing results.

Execution Sample

Deno

Deno.bench("simple loop", () => {
  let sum = 0;
  for (let i = 0; i < 1000; i++) sum += i;
});

This code registers a benchmark named 'simple loop' that sums numbers from 0 to 999.

Execution Table

Step	Action	Details	Result
1	Register benchmark	Deno.bench called with name 'simple loop' and function	Benchmark added to queue
2	Run 'deno bench'	Deno starts executing registered benchmarks	Benchmark function starts
3	Execute loop	Sum numbers 0 to 999	sum calculated as 499500
4	Finish benchmark function	Function returns after loop	Time taken recorded
5	Calculate ops/sec	Based on time taken	Ops/sec computed
6	Display results	Print benchmark name, time, ops/sec	User sees output in console
7	Exit	All benchmarks done	Process ends

💡 All registered benchmarks executed and results displayed

Variable Tracker

Variable	Start	After loop	Final
sum	0	499500	499500
i	0	999	1000

Key Moments - 3 Insights

Why do we use Deno.bench() instead of just calling the function?

Deno.bench() registers the function so the Deno test runner knows to run it and measure time, as shown in execution_table step 1 and 2.

What does 'ops/sec' mean in the benchmark output?

'Ops/sec' means how many times the benchmark function could run in one second, calculated after timing the function (see execution_table step 5).

Why does the benchmark function not print anything itself?

The function only runs the code to measure time; Deno bench prints results after running all benchmarks (see execution_table step 6).

Visual Quiz - 3 Questions

Look at the execution table, what is the value of 'sum' after the loop completes?

A 1000

B 499500

C 0

D Undefined

💡 Hint

Check variable_tracker row for 'sum' after loop

At which step does Deno calculate how many operations per second the benchmark can perform?

A Step 5

B Step 3

C Step 2

D Step 6

💡 Hint

Look at execution_table step descriptions for ops/sec calculation

If the loop ran 10,000 times instead of 1,000, how would the 'sum' variable change after the loop?

A It would be 499500

B It would be 10000

C It would be 49995000

D It would be 0

💡 Hint

Sum of numbers 0 to n-1 is n*(n-1)/2; check variable_tracker logic

Concept Snapshot

Use Deno.bench() to register a function for benchmarking.
Run benchmarks with 'deno bench' command.
Deno measures time and calculates ops/sec.
Results print automatically after all benchmarks run.
Benchmark functions should not print; just run code to measure.

Full Transcript

Deno provides a built-in way to benchmark code using Deno.bench(). You write a function with the code you want to test and register it with Deno.bench() giving it a name. When you run 'deno bench' in the terminal, Deno runs all registered benchmarks one by one. It measures how long each function takes to run and calculates how many times it could run in one second (operations per second). After running, Deno prints the results in the console showing the benchmark name, time taken, and ops/sec. The benchmark function itself does not print anything; it only runs the code to be measured. This helps you see how fast your code runs and compare different approaches easily.

Practice

1. What is the main purpose of deno bench in Deno?

easy

A. To format code automatically

B. To check for syntax errors in code

C. To deploy Deno applications to the cloud

D. To measure how fast a piece of code runs

Solution

1. Step 1: Understand the role of benchmarking

   Benchmarking is used to measure the speed or performance of code.

2. Step 2: Identify what deno bench does

   deno bench runs benchmark tests to measure execution time of code snippets.

3. Final Answer:

   To measure how fast a piece of code runs -> Option D

4. Quick Check:

   Benchmarking = measuring speed [OK]

Hint: Benchmark means measuring speed or performance [OK]

Common Mistakes:

• Confusing benchmarking with syntax checking
• Thinking it deploys code
• Assuming it formats code automatically

2. Which of the following is the correct syntax to define a benchmark in Deno?

easy

A. bench({ name: "test", fn: () => { /* code */ } })

B. bench = function(name, fn) { /* code */ }

C. benchmark test() { /* code */ }

D. bench: { name = "test", fn() { /* code */ } }

Solution

1. Step 1: Recall the official benchmark syntax

   The correct way is to call bench with an object containing name and fn properties.

2. Step 2: Compare options to the correct pattern

   bench({ name: "test", fn: () => { /* code */ } }) matches the pattern bench({ name: "test", fn: () => { } }). Others are invalid syntax.

3. Final Answer:

   bench({ name: "test", fn: () => { /* code */ } }) -> Option A

4. Quick Check:

   Use object with name and fn keys [OK]

Hint: Use bench({ name, fn }) to define benchmarks [OK]

Common Mistakes:

• Using assignment instead of function call
• Incorrect object syntax
• Using invalid keywords like 'benchmark'

3. What will be the output behavior when running this benchmark code with deno bench?

bench({
  name: "sum test",
  fn() {
    let sum = 0;
    for (let i = 0; i < 1000; i++) {
      sum += i;
    }
  }
});

medium

A. It prints the time taken to run the loop 1000 times

B. It prints the sum value after the loop

C. It throws a syntax error because of missing return

D. It runs but does not show any output

Solution

1. Step 1: Understand what deno bench does

   It runs the benchmark function multiple times and reports the time taken.

2. Step 2: Analyze the code behavior

   The code sums numbers but does not return or print the sum. The benchmark tool measures execution time, not return values.

3. Final Answer:

   It prints the time taken to run the loop 1000 times -> Option A

4. Quick Check:

   Benchmarks show timing, not return values [OK]

Hint: Benchmarks report time, not return values [OK]

Common Mistakes:

• Expecting printed sum output
• Thinking a return is required
• Assuming no output is shown

4. Identify the error in this benchmark code:

bench({
  name: "test",
  fn: () => {
    let x = 0
    for (let i = 0; i < 10; i++) {
      x += i;
    }
  }
});

medium

A. Missing semicolon after let x = 0

B. Using arrow function instead of regular function

C. No error, code runs fine

D. Missing await keyword inside fn

Solution

1. Step 1: Check syntax carefully

   JavaScript allows optional semicolons. Automatic Semicolon Insertion (ASI) inserts a semicolon after let x = 0 before the for loop since for cannot continue the previous statement.

2. Step 2: Verify other potential issues

   Arrow functions are valid for fn. The code is synchronous, so no await is needed. The code is syntactically valid and runs fine.

3. Final Answer:

   No error, code runs fine -> Option C

4. Quick Check:

   ASI handles missing semicolon before for [OK]

Hint: Semicolons are optional in JS; ASI works before for loops [OK]

Common Mistakes:

• Thinking missing semicolon is a syntax error
• Believing arrow functions are invalid in benchmarks
• Assuming await is needed for synchronous loops

5. You want to benchmark two functions: one that sums numbers from 1 to 1000, and another that multiplies numbers from 1 to 1000. How should you write the benchmark code to compare their speeds correctly?

hard

A. Run one function inside bench and call the other outside

B. Define two separate bench calls each with a unique name and function

C. Put both functions inside one bench call and run them sequentially

D. Use bench only for the sum function and measure multiply manually

Solution

1. Step 1: Understand benchmarking multiple functions

   Each benchmark should be defined separately with a unique name to measure independently.

2. Step 2: Why separate bench calls are needed

   Running both in one bench mixes timings and does not isolate performance.

3. Final Answer:

   Define two separate bench calls each with a unique name and function -> Option B

4. Quick Check:

   Separate benchmarks for accurate comparison [OK]

Hint: Use separate bench calls with unique names [OK]

Common Mistakes:

• Combining multiple tests in one bench
• Measuring one function outside bench
• Skipping benchmark for one function