Patent Publication Number: US-8990655-B2

Title: Techniques associated with error correction for encoded data

Description:
BACKGROUND 
     An error correction code (ECC) may be used to protect data or recover from errors related to a medium via which the data was either transmitted or stored. For example, data may be encoded using an ECC to possibly recover from errors associated with wired/wireless communications, storage to memory devices/mediums or optical readers such as 2-dimensional bar code readers. ECC encoded data received by either reading data from a memory device/medium or barcode or received via a wired/wireless communication channel may be able to identify and correct a given number of errors. Typically, ECC encoded data may include codewords having a combination of data and redundant or parity bits or symbols. Depending on the size of a given codeword and the level of protection desired, codewords may vary in size and also may vary in the complexity of algorithms used to recover from possible errors. 
     Errors in a given period of time may be referred to as a bit error rate (BER). Technological advances in digital signal transmissions that have greatly increased data transmission speeds have also increased the possibility of a higher BER. Also, memory storage/medium technologies have resulted in increasingly denser storage that may also lead to an increased possibility of a higher BER. In order to reduce the impacts of possibly higher BERs, data may be encoded in larger codewords. These larger codewords may have more parity bits. Large codewords with more parity bits may require complex algorithms implemented with increasing amount of computing resources. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         FIG. 1  illustrates an example memory system. 
         FIG. 2  illustrates an example storage system. 
         FIG. 3  illustrates an example error correction code (ECC) system. 
         FIG. 4  illustrates an example single error system. 
         FIG. 5  illustrates an example single/multiple error system. 
         FIG. 6  illustrates an example apparatus. 
         FIG. 7  illustrates an example logic flow. 
         FIG. 8  illustrates an example storage medium. 
         FIG. 9  illustrates an example computing platform. 
     
    
    
     DETAILED DESCRIPTION 
     As contemplated in the present disclosure, large codewords with more parity bits may require complex algorithms implemented with increasing amounts of computing resources in order to reduce BERs. In some examples, users of memory storage technologies seek a balance between reducing BERs yet minimizing latencies possibly caused by using increasing amounts of computing resources (e.g., processor clock cycles). Some memory storage technologies such as those associated with non-volatile memories (e.g., phase change memory) may have relatively fast data access times but inherent physical characteristics of the non-volatile memories may lead to a higher potential for BERs. Thus, relatively large codewords are used to protect data and counteract the higher potential for BERs. However, more computing resources may be used to decode these large codewords when errors are detected. More computing resources may increase access times to unacceptable levels for some desired uses of at least some types of non-volatile memory (e.g., two level memory (2LM) or solid state drive (SSD)). It is with respect to these and other challenges that the examples described herein are needed. 
     In some examples, techniques associated with error correction for encoded data may be implemented. These techniques may include receiving, at a processor circuit, error correction code (ECC) information for ECC encoded data indicating one or more errors in the ECC encoded data. A determination may then be made as to whether the ECC encoded data includes a single error. Base on the determination, an error location for the single error in the ECC encoded data may be identified or a flag may be generated to indicate the ECC encoded data has more than one error. For examples of the ECC encoded data including more than one error, separate error locations may be identified. The one or more errors may then be corrected and the ECC encoded data may be decoded. 
       FIG. 1  illustrates an example memory system  100 . As shown in  FIG. 1 , memory system  100  includes a controller  110  and a memory  120 . According to some examples, controller  110  may receive and/or fulfill read/write requests via communication link  130 . Although not shown in  FIG. 1 , in some examples, communication link  130  may communicatively couple controller  110  to elements or features associated with an operating system for a computing device. For these examples, memory system  100  may be a memory device for the computing device. As a memory device, memory system  100  may serve as a two level memory (2LM) system or a solid state drive (SSD) for the computing device. 
     In some examples, as shown in  FIG. 1 , controller  110  may include an error correction code (ECC) encoder  112  and an ECC decoder  114 . ECC encoder  112  may include logic and/or features to generate codewords to protect data to be written to memory  120 . As described in more detail below, ECC decoder  114  may include logic and/or features to detect, locate, possibly evaluate and correct errors included in ECC encoded data. According to some examples, the ECC used to encode the data may include, but is not limited to, Reed-Solomon (RS) codes or binary Bose, Chaudhuri, and Hocquenghem (BCH) codes. 
     In some examples, memory  120  may include non-volatile and/or volatile types of memory. Non-volatile types of memory may include, but are not limited to, phase change memory (PCM), PCM and switch (PCMS), flash memory, ferroelectric memory, silicon-oxide-nitride-oxide-silicon (SONOS) memory, polymer memory such as ferroelectric polymer memory, nanowire, ferroelectric transistor random access memory (FeTRAM or FeRAM), ovonic memory or electrically erasable programmable read-only memory (EEPROM). Volatile types of memory may include, but are not limited to, dynamic random access memory (DRAM) or static RAM (SRAM). 
     In some examples, memory  120  may also include types of storage mediums such as optical discs to include, but not limited to, compact discs (CDs), digital versatile discs (DVDs), a high definition DVD (HD DVD) or a Blu-ray disc. 
     According to some examples where memory system  100  is configured as a 2LM system, memory system  100  may serve as main memory for a computing device. For these examples, memory  120  may include the two levels of memory including cached subsets of system disk level storage. In this configuration, the main memory may include “near memory” arranged to include volatile types on memory and “far memory” arranged to include volatile or non-volatile types of memory. The far memory may include volatile or non-volatile memory that may be larger and possibly slower than the volatile memory included in the near memory. The far memory may be presented as “main memory” to an operating system (OS) for the computing device while the near memory is a cache for the far memory that is transparent to the OS. The management of the 2LM system may be done by a combination of logic and modules executed via either controller  110  and/or processing circuitry (e.g., a CPU) for the computing device. Near memory may be coupled to the processing circuitry via high bandwidth, low latency means for efficient processing. Far memory may be coupled to the processing circuitry via low bandwidth, high latency means. 
       FIG. 2  illustrates an example storage system. In some examples, as shown in  FIG. 2 , storage system  200  includes a compression/encryption unit  205 , ECC encoder  112 , a scrambler unit  210 , memory  120 , a descrambler unit  205 , ECC decoder  114  and a decryption/decompression unit  220 . 
     According to some examples, as shown in  FIG. 2 , compression/encryption of data at compression/encryption unit  205  may result in “u”. ECC encoder  112  may receive u and generate a codeword “x” using an ECC code (e.g., binary BCH or RS). Scrambler unit  210  may receive x and cause x to be programmed or written to memory  120 . The codeword may be read from memory  120  and descrambled by descrambler unit  205  to result in a codeword “y”. As shown in  FIG. 2 , y=x+e n , where “e n ” represents errors possibly introduced during the writing then reading of x from memory  120  and “n” represents the number of errors introduced during the writes and reads from memory  120 . ECC decoder  114  may receive y and possibly correct identified errors to generate “d”. As shown in  FIG. 2 , if the errors were correctable, d=u. Decryption/Decompression unit  220  may then decrypt/decompress u to generate data originally compressed/encrypted by compression/encryption unit  205 . 
     In some examples, ECC decoder  114  may include logic and/or features to receive ECC encoded data y having e n . ECC decoder  114  may determine whether e n  includes a single error or multiple errors. For these examples, if e n  includes a single error, ECC decoder  114  may include logic and/or features to either identify an error location and/or error value in ECC encoded data y or generate a flag to indicate y includes more than one error. If a flag is generated, ECC decoder  114  may go through a more computing resource intensive ECC process to separately identify error locations and/or values in y. This process of identifying a location and/or error value for a single error in y before attempting to identify a plurality of error locations and/or values in y may substantially reduce error correction latencies for types of memory that predominately have single errors when errors are detected in ECC encoded data. 
     According to some examples, identification of the plurality of errors e n  in y when the ECC used to decode y is either an RS code or a binary BCH code may use several processor clock cycles to identify possible errors. For example, a Berlekamp-Massey algorithm (BMA) may be implemented by logic and/or features of ECC decoder  114  that includes a plurality of computations to generate error location polynomials. A Chien Search may then be implemented by ECC decoder  114  to locate the errors. Also, additional processor clock cycles may be used to identify an error value for located errors if the ECC used to decode y is the RS code. 
     Although  FIG. 2 , depicts ECC encoded data having errors possibly caused by writing/reading data to memory  120 . Other types of ECC encoded data such as ECC encoded data associated with wired/wireless communications or ECC encoded data associated with optical readers for 2-dimensional bar coder readers are also contemplated. 
     In some examples, a single error identification process may be based on the type of ECC code used to both encode u and decode y. For example, for binary BCH codes, partial syndromes that identify errors in y may have properties shown below for example equation (1) when there is one error, where j is the location of the error.
         Example Equation (1):       

     
       
         
           
             
               S 
               1 
             
             = 
             
               
                 
                   ∝ 
                   j 
                 
                 ⁢ 
                 
                   
 
                 
                 ⁢ 
                 
                   S 
                   2 
                 
               
               = 
               
                 
                   
                     ∝ 
                     
                       2 
                       ⁢ 
                       j 
                     
                   
                   ⁢ 
                   
                     
 
                   
                   ⁢ 
                   
                     S 
                     3 
                   
                 
                 = 
                 
                   
                     ∝ 
                     
                       3 
                       ⁢ 
                       j 
                     
                   
                   ⁢ 
                   
                     
 
                   
                   ⁢ 
                   … 
                 
               
             
           
         
       
       
         
           
             
               S 
               
                 2 
                 ⁢ 
                 t 
               
             
             = 
             
               ∝ 
               
                 2 
                 ⁢ 
                 tj 
               
             
           
         
       
     
     According to some examples, to correct a single bit error, a check to see if the partial syndromes form a geometric series may be made. The error location j may be determined based on example algorithm or equation (2).
 
 j=∝   j =log  S   1   Example equation (2)
 
     In some examples, ECC decoder  114  may include logic and/or features to implement example equation (2) via use of a lookup table or a logarithm calculating unit. 
     According to some examples, in binary BCH, even partial syndromes are fully determined by odd partial syndromes, so there may be no need to check the even partial syndromes. For these examples, example equation (3) may check that:
         Example Equation (3):       

     
       
         
           
             
               S 
               3 
             
             = 
             
               
                 ( 
                 
                   S 
                   1 
                 
                 ) 
               
               3 
             
           
         
       
       
         
           
             
               S 
               5 
             
             = 
             
               
                 ( 
                 
                   S 
                   1 
                 
                 ) 
               
               5 
             
           
         
       
       
         
           
             
               S 
               7 
             
             = 
             
               
                 ( 
                 
                   S 
                   1 
                 
                 ) 
               
               7 
             
           
         
       
       
         
           … 
         
       
       
         
           
             
               S 
               
                 
                   2 
                   ⁢ 
                   t 
                 
                 - 
                 1 
               
             
             = 
             
               
                 ( 
                 
                   S 
                   1 
                 
                 ) 
               
               
                 
                   2 
                   ⁢ 
                   t 
                 
                 - 
                 1 
               
             
           
         
       
     
     Also, in order to check for a geometric series, it may be shown by example equation (5) that:
         Example Equation (4):       

     
       
         
           
             
               ∝ 
               
                 2 
                 ⁢ 
                 j 
               
             
             ⁢ 
             
               = 
               
                 
                   
                     S 
                     3 
                   
                   
                     S 
                     1 
                   
                 
                 = 
                 
                   
                     
                       S 
                       5 
                     
                     
                       S 
                       3 
                     
                   
                   = 
                   
                     
                       
                         S 
                         7 
                       
                       
                         S 
                         5 
                       
                     
                     = 
                     
                       … 
                       = 
                       
                         
                           S 
                           
                             
                               2 
                               ⁢ 
                               t 
                             
                             - 
                             1 
                           
                         
                         
                           S 
                           
                             
                               2 
                               ⁢ 
                               t 
                             
                             - 
                             3 
                           
                         
                       
                     
                   
                 
               
             
           
         
       
     
     However, checking for the geometric series using example equation (4) may require many divisions, which may be relatively expensive in terms of computing resources (e.g., clock cycles). Instead, example equation (5) may be used to check:
 
