Projects

Primarily focused on Server Standardisation. Examples to include SBSA, xBBR to enable simplified adoption of mainline builds on new server hardware.

Make ARM64 a first class citizen in the Hadoop/Spark community and scale-out analytics

This project focuses on making Arm and Linaro members SoCs a first class citizen in the Linux camera ecosystem. Primarily through development on the libcamera open source library which provides complex camera support to Chrome OS, Linux and Android but also Camera related work in the Linux kernel and RDK-C camera stack.

The Cloud infrastructure team focuses on cloud infrastructure technologies such as Kubernetes, OpenStack, Ceph, and container runtime.

We dedicate to make open-source cloud infrastructure projects have the capabilities of easy deployment, easy management, and good performance on Arm64.

We also run the Linaro Developer Cloud. It is a pure open-source cloud, free for developers. It offers the virtual machine instances and Kubernetes as a service. Link: www.linaro.cloud

Development of GNU Toolchain:

• GCC compiler
• We improve Link-Time Optimizations (LTO), SVE auto-vectorization optimizations, and microarchitecture-specific optimizations for popular Arm cores.
• We improve performance and scalability of Libgomp (GNU OpenMP runtime)
• We support compiler sanitizers (ASAN, TSAN, etc.) in GCC. Sanitizers are developed under LLVM Toolchain project, and sanitizer changes are then merged into GCC to have both LLVM and GNU toolchains provide sanitizer features.
• GDB debugger
• We develop support for new ARMv8.x architectural features and improve debugging experience.
• Glibc C Library
• We implement both target-specific and generic optimizations in Glibc. We then aim to propagate all relevant Glibc improvements to Newlib and Bionic C libraries.
• GNU Binutils assembler, BFD and Gold linkers
• In Binutils we implement ELF section-level optimizations, as well as workarounds for hardware errata.

High Performance Computing & Artificial Intelligence

Drive the adoption of ARM in HPC through standardisation, interoperability, orchestration and use case development. Leverage ARM-based hardware around server class infrastructure, multi-gigabit interconnect support, scalable vector extensions and software ecosystem support to build exascale HPC deployments. The engineering focus is on OpenHPC, application performance, AI solutions, SVE enablement and hardware deployment.

Development of LLVM Toolchain:

• Clang compiler
• We implement new and improve existing code-size and code-speed optimizations for AArch64 and ARM targets.
• LLDB debugger
• We develop support for new ARMv8.x architectural features and improve debugging experience.
• Compiler-RT runtime libraries
• We port and improve compiler sanitizers (ASAN, TSAN, etc.) to AArch64 and ARM architectures. Sanitizer changes are then merged into GCC to have both LLVM and GNU toolchains provide sanitizer features.
• LLD linker
• In LLD linker we implement ELF section-level optimizations, as well as workarounds for hardware errata.

The mission of the Linux Kernel Quality project is to improve the quality of the Linux kernel by testing its upstream and Android Common kernel on releases on Arm and X86 hardware and virtual platforms of various architectures.

You can learn more at lkft.linaro.org

TBD

Performance and Power Management have always been tightly linked because the power consumption often arises as a variable of the performance of the system. Mobile Phone world has been one of the most active contributors in this area with the aim to run always more powerful systems on always more constrained batteries. In fact, most of systems can’t afford to simply put everything to its maximum performance level but has to follow either a thermal budget or a maximum power budget. In this way, large systems also have to deal with those constraints in order to use their power budget efficiently and reach maximum performances. This project aims to improve the efficiency of all ARM based Linux systems, small or large, by improving Linux subsystems that influence its performance or power consumption, which includes the scheduler or the thermal framework in addition to the traditional power management subsystems.

Expanding various tools (especially QEMU) to emulate new ARM architectural features so open source projects can rapidly adopt the latest technology. We also continually improve ARMs hardware virtualization aiming for feature parity with other popular enterprise architectures.

There is a growing trend towards virtualization in areas other than the tradition server environment. The server enviroment is uniform in nature but as we move towards a richer echosystem in automotive, medical and general mobile and the IoT spaces, the rich array of hypervisors and SoCs become a problem.

Project Stratos is working towards developing hypervisor agnostic Virtio interfaces and standards.
The four key areas of interest are

• High performance Virtio interfaces
• Virtual Machine Monitors with a safety island
• Boot Orchestration
• Written Standards for the hypercalls

System Control and Management Interface (SCMI) has been designed to standardize the interface between a power coprocessor and other parts of a SoC. That includes the application processor (AP) on which we can have both rich OS like Linux but also a TEE like OP-TEE.
Each client of the power coprocessor has its own access point with specific control permissions on the power resources. But on some “medium/small” systems, the power coprocessor may not be present or doesn’t provide enough access points. In such a case, the AP itself has to control and filter the access to the power resources.
For security reason, the TEE must have the control of shared resources and populate the authorized resources to the non secure world. The TEE acts as a power coprocessor from Linux PoV and we can keep the SCMI interface.

Trusted Substrate project ambition is to upstream all necessary technologies in multiple projects to enable SystemReady compliance. Projects can be Trusted Firmware, OP-TEE, U-Boot, SCP, Linux kernel (EFI stub) and others.

Linaro's engineers are actively participating in upstream engineering communities. As a result, as maintainers, they become responsible for keeping their code upstream in sync with the overall development of respective upstream projects.