Skip to content

Index

Exposes the LPDDR5 specific hardware components and system model.

BusTrim

Bases: Base

Component for trimming and distributing failure rates across the bus architecture.

This module injects specific bus-related fault sources (AZ) and redistributes SBE, DBE, and TBE faults for both SPFM and LFM paths based on LPDDR5 specifications.

Source code in src/ecc_analyzer/models/lpddr5/bus_trim.py 
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
class BusTrim(Base):
    """Component for trimming and distributing failure rates across the bus architecture.

    This module injects specific bus-related fault sources (AZ) and redistributes
    SBE, DBE, and TBE faults for both SPFM and LFM paths based on LPDDR5 specifications.
    """

    def __init__(self, name: str):
        """Initializes the BusTrim component with bus-specific split parameters.

        Args:
            name (str): The descriptive name of the component.
        """
        self.spfm_sbe_split = {FaultType.SBE: 0.438}
        self.spfm_dbe_split = {FaultType.SBE: 0.496, FaultType.DBE: 0.314}
        self.spfm_tbe_split = {
            FaultType.SBE: 0.325,
            FaultType.DBE: 0.419,
            FaultType.TBE: 0.175,
        }
        self.spfm_az_source = 172.0

        self.lfm_sbe_split = self.spfm_sbe_split
        self.lfm_dbe_split = self.spfm_dbe_split
        self.lfm_tbe_split = self.spfm_tbe_split

        super().__init__(name)

    def configure_blocks(self):
        """Configures the root block as a collection of fault injections and split operations.

        Uses a SumBlock to aggregate the source injection (AZ) and the parallel
        redistribution (SplitBlocks) of incoming faults.
        """
        self.root_block = SumBlock(
            self.name,
            [
                BasicEvent(FaultType.AZ, self.spfm_az_source, is_spfm=True),
                SplitBlock("SPFM_SBE_Split", FaultType.SBE, self.spfm_sbe_split, is_spfm=True),
                SplitBlock("SPFM_DBE_Split", FaultType.DBE, self.spfm_dbe_split, is_spfm=True),
                SplitBlock("SPFM_TBE_Split", FaultType.TBE, self.spfm_tbe_split, is_spfm=True),
                SplitBlock("LFM_SBE_Split", FaultType.SBE, self.lfm_sbe_split, is_spfm=False),
                SplitBlock("LFM_DBE_Split", FaultType.DBE, self.lfm_dbe_split, is_spfm=False),
                SplitBlock("LFM_TBE_Split", FaultType.TBE, self.lfm_tbe_split, is_spfm=False),
            ],
        )

__init__(name)

Initializes the BusTrim component with bus-specific split parameters.

Parameters:

Name Type Description Default
name str

The descriptive name of the component.

 required
Source code in src/ecc_analyzer/models/lpddr5/bus_trim.py 
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
def __init__(self, name: str):
    """Initializes the BusTrim component with bus-specific split parameters.

    Args:
        name (str): The descriptive name of the component.
    """
    self.spfm_sbe_split = {FaultType.SBE: 0.438}
    self.spfm_dbe_split = {FaultType.SBE: 0.496, FaultType.DBE: 0.314}
    self.spfm_tbe_split = {
        FaultType.SBE: 0.325,
        FaultType.DBE: 0.419,
        FaultType.TBE: 0.175,
    }
    self.spfm_az_source = 172.0

    self.lfm_sbe_split = self.spfm_sbe_split
    self.lfm_dbe_split = self.spfm_dbe_split
    self.lfm_tbe_split = self.spfm_tbe_split

    super().__init__(name)

configure_blocks()

Configures the root block as a collection of fault injections and split operations.

Uses a SumBlock to aggregate the source injection (AZ) and the parallel redistribution (SplitBlocks) of incoming faults.

