SoC
  • Home
  • Arm
  • Arm Cortex M0/M0+
  • Arm Cortex M4
  • Arm Cortex M3
  • Contact
Reading: What are the different faults in ARM?
SUBSCRIBE
SoCSoC
Font ResizerAa
  • Home
  • Arm
  • Arm Cortex M0/M0+
  • Arm Cortex M4
Search
  • Home
  • Arm
  • Arm Cortex M0/M0+
  • Arm Cortex M4
Have an existing account? Sign In
Follow US
  • Looking for Something?
  • Privacy Policy
  • About Us
  • Sitemap
  • Contact Us
© S-O-C.ORG, All Rights Reserved.
Arm

What are the different faults in ARM?

Eileen David
Last updated: September 13, 2023 6:49 am
Eileen David 6 Min Read
Share
SHARE

ARM processors, like all microprocessors, are susceptible to faults during operation. These faults can occur due to issues in the hardware, software, or environment. Understanding the different types of faults in ARM and their causes can help developers build more robust and fault-tolerant systems.

Contents
Hardware FaultsStuck-At FaultsBridging FaultsDelay FaultsTransient FaultsSoftware FaultsMemory Access ErrorsRace ConditionsDeadlockLivelockInfinite LoopsEnvironmental FaultsPower Supply NoiseOverheatingElectromagnetic InterferenceIonizing RadiationHandling Faults in ARMError Detection and CorrectionFail-Safe DesignRedundancyFault IsolationRollback and RecoveryFault Injection TestingBuilt-In Self TestCommon ARM Fault Handling FeaturesParity ProtectionECC ProtectionMemory Tagged PointersExternal Abort HandlingLockstep CoresConclusion

Hardware Faults

Hardware faults occur due to issues with the physical microarchitecture of the ARM processor. Some common hardware faults include:

Stuck-At Faults

These faults occur when a signal line in the processor gets stuck at either logic 0 or logic 1. This can happen due to manufacturing defects or electrical issues. Stuck-at faults can cause instructions to be incorrectly executed or data to be corrupted.

Bridging Faults

Bridging faults occur when two signal lines in the processor inadvertently get connected. This leads to crosstalk and interference between the two signals. Bridging faults can alter signal values and lead to faulty processor behavior.

Delay Faults

Delay faults happen when a signal takes longer than expected to propagate through a circuit. This can be caused by slow transistors, resistive interconnects, or voltage drops. Delay faults may cause race conditions, timing failures, and synchronization issues.

Transient Faults

These are temporary or intermittent faults caused by external effects like radiation, power supply noise, or electromagnetic interference. They cause sporadic bit flips in processors. Transient faults are difficult to detect and isolate.

Software Faults

Software faults arise due to bugs in code, compiler issues, errors in firmware or device drivers. Some examples include:

Memory Access Errors

Invalid memory accesses, buffer overflows, accesses to uninitialized or deallocated memory can corrupt data and crash programs. Memory access errors are a common source of software faults.

Race Conditions

Race conditions occur when the timing or ordering of events affects the program’s correctness. Concurrent code paths accessing shared resources without synchronization are prone to race conditions.

Deadlock

Deadlock happens when processes or threads get stuck waiting for resources held by each other. This leads to a permanent blocking of those processes. Deadlocks render ARM cores unusable.

Livelock

A livelock is similar to deadlock, except processes are not blocked but keep retrying their requests in a loop unsuccessfully. This consumes CPU cycles wastefully.

Infinite Loops

Infinite loops occur when the loop condition never evaluates to false. The program gets stuck in the loop indefinitely, unable to exit. Infinite loops lock up the ARM core.

Environmental Faults

These faults arise from issues with the environment in which the ARM processor operates. Some examples are:

Power Supply Noise

Fluctuations in power supply voltage and ripples in power lines can cause bit flips or timing violations in processors. This leads to incorrect operation.

Overheating

Due to high CPU utilization or inadequate cooling, ARM cores can overheat. High temperatures affect transistor switching speeds and may damage processors permanently.

Electromagnetic Interference

External sources of magnetic or electromagnetic radiation like motors, relays can induce currents and voltages in processors. This causes signal interference and functional errors.

Ionizing Radiation

High energy particles from space or radioactive materials can strike the semiconductor substrate of processors. This flips bits in memory cells and registers, causing program crashes.

Handling Faults in ARM

To build reliable ARM-based systems, faults need to be handled effectively. Some techniques include:

Error Detection and Correction

ECC memory and parity checks can detect and even correct some data errors caused by faults.

Fail-Safe Design

Hardware and software should be designed to fail safely, without catastrophic consequences, when faults inevitably occur.

Redundancy

Hardware redundancy via extra cores or duplicate units improves tolerance to faults. Software redundancy via N-version programming also helps.

Fault Isolation

Faulty units can be isolated by microarchitecture techniques like Razor to avoid corrupting other blocks.

Rollback and Recovery

Checkpointing and roll back of program state after faults enables software to recover and continue execution.

Fault Injection Testing

Injecting faults at development time finds weaknesses and improves the robustness of ARM systems.

Built-In Self Test

BIST units integrated into ARM cores can detect faults like stuck-at faults during power-on self tests.

Common ARM Fault Handling Features

Some fault handling features built into ARM processors include:

Parity Protection

The ARM Embedded Trace Macrocell has parity protection on trace data to detect transmission errors.

ECC Protection

The ARM AMBA AXI bus protocol supports optional ECC protection on transactions to correct data faults.

Memory Tagged Pointers

Tagged pointers in ARMv8-A catch invalid memory accesses that could potentially cause crashes.

External Abort Handling

External aborts triggered by parity errors are handled gracefully by saving state and jumping to an abort handler.

Lockstep Cores

ARM CoreLink NMMU links two cores lockstep for fault detection by comparing outputs clock-by-clock.

Conclusion

From hardware issues like stuck-at faults to software bugs like deadlock, ARM cores are vulnerable to various faults. By understanding fault classes, applying fault tolerance techniques, and leveraging built-in ARM safeguards, robust ARM systems can be designed.

Newsletter Form (#3)

More ARM insights right in your inbox

 


Share This Article
Facebook Twitter Email Copy Link Print
Previous Article What is the purpose of the hard fault exception in ARM Cortex-M?
Next Article Does ARM allow unaligned access?
Leave a comment Leave a comment

Leave a Reply Cancel reply

Your email address will not be published. Required fields are marked *

2k Followers Like
3k Followers Follow
10.1k Followers Pin
- Sponsored-
Ad image

You Might Also Like

How to use ARM Toolchains for Disassembly?

Disassembly is the process of converting machine code back into…

15 Min Read

LCD Interfacing with ARM Cortex M0+ LPC845

The LPC845 is an ARM Cortex M0+ based microcontroller from…

12 Min Read

Which microcontroller is better than ESP32?

The ESP32 is an extremely popular WiFi-enabled microcontroller produced by…

9 Min Read

What is the Difference Between Arm Cortex-M0 and M4?

The main differences between the Arm Cortex-M0 and Cortex-M4 processor…

6 Min Read
SoCSoC
  • Looking for Something?
  • Privacy Policy
  • About Us
  • Sitemap
  • Contact Us
Welcome Back!

Sign in to your account