Hubbry Logo
search
logo
LEON avatar
LEON
LEON
current hub
L

LEON

logo
Community Hub0 Subscribers
Read side by side
LEON
View on Wikipedia
from Wikipedia
LEON
General information
Launched1997; 28 years ago (1997)
Marketed byAirbus Defence and Space
Designed bySun Microsystems (acquired by Oracle Corporation)
(instruction set, original design[clarification needed])
European Space Agency (ESA)
Gaisler Research
(processor, design derivative[clarification needed])
Common manufacturer
Performance
Max. CPU clock rate150 MHz[1] to 1500 MHz[2]
Architecture and classification
Instruction setSPARC V8
Physical specifications
Cores
  • 1
History
PredecessorERC32

LEON (from Spanish: león meaning lion) is a radiation-tolerant 32-bit central processing unit (CPU) microprocessor core that implements the SPARC V8 instruction set architecture (ISA) developed by Sun Microsystems. It was originally designed by the European Space Research and Technology Centre (ESTEC), part of the European Space Agency (ESA), without any involvement by Sun. Later versions have been designed by Gaisler Research, under a variety of owners. It is described in synthesizable VHSIC Hardware Description Language (VHDL). LEON has a dual license model: An GNU Lesser General Public License (LGPL) and GNU General Public License (GPL) free and open-source software (FOSS) license that can be used without licensing fee, or a proprietary license that can be purchased for integration in a proprietary product.[3][4] The core is configurable through VHDL generics, and is used in system on a chip (SOC) designs both in research and commercial settings.[5]

History

[edit]

The LEON project was begun by the European Space Agency (ESA) in late 1997 to study and develop a high-performance processor to be used in European space projects.[6] The objectives for the project were to provide an open, portable and non-proprietary processor design, capable to meet future requirements for performance, software compatibility and low system cost. Another objective was to be able to manufacture in a single-event upset (SEU) tolerant sensitive semiconductor process. To maintain correct operation in the presence of SEUs, extensive error detection and error handling functions were needed. The goals have been to detect and tolerate one error in any register without software intervention, and to suppress effects from Single Event Transient (SET) errors in combinational logic.

The LEON family includes the first LEON1 VHSIC Hardware Description Language (VHDL) design that was used in the LEONExpress test chip developed in 0.25 μm technology to prove the fault-tolerance concept. The second LEON2 VHDL design was used in the processor device AT697 from Atmel (F) and various system-on-chip devices. These two LEON implementations were developed by ESA. Gaisler Research, now part of Frontgrade (previously Aeroflex and Cobham), developed the third LEON3 design and has announced the availability of the fourth generation LEON, the LEON4 processor.[7]

LEON processor models and distributions

[edit]

A LEON processor can be implemented in programmable logic such as a field-programmable gate array (FPGA) or manufactured into an application-specific integrated circuit (ASIC). This section and the subsequent subsections focus on the LEON processors as soft IP cores and summarise the main features of each processor version and the infrastructure with which the processor is packaged, referred to as a LEON distribution.

All processors in the LEON series use the SPARC V8 reduced instruction set computer (RISC) ISA. LEON2(-FT) has a five-stage pipeline while later versions have a seven-stage pipeline. LEON2 and LEON2-FT are distributed as a system-on-chip design that can be modified using a graphical configuration tool. While the LEON2(-FT) design can be extended and re-used in other designs, its structure does not emphasise re-using parts of the design as building blocks or enable designers to easily incorporate new IP cores in the design.

The standard LEON2(-FT) distribution includes the following support cores:[8]

The LEON3, LEON3FT, and LEON4 cores are typically used together with the GRLIB IP Library. While the LEON2 distributions contain one design that can be used on several target technologies, GRLIB contains several template designs, both for FPGA development boards and for ASIC targets that can be modified using a graphical configuration tool similar to the one in the LEON2 distribution. The LEON/GRLIB package contains a larger number of cores compared to the LEON2 distributions and also include a plug and play (PnP) extension to the on-chip Advanced Microcontroller Bus Architecture (AMBA) bus. IP cores available in GRLIB also include:[9]

FPGA design flow

[edit]

Design flow documentation for the LEON into FPGA are available from the manufacturer[10] and from third party resources.[11]

Terminology

[edit]

The term LEON2/LEON2-FT often refer to the LEON2 system-on-chip design, which is the LEON2 processor core together with the standard set of peripherals available in the LEON2(-FT) distribution. Later processors in the LEON series are used in a wide range of designs and are therefore not as tightly coupled with a standard set of peripherals. With LEON3 and LEON4 the name typically refers to only the processor core, while LEON/GRLIB is used to refer to the complete system-on-chip design.

LEON2 processor core

[edit]

LEON2 has the following characteristics:

  • The GNU LGPL allows a high degree of freedom of intervention on the freely available source code.
  • Configurability is a key feature of the project,[12] and is achieved through the usage of VHDL generics.[13]
  • It offers all basic functions of a pipelined in-order processor.
  • It is a fairly sized VHDL project (about 90 files, for the complete LEON2 distribution, including peripheral IP cores)

LEON2-FT processor core

[edit]

The LEON2-FT processor is the single-event upset fault tolerant (FT) version of the LEON2 processor. Flip-flops are protected by triple modular redundancy and all internal and external memories are protected by EDAC or parity bits. Special licence restrictions apply to this IP (distributed by the European Space Agency[8]). Among other satellites, the processor was used in ESA's Intermediate eXperimental Vehicle (IXV) in 2015[14] and China's Chang'e 4 lunar lander.[15]

