850 karma · joined October 17, 2014
This does not make MLIR the best infrastructure for building an industrial embedded Javascript compiler for instance (just like you wrote B3 to move away from LLVM), but I am not convinced that between these two, MLIR is the niche ;-) Time will tell!
Now think about use-cases like https://drive.google.com/file/d/19pSpEsi4I9-MKLRodD-po82HFCW... and what the MLIR ecosystem (if it develop can provide them). After 6 months of work, instead of having "just" an IR for their abstraction, they would likely have iterated on the IR, revisited their abstraction, write optimizations, and most importantly mapped their use-cases to heterogeneous HW! They can benefit fairly easily from the work of PlaidML on the affine/polyhedral optimizations for instance.
On the other hand, if a new HW vendor would like to expose their accelerator to a wide range of use-cases (whether it is Fortran OpenACC or the Stencil DSL), plugin lowering/backend to MLIR is a much efficient way than the alternative (which are almost non-existent today by the way).
If it was so easy to write its own compiler end-to-end from scratch, wouldn't LLVM be out of users by now?
> Andrej Karpathy basically threw everything out once he replaced Latner.
What are you basing this on? I don't believe there is any truth to this. First Chris was not replaced by Andrej but by Jim Keller and then Stuart Bowers. Andrej is amazing in his field and has done impressive things at Tesla, but he is managing the ML part of the org, which was a relatively small portion of the Autopilot Software group overall.
MLIR is getting used internally more and more inside TensorFlow, but also by separate team in different projects, like IREE for example (https://github.com/google/iree ). The TensorFlow lite converter has been replaced by the new MLIR-based one, similarly for the Edge TPU.
But more than that, what makes me confident is the traction we are getting outside Google. First, we landed MLIR in LLVM last month: https://github.com/llvm/llvm-project/commit/0f0d0ed1c78f1a80...
The LLVM Fortran frontend (f18/flang) which will merge soon in the LLVM monorepo is using MLIR for their own IR. It'll be exiting to develop a non-ML MLIR-based frontend within LLVM! In particular Flang is opening an HPC perspective that could be leveraged by other DSLs later. They are adding an OpenMP dialect to MLIR right now: https://llvm.discourse.group/t/rfc-openmp-dialect-in-mlir/39...
Intel has been actively porting their nGraph/PlaidML framework to be based on MLIR (search for "The Stripe dialect" and "nGraph Dialect" here: https://mlir.llvm.org/talks/ ).
I'm less familiar with S4TF, but I know they recently got some nice new hires, including https://twitter.com/DaveAbrahams/status/1207690883782467584
Today thousands are dying every year on the road, are we just forbidding cars entirely?
> And no, failover control is not acceptable given the past incidents and deaths.
How many incidents/deaths per miles driven? How does it compare to all the other transportation systems?
The LLVM Context is the unit of isolation between threads. For instance the multi-threaded ThinLTO optimizer/codegen will use one LLVM Context per-thread, and so each thread is processing a single Module / TU.
The issue for concurrency is fairly deep in LLVM (use-lists, constant stored uniquely in context, etc.) that would make it really difficult to address intra-module parallelism.
MLIR for example is designed with this in mind and the pass-manager is already multi-threaded at every level of nesting (function passes would runs on two functions of the same Module in parallel). This is causing other complication/inefficiency in the infrastructure, I'm still not sure how much it is a good tradeoff, we'll see...
Build systems like Bazel are providing some way to ensure some level of isolation that provides correctness guarantees. It also provide an easy way to statically build a superset of the files needed for each step of the build, allowing to integrate with a distributed service. Some related documentation/discussions can be found starting from https://docs.bazel.build/versions/master/remote-execution.ht... Another good source of information is online videos from BazelCon: https://conf.bazel.build
Disclaimer: I work on the MLIR/XLA team.
> As a Works with Nest developer and partner, you will not be able to access or control Nest devices once the Works with Nest APIs are turned off on August 31, 2019. Moving forward, our team will focus on making Works with Google Assistant the most helpful and intelligent ecosystem for the home, enabling all of the products in your users’ homes to work together. We encourage all smart home developers to visit the Actions on Google Smart Home developer site to learn how to integrate your devices or services with the Google Assistant.
I don't thinks it is a fair characterization: first the notion of "large" is fairly subjective. But more importantly the fact that they collect data on pre-determined triggers is just a guarantee that the dataset is not over-fitted (let say to the 280 and 101 in the Bay Area and to Elon's commute in LA) and instead has good coverage of the world.
Their capabilities of triggering on situation allows them to grow the dataset quickly in a supervised way. It is all about the granularity of these triggers, imagine that you can express "collect situation in tunnels with jerk higher than X m/s3" or "collect all lane change abort in snow condition", ... In the next 24h you get data from all over the world and this data is automatically tagged and classified by the neural net.
In the same way, to reach peak FLOPs on a GPU you better use the local/shared memory as much as possible.
When you read a novel written in the present tense, you don't assume it tells a story that is currently happening right? ;)
While the past tense makes sense from the author point of view describing what just happened until they typed `git commit`, I'm in the "present" camp since I find it more relevant to me when reading `git show <rev>`: it tells me what the commit is doing at this particular point in history. I don't really care about the programmer/author centric point of view at the time the message was written.
Bumping requirements is causing other problems than just being able to build with the just built compiler: namely deployment and integration in other products. For example, you may be forced to isolate components in dynamic library that talks with each others through C APIs and each statically link the C++ standard library. It can become fairly complicated when this does not fit your setup and you get forced into this because LLVM decided to bump their standard.
LLVM is currently moving to C++14, which is a pain for some users like TensorFlow for instance which supports Ubuntu 14.04: the c++ standard library is too old. There are technical solutions for everything but for a component like LLVM, not pressuring its users into convoluted workflow is important.
Of course the LLVM developpers would love to just use the latest version of the standard all the time. For the library part of the standard, it is worked around by having its own: https://github.com/llvm/llvm-project/blob/master/llvm/includ... (and others in the same directory)
UBI may be part of the next evolutionary step of society, we'll see, but I'm slightly bothered that it relies on the comfort and the wealthiness of the "first world" built to the detriment of the "third world". I personally feel that "people should be allowed to live" would be more convincing to me if it was about worldwide inequality rather than UBI in westerner society.