What do the "Not optimized" warnings in the Chrome Profiler mean?

Question

When I use the Developer Tools in Chrome to collect JavaScript CPU Profiles, I am getting two mysterious warnings on functions:

• Not optimized: optimized too many times
• Not optimized: inlining bailed out

What do these actually mean? and what are some possible solutions?

Another one I've seen is Not optimized: TryCatchStatement, but that makes sense. Solution is to remove the try-catch.

The closest attempt at an explanation I've found so far was this - https://github.com/GoogleChrome/devtools-docs/issues/53

Answer 1

1. I believe that "Not optimized: optimized too many times" refers to when the chrome optimizer keeps reoptimizing a function.

   https://groups.google.com/forum/#!topic/v8-users/_oZ4fUSitRY

   If I recall correctly, there are several things that can cause this including parameters that change type, I'll try to dig up the link.

   This one is somewhat cryptic and fixes will depend on your code. I've had this pop up in my code many times and sometimes I just can't fix it.

2. 'Not optimized: inlining bailed out' Seems answered in the link you posted.

3. For the try/catch, a non-exhaustive but useful list of Chrome optimization quirks can be found on this github page:

   https://github.com/petkaantonov/bluebird/wiki/Optimization-killers

   This page mentions that try/catches are not currently optimized:

   • Generator functions
   • Functions that contain a for-of statement
   • Functions that contain a try-catch statement
   • Functions that contain a try-finally statement
   • Functions that contain a compound let assignment
   • Functions that contain a compound const assignment
   • Functions that contain object literals that contain proto, or get or set declarations.

Answer 2

The explanations for these bailout reasons are being crowdsourced and documented in this github thread: https://github.com/GoogleChrome/devtools-docs/issues/53

The short explanation: V8 will not try to optimize functions with some constructs, try/catch block is one example, the full list may change over time as the engine evolves. It can also give up if it tries to optimize and then has to deoptimize some hot function too many times (e.g. because of the type feedback being different each time the function executes).

Answer 3

I had a

function generate_year_blob(year,action,callback){ ... do_blob({act: action, cb:callback, ...}) ... }

and I called it always using only one parameter like this generate_year_blob(this_year).

Those action (expected to be string) and callback (expected to be function) were passed to do_blob() function.

When I changed the the call from generate_year_blob(this_year) to generate_year_blob(this_year,'',null), the 'Not optimized: optimized too many times' warning disappeared.

I didn't find this out immediately, because there were many similar functions generate_month_blob(...), generate_day_blob(...) etc. which were called with all parameters defined.

Answer 4

The first one is likely because the engine has optimised it, but then found the optimisation no good for some reason (maybe the return type varies over time, etc).

Enabling the flags --trace-opt and --trace-deopt should help you pinpoint.

My excuses if the links provided in the comments already pointed you there.