Patent Description:
Solid state flash memory devices, such as NAND memory devices, store data as charges in semiconductor floating gate transistors. Charges are stored on individual semiconductor cells by applying a programming voltage to these cells. Different charge levels are assigned to different bit values or bit value combinations. In a Single Level Cell (SLC) - which stores only one bit per cell - a first charge level represents a '<NUM>' and a second charge level may represent a '<NUM>'. In a multi-level cell (MLC), two bits may be stored by use of four different charge levels. In a triple level cell (TLC), three bits may be stored by using eight charge levels, and so on.

<CIT> discloses reading data using a reliability measure in which a reliability measure is computed for at least one bit stored in the target memory cell of a memory array based on a voltage value associated with the target memory cell and based on one or more corresponding voltage values associated with each of the one or more other memory cells of the memory array.

<CIT> discloses a semiconductor memory device in which data is rearranged by various operations such as a modulation code operation and the data is processed according to an ECC operation to reduce the interference between memory cells.

While magnetic and solid-state storage technologies have much different structures and methods of operation, they both rely upon the encoding of data as electrons or magnetic charge to represent the <NUM>'s and <NUM>'s of data. Both electrons stored in a semiconductor and magnetic charge stored on a magnetic medium are subject to interference. For example, a magnetic hard drive has a plurality of circular tracks that each have a plurality of sectors. To meet the demand for increased storage, hard drives have increased the density of the tracks, sectors, and the like. By reducing the size of the magnetic grains that store the magnetic charge the hard drive can store more data. As the charges becomes closer and closer together, the magnetic charge becomes more susceptible to spontaneous switching of its state of magnetization. This susceptibility increases with increases in temperature. In some examples, to solve this problem, some hard drives store their charge perpendicularly - that is, the magnetic grains are perpendicularly oriented to the plane of the media. In these devices, problems still exist where a long run length of a same value can cause a demagnetization field that causes a self-demagnetization force that tries to switch back a magnetization state of the grains within the region. These problems may affect multiple neighboring sectors.

Similarly, for solid state devices, the structure of NAND devices into word lines, pages, and blocks creates certain challenges. In NAND flash, memory cells are organized into two dimensional arrays called blocks. In each block, cells in a same row share a wordline and cells in a same column share a bitline. A page is the smallest data unit that may be programmed and read and is made up of cells connected on a same wordline. To write data to a NAND cell, a programming voltage is applied to the cell and this voltage increases the charge level to the desired range that represents the value being stored. This programming voltage may cause cell-to-cell program interference to adjacent memory cells that are not being programmed because charge from this programming voltage increases the charge level in those neighboring cells due to the interconnections of the cells. This effect is called program-disturb. If the cumulative effect of many programming voltages being applied to neighboring cells increases the charge level enough, it may change the value stored in the cell. For MLC, TLC and other cells, each cell is programmed using multiple steps to reduce the impact of this interference. Despite the use of multiple steps, programming interference is still an issue in modern NAND devices.

To read a page of NAND flash, a read voltage is applied to the wordline that contains the data to be read and sense amplifiers connected to the bitlines determine the value in the cell. To read MLC and TLC cells, multiple read voltages of different threshold voltage levels may be applied. A passthrough voltage is applied to cells of other wordlines connected to the same bitlines that are being read. The passthrough voltage is not as high as the programming voltage, but still induces a weak programming effect on those cells. This is called read-disturb. As with the program disturb, enough cumulative read-disturb incidents may cause a change in the value of a cell.

Both storage device types rely upon a number of mechanisms to deal with the errors mentioned above. For example, some NAND devices track the number of reads and writes that impact a cell as a read-disturb counter and a program-disturb counter. Each time a neighboring cell is read, the read-disturb counter for that cell is incremented. Similarly, each time a neighboring cell is programmed, the program-disturb counter may be incremented. Various actions may be taken when the read and/or program-disturb counter exceeds a threshold to ensure that the data is not compromised. For example, the data may be read and rewritten in a different cell.

