Linaro Blog

> AMD could release a 2x powerful GPGPU tomorrow for half the price and most current NVIDIA users wouldn't care because what good is that if you can't program it?. Correction: Nobody will be able to use the AMD hardware (outside of computer graphics) because everybody has been locked-in with CUDA on Nvidia. They can not even change even if they want to: it is pure madness to reprogram an entire GPGPU software stack every 2 years just to change your hardware provider. And I think it will remain like that until NVidia get sued for anti-trust. > ARM and Intel make great software [..] doesn't open-source any of that either for the same reasons as NVIDIA. That's propaganda and it's wrong. Intel and ARM contribute a lot to OSS. Most of the software they release nowadays is Open Source. This includes compiler support, drivers, libraries and entire dev environment: mkl-dnn, TBB, BLIS, ISPC, "One", mbedTLS.... ARM has even an entire foundation only to contribute to OSS (https://www.linaro.org/) . Near to that, NVidia does close to nothing. There is no justification to NVidia's attitude related to OSS. It reminds me the one of Microsoft at its darkest days. The only excuse I can see to this attitude is greed. I hope at least they do not contaminate Mellanox with their toxic policies. Mellanox was an example of successful Open Source contributor/company (up to now) with OFabric (https://www.openfabrics.org/). It would be dramatic if this disappear.

ARM has helped found Linaro (linaro.org) ~10 years ago to fix the problem with mainline Linux integration for all the participating SoC vendors. You should expect the following manufacturers to have good mainline support: https://www.linaro.org/membership/ I am sure your mileage will vary between vendors (I am pretty sure Qualcomm was NOT one of the founding members, but it's there now), but this at least signals an investment of money and resources.

Two groups probably have more experience in that than others: Linaro: https://www.linaro.org/ OpenWRT: https://www.openwrt.org/ Going on a bit of a tangent: Most of the time these companies just don't care. If you don't mind getting your hands dirty, then have a look at some vendor kernel trees. For example, a $300AUD router released last year is running 2.6.34brcm - http://www.tp-link.com.au/download/Archer-D9.html#GPL-Code The 802.11AC card in that router will likely never have open source drivers. I'm pretty sure the routing engine is closed source too, although with 2x Cortex A9 chips I would have thought you could get away with doing it in software.

TrustZone alone is much closer to a SecureBoot or TPMish feature than ME. It's possible it would allow implementation of an ME-like software stack running inside the TEE. It's worth mentioning that there is at least one OSS implementation of a TEE software stack, OP-TEE, making this even less of an issue. Assuming your device/soc mfg doesn't lock you out. http://www.linaro.org/blog/core-dump/op-tee-open-source-security-mass-…

There are many Linux kernel driver hackers who work remotely as contractors, for example for http://www.linaro.org/.

I even made a cheesy video ;-) http://www.youtube.com/watch?v=vX61U_q6ksg Board: http://pandaboard.org/ OS: http://www.linaro.org/

Does anyone know if there's been any efforts towards running freeBSD on arm64 laptops? On Linux there's been some effort: https://www.linaro.org/blog/linux-on-snapdragon-x-elite/ Ed: hn discussion: https://news.ycombinator.com/item?id=44699393

It is packaged by Ubuntu. Linaro is doing the work with Qualcomm. https://www.linaro.org/blog/qualcomm-and-linaro-enable-latest-flagship…

That's disappointing, since mainline Linux support has made progress, https://www.linaro.org/blog/qualcomm-and-linaro-enable-latest-flagship…

In this case, Linaro has mostly been getting everything running with mainline kernel (and upstreaming their work): https://www.linaro.org/blog/qualcomm-and-linaro-enable-latest-flagship… . So things are looking a lot better than the usual Android ecosystem imo.

That's certainly been the case in the past but they've clearly changed their strategy of late. They've upstreamed support for snapdragon 8g3 and I think also X (or x is in progress?). https://www.linaro.org/blog/upstream-linux-support-now-available-for-t… https://www.linaro.org/blog/qualcomm-and-linaro-enable-latest-flagship…

The actual announcement https://www.linaro.org/blog/upstream-linux-support-now-available-for-t…

