Or, more accurately: it's not possible to apply copyright to generated code; if you don't release it, it's a trade secret, but if you do, people can use it how they please.
At least with LG TVs you can just not give them the internet and nothing of value is lost (at least assuming you have an Apple TV or other trusted smart tv capability). Much more difficult to not give the windows PC internet and have it be useful (at least mine is only used for gaming).
I'm still astounded my Ford's infotainment system takes 5-10 seconds after opening the radio "app" to present me with the station selection UI. Most of that seems to be some sort of startup delay. The mind boggles.
I'm frankly amazed at the speed at which the Ford and Chevy native UIs will take over from CarPlay for functions like reverse camera, lane camera etc. You'd expect some delay/lag but it's pretty responsive which obviously is essential for safety.
It’s federal regulations. If the reverse camera screen doesn’t appear quickly enough, the car gets recalled and fixed. This has happened to many manufacturers.
Ford, Toyota, Lexus, etc. This notice from Tesla actually specifies the regulation:
> On affected vehicles, upon vehicle power up, a certain software configuration may prevent camera streams from being sent to the MCU for up to 11 seconds, causing a loss of rearview image for up to 11 seconds for drivers who shift into reverse during this time, which does not comply with FMVSS 111, S5.5.3.
AFAICT, they always run in the background anyway. CarPlay is mostly just a pass through canvas rendered on the phone. The system can decide at anytime to overlay something on the CarPlay canvas.
I'm somewhat dubious about anything talking about low level performance programming at the instruction level that doesn't distinguish between latency and throughput, never mind mention the incredibly out-of-order nature of modern desktop/server class CPU cores.
That's a very important point. For instance on Intel's CPUs multiplication is pipelined - its latency is 3 cycles, but throughput is 1 cycle. Thus completing N multiplication takes 2 + N cycles (in the best case), not 3 * N.
Or economies of liability and buck passing. I suspect managers and businesses will still want to be in the game of "not my fault, supplier is working on it, we can sue them if they don't meet SLA".
It will be interesting to see if this solves any issues that aren't already addressed by the likes of matlab / SciPy / Julia. Reading the paper it sounds a lot like "SciPy but with MLIR"?
It's more like OpenXLA or the PyTorch compiler, that codegens Kokkos C++ kernels from MLIR defined input programs, which for example can be outputted from PyTorch. Kokkos is common in scientific computing workloads, so outputting readable kernels is a feature in itself. Beyond that there's a lot of engineering that can go into such a compiler to specifically optimize sparse workloads.
What I am missing is a comparison with JAX/OpenXLA and PyTorch with torch.compile().
Also instead of rebuilding a whole compiler framework they could have contributed to Torch Inductor or OpenXLA, unless they had some design decisions that were incompatible. But it's quite common for academic projects to try to reinvent the wheel. It's also not necessarily a bad thing. It's a pedagogical exercise.
I think the exactly opposite, if someone was able to build a framework that doesn't overly constrain the problem, and doesn't require weeks of screwing around with the build, integration of half baked components and insane amounts of boilerplate, that would be a fantastic contribution in and of itself even it didn't advance the state of tensor compilation in any other way.
FORmula TRANslation, the clue is in the name. It's great at math, but yeah, strings and OS stuff is a PITA. The modern vector-based syntax is still really nice and I've yet to come across a C++ library quite as slick.
But I think what it was really missing last time I looked at it was good access to compiler intrinsics (or otherwise) to hit vectorizations and math optimization instructions. The OpenMP simd pragmas weren't really doing a fantastic job. I hope that's better now it's in LLVM.
I suspect main benefits are they have no need to maintain the hardware or software for any longer than it makes sense for their own needs, and don't have to handhold users through a constantly evolving minefield of performance and technical capabilities.
I think the current generation of tools have a long way to go before I trust any numerical algorithm they implement, based on our recent experiments trying to make it implement some linear algebra by calling LAPACK. When we asked it to write some sparse linear algebra code based on some more obscure graph algorithms it produced some ugly stepchild of dijkstra's algorithm instead, which needless to say did not achieve the desired aim.