Both flash memory and magnetic storage typically also use error correction codes (ECC) to detect, and correct errors caused by the mechanisms described above and other errors. Error correction codes may detect and correct a defined number of errors for a particular number of bits stored in the memory devices. The ECC is applied to the data prior to it being written to the storage medium and one or more ECC values may also be stored on the storage medium. If the errors caused by the mechanisms noted above are too numerous, they may exceed the ability of the ECC to correct the errors and the data may be irretrievably lost. For example, if the read-disturb errors change too many bits, the ECC may not be able to detect and/or correct the errors. Example ECC algorithms include block codes (e.g., Hamming codes), cyclic codes, BCH (Bose-Chaudhri-Hocquenghem) codes, Reed-Solomon codes, Convolutional codes (including Viterbi codes), and the like. ECC algorithms may include Forward Error Correction (FEC). While ECC algorithms are traditionally used to correct errors after they occur, they have not been used to actively prevent errors.

Disclosed in some examples are methods, systems, storage devices, and machine readable mediums that utilize the ability of ECC to correct errors to actively prevent errors. The memory device determines whether a request to place data of a requested value at a requested location in the storage media is likely to interfere with other data stored at other locations on the storage media, and if so, changes the requested value to a second value that will not interfere (or has a lower probability of interfering) with neighboring data. The second value may be corrected to the requested value when a read request is made for that data using ECC. That is, the ECC information may be generated on the requested value and the second value (which is actually stored) may be later corrected to the requested value using the ECC information. The second value may be chosen to be less destructive and/or interfering to neighboring data while at the same time, being close enough to the requested value to be correctable by the ECC. While intentionally introducing an error to reduce errors may seem counterintuitive, introducing a single correctable error to reduce the probability of multiple errors or one or more uncorrectable errors may reduce an overall error rate. As used herein, a data storage unit is a storage location on a physical media for a single unit of data. For example, a sector on a magnetic media, or a page on flash memory, or the like. While the techniques described herein are described as applying to a unit of data, it will be appreciated by one of ordinary skill that the techniques may be applied to smaller units of storage, such as a single NAND cell, or a location where a single bit is stored on magnetic media.

Turning now to <FIG> a data storage device <NUM> is shown according to some examples of the present disclosure. Data storage device <NUM> may be a magnetic memory storage device, a FLASH memory storage device (including a NAND or NOR storage device), or some combination. Data storage device <NUM> may comprise a storage controller <NUM> and storage media <NUM>. Storage controller <NUM> may perform one or more management actions to manage the storage media <NUM>. For example, address translation that translates an address (e.g., a logical address) given in a read or write command from a host <NUM> to a physical address on the storage media <NUM>. For example, the storage controller <NUM> may include a flash translation layer that maps logical addresses to physical cells on the storage media <NUM>. Storage controller <NUM> may also handle tasks such as garbage collection, wear levelling, encryption, defragmentation, and other tasks. Storage media <NUM> may include the physical storage media, such as NAND cells, NOR cells, magnetic media, and the like.

In addition to the functions described above, storage controller <NUM> may perform one or more additional operations, including changing a value to be written to the storage media <NUM> if storage of the proposed value at the proposed location has a probability greater than a threshold of damaging other data on the storage media. As used herein, proposed value and proposed location is the value and location specified by the host (e.g., the operating system or other application) in a write request issued to the data storage device <NUM>. For example, the storage controller <NUM> may include a host command control <NUM> which may receive commands from a host <NUM> - e.g., across a host interface (e.g., a Peripheral Component Interconnect Express - PCIE). Host <NUM> may send commands such as read, write, erase, and other commands to the storage controller <NUM> to perform operations on storage media <NUM>. Host command control <NUM> may perform those commands and return a result to the host <NUM>. For example, host <NUM> may send a write command with a proposed data value and a proposed address. Upon receiving the write command, host command control <NUM> may translate the proposed address to a physical address on the storage media <NUM>. The host command control <NUM> may apply an ECC operation to the proposed data value by sending the data to ECC component <NUM>. While <FIG> shows ECC component <NUM> as part of the storage controller <NUM>, in other examples, ECC component <NUM> may be a separate processor. ECC component <NUM> may return the data to the host command control <NUM> along with any ECC information needed.