One thing I was curious about but couldn’t work out from reading online is whether hardware-assisted tracing is supported. (see https://www.linaro.org/blog/coresight-perf-and-the-opencsd-library/ or https://www.youtube.com/watch?v=Gm2ZXIB18PQ for descriptions. This uses the ARM CoreSight/Embedded Trace Macrocells feature. The Intel equivalent is something called Intel Processor Trace. MacOS doesn’t seem to expose this tracing functionality in the way that perf on linux may, and the publically released Darwin source code seems to barely mention it). Has anyone here installed Linux on an M1/2 computer and checked if the hwtracing support works?

Does that happen at the firmware level or the driver level? It seems Qualcomm devices are pretty actively developed in the Linux kernel? I found Linaro, which claims to be doing work on Qualcomm devices: https://www.linaro.org/blog/highlights-from-linaro-connect-on-qualcomm…

Linaro is also doing a lot in that space (at least for ARM): https://www.linaro.org/os-build-and-test/

Linaro | Software Automation Engineer | REMOTE (US/UK) | Full-Time I'm hiring for a position on our Linux Kernel Validation team which performs CI/CD on upstream Linux kernel branches, with a particular focus on long term stable branches. Full details @ https://www.linaro.org/careers/#op-167495-software-automation-engineer Feel free to contact me directly at [email protected] with questions or interest, or apply on the website.

http://www.linaro.org/linaro-blog/2011/08/15/enabling-device-tree-supp… The Linaro kernels ("Linaro Stable Kernel" is the keyphrase) boot from devicetrees (aka FDTs). Not sure how much of that is upstreamed, but devicetrees are pretty standard in the ARM world as far as I can tell. (Also, in general if you're doing Linux stuff on ARM, Linaro is the place to look for everything). Edit: actually, that link isn't very relevant - I just lazily googled "linaro devicetree". But you should be able to find more info!

There's a vital word missing because the title needed to be truncated. These guys are already rolling out linux-based devices, this new company they are forming together isn't going to produce devices, just to make that process go faster and easier. Most of the comments think this is designed to compete with things (Android, Ubuntu etc.) that it's actually designed to work with and make better on the hardware platforms they care about. Interesting reading in the FAQs: http://www.linaro.org/faqs/

For reference, [0] appears to be the referenced paper. The relevant passage: > To understand how disabling these optimizations may impact performance, we ran SPECint 2006 with GCC and Clang, respectively, and measured the slowdown when compiling the programs with all the three -fno-* [-fno-strict-overflow, -fno-delete-null-pointer-checks, and -fno-strict-aliasing] options shown in Figure 9. The experiments were conducted on a 64-bit Ubuntu Linux machine with an Intel Core i7-980 3.3 GHz CPU and 24 GB of memory. We noticed slowdown for 2 out of the 12 programs, as detailed next. > 456.hmmer slows down 7.2% with GCC and 9.0% with Clang. The first reason is that the code uses an int array index, which is 32 bits on x86-64, as shown below. int k; int *ic, *is; ... for (k = 1; k <= M; k++) { ... ic[k] += is[k]; ... } > As allowed by the C standard, the compiler assumes that the signed addition k++ cannot overflow, and rewrites the loop us- ing a 64-bit loop variable. Without the optimization, however, the compiler has to keep k as 32 bits and generate extra in- structions to sign-extend the index k to 64 bits for array access. This is also observed by LLVM developers [14]. > Surprisingly, by running OProfile we found that the most time-consuming instruction was not the sign extension but loading the array base address is[] from the stack in each iteration. We suspect that the reason is that the generated code consumes one more…

pocl (Portable Computing Language) [1] provides a remote backend [2] that allows for serialization and forwarding of OpenCL commands over a network. Another solution is qCUDA [3] which is more specialized towards CUDA. In addition to these solutions, various virtualization solutions today provide some sort of serialization mechanism for GPU commands, so they can be transferred to another host (or process). [4] One example is the QEMU-based Android Emulator. It is using special translator libraries and a "QEMU Pipe" to efficiently communicate GPU commands from the virtualized Android OS to the host OS [5]. The new Cuttlefish Android emulator [6] uses Gallium3D for transport and the virglrenderer library [7]. I'd expect that the current virtio-gpu implementation in QEMU [8] might make this job even easier, because it includes the Android's gfxstream [9] (formerly called "Vulkan Cereal") that should already support communication over network sockets out of the box. [1] https://github.com/pocl/pocl [2] https://portablecl.org/docs/html/remote.html [3] https://github.com/coldfunction/qCUDA [4] https://www.linaro.org/blog/a-closer-look-at-virtio-and-gpu-virtualisa… [5] https://android.googlesource.com/platform/external/qemu/+/emu-master-d… [6] https://source.android.com/docs/devices/cuttlefish/gpu [7] https://cs.android.com/android/platform/superproject/main/+/main:devic… [8]…