151–160 of 169 posts
Earlier quoted context omitted.
What’s even stranger is that as a 26 year old this is my first time hearing that compilers used to be paid for :) what a great indication of the FOSS movement’s success
"used to be" They still are in many cases. Proprietary compilers for embedded devices (MCUs, FPGAs, etc.) are still commonplace. The license for the full Intel compiler suite discussed here isn't free either.
Earlier quoted context omitted.
What that sentence actually means is "we don't want to help our competition (AMD, NVIDIA) but we don't want to re-implement the wheel". The API and fundamental part of LLVM is its IR, LLVM-IR, which is where most optimizations happen. From this point-of-view, LLVM is a "platform", and an extremely brittle one: every release has breaking changes to the IR, the IR is constantly evolved to support new hardware and new o…
Same thing with C++Builder whose last version from this year is still based on LLVM 5, I think. Even Apple's clang is behind LLVM upstream if I'm not mistaken. The joy of permissive licenses!
Earlier quoted context omitted.
If Johnny/Jane didn't want their contributions to be used like that they could have licensed them differently though, or contributed to gcc instead. Of course llvm wouldn't accept their contributions if they were licensed under, say, the AGPL. But presumably getting their changes upstreamed is not a condition for completing their thesis, so it's their choice. As a PHD student they are hopefully capable of reading and…
True, except in this fictional story maybe the condition was set by the professor, university department and not a free option of the respective student that now sees his work being abused by a mega corp too cheap to contribute back.
In any case, it sounds like you want to blame the llvm license for the bad feelings the student might have, but that blame is misdirected: the student should aim their anger (if any) at their professor or university for introducing unreasonable requirements. Or maybe they should suck it up because without llvm they would have had to pick another subject for their thesis. I suspect that llvm wouldn't have grown to where it is now (for better or for worse) with a copyleft license. And then our student would have been "forced" to contribute to gcc instead, and sign over their copyright to the fsf instead.
Finally I think the academic world is a lot like permissive licenses already. Anyone can read papers, use that information in any way, and there is no obligation to contribute back. Only when writing new papers are you expected to acknowledge your sources.
Earlier quoted context omitted.
clang already builds Linux kernel on Mountain View dungeons, and it has been doing that for a couple of years now. Those changes just don't get to upstream.
That's...not true? https://www.kernel.org/doc/html/latest/kbuild/llvm.html I could be missing something, but I don't see any suggestion that you need a specific forked tree with patches to build with LLVM, and I've seen people filing bugs about using LLVM sanitizers to build the vanilla tree, so I don't think the expectation is that you need to apply a huge out of tree patchset for this to work any more?
AFAICT from the issues page, Clang and binutils/LLVM tools work fine with no patches for the mainstream archs and when not trying to be super-fancy with custom flags. The more non-mainstream one goes with arch or flags the more likely one will run into something.
[0] https://github.com/ClangBuiltLinux/linux/issues (Note they use github for issues/wiki, not code, so no surprise the 'linux version' in code is oldish).
Earlier quoted context omitted.
Everyone says software monocultures are bad, without evidence. In fact, there seems to be evidence against this: the Linux kernel.
The Linux kernel isn't a monoculture yet. For example there is no indication Apple or the BSDs are going to stop developing their kernels nor is there indication Windows is dropping NT and most anything can/is easily moved between them (particularly the *NIX kernels) still. That doesn't mean there are certain places the only choice is the Linux kernel but that alone isn't enough to make it a monoculture in this sense…
Anyone actually use Intel compilers
Earlier quoted context omitted.
True, except in this fictional story maybe the condition was set by the professor, university department and not a free option of the respective student that now sees his work being abused by a mega corp too cheap to contribute back.
Sure, in that very specific and somewhat unlikely scenario. Maybe the professor demanded a handjob as well. Or perhaps the university claims ownership over all intellectual property produced by the PhD student as part of their thesis, and they're unable to upstream their source to any project under any license. In any case, it sounds like you want to blame the llvm license for the bad feelings the student might have,…
How are those PlayStation 5 optimisations working out?
Guess which compiler is currently lagging in ISO C++ 20 support.
Earlier quoted context omitted.
My understanding was the llvm was made because the code basis of gcc is too complicated. Since seems to be a killer move.
That was a long time ago and the actual primary reason was apparently Stallman missed an email [1], although I think the intentional technical hurdles to plugins was another of many reasons. When GNU moved all their software to GPLv3 and the business community decided they didn’t like that license and Apple brought LLVM as a serious contender. GCC hasn’t remained stagnant though. [1] https://lwn.net/Articles/632062/
I'm not sure I love this. I mean, LLVM is awesome and everthing, but software monocultures are pretty bad. It's not like the situation is dire yet (given that there are also GCC and MSVC), but you can imagine a situation in a couple of years when Microsoft goes "yeah, we're also gonna go with LLVM now" and also GCC starting to fade away. It's a bit concerning. Also: if icc is going to go with LLVM as a backend, then…
The recent CPPCast episode on LFortran might shed some light on that? https://cppcast.com/lfortran/ In it, the guest talks about how he couldn't rely on LLVM for things like optimizing array operations; LLVM apparently does a poor job of that so he had to implement his own. Given that one of the key selling points of Intel's compiler is that it does a better job with SIMD optimizations, it may be exactly the same sto…
The LLVM IR doesn't understand array operations, so the Fortran frontend must 'scalarize' the array expressions, that is, turn them into the equivalent loops. Only after that can the LLVM middle and back-ends try to vectorize that scalar IR for execution on SIMD (or vector, or GPU) HW. The problem is that this scalarization loses some information, and thus for good performance on array code the Fortran frontend must implement some optimizations on array operations before scalarizing.
There is an LLVM subproject called MLIR (https://mlir.llvm.org/ ) that aims to build a higher level IR that understands arrays, and can be useful for things like optimizing deep learning graphs, but also things like Fortran frontends could make use of it. AFAIK the flang Fortran project aims to make use of it, but I haven't followed development that closely.
Earlier quoted context omitted.
There is significant investment in building Linux with Clang so I wouldn't count on Linux keeping GCC relevant forever. Doubly so with the inevitable rustc requirement.
Isn't that the other way around? I thought clang was trying to support all gcc extensions to be able to build Linux kernel. I would rather see both of these compilers to stay competitive to push themselves higher.