Source code in src/ecc_analyzer/models/lpddr5/bus_trim.py 
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
def configure_blocks(self):
    """Configures the root block as a collection of fault injections and split operations.

    Uses a SumBlock to aggregate the source injection (AZ) and the parallel
    redistribution (SplitBlocks) of incoming faults.
    """
    self.root_block = SumBlock(
        self.name,
        [
            BasicEvent(FaultType.AZ, self.spfm_az_source, is_spfm=True),
            SplitBlock("SPFM_SBE_Split", FaultType.SBE, self.spfm_sbe_split, is_spfm=True),
            SplitBlock("SPFM_DBE_Split", FaultType.DBE, self.spfm_dbe_split, is_spfm=True),
            SplitBlock("SPFM_TBE_Split", FaultType.TBE, self.spfm_tbe_split, is_spfm=True),
            SplitBlock("LFM_SBE_Split", FaultType.SBE, self.lfm_sbe_split, is_spfm=False),
            SplitBlock("LFM_DBE_Split", FaultType.DBE, self.lfm_dbe_split, is_spfm=False),
            SplitBlock("LFM_TBE_Split", FaultType.TBE, self.lfm_tbe_split, is_spfm=False),
        ],
    )

DramTrim

Bases: Base

Handles the redistribution of SBE, DBE, and TBE faults for both residual and latent paths.

This component uses a SumBlock to apply parallel split operations that redistribute fault rates according to specific hardware trimming factors defined for LPDDR5.

Source code in src/ecc_analyzer/models/lpddr5/dram_trim.py 
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
class DramTrim(Base):
    """Handles the redistribution of SBE, DBE, and TBE faults for both residual and latent paths.

    This component uses a SumBlock to apply parallel split operations that redistribute
    fault rates according to specific hardware trimming factors defined for LPDDR5.
    """

    def __init__(self, name: str):
        """Initializes the DramTrim component with hardware-specific split distribution parameters.

        Args:
            name (str): The descriptive name of the component.
        """
        self.spfm_sbe_split = {FaultType.SBE: 0.94}
        self.spfm_dbe_split = {FaultType.SBE: 0.11, FaultType.DBE: 0.89}
        self.spfm_tbe_split = {
            FaultType.SBE: 0.009,
            FaultType.DBE: 0.15,
            FaultType.TBE: 0.83,
        }

        self.lfm_sbe_split = self.spfm_sbe_split
        self.lfm_dbe_split = self.spfm_dbe_split
        self.lfm_tbe_split = self.spfm_tbe_split

        super().__init__(name)

    def configure_blocks(self):
        """Configures the root block as a collection of split operations.

        Each split block redistributes the specified fault type according to the defined ratios.
        Both SPFM (residual) and LFM (latent) paths are processed in parallel.
        """
        self.root_block = SumBlock(
            self.name,
            [
                SplitBlock("SPFM_SBE_Split", FaultType.SBE, self.spfm_sbe_split, is_spfm=True),
                SplitBlock("SPFM_DBE_Split", FaultType.DBE, self.spfm_dbe_split, is_spfm=True),
                SplitBlock("SPFM_TBE_Split", FaultType.TBE, self.spfm_tbe_split, is_spfm=True),
                SplitBlock("LFM_SBE_Split", FaultType.SBE, self.lfm_sbe_split, is_spfm=False),
                SplitBlock("LFM_DBE_Split", FaultType.DBE, self.lfm_dbe_split, is_spfm=False),
                SplitBlock("LFM_TBE_Split", FaultType.TBE, self.lfm_tbe_split, is_spfm=False),
            ],
        )

__init__(name)

Initializes the DramTrim component with hardware-specific split distribution parameters.

Parameters:

Name Type Description Default
name str

The descriptive name of the component.

 required
Source code in src/ecc_analyzer/models/lpddr5/dram_trim.py 
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
def __init__(self, name: str):
    """Initializes the DramTrim component with hardware-specific split distribution parameters.

    Args:
        name (str): The descriptive name of the component.
    """
    self.spfm_sbe_split = {FaultType.SBE: 0.94}
    self.spfm_dbe_split = {FaultType.SBE: 0.11, FaultType.DBE: 0.89}
    self.spfm_tbe_split = {
        FaultType.SBE: 0.009,
        FaultType.DBE: 0.15,
        FaultType.TBE: 0.83,
    }

    self.lfm_sbe_split = self.spfm_sbe_split
    self.lfm_dbe_split = self.spfm_dbe_split
    self.lfm_tbe_split = self.spfm_tbe_split

    super().__init__(name)

