Skip to content

Index

Exposes the LPDDR4 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 (MBE, AZ) and redistributes SBE, DBE, and TBE faults for both SPFM and LFM paths.

Source code in src/ecc_analyzer/models/lpddr4/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
55
class BusTrim(Base):
    """Component for trimming and distributing failure rates across the bus architecture.

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

    def __init__(self, name: str):
        """Initializes the BusTrim component with LPDDR4-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.lfm_sbe_split = {FaultType.SBE: 0.438}
        self.lfm_dbe_split = {FaultType.SBE: 0.496, FaultType.DBE: 0.314}

        self.spfm_mbe_source = 2.3
        self.spfm_az_source = 172.0

        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 source injections and parallel redistribution
        (SplitBlocks) of incoming faults.
        """
        self.root_block = SumBlock(
            self.name,
            [
                BasicEvent(FaultType.MBE, self.spfm_mbe_source, is_spfm=True),
                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),
            ],
        )

__init__(name)

Initializes the BusTrim component with LPDDR4-specific split parameters.

Parameters:

Name Type Description Default
name str

The descriptive name of the component.

 required
Source code in src/ecc_analyzer/models/lpddr4/bus_trim.py 
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
def __init__(self, name: str):
    """Initializes the BusTrim component with LPDDR4-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.lfm_sbe_split = {FaultType.SBE: 0.438}
    self.lfm_dbe_split = {FaultType.SBE: 0.496, FaultType.DBE: 0.314}

    self.spfm_mbe_source = 2.3
    self.spfm_az_source = 172.0

    super().__init__(name)

configure_blocks()

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

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

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

    Uses a SumBlock to aggregate source injections and parallel redistribution
    (SplitBlocks) of incoming faults.
    """
    self.root_block = SumBlock(
        self.name,
        [
            BasicEvent(FaultType.MBE, self.spfm_mbe_source, is_spfm=True),
            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),
        ],
    )

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 LPDDR4.

Source code in src/ecc_analyzer/models/lpddr4/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
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 LPDDR4.
    """

    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 = {FaultType.SBE: 0.94}
        self.lfm_dbe_split = {FaultType.SBE: 0.11, FaultType.DBE: 0.89}

        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),
            ],
        )

__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/lpddr4/dram_trim.py 
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
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 = {FaultType.SBE: 0.94}
    self.lfm_dbe_split = {FaultType.SBE: 0.11, FaultType.DBE: 0.89}

    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/lpddr4/dram_trim.py 
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
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),
        ],
    )

Events

Bases: Base

Initializes the baseline DRAM failure rates for LPDDR4.

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/lpddr4/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 LPDDR4.

    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/lpddr4/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/lpddr4/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),
        ],
    )

Lpddr4System

Bases: SystemBase

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

