Reduce non-default-interface costs for complicated runtimeclasses

[jonwis]

Super Summary

"Thunked" or "flattened" runtimeclasses decrease binary size and increase throughput by reducing the effort required to call non-default interface members on runtimeclass types. When calling a method on a non-default interface, a place holder vtable proxy swaps itself for the "real" interface obtained from the default interface. Those "real" interfaces are cached inside the runtimeclass instance until the class is destroyed.

Certain kinds of types are excluded - classes with fast_abi metadata or which are unsealed. These limitations may be addressed at a later time.

Use

1. Use cppwinrt.exe in the usual way
2. For NuGet consumers, the *.asm thunk files are pre-compiled as libraries similar to the fast_abi.lib per-architecture files
3. Rebuild clean

This feature is turned on with the -thunked_classes switch, which is off by default.

Background

A type like ValueSet implements a number of interfaces. Most developers write code like this:

PropertySet v;
v.Insert(L"kittens", box_value(true));
v.Insert(L"puppies", box_value(false));
for (auto& [k, v] : v) {
    tell_people(k, v.as<bool>());
}

Under the covers, each call to .Insert and the use of .First behind range-based for is a sequence of:

1. QueryInterface from IPropertySet (the default marker interface)
2. Call IMap<String, Object>::Insert
3. Release the temporary from step 1

This produces a nontrivial amount of code for composite objects, those with interfaces with requires, and those that have gone through multiple versioning cycles. While QI and Release are fast-ish, they're still cacheline flushes (interlocked operations) and code the processor has to use. Windows heavily relies on runtimeclass contract versioning, producing types that grow in complexity over time.

Mechanism

See docs/runtimeclass-caching.md for the full details. Projected runtimeclasses contain up to 8 "cached slots" for their non-default interfaces. Each slot acts like another COM instance - a pointer to a thunk vtable, plus a pointer to the parent class type combined with a slot index.

When any method on the thunk vtable is invoked, the stub calls out to the parent class's cache to resolve its slot. "Resolve" means calling defaultInterface->QueryInterface(iid, &result), then using racy-init to swap the result of the QI into the projected type's interface pointers. Future calls on the same runtimeclass for the same interface then go through the "real" interface instance, rather than the thunk stub.

Notable Changes

This mechanism is a departure from the sizeof(runtimeclass)==sizeof(void*) model. A runtimeclass instance is no longer just a container for a winrt::com_ptr<abi_t<TDefaultInterface>> ... runtimeclass instances grow in size to contain up to 8 slots, along with the increased code required to make full-value copies. ValueSet v = otherValueSet copies only the default interface, causing a re-query for all the slots.

Many C++/WinRT functions that expected this pointer-is-the-default-interface model changed to accomodate

[oldnewthing]

I don't think you can issue call instructions on a non-paragraph aligned stack.