The host command control <NUM> may pass the returned ECC encoded proposed data value along with the physical address of the proposed location to a disturbance checker component <NUM>. Disturbance checker component <NUM> may check to determine whether storage of the ECC encoded proposed value at the proposed location will cause interference to any non-targeted data storage units.

For solid state devices, in some examples, the disturbance checker component <NUM> may track the number of read disturbs and/or program disturbs that have been experienced by each cell in the storage media <NUM>. In some examples, this may be inefficient and so the disturbance checker component <NUM> may track these metrics on a higher level - such as at a data storage unit level, such as a page, sub-block, block, superblock, or other organizational level. The disturbance checker component <NUM> may determine the data storage units that are to be programmed (target data units) and determine a set of one or more other non-target data storage units that are likely to experience read and/or write disturb effects when a particular data storage unit is programmed. The disturbance checker component <NUM> may determine whether incrementing the read and/or program disturb counter for each particular non-target data storage unit puts any of the non-target data storage unit at risk by comparing the counter to one or more thresholds. For example, a first threshold may correspond to a first probability, a second threshold may correspond to a second probability, and so on. In other examples, the counters may be input to a formula that determines a probability that a non-target data storage unit would be impacted by writing the requested data.

For magnetic devices such as hard disk drives, the disturbance checker may compare the proposed data to be stored and the non-target data storage units to a pattern. For example, certain patterns may tend to produce higher probabilities of interference, for example, by creating large magnetic fields. These patterns may be stored in a working memory of the memory device or on the storage media <NUM> itself.

For either magnetic storage devices or flash devices, certain repeated sequences of data (e.g., runs of '<NUM>'s or '<NUM>'s) may cause interference. In these examples, the proposed value and the values stored in non-target data storage units may be examined to determine whether a density of a particular value is over a threshold, or whether a pattern of data matches stored patterns of data that have historically caused problems.