configure_blocks()

Configures the root block as a collection of split operations.

Each split block redistributes the specified fault type according to the defined ratios. Both SPFM (residual) and LFM (latent) paths are processed in parallel.

Source code in src/ecc_analyzer/models/lpddr5/dram_trim.py 
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
def configure_blocks(self):
    """Configures the root block as a collection of split operations.

    Each split block redistributes the specified fault type according to the defined ratios.
    Both SPFM (residual) and LFM (latent) paths are processed in parallel.
    """
    self.root_block = SumBlock(
        self.name,
        [
            SplitBlock("SPFM_SBE_Split", FaultType.SBE, self.spfm_sbe_split, is_spfm=True),
            SplitBlock("SPFM_DBE_Split", FaultType.DBE, self.spfm_dbe_split, is_spfm=True),
            SplitBlock("SPFM_TBE_Split", FaultType.TBE, self.spfm_tbe_split, is_spfm=True),
            SplitBlock("LFM_SBE_Split", FaultType.SBE, self.lfm_sbe_split, is_spfm=False),
            SplitBlock("LFM_DBE_Split", FaultType.DBE, self.lfm_dbe_split, is_spfm=False),
            SplitBlock("LFM_TBE_Split", FaultType.TBE, self.lfm_tbe_split, is_spfm=False),
        ],
    )

Events

Bases: Base

Initializes the baseline DRAM failure rates for LPDDR5.

This module acts as a primary source for SBE, DBE, MBE, and WD faults. As a pure source component, it uses a SumBlock to inject all rates in parallel.

Source code in src/ecc_analyzer/models/lpddr5/events.py 
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
class Events(Base):
    """Initializes the baseline DRAM failure rates for LPDDR5.

    This module acts as a primary source for SBE, DBE, MBE, and WD faults.
    As a pure source component, it uses a SumBlock to inject all rates in parallel.
    """

    def __init__(self, name: str):
        """Initializes the fault rates based on a baseline DRAM FIT value.

        Args:
            name (str): The descriptive name of the component.
        """
        dram_fit = 2300.0

        self.fault_sbe = 0.7 * dram_fit
        self.fault_dbe = 0.0748 * dram_fit
        self.fault_mbe = 0.0748 * dram_fit
        self.fault_wd = 0.0748 * dram_fit

        super().__init__(name)

    def configure_blocks(self):
        """Configures the internal block structure by injecting failure rates as basic events.

        Uses a SumBlock as these faults occur independently and in parallel on the hardware level.
        """
        self.root_block = SumBlock(
            self.name,
            [
                BasicEvent(FaultType.SBE, self.fault_sbe, is_spfm=True),
                BasicEvent(FaultType.DBE, self.fault_dbe, is_spfm=True),
                BasicEvent(FaultType.MBE, self.fault_mbe, is_spfm=True),
                BasicEvent(FaultType.WD, self.fault_wd, is_spfm=True),
            ],
        )

__init__(name)

Initializes the fault rates based on a baseline DRAM FIT value.

Parameters:

Name Type Description Default
name str

The descriptive name of the component.

 required
Source code in src/ecc_analyzer/models/lpddr5/events.py 
16
17
18
19
20
21
22
23
24
25
26
27
28
29
def __init__(self, name: str):
    """Initializes the fault rates based on a baseline DRAM FIT value.

    Args:
        name (str): The descriptive name of the component.
    """
    dram_fit = 2300.0

    self.fault_sbe = 0.7 * dram_fit
    self.fault_dbe = 0.0748 * dram_fit
    self.fault_mbe = 0.0748 * dram_fit
    self.fault_wd = 0.0748 * dram_fit

    super().__init__(name)

configure_blocks()

Configures the internal block structure by injecting failure rates as basic events.

Uses a SumBlock as these faults occur independently and in parallel on the hardware level.

