Hacker News Reader

Comment by m_mueller | Hacker News Reader

Note: It's not emulation but ahead-of-time cross-compilation. This has some limitations, most notably x86 VMs are not possible.

From my POV, the future of business laptops could be such powerful ARM macs around 1000-1300$ (i.e. quite low priced) coupled with cloud based Windows 10 instances to get all software running. This would then create some pressure on software developers to port over their software at least to Windows-on-ARM which could feasibly run in a local VM.

View on HN

It’s an emulator too though, right? Otherwise things like Chrome (which has a Javascript JIT) would never work in Rosetta.

Rosetta does work with JIT'ed code. I think the way it works is that any code in memory gets the Rosetta magic applied as soon as it is marked executable.

So it's sort of adding latency, as a trade-off for speed (once it starts). That makes so much sense and seems so obvious in a 'huh, probably never would have thought of that' sort of way!

Rosetta compiles JITted code ahead of time, once the OS detects the code exists.

From what I understand, the OS enforces W^X (memory pages that are writable cannot be executable). That means the OS can use the “set page read-only and executable” system calls to detect the existence of JITted code.

Pretty sure if it’s done ahead of time we can’t really call it “JIT” can we? :)

I think what get's cross-compiled is the Javascript JIT-Compiler itself. (The V8)

That wouldn't do much, because the JIT would still be producing Intel code, no?

See other answers, it does sort of a JIT cross compile once a page is marked executable.

Hmm, I guess you have a point.

I wonder if this ahead-of-time cross-compilation is a way of avoiding licensing issues? It seems like one cannot just make x86 CPU without Intel's agreement, but I couldn't find a source explaining this well. I also can't see why someone cannot do a clean room implementation of the instruction set. Some people wrote to me that it may be to do with patents on some instructions, but I wonder how valid such patents are if they describe an obvious way to do a certain thing (I have not seen the patents, so this is my speculation only).

I think its just that it works better for most applications, where you run them multiple times. JIT is going to be slower under emulation anyway. Also note that Rosetta uses the native libraries where available, so as soon as you call into say graphics libraries that is running native, not emulating.

(I believe most of the relevant patents just expired; they don't emulate the vector instructions that are newer).

Rosetta 2 is not emulating an Intel CPU. It recompiles the binary to ARM when you run the app for the first time. It also does on-the-fly compilation of JITed code, too.

Actual emulation would be much slower.

1000-1300 sounds like a lot of money.

The key word there is "business" - most laptops geared for corporate (in PC world at least) are the thin and light metal chassis ones. They are easily $1200 for "pretty good" hardware but a sleek look and feel. But the same (core component) hardware in a budget laptop might be $500-800. Business laptops with best in class hardware are often over $2000.

Compared to what?

$2-3k for a dev laptop since forever, innit?

Maybe a few years ago, but you can get a fairly beefy 8c16t thinkpad for less than $1300.

[1] https://www.lenovo.com/us/en/laptops/thinkpad/thinkpad-t-ser...

I remember $6K for dev laptops in the mid 90s.

How fast is the ARM used in the Windows computers compared to the M1? I would think that if it had the performance of the M1 that we would have seen Windows RT more widely accepted by now.

Does Windows have a Rosetta equivalent? If not that might be the answer to why it’s not widespread

Yes you run x86 apps but not x86_64 on Windows for ARM.

It did not in the original Windows RT release. Recent versions of Windows 10 on ARM have x86 (32-bit) emulation, which is a different approach to Rosetta, but equivalent in allowing older software to run. Beta and future versions of Windows 10 on ARM will also have support for x64 emulation.

Oh right, so that means any JIT that expects to generate x86-64 code and run it, can't. Maybe some exceptionally flexible jit implementations run (if they detect which arch to use at run time - sounds very unlikely).

Reply on news.ycombinator.com