Pitchbook shows it as "Out of Business" since 2019.
Pitchbook shows it as "Out of Business" since 2019.
https://www.sigarch.org/distance-based-isa-for-efficient-reg...
I think the most important good one is that it takes "register" renaming seriously. Calls start with a belt that only contains the arguments, for example, and that's done through the magic of renaming. Loops do something similar (they are a lot like calls on the Mill).
I believe there were lots of important bad ones: explicit speculation (super interesting but unlikely to work well), separating memory mapping and memory protection, having "dirty" flags in the cache at the byte level (to minimize writebacks), two PCs moving in opposite directions, very "interesting" encoding, two encoding levels: a general encoding shared between all implementations and many implementation-specific encodings via an installer/converter/loader/JIT, novel protection hierarchy mechanism, backing the renaming mechanism with a more compact representation of older values that aren't likely to be reused soon, automatic spill/restore of that to/from memory, ...
They came up with an interesting compromise between exposed pipelines and guaranteed repeatable execution for loads ("drop the value from this load onto the belt in n cycles").
If you desperately want a high performance implementation that doesn't use out of order execution then the Mill has a lot of good ideas... but an out of order execution implementation is much safer and is not nearly as scary as people think (in terms of complexity, gate count, frequency loss). Mill does not seem to be easy to implement as OOO which means it would have to work as an architecture with only in-order implementations, which sounds like a guaranteed dead end for the future of the architecture.
Maybe you can have a decoder that runs ahead and converts everything to something that isn't so full of relative value references (like the loads) -- and then bolt that onto a fairly standard OOO engine?
Profile: https://news.ycombinator.com/user?id=igodard
Presentation: https://www.youtube.com/watch?v=QGw-cy0ylCc
For comparison, RISC-V started years later and had a tapeout within a year and working silicon available as a commercial product in less than seven years.
2003: Mill computing started
2010: RISC-V project started
2011: RISC-V first tapeout
2017: RISC-V production chips available in the market
2019: Mill computing dead?
The Mill was (is?) a much bigger swing, with much bigger problems to solve in getting to production.
They specifically wanted to avoid the kinds of "quirks" that vendors like Intel and ARM used to make people subject to their patents.
They did try to avoid what they saw as the blunders of past designs, like not leaving enough opcode space for compressed instructions, making instructions conditional, leaving out byte and halfword memory access instructions, having a flags register, having a complicated page table structure, having register windows, having delay slots, etc. None of that was innovative. The actual design of the compressed instruction set and the vector instruction set were innovative, but that came later.
The Mill was the opposite extreme.
Sure, but even so they should have made real chips and iterated on silicon, not just simulations.
It’s the SpaceX rapid iteration development cycle vs NASA waterfall.
Even in 02016, I don't think US$2M was enough to tape out a silicon prototype of a working high-performance CPU. MPW ("shuttle") programs can give you working prototypes for as low as US$3000, but only in process nodes a decade or more behind the state of the art. (This is fine for analog, but for high-performance digital designs it's generally fatal.) US$30M is a much more plausible budget for the multiple rapid-fire tapeouts you need for anything close to a state-of-the-art process.
Huh? LB(U) / LH(U)