Source code in src/ecc_analyzer/models/lpddr5/events.py 
31
32
33
34
35
36
37
38
39
40
41
42
43
44
def configure_blocks(self):
    """Configures the internal block structure by injecting failure rates as basic events.

    Uses a SumBlock as these faults occur independently and in parallel on the hardware level.
    """
    self.root_block = SumBlock(
        self.name,
        [
            BasicEvent(FaultType.SBE, self.fault_sbe, is_spfm=True),
            BasicEvent(FaultType.DBE, self.fault_dbe, is_spfm=True),
            BasicEvent(FaultType.MBE, self.fault_mbe, is_spfm=True),
            BasicEvent(FaultType.WD, self.fault_wd, is_spfm=True),
        ],
    )

LinkEcc

Bases: Base

Component for the Link ECC interface.

This block models the transmission errors on the interface (Source) and the corresponding Error Correction Code (Coverage) that mitigates these errors.

Source code in src/ecc_analyzer/models/lpddr5/link_ecc.py 
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
class LinkEcc(Base):
    """Component for the Link ECC interface.

    This block models the transmission errors on the interface (Source) and
    the corresponding Error Correction Code (Coverage) that mitigates these errors.
    """

    def __init__(self, name: str):
        """Initializes the LinkEcc component.

        Args:
            name (str): The descriptive name of the component.
        """
        self.sbe_if_source_rate = 5.050

        self.sbe_if_dc_residual = 1.0
        self.sbe_if_dc_latent = 1.0

        super().__init__(name)

    def configure_blocks(self):
        """Configures the root block as a sequential pipeline.

        Using a PipelineBlock ensures that the faults generated by the BasicEvent (Source)
        are immediately processed by the CoverageBlock (ECC).
        """
        self.root_block = PipelineBlock(
            self.name,
            [
                BasicEvent(FaultType.SBE, self.sbe_if_source_rate, is_spfm=True),
                CoverageBlock(
                    FaultType.SBE,
                    self.sbe_if_dc_residual,
                    dc_rate_latent_cL=self.sbe_if_dc_latent,
                    is_spfm=True,
                ),
            ],
        )

__init__(name)

Initializes the LinkEcc component.

Parameters:

Name Type Description Default
name str

The descriptive name of the component.

 required
Source code in src/ecc_analyzer/models/lpddr5/link_ecc.py 
16
17
18
19
20
21
22
23
24
25
26
27
def __init__(self, name: str):
    """Initializes the LinkEcc component.

    Args:
        name (str): The descriptive name of the component.
    """
    self.sbe_if_source_rate = 5.050

    self.sbe_if_dc_residual = 1.0
    self.sbe_if_dc_latent = 1.0

    super().__init__(name)

configure_blocks()

Configures the root block as a sequential pipeline.

Using a PipelineBlock ensures that the faults generated by the BasicEvent (Source) are immediately processed by the CoverageBlock (ECC).

Source code in src/ecc_analyzer/models/lpddr5/link_ecc.py 
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
def configure_blocks(self):
    """Configures the root block as a sequential pipeline.

    Using a PipelineBlock ensures that the faults generated by the BasicEvent (Source)
    are immediately processed by the CoverageBlock (ECC).
    """
    self.root_block = PipelineBlock(
        self.name,
        [
            BasicEvent(FaultType.SBE, self.sbe_if_source_rate, is_spfm=True),
            CoverageBlock(
                FaultType.SBE,
                self.sbe_if_dc_residual,
                dc_rate_latent_cL=self.sbe_if_dc_latent,
                is_spfm=True,
            ),
        ],
    )

Lpddr5System

Bases: SystemBase

Coordinates the connection of all sub-components and defines the overall system layout for LPDDR5.

Source code in src/ecc_analyzer/models/lpddr5/lpddr5_system.py 
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
class Lpddr5System(SystemBase):
    """Coordinates the connection of all sub-components and defines the overall system layout for LPDDR5."""

    def configure_system(self):
        """Defines the hierarchical structure of the LPDDR5 system.

        Constructs the main DRAM processing chain (Sources -> SEC -> TRIM -> BUS -> LINK -> SEC-DED -> TRIM)
        and merges it with other hardware components.
        """
        main_chain = PipelineBlock(
            "DRAM_Path",
            [
                Events("DRAM_Sources"),
                Sec("SEC"),
                DramTrim("TRIM"),
                BusTrim("BUS"),
                LinkEcc("LINK-ECC"),
                SecDed("SEC-DED"),
                SecDedTrim("SEC-DED-TRIM"),
            ],
        )

        self.system_layout = SumBlock(self.name, [main_chain, OtherComponents("Other_HW")])