LEON3 processor core

[edit]

The LEON3 is a synthesisable VHDL model of a 32-bit processor compliant with the SPARC V8 architecture. The model is highly configurable, and particularly suitable for system-on-a-chip (SoC) designs. The full source code is available under the GNU GPL license, allowing use for any purpose without licensing fee. LEON3 is also available under a proprietary license, allowing it to be used in proprietary applications.

There are several differences between the two LEON2 processor models and the LEON3. LEON3 includes SMP support and a seven-stage pipeline, while LEON2 does not support SMP and has a five-stage pipeline.

LEON3FT processor core

[edit]

The LEON3FT is a fault-tolerant version of the standard LEON3 SPARC V8 Processor. It has been designed for operation in the harsh space environment, and includes functionality to detect and correct single-event upset (SEU) errors in all on-chip RAM memories. The LEON3FT processor supports most of the functionality in the standard LEON3 processor, and adds the following features:

  • Register file SEU error-correction of up to 4 errors per 32-bit word
  • Cache memory error-correction of up to 4 errors per tag or 32-bit word
  • Autonomous and software transparent error handling
  • No timing impact due to error detection or correction

The following features of the standard LEON3 processor are not supported by LEON3FT

The LEON3FT core is distributed together with a special FT version of the GRLIP IP library. Only netlist distribution is possible.

An FPGA implementation called LEON3FT-RTAX was proposed for critical space applications.,[16] but it has been discontinued.

LEON4 processor core

[edit]

In January 2010, the fourth version of the LEON processor was released.[7] This release has the following new features:

  • Static branch prediction added to pipeline
  • Optional level-2 cache
  • 64-bit or 128-bit path to AMBA AHB interface
  • Higher performance possible (claimed by manufacturer: 1.7 DMIPS/MHz as opposed to 1.4 DMIPS/MHz of LEON3)
  • Rad hardened.[1]

LEON5 processor core

[edit]

Real-time OS support

[edit]

The Real-time operating systems that support the LEON core are currently RTLinux, PikeOS, eCos, RTEMS, Nucleus, ThreadX, OpenComRTOS, VxWorks (a port by Gaisler Research), LynxOS (also a port by Gaisler Research), POK[17] (a free ARINC653 implementation released under the BSD licence) and ORK+,[18] an open-source real-time kernel for high-integrity real-time applications with the Ravenscar Profile, Embox[19] an open-source configurable real-time OS which allows using Linux software without Linux.

See also

[edit]

References