In still other examples, a machine learning model may be utilized that predicts a probability of interference based upon the value to be stored and information about the non-target data storage units (e.g., neighboring memory pages, sectors, etc.. The information about the non-target data storage units may include the value stored in the storage unit, the location of the non-target storage unit in relation to the location of the programmed storage unit and the value to be stored, and metadata about the non-target storage unit (e.g., read disturb and/or write disturb count, number of erasures, etc.. ) and information about the programmed storage unit. More information on the machine learning model is discussed in relation to <FIG>.

Non-target data units are data units that are not being programmed or written by the requested write command. Target data units are data units that are being programmed or written by the requested write command. The system may analyze all non-target data units for interference potential, or only a subset of non-target data units that are neighboring data units. Neighboring data units may be determined by the structure of the storage media <NUM>. For example, neighboring data units may be non-target data units that are electrically or magnetically proximate to the target data units such that application of a charge or a current to, or storage of a value in, the target data unit may cause interference to the non-target data units.

If the disturbance checker component <NUM> determines that there exists a probability that writing this value to the selected location may cause other data storage units to be interfered with, the disturbance checker component <NUM> may determine a new value to store. In some examples, the probability may be a probability of affecting a single non-target data unit that is over a specified threshold. In these examples, it may not be valuable to introduce an error to prevent only one non-target error. In some examples, the probability may be a probability of affecting two or more non-target values. In these examples, introducing a correctable error to prevent multiple errors may be valuable. In still other examples, the system may distinguish between correctable errors that are introduced by writing the data and uncorrectable errors. That is, if a non-target data unit were to experience an uncorrectable ECC error because of the data write, then it would be valuable to introduce a correctable ECC error in the data to be written to prevent the uncorrectable ECC of a non-target data value. Thus, the system may utilize one or more rules (e.g., if-then statements) to determine when to modify the data value before writing. For example:
IF the probability of a non-target data unit experiencing an uncorrectable error is greater than a first threshold AND the probability of the non-target data unit experiencing an uncorrectable error is reduced below a second threshold by introducing a correctable error on the data-to-be-written THEN introduce the correctable error on the data-to-be-written ELSE IF the probability of multiple non-target data units experiencing a correctable error is greater than a fourth threshold AND by introducing a correctable error on the data-to-be-written reduces the probability of multiple non-target data units experiencing a correctable error below a fifth threshold THEN introduce the correctable error on the data-to-be written.

In some examples, the value to change the data to may be determined through communication with the value changer <NUM>. For example, value changer <NUM> may have a table that maps data values to one or more changed data values. The table may be based upon experience that changing a first value to a second value may reduce the probability of interference to data values stored in non-target data units. In some examples, the value changer <NUM> may provide one or more hypothesis for new values. These new values may be run through the disturbance checker component <NUM> to determine if the probability for interference is greater or lower than the original value. Probabilities for a series of these values may be calculated and the value that produces the lowest probability for interference may be selected.

In some examples, the ECC applied to the data allows for a set number of bit error corrections per specified unit of data written. In these examples, the values produced by the value changer <NUM> may only change that many bits to ensure that the ECC error is correctable. In other examples, the number of bit error corrections per specified unit may be lowered from the maximum for the given ECC based upon the condition of the media at the address the data will be written at For example, if that media location is wearing, has produced ECC errors in the past, or the like, the system may not use the full amount of bit errors that may be corrected in the anticipation that the media may add one or more unintentional errors.

Once the new value is calculated, the disturbance checker component <NUM> may provide the results to host command control <NUM>, which may instruct the media controller <NUM> to write the new value to the storage media <NUM> at the proposed address. When the host <NUM> wishes to read this value from the address, the host <NUM> will issue a read command to the storage controller <NUM>. The host command control <NUM> may command the media controller <NUM> to read the value at the given address from the storage media <NUM>. The value will then fail the ECC check and may be corrected by the ECC component <NUM>. The corrected value may then be provided to the host <NUM>. If the ECC component <NUM> cannot correct the error, the host <NUM> is notified.

<FIG> illustrates a flowchart of a method <NUM> of storing data in a data storage device according to some examples of the present disclosure. At operation <NUM> the memory device may receive a first data value for storage. The data value may be the proposed data value. The memory device may receive the first data value from a host device over a host interface. For example, from a host device over a Peripheral Component Interconnect Express (PCI-E) interface, a Small Computer System Interface (SCSI), a Universal Flash Storage (UFS) interface, and the like. The host device may be a controller on the processor of a computing device of which the memory device is a part of. For example, a processor, a platform controller hub (PCH), a device driver, or the like. The first data value may be received in a write request that requests the memory device write the first data value (the proposed data value) at a proposed memory address. The memory address given by the host may be translated into a physical memory address on the storage medium. For example, a flash translation layer may translate the logical address provided by the host to one or more physical memory addresses. In some examples, this may include determining multiple addresses. For example, a byte of data may map to multiple memory cells or magnetic charges on the disk.

At operation <NUM>, the memory device may determine that placement of the first data value at the proposed location has a probability of causing interference with other non-target data units that is greater than a threshold probability. In some examples, all non-target data units are analyzed, but in other examples, only neighboring data units may be analyzed. For example, the physical memory addresses may have values stored in non-target (e.g., neighboring) data units that have a high read and/or write disturb count and writing the proposed data value may cause one or more of these non-target data units to increase in charge such that it reads a wrong value. In other examples, placing the data at the proposed location may create one or more patterns that causes electrical or magnetic interference to other data. The patterns may be determined using one or more if-then rules that may consider the non-target data units, media state of the non-target data units, the location of the non-target data units relative to the written data, and the like. In other examples, the patterns may be described by one or more data structures and the pattern that would result from writing the proposed data value at the physical address may be compared to a plurality of undesirable patterns. The undesirable patterns may be stored in the memory device. For example, if the request at operation <NUM> would cause a long run of same-valued data to be stored on a magnetic disk in a small area (i.e. a high density of a same value or a long run of a same data value), it may increase the probability of creating a self-demagnetization field and thus the probability at operation <NUM> may be above a threshold.

The threshold probability at operation <NUM> may be a numerical threshold that may be specified by a designer of the memory device. In other examples, the probability at operation <NUM> may be a yes or no probability - e.g., if the proposed data value being written at the proposed address matches one of the undesirable patterns, the result of operation <NUM> may be a "yes.

At operation <NUM>, the system may change the first data value to a second data value that reduces the probability of causing interference to one or more data values in non-target data units. For example, the system may change one or more bits of the data value and re-evaluate the changed data value using the methods disclosed for operation <NUM>. The new data value with the lowest probability of causing interference to one or more non-targeted data values may be selected. In some examples, the memory device may only change a number of bits that are correctable using the ECC applied to the first data values prior to changing it to the second data value. In some examples, the memory device may change fewer bits than are correctable using an ECC to ensure that minor disturbances on the media do not cause uncorrectable ECC errors.

At operation <NUM>, the memory device may write the second value to the media of the data storage device at the proposed location. In some examples, the ECC information (e.g., a parity check value, or the like) from the originally proposed value may also be written. For example, the controller may spin the magnetic disks to the proper track and sector and cause application of a magnetic field to write the second value. In other examples, a program voltage is applied to one or more memory cells of flash memory (e.g., NAND or NOR).

<FIG> illustrates a flowchart of a method <NUM> of determining a probability that the placement of the first data value at a proposed location has a probability of causing interference with other data that is greater than a threshold probability according to some examples of the present disclosure. The method <NUM> may be one example of operation <NUM> of <FIG>. At operation <NUM>, the memory device may determine non-target data storage units to the proposed address. In some examples, this may be neighboring data units as defined above. In some examples, this may include non-target data values within a threshold distance on the physical media from the one or more storage units used to store the data value at the requested storage location. For example, data that is physically stored on the media in a location that is adjacent to the requested storage location. For example, a same sector on adjacent tracks, a same track on adjacent sectors, or the like. In examples in which the memory device is a NAND memory device, memory cells that are on adjacent word lines, adjacent page lines, and the like.

At operation <NUM>, in some examples, the memory device may determine metrics of one or more of the non-target data storage units determined in operation <NUM>. For example, one or more of a read-disturb count, a write-disturb count, a number of uncorrectable ECC errors associated with those locations, a write count, a read count, and the like. In some examples, the metrics may be individualized to each data storage unit (e.g., each memory cell, or each bit storage unit on a hard drive), but in other examples, the metrics may be generalized to one or more groups of data storage units. For example, a page of NAND cells, a sector of a magnetic hard disk, or the like.

At operation <NUM>, the memory device may analyze the proposed value using one or more models. In some examples, the models may be if-then-else rules. In some examples, the models may be one or more nested sets of ifthen-else rules such as a decision tree. For example, the rules may model placements of data, such as rules specifying a maximum run-length of a particular value, a maximum density of a particular value in a particular area (e.g., within a radius of x data units, there can only be a maximum of y same bit values). In some examples, rules may specify a maximum threshold of reads, writes, or other values for non-target data units before a probability of an error in a non-targeted data unit exceeds a threshold.

In other examples, machine-learned models may be utilized that may take as input the proposed value and the proposed location and information on values in non-target data units and their locations respective to the proposed location. Additionally, the machine-learned models may also use information on the status of the media for the data units making up the proposed location and the non-target data units. For example, a read-disturb counter, write-disturb counter, a number of reads, a number of writes, and the like. The machine-learned model may be trained on a large corpus of historical data writes and may be labelled on whether a subsequent read of non-target data units resulted in an ECC error. The machine-learned model may thus be trained to predict the likelihood of an ECC error. More information on machine-learned models is shown in <FIG>.

At operation <NUM>, the results of the models may be used to determine whether a probability of a non-target data unit being interfered with by writing the requested value at the requested location is above a threshold. In some examples, at operation <NUM> a single rule may be evaluated, and the result of the evaluation may be used to determine the probability. For example, a comparison may yield a match between the proposed value at the proposed location, non-target values, and one or more undesirable data patterns. In these examples, finding a match with an undesirable data pattern may cause the result of operation <NUM> to return true - that the probability is above a threshold. In some examples, at operation <NUM> multiple rules may be evaluated. For example, the system may return that the probability is above a threshold that a non-target data unit may be interfered with by the placement of the requested value at the proposed location if one or more rules return true, or if a combination of rules returns true as specified by one or more Boolean logical connectors between rules (e.g., AND, OR, NOR, XOR). In some examples, rather than use Boolean logical rules, each of multiple rules may produce a sub score that may be weighted and combined to produce a value, which, if the value exceeds a threshold, the system indicates that the placement of the proposed value in the proposed location may cause interference to data in non-targeted data units. In other examples, for machine-learned models, operation <NUM> utilizes the results of the machine-learned model.

<FIG> illustrates an example machine learning module <NUM> according to some examples of the present disclosure. The machine learning module <NUM> may be implemented in whole or in part by the storage controller <NUM>. In some examples, the training module <NUM> may be implemented by a different device than the prediction module <NUM>. In these examples, the model <NUM> may be created on a first machine and then sent to a second machine.

Machine learning module <NUM> utilizes a training module <NUM> and a prediction module <NUM>. Training module <NUM> inputs feature data <NUM> into feature determination module <NUM>. Feature determination module <NUM> determines one or more features for feature vector <NUM> from the feature data <NUM>. Features chosen for inclusion in the feature vector <NUM> may be all the feature data <NUM> or in some examples, may be a subset of all the feature data <NUM>. In examples in which the features chosen for the feature vector <NUM> are a subset of the feature data <NUM>, a predetermined list of which feature data <NUM> is included in the feature vector may be utilized. The feature vector <NUM> may be utilized (along with any applicable labels) by the machine learning algorithm <NUM> to produce a model <NUM>.

In the prediction module <NUM>, the current feature data <NUM> of the user may be input to the feature determination module <NUM>. Feature determination module <NUM> may determine the same set of features or a different set of features as feature determination module <NUM>. In some examples, feature determination module <NUM> and <NUM> are the same modules or different instances of the same module. Feature determination module <NUM> produces feature vector <NUM>, which are input into the model <NUM> to produce results <NUM>.

The training module <NUM> may operate in an offline manner to train the model <NUM>. The prediction module <NUM>, however, may be designed to operate in an online manner. It should be noted that the model <NUM> may be periodically updated via additional training and/or user feedback. The machine learning algorithm <NUM> may be selected from among many different potential supervised or unsupervised machine learning algorithms. Examples of supervised learning algorithms include artificial neural networks, convolutional neural networks, Bayesian networks, instance-based learning, support vector machines, decision trees (e.g., Iterative Dichotomiser <NUM>, C4. <NUM>, Classification and Regression Tree (CART), Chi-squared Automatic Interaction Detector (CHAID), and the like),random forests, linear classifiers, quadratic classifiers, k-nearest neighbor, linear regression, logistic regression, and hidden Markov models. Examples of unsupervised learning algorithms include expectation-maximization algorithms, vector quantization, and information bottleneck method. Unsupervised models may not have a training module <NUM> or may not utilize labels on feature data <NUM>.

The model <NUM> may be utilized in some examples to determine whether placement of the proposed value at the proposed location is likely to cause errors to values in non-target data units. In these examples, the feature data <NUM> may include historical data storage requests including the proposed value and location as well as one or more of: the non-target data units locations relative to the value and location, information about the data units making up the proposed location and non-target data units (e.g., such as the number of previous writes, erases, reads, read-disturb counters, write-disturb counters, and the like), or the like. The feature data <NUM> may be labeled with an indication of whether and which non-target data units experienced an ECC error that corresponds to the proposed write. Corresponding to the proposed write may include experiencing an ECC error within a specified number of reads since the proposed write, within a specified amount of time since the proposed write, errors occurring within a specified amount of additional write requests, or the like. Feature data <NUM> includes the current proposed value and location as well as one or more of: the non-target data units locations relative to the value and location, information about the data units making up the proposed location and non-target data units (e.g., such as the number of previous writes, erases, reads, read-disturb counters, write-disturb counters, and the like), or the like. The model <NUM> may provide a probability that the proposed write may introduce one or more errors into the data or may be an indication of whether one or more errors are likely to be introduced.

In some examples, the system modifies the proposed value if the probability of a single error being introduced in a single non-target data unit exceeds a threshold. In other examples, the system may modify the proposed value only if the probability of multiple errors being introduced in multiple non-target data units exceeds a threshold or if the single error in the single non-target data unit would be an uncorrectable ECC error.

<FIG> illustrates a block diagram of an example machine <NUM> that may implement any one or more of the techniques (e.g., methodologies) discussed herein. In some examples, the host device may include the machine <NUM> and the memory device may be the main memory <NUM>, static memory <NUM>, drive unit <NUM>, or the like. The memory device may also include one or more of the components of <FIG>, such as processor <NUM>, main memory <NUM> (including instructions <NUM>), and the like. Machine <NUM> may implement the data storage device <NUM>, a device implementing host <NUM>, and perform the methods of <FIG> and <FIG> and implement one or more of the machine-learning modules of <FIG>. The machine <NUM> may be a memory device, a personal computer (PC), a tablet PC, a set-top box (STB), a personal digital assistant (PDA), a mobile telephone, a smart phone, a web appliance, a network router, switch or bridge, or any machine capable of executing instructions (sequential or otherwise) that specify actions to be taken by that machine.

The term "machine readable medium" may include any medium that is capable of storing, encoding, or carrying instructions for execution by the machine <NUM> and that cause the machine <NUM> to perform any one or more of the techniques of the present disclosure, or that is capable of storing, encoding or carrying data structures used by or associated with such instructions. Non-limiting machine readable medium examples may include solid-state memories, and optical and magnetic media. Specific examples of machine readable media may include: non-volatile memory, such as semiconductor memory devices (e.g., Electrically Programmable Read-Only Memory (EPROM), Electrically Erasable Programmable Read-Only Memory (EEPROM)) and flash memory devices; magnetic disks, such as internal hard disks and removable disks; magneto-optical disks; Random Access Memory (RAM); Solid State Drives (SSD); and CD-ROM and DVD-ROM disks. In some examples, machine readable media may include non-transitory machine readable media. In some examples, machine readable media may include machine readable media that is not a transitory propagating signal.

Claim 1:
A data storage device (<NUM>) comprising:
a processor (<NUM>);
a memory, storing instructions, which when executed by the processor (<NUM>), causes the processor (<NUM>) to perform operations comprising:
receiving a first data value for storage at a specified location on the data storage device (<NUM>);
applying an error correction code to the first data value;
determining a probability that placement of the first error-corrected data value at the specified location will cause interference with other data stored at other locations on the data storage device (<NUM>);
in the case that the probability is greater than a threshold probability, changing the first error-corrected data value to a second data value, the second data value reducing the probability of causing interference with the other data stored at the other locations; and
writing the second data value to the data storage device (<NUM>) at the specified location.