configure_system()

Defines the hierarchical structure of the LPDDR5 system.

Constructs the main DRAM processing chain (Sources -> SEC -> TRIM -> BUS -> LINK -> SEC-DED -> TRIM) and merges it with other hardware components.

Source code in src/ecc_analyzer/models/lpddr5/lpddr5_system.py 
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
def configure_system(self):
    """Defines the hierarchical structure of the LPDDR5 system.

    Constructs the main DRAM processing chain (Sources -> SEC -> TRIM -> BUS -> LINK -> SEC-DED -> TRIM)
    and merges it with other hardware components.
    """
    main_chain = PipelineBlock(
        "DRAM_Path",
        [
            Events("DRAM_Sources"),
            Sec("SEC"),
            DramTrim("TRIM"),
            BusTrim("BUS"),
            LinkEcc("LINK-ECC"),
            SecDed("SEC-DED"),
            SecDedTrim("SEC-DED-TRIM"),
        ],
    )

    self.system_layout = SumBlock(self.name, [main_chain, OtherComponents("Other_HW")])

OtherComponents

Bases: Base

Component representing miscellaneous hardware parts that contribute a fixed FIT rate.

This module encapsulates all non-DRAM components (e.g., peripheral logic) into a single source injection block to simplify the top-level model.

Source code in src/ecc_analyzer/models/lpddr5/other_components.py 
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
class OtherComponents(Base):
    """Component representing miscellaneous hardware parts that contribute a fixed FIT rate.

    This module encapsulates all non-DRAM components (e.g., peripheral logic) into a
    single source injection block to simplify the top-level model.
    """

    def __init__(self, name: str):
        """Initializes the component and sets the constant source FIT rate.

        Args:
            name (str): The descriptive name of the component.
        """
        self.other_rf_source = 9.5

        super().__init__(name)

    def configure_blocks(self):
        """Configures the root block to inject the FIT rate.

        Uses a SumBlock as the base container for the fault source (BasicEvent).
        The fault is injected into the residual path (is_spfm=True).
        """
        self.root_block = SumBlock(
            self.name,
            [
                BasicEvent(FaultType.OTH, self.other_rf_source, is_spfm=True),
            ],
        )

__init__(name)

Initializes the component and sets the constant source FIT rate.

Parameters:

Name Type Description Default
name str

The descriptive name of the component.

 required
Source code in src/ecc_analyzer/models/lpddr5/other_components.py 
16
17
18
19
20
21
22
23
24
def __init__(self, name: str):
    """Initializes the component and sets the constant source FIT rate.

    Args:
        name (str): The descriptive name of the component.
    """
    self.other_rf_source = 9.5

    super().__init__(name)

configure_blocks()

Configures the root block to inject the FIT rate.

Uses a SumBlock as the base container for the fault source (BasicEvent). The fault is injected into the residual path (is_spfm=True).

Source code in src/ecc_analyzer/models/lpddr5/other_components.py 
26
27
28
29
30
31
32
33
34
35
36
37
def configure_blocks(self):
    """Configures the root block to inject the FIT rate.

    Uses a SumBlock as the base container for the fault source (BasicEvent).
    The fault is injected into the residual path (is_spfm=True).
    """
    self.root_block = SumBlock(
        self.name,
        [
            BasicEvent(FaultType.OTH, self.other_rf_source, is_spfm=True),
        ],
    )

Sec

Bases: Base

Component for Single Error Correction (SEC) in LPDDR5.

This module handles SBE coverage (correcting single bit errors) and redistributes DBE failure rates (Double Bit Errors splitting into TBE). It also introduces a latent Single Bit (SB) fault source.

