[vm/ffi] Optimize Pointer<Struct> operations

[dcharkes]

Hot loops with structs usually contain loading a struct in the hot loop. For example

void doStoreInt32(Pointer<VeryLargeStruct> pointer, int length) {
  for (int i = 0; i < length; i++) {
    pointer.elementAt(i).load<VeryLargeStruct>().c = 1;
    // pointer[i].c = 1; // With extension method syntax.
  }
}

This is currently slow because (1) loading a struct from a pointer is a runtime entry (2) looking up the size of a struct is a runtime entry.

1. Loading a struct from a Pointer

The way that we implement this runtime entry is:

// Find <class name>.#fromPointer constructor and call it.

https://github.com/dart-lang/sdk/tree/master/runtime/lib/ffi.cc

The constructor is generated in kernel

// Add a constructor which 'load' can use.
// C.#fromPointer(Pointer<Void> address) : super.fromPointer(address);

https://github.com/dart-lang/sdk/tree/master/pkg/vm/lib/transformations/ffi_definitions.dart

It would be simple to generate IL per call site to call the right constructor, but our recognized methods generate method bodies, not specialized per call site. We could use a hashtable from class to method to make a generic method body, but we would need to populate that hashtable at some point.

2. Looking up the size of a struct

Same kind of problem: we find the right #sizeOf field, and read its value in the runtime entry.

This would also be trivial per (non-generic) call site.

@sjindel-google @mkustermann Any suggestion on how to implement this optimization?

[sjindel-google]

We should just require that the struct type being loaded is statically known, as in C.

[dcharkes]

As discussed with @mkustermann offline, we can optimize the load and sizeOf of statically known type arguments by rewiring in the frontend.

We need to keep supporting generic invocations, at least for sizeOf, if we want support package:ffi exposing allocate with the current signature (#38520):

malloc = // lookedUpSymbol

Pointer<T> allocate<T>(int count){
  final int size = sizeOf<T>() * count;
  final int addr = malloc(size);
  return Pointer.fromAddress(addr);
}

[dcharkes]

Pointer.ref is dominating benchmarks with structs: https://github.com/mannprerak2/exp-ffi-dart/tree/master/json_parser_ffi#observatory-cpu-profile

Thanks for the benchmark @mannprerak2!