∝ 2tj   =S   1   S   2t−1   =S   3   S   2t−3   =S   5   S   2t−5   = . . . =S   2┌t/2┐−1   S   2└t/2┘+1   Example equation (5)
 
     Example equation (5) would show that the first t odd partial syndromes and the second t odd partial syndromes are symmetric. Example equation (6) may then be used to check only that the first t odd partial syndromes form a geometric series.
 
∝ (t+2)j   =S   1   S   t+1   =S   3   S   t−1   =S   5   S   t−3   = . . . =S   2┌┌t/2┐/2┐−1   S   2└┌t/2┐/2┘+1   Example equation (6)
 
     The check using example equation (6) would show that the first ┌t/2┐ odd partial syndromes and the second ┌t/2┐ odd partial syndromes are symmetric. Then example equation (7) may be used to check only that the first ┌t/2┐ odd partial syndromes form a geometric series and continue to divide and conquer until it can be shown that S 1 , S 3 , and S 5  form a geometric series.
         Example Equation (7):       

     
       
         
           
             
               
                 e 
                 2 
               
               ⁢ 
               
                 ∝ 
                 
                   
                     ( 
                     
                       
                         ⌈ 
                         
                           t 
                           / 
                           2 
                         
                         ⌉ 
                       
                       + 
                       1 
                     
                     ) 
                   
                   ⁢ 
                   j 
                 
               
             
             = 
             
               
                 
                   S 
                   1 
                 
                 ⁢ 
                 
                   S 
                   
                     ⌈ 
                     
                       t 
                       / 
                       2 
                     
                     ⌉ 
                   
                 
               
               = 
               
                 
                   
                     S 
                     2 
                   
                   ⁢ 
                   
                     S 
                     
                       
                         ⌈ 
                         
                           t 
                           / 
                           2 
                         
                         ⌉ 
                       
                       - 
                       1 
                     
                   
                 
                 = 
                 
                   
                     
                       S 
                       3 
                     
                     ⁢ 
                     
                       S 
                       
                         
                           ⌈ 
                           
                             t 
                             / 
                             2 
                           
                           ⌉ 
                         
                         - 
                         2 
                       
                     
                   
                   = 
                   
                     … 
                     = 
                     
                       
                         
                           
                             S 
                             
                               ⌈ 
                               
                                 
                                   ⌈ 
                                   
                                     t 
                                     / 
                                     2 
                                   
                                   ⌉ 
                                 
                                 / 
                                 2 
                               
                               ⌉ 
                             
                           
                           ⁢ 
                           
                             S 
                             
                               
                                 ⌊ 
                                 
                                   
                                     ⌈ 
                                     
                                       t 
                                       / 
                                       2 
                                     
                                     ⌉ 
                                   
                                   / 
                                   2 
                                 
                                 ⌋ 
                               
                               + 
                               1 
                             
                           
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           … 
                         
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         
                           ∝ 
                           
                             6 
                             ⁢ 
                             j 
                           
                         
                       
                       = 
                       
                         
                           
                             S 
                             1 
                           
                           ⁢ 
                           
                             S 
                             5 
                           
                         
                         = 
                         
                           S 
                           3 
                           2 
                         
                       
                     
                   
                 
               
             
           
         
       
     
     Further, to check that partial syndromes that form a geometric series match the form in example equation (3), check that example equation (8) is satisfied:
 
 S   3 =( S   1 ) 3   Example equation (8)
 
     According to some examples, single error correction for binary BCH codes may require (t−1) Galois field constant power functions and Galois field multipliers. The logic and/or features at decoder  114  may include (t−1) m-bit comparators and use of at least one lookup table or a logarithm calculating unit. According to some other examples, the logic and/or features at decoder  114  may include approximately t multipliers and t comparators or at least t−1 multipliers and t−1 comparators to multiply odd partial syndromes to check if the odd partial syndromes form a geometric series. 
     In some examples, for single error correction based on RS codes, partial syndromes that identify errors in y may have properties shown below for example equation (9) when there is one error, where j is the location of the error and e is the error value. 
     Example Equation (9): 
     
       
         
           
             
               S 
               1 
             
             = 
             
               
                 e 
                 ⁢ 
                 
                   ∝ 
                   j 
                 
                 ⁢ 
                 
                   
 
                 
                 ⁢ 
                 
                   S 
                   2 
                 
               
               = 
               
                 
                   e 
                   ⁢ 
                   
                     ∝ 
                     
                       2 
                       ⁢ 
                       j 
                     
                   
                   ⁢ 
                   
                     
 
                   
                   ⁢ 
                   
                     S 
                     3 
                   
                 
                 = 
                 
                   e 
                   ⁢ 
                   
                     ∝ 
                     
                       3 
                       ⁢ 
                       j 
                     
                   
                   ⁢ 
                   
                     
 
                   
                   ⁢ 
                   … 
                 
               
             
           
         
       
       
         
           
             
               S 
               
                 2 
                 ⁢ 
                 t 
               
             
             = 
             
               e 
               ⁢ 
               
                 ∝ 
                 
                   2 
                   ⁢ 
                   tj 
                 
               
             
           
         
       
     
     According to some examples, to correct a single error, example equation (10) may be used to check that the partial syndromes form a geometric series and then solve for e and j.
         Example Equation (10):       

     
       
         
           
             
               ∝ 
               j 
             
             ⁢ 
             
               = 
               
                 
                   
                     S 
                     2 
                   
                   
                     S 
                     1 
                   
                 
                 = 
                 
                   
                     
                       S 
                       3 
                     
                     
                       S 
                       2 
                     
                   
                   = 
                   
                     
                       
                         S 
                         4 
                       
                       
                         S 
                         3 
                       
                     
                     = 
                     
                       … 
                       = 
                       
                         
                           S 
                           
                             2 
                             ⁢ 
                             t 
                           
                         
                         
                           S 
                           
                             
                               2 
                               ⁢ 
                               t 
                             
                             - 
                             1 
                           
                         
                       
                     
                   
                 
               
             
           
         
       
     
     However, checking for the geometric series using example equation (10) may require many divisions, which are relatively expensive in terms of computing resources. Instead, example equation (11) may be used to check:
 
 e   2 ∝ (2t+1)j   =S   1   S   2t   =S   2   S   2t−1   =S   3   S   2t−2   = . . . =S   t   S   t+1   Example equation (11)
 
     Example equation (11) would show that the first t partial syndromes and the second t partial syndromes are symmetric. Example equation (12) may then be used to check only that the first t partial syndromes form a geometric series.
 
 e   2 ∝ (t+2)j   =S   1   S   t+1   =S   2   S   t   =S   3   S   t−1   = . . . =S   ┌(t+1)/2┐   S   └(t+1)/2┘+1   Example equation (12)
 
     The check using example equation (12) would show that the first ┌t/2┐ partial syndromes and the second ┌t/2┐ partial syndromes are symmetric. Then example equation (13) may be used to check only that the first ┌t/2┐ partial syndromes form a geometric series and continue to divide and conquer until it can be shown that S 1 , S 2 , and S 3  form a geometric series. 
     Example Equation (13): 
     
       
         
           
             
               
                 e 
                 2 
               
               ⁢ 
               
                 ∝ 
                 
                   
                     ( 
                     
                       
                         ⌊ 
                         
                           
                             ( 
                             
                               t 
                               + 
                               1 
                             
                             ) 
                           
                           / 
                           2 
                         
                         ⌋ 
                       
                       + 
                       2 
                     
                     ) 
                   
                   ⁢ 
                   j 
                 
               
             
             = 
             
               
                 
                   S 
                   1 
                 
                 ⁢ 
                 
                   S 
                   
                     
                       ⌊ 
                       
                         
                           ( 
                           
                             t 
                             + 
                             1 
                           
                           ) 
                         
                         / 
                         2 
                       
                       ⌋ 
                     
                     + 
                     1 
                   
                 
               
               = 
               
                 
                   
                     S 
                     2 
                   
                   ⁢ 
                   
                     S 
                     
                       
                         ⌈ 
                         
                           t 
                           / 
                           2 
                         
                         ⌉ 
                       
                       - 
                       1 
                     
                   
                 
                 = 
                 
                   
                     
                       S 
                       3 
                     
                     ⁢ 
                     
                       S 
                       
                         
                           ⌈ 
                           
                             t 
                             / 
                             2 
                           
                           ⌉ 
                         
                         - 
                         2 
                       
                     
                   
                   = 
                   
                     … 
                     = 
                     
                       
                         
                           
                             S 
                             
                               ⌈ 
                               
                                 
                                   ( 
                                   
                                     t 
                                     + 
                                     1 
                                   
                                   ) 
                                 
                                 / 
                                 2 
                               
                               ⌉ 
                             
                           
                           ⁢ 
                           
                             S 
                             
                               
                                 ⌊ 
                                 
                                   
                                     ( 
                                     
                                       
                                         ⌊ 
                                         
                                           
                                             ( 
                                             
                                               t 
                                               + 
                                               1 
                                             
                                             ) 
                                           
                                           / 
                                           2 
                                         
                                         ⌋ 
                                       
                                       + 
                                       1 
                                     
                                     ) 
                                   
                                   / 
                                   2 
                                 
                                 ⌋ 
                               
                               + 
                               1 
                             
                           
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           … 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           
                             e 
                             2 
                           
                         
                         ⁢ 
                         
                           ∝ 
                           
                             4 
                             ⁢ 
                             j 
                           
                         
                       
                       = 
                       
                         
                           
                             S 
                             1 
                           
                           ⁢ 
                           
                             S 
                             3 
                           
                         
                         = 
                         
                           S 
                           2 
                           2 
                         
                       
                     
                   
                 
               
             
           
         
       
     
     In some examples, example equation (14) may then be used to solve for e and j. 
     Example Equation (14): 
     
       
         
           
             e 
             = 
             
               
                 
                   
                     e 
                     2 
                   
                   ⁢ 
                   
                     ∝ 
                     
                       2 
                       ⁢ 
                       j 
                     
                   
                 
                 
                   e 
                   ⁢ 
                   
                     ∝ 
                     
                       2 
                       ⁢ 
                       j 
                     
                   
                 
               
               = 
               
                 
                   
                     S 
                     1 
                     2 
                   
                   
                     S 
                     2 
                   
                 
                 = 
                 
                   
                     S 
                     n 
                     2 
                   
                   
                     S 
                     
                       2 
                       ⁢ 
                       n 
                     
                   
                 
               
             
           
         
       
       
         
           
             
               α 
               j 
             
             = 
             
               
                 
                   e 
                   ⁢ 
                   
                     ∝ 
                     
                       3 
                       ⁢ 
                       j 
                     
                   
                 
                 
                   e 
                   ⁢ 
                   
                     ∝ 
                     
                       2 
                       ⁢ 
                       j 
                     
                   
                 
               
               = 
               
                 
                   
                     S 
                     3 
                   
                   
                     S 
                     2 
                   
                 
                 = 
                 
                   
                     S 
                     
                       n 
                       + 
                       1 
                     
                   
                   
                     S 
                     n 
                   
                 
               
             
           
         
       
       
         
           
             j 
             = 
             
               log 
               ⁢ 
               
                 
                   S 
                   
                     n 
                     + 
                     1 
                   
                 
                 
                   S 
                   n 
                 
               
             
           
         
       
     
     According to some examples, decoder  114  may include logic and/or features to implement single error correction for RS codes. The logic and/or features may include approximately 2t multipliers and 2t comparators or at least 2t−1 multipliers and 2t−1 comparators to multiply partial syndromes to check if the partial syndromes form a geometric series. The logic and/or features may also be capable of a constant squaring, a Galois Field inversion, and have two multipliers to calculate e and j. 
       FIG. 3  illustrates an example error correction code (ECC) system  300 . In some examples, as shown in  FIG. 3 , ECC system  300  includes ECC encoder  112 , memory  120  and ECC decoder  114 . Also, ECC decoder  114  is shown as including an error detector/syndrome calculator  305 , error identification unit  315 , a corrector unit  325  and a codeword buffer  335 . 
     In some examples, data (possibly encrypted/compressed) may be encoded by ECC encoder  112  using an ECC code that may include binary BCH codes or RS codes. The resultant codeword may then be stored to memory  120 . According to some examples, the stored codeword may be read from memory  120  and may include possible errors. As shown in  FIG. 3 , the codeword with possible errors may be forwarded to codeword buffer  335 . Codeword buffer  335  may be configured to at least temporarily store the codeword while other elements of ECC decoder  114  identify a location and/or a value for each error possibly included in the codeword. 
     According to some examples, error detector/syndrome calculator  305  may be configured to determine if the codeword includes any errors. For these examples, if no errors are detected, ECC decoder  114  may include logic and/or features to indicate to corrector unit  325  or codeword buffer  335  to forward the codeword being stored at codeword buffer  335 . However, if errors are detected, error detector/syndrome calculator  305  may calculate partial syndromes for the ECC encoded data and forward the calculated partial syndromes to error identification unit  315 . Error locations and/or values may then be identified by error identification module  315 . As described more below, the error locations and/or values may be identified using either single error circuitry or multiple error circuitry. 
     In some examples, as shown in  FIG. 3 , error locations and/or values may be provided to corrector unit  325  from error identification circuitry  315 . For these examples, corrector unit  325  may be configured to correct identified errors based on the error locations and/or values. Corrector unit  325  may also be configured to decode the codeword and then forward the data for possible decompression/decryption and eventual delivery to the source of the read request. 
       FIG. 4  illustrates an example single error system. In some examples, as shown in  FIG. 4 , single error system  400  includes error detector/syndrome calculator  305  to provide partial syndromes to single error circuitry  410 . For these examples, single error circuitry  410  may be part of error identification unit  315  mentioned above for  FIG. 3 . 
     According to some examples, as shown in  FIG. 4 , single error circuitry  410  includes a syndrome multiplier  412 , a product comparator  414 , a logarithm unit  415 , an inversion calculator  416  and a syndrome multiplier  418 . In some examples, if the ECC used to encode ECC encoded data included binary BCH codes, syndrome multiplier  412 , product comparator  414  and logarithm unit  415  may be used to determine whether the ECC encoded data includes a single error and to locate the single error based on this determination. For these examples, if the ECC used attempted to protect from t errors, then syndrome multiplier  412  may be arranged to perform (t−1) Galois field constant power functions as mentioned above for example equation (7). Product comparator  414  may be arranged to have (t−1) m-bit comparators as also mentioned above for example equation (7). Also logarithm unit  415  may be arranged to determine the single error location based on partial syndromes received from error detector/syndrome calculator  305  and the implementation of example equation (2) to solve for j. 
     In some examples, if the ECC used to encode ECC encoded data included BCH codes, syndrome multiplier  412 , product comparator  414 , logarithm unit  415 , inversion calculator  416  and syndrome multiplier  418  may be used to determine whether the ECC encoded data includes a single error, locate the single error and identify a value for the single error based on this determination. For these examples, if the ECC used attempted to protect from t errors, then syndrome multiplier  412  may be arranged to include t multipliers and product comparator  414  may be arranged to include at least t comparators as mentioned above for example equation (14). Also, inversion calculator  416  may be arranged to perform Galois field inversions according to example equation (14) and syndrome multiplier  418  may include at least two multipliers to calculate a value for j to determine the location of the single error. According to some examples, operations carried out at syndrome multiplier  412 /product comparator  414  and logarithm unit  415 /inversion calculator  416 /syndrome multiplier  418  may occur in parallel and thus may be implemented by combinational circuitry. 
     In some examples, if the ECC used to encode ECC encoded data included RS codes, syndrome multiplier  412 , product comparator  414 , inversion calculator  416  and syndrome multiplier  418  may be used to determine whether the ECC encoded data includes a single error, locate the single error and identify a value for the single error based on this determination. For these examples, if the ECC used attempted to protect from t errors, then syndrome multiplier  412  may be arranged to include 2t multipliers and product comparator  414  may be arranged to include at least 2t comparators as mentioned above for example equation (14). Also, inversion calculator  416  may be arranged to perform Galois field inversions according to example equation (14) and syndrome multiplier  418  may include at least two multipliers to calculate values for e and j to determine the value and location of the single error. According to some examples, operations carried out at syndrome multiplier  412 /product comparator  414  and logarithm unit  415 /inversion calculator  416 /syndrome multiplier  418  may occur in parallel and thus may be implemented by combinational circuitry. 
     According to some examples, if more than one error is identified, single error circuitry  410  may be configured or arranged to generate a multiple error flag. As described more below, responsive to the multiple error flag, multiple error circuitry may be configured to locate and/or identify values for the full number of t possible errors protected by the particular ECC used. 
       FIG. 5  illustrates an example single/multiple error system  500 . In some examples, as shown in  FIG. 5 , single/multiple error system  500  includes error detector/syndrome calculator  305 , error identification unit  315 , multiple error circuitry  510 , multiplexer (MUX)  520  and corrector unit  335 . For these examples, multiple error circuitry  510  is shown in  FIG. 5  as including a Berlekamp-Massey algorithm (BMA) unit  516 , a Chien Search unit  518  and an error evaluator  519 . 
     According to some examples, error detector/syndrome calculator  305  may detect that one or more errors may be included in ECC encoded data and generate partial syndromes that indicate the one or more errors. For these examples, single error circuitry  410  may quickly determine if the partial syndromes indicate a single error and identify error locations and/or values for the single error. MUX  520  may be arranged, to allow information from single error circuitry  410  to pass to corrector unit  335  by default, e.g., selector bit not asserted on MUX  520 . However, if multiple errors are found in the ECC encoded data, single error circuitry  410  may generate a multiple error flag that may result in MUX  520  blocking any signals inputted to MUX  520  from single error circuitry  410 . Error identification unit  315  may then activate multiple error circuitry  510 . 
     In some examples, the ECC encoded data may have been protected using a binary BCH code capable of protecting the encoded data from t errors. For these examples, BMA unit  516  and Chien Search unit  518  may be arranged to identify separate locations of errors included in the ECC encoded data up to at least the t errors. Since the multiple error flag was generated, MUX  520  may be arranged to permit multiple error circuitry  510  to pass/forward information indicating the identified error locations to corrector unit  335 . 
     In some examples, the ECC encoded data may have been protected using a RS code capable of protecting the encoded data from t errors. For these examples, BMA unit  516 , Chien Search unit  518  and error evaluator  519  may be arranged to identify separate locations and values of errors included in the ECC encoded data up to at least t errors. As mentioned above, MUX  520  may be arranged to permit multiple error circuitry  510  to pass/forward information indicating the identified error locations and values to corrector unit  335 . 
     In some examples, other algorithms are schemes may be used to identify error locations and/or values in ECC encoded data. These other algorithms may include, but are not limited to, a Peterson-Goresntein-Zierler algorithm or a Euclidean algorithm. 
       FIG. 6  illustrates an example apparatus  600 . Although the apparatus  600  shown in  FIG. 6  has a limited number of elements in a certain topology, it may be appreciated that the apparatus  600  may include more or less elements in alternate topologies as desired for a given implementation. 
     The apparatus  600  may comprise a computer-implemented apparatus that may include at least some of the logic and/or features mentioned above for an ECC decoder  114  as mentioned above for  FIGS. 1-5 . The computer-implemented apparatus  600  may be arranged to execute one or more software components  622 - a . It is worthy to note that “a” and “b” and “c” and similar designators as used herein are intended to be variables representing any positive integer. Thus, for example, if an implementation sets a value for a=5, then a complete set of software components  622 - a  may include modules  622 - 1 ,  622 - 2 ,  622 - 3 ,  622 - 4  or  622 - 5 . The embodiments are not limited in this context. 
     According to some examples, apparatus  600  may be capable of being located with a controller or ECC decoder for a memory system, e.g., as part of a memory system such as memory system  100 . For these examples, apparatus  600  may be included in or implemented by a processor, processor circuitry, microcontroller circuitry or an application-specific integrated circuit (ASIC). In other examples, apparatus  600  may be implemented as part of firmware (e.g., BIOS), or implemented as a middleware application. The examples are not limited in this context. 
     In some examples, if implemented in a processor, the processor may be generally arranged to execute one or more software components  622 - a . The processor can be any of various commercially available processors, including without limitation an AMD® Athlon®, Duron® and Opteron® processors; ARM® application, embedded and secure processors; IBM® and Motorola® DragonBall® and PowerPC® processors; IBM and Sony® Cell processors; Intel® Celeron®, Core (2) Duo®, Core i3, Core i5, Core i7, Pentium®, and XScale® processors; and similar processors. Multi-core processors and other multi-processor architectures may also be employed to implement apparatus  600 . 
     According to some examples, apparatus  600  may include an error checking component  622 - 1 . Error checking component  622 - 1  may be arranged for execution by processor circuit  620  to determine that ECC encoded data received via codeword  610  may have one or more errors. For these examples, error checking component  622 - 1  may calculate partial syndromes that may result in non-zero values indicating errors in the ECC encoded data. These partial syndromes may at least be temporarily maintained by error checking component  622 - 1  (e.g., stored in a data structure such as a register). In some examples, the partial syndromes may be based on codes for error correction such as binary BCH codes or RS codes. 
     In some examples, apparatus  600  may also include a single error component  622 - 2 . Single error component  622 - 2  may be arranged for execution by processor circuit  620  to receive ECC information for ECC encoded data indicating one or more errors in the ECC encoded data (e.g., included in partial syndromes). Single error component  622 - 2  may also be arranged to determine whether the ECC encoded data includes a single error, identify a location and/or value of the single error if the ECC encoded data was determined to have the single error. If the ECC information indicated multiple errors, single error component  622 - 2  may be arranged to generate a flag to indicate the multiple errors. 
     According to some examples, single error component  622 - 2  may at least temporarily maintain syndrome multiplications/comparisons  626 - b  and error evaluation  626 - c  (e.g., in a data structure such as a register). For these examples, if the ECC used to encode the ECC encoded data was a binary BCH code, multiplications/comparisons  626 - b  may include error location information for the single error. If the ECC used to encode the ECC encoded data was a RS code, error evaluation  626 - c  may include both error location and error value information for the single error. 
     In some examples, apparatus  600  may also include a multiple error component  622 - 3 . Multiple error component  622 - 3  may be arranged for execution by processor circuit  620  to receive ECC information for ECC encoded data indicating multiple errors. Multiple error component  622 - 3  may be arranged to separately identify an error location and/or value for each error up to at least t. 
     According to some examples, multiple error component  622 - 3  may at least temporarily maintain BMA results  626 - d , Chien Search results  626 - e  and error evaluations  626 - f , e.g., in a data structure such as a register. For these examples, if the ECC used to encode the ECC encoded data was an RS code or a binary BCH code, both BMA results  626 - d  and Chien Search results  626 - e  may be used by multiple error component  622 - 3  to identify separate error locations. If the ECC used was RS code, then error evaluations  626 - f  may include error values associated with the separately identified error locations. 
     Apparatus  600  may also include a buffer component  622 - 4 . Buffer component  622 - 4  may be arranged for execution by processor circuit  620  to maintain a memory capable of temporarily storing the ECC encoded data received in codeword  610 . 
     According to some examples, apparatus  600  may also include a corrector component  622 - 5 . Corrector component  622 - 5  may be arranged for execution by processor circuit  620  to receive either the identified location for a single error from single error component  622 - 2  or the separately identified error locations for the multiple errors identified by multiple error component  622 - 3 . Corrector component  622 - 5  may also be arranged to obtain the ECC encoded data from the memory maintained by buffer component  622 - 4  and then correct the ECC encoded data included in codeword  610 . The corrected ECC encoded data may then be decoded. 
     Included herein is a set of logic flows representative of example methodologies for performing novel aspects of the disclosed architecture. While, for purposes of simplicity of explanation, the one or more methodologies shown herein are shown and described as a series of acts, those skilled in the art will understand and appreciate that the methodologies are not limited by the order of acts. Some acts may, in accordance therewith, occur in a different order and/or concurrently with other acts from that shown and described herein. For example, those skilled in the art will understand and appreciate that a methodology could alternatively be represented as a series of interrelated states or events, such as in a state diagram. Moreover, not all acts illustrated in a methodology may be required for a novel implementation. 
     A logic flow may be implemented in software, firmware, and/or hardware. In software and firmware embodiments, a logic flow may be implemented by computer executable instructions stored on at least one non-transitory computer readable medium or machine readable medium, such as an optical, magnetic or semiconductor storage. The embodiments are not limited in this context. 
       FIG. 7  illustrates a logic flow  700 . Logic flow  700  may be representative of some or all of the operations executed by one or more logic, features, or devices described herein, such as apparatus  600 . More particularly, logic flow  700  may be implemented by error checking component  622 - 1 , single error component  622 - 2 , multiple error component  622 - 3 , buffer component  622 - 4  or corrector component  622 - 5 . 
     According to some examples, logic flow  700  may receive ECC information for ECC encoded data indicating one or more errors in the ECC encoded data at block  702 . For these examples, single error component  622 - 2  may receive the ECC information as partial syndromes having at least some non-zero values that indicate one or more errors in the ECC encoded data. 
     In some examples, logic flow  700  may determine whether the encoded data includes a single error at block  704 . 
     According to some examples, based on the determination of whether the ECC encoded data includes a single error, logic flow  700  may identify an error location for the single error in the ECC encoded data or generate a flag to indicate the ECC encoded data has more than one error at block  706 . If a single error was determined, logic flow may correct the single error based on the identified error location and decode the ECC encoded data at block  708 . 
     In some examples, logic flow  700  may identify separate error locations for the more than one error in the ECC encoded data responsive to the generated flag at block  710 . For these examples, single error component  622 - 2  may have generated a multiple error flag to indicate the more than one error. Also, identification of the separate error locations may include use of BMA information  626 - d  and Chien Search information  626 - e  maintained at multiple error component  622 - 3 . 
     According to some examples, logic flow  700  may the correct the more than one error based on the separately identified error locations and decode the ECC encoded data at block  712 . For these examples, corrector component  622 - 5  may receive the separately identified error locations and correct the ECC encoded data that may have been temporarily stored at a memory maintained by buffer component  622 - 4 . The corrected ECC encoded data may then be decoded by corrector component  622 - 5 . 
       FIG. 8  illustrates an embodiment of a storage medium  800 . The storage medium  800  may comprise an article of manufacture. In some examples, storage medium  800  may include any non-transitory computer readable medium or machine readable medium, such as an optical, magnetic or semiconductor storage. Storage medium  800  may store various types of computer executable instructions, such as instructions to implement logic flow  700 . Examples of a computer readable or machine readable storage medium may include any tangible media capable of storing electronic data, including volatile memory or non-volatile memory, removable or non-removable memory, erasable or non-erasable memory, writeable or re-writeable memory, and so forth. Examples of computer executable instructions may include any suitable type of code, such as source code, compiled code, interpreted code, executable code, static code, dynamic code, object-oriented code, visual code, and the like. The examples are not limited in this context. 
       FIG. 9  illustrates an example computing platform  900 . In some examples, as shown in  FIG. 9 , computing platform  900  may include a memory system  930 , a processing component  940 , other platform components  950  or a communications interface  960 . According to some examples, computing platform  900  may be implemented in a computing device. 
     According to some examples, memory system  930  may be similar to memory system  100 . For these examples, logic and/or features (e.g., included in an ECC decoder/controller) resident at or located with memory system  930  may execute at least some processing operations or logic for apparatus  600 . Also, memory system  930  may include volatile or non-volatile types of memory (not shown) that may store ECC encoded data written to or read from in a similar manner as described above for memory  120  included in memory system  100 . 
     According to some examples, processing component  940  may also execute at least some processing operations or logic for apparatus  600  and/or storage medium  800 . Processing component  940  may include various hardware elements, software elements, or a combination of both. Examples of hardware elements may include devices, logic devices, components, processors, microprocessors, circuits, processor circuits, circuit elements (e.g., transistors, resistors, capacitors, inductors, and so forth), integrated circuits, application specific integrated circuits (ASIC), programmable logic devices (PLD), digital signal processors (DSP), field programmable gate array (FPGA), memory units, logic gates, registers, semiconductor device, chips, microchips, chip sets, and so forth. Examples of software elements may include software components, programs, applications, computer programs, application programs, system programs, software development programs, machine programs, operating system software, middleware, firmware, software modules, routines, subroutines, functions, methods, procedures, software interfaces, application program interfaces (API), instruction sets, computing code, computer code, code segments, computer code segments, words, values, symbols, or any combination thereof. Determining whether an example is implemented using hardware elements and/or software elements may vary in accordance with any number of factors, such as desired computational rate, power levels, heat tolerances, processing cycle budget, input data rates, output data rates, memory resources, data bus speeds and other design or performance constraints, as desired for a given example. 
     In some examples, other platform components  950  may include common computing elements, such as one or more processors, multi-core processors, co-processors, memory units, chipsets, controllers, peripherals, interfaces, oscillators, timing devices, video cards, audio cards, multimedia input/output (I/O) components (e.g., digital displays), power supplies, and so forth. Examples of memory units associated with either other platform components  950  or memory system  930  may include without limitation, various types of computer readable and machine readable storage media in the form of one or more higher speed memory units, such as read-only memory (ROM), RAM, DRAM, Double-Data-Rate DRAM (DDRAM), synchronous DRAM (SDRAM), SRAM, programmable ROM (PROM), erasable programmable ROM (EPROM), electrically erasable programmable ROM (EEPROM), flash memory, nanowires, ferroelectric transistor random access memory (FeTRAM or FeRAM), polymer memory such as ferroelectric polymer memory, ovonic memory, phase change or ferroelectric memory, silicon-oxide-nitride-oxide-silicon (SONOS) memory, magnetic or optical cards, an array of devices such as Redundant Array of Independent Disks (RAID) drives, solid state memory devices (e.g., USB memory), solid state drives (SSD) and any other type of storage media suitable for storing information. 
     In some examples, communications interface  960  may include logic and/or features to support a communication interface. For these examples, communications interface  960  may include one or more communication interfaces that operate according to various communication protocols or standards to communicate over direct or network communication links. Direct communications may occur via use of communication protocols or standards described in one or more industry standards (including progenies and variants) such as those associated with the System Management Bus (SMBus) specification, the PCI Express specification, the Serial Advanced Technology Attachment (SATA) specification, Serial Attached SCSI (SAS) or the Universal Serial Bus (USB) specification. Network communications may occur via use of communication protocols or standards such those described in the Ethernet standard. 
     Computing platform  900  may be part of a computing device that may be, for example, user equipment, a computer, a personal computer (PC), a desktop computer, a laptop computer, a notebook computer, a netbook computer, a tablet, a smart phone, embedded electronics, a gaming console, a server, a server array or server farm, a web server, a network server, an Internet server, a work station, a mini-computer, a main frame computer, a supercomputer, a network appliance, a web appliance, a distributed computing system, multiprocessor systems, processor-based systems, or combination thereof. Accordingly, functions and/or specific configurations of computing platform  900  described herein, may be included or omitted in various embodiments of computing platform  900 , as suitably desired. 
     The components and features of computing platform  900  may be implemented using any combination of discrete circuitry, application specific integrated circuits (ASICs), logic gates and/or single chip architectures. Further, the features of computing platform  900  may be implemented using microcontrollers, programmable logic arrays and/or microprocessors or any combination of the foregoing where suitably appropriate. It is noted that hardware, firmware and/or software elements may be collectively or individually referred to herein as “logic” or “circuit.” 
     It should be appreciated that the exemplary computing platform  900  shown in the block diagram of  FIG. 9  may represent one functionally descriptive example of many potential implementations. Accordingly, division, omission or inclusion of block functions depicted in the accompanying figures does not infer that the hardware components, circuits, software and/or elements for implementing these functions would necessarily be divided, omitted, or included in embodiments. 
     One or more aspects of at least one example may be implemented by representative instructions stored on at least one machine-readable medium which represents various logic within the processor, which when read by a machine, computing device or system causes the machine, computing device or system to fabricate logic to perform the techniques described herein. Such representations, known as “IP cores” may be stored on a tangible, machine readable medium and supplied to various customers or manufacturing facilities to load into the fabrication machines that actually make the logic or processor. 
     Various examples may be implemented using hardware elements, software elements, or a combination of both. In some examples, hardware elements may include devices, components, processors, microprocessors, circuits, circuit elements (e.g., transistors, resistors, capacitors, inductors, and so forth), integrated circuits, application specific integrated circuits (ASIC), programmable logic devices (PLD), digital signal processors (DSP), field programmable gate array (FPGA), memory units, logic gates, registers, semiconductor device, chips, microchips, chip sets, and so forth. In some examples, software elements may include software components, programs, applications, computer programs, application programs, system programs, machine programs, operating system software, middleware, firmware, software modules, routines, subroutines, functions, methods, procedures, software interfaces, application program interfaces (API), instruction sets, computing code, computer code, code segments, computer code segments, words, values, symbols, or any combination thereof. Determining whether an example is implemented using hardware elements and/or software elements may vary in accordance with any number of factors, such as desired computational rate, power levels, heat tolerances, processing cycle budget, input data rates, output data rates, memory resources, data bus speeds and other design or performance constraints, as desired for a given implementation. 
     Some examples may include an article of manufacture or at least one computer-readable medium. A computer-readable medium may include a non-transitory storage medium to store logic. In some examples, the non-transitory storage medium may include one or more types of computer-readable storage media capable of storing electronic data, including volatile memory or non-volatile memory, removable or non-removable memory, erasable or non-erasable memory, writeable or re-writeable memory, and so forth. In some examples, the logic may include various software elements, such as software components, programs, applications, computer programs, application programs, system programs, machine programs, operating system software, middleware, firmware, software modules, routines, subroutines, functions, methods, procedures, software interfaces, API, instruction sets, computing code, computer code, code segments, computer code segments, words, values, symbols, or any combination thereof. 
     According to some examples, a computer-readable medium may include a non-transitory storage medium to store or maintain instructions that when executed by a machine, computing device or system, cause the machine, computing device or system to perform methods and/or operations in accordance with the described examples. The instructions may include any suitable type of code, such as source code, compiled code, interpreted code, executable code, static code, dynamic code, and the like. The instructions may be implemented according to a predefined computer language, manner or syntax, for instructing a machine, computing device or system to perform a certain function. The instructions may be implemented using any suitable high-level, low-level, object-oriented, visual, compiled and/or interpreted programming language. 
     Some examples may be described using the expression “in one example” or “an example” along with their derivatives. These terms mean that a particular feature, structure, or characteristic described in connection with the example is included in at least one example. The appearances of the phrase “in one example” in various places in the specification are not necessarily all referring to the same example. 
     Some examples may be described using the expression “coupled” and “connected” along with their derivatives. These terms are not necessarily intended as synonyms for each other. For example, descriptions using the terms “connected” and/or “coupled” may indicate that two or more elements are in direct physical or electrical contact with each other. The term “coupled,” however, may also mean that two or more elements are not in direct contact with each other, but yet still co-operate or interact with each other. 
     In some examples, example methods may include receiving, at a processor circuit, ECC information for ECC encoded data indicating one or more errors in the ECC encoded data. A determination as to whether the ECC encoded data includes a single error may be made. Based on the determination, an error location for the single error in the ECC encoded data may be identified or a flag to indicate the ECC encoded data has more than one error may be generated. 
     According to some examples for the example methods, the single error may be corrected based on the identified error location and the ECC encoded data may then be decoded. 
     In some examples for the example methods, the ECC may include one of a RS code or a binary BCH code. 
     According to some examples for the example methods, identifying an error value associated with the identified error location may be based on the ECC including the RS code. 
     In some examples for the example methods, determining that the ECC encoded data has the one or more errors may be based on a syndrome check associated with one of the RS code or the binary BCH code. 
     According to some examples for the example methods, identifying separate error locations for the more than one error included in the ECC encoded data responsive to the generated flag may include correcting the more than one error based on the separately identified error locations and then decoding the ECC encoded data. For these examples, the ECC may include one of a RS code a binary BCH code. Also, if RS code, identifying an error value associated with the identified error location. Also, for these examples, determining that the ECC encoded data has the one or more errors may be based on a syndrome check associated with one of the RS code or the binary BCH code. 
     In some examples for the example methods, identifying separate error locations for the more than one error included in the ECC encoded data responsive to the generated flag may include correcting the more than one error based on the separately identified error locations and decoding the ECC encoded data. For these examples, the ECC may include one or a RS code or a binary BCH code. Also, the separate error locations for the more than one error may include implementing a BMA and a Chien Search to separately identify error values and locations. Also, for these examples, identifying an error value associated with a given identified error location may be based on the ECC including the RS code. 
     According to some examples for the example methods, identifying the error value and the given identified error location for the single error may be based on implementing an algorithm that includes 
             e   =       S   n   2       S     2   ⁢   n                   and               j   =     log   ⁢       S     n   +   1         S   n           ,         