Source code in src/ecc_analyzer/models/lpddr5/sec.py 
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
class Sec(Base):
    """Component for Single Error Correction (SEC) in LPDDR5.

    This module handles SBE coverage (correcting single bit errors) and redistributes
    DBE failure rates (Double Bit Errors splitting into TBE). It also introduces
    a latent Single Bit (SB) fault source.
    """

    def __init__(self, name: str):
        """Initializes the SEC component.

        Args:
            name (str): The descriptive name of the component.
        """
        self.sbe_dc_residual = 1.0
        self.sbe_dc_latent = 0.0

        self.dbe_to_dbe_p = 0.83
        self.dbe_to_tbe_p = 0.17

        self.sb_source = 0.1

        super().__init__(name)

    def configure_blocks(self):
        """Configures the root block.

        Combines latent fault injection (SB) with parallel processing of incoming
        SBE (Coverage) and DBE (Split) faults using a SumBlock.
        """
        self.root_block = SumBlock(
            self.name,
            [
                BasicEvent(FaultType.SB, self.sb_source, is_spfm=False),
                CoverageBlock(
                    FaultType.SBE,
                    self.sbe_dc_residual,
                    dc_rate_latent_cL=self.sbe_dc_latent,
                    is_spfm=True,
                ),
                SplitBlock(
                    "DBE_Split",
                    FaultType.DBE,
                    {
                        FaultType.DBE: self.dbe_to_dbe_p,
                        FaultType.TBE: self.dbe_to_tbe_p,
                    },
                    is_spfm=True,
                ),
            ],
        )

__init__(name)

Initializes the SEC component.

Parameters:

Name Type Description Default
name str

The descriptive name of the component.

 required
Source code in src/ecc_analyzer/models/lpddr5/sec.py 
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
def __init__(self, name: str):
    """Initializes the SEC component.

    Args:
        name (str): The descriptive name of the component.
    """
    self.sbe_dc_residual = 1.0
    self.sbe_dc_latent = 0.0

    self.dbe_to_dbe_p = 0.83
    self.dbe_to_tbe_p = 0.17

    self.sb_source = 0.1

    super().__init__(name)

configure_blocks()

Configures the root block.

Combines latent fault injection (SB) with parallel processing of incoming SBE (Coverage) and DBE (Split) faults using a SumBlock.

Source code in src/ecc_analyzer/models/lpddr5/sec.py 
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
def configure_blocks(self):
    """Configures the root block.

    Combines latent fault injection (SB) with parallel processing of incoming
    SBE (Coverage) and DBE (Split) faults using a SumBlock.
    """
    self.root_block = SumBlock(
        self.name,
        [
            BasicEvent(FaultType.SB, self.sb_source, is_spfm=False),
            CoverageBlock(
                FaultType.SBE,
                self.sbe_dc_residual,
                dc_rate_latent_cL=self.sbe_dc_latent,
                is_spfm=True,
            ),
            SplitBlock(
                "DBE_Split",
                FaultType.DBE,
                {
                    FaultType.DBE: self.dbe_to_dbe_p,
                    FaultType.TBE: self.dbe_to_tbe_p,
                },
                is_spfm=True,
            ),
        ],
    )

SecDed

Bases: Base

Component for Single Error Correction and Double Error Detection (SEC-DED).

This module handles the diagnostic coverage for multiple fault types (SBE, DBE, TBE, MBE) and manages the transformation of Triple Bit Errors (TBE) into Multi Bit Errors (MBE).