Source code in src/ecc_analyzer/models/lpddr4/lpddr4_system.py 
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
class Lpddr4System(SystemBase):
    """
    Coordinates the connection of all sub-components and defines the overall system layout.
    """

    def configure_system(self):
        """
        Defines the hierarchical structure of the LPDDR4 system.
        Constructs the main DRAM processing chain and merges it with other hardware components.
        """
        main_chain = PipelineBlock(
            "DRAM_Path",
            [
                Events("Source"),
                Sec("SEC"),
                DramTrim("TRIM"),
                BusTrim("BUS"),
                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 LPDDR4 system. Constructs the main DRAM processing chain and merges it with other hardware components.

Source code in src/ecc_analyzer/models/lpddr4/lpddr4_system.py 
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
def configure_system(self):
    """
    Defines the hierarchical structure of the LPDDR4 system.
    Constructs the main DRAM processing chain and merges it with other hardware components.
    """
    main_chain = PipelineBlock(
        "DRAM_Path",
        [
            Events("Source"),
            Sec("SEC"),
            DramTrim("TRIM"),
            BusTrim("BUS"),
            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 into a single source injection block to simplify the top-level model.

Source code in src/ecc_analyzer/models/lpddr4/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
class OtherComponents(Base):
    """Component representing miscellaneous hardware parts that contribute a fixed FIT rate.

    This module encapsulates all non-DRAM components 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.source_rate = 96.0
        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.source_rate, 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/lpddr4/other_components.py 
16
17
18
19
20
21
22
23
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.source_rate = 96.0
    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/lpddr4/other_components.py 
25
26
27
28
29
30
31
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.source_rate, is_spfm=True)])

Sec

Bases: Base

Component for Single Error Correction (SEC) in LPDDR4 architectures.

This module handles SBE coverage and redistributes DBE failure rates into TBEs. It uses a PipelineBlock to ensure that local sources are added before diagnostic coverage and split operations are applied.

Source code in src/ecc_analyzer/models/lpddr4/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
class Sec(Base):
    """Component for Single Error Correction (SEC) in LPDDR4 architectures.

    This module handles SBE coverage and redistributes DBE failure rates into TBEs.
    It uses a PipelineBlock to ensure that local sources are added before
    diagnostic coverage and split operations are applied.
    """

    def __init__(self, name: str):
        """Initializes the SEC component with specific diagnostic coverage and failure rates.

        Args:
            name (str): The descriptive name of the component.
        """
        self.sec_ecc_dc = 1.0
        self.dbe_to_dbe_p = 0.83
        self.dbe_to_tbe_p = 0.17

        self.sb_source = 0.1
        self.dbe_source = 172.0

        super().__init__(name)

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

        This ensures fault sources are injected first, followed by coverage application
        and final rate redistribution.
        """
        self.root_block = SumBlock(
            self.name,
            [
                BasicEvent(FaultType.SB, self.sb_source, is_spfm=False),
                BasicEvent(FaultType.DBE, self.dbe_source, is_spfm=False),
                CoverageBlock(FaultType.SBE, self.sec_ecc_dc),
                SplitBlock(
                    "DBE_to_TBE_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 with specific diagnostic coverage and failure rates.

Parameters:

Name Type Description Default
name str

The descriptive name of the component.

 required
Source code in src/ecc_analyzer/models/lpddr4/sec.py 
17
18
19
20
21
22
23
24
25
26
27
28
29
30
def __init__(self, name: str):
    """Initializes the SEC component with specific diagnostic coverage and failure rates.

    Args:
        name (str): The descriptive name of the component.
    """
    self.sec_ecc_dc = 1.0
    self.dbe_to_dbe_p = 0.83
    self.dbe_to_tbe_p = 0.17

    self.sb_source = 0.1
    self.dbe_source = 172.0

    super().__init__(name)

configure_blocks()

Configures the internal block structure as a sequential pipeline.

This ensures fault sources are injected first, followed by coverage application and final rate redistribution.

Source code in src/ecc_analyzer/models/lpddr4/sec.py 
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
def configure_blocks(self):
    """Configures the internal block structure as a sequential pipeline.

    This ensures fault sources are injected first, followed by coverage application
    and final rate redistribution.
    """
    self.root_block = SumBlock(
        self.name,
        [
            BasicEvent(FaultType.SB, self.sb_source, is_spfm=False),
            BasicEvent(FaultType.DBE, self.dbe_source, is_spfm=False),
            CoverageBlock(FaultType.SBE, self.sec_ecc_dc),
            SplitBlock(
                "DBE_to_TBE_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 manages diagnostic coverage for multiple fault types and handles transformations between failure modes (e.g., TBE -> MBE).

Source code in src/ecc_analyzer/models/lpddr4/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
class SecDed(Base):
    """Component for Single Error Correction and Double Error Detection (SEC-DED).

    This module manages diagnostic coverage for multiple fault types and handles
    transformations between failure modes (e.g., TBE -> MBE).
    """

    def __init__(self, name: str):
        """Initializes the SEC-DED component with specific diagnostic 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 internal block structure as a sum block."""
        self.root_block = SumBlock(
            self.name,
            [
                BasicEvent(FaultType.SDB, self.sdb_source, is_spfm=False),
                CoverageBlock(FaultType.SBE, self.lfm_sbe_dc, is_spfm=False),
                CoverageBlock(FaultType.DBE, self.lfm_dbe_dc, is_spfm=False),
                TransformationBlock(FaultType.TBE, FaultType.MBE, self.tbe_split_to_mbe),
                CoverageBlock(FaultType.SBE, self.sbe_dc),
                CoverageBlock(FaultType.DBE, self.dbe_dc),
                CoverageBlock(FaultType.TBE, self.tbe_dc),
                CoverageBlock(FaultType.MBE, self.mbe_dc),
            ],
        )

__init__(name)

Initializes the SEC-DED component with specific diagnostic 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/lpddr4/sec_ded.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 SEC-DED component with specific diagnostic 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 internal block structure as a sum block.

Source code in src/ecc_analyzer/models/lpddr4/sec_ded.py 
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
def configure_blocks(self):
    """Configures the internal block structure as a sum block."""
    self.root_block = SumBlock(
        self.name,
        [
            BasicEvent(FaultType.SDB, self.sdb_source, is_spfm=False),
            CoverageBlock(FaultType.SBE, self.lfm_sbe_dc, is_spfm=False),
            CoverageBlock(FaultType.DBE, self.lfm_dbe_dc, is_spfm=False),
            TransformationBlock(FaultType.TBE, FaultType.MBE, self.tbe_split_to_mbe),
            CoverageBlock(FaultType.SBE, self.sbe_dc),
            CoverageBlock(FaultType.DBE, self.dbe_dc),
            CoverageBlock(FaultType.TBE, self.tbe_dc),
            CoverageBlock(FaultType.MBE, self.mbe_dc),
        ],
    )

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 LPDDR4 architecture.

Source code in src/ecc_analyzer/models/lpddr4/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
52
53
54
55
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 LPDDR4 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 = {FaultType.SBE: 0.89}
        self.lfm_dbe_split = {FaultType.SBE: 0.20, FaultType.DBE: 0.79}
        self.lfm_tbe_split = {
            FaultType.SBE: 0.03,
            FaultType.DBE: 0.27,
            FaultType.TBE: 0.70,
        }

        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/lpddr4/sec_ded_trim.py 
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
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 = {FaultType.SBE: 0.89}
    self.lfm_dbe_split = {FaultType.SBE: 0.20, FaultType.DBE: 0.79}
    self.lfm_tbe_split = {
        FaultType.SBE: 0.03,
        FaultType.DBE: 0.27,
        FaultType.TBE: 0.70,
    }

    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/lpddr4/sec_ded_trim.py 
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
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),
        ],
    )