where e is the error value, j is the given identified error location, S represents partial syndromes included in the received ECC information and n represents any positive integer.
 
     In some examples for the example methods, the ECC encoded data encoded may be encoded using the binary BCH code. Identifying the error location for the single error may be based on implementing an algorithm that includes j=log S 1 , where j is the given identified error location and S represents partial syndromes included in the received ECC information. 
     In some examples for the example methods, the ECC encoded data may be associated with one of storage to a memory device, storage to a storage medium, wireless communications or 2-dimensional bar code readers. 
     According to some examples for the example methods, the memory device may include non-volatile memory such as PCM, PCMS, flash memory, ferroelectric memory, SONOS memory, polymer memory, nanowire, FeTRAM, FeRAM, or EEPROM. 
     According to some examples, at least one machine readable medium comprising a plurality of instructions that in response to being executed on a system cause the system to carry out the example method as mentioned above. 
     According to some examples, an example apparatus may include a processor circuit a single error component arranged for execution by the processor circuit to receive ECC information for ECC encoded data indicating one or more errors in the ECC encoded data. The single error component may also be arranged to determine whether the encoded data includes a single error, identify a location of the error in the ECC encoded data when the encoded data was determined to have the single error or generate a flag to indicate the ECC encoded data has multiple errors. The example apparatus may also include a multiple error component arranged for execution by the processor circuit to receive the ECC information for the ECC encoded data indicating one or more errors and separately identify an error location for each error. The example apparatus may also include a corrector component arranged for execution by the processor circuit to receive either the identified location for the single error or the separately identified error locations for the multiple errors and correct the one or more errors in the ECC encoded data. 
     In some examples, the example apparatus may also include a buffer component arranged for execution by the processor circuit to maintain a memory capable of temporarily storing the ECC encoded data for correction by the corrector component. 
     In some examples, the example apparatus may also include an error checking component arranged for execution by the processor circuit to determine that the ECC encoded data has the one or more errors and generate the ECC information to indicate the one or more errors in the ECC encoded data. 
     According to some examples for the example apparatus, the ECC may include one of a RS code or a binary BCH code. 
     In some examples for the example apparatus, the multiple error component capable of implementing a BMA and Chien Search to separately identify error locations. 
     According to some examples for the example apparatus, the single error component and the multiple error component configured to identify an error value associated with a given identified error location based on the ECC encoded data encoded using the RS code. 
     In some examples for the example apparatus, the single error component may be configured to identify the error value and the given identified error location for the single error based on implementing an algorithm that includes 
             e   =       S   n   2       S     2   ⁢   n                   and               j   =     log   ⁢       S     n   +   1         S   n           ,         
