Guide how to compile (AOT) of *.dart in Dart 2.0

[segfaultmedaddy]

AOT compilation was possible on Dart 1.24 through CLI with using appropriated app-aot value for --snapshot-kind, but I've recently tried to compile *.dart source code on Dart 2.0 like this:

$ dart --snapshot-kind=app-aot --snapshot=app.snapshot example/http_handler.dart 

and it returned error with following context:

../../runtime/bin/main.cc: 251: error: Dart 2.0 AOT compilations only accept Kernel IR files as input ('example/http_handler.dart' is not a valid Kernel IR file).

Dumping native stack trace for thread 1428
  [0x0000560cff5767df] dart::Profiler::DumpStackTrace(void*)
  [0x0000560cff5767df] dart::Profiler::DumpStackTrace(void*)
  [0x0000560cff7b2302] dart::Assert::Fail(char const*, ...)
  [0x0000560cff1f3083] dart::bin::RunMainIsolate(char const*, dart::bin::CommandLineOptions*)
  [0x0000560cff1f3ae7] dart::bin::main(int, char**)
  [0x0000560cff1f43c9] Unknown symbol
-- End of DumpStackTrace
Aborted (core dumped)

Can you, please, provide a detailed guide how to AOT compile source as it seems Dart 2.0 isn't able to compile *.dart using CLI.

[segfaultmedaddy]

May be, it's also a good idea to provide a complete documentation on dartlang.org how to AOT compile Dart code if it is possible in Dart 2.0 (I think it is possible, as Flutter uses it successfully)

[mraleph]

AOT compilation was possible on Dart 1.24 through CLI with using appropriated app-aot value for --snapshot-kind

I don't think this is true. In general you needed to use dart_bootstrap or gen_snapshot neither of which was part of the SDK.

Can you, please, provide a detailed guide how to AOT compile source as it seems Dart 2.0 isn't able to compile *.dart using CLI.

AOT compiler is not part of the SDK at the moment. If you have an SDK checkout you can do this:

# Build necessary components
$ tools/build.py -m release -a x64 runtime dart_precompiled_runtime

# Precompile
$ pkg/vm/tool/precompiler2 example/http_handler.dart app.snapshot

# Run the snapshot
$ pkg/vm/tool/dart_precompiled_runtime2 app.snapshot

Could you clarify why are you interested in AOT compilation? In general we would still expect JIT to reach better peak performance than AOT compiled code, though AOT code would have better startup latency.

[segfaultmedaddy]

Could you clarify why are you interested in AOT compilation?

The purpose of my needs is just studying more about Dart as I'm new to it, to benchmark different modes of execution Dart support, understand capability of it, etc. I'd like to use Dart as primary language on the server side of the project.

In general we would still expect JIT to reach better peak performance than AOT compiled code, though AOT code would have better startup latency.

I believed that the static typing enforced in Dart 2.0 is used by AOT and generates a result code as a lot is known at compile-time and no runtime overhead etc.

[segfaultmedaddy]

Yes, you are correct about this part:

I don't think this is true. In general you needed to use dart_bootstrap or gen_snapshot neither of which was part of the SDK.

I have just downloaded it and tried to run following was returned.

This VM was built without support for AOT compilation.

strange thing, I believed it worked.

[segfaultmedaddy]

Are there any plans to provide general support for AOT in the distribution?

[mraleph]

I believed that the static typing enforced in Dart 2.0 is used by AOT and generates a result code as a lot is known at compile-time and no runtime overhead etc.

JIT has access the exactly the same type information as AOT - plus ability to apply profile guided optimizations and speculatively adapt the code to the workload - which often means that JIT actually knows more about actual types than AOT (though JIT has to pay for tracking it, where is AOT sometimes can run some global static analysis and compute it).

Just to give you a concrete (yet simplified and somewhat artificial) example:

void compute(List<int> l) {
  // do some computations with elements of the l.
}

void main(List<String> args) {
  final list = args.contains('something') ? <int>[0, 1, 2] : new Uint8List(3);
  for (var i = 0; i < 10000; i++)
    compute(list);
}

Here static types don't actually give AOT much information: knowing that something is a List<int> does not help much, as there are various implementations of List<int>.

JIT on the other side would specialize compute to a particular implementation of List<int> because it does type profiling in runtime.

Obvious in real world use cases the comparison is much more complicated, but in general you can't say that "AOT = fast, JIT = slow".

Are there any plans to provide general support for AOT in the distribution?

This is being discussed - but no immediate decisions have been made.

[corporateselect]

We would love to have aot compilation in distribution - use case: faas

aws lambda cold start with 1500MB Ram, Dart, Script snapshot: 950ms, App-JIT snapshot: 700ms, App-AOT snapshot: 70ms

[Indribell]

Any chance for a update on this issue. We are also looking to Dart 2 AOT compilation and the lacking inclusion of the AOT in the distribution is somewhat disturbing. As in "will this feature be supported in the future". Any update on this issue is welcome.

[mraleph]

@Indribell please include your use case here - that would help to prioritize the issue.

/cc @mit-mit