3 ms·

> Small functions and higher-order functions are the most natural candidates. (The two categories greatly overlap in most cases.) But then you're just guessing

> Small functions and higher-order functions are the most natural candidates. (The two categories greatly overlap in most cases.) But then you're just guessing. Isn't that also inelegant? Let's play devil's advocate: how do you decide the cutoff on function size for inlining? Well, you would profile a bunch of programs with various cutoffs... now all you have is a heuristic, and MLton will inline some functions that it shouldn't, and it will fail to inline other functions that it should. It will do worse than a JIT at this, because the JIT has more information. > That knowledge can be encoded statically in many cases, if only you used the right languages. Sure, but you won't ever succeed in encoding all of it, which is why runtime techniques can have a place. > This is only the case when your program wasn't close to optimal to begin with. That's simply untrue, and you can prove that formally -- given a machine M and a program P that produces outputs on a set of inputs I, it is always possible to come up with a program P' that produces those outputs with fewer steps on some subset of I, in return for taking more steps on the rest of I (except in the trivial case where the running time is completely independent of input). You can view a JIT as iteratively replacing P with P' after it sees which inputs I are most common, and this is true no matter what M, P, or I are. In particular, there exists a version of P' that is faster than the statically optimized version of P on your program's input. > Yes, but languages amenable to static analysis will actively get in your way if you try to write such obfuscated code. I don't see how that isn't equally applicable to writing code to fool your JIT. > So. basically, you're telling me to ditch Java's entire library and framework ecosystem? Framework code doesn't generally run inside your inner loops, so I don't see how that should affect either your AOT or JIT compiler much.

catnaroek 10y ago
> In particular, there exists a version of P' that is faster than the statically optimized version of P on your program's input. Sure, but I'm interested in what the program does on all meaningful inputs, not a specific one. Otherwise, I'd just precompute the answer and hardcode it. > I don't see how that isn't equally applicable to writing code to fool your JIT. AOT compilers are supposed to provide feedback to the programmer about what the program means (e.g., inferred types, type errors). JIT compilers are not. > I don't really understand why optimistic heuristics bother you so much. Um, because they can be wrong, and then you need to fix errors, which makes the system more complex? > Seems like you just have an aesthetic preference. Yes, for simplicity, and for thinking before writing code.
- smallnamespace 10y ago
  > Um, because they can be wrong, and then you need to fix errors, which makes the system more complex? Yes, but I don't understand why compiler complexity concerns you, so long as the whole thing works. AOT compilers are also extremely complex, and are also full of heuristics. You seem really hung up on the fact that an optimization can be rolled back at some point, but why should you care? JIT optimizations can be 'wrong' in the same way that caches can miss. It the right engineering solution to eliminate caching, over some belief that one should never be 'wrong' anywhere in a program, even though the eventual answer is always correct? This might matter in system with real-time performance demands, but then you should be equally concerned about the garbage collector, for example.
  - catnaroek 10y ago
    > Yes, but I don't understand why you compiler complexity concerns you, so long as the whole thing works. Because I find it easier to trust simpler systems than complex ones. > AOT compilers are also extremely complex, and are also full of heuristics. Yep, those heuristics are annoying too. (But less so than the ones JIT compilers use, because at least they don't involve temporarily breaking my program.) > unless you've profiled it and see this having a real adverse effect on overall performance? How many times do I have to repeat that what annoys me is the excessive complexity?
gpderetta 10y ago
>Let's play devil's advocate: how do you decide the cutoff on function size for inlining AOT compiler writers have been tuning inline heuristics for more than 40 years. Sure sometimes you have to help the compiler with annotations or PGO, but in the large majority of cases things just work. In fact AOT can deal much better with the massive code explosion due to aggressive inlining than JIT compilers which have a very tight time budget for optimisations.

catnaroek 10y ago

> In particular, there exists a version of P' that is faster than the statically optimized version of P on your program's input. Sure, but I'm interested in what the program does on all meaningful inputs, not a specific one. Otherwise, I'd just precompute the answer and hardcode it. > I don't see how that isn't equally applicable to writing code to fool your JIT. AOT compilers are supposed to provide feedback to the programmer about what the program means (e.g., inferred types, type errors). JIT compilers are not. > I don't really understand why optimistic heuristics bother you so much. Um, because they can be wrong, and then you need to fix errors, which makes the system more complex? > Seems like you just have an aesthetic preference. Yes, for simplicity, and for thinking before writing code.

smallnamespace 10y ago
> Um, because they can be wrong, and then you need to fix errors, which makes the system more complex? Yes, but I don't understand why compiler complexity concerns you, so long as the whole thing works. AOT compilers are also extremely complex, and are also full of heuristics. You seem really hung up on the fact that an optimization can be rolled back at some point, but why should you care? JIT optimizations can be 'wrong' in the same way that caches can miss. It the right engineering solution to eliminate caching, over some belief that one should never be 'wrong' anywhere in a program, even though the eventual answer is always correct? This might matter in system with real-time performance demands, but then you should be equally concerned about the garbage collector, for example.
- catnaroek 10y ago
  > Yes, but I don't understand why you compiler complexity concerns you, so long as the whole thing works. Because I find it easier to trust simpler systems than complex ones. > AOT compilers are also extremely complex, and are also full of heuristics. Yep, those heuristics are annoying too. (But less so than the ones JIT compilers use, because at least they don't involve temporarily breaking my program.) > unless you've profiled it and see this having a real adverse effect on overall performance? How many times do I have to repeat that what annoys me is the excessive complexity?

gpderetta 10y ago

>Let's play devil's advocate: how do you decide the cutoff on function size for inlining AOT compiler writers have been tuning inline heuristics for more than 40 years. Sure sometimes you have to help the compiler with annotations or PGO, but in the large majority of cases things just work. In fact AOT can deal much better with the massive code explosion due to aggressive inlining than JIT compilers which have a very tight time budget for optimisations.