Source code in src/ecc_analyzer/models/lpddr5/sec_ded.py 
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
class SecDed(Base):
    """Component for Single Error Correction and Double Error Detection (SEC-DED).

    This module handles the diagnostic coverage for multiple fault types (SBE, DBE, TBE, MBE)
    and manages the transformation of Triple Bit Errors (TBE) into Multi Bit Errors (MBE).
    """

    def __init__(self, name: str):
        """Initializes the SEC-DED component with coverage and source parameters.

        Args:
            name (str): The descriptive name of the component.
        """

        self.sbe_dc = 1.0
        self.dbe_dc = 1.0
        self.mbe_dc = 0.5
        self.tbe_dc = 1.0

        self.tbe_split_to_mbe = 0.56

        self.lfm_sbe_dc = 1.0
        self.lfm_dbe_dc = 1.0

        self.sdb_source = 0.1

        super().__init__(name)

    def configure_blocks(self):
        """Configures the block structure.

        Uses a SumBlock to combine the latent fault source (SDB) with the main
        processing pipeline (Split & Coverage).
        """
        spfm_pipeline = PipelineBlock(
            "SEC_DED_Processing",
            [
                SplitBlock(
                    "TBE_to_MBE_Split",
                    FaultType.TBE,
                    {
                        FaultType.MBE: self.tbe_split_to_mbe,
                        FaultType.TBE: 1.0 - self.tbe_split_to_mbe,
                    },
                    is_spfm=True,
                ),
                CoverageBlock(
                    FaultType.SBE,
                    self.sbe_dc,
                    dc_rate_latent_cL=self.lfm_sbe_dc,
                    is_spfm=True,
                ),
                CoverageBlock(
                    FaultType.DBE,
                    self.dbe_dc,
                    dc_rate_latent_cL=self.lfm_dbe_dc,
                    is_spfm=True,
                ),
                CoverageBlock(FaultType.TBE, self.tbe_dc, is_spfm=True),
                CoverageBlock(FaultType.MBE, self.mbe_dc, is_spfm=True),
            ],
        )

        self.root_block = SumBlock(
            self.name,
            [
                spfm_pipeline,
                BasicEvent(FaultType.SDB, self.sdb_source, is_spfm=False),
            ],
        )

__init__(name)

Initializes the SEC-DED component with coverage and source parameters.

Parameters:

Name Type Description Default
name str

The descriptive name of the component.

 required
Source code in src/ecc_analyzer/models/lpddr5/sec_ded.py 
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
def __init__(self, name: str):
    """Initializes the SEC-DED component with coverage and source parameters.

    Args:
        name (str): The descriptive name of the component.
    """

    self.sbe_dc = 1.0
    self.dbe_dc = 1.0
    self.mbe_dc = 0.5
    self.tbe_dc = 1.0

    self.tbe_split_to_mbe = 0.56

    self.lfm_sbe_dc = 1.0
    self.lfm_dbe_dc = 1.0

    self.sdb_source = 0.1

    super().__init__(name)

configure_blocks()

Configures the block structure.

Uses a SumBlock to combine the latent fault source (SDB) with the main processing pipeline (Split & Coverage).

Source code in src/ecc_analyzer/models/lpddr5/sec_ded.py 
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
def configure_blocks(self):
    """Configures the block structure.

    Uses a SumBlock to combine the latent fault source (SDB) with the main
    processing pipeline (Split & Coverage).
    """
    spfm_pipeline = PipelineBlock(
        "SEC_DED_Processing",
        [
            SplitBlock(
                "TBE_to_MBE_Split",
                FaultType.TBE,
                {
                    FaultType.MBE: self.tbe_split_to_mbe,
                    FaultType.TBE: 1.0 - self.tbe_split_to_mbe,
                },
                is_spfm=True,
            ),
            CoverageBlock(
                FaultType.SBE,
                self.sbe_dc,
                dc_rate_latent_cL=self.lfm_sbe_dc,
                is_spfm=True,
            ),
            CoverageBlock(
                FaultType.DBE,
                self.dbe_dc,
                dc_rate_latent_cL=self.lfm_dbe_dc,
                is_spfm=True,
            ),
            CoverageBlock(FaultType.TBE, self.tbe_dc, is_spfm=True),
            CoverageBlock(FaultType.MBE, self.mbe_dc, is_spfm=True),
        ],
    )

    self.root_block = SumBlock(
        self.name,
        [
            spfm_pipeline,
            BasicEvent(FaultType.SDB, self.sdb_source, is_spfm=False),
        ],
    )

SecDedTrim

Bases: Base

Component for trimming and distributing residual and latent fault rates after SEC-DED processing.

This module chains sequential split operations for SBE, DBE, and TBE fault types to model the final trimming behavior of the LPDDR5 architecture.

