News for hackers. Stuff that matters.
Re:GCC Rust Approved by GCC Steering Committee by bombcar on Monday July 11, 2022 @11:47AM (#32057695)
Would it ever make sense to build a chip/vm (something like the JVM) designed to run the intermediate code directly?
Re:GCC Rust Approved by GCC Steering Committee by Twirrim on Monday July 11, 2022 @12:50PM (#32058580)
Been there, done that!

https://en.wikipedia.org/wiki/Jazelle

Jazelle was an instruction set extension to allow natively running java bytecode on Arm processors. Arm never seemed to give it any proper care and attention necessary for it to make any actual market impact, they didn't even publish the ABI.

Transmeta, that used to employ Linus Torvalds at one stage, had Code Morphing Software: https://en.wikipedia.org/wiki/Transmeta#Code_Morphing_Softwa...

It was built in to the silicon, that essentially operated as a full JIT for x86 software, translating to back-end VLIW instruction set. Transmeta seemed heavy on the marketing and buzz (hiring Linus was very much a marketing move), light on the actual execution. Crusoe didn't even remotely live up to their own buzz and it just about killed off their chances of success.

Re:GCC Rust Approved by GCC Steering Committee by jcranmer on Monday July 11, 2022 @12:00PM (#32057891)
Generally not. There are cases where something akin to intermediate code is shipped (e.g., SPIR-V or PTX for GPU code), but even then, the intent is that it is converted to a binary machine code in the driver.

Intermediate code tends to have downsides that make it hard to work with in an actual hardware implementation. Infinite registers, for example, which makes encoding instructions challenging.

Re:GCC Rust Approved by GCC Steering Committee by jerf on Monday July 11, 2022 @12:01PM (#32057908)
Generally, no. The IR will be tuned for compiler purposes, not execution purposes. It can be possible but it won't be optimal. For instance, the IR will probably retain type information that generally CPUs don't care about, since they live in a world of bits. The IR will have been designed knowing it is upstream of optimization code, so it won't be something that is already optimal, it'll be something designed to be easily made optimal in many different ways.

As Blackthorn mentioned, specifically it can be done. There was a chip that ran JVM bytecode directly. There was an entire Lisp Machine which was very influential... but not because of its high performance.

Wikipedia has a page on this: https://en.wikipedia.org/wiki/High-level_language_computer_a...

Many people decry the lack of innovation in computer architecture over the past 50-60 years. There is a legitimate reason for that, though: Any such innovation had to outrun the exponential increases conventional architecture was experiencing. We had it for so long we could take it for granted, but while computing wasn't the first and won't be the last to see periods of exponential growth, I can't think of anything else that had the length of run that computer chips had. (And even now, it's only slowed down. There's still multiplicative advances rather than additive ones every year. The base on the exponent is just smaller than it used to be.) There's been a number of architectures based on running IR (or an equivalent directly) that didn't pan out, but there's also some that did run OK, but they just couldn't keep up with the exponentially accelerating behemoth.

I think if silicon continues to plateau, there is some hope that this could change. However, a new challenger has appeared! Now it's not good enough to just outrun what a "conventional" architecture can do with CPU and RAM and peripherals... now you also need outrun what a GPU-based architecture can do! This sucks up a lot of the oxygen. For instance, right now you see some tentative steps towards special-purpose AI silicon, but it has to do something amazing to beat out a GPU, and you also have to be really, really sure that the AI technique you are committing to silicon will still be the state-of-the-art in the couple of years it'll take you to bring it to market. AI hasn't been moving as fast as, say, JS front-end frameworks, but it's still moving fast enough that I'd be nervous in investing in that vs. the same amount of effort poured into optimizing a GPU algorithm on GPUs that are still advancing a lot every year.

Re:GCC Rust Approved by GCC Steering Committee by cogman10 on Monday July 11, 2022 @01:06PM (#32058768)
I don't think these limitations are ones that really impact hardware all that much. It wouldn't be impossible to create hardware with the concept of "infinite registers" that ultimately gets optimized away. (see: Mill CPU)

The bigger issue (IMO) is that the IR for compilers tends to evolve rapidly while hardware is stuck in the mud. Moving the problem of finalizing the IR into the hardware will effectively make it so you'd change your compiler to emit IR that targets old IR.

This is why, for example, x86 will get a new instruction which will effectively go unused for 5 to 10 years (except in extreme cases where the performance gains are worth the cost of writing code to detect and use those new instructions... For example, FMA). Those who compile code want it to be able to run most anywhere in not so surprising fashions, so they'll target the LCD.

Now, imagine someone was building a JVM bytecode chip today. The JVM is on a 6 month release schedule. That's incredibly hard for a hardware manufacturer to want to keep updating their chips at that rate. Further, even if they targeted "LTS" versions, they've moved that to a 2 year cycle. Again, hard to really expect customers to want a new JVM chip every 2 years.

The likes of GCC and LLVM IR change and expand just as rapidly (if not moreso) than than JVM.

There is the option of something like FPGA or programmable hardware leaking into more places, but IMO, the HDLs and their tools simply suck too bad to expect FPGA on an ASIC to really take off. We need a first mover here and after that happens, I expect at least 5 to 10 years before the tools get to a level that doesn't completely suck. Even then, while access to GPGPUs is now pretty much universal, GPGPU programming still feels like it is in the stone ages. Despite being a thing for over 10 years. So how can we expect HDLs to evolve at a faster pace?

Re:GCC Rust Approved by GCC Steering Committee by jerf on Monday July 11, 2022 @01:45PM (#32059263)
" Even then, while access to GPGPUs is now pretty much universal, GPGPU programming still feels like it is in the stone ages. Despite being a thing for over 10 years."

I'd be interested in reading an article from someone who has been doing it for 10 years as to why that is the case. I have theories but nowhere near enough direct experience to evaluate.

(My hypothesis is that the extreme parallelism makes it so very tiny mistakes have catastrophic performance impact by introducing accidental serialism, and as a result, it is very difficult to create an "easy to use" framework that doesn't abstract too much away and make it trivially easy to introduce even a tiny such error and crash performance. We actually make this mistake all the time in conventional CPU code, it just generally just costs you small integer multiples of performance instead of large integer multiples of performance.)

Re:GCC Rust Approved by GCC Steering Committee by cogman10 on Monday July 11, 2022 @04:34PM (#32061440)
My hypothesis is more cynical.

We have 4 major GPGPU manufactures (Apple, Intel, AMD, nVidia) and none of them want to make creating an open standard easy. There is no reason why nVidia should support OpenCL the same way that AMD does, they want people to write CUDA. There's no reason for Apple to support OpenAAC like Intel does, they want people to write Metal... etc. These 4 companies are trying to push everyone into their proprietary ecosystem or into an open ecosystem where they have a large say.

I had hoped that SPIR-V would be a good inroad to start fixing some of these problems, but alas, it seems like Apple and nVidia aren't big fans. It's early still, though, so maybe that changes?

Re:GCC Rust Approved by GCC Steering Committee by pjmlp on Monday July 11, 2022 @06:24PM (#32062850)
AMD and Intel don't care enough about OpenCL to actually provide the same tooling and libraries that CUDA does.

OpenCL 2.x was a failure, hence why OpenCL 3.0 is basically 1.2 with everything else from 2.x marked as optional.

Re:GCC Rust Approved by GCC Steering Committee by msbarnett on Monday July 11, 2022 @01:27PM (#32059024)
> It wouldn't be impossible to create hardware with the concept of "infinite registers" that ultimately gets optimized away. (see: Mill CPU)

I'm not sure that the vaporware Mill CPU acts as an existence proof for anything, to be honest.

Re:GCC Rust Approved by GCC Steering Committee by cogman10 on Monday July 11, 2022 @04:27PM (#32061351)
It was a PoC that didn't get funding because the advantages it touts aren't nearly useful enough compared to simpler/familiar architectures. That, and it was proprietary which, come on guys, that was never gonna fly (I still have my doubts about RISC-V going very far).

The problem of infinite registers is pretty easily solvable. Heck x87 already has that basic concept down with the stack registers. The only missing piece is moving overflow values onto and off of the stack. It's a fairly easy to solve problem.

That's effectively what Mill proposed in their docs. The "belt" notation was their cute way of doing that.

Re:GCC Rust Approved by GCC Steering Committee by jcranmer on Monday July 11, 2022 @08:30PM (#32064070)
> The problem of infinite registers is pretty easily solvable. Heck x87 already has that basic concept down with the stack registers. The only missing piece is moving overflow values onto and off of the stack. It's a fairly easy to solve problem.

You still have a limited window of 8 registers. Need 9 simultaneous live values? Oops, too few registers! In order to encode infinite registers, you need to be able to support referring to an arbitrary number of registers at once, which means you need an arbitrary-length register number specifier... have fun handling that in hardware!

Re:GCC Rust Approved by GCC Steering Committee by cogman10 on Monday July 11, 2022 @08:47PM (#32064194)
> The only missing piece is moving overflow values onto and off of the stack.

Already addressed and not really that hard of an issue to solve. Hardware already has all the logic embedded in it to be able to load or store memory into/from registers.

The logic would mirror the logic done by compilers when they are allocating registers and deciding what needs to be evicted to the stack.

The only missing piece is where that memory should be, but that's really as simple as having either the OS or the application logic allocate a special memory region for the purpose of register evictions and loads.

Re:GCC Rust Approved by GCC Steering Committee by pjmlp on Tuesday July 12, 2022 @04:34AM (#32067055)
And yet we are in the middle of adoption of hardware memory tagging architectures, as last resort to fix C and the languages copy-paste compatible with it, the irony.
Re:GCC Rust Approved by GCC Steering Committee by mcronce on Monday July 11, 2022 @11:53AM (#32057792)
You actually can - https://llvm.org/docs/CommandGuide/lli.html

LLVM's original purpose was something analogous to the JVM, but it's obviously evolved to be more of a compiler platform, debugging toolchain, etc these days

(No direct hardware support, though, as cool as that sounds)

Re:GCC Rust Approved by GCC Steering Committee by gpm on Monday July 11, 2022 @11:54AM (#32057805)
Probably not a chip, since the intermediate language is optimized for optimizing and compiling, not for executing quickly.

Meanwhile normal instruction sets are just a bytecode optimized to run quickly.

LLVM-IR at least also isn't stable, so not a good thing to bake into a chip - but you could conceivably make a stable intermediate language.

Re:GCC Rust Approved by GCC Steering Committee by Blackthorn on Monday July 11, 2022 @11:49AM (#32057724)
At some point in history there was a jvm chip like that. It's long gone, not sure for what reason.
Re:GCC Rust Approved by GCC Steering Committee by 1980phipsi on Monday July 11, 2022 @12:01PM (#32057895)
I would be worried about the intermediate code not being stable over time.
Re:GCC Rust Approved by GCC Steering Committee by pjmlp on Monday July 11, 2022 @12:28PM (#32058294)
Unless one keeps it stable, like Apple did for watchOS.

However they apparently don't want to keep fixing upstream changes and is now deprecated going forward.

Re:GCC Rust Approved by GCC Steering Committee by tendstofortytwo on Monday July 11, 2022 @12:22PM (#32058191)
For a chip, I think you would run into the same problems as Intel iAPX if you did that: https://en.wikipedia.org/wiki/Intel_iAPX_432
Re:GCC Rust Approved by GCC Steering Committee by kergonath on Monday July 11, 2022 @12:48PM (#32058559)
Something like a Low-Level Virtual Machine?

Short answer, it’s feasible in theory, but usually suboptimal.