README.md

Benchmark Packages

The benchmark is organized into several packages, each one targeting a specific type of call, e.g., static dispatch or dynamic dispatch calls.

Next we present each package by providing a general description and descriptions for several "types" of calls with links to the actual benchmark code. The benchmark includes several more calls, which can be accessed by following the links of the example calls or by simply browsing the benchmark code. For each "type" of call at least the following documentation is provided, as demonstrated in the following example:

// instance method call (trait)
// traits::lib::FooTrait::method
// Dynamic dispatch with fully qualified syntax.
FooTrait::method(x)

The first comment line gives a description of the "type" of the call. A call could be static or instance call, function or method call, and it could be defined in a struct's implementation (inherent) or in a trait's implementation (trait).

The second comment line specifies the target functions/methods. In dynamic scenarios such as dynamic dispatch calls and function pointer calls the target method/function is the trait defined method and the function employed by the function pointer respectively.

The third comment line gives a more detailed description of the call and the reasons behind its inclusion in the benchmark.

main

• Description: Main benchmark code. Calls the benchmarks defined in the supporting benchmark packages.
• Crates: 1 binary
• Depends on: traits, structs, static_dispatch, dynamic_dispatch, generics, function_pointers, conditionally_compiled, macros

traits

• Description: Trait definitions used by the individual benchmarks.
• Crates: 1 library
• Depends on: nothing

structs

• Description: Struct definitions and struct and trait implementations used by the individual benchmarks.
• Call examples:
  • Call to inherent public method inside another method.
  • Call to inherent private method inside another method.
• Crates: 1 library
• Depends on: traits

static_dispatch

• Description: Static and instance method calls implemented directly on type T or provided by a trait implemented by T. Test cases that target different calling conventions but also touch upon static method resolution and lookup.
• Call examples:
  • Static method call (inherent).
  • Instance method call (inherent).
  • Instance method call (inherent) on newly allocated object.
  • Instance method call (trait) using fully qualified syntax.
• Crates: 1 library
• Depends on: traits, structs

dynamic_dispatch

• Description: Trait objects and dynamic dispatch.
• Call examples:
  • Dynamic dispatch.
  • Dynamic dispatch (qualified syntax).
  • Dynamic dispatch on generic trait object.
  • Dynamic dispatch on referenced vector elements.
• Crates: 1 library
• Depends on: structs, traits

generics

• Description: Generic trait bounded functions and structs that are monomorphized during compilation.
• Call examples:
  • Call on generic type receiver (trait bounded).
  • Call on generic type receiver (trait bounded by a generic trait).
  • Call on generic type receiver (trait bounded by a generic trait which is concretized).
• Crates: 1 library
• Depends on: structs, traits

function_pointers

• Description: Function pointer and Fn trait instance calls.
• Call examples:
  • Call via function pointer.
  • Call via generic function pointer.
  • Call of an Fn trait instance.
• Crates: 1 library
• Depends on: structs

conditionally_compiled

• Description: Conditionally compiled functions.
• Crates: 1 library
• Depends on: structs

macros

• Description: Function and method calls inside macros.
• Call examples:
  • Call inside declarative macro.
  • Method definition and call generated by derive macro.
• Crates: 1 library
• Depends on: structs