Enum InstrumentationStrategy 

pub enum InstrumentationStrategy {
    ThreeGlobals,
    HostCalls,
}

The instrumentation strategy for recording profiling data.

Variants

ThreeGlobals

A low-overhead but imprecise instrumentation strategy that records profiling information in globals.

This strategy adds three globals per indirect call site:

1. The total number of calls for this call site.
2. The table index of the last indirect callee.
3. The number of times the last callee has been called.

A call_indirect then becomes the following sequence:

;; $total_count += 1
global.get $total_count
i64.const 1
i64.add
global.set $total_count

;; if $last_callee != $current_callee {
;;     $last_callee = $current_callee
;;     $last_callee_count = 0
;; }
local.tee $current_callee
global.get $last_callee
i32.eq
i32.eqz
if
    local.get $current_callee
    global.set $last_callee
    i64.const 0
    global.set $last_callee_count
end

;; $last_callee_count += 1
global.get $last_callee_count
i64.const 1
i64.add
global.set $last_callee_count

;; Finally, do the actual indirect call.
local.get $current_callee
call_indirect

When $last_callee_count / $total_count is high enough, then winlining table[$last_callee] is beneficial.

Note that this strategy is imprecise and is easily defeated by the following sequence of calls:

• Indirect call to f
• Indirect call to f
• Indirect call to f
• … many, many times …
• Indirect call to f
• Indirect call to g

In this case, winlining f would be beneficial, but we don’t learn that because the last call to g clears that information away.

However, this instrumentation’s overhead is low enough that it is practical to run the instrumented Wasm programs in many production scenarios.

HostCalls

A precise but high-overhead strategy that inserts calls out to the host.

This strategy inserts a call to an imported host function before every call_indirect instruction, letting the host record precise information about the number of indirect calls per call site and which function was the callee.

The imported instrumentation function has the following module, name, and signature:

(import "winliner" "add_indirect_call" (func (param i32 i32)))

Each call_indirect is then transformed into the following sequence:

;; Call out to the host to record the indirect call.
local.tee $current_callee
i32.const 1234 ;; This is the 1234th indirect call site.
call $winliner_add_indirect_call

;; Finally, do the actual indirect call.
local.get $current_callee
call_indirect

When using this strategy, it is your responsibility to provide the host function that this instrumentation inserts calls to, and to build up the profiles using the ProfileBuilder type.

Note that, while this strategy yields precise profiling information, it incurs fairly high overheads, likely making it unacceptable to run the instrumented Wasm programs in production scenarios.

Trait Implementations

impl Clone for InstrumentationStrategy

fn clone(&self) -> InstrumentationStrategy

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl FromStr for InstrumentationStrategy

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self>

Parses a string s to return a value of this type.

impl PartialEq for InstrumentationStrategy

fn eq(&self, other: &InstrumentationStrategy) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for InstrumentationStrategy

impl Eq for InstrumentationStrategy

impl StructuralPartialEq for InstrumentationStrategy