[edit]
[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

LEON

View on Grokipedia
from Grokipedia
LEON is a family of radiation-hardened 32-bit central processing unit (CPU) cores that implement the SPARC V8 instruction set architecture, developed by the European Space Agency (ESA) primarily for embedded systems in space missions and high-reliability applications.[1] The LEON project originated in the 1990s as part of ESA's efforts to foster European independence in space electronics, amid concerns over reliance on foreign components, under initiatives like the European Components Space Qualification and Standardization Program.[2] Initial development focused on creating synthesizable VHDL models for custom system-on-chip designs, with the first major release being the LEON2 in the early 2000s, followed by the LEON3, certified as SPARC V8 compliant by SPARC International in 2005.[3] Subsequent iterations, including the fault-tolerant LEON2-FT (manufactured as the AT697 by Atmel), LEON3 (with a seven-stage pipeline and multiprocessing support for up to 16 cores), LEON4 (featuring branch prediction and up to 1.7 DMIPS/MHz performance), and LEON5 (optimized for high-end FPGAs and ASICs), have progressively enhanced configurability, speed (up to 1500 MHz on 32 nm processes), and integration options like AMBA AHB/APB buses and optional floating-point units. The latest development includes the GR765, an octa-core SoC with LEON5FT SPARC V8 cores (or selectable RISC-V), presented in 2025.[1][4][5] Key features of the LEON family include high radiation tolerance, with linear energy transfer (LET) thresholds exceeding 100 MeV·cm²/mg and total ionizing dose (TID) ratings up to 300 krad(Si), making them SEU-proof through techniques like triple modular redundancy in fault-tolerant variants such as LEON3FT and LEON4FT.[4] These cores are highly modular, supporting configurable instruction and data caches (1-256 KB), scratchpad RAM, memory management units, and debug interfaces, while enabling both single-core and multi-core configurations in ASICs and FPGAs from vendors like Microchip and Frontgrade Gaisler.[3] Performance metrics vary by model, with LEON3 achieving 1.4 DMIPS/MHz and up to 400 MHz on 0.13 µm ASICs, and later versions scaling to over 400 DMIPS per core in quad-core setups like the GR740.[1] LEON processors have been deployed in numerous space missions, powering critical subsystems such as flight computers, GPS receivers, star trackers, and payload controllers.[2] Notable examples include the Gaia mission for star mapping (LEON2-FT, launched 2013), BepiColombo to Mercury (LEON2-FT, launched 2018), the Sentinel satellites for Earth observation (LEON2-FT in receivers and trackers, ongoing since 2014), Proba-V for vegetation monitoring (AT697 in flight computer, launched 2013), Alphasat telecommunications satellite (LEON2-FT in star tracker and payload, launched 2013), and the Intermediate eXperimental Vehicle (IXV) for reentry testing (LEON2-FT avionics, 2015).[2] Beyond ESA programs, variants like the GR712RC (dual-core LEON3FT) have supported missions such as Argotec's LICIACube on NASA's DART impactor (2022).[6] The family's open-source elements and robust software ecosystem, including real-time operating systems like RTEMS and VxWorks, have solidified its role in advancing autonomous, radiation-resilient computing for satellites, scientific instruments, and deep-space exploration.[3]

Overview

Architecture and Compliance

The LEON processors implement the SPARC V8 instruction set architecture (ISA) as a 32-bit reduced instruction set computing (RISC) microprocessor core, conforming to the IEEE-1754 standard. This architecture supports a full set of integer operations, including multiplication and division, with optional extensions for floating-point arithmetic compliant with SPARC V8 specifications. The design emphasizes synthesizability in VHDL for both field-programmable gate arrays (FPGAs) and application-specific integrated circuits (ASICs), enabling customization for embedded systems while maintaining compatibility with the SPARC V8's load/store model and register windowing mechanism.[3][7][1] LEON processors incorporate radiation-tolerant features tailored for space environments, where single-event upsets (SEUs) from cosmic radiation pose significant risks. Fault-tolerant variants, such as LEON3FT, employ triple modular redundancy (TMR) at the register-transfer level (RTL) for critical logic paths and integrate error detection and correction (EDAC) mechanisms using a Bose-Chaudhuri-Hocquenghem (BCH) algorithm. This EDAC scheme adds 7 check bits to each 32-bit word, enabling correction of up to four-bit errors and detection of additional errors in registers and caches without performance penalties, and is applied to the register file, caches, and external memories like SRAM and SDRAM. Optional Reed-Solomon coding further enhances SDRAM protection against multi-bit errors.[7][1][3] The register file structure adheres to SPARC V8 conventions, featuring 32 visible general-purpose 32-bit registers organized via an 8-window overlapping scheme, backed by 136 physical registers each widened to 39 bits (32 data bits plus 7 BCH parity bits for EDAC). An optional floating-point unit (FPU), such as the GRFPU, provides 32 dedicated 32-bit registers for single- and double-precision operations, executing in parallel with the integer unit to minimize latency. The integer unit includes a hardware multiplier (2-cycle latency) and radix-2 divider (up to 35 cycles), while the FPU handles most operations in 4 cycles, except for division and square root (14-25 cycles).[7][3] Base LEON models, like LEON3, utilize a 7-stage pipeline with a Harvard architecture, comprising instruction fetch (FE), decode (DE), register access (RA), execute (EX), memory (ME), exception (XC), and writeback (WB) stages to handle hazards and exceptions. The integer execution unit processes arithmetic and logical operations, interfacing with the FPU for coprocessor instructions, while separate cache controllers manage instruction and data accesses. In FPGA implementations, clock speeds reach up to 125 MHz, delivering performance metrics of approximately 1.4 Dhrystone MIPS per MHz (DMIPS/MHz).[3][7]

Key Features and Design Principles

The LEON processor family is designed with synthesizable VHDL models that facilitate seamless integration into system-on-chip (SoC) designs, allowing hardware engineers to target various FPGA and ASIC technologies without proprietary dependencies.[8] This approach stems from the core's implementation as a highly configurable IP block, compliant with the SPARC V8 architecture, enabling rapid prototyping and customization for embedded systems.[8] A core design principle of LEON is its modularity, which permits extensive customization through VHDL generics and parameters. For instance, engineers can adjust instruction and data cache sizes (from 1 KB to 4 MB), enable or disable the memory management unit (MMU), and select peripherals such as interval timers, UARTs, and interrupt controllers to match application requirements.[8] This configurability reduces resource overhead in resource-constrained environments like space missions, while the AMBA APB and AHB bus interfaces ensure compatibility with a wide array of third-party IP cores.[8] Fault tolerance is a foundational principle in LEON's fault-tolerant (FT) variants, particularly for radiation-hardened applications, where triple modular redundancy (TMR) is applied to critical registers and logic to mitigate single event upsets (SEUs) and single event transients (SETs). In LEON3-FT and later cores, TMR uses triple-voted flip-flops with skewed clocks to detect and correct errors, complemented by error detection and correction (EDAC) codes like BCH or Reed-Solomon on caches and memory controllers, achieving near-zero undetected error rates in SEU testing.[9] These techniques, validated through extensive fault injection campaigns, ensure reliable operation in high-radiation environments without compromising performance.[9] Power optimization in LEON emphasizes efficiency for battery-powered or thermally constrained systems, incorporating clock gating to disable unused pipeline stages and peripherals, as well as low-power sleep modes that halt the clock when the processor is idle.[8] These features, combined with a Harvard architecture and scalable pipeline depths, allow dynamic power consumption to scale with workload, often achieving sub-1W operation in embedded configurations.[8] The open-source nature of LEON, distributed under the GNU General Public License (GPL), promotes community-driven development and rigorous verification, with the full VHDL source code available for modification and extension.[8] This licensing model has fostered contributions from academic and industrial users, enhancing the core's robustness through shared testing suites and optimizations.[10]

History and Development

Origins and ESA Involvement

The LEON processor project was initiated in October 1997 by the European Space Agency's (ESA) Microelectronics Section at the European Space Research and Technology Centre (ESTEC) to develop a high-performance, radiation-tolerant microprocessor for upcoming space missions.[11] This effort addressed the need for processors capable of operating in harsh radiation environments while providing greater computational power than ESA's prior ERC32 design, targeting applications in satellites and scientific instruments.[12] The project emphasized low-cost development through synthesizable VHDL models, portability across ASIC and FPGA technologies, and built-in fault tolerance to mitigate single-event upsets (SEUs) without relying on expensive radiation-hardened fabrication processes.[11] The initial design was led by Jiri Gaisler, in collaboration with André Pouponnot, under the coordination of division head Richard Creasey, all ESA staff at the time.[12] Drawing on the open SPARC V8 instruction set architecture, the team aimed for software compatibility with existing tools and the ERC32, while achieving a target of 100 MIPS and 25 MFLOPS to support more complex onboard data processing.[11] ESA funded the project through internal resources and programs like the Technology Research Programme to foster European independence in space-qualified electronics, reducing reliance on proprietary U.S. processors such as the RAD6000, which faced export controls and high costs.[13] The core objective was to create an open, customizable alternative that promoted the SPARC standard, enabling cost-effective, high-reliability solutions for ESA's satellite programs.[11] Early evaluations of the LEON-1 prototype, completed by March 2000, demonstrated compliance with SPARC V8 through extensive simulations and over 250,000 injected errors to verify fault tolerance.[11] Synthesized on a 0.35 μm CMOS process, it operated at 100 MHz with 35K gates, delivering the targeted 100 MIPS performance, while an FPGA implementation on Xilinx VirtexE reached 45 MHz using 5,300 lookup tables.[11] These benchmarks confirmed the design's scalability and efficiency, paving the way for broader adoption in space applications. In January 2001, following Gaisler's departure from ESA after 12 years of service, he founded Gaisler Research to commercialize and advance the LEON technology, transitioning the project from ESA's internal development to a sustainable, industry-supported initiative.[14] This shift allowed for open-source release of the VHDL models, encouraging community contributions while maintaining ESA's oversight for space-qualified variants.[15]

Evolution and Key Milestones

The LEON processor family originated with the LEON1 prototype developed by the European Space Agency (ESA) in late 1997 as part of an initiative to create a high-performance, radiation-tolerant microprocessor for space applications. This initial version was a proof-of-concept design implementing the SPARC V8 architecture but was not intended for production, focusing instead on validating core concepts like fault tolerance and synthesizability in VHDL.[11] By 2000, the project advanced to the LEON2 release, which introduced support for the AMBA AHB/APB bus architecture to enable modular integration of peripherals and memory controllers, marking a shift toward more flexible system-on-chip designs. This version achieved its first silicon implementation in early 2001 using a 0.35 μm process, with further enhancements like the Debug Support Unit added in 2002, improving debugging capabilities for embedded applications. LEON2's fault-tolerant variant (LEON2-FT) became a cornerstone for space missions, offering five times the performance of prior ESA processors like the ERC32 while maintaining radiation hardness.[15][16] The LEON3 was introduced in 2005, bringing symmetric multiprocessing (SMP) support for up to 16 cores and an advanced debug unit that facilitated real-time monitoring and breakpoint handling in multi-processor environments. This iteration passed SPARC V8 compliance testing that year and included features like integrated cache controllers and enhanced interrupt handling, enabling more complex avionics systems. LEON3's fault-tolerant implementation saw early testing for single-event upset mitigation on radiation-hardened platforms, solidifying its role in ESA's growing portfolio of space-qualified components.[17][18] In 2010, the LEON4 launched as the fourth-generation processor, emphasizing power efficiency through a refined pipeline and dynamic voltage scaling options, alongside improved branch prediction to reduce energy consumption in low-power space scenarios. Targeted at next-generation microprocessors under ESA's NGMP program, LEON4 supported higher clock speeds up to 300 MHz in FPGA implementations and introduced better input/output virtualization for secure multi-partitioning. Its fault-tolerant version (LEON4-FT) integrated quad-core configurations in devices like the GR740, which became widely adopted for deep-space missions.[19][20] Development of the LEON5 spanned 2015 to 2020, culminating in its release in December 2019 as a superscalar, dual-issue processor delivering up to 85% higher performance than LEON4, with multi-core setups like the octa-core GR765 reaching up to 26,000 Dhrystone MIPS. This version enhanced support for DDR2/3 memory interfaces and advanced floating-point operations, making it suitable for computationally intensive tasks in modern spacecraft. LEON5's integration into octa-core systems like the GR765, with prototypes available by 2023 and flight models in 2024, represented a peak in SPARC-based evolution before transitioning toward RISC-V alternatives like the NOEL family. As of 2024, FPGA prototypes of the GR765 were available, with ASIC development continuing toward flight qualification.[21][22] From 2023 to 2025, LEON processors continued to integrate into high-profile missions, powering subsystems in ESA's Solar Orbiter (launched 2020, operational 2021) for instrument control and data processing units. These deployments highlighted LEON's reliability, with ongoing firmware updates ensuring compatibility with emerging standards. Licensing evolved under a dual model—GPL for open-source community use and proprietary options for commercial entities—fostering widespread adoption, as evidenced by inclusion in most ESA missions post-2010 and sales of hundreds of units to non-space sectors for high-reliability applications.[23][24][25][20][26]

Processor Cores

LEON2 Cores

The LEON2 processor core, released in 2000 as the first production implementation of the LEON family by the European Space Agency (ESA), introduced a configurable 5- to 7-stage pipeline for its integer unit, enabling efficient execution of SPARC V8 instructions in embedded systems.[27] It includes integrated debug support through the Debug Support Unit (DSU), which provides non-intrusive monitoring, breakpoints, watchpoints, and a configurable trace buffer for real-time analysis without halting the processor.[28] This core was designed for synthesis in both FPGA and ASIC technologies, prioritizing radiation tolerance and reliability for space applications while maintaining compatibility with the SPARC V8 architecture.[27] A key variant, the LEON2-FT, enhances fault tolerance by incorporating triple modular redundancy (TMR) for flip-flops and error detection and correction (EDAC) for memories, allowing it to withstand single-event upsets (SEUs) common in space environments.[29] This variant underwent early space qualification testing and was integrated into ASICs like the AT697, supporting initial ESA demonstrations of radiation-hardened processing.[16] The core's bus interface utilizes the AMBA AHB protocol for high-performance data transfers, with optional separate instruction and data caches configurable from 4 KB to 16 KB each, promoting flexibility in memory hierarchies for resource-constrained designs.[28] In terms of performance, the LEON2 achieves up to 80 MHz clock speeds in typical implementations, delivering approximately 0.8 DMIPS/MHz, which provided a significant improvement over prior space processors like the ERC32 for real-time tasks.[30] It found legacy applications in initial ESA technology demonstrations and early commercial embedded systems, such as spacecraft control prototypes, where its balanced performance and low power suited harsh environments.[16] However, the design has limitations, including no support for symmetric multiprocessing (SMP) and only a basic memory management unit (MMU) interface without advanced paging capabilities.[28]

LEON3 Cores

The LEON3 processor core, released in 2005, represents a significant advancement in the LEON family, building on the LEON2 design with enhanced pipeline architecture and multi-core capabilities. It supports up to 16 cores in symmetric multiprocessing (SMP) configurations, enabling efficient parallel processing for demanding embedded applications. Certified as SPARC V8 compliant on May 1, 2005, the core is implemented as a synthesizable VHDL model, targeting both FPGA and ASIC technologies for high-reliability environments.[3][1] A key variant is the LEON3FT, which integrates full triple modular redundancy (TMR) with lockstep execution to achieve radiation hardness, making it suitable for space missions where single-event upsets pose risks. This fault-tolerant version employs error detection and correction mechanisms, including parity and ECC on registers and caches, to maintain operational integrity under radiation exposure. Advanced features include configurable Level 1 instruction and data caches (1–256 KB), each with support for multi-way associativity, and an optional Level 2 cache for improved memory hierarchy performance. Additionally, it incorporates multi-processor performance trace (MPPT) capabilities via the debug support unit, facilitating real-time monitoring in SMP setups. The core also supports SPARC V8 extensions, such as the Visual Instruction Set (VIS) for enhanced multimedia processing.[31][3][1] Performance metrics highlight the LEON3's efficiency, achieving up to 400 MHz on 0.13 µm ASICs and 125 MHz on FPGAs, with a rating of 1.4 Dhrystone MIPS per MHz. The optional floating-point unit (FPU) ensures full IEEE 754 compliance for single- and double-precision operations, supporting pipelined execution to minimize latency in numerical computations. Peripherals are interfaced via the AMBA APB bus, including general-purpose I/O (GPIO) ports, programmable timers, and interrupt controllers, allowing seamless integration into system-on-chip designs. These elements contribute to the core's versatility in resource-constrained systems.[31][3] The LEON3 core has been widely adopted in European Space Agency (ESA) missions, serving as the processing backbone for instruments and onboard computers in several high-profile projects. Its radiation-tolerant design and configurable features have made it a staple for scientific payloads requiring reliable, autonomous operation in deep space.[2][1]

LEON4 Core

The LEON4 is a 32-bit SPARC V8 processor core developed by Aeroflex Gaisler (now Frontgrade Gaisler), released in March 2010 as a synthesizable VHDL model highly configurable for system-on-chip designs.[32] It operates as a single-core processor with optional support for dual-core lockstep mode and symmetric multiprocessing (SMP) in fault-tolerant configurations to enhance reliability against single-event upsets in radiation environments.[33] The core maintains full software compatibility with prior LEON generations while introducing optimizations for performance and power efficiency, targeting embedded applications in space and high-reliability industrial sectors, such as onboard computing for satellites and navigation systems.[33][32] Key architectural improvements include an advanced seven-stage pipeline that delivers up to a 50% performance increase over the LEON3 at the same clock frequency, achieved through wider internal buses, single-cycle 64-bit load/store operations, and static branch prediction to reduce pipeline stalls.[32][33] The instruction cache supports up to 256 KB in a configurable Harvard architecture with 1-4 ways and random or least-recently-used replacement policies, complemented by an optional Level-2 cache ranging from 16 KB to 8 MB for improved memory hierarchy efficiency.[33] These enhancements enable the core to achieve 1.7 Dhrystone MIPS per MHz and operate at up to 1500 MHz on 32 nm ASICs, balancing speed with low power consumption suitable for constrained environments.[33][32] Power management features emphasize efficiency through clock gating to disable unused pipeline stages and a power-down mode that allows the core to enter low-power sleep states when idle, reducing overall energy use without compromising real-time responsiveness.[33] Integrated hardware support for multiply-accumulate operations, IEEE-754 floating-point unit, and AMBA AHB bus interface further optimize it for compute-intensive tasks in fault-tolerant setups.[33]

LEON5 Core

The LEON5 core, released in December 2019 by Cobham Gaisler (now Frontgrade Gaisler), represents the latest iteration in the LEON family of SPARC V8-compliant processors, succeeding the LEON4. It fully implements the SPARC V8 instruction set architecture, including V8e extensions such as conditional moves and compare-and-swap instructions, enabling efficient handling of atomic operations and branch predictions in embedded systems. The core's design emphasizes high performance and configurability for space and aerospace applications, with backward compatibility to LEON3 and LEON4 software ecosystems.[34][35][21] The integer unit features an 8-stage dual-issue pipeline with a 64-bit four-port register file, hardware multiply/divide units, and a dynamic branch predictor, achieving up to 3.23 DMIPS/MHz on the Dhrystone benchmark (compiled with -O3 and inlining). The floating-point unit (FPU) options include the non-pipelined NanoFPU for basic needs or the fully pipelined GRFPU5, which complies with IEEE-754 standards and supports denormalized numbers for precise computations in scientific workloads. Performance reaches up to 250 MHz in worst-case corner conditions on high-end FPGAs, supported by low-latency interrupt handling via a unified 32-signal scheme and an advanced on-chip debug unit with trace buffers and performance counters.[35][36][21] Configurability is a core strength, allowing separate Harvard-architecture L1 instruction and data caches with up to four ways, alongside an optional L2 cache ranging from 16 KB to 8 MB in 256-bit blocks. An integrated NoMMU option is available by disabling the SPARC Reference MMU (SRMMU), facilitating simpler embedded designs without virtual memory overhead while retaining TLB support when enabled. The core integrates with AMBA AHB or AXI4 buses and supports symmetric multiprocessing (SMP) for multi-core configurations.[35][36][37] Recent updates through 2025, including GRLIB version 2025.2 released in July 2025, have enhanced compatibility with modern electronic design automation (EDA) tools such as Xilinx Vivado, Synopsys Design Compiler, and ModelSim, streamlining FPGA and ASIC flows. The LEON family has been utilized in precursors to NASA's Artemis program, building on LEON heritage for radiation-tolerant computing in lunar missions. While remaining firmly SPARC-focused, it serves as a bridge to Gaisler's RISC-V-based NOEL-V cores, offering a migration path for future designs without abandoning established SPARC infrastructure.[37][38][21]

Implementations and Configurations

FPGA Design Flow

The FPGA design flow for LEON cores leverages the GRLIB IP library, which provides a modular set of VHDL-based reusable IP cores centered around AMBA AHB and APB buses for system-on-chip integration on FPGAs. Synthesis is primarily performed using Xilinx ISE or Vivado toolchains for Xilinx devices, and Actel Designer or Libero for Microsemi (formerly Actel) FPGAs, enabling plug-and-play configuration of LEON processors with peripherals like memory controllers and I/O interfaces. The GRLIB library facilitates this by allowing designers to instantiate cores via generics in a top-level VHDL file, such as leon3mp.vhd, with parameters defined in config.vhd generated through the xconfig GUI tool.[39] The typical workflow begins with VHDL instantiation and configuration of the LEON core within the GRLIB environment, followed by RTL simulation using ModelSim (version 10.6 or later) to verify functionality before synthesis. Simulation commands like make sim or make vsim load testbenches (e.g., testbench.vhd) that emulate PROM, SDRAM, and SRAM, checking for AMBA bus violations and executing boot code. Post-simulation, synthesis is run via make syn or tool-specific flows (e.g., make ise for Xilinx ISE), incorporating user constraint files (UCF) for pin mapping and timing. Bitstream generation completes the process, producing files like leon3mp.bit for programming the target FPGA, with support for partial reconfiguration on licensed devices.[39] Verification emphasizes self-test libraries included in GRLIB, such as the system test software in section 5.11, which runs systest.c and prom.srec on the LEON processor during simulation to validate CPU integer units, caches, and peripherals like UART and timers. For space qualification, fault injection techniques are applied in fault-tolerant (FT) variants using ModelSim to simulate radiation-induced errors, analyzing recovery mechanisms like triple modular redundancy (TMR) in LEON3FT configurations. These methods ensure compliance with ESA standards for radiation hardness, with diagnostics output to the simulator console for bus collisions or memory issues.[39] Supported target devices include Xilinx families from Virtex-5 through UltraScale (e.g., Virtex-5 LX, Virtex-6, 7-series like Artix-7 XC7A100T, and Kintex UltraScale), as well as Microsemi Fusion and ProASIC3L. A representative LEON3 configuration utilizes approximately 20,000 LUTs on Virtex-5 devices, depending on features like cache size (e.g., 16 kB I-cache and 8 kB D-cache) and enabled peripherals, leaving ample resources for additional IP. Best practices include managing clock domain crossings via GRLIB's AMBA packages and the clkgen module for multi-clock generation, and implementing I/O buffering with technology-specific primitives like inpad and outpad to maintain signal integrity during synthesis.[39]

ASIC and Fault-Tolerant Variants

The LEON processor family has been ported to several ASIC processes for radiation-hardened applications, enabling deployment in space environments. Notable examples include the GR712RC, a dual-core LEON3-FT system-on-chip fabricated in a 180 nm CMOS process by Tower Semiconductors, which incorporates radiation-hard-by-design techniques for high-reliability aerospace use.[40] Similarly, the GR740 quad-core LEON4-FT device utilizes STMicroelectronics' C65SPACE 65 nm CMOS rad-hard process, providing enhanced performance and integration for demanding missions.[41][42] Fault-tolerant variants of the LEON cores, such as LEON2-FT through LEON5, employ triple modular redundancy (TMR) to mitigate single-event upsets (SEUs) in radiation-prone settings. In these implementations, critical elements like flip-flops, registers, and memory are triplicated, with dedicated voter circuits resolving discrepancies by selecting the majority output, thereby masking transient faults without software intervention.[1][3] The LEON3-FT and LEON4-FT variants extend this to caches and register files using parity or error-correcting codes alongside TMR, while LEON5 builds on these for advanced payloads with configurable redundancy levels.[33][35] Radiation testing of these ASIC variants demonstrates robust performance in space-like conditions. The GR740 achieves a total ionizing dose (TID) tolerance of 300 krad(Si) with no functional degradation, as verified under MIL-STD-883K protocols, and exhibits single-event latch-up (SEL) immunity up to a linear energy transfer (LET) of 125 MeV·cm²/mg at elevated temperatures.[42] SEL immunity in such designs often leverages silicon-on-insulator (SOI) or radiation-hard-by-design (RHBD) techniques to prevent destructive latch-ups, complemented by TMR for SEU correction rates below 1×10⁻⁵ errors per device per day in geostationary orbit.[43][44] The GR712RC exemplifies these capabilities in operational space missions, serving as a dual-core LEON3-FT processor for satellites and instruments, delivering up to 100% performance improvement over single-core predecessors at equivalent clock speeds while maintaining full compatibility.[40][6] Customizations for mission-specific needs include register-based adjustments to cache sizes and interfaces, enabling die area reductions of up to 20% through selective feature integration, and specialized packaging such as CCGA625 ceramic column grid arrays for thermal and mechanical resilience in launch and orbital environments.[41][45] As of November 2025, development is underway on the GR765, a radiation-hardened, fault-tolerant octa-core system-on-chip under contract with the European Space Agency. The GR765 features LEON5FT SPARC V8 cores (with optional RISC-V NOEL-V cores), SIMD extensions, floating-point units, memory management units, and an embedded FPGA, targeting advanced space applications requiring high processing power and configurability.[46]

Software Ecosystem

Real-Time Operating Systems

The Real-Time Executive for Multiprocessor Systems (RTEMS) serves as the primary real-time operating system (RTOS) for LEON processors, providing comprehensive support across the LEON2, LEON3, LEON4, and LEON5 families through dedicated board support packages (BSPs).[47] RTEMS, an open-source RTOS originally developed for embedded applications, enables deterministic task scheduling essential for space and avionics tasks, with symmetric multiprocessing (SMP) capabilities integrated for LEON3 and later cores to leverage multi-core configurations.[48] This SMP support facilitates efficient resource utilization in fault-tolerant systems, such as those deployed in European Space Agency (ESA) missions.[49] Additional RTOS ports tailored for LEON include VxWorks from Wind River, which offers robust uni-processor and SMP modes for LEON variants, including fault-tolerant models like LEON3FT and LEON5, with integrated development environments for debugging and analysis.[50][51] PikeOS, a hypervisor-based RTOS from SYSGO, supports LEON processors via SPARC V8 compatibility, enabling partitioned execution for safety-critical applications through personalities like ARINC 653 and POSIX.[52] These ports emphasize low-overhead interrupt handling and predictable response times, critical for real-time constraints in embedded environments.[53] LEON-compatible RTOS implementations achieve certifications aligned with industry standards for high-reliability domains. RTEMS provides a Qualification Data Package (QDP) pre-qualified to ECSS-E-ST-40C for space criticality categories C and D, supporting verifiable software development for ESA projects.[54] VxWorks Cert Edition meets DO-178C requirements up to Level A for avionics, with qualification evidence available for LEON deployments.[55][56] PikeOS offers certification kits for DO-178C (up to Level A), ECSS, and ISO 26262, facilitating mixed-criticality systems on LEON hardware.[57] For bare-metal applications without a full RTOS, LEON processors utilize lightweight boot monitors and loaders, such as those provided in the Gaisler software ecosystem, to initialize hardware and load executables directly.[58] These options support minimal-overhead environments for simple, deterministic control tasks in radiation-hardened settings.[53]

Development Tools and Distributions

The primary compiler toolchain for LEON processors is the Bare C Cross-compiler (BCC), a SPARC V8-targeted system based on the GNU Compiler Collection (GCC) and the Newlib C library, enabling cross-compilation of C and C++ applications for bare-metal or embedded environments.[59][60] GCC itself supports LEON-specific architectures through options like -mcpu=leon or -mcpu=leon3, allowing generation of optimized code for the processor's features, including floating-point units (FPU).[61] For space-constrained applications, developers commonly use optimization flags such as -Os to minimize code size and -msoft-float when targeting configurations without hardware floating-point support, reducing dependency on FPU hardware to enhance radiation tolerance.[61] Debugging for LEON systems relies on the GRMON hardware monitor, a non-intrusive tool optimized for SPARC/LEON architectures that provides JTAG connectivity, trace capabilities, and breakpoint management.[62][63] GRMON integrates seamlessly with the GNU Debugger (GDB), acting as a remote target to enable symbolic debugging of applications at both assembly and C/C++ levels, either on simulators like TSIM or directly on target hardware.[53][64] This setup supports advanced features like automated testing and real-time trace logging, essential for verifying LEON-based system-on-chip (SoC) designs in fault-tolerant environments.[65] LEON GNU/Linux distributions are facilitated through Gaisler Buildroot, an embedded Linux build environment based on upstream Buildroot LTS releases, which automates the creation of kernels, root filesystems, and user-space applications tailored for LEON3, LEON4, and LEON5 processors.[66][67] These distributions incorporate kernel patches from the LEON Linux 5.10 LTS series or the 6.13 (as of mid-2025), enabling support for SPARC V8 memory management units (MMU) in single-core or symmetric multi-processing (SMP) configurations, along with features like preemptible real-time scheduling and high-resolution timers.[67][68] Buildroot configurations allow customization for space applications, integrating drivers for LEON peripherals while maintaining compatibility with standard Linux tools. The GRLIB IP library serves as the foundational toolkit for LEON SoC assembly, offering a collection of reusable VHDL cores connected via the AMBA APB/AHB bus, including the LEON processor family, GRETH Gigabit Ethernet MAC, and GRSPW SpaceWire interface for high-speed data links in space systems.[69][39] GRLIB enables rapid prototyping on FPGAs or ASICs by providing configurable modules for peripherals like timers, UARTs, and memory controllers, streamlining the integration of LEON cores into complete avionics designs.[70][36] As of 2025, modern development workflows for LEON incorporate Visual Studio Code (VS Code) setups, with Gaisler providing quick-start guides for configuring the IDE with GCC toolchains to cross-compile and debug C/C++ applications targeting LEON processors via simulators or hardware.[71] These configurations leverage VS Code's extension ecosystem for syntax highlighting and build integration, enhancing productivity over traditional tools like Eclipse. For VHDL-based verification of GRLIB components, continuous integration/continuous deployment (CI/CD) pipelines are increasingly adopted using frameworks like VUnit and cloud-based environments such as Azure, automating simulation, coverage analysis, and regression testing to ensure reliability in LEON SoC designs.

References

  1. ESA - Microprocessors - European Space Agency
  2. LEON: the space chip that Europe built - ESA
  3. LEON3 - Gaisler
  4. LEON (SPARC) Microprocessors & Microcontrollers | Frontgrade
  5. CAES GR712RC Microprocessor Selected by Argotec for Multiple ...
  6. [PDF] UT699 LEON 3FT /SPARCTM V8 Microprocessor
  7. [PDF] LEON/GRLIB Design and Configuration Guide - Gaisler
  8. [PDF] Fault-Tolerant and Radiation Hardened SPARC Processors
  9. ESA - LEON: a new recipe for chips - European Space Agency
  10. [PDF] LEON-1 Processor - First Evaluation Results
  11. Leading up to LEON: ESA's first microprocessors
  12. LEON: The Space Chip That Europe Built - SatMagazine
  13. [PDF] 25 (and counting) years of SPARC history in SPACE
  14. Introduction to LEON for UT SoC - UTK-EECS
  15. Father of the chips steering Europe's space missions - ESA
  16. LEON3 has passed SPARC V8 compliance testing
  17. (PDF) LEON3-FT-RTAX SEU Test Results - ResearchGate
  18. [PDF] LEON4: Fourth Generation of the LEON Processor
  19. ESA - Chang'e-4 lander - European Space Agency
  20. [PDF] Position paper: LEON and NOEL-V SoC Architectures - Gaisler
  21. Gaisler Releases LEON5 Processor IP Core
  22. Solar Orbiter Mission - eoPortal
  23. RadHard Microelectronics Assist in Study of Sun and Earth ...
  24. Gaisler: Embedded computer systems for harsh environments
  25. [PDF] The Gaisler Research Roadmap for FPGA IP-Cores - NASA NEPP
  26. ESA - LEON2-FT - European Space Agency
  27. [PDF] The LEON2-FT Processor User's Manual - European Space Agency
  28. System-On-Chip (SOC) Development - ESA Microelectronics Section
  29. [PDF] LEON2 Processor User's Manual
  30. [PDF] GRLIB IP Core User's Manual - Gaisler
  31. eASIC Announces Immediate Availability of Aeroflex Gaisler's Leon4 ...
  32. LEON4 - Gaisler
  33. Frontgrade Releases LEON5 Processor IP Core
  34. LEON5 - Gaisler
  35. [PDF] LEON/GRLIB
  36. http://download.gaisler.com/products/GRLIB/doc/grlib.pdf
  37. LEON3FT Technology Supports NASA's Return to the Moon - Gaisler
  38. [PDF] GRLIB IP Library User's Manual - Gaisler
  39. GR712RC - Gaisler
  40. [PDF] GR740 Data Sheet and User's Manual - Gaisler
  41. [PDF] GR740 Radiation Summary - Gaisler
  42. [PDF] FT-UNSHADES CCN2 Report - ESA Microelectronics Section
  43. Radiation characterization of a dual core LEON3FT processor
  44. GR-SBC-GR740 | Gaisler
  45. 6.2. Architectures - RTEMS Documentation Project
  46. [PDF] RTEMS SMP FOR LEON3/LEON4 MULTI-PROCESSOR DEVICES
  47. Software engineering and standardisation - Overview of LEON tools
  48. VxWorks 7 - Gaisler
  49. Frontgrade Introduces Support for Wind River VxWorks RTOS for ...
  50. SYSGO's PikeOS now supports LEON Processor and RTEMS ...
  51. LEON Software Overview | Gaisler
  52. RTEMS Qualifies for the Space Domain
  53. VxWorks Cert Edition Product Overview - Wind River Systems
  54. Qualified Software | Gaisler
  55. PikeOS RTOS & Hypervisor - SYSGO
  56. Operating systems for the LEON SPARC and NOEL RISC ... - Gaisler
  57. BCC1 - LEON bare-metal cross-compiler system - Gaisler
  58. BCC user's manual
  59. SPARC Options (Using the GNU Compiler Collection (GCC))
  60. GRMON3 - Gaisler
  61. GRMON4 - Gaisler
  62. GRMON3 - Manuals.plus
  63. Software Debug Tools - Gaisler
  64. Gaisler Buildroot
  65. Linux for LEON - Gaisler
  66. [PDF] LEON Linux LEON Linux Overview - Gaisler
  67. GRLIB IP Library - Gaisler
  68. [PDF] LEON/GRLIB Configuration and Development Guide
  69. LEON/NOEL C/C++ IDE - Gaisler
  70. Scalable Cloud-based CI/CD HDL Verification Environment
User Avatar
No comments yet.