where e is the error value, j is the given identified error location, S represents partial syndromes included in the received ECC information and n represents any positive integer.
 
     According to some examples for the example apparatus, the ECC encoded data may be encoded using the binary BCH code. For these examples, the single error component may be configured to identify the location of the error in the ECC encoded data based on implementing an algorithm that includes j=log S 1 , where j is the given identified error location and S represents partial syndromes included in the received ECC information. 
     In some examples for the example apparatus, the ECC encoded data associated with one of storage to a memory device, storage to a storage medium, wireless communications or 2-dimensional bar code readers. 
     According to some examples for the example apparatus, the memory device to include non-volatile memory comprising PCM, PCMS, flash memory, ferroelectric memory, SONOS memory, polymer memory, nanowire, FeTRAM, FeRAM, or EEPROM. 
     In some examples for the example apparatus, the memory device may be a two level memory (2LM) system for a computing device. For these examples the 2LM system may also include volatile memory. 
     It is emphasized that the Abstract of the Disclosure is provided to comply with 37 C.F.R. Section 1.72(b), requiring an abstract that will allow the reader to quickly ascertain the nature of the technical disclosure. It is submitted with the understanding that it will not be used to interpret or limit the scope or meaning of the claims. In addition, in the foregoing Detailed Description, it can be seen that various features are grouped together in a single example for the purpose of streamlining the disclosure. This method of disclosure is not to be interpreted as reflecting an intention that the claimed examples require more features than are expressly recited in each claim. Rather, as the following claims reflect, inventive subject matter lies in less than all features of a single disclosed example. Thus the following claims are hereby incorporated into the Detailed Description, with each claim standing on its own as a separate example. In the appended claims, the terms “including” and “in which” are used as the plain-English equivalents of the respective terms “comprising” and “wherein,” respectively. Moreover, the terms “first,” “second,” “third,” and so forth, are used merely as labels, and are not intended to impose numerical requirements on their objects. 
     Although the subject matter has been described in language specific to structural features and/or methodological acts, it is to be understood that the subject matter defined in the appended claims is not necessarily limited to the specific features or acts described above. Rather, the specific features and acts described above are disclosed as example forms of implementing the claims.