Source code in src/ecc_analyzer/models/lpddr5/sec_ded_trim.py 
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
class SecDedTrim(Base):
    """Component for trimming and distributing residual and latent fault rates after SEC-DED processing.

    This module chains sequential split operations for SBE, DBE, and TBE fault types to
    model the final trimming behavior of the LPDDR5 architecture.
    """

    def __init__(self, name: str):
        """Initializes the SecDedTrim component with predefined split parameters.

        Args:
            name (str): The descriptive name of the component.
        """
        self.spfm_sbe_split = {FaultType.SBE: 0.89}
        self.spfm_dbe_split = {FaultType.SBE: 0.20, FaultType.DBE: 0.79}
        self.spfm_tbe_split = {
            FaultType.SBE: 0.03,
            FaultType.DBE: 0.27,
            FaultType.TBE: 0.70,
        }

        self.lfm_sbe_split = self.spfm_sbe_split
        self.lfm_dbe_split = self.spfm_dbe_split
        self.lfm_tbe_split = self.spfm_tbe_split

        super().__init__(name)

    def configure_blocks(self):
        """Configures the root block as a collection of split operations.

        Redistributes faults for both residual (SPFM) and latent (LFM) paths.
        """
        self.root_block = SumBlock(
            self.name,
            [
                SplitBlock("SPFM_SBE_Split", FaultType.SBE, self.spfm_sbe_split, is_spfm=True),
                SplitBlock("SPFM_DBE_Split", FaultType.DBE, self.spfm_dbe_split, is_spfm=True),
                SplitBlock("SPFM_TBE_Split", FaultType.TBE, self.spfm_tbe_split, is_spfm=True),
                SplitBlock("LFM_SBE_Split", FaultType.SBE, self.lfm_sbe_split, is_spfm=False),
                SplitBlock("LFM_DBE_Split", FaultType.DBE, self.lfm_dbe_split, is_spfm=False),
                SplitBlock("LFM_TBE_Split", FaultType.TBE, self.lfm_tbe_split, is_spfm=False),
            ],
        )

__init__(name)

Initializes the SecDedTrim component with predefined split parameters.

Parameters:

Name Type Description Default
name str

The descriptive name of the component.

 required
Source code in src/ecc_analyzer/models/lpddr5/sec_ded_trim.py 
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
def __init__(self, name: str):
    """Initializes the SecDedTrim component with predefined split parameters.

    Args:
        name (str): The descriptive name of the component.
    """
    self.spfm_sbe_split = {FaultType.SBE: 0.89}
    self.spfm_dbe_split = {FaultType.SBE: 0.20, FaultType.DBE: 0.79}
    self.spfm_tbe_split = {
        FaultType.SBE: 0.03,
        FaultType.DBE: 0.27,
        FaultType.TBE: 0.70,
    }

    self.lfm_sbe_split = self.spfm_sbe_split
    self.lfm_dbe_split = self.spfm_dbe_split
    self.lfm_tbe_split = self.spfm_tbe_split

    super().__init__(name)

configure_blocks()

Configures the root block as a collection of split operations.

Redistributes faults for both residual (SPFM) and latent (LFM) paths.

Source code in src/ecc_analyzer/models/lpddr5/sec_ded_trim.py 
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
def configure_blocks(self):
    """Configures the root block as a collection of split operations.

    Redistributes faults for both residual (SPFM) and latent (LFM) paths.
    """
    self.root_block = SumBlock(
        self.name,
        [
            SplitBlock("SPFM_SBE_Split", FaultType.SBE, self.spfm_sbe_split, is_spfm=True),
            SplitBlock("SPFM_DBE_Split", FaultType.DBE, self.spfm_dbe_split, is_spfm=True),
            SplitBlock("SPFM_TBE_Split", FaultType.TBE, self.spfm_tbe_split, is_spfm=True),
            SplitBlock("LFM_SBE_Split", FaultType.SBE, self.lfm_sbe_split, is_spfm=False),
            SplitBlock("LFM_DBE_Split", FaultType.DBE, self.lfm_dbe_split, is_spfm=False),
            SplitBlock("LFM_TBE_Split", FaultType.TBE, self.lfm_tbe_split, is_spfm=False),
        ],
    )