The Great microSD Card Survey

Or: What are the best microSD cards you can get for under $15 in 2024?

Table of Contents

    Introduction

    MicroSD cards are ubiquitous nowadays, having found applications in a wide variety of consumer devices -- including smartphones, digital cameras, and single-board computers. While innovation is continuing to take place in this space, the market has largely matured. There are a wide variety of brands, models, and capacities available today, but it could be argued that consumers see little difference -- aside from capacity -- from one brand or model of card to the next. This ubiquity has helped to drive prices down to the point where a card able to store hundreds of gigabytes of data can be obtained for less than the price of a single meal at an average restaurant.

    As with any popular product, the market is littered with fakes. For example, 1 terabyte microSD cards from major brands -- such as SanDisk or Lexar -- cost around $70-$100, depending on the specific brand or model. A cursory search on Amazon for a 1 TB microSD card, however, yields off-brand (or no-brand) cards with prices as low as $12.99. How are these brands able to offer their products for far less than their name-brand competitors? In many cases, these cards are what is known as "fake flash" -- cards that have been programmed to advertise a certain capacity to their host device, but whose actual capacity is far less. For example, a card advertised as having a capacity of 1 terabyte might have an actual capacity closer to 8 gigabytes. On these cards, the actual storage space is typically located at the beginning of the card's logical address space; writes that occur beyond the end of the available space are simply discarded, while reads will typically result in all zeroes. Additionally, most filesystem implementations will fill up the available space in a linear fashion. Altogether, this means that the user might not notice anything wrong until they've filled the card's physical space -- at which point they will find that the data that was saved beyond the end of the card's physical space is simply gone and unrecoverable.

    Fake flash is not completely worthless, however. If the true amount of physical space can be determined, the card's partition table can be adjusted so that filesystems do not take up more than the amount of physical space available on the card. But, how well do these cards perform -- in terms of performance and durability -- compared to their "legitimate" counterparts? Is there value in buying fake flash if the caveat on the amount of available space is known beforehand? This was the question that I sought to answer.

    A few months back, I began purchasing various brands and capacities of microSD cards, and I've been testing them continuously since then. Originally I turned to AliExpress, focusing primarily on the cheapest options I could find; however, I've since expanded my collection to include some name-brand media as well. I also purchased some name-brand media from Amazon -- not only because I was curious to see how they performed as well, but also to act as a sort of baseline for comparison.

    On this page, I'm listing the results I've obtained so far. Keep in mind that many of the cards I purchased are still undergoing testing, and others are still sitting in the packaging waiting to be tested -- I'll note those in my results and update them once I have results to share.

    Criteria

    For each card I purchased, I wanted to be able to answer the following questions:

    1. Authenticity: Is the card the size it says it is, or is it fake flash?
    2. Performance: How well does the card perform in reading and writing operations? Does the card perform well enough to merit the various speed class markings that appear on the card or the card's packaging?
    3. Endurance: How much data can be written to the card before the card becomes unreliable or fails completely?

    Authenticity

    On the authenticity front, I'm primarily concerned with whether or not a card is "fake flash". For the purposes of this survey, I'm defining "fake flash" to mean "(a) SD media whose physical capacity is less than what is advertised to the host via its CSD register, or (b) SD media whose physical capacity is less than 95% of what is printed on the card's exterior or the product packaging". (I don't have a method for determining whether a card has a capacity that is more than what is advertised...yet.)

    As a secondary concern, I'm also going to be evaluating whether a card can be considered "skimpy flash". For the purposes of this survey, I'm defining "skimpy flash" to mean "any flash media whose physical capacity -- as advertised to the host via its CSD register -- is less than what is printed on the card's exterior or the product packaging". And, for the purposes of this survey, sizes will be evaluated using linear scales -- that is, 1 terabyte = 1,000,000,000,000 bytes, 1 gigabyte = 1,000,000,000 bytes, and so on. For example, if a card is labelled as being 32GB in size, does it actually have at least 32,000,000,000 bytes of available space, or does it have something closer to 31,500,000,000 bytes of available space?

    Why include this criteria? Because it can have a material effect on a user's experience with a card. Skimpy flash is a problem with name-brand and off-brand media alike -- with a couple particular name-brands actually being the worst offenders in my survey (so far). (That said, there are a couple other name-brands that were actually the least offenders as well.) Consider, for example, two 64GB cards I obtained -- one from Kioxia (the company formed as a result of Toshiba spinning off their flash memory division in 2018) that had a capacity of about 61.89GB, and one from Lexar that had a capacity of about 64.09GB. This is a difference of almost 2.2GB -- or about 18 minutes of 1080p video (at 16Mbps).

    Performance

    The SD Association has created a number of performance standards for SD cards, each with their own mark. Virtually all SD and microSD cards sold today carry at least one of these marks. I'm concerned with how well cards performed overall, but I'm also concerned with whether or not the card performed well enough to qualify for the markings that it bears -- both on the packaging and on the card itself.

    As of today, the SD Association has defined the following speed classes:

    • Class 2, 4, 6, 10: These speed classes dictate that read and write speeds should be at least 2MB/sec, 4MB/sec, 6MB/sec, and 10MB/sec, respectively. Cards have an application unit (AU) size defined in their SSR register, and write performance is measured by the amount of time taken to write in a sequential fashion to a single AU. (In the case of SDXC and SDUC cards, write performance is measured over a single AU or a 4MB segment of an AU, whichever is smaller.) Read performance, on the other hand, is measured by the amount of time taken to perform 256 random read operations.
    • U1 and U3: These speed classes dictate that read and write speeds should be at least 10MB/sec and 30MB/sec, respectively, when operating in UHS-I or UHS-II mode. The semantics of how performance is measured is largely the same as for Class 2/4/6/10.
    • Video Speed Class 6, 10, 30, 60, and 90: Version 5 of the SD card specification added a set of video speed classes, as well as some new commands to control the operation of the card and place the card into Video Speed Class recording mode. When operating in this mode, these speed classes dictate that write speeds should be at least 6MB/sec, 10MB/sec, 30MB/sec, 60MB/sec, and 90MB/sec, respectively.
    • Application Performance Class 1 and 2: These speed classes dictate a minimum number of random read and write operations per second (where each operation is 4KB in size), as well as a minimum sequential read and write speed of 10MB/sec. Application Performance Class 1 dictates a minimum of 1500 read operations per second and 500 write operations per second, while Application Performance Class 2 dictates a minimum of 4,000 read operations per second and 2,000 write operations per second.

    Realistically, I don't have the ability to perform tests exactly as the SD specification prescribes (although I'm working on that), so I've tried to engineer tests that at least approximate the spirit of the test. Many of the cards I tested performed far beyond what would have been required for the speed class markings they carried, while others fell far short of them. Others fell into a gray area, where they came close to the thresholds needed to qualify for one or more speed class markings, but technically fell short -- and until such time as I'm able to test them properly, I'm willing to concede that they might have qualified for a particular speed class marking had they been tested under the right conditions. I'll note these in my results.

    Endurance

    This one is pretty simple: how long will the card last if we write to every available byte on the card? Flash media has a tendency to degrade and become less reliable the more it's written to, so I'm interested in seeing not only how many times we can write to the card before data errors start cropping up, but also how many times we can write to the card before it becomes completely unusable. I'm not sure there's a standard here -- at least, the SD specification doesn't seem to define one -- but I've seen things online indicating that 2,000 write cycles seems to be a reasonable expectation, so I'm going with that. Specifically, I want to see whether a card can reliably store data across at least 2,000 read/write cycles. Flash media isn't perfect -- some data errors are bound to occur even before the card has hit the 2,000 write cycle mark -- so some allowance will be made for data errors that occur early on, as long as the error does not recur shortly afterwards.

    Methodology

    I had originally intended to use a combination of f3 and stressdisk to perform these tests; however, after finding some shortcomings to both tools, I decided to write a single tool that would combine the functionalities of both. I've made the source code available on GitHub.

    Admittedly, these tests have not been completely scientific in nature, despite my desire to do so -- for example:

    • I've been making code fixes to my tool as the project has gone on, and different cards were tested by the different versions of the program (or multiple versions of the program).
    • I'm using multiple different models/brands of SD card reader (although I'm in the process of trying to migrate to a single model).
    • I'm using two different PCs that are running two different versions of Ubuntu.

    But, the general strategy I took is described in the following sections.

    All of these tests were run on x86_64 PCs running Ubuntu. SD cards are connected to SD card readers, which are attached to the system via USB. The device is opened with the O_DIRECT and O_SYNC flags to try to minimize the effects of caching by the system.

    Authenticity

    The physical space on the card is divided into 8 equal or near-equal segments. The length of each segment is determined by taking the total number of sectors on the card and dividing by 8. (Side note: Linux always considers a sector to be 512 bytes, regardless of the physical size of the sector on the device.) In each segment (with the exception of the first), a random starting sector is chosen. In the first segment, the starting sector is always sector 0; in the last segment, the starting sector is chosen such that its starting sector is at least 8MB from the end of the device. (Note: for the purposes of this test, 1MB = 1,048,576 bytes.)

    Next, 36MB of random data is generated and held in memory. (This number was chosen in the hopes that it would exceed the foreseeable write cache size of any SD card by at least a factor of 2.) The random data is divided into 4MB chunks, and each chunk is written, in a linear fashion, starting with each of the starting sectors chosen earlier. The final 4MB is written in a linear fashion starting 4MB from the end of the device's logical address space. Each chunk is then read back and compared to the data written. If all nine chunks match what was written to the card, the card is considered "genuine"; e.g., that its physical space matches (or possibly exceeds) the amount of space indicated in its CSD register. If the contents of the first chunk do not match what was written to the card, the card is considered unusable and testing stops completely. Otherwise, the card is considered "fake". The logical space on the card is then bisected, 4MB of new random data is generated and written starting at the sector in the center of the new window, then read back and compared to the data written. This process is repeated until the extent of the card's physical space can be determined.

    I should note that my algorithm isn't perfect -- I've come across some fake flash that purported to be 512GB (but in actuality was closer to 32GB) that was misidentified as being closer to 256GB in size. In these situations, I've been allowing the first round of the endurance test to run on the device and using the results of that to determine where the card's physical space ends.

    Performance

    The performance test is divided into two parts: a sequential I/O test and a random I/O test. Each of these parts is divided into a read test and a write test. The read test is performed first, followed by the write test. Data obtained from read operations is not checked for consistency. USB3-enabled readers are used to ensure that the speed of the USB bus is not a bottleneck.

    During the sequential I/O tests, data is read from or written to the device continuously for 30 seconds. Data is read from or written to the device in chunks equal to the logical sector size (512 bytes) multiplied by the maximum number of sectors per request (as indicated by a BLKSECTGET ioctl call). After 30 seconds have passed, the total amount of data read or written is divided by the amount of time actually taken (measured with microsecond resolution) to determine the sequential data rate measurement.

    During the random I/O tests, data is read from or written to the device continuously for 30 seconds. Each read or write operations is targeted to a random sector in the card's physical storage space (as determined during the authenticity test). Data is read from or written to the device in 4KB chunks (as prescribed by section 4.16.2.4.2 of the SD Card Physical Layer Simplified Specification, version 9.0). After 30 seconds have passed, the total number of I/O operations is divided by the amount of time actually taken (measured with microsecond resolution) to determine the random IOPS measurement.

    Again, these tests aren't perfect. In fact, there's a number of issues with them. For example:

    • Most speed classes require you to issue a CMD20 command to the card to put it into an operating state where it will meet the demands of that speed class. Most USB card readers (including the ones I'm using) don't provide a way to issue arbitrary commands to a card. The reader might be issuing this command to the card transparently to my application, or it might not be -- I just don't know.
    • SD cards are divided into sections, called Application Units (or AUs). The Video Speed Classes in particular require certain commands to be issued to it to put the card into Video Speed Class mode and to specify which AU the host will be writing to. The host is then supposed to write only to that AU, in a sequential fashion (skipping over any blocks that are already in use). Once the host has reached the AU, it must issue another command to specify which AU it will be writing to next. Again, my card readers don't provide a way for the host to issue these commands to the card, so my application isn't doing this. Given the complexity involved in using Video Speed Class mode, I doubt that any of the card readers I'm using are doing this transparently for me.
    • The Application Performance Classes require the card to be preconditioned in a certain way -- e.g., you're supposed to start by fully erasing the card, filling up 75% of it with data, then overwriting part of that data with 256MB of data (written in a sequential fashion). You're then supposed to use that 256MB region for performing the actual performance tests. The test itself is supposed to last for 10 minutes. My application does not do this -- primarily because, when I initially wrote the random I/O tests, I got my technical details from Wikipedia, which fails to mention any of these details. Additionally, the host is supposed to issue a number of commands to the card to perform the preconditioning -- for example, CMD38 is to be used to perform a full erase of the card; CMD25 is to be used when filling up 75% of the card; and, if Application Performance Class 2 is being tested, CMD45/CMD46/CMD47/CMD48 are to be used to perform the actual reading/writing. Again, my card readers don't provide a way to issue these commands to the card, so I have no way of doing this.
    • In addition, read and write operations for the Application Performance Class tests are supposed to be 4KB-aligned. I didn't fix this in my code until just now.

    So I think I'm going to say that my tests encompass the spirit of each of the speed classes...but until I learn Verilog and can program an FPGA to perform a proper set of speed tests, my tests aren't going to truly accurate.

    Endurance

    The physical space on the card (as determined during the authenticity test) is divided into 16 roughly equal segments -- that is, the physical number of sectors is divided by 16 (rounding down), and each segment is assigned that number of sectors. The first segment begins at sector (physical_number_of_sectors / 16) * 0, the second segment begins at (physical_number_of_sectors / 16) * 1, the third segment begins at (physical_number_of_sectors / 16) * 2, and so on. If the number of physical sectors on the card is not evenly divisible by 16, any extra sectors are assigned to the last segment. (I'll note that while it's possible for an SDSC card -- that is, a card that is 2GB or less in size -- to have a number of sectors that is not evenly divisible by 16, it's not possible for an SDHC, SDXC, or SDUC card. This is because, for an SDHC, SDXC, or SDUC card, the card's capacity [in bytes] is determined by taking the contents of the C_SIZE field -- from the card's CSD register -- and multiplying it by 512KB (or 524,288), which is itself a multiple of 16 sectors [or 8,192 bytes]. However, in practice, the authenticity test frequently finds fake flash whose physical number of sectors is not a multiple of 16.)

    At the beginning of each round, the order of the segments is randomized. Then, for each segment (in the order they appear in the randomized list), a seed is determined, and a pseudorandom number generator is initialized with that seed. Pseudorandom data is then generated and written to the entire segment in a sequential fashion.

    Once all segments have been written, the order of the segments is randomized again. Then, for each segment (in the order they appear in the randomized list), the pseudorandom number generator is re-initialized using the same seed that was used when the data was written to that segment. The pseudorandom data is regenerated; the data is read back from the card (again, in a sequential fashion) and compared to the pseudorandom data. If any discrepancies are found, the sector in which discrepancy appeared is flagged as "bad". (The program continues to write to/read from sectors that have been flagged as "bad", but does not take any further action if further discrepancies are found in those sectors.)

    One all segments have been read back, the round is considered complete, and the program moves on to the next round.

    If an I/O error occurs, the program has logic to detect whether the device has become disconnected from the system. If it has, it pauses, displays a message to the user, and waits for the device to be reconnected. If the disconnect occurred during a write operation, the segment in which the error occurred is restarted to avoid any corruption that may have occurred due to the contents of any write caches being lost at the time of the disconnect.

    If it is determined that the device is still connected to the system, the program has logic to retry the I/O operation a set number of times. If all of those attempts fail, the program attempts to perform a reset operation on the card reader. Once the reset is complete, the program makes another set of attempts to retry the I/O operation. This process is repeated a set number of times, or until the I/O operation completes successfully. If all retry/reset attempts are exhausted, the program flags the sector in which the error occurred as "bad" and moves on to the next sector. (I'll note that, at present, there is no distinction between a sector that has been flagged as "bad" due to a data discrepancy and a sector that has been flagged as "bad" due to a failed I/O operation; therefore, the program will still attempt to read and write to the sector on future rounds.)

    This process repeats until any of the following conditions are met:

    • An I/O error occurs, a reset operation is performed, and the reset attempt failed
    • 50% or more of the sectors on the card have been flagged as "bad"

    In the former case, there have been some instances where I've been able to "resurrect" the card and continue testing -- generally by physically unplugging the card reader from the system and plugging it back in. If the card comes back to life through such a measure, I've generally allowed the endurance test to continue.

    Card Readers Used

    I've used the following card readers in my testing so far:

    • SmartQ Single: A nice low-cost SD card reader that supports USB 3.0. However, in my testing, this reader has a tendency to stop responding after extended continuous use (generally once every few days). The reader has to be physically unplugged and reconnected to continue working.
    • SmartQ Duo: Slightly more expensive than the SmartQ Single and sporting an almost identical form factor, it supports dual LUNs (meaning that it can operate on two cards simultaneously -- one in the microSD slot, one in the full-size SD slot). It doesn't seem to have the same problems with disconnects that the SmartQ Single does.
    • SanDisk MobileMate: A compact reader that only accepts microSD cards. SanDisk has a technology that allows for faster transfer rates than is possible under the UHS-I protocol (up to 170MB/sec), and requires both a compatible card and a compatible reader to achieve. This reader supports these enhanced transfer rates.
    • JJS CR-UTC4AC: A slightly larger, but still compact, SD/microSD card reader. This is a dual-LUN reader that supports UHS-II, and features USB-C, USB-A, and micro-USB connectors (although the micro-USB connector only supports USB 2.0). This has quickly become my reader of choice as it is only slightly more expensive than the SanDisk MobileMate while supporting UHS-II. I'll note that some of these readers were sourced from Amazon Marketplace, while others were sourced from AliExpress; however, they are physically identical (at least on the exterior), and the product packaging was identical. I believe that there are no differences between the two.
    • Lexar LRWM05U-7000: This is a compact UHS-II-compatible microSD reader that was bundled with the two Lexar Professional cards I purchased. It looks like Lexar doesn't sell these by themselves.
    • Prograde Digital Dual Slot Mobile Reader: A compact SD/microSD card reader with dual slots and dual LUNs that sports a USB-C connector and supports USB 3.2 and UHS-II. At some point I made the decision that I wanted to have at least one UHS-II-compatible card, and went in search of a good quality UHS-II-compatible card reader. This one initially appeared to be the best/cheapest option (until I later discovered the JJS CR-UTC4AC). I haven't noticed any significant difference in performance between this one and any of the other readers I'm using. Its main downside is its USB-C connector -- only because I only have a single USB-C port across the two machines that I'm presently using.
    • Platinum PT-CRSA1: A more moderately-priced single LUN SD/microSD card reader. Honestly, I bought this one because I ran out of SD readers, and I happened to be at Best Buy at the time, and I wanted to see if they had anything comparable to what I had been using. This happened to be the cheapest USB 3.0-compatible card reader they had. I would say it's been fine, but I won't be buying any more of these -- partly because the JJS CR-UTC4AC is a better value for slightly less money, but partly because Best Buy doesn't carry them anymore.
    • Togconn TOG-SD-CR: A nice low-cost multi-LUN card reader. This reader can read two SD cards, a Memory Stick, a CompactFlash card, and an xD card simultaneously. (This reader has two full-size SD card slots and two microSD card slots, but each full-size SD/microSD slot pair are a single LUN.) At one point, I was looking to see if there was a cost-effective way to test multiple cards at the same time. While there are readers out there that will read four SD cards simultaneously, they cost more than what I wanted to pay -- so I settled on this one instead. Originally the plan was to use a microSD-to-Memory Stick adapter, a microSD-to-CompactFlash adapter, and a microSD-to-xD adapter to fill all of the available slots on this card reader; however, my results have been disappointing. While the microSD-to-CompactFlash reader is working well, I quickly noticed that a microSD card plugged into a microSD-to-Memory Stick adapter appeared to the reader as the wrong size. Reviews of microSD-to-xD adapters indicated poor results as well, so I opted not to even try. Consequently, I currently have two microSD cards plugged directly into this reader, with a third card plugged in using a QUMOX B664U microSD-to-CompactFlash adapter. (I'm not using the second port on the QUMOX, as that would cause it to RAID the two cards together -- which I don't want.)
    • Realtek RTS5129: This card reader isn't one I purchased directly; rather, it was built into one of the laptops that I used as one of my test rigs. Its primary advantage is that the Linux kernel module presents it as an SD/MMC reader (rather than a generic block storage device, as with all the other readers I've used). Since it's wired up to the USB 2.0 bus internally, I didn't use it for any performance testing; I only used it to read the contents of the various card registers for later analysis.

    Overall Scoring

    As I was working on writing this, I realized that I needed a rating system for these cards. I was originally just looking at the top 10 in each of the three categories, but it became apparent that there were no crossovers between the top 10 in all three categories. There were a few that appeared in the top 10 in both the capacity and endurance categories -- but it was only four of them, and two were from brands that were known to put out fake flash. That wasn't ideal -- so I decided to come up with a different system.

    Here's how it's going to work:

    • Each model will receive a separate score in each of the three categories (capacity, performance, and endurance). The total score for that model will be the average of the three scores.
    • The score for the capacity test will be the distance, in standard deviations, of that model's average skimp score from the average skimp score for all cards. Since we want to penalize fake flash and (to a lesser extent) skimpy flash, we're going to negate the score -- ergo, fake flash will generally have a negative score here, and genuine flash will generally have a positive score.

      Let's look at an example. Let's say a card has a skimp score of 3.3%, the average is 14.29%, and the standard deviation is 31.33%. This would mean that the card's skimp score is actually 0.35 standard deviations below average ((3.3 - 14.29) / 31.33 = -0.35). We then negate this result, which would give us a score of +0.35.

      This is going to penalize fake flash -- and hard -- and that's kinda the idea. We don't want to reward fake flash at all.
    • The score for the performance test will consist of four sub-scores, for each of the performance metrics (sequential read speed, sequential write speed, random read speed, random write speed), averaged together. As with the capacity test, we'll use the distance, in standard deviations, from the average. Here, we want to reward faster-performing cards, so we're not going to negate the scores like we did with the capacity score -- the best-performing cards will generally have a positive score, while the worst-performing cards will generally have a negative score.

      Let's look at an example. Let's say a card got 100MB/sec sequential read speeds, 50MB/sec sequential write speeds, 2,000 IOPS/sec random read speeds, and 250 IOPS/sec random write speeds. Now, let's say the averages are 50MB/sec sequential read speeds, 25MB/sec sequential write speeds, 1,000 IOPS/sec random read speeds, and 350 IOPS/sec random write speeds. Finally, let's say the standard deviations are 25MB/sec in sequential read speeds, 25MB/sec in sequential write speeds, 100 IOPS/sec random read speeds, and 50 IOPS/sec random write speeds. That would mean that the card scored 2 standard deviations above average in sequential read speeds ((100 - 50) / 25 = 2), 0 standard deviations above average in sequential write speeds ((50 - 50) / 25 = 0), 10 standard deviations above average in random read speeds ((2000 - 1000) / 100 = 10), and 2 standard deviations below average in random write speeds ((250 - 35) / 50 = -2). The individual scores for this card would be 2, 0, 10, and -2. We then take the four scores and average them together, giving it an overall performance score of 2.5 ( ( 2 + 0 + 10 + -2 ) / 4 = 2.5).
    • The score for the endurance test will consists of six sub-scores: one for the number of read/write cycles the card endured before experiencing its first error, and one each for how many read/write cycles the card endured before 0.1%, 1%, 10%, 25%, and 50% of the sectors on the card have been marked as "bad". If a card fails before reaching any of these thresholds, they will be considered to have instantly hit those thresholds. We want to reward cards that fail more slowly, so we're going to take each threshold and subtract it from the previous one to figure out how many read/write cycles it went between hitting each one. For example, if a card hits the 1% threshold after 2,500 read/write cycles, and it hits the 10% threshold after 3,500 read/write cycles, then we'll use the difference between the two -- 1,000 in this example -- as the basis for calculating the score. We'll then figure out the distance, in standard deviations, from the average for each category, and finally we'll average all six scores together.

      Ok, that was a mouthful, so let's look at an example. Let's say a card experiences its first error at 1,000 read/write cycles, it hits the 0.1% threshold after 2,000 read/write cycles, the 1% threshold after 3,000 read/write cycles, the 10% threshold after 4,000 read/write cycles, the 25% threshold after 5,000 read/write cycles, and the 50% threshold after 6,000 read/write cycles. That means that we would use 1,000 as the basis for calculating each score.

      Now, let's say that the average for each category is 500, and the standard deviation is 250. A score of 1,000 would be two standard deviations above the average ((1000 - 500) / 250 = 2), so the card would receive a score of 2 in each of the six categories. We then take the average of all six scores -- which would be 2, so the card would receive a score of 2 for endurance.

    This isn't a perfect system -- obviously, a card's score is going to change whenever I test any other card -- but it does give us something that lets us easily and objectively rate one card in comparison to the others. A perfectly average card will have a score of 0; a below average card will have a negative score; and an above average card will have a positive score.

    Results

    There's a number of ways I could break down this data. Since I did define some goals for this project, let's go in order of those goals.

    Capacity

    As I said earlier, I wanted to identify whether these cards really offered the capacity that they advertised. For this result, I created a metric called "skimp" -- which I'm defining as:

    S = 1 - (CPhysical/CPackage)

    Where CPhysical is the card's physical capacity, CPackage is the capacity advertised on the package (or in some cases, on the exterior of the card or on the product listing for the card), and S is the skimp factor, expressed as a percentage. Think of it like the answer to the question of "how much capacity am I actually getting vs. how much I paid for?" Lower numbers (or even negative numbers) are better. For example, if a card is advertised as being 8GB in size, and the physical storage capacity is 7.8GB, then it would have a skimp factor of 2.5%, because you lost 2.5% of the stated capacity of the card. On the other hand, if a card is advertised as being 8GB in size, and it turns out to actually be 8.2GB in size, then it would have a skimp factor of -2.5%. I used linear scaling for data storage prefixes (e.g., one kilobyte = 1,000 bytes, one megabyte = 1,000 kilobytes, etc.), because if I had used binary scaling, no card would have had a skimp level anywhere close to 0.

    So...is there a difference between the cards I got from Amazon vs. the cards I got from AliExpress?

    (Error bars represent the range of values obtained.)

    At first glance, it would look like the AliExpress cards were a lot more skimpy -- and they were -- but there's a reason for this: I only ordered authentic cards from Amazon, whereas I ordered a mix of authentic and fake cards from AliExpress.

    What if we narrow down the data to just the authentic cards from both marketplaces?

    Well, the margin is a little closer here, but the AliExpress cards were still skimpier. Why is that? Let's break this down further: both by which marketplace I obtained them from, and by brand/model. (Note that I'm adding the off-brand/knockoffs back in -- just so that I don't have to make another chart later that has all the cards.)

    (Side note: I like making rainbows.)

    Admittedly it's kinda hard to tell with this chart -- because it includes the fake cards, and the chart has to scale to show those -- but aside from the Kingston Canvas Select Plus's, all of the Amazon cards had a skimp factor of 0.65% or less, whereas the AliExpress cards -- even the name-brand ones -- were all over the place (with the Kioxia Exceria Plus 32GB being the worst non-fake flash offender, coming in at a skimp factor of 3.32%).

    From this data, I think we can draw a couple of conclusions:

    • Authentic cards generally have a skimp factor of 5% or less.
    • Fake cards generally have a skimp factor of 50% or more.

    Is it possible for a card to be fake and have a skimp factor of less than 50%? Sure -- but in practicality, it doesn't seem to happen. I think it's more practical for fake flash sellers to scale up the logical storage space by a factor of 2 or more. (Edit: OK, the QWQ Extreme Pro proved me wrong here.)

    By that same token, is it possible for an authentic card to have a skimp factor of more than 5%? Sure -- I just didn't find any examples of this happening.

    We can also pick out the top 10 performers in this category:

    1. Auotkn Extreme 8GB
    2. QEEDNS 8GB
    3. Bekit 8GB
    4. Lexar Professional 1000x 64GB
    5. Samsung PRO Endurance 32GB
    6. Samsung EVO Plus 64GB
    7. Samsung EVO Plus 32GB
    8. Hiksemi NEO 8GB
    9. Amzwn 32GB
    10. SanDisk High Endurance 64GB
    11. SanDisk Extreme 64GB
    12. SanDisk Extreme PRO 64GB

    (The SanDisk High Endurance 64GB, SanDisk Extreme 64GB, and SanDisk Extreme PRO 64GB were all tied for 10th place.)

    (Note: The charts above are being automatically rendered using data from my spreadsheet -- so it's possible that the charts above indicate a different top 10, and I just haven't updated the list above. The list here is current as of 3/2/2024.)

    Here's how these cards lined up on my rating scale:

    We can also look at these cards from another angle: price per gigabyte:

    Here, we can see that the AliExpress cards had a little bit of an advantage. Here's how it shook out for all of the cards I've tested so far:

    Here, the Hiksemi NEO 128GB is the clear winner -- and honestly (for reasons I'll discuss later on), this card is a good buy.

    Last updated: 3/2/2024

    Performance

    The second goal of this project was to look at performance -- so let's compare how the Amazon cards performed when compared to the AliExpress cards.

    (Error bars represent the range of values obtained.)

    At first glance, it would appear that there's a marked difference between the Amazon cards and the AliExpress cards -- with Amazon cards performing better than the AliExpress cards across the board and with less variability in scores across Amazon cards vs. AliExpress cards. Again, however, I primarily obtained name-brand cards from Amazon, whereas I got a mix of name-brand, off-brand, and knock-off cards from AliExpress. What if we separate the AliExpress cards out into name-brand cards, off-brand cards (fake and authentic), and knockoff cards (fake and authentic)?

    Now it looks like the name-brand cards I got from AliExpress did on par with -- or even better than -- the Amazon cards.

    But it also highlights a couple more important differences:

    • Categorically, off-brand cards did worse than name-brand cards in all performance metrics.
    • Categorically, knockoff cards did worse than off-brand cards, and much worse than name-brand cards, in all performance metrics. (Yes, all of the fake cards I tested got less than 10 write operations per second on the random write test. Yes, some of them got less than one write operation per second. I don't know how they managed to suck so bad...but they found a way.)

    Ok, let's spin this a different way: which brands/models performed the best? First, let's look at the individual scores in each category:

    Now, how did these cards score according to my ratings system?

    So overall, the top performing cards here would be:

    • Kioxia Exceria G2 64GB
    • Samsung PRO Endurance 32GB
    • Samsung EVO Plus 64GB
    • SanDisk Extreme (both 32GB and 64GB versions)
    • Lexar Professional 1000x 64GB
    • Kingston Canvas Select Plus 32GB
    • SanDisk Extreme PRO (both 32GB and 64GB versions)
    • Lexar Blue 633x 32GB

    We can also look at this a different way: which cards would work best in certain applications?

    When using a microSD card in a digital camera, sequential write speeds are generally going to be the most important. When taking still photographs, the camera must generally be able to write the picture out to the card before it can take the next one -- so faster write speeds means the camera can be ready to take the next picture sooner. When shooting video, the camera has to be able to write data out to the card faster than the camera can generate it -- if it can't, it generally has to stop recording video. Sequential read speeds are important as well, as you generally want to be able to offload pictures and videos -- to, say, your computer -- very quickly.

    The nice thing about this ratings system is that I can very easily re-weight certain categories. So for this rating, let's give the sequential write speed double weight, and random I/O scores half weight:

    So, for photography/videography, my top picks here would be:

    • Kioxia Exceria G2 64GB
    • SanDisk Extreme PRO (both 32GB and 64GB versions)
    • SanDisk Extreme (both 32GB and 64GB versions)
    • Lexar Professional 1000x 64GB
    • Hiksemi NEO (both 8GB and 128GB versions)
    • Kingston Canvas Select Plus 32GB
    • Samsung EVO Plus 64GB

    The other way we could look at it is in something like a tablet, mobile phone, or mobile game console (like a Nintendo Switch or a Steam Deck). Here, random read speeds are going to be most important -- as you want your apps/games to load quickly. Sequential write speeds are going to be a factor as well -- as that's going to affect how quickly you can download new apps and games.

    So let's re-weight these cards -- we'll give random read speeds double weight, and we'll give random write and sequential read speeds half weight:

    So, the top picks here would be:

    • Samsung PRO Endurance 32GB
    • SanDisk Extreme (both the 32GB and 64GB versions)
    • Kioxia Exceria G2 64GB
    • SanDisk Ultra 32GB
    • Samsung EVO Plus 64GB
    • Kingston Canvas Select Plus 32GB
    • SanDisk Extreme PRO 64GB
    • Lexar Professional 1000x 64GB
    • Lexar Blue 633x 32GB

    Endurance

    This is the area where I'm most unready to publish results, but I'm going to publish what I have. Why is that? Well...endurance testing takes a while. A long while. On average, these cards can complete about 36 read/write cycles per day, but that number is pretty variable depending on the size of the card, how well it performs, and how many errors it runs into. Some of them have been able to complete over 200 read/write cycles per day -- meaning that it can hit 2,000 read/write cycles in as little as 10 days. Others are only been able to complete about 3.6 read/write cycles per day -- meaning that it's going to take a year and a half to get to 2,000 read/write cycles. I've only been running this project for 6 months now -- so I've got a long way to go.

    Some of these cards have been going through endurance testing for six months now, and have yet to experience a single error. I bought an initial batch of 18 cards; out of those 18:

    • 11 are still going through their endurance tests.
    • 7 haven't even experienced a single error yet.
    • One hasn't been through any testing yet, because I've been working on an FPGA design for a card tester, and I've been using it as part of my testbed. (I really should just order a replacement instead.)

    I have 119 cards right now (plus another 6 on order -- and that's assuming I don't order more, which is a definite possibility). Out of those:

    • I've only managed to destroy 16 of them.
    • 73 of them are still going through endurance testing.
    • The remaining 30 haven't undergone any testing yet.

    So...when I say these results are preliminary and subject to change, keep in mind that they are very preliminary and very subject to change.

    Since I've started the previous two sections by comparing Amazon cards to AliExpress cards, let's start with that. Keep in mind, many of these cards that are represented in this data are still undergoing endurance testing -- so the data represents how many rounds the cards have endured so far, as opposed to how many they will ultimately endure. Also, I started different cards at different times -- so the data is going to be skewed a little bit because of that.

    I'm not going to try to justify the difference between the Amazon and the AliExpress cards, because there's several factors affecting how many read/write cycles I've been able to complete:

    • Most cards are still undergoing endurance testing.
    • I'm testing cards of various sizes, and it takes longer to test a bigger card than a smaller card. For example, all other factors being equal, it's going to take 16 times longer to complete a single round of testing on a 128GB card than on a 4GB card. (Don't get me wrong -- I've been tempted to buy the SanDisk Ultra 1.5TB or the Kioxia Exceria Plus 2TB card that Kioxia just announced, but they're a little cost prohibitive right now. If anyone from SanDisk or Kioxia is reading this and you're willing to send me some samples of these cards, I'll happily add them to these results.)
    • I started testing these cards at different times. I started this project in August of 2023. The most recent set of cards started testing in February 2024.
    • I'm saturating the USB bus on both machines that I'm using for testing. Almost all of my cards are not running at their full speed potential during the endurance test because the bandwidth simply isn't available. For endurance testing, I didn't consider this to be an important factor, because the endurance test isn't about speed. (Side note: I've coded my program so that if I'm running a performance test, all other instances of my program pause what they're doing so that they're not sucking up USB bandwidth and negatively affecting the results.)

    I have started keeping track of how long cards go between their initial failure, the 0.1% threshold, the 1% threshold, the 10% threshold, the 25% threshold, and the 50% threshold. I don't want to call out individual brands/models here -- because I only have 16 cards total that have failed thus far. However, for the cards that have completely failed, here's how things shook out:

    MeasureAverageStandard DeviationMinMaxCount
    Number of read/write cycles completed before first error1,6721,67806,11156
    Number of read/write cycles completed between first error and 0.1% error threshold7721,71605,91422
    Number of read/write cycles completed between 0.1% and 1% error thresholds3651,40105,79119
    Number of read/write cycles completed between 1% and 10% error thresholds53137051117
    Number of read/write cycles completed between 10% and 25% error thresholds1855022617
    Number of read/write cycles completed between 25% and 50% error thresholds2656020316

    But with only 16 samples, it doesn't seem like we have very high quality data -- especially when we know that we have cards that will skew these results when they finally start experiencing errors. In order for us to make sense of these results, I think we have to take a more qualitative look at the data rather than a quantitative look.

    Earlier on, I said that I was going to use 2,000 read/write cycles as the threshold for a card to be considered "reliable". It's an arbitrary number, but it was based on some other reading I had been doing. So, I think we can spin this in two ways:

    • Which models have made it successfully past the 2,000 read/write cycle mark without errors?
    • Which cards experienced errors before hitting the 2,000 read/write cycle mark?

    In the first category, we have the following:

    • Auotkn Extreme 8GB: All three samples survived for at least 2,000 read/write cycles without errors.
    • Bekit 8GB: One of the three samples survived for at least 2,000 read/write cycles without errors; the other two did not.
    • Chuxia 32GB: One of the three samples survived for at least 2,000 read/write cycles without errors; the other two did not.
    • Cloudisk 32GB: One of the three samples survived for at least 2,000 read/write cycles without errors, and one did not. The third has not yet hit the 2,000 read/write cycle mark.
    • Hiksemi NEO 8GB: Two of the three samples survived for at least 2,000 read/write cycles without errors; the other one did not.
    • Hiksemi NEO 32GB: One of the samples survived for at least 2,000 read/write cycles without errors. The other one has not yet hit the 2,000 read/write cycle mark.
    • Hiksemi NEO 128GB: One of the three samples survived for at least 2,000 read/write cycles without errors, while one did not. The third has not yet hit the 2,000 read/write cycle mark.
    • Kingston Canvas Select Plus 32GB: One of the six samples survived for at least 2,000 read/write cycles without errors; three did not. The other two have not yet hit the 2,000 read/write cycle mark.
    • Kioxia Exceria 32GB:The one sample I tested survived for at least 2,000 read/write cycles without errors.
    • Kioxia Exceria G2 64GB: One of the three samples survived for at least 2,000 read/write cycles without errors, while one did not. The third has not yet hit the 2,000 read/write cycle mark.
    • Kodak Ultra Performance 32GB: One sample I tested survived for at least 2,000 read/write cycles without errors. The other two have not yet been tested.
    • Kodak Ultra Performance 64GB: One sample I tested survived for at least 2,000 read/write cycles without errors. The other two have not yet been tested.
    • "Lenovo" 2TB: The one sample I tested survived for at least 2,000 read/write cycles without errors.
    • Microdrive "Bart Simpson" 16GB: All three samples survived for at least 2,000 read/write cycles without errors.
    • OV 32GB: One of the three samples survived for at least 2,000 read/write cycles without errors; the other two did not.
    • QEEDNS 8GB:The one sample I tested survived for at least 2,000 read/write cycles without errors.
    • Samsung EVO Plus 32GB: One sample survived for at least 2,000 read/write cycles without errors. One has not yet hit the 2,000 read/write cycle mark. The third has not yet been tested.
    • Samsung PRO Endurance 32GB: The one sample I tested survived for at least 2,000 read/write cycles without errors.
    • SanDisk Extreme 32GB: One of the three samples survived for at least 2,000 read/write cycles without errors; the other two did not.
    • SanDisk Extreme PRO 32GB: One of the three samples survived for at least 2,000 read/write cycles without errors; the other two did not.
    • SanDisk High Endurance 64GB: One of the three samples survived for at least 2,000 read/write cycles without errors, while one did not. The third has not yet hit the 2,000 read/write cycle mark.

    For the second category...well, let's just say this: of the cards where I have at least three samples in testing or that have completed testing, there's only two cards where all three samples made it past the 2,000 read/write mark: the Auotkn Extreme 8GB, and the Microdrive "Bart Simpson" 16GB. All of the others had at least one card that experienced errors before hitting the 2,000 read/write cycle mark.

    To get a list of top performers, let's narrow down the list above to just the ones where all samples survived for at least 2,000 read/write cycles without errors. The current contenders -- as of this writing -- are (in order from "most read/write cycles survived without errors" to "least read/write cycles survived without errors"):

    Frankly, I don't like this list, for a couple of reasons:

    • All of these contenders -- with the exception of the Auotkn Extreme 8GB -- are on the list based on the results from one sample, because I only purchased one of them. I'd like to go back and buy additional samples of these to get some more representative data.
    • One of these options (the "Lenovo" 2TB) is fake flash. This card should have no business being this reliable.

    Known Failure Modes

    There were a number of ways in which I observed cards failing. I'm lumping them into two categories: data verification errors, and card failures. The "data verification errors" category consists of bit flip errors, data shift errors, missing data errors, and corrupted data errors. The "card failures" category consists of unresponsive cards, corrupted CSDs, and write-protected cards.

    Bit Flip Errors

    The term "bit flip errors" refers to a phenomenon when the data read back matches the data written to the card, with the exception of a few bits -- or sometimes only one bit. Bit flip errors can occur when a bit flips from a 0 to a 1, or from a 1 to a 0. Bit flip errors tended to happen most frequently on fake flash and low-quality flash, and once they started, they tended to increase in number and frequency.

    Data Shift Errors

    I'm using the term "data shift error" to refer to a phenomenon where data that is expected to show up in one sector appears two sectors later. (When I say "data", I'm referring to all 512 bytes in a sector -- not just a portion of it.) This phenomenon affects a variable number of sectors at a time; however, most times the number of sectors is in the single-digits.

    It took me some time to notice this phenomenon occurring; however, once I did, I started noticing it happening more and more. It doesn't seem to be isolated to any particular brand of card or any particular card reader. It's frankly baffling the hell out of me, because I don't know if it's just something wrong with the cards or if it's something else. However, this tended to be a pretty common failure mode for name-brand cards.

    Missing Data Errors

    I'm using the term "missing data error" to refer to a situation where a card responded to a read request, but the data returned consists of a single byte repeated over and over (usually 00 or ff). This type of error tends to occur with fake flash when reading from a sector that isn't mapped to a physical sector in the card's flash storage.

    Corrupted Data Errors

    I'm using the term "corrupted data errors" to refer to any other situation where a card responded to a read request, but the data returned did not match the data written. Sometimes this can be due to a write request that was cached by the card but not written out (or only partially written out) to the card's flash storage. In general, though, I'm using this term to refer to a data verification error that doesn't fit into any of the other categories.

    Unresponsive Cards

    I'm using the term "unresponsive card" to refer to a situation where the system did not expose the card as a block device when plugged into a card reader.

    Upon further inspection, I managed to get a little more insight as to what's happening with at least some of these cards. When initializing a card, the host is supposed to send ACMD41 to the card to tell it to begin its power-up sequence. While the power-up sequence is taking place, the host can issue additional ACMD41s to the card to ask the card whether it has finished powering up. From the time the card gets the first ACMD41, it has one second to complete its power-up sequence. With at least a few cards, I could see it responding to the ACMD41s commands, but they would never indicate that their power-up sequence was complete.

    I was able to unintentionally trigger this scenario with a working card while working on an FPGA design -- and after diagnosing the issue for some time, I concluded that the issue was that the card was being undervolted. This leads me to conclude that the "dead" cards have some component (like a resistor, transistor, diode, etc.) that has failed, and is either preventing the card from getting up to operating voltage or is preventing it from detecting that it got up to operating voltage.

    Corrupted CSD

    The CSD register is a register that the host can read from the card, and specifies a number of parameters for the card -- such as whether the card is write protected, how much time it should take for a nominal write operation to complete, and -- most importantly -- the size of the card. There have been two instances (with a single brand of card) where the contents of the card's CSD register changed, which resulted in the overall capacity of the card changing to be far less than what it was originally. When this has happened, I've immediately declared the card "dead" without any further testing.

    Write-Protected Cards

    Some cards have been known to make themselves write-protected -- either by indicating as such in the CSD register or by exhibiting I/O errors whenever writes are attempted. It is not known whether this behavior is accidental or by design. If this behavior is by design, a hypothetical design might be as follows:

    • A card has a certain number of "spare" sectors. These sectors are designated for performing wear leveling and/or bad sector replacement.
    • The card maintains a sector map, for its internal use, that maps logical sectors to physical ones. When the host requests a given sector, it uses this map to determine the physical location of the requested sector in the flash core.
    • As wear leveling is performed, the sector map is updated to reflect the physical location of each logical sector in the card's user area.
    • If a bad sector is detected, it is flagged as such in the sector map and replaced with one of the spare sectors -- thus reducing the number of spare sectors available.
    • Once the card runs out of spare sectors (or falls below a defined threshold), it makes itself read-only to protect the integrity of the data already on the card.

    Of course, the other explanation is that this behavior is accidental -- for example, the portion of flash memory where the card stores its write-protect flags could become corrupted, causing it to report that it is write protected.

    Regardless of the mechanism, when this situation occurs, I've generally tried to reset the card -- by pulling it from the reader and reinserting it -- to try to resolve the situation. (After all, there is a "write protect until power cycle" flag in the Physical Layer Specification.) If that fails to fix it, I've declared the card "dead".

    Overall Picks

    To get a list of top performers, I'm going to look at the top scores in the capacity and performance categories. For now, I'm not going to include any of the endurance data in here, as I still have incomplete data for all but a handful of cards.

    Here's how things shook out:

    So out of these scores, we can pick out the top 10 pretty easily:

    1. Kioxia Exceria G2 64GB
    2. Samsung PRO Endurance 32GB
    3. Samsung EVO Plus 64GB
    4. SanDisk Extreme 32GB
    5. Lexar Professional 1000x 64GB
    6. SanDisk Extreme 64GB
    7. Kingston Canvas Select 32GB
    8. SanDisk Extreme PRO 64GB
    9. Lexar Blue 633x 32GB
    10. SanDisk Extreme PRO 32GB

    This lines up pretty well with the results that I've been seeing -- so maybe my rating system isn't so bad after all.

    Individual Cards

    Below are the results that I've gotten from each brand/model of card -- in alphabetical order by brand/model/capacity -- along with a discussion indicating why I chose this card, things that I found out about the cards, things that happened during testing, etc. A few things to note as you peruse this list:

    • Prices paid are shown in US Dollars.
    • Prices paid include shipping to the United States. In instances where I ordered multiple items from the same seller, I've divided the shipping amount by the number of items I purchased to determine a per-item shipping price.
    • Priced paid do not include sales tax -- as sales tax in the US varies widely depending on where you live.
    • The data is organized by brand name. If all of the cards underneath that brand name have the same value for one of their attributes, I'll list it in the bulleted list. Otherwise, I'll list it in the table. (For example, if I obtained three of a particular brand, and I paid the same price for all three of them, I'll list it in the bulleted list. If I paid different prices for any of them, I'll show the prices in the table instead.
    • "Card reader used" indicates the card reader that was used for doing performance testing. In some cases, I've moved the card over to another card reader afterwards.
    • I'm not done testing everything! I'll update this page as I get more results.

    Amzwn 32GB

    • Obtained from: AliExpress
    • Price paid: $4.92
    • Advertised capacity: 32GB
    • Logical capacity: 31,954,305,024 bytes
    • Physical capacity: 31,954,305,024 bytes
    • Fake/skimpy flash: Skimpy (0.14% skimp)
    • Speed class markings: Class 10, U3, A2
    • CID data:
      • Manufacturer ID: 0x9f
      • OEM ID: 0x5449 (ASCII: TI)
      • Product name: 0x3030303030 (ASCII: 00000)
      • Product revision: 0x00
    Card #123Average
    Serial number0x000000260x0000001e0x00000011N/A
    Manufacture dateFeb 2023Feb 2023Feb 2023N/A
    Sequential read speed (MB/sec)22.7222.4322.7422.63
    Sequential write speed (MB/sec)12.4011.4812.1812.02
    Random read speed (IOPS/sec)1,060.511,149.89971.341060.58
    Random read speed (IOPS/sec)149.89166.74150.42155.68
    Read/write cycles to first errorNot yet determinedNot yet determined4141
    Read/write cycles to complete failureNot yet determinedNot yet determinedNot yet determinedNot yet determined
    Total days to complete failureNot yet determinedNot yet determinedNot yet determinedNot yet determined
    Card reader usedJJS CR-UTC4ACSmartQ SingleJJS CR-UTC4ACN/A
    Package frontN/A
    Package backN/A
    Card frontN/A
    Card backN/A

    Discussion

    Amzwn is a brand that appeared pretty frequently while I was browsing AliExpress -- both when searching for microSD cards, and as recommendations on other products. They appear to come in various sizes, ranging from 32GB to 256GB. At least one version of their card is labeled as "Amzwn basics", with an arrow similar to the "A to Z" arrow used in Amazon's logo appearing underneath Amzwn. Combined with the similarity to Amazon's name, this strongly suggests that they are hoping buyers will confuse them with Amazon.

    Overall, I wasn't terribly impressed with these cards. Read/write speeds were well below average, and not high enough to warrant any of the speed class marks that it bears, with the exception of the Class 10 mark. As of the time of this writing, samples #1 and #2 have not yet hit the 2,000 read/write cycle mark. (Sample #1 is expected to hit the 2,000 read/write cycle mark sometime in August 2024, while sample #2 is expected sometime in March 2024.) Sample #3 experienced a data shift error affecting 4 sectors during round 42, and has experienced occasional errors since then; it has survived 776 read/write cycles total. On the bright side, these cards were not fake flash; and while they were skimpy, they were definitely not the worst offenders.

    Last updated: 2/25/2024

    Auotkn Extreme 8GB

    • Obtained from: AliExpress
    • Price paid: $2.58
    • Advertised capacity: 8GB
    • Logical capacity: 8,053,063,680 bytes
    • Physical capacity: 8,053,063,680 bytes
    • Fake/skimpy flash: No
    • Speed class markings: U1, V10
    Card #123Average
    Manufacturer ID0x000xfe0xfeN/A
    OEM ID0x00000x3432 (ASCII: 42)0x3432 (ASCII: 42)N/A
    Product name0x534d492020 (ASCII: SMI)0x5344313647 (ASCII: SD16G)0x5344313647 (ASCII: SD16G)N/A
    Product revision0x000x200x20N/A
    Serial number0x000000000x000001af0x000007e1N/A
    Manufacture dateSep 2023Jun 2023Aug 2023N/A
    Sequential read speed (MB/sec)17.6068.4418.6334.89
    Sequential write speed (MB/sec)11.1319.7718.6916.53
    Random read speed (IOPS/sec)1,147.21385.88375.45636.18
    Random write speed (IOPS/sec)37.68172.01204.32138.00
    Read/write cycles to first error3,0135,449Not yet determined4,231
    Read/write cycles to complete failure4,773Not yet determinedNot yet determined4,773
    Total days to complete failure71Not yet determinedNot yet determined71
    Card reader usedJJS CR-UTC4ACJJS CR-UTC4ACJJS CR-UTC4ACN/A
    Package frontN/A
    Package backN/A
    Card frontN/A
    Card backN/A

    Discussion

    Auotkn is another brand that came up frequently while browsing AliExpress. The visual design is almost identical to that used by SanDisk's Extreme cards -- to the point where a casual observer from 10 feet away likely wouldn't notice the difference.

    I initially found it curious that the first two cards displayed such wildly different results on the performance test. It wasn't until I compared the CID data between the two -- which, admittedly, I didn't do until I was writing this up -- that I noticed that they are completely different. Initially I thought that maybe I got the CID data mixed up with one of my other cards -- after all, card #1 shared the same manufacturer ID, OEM ID, product name, and product revision as the one QEEDNS card I've tested, and sample #2 shared the same values as the Cloudisk and Bekit cards -- but after rechecking the data, it appears that I recorded it correctly the first time. This points to the conclusion that Auotkn may be in the middle of switching manufacturers. Or that they source their cards from multiple manufacturers. Or that they're reselling used cards. On second thought, maybe this doesn't point to any conclusion in particular.

    Regardless, the cards have performed well on their endurance tests. All three managed to endure well over 2,000 read/write cycles without any errors, making it only one of two models I've tested so far to do so. As of this writing, samples #2 and #3 are still chugging along: sample #2 has survived 10,615 read/write cycles (and did not experience any errors for the first 5,449 read/write cycles), while sample #3 has survived 5,222 read/write cycles without issues.

    What's that you say? You want to see a graph showing how many bad sectors were on sample #1 each round? Well OK then, but this one is going to be pretty boring:

    This card failed pretty quickly: it experienced a small error (only affecting two sectors) during round 3,013; it then went until round 4,772 without experiencing any more errors. During round 4,772, about 45% of the sectors on the card failed verification; during round 4,773, all of them failed verification -- at which point the 50% failure threshold was reached, and the endurance test was complete.

    Last updated: 2/25/2024

    Auotkn Extreme 512GB

    • Advertised capacity: 512GB
    • Speed class markings: U1, V10
    Card #123Average
    Obtained fromAliExpressAliExpressAliExpressN/A
    Manufacturer ID0x00UnknownNot yet testedN/A
    OEM ID0x0000UnknownNot yet testedN/A
    Product name0x4150505344 (ASCII: APPSD)UnknownNot yet testedN/A
    Product revision0x00UnknownNot yet testedN/A
    Serial number0x12800003UnknownNot yet testedN/A
    Manufacture dateMar 2023UnknownNot yet testedN/A
    Price paid$14.26$13.56$14.44$14.09
    Logical capacityUnknown536,871,960,576 bytesNot yet tested536,871,960,576 bytes
    Physical capacityUnknown31,596,637,696 bytesNot yet tested31,596,637,696 bytes
    Fake/skimpy flashUnknownFake flashNot yet testedN/A
    Sequential read speed (MB/sec)Unknown16.64Not yet tested16.64
    Sequential write speed (MB/sec)Unknown12.54Not yet tested12.54
    Random read speed (IOPS/sec)Unknown1,057.40Not yet tested1,057.40
    Random write speed (IOPS/sec)Unknown0.46Not yet tested0.46
    Read/write cycles to first error06Not yet tested3
    Read/write cycles to complete failure0164Not yet tested82
    Total days to complete failure017Not yet tested8.5
    Card reader usedN/APrograde Digital Dual-Slot Mobile ReaderNot yet testedN/A
    Package frontNot yet testedN/A
    Package backNot yet testedN/A
    Card frontNot yet testedN/A
    Card backNot yet testedN/A

    Discussion

    After deciding to test the Auotkn Extreme 8GB, I purchased a single 512GB card, as I was curious to see if I would find the same manufacturer selling genuine flash and fake flash.

    At first, I thought sample #1 was dead on arrival. The card was completely unresponsive whenever I plugged it in. I wasn't sure if these cards were defective by design or if I had simply received a bad card, but I decided to give it the benefit of the doubt and ordered another one -- from a different seller.

    Initially, sample #2 was also unresponsive. I was about ready to call it dead on arrival as well, but then I decided to try it with the Prograde reader -- and it worked. Unfortunately, I couldn't use the Prograde reader to read the registers from the card -- I'm only able to do that with the Realtek reader -- so I wasn't able to read the CID data from this card.

    As I started working on my FPGA design, however, I decided to try out card #1 to see what it would do when the FPGA tried to initialize it. At first, the FPGA complained that the card sent back a response with a bad CRC. I had my logic analyzer hooked up to it, so I decided to do a capture and look at the communications going between my card and the FPGA. This is the command and response where my FPGA was telling me the response had a bad CRC:

    Next, I hooked up one of my working cards and captured the same transaction with that one as well:

    If you don't know what you're looking at: the top row (the blue signal) is the clock signal that my FPGA is sending to the card. The bottom row (the green signal) is the "CMD" line -- it's a bidirectional line that the host uses to send commands to the card, and that the card uses to respond to those commands. Coding is NRZL (basically -- a high level represents a 1, a low level represents a 0). In the screenshots, the command and response start at the green dot and end at the red dot.

    So as I stared at these captures, I was confused: they looked identical to me. Was the Auotkn sending back voltage levels that were enough for my logic analyzer to detect, but not enough for my FPGA to detect? Was there something wrong with the way I was calculating CRCs? Did a random wire get disconnected from my breadboard?

    Eventually I decided to enable the signal tap logic analyzer, which lets you essentially see the signals that the FPGA is seeing -- it's kind of a debugger for the FPGA. I set it to trigger at the point where my card starts to listen for the response from the card, and here's what I got:

    What you're seeing in the screenshot above is the FPGA's view of the signals going back and forth over the card's CMD line. The "0" represents the point where it started listening for the reply.

    And seeing this, I suddenly realized what the issue was. When the card sends a reply back to the host, it's supposed to start it with 00 (the first bit is a "start" bit, and the other bit indicates the direction -- 0 for card to host, and 1 for host to card). However, my FPGA took a few clock cycles to switch from "sending mode" to "receiving mode", and it didn't have a chance to switch over to "receiving mode" until after the card sent the first bit of its reply back. The card was simply replying back too quickly! I adjusted my design to let the FPGA start listening for the reply sooner -- and whaddya know, it was able to communicate with the card successfully, and I was able to query it for its CID! The CID data I have shown above is what I obtained from this process. I haven't gotten my FPGA design to the point where it can do performance tests, however...so that will have to wait for another day.

    This discovery led me to wonder -- did my other card readers have this same deficiency in their design? Were they simply not starting to listen for the card's reply soon enough? As far as I can tell, the SD card specification doesn't say how many clock cycles the card is supposed to wait before replying back to the host, so I imagine the engineers that designed these card reader ICs never had to specifically think about this issue. I imagine I'll probably never know for sure.

    As I haven't been able to do performance testing with sample #1, I only have results from sample #2 -- and I have to say, they were pretty unimpressive. Unsurprisingly, this card's physical capacity was not 512GB; its actual capacity was closer to 32GB. The sequential read/write speeds were barely enough to qualify for the U1 and V10 markings that it carries. Additionally, this card only lasted a few read/write cycles before it began showing data mismatch errors; and when it started failing, it failed quickly. By the time the card reached 164 read/write cycles, over half of the sectors on the card had been flagged as bad due to data mismatches.

    I do find it interesting to look at exactly what symptoms a card shows when it starts to fail. In this case, some sectors showed a number of bit flips; others simply read back as all ff's.

    Here's what the track record for this sample looks like:

    As you can see, this sample's endurance test went as follows:

    • A few rounds of nothing (or practically nothing);
    • A sudden jump to "halfway to the 50% failure threshold";
    • A slow rise in the number of bad sectors for about the next 150 read/write cycles;
    • A sudden jump to "almost 50% of the sectors have failed";
    • And finally, the card becomes unresponsive.

    Given that there are better 32GB cards for less than what I paid, I haven't been inclined to buy a third card so far. (Edit: In the interest of trying to evaluate at least three samples of every model that I've tested, I have a third sample on the way.)

    Last updated: 2/25/2024

    Bekit 8GB

    • Obtained from: AliExpress
    • Price paid: $3.46
    • Advertised capacity: 8GB
    • Logical capacity: 8,032,092,160 bytes
    • Physical capacity: 8,032,092,160 bytes
    • Fake/skimpy flash: No
    • Speed class markings: Class 6, U1
    • CID data:
      • Manufacturer ID: 0xfe
      • OEM ID: 0x3432 (ASCII: 42)
      • Product name: 0x5344313647 (ASCII: SD16G)
      • Product revision: 0x20
      • Manufacture date: Nov 2022
    Card #123Average
    Serial number0x000002c6Unknown0x00000296N/A
    Sequential read speed (MB/sec)90.62Unknown87.5889.10
    Sequential write speed (MB/sec)20.66Unknown21.3220.99
    Random read speed (IOPS/sec)828.80Unknown455.90642.35
    Random write speed (IOPS/sec)236.03Unknown187.68211.86
    Read/write cycles to first error1,5720Not yet determined785
    Read/write cycles to complete failure1,5820Not yet determined790
    Total days to complete failure140Not yet determined7
    Card reader usedJJS CR-UTC4AC*N/AJJS CR-UTC4ACN/A
    Package frontN/A
    Package backN/A
    Card frontN/A
    Card backN/A

    * I think. I didn't specifically write down which card reader I used on any given card, so some of this is going off of memory, and some of it is going off of what the card is plugged into right now.

    Discussion

    This brand took a little bit more digging to find, but once it came up, the colorful design caught my attention. What can I say. (Squirrel!)

    Performance was good enough to merit the speed class marks it bore, and it approached the maximum practical sequential read speed for a UHS-I-compatible card, but sequential write speeds and random I/O speeds were disappointing. Sequential read speeds were above average, but all other performance metrics were below average. Sample #3 had a random read speed that was more than one standard deviation below average.

    Sample #1 lasted just shy of 1,600 read/write cycles before it failed. Just before failure (starting with round 1,573), it experienced a few rounds where a handful of sectors had data mismatch errors. However, during round 1,583, the device spontaneously changed capacity to 127MB (specifically, to 127,139,840 bytes). At that point, I decided to consider it "dead". I'll note that in versions 2 and 3 of the CSD register specification, the size of the card is indicated by adding 1 to the value of the C_SIZE field, then multiplying it by 524,288. Since 127,139,840 is not a multiple of 524,288, it suggests that (at least) the portion of the card controller's code responsible for populating the CSD register was corrupted, possibly causing it to report that it was using version 1 of the CSD register specification instead.

    Here's what the track record for the endurance tests for sample #1 looked like:

    Interestingly, sample #2 also reported its capacity as 127MB right out of the package. Given that the other two cards initially reported their capacities correctly -- and the fact that it would not respond to commands when plugged into my Realtek reader -- I decided to declare this card "dead on arrival".

    Sample #3. on the other hand, is doing quite well: it has survived 9.153 read/write cycles without issue, and is still chugging along. So I guess 1 out of 3 is...better than nothing?

    Overall, I was impressed by the fact that the card did well on sequential read speeds, but this appears to be where its advantages end. The sequential write speeds and random I/O speeds were all below average, and endurance for 2 out of the 3 cards was below expectations.

    Last updated: 2/25/2024

    Chuxia 32GB

    • Obtained from: AliExpress
    • Price paid: $5.78
    • Advertised capacity: 32GB
    • Logical capacity: 31,719,424,000 bytes
    • Physical capacity: 31,719,424,000 bytes
    • Fake/skimpy flash: Skimpy (0.88% skimp)
    • Speed class markings: Class 10, U1, V10, A1
    • CID data:
      • Manufacturer ID: 0xad
      • OEM ID: 0x4c53 (ASCII: LS)
      • Product name: 0x5553443030 (ASCII: USD00)
      • Product revision: 0x10
      • Manufacture date: Apr 2023
    Card #123Average
    Serial number0x438508270x43731a750x43320716N/A
    Sequential read speed (MB/sec)51.8979.6630.5954.05
    Sequential write speed (MB/sec)17.9623.2518.0219.74
    Random read speed (IOPS/sec)556.664,429.84444.001,810.17
    Random write speed (IOPS/sec)703.031,000.08574.58759.23
    Read/write cycles to first error1,383Not yet determined113748
    Read/write cycles to complete failureNot yet determinedNot yet determinedNot yet determinedNot yet determined
    Total days to complete failureNot yet determinedNot yet determinedNot yet determinedNot yet determined
    Card reader usedSmartQ DuoJJS CR-UTC4ACJJS CR-UTC4ACN/A
    Package frontN/A
    Package backN/A
    Card frontN/A
    Card backN/A

    Discussion

    Chuxia is another brand that took a little bit more digging to find, but caught my attention because of its original design.

    I'm honestly not sure why I got such wildly different results between the different samples, especially on the random read test. If the random read speed for sample #2 is accurate, it would be the highest random read speed of any card I've tested so far. I should take sample #2 and put it into one of the SmartQ Duos to see if it performs similarly to sample #1; however, I don't have any free at the moment. As it stands right now, however, all three samples performed well enough to qualify for the Class 10, U1, and V10 markings; however, only sample #2 performed well enough for the A1 marking.

    Endurance results for these cards were not too great. All three are still undergoing endurance testing; however, two of the three experienced errors before hitting the 2,000 read/write cycle mark: sample #1 only made it 1,383 read/write cycles before encountering its first error, while sample #3 only made it 113 read/write cycles. Sample #2, however, has completed 4,225 read/write cycles without errors, and is still going strong.

    Last updated: 2/25/2024

    Cloudisk 32GB

    • Obtained from: AliExpress
    • Price paid: $3.52
    • Advertised capacity: 32GB
    • Logical capacity: 31,457,280,000 bytes
    • Physical capacity: 31,457,280,000 bytes
    • Fake/skimpy flash: Skimpy (1.70% skimp)
    • Speed class markings: Class 10, U1, A1
    • CID data:
      • Manufacturer ID: 0xfe
      • OEM ID: 0x3432 (ASCII: 42)
      • Product name: 0x5344313647 (ASCII: SD16G)
      • Product revision: 0x20
      • Manufacture date: Jul 2023
    Card #123Average
    Serial number0x00000ba20x00000bb40x00000b9eN/A
    Sequential read speed (MB/sec)83.1737.0840.3653.54
    Sequential write speed (MB/sec)23.1423.7523.2223.37
    Random read speed (IOPS/sec)495.66719.31540.54585.17
    Random write speed (IOPS/sec)174.86143.62150.28156.25
    Read/write cycles to first error2,0771,516Not yet determined1,797
    Read/write cycles to complete failure2,1882,279Not yet determined2,234
    Total days to complete failure14289Not yet determined115.5
    Card reader usedSmartQ DuoJJS CR-UTC4ACJJS CR-UTC4ACN/A
    Package frontNot availableN/A
    Package backNot availableNot availableNot availableN/A
    Card frontN/A
    Card backN/A

    Discussion

    This card was unusual in the fact that it did not come in a retail package -- instead, it came in a simple plastic case.

    All three samples performed well enough on the performance tests to qualify for the Class 10 and U1 markings; however, none of them performed well enough to qualify for the A1 marking. As we've established previously, my tests don't conform to the tests described in the SD Physical Layer Specification -- so maybe these cards would have performed better under the right conditions...but somehow I doubt it (especially seeing as how I have other cards that did perform well enough to qualify for the A1 marking).

    Sample #1 did make it past the 2,000 read/write cycle mark without encountering any errors -- but just barely. Its track record was pretty boring -- but here it is:

    Like I said, it's pretty boring: nothing happens until round 2,077 -- where barely anything happens -- and then nothing happens for another 100 rounds or so before the card becomes unresponsive.

    Sample #2 encountered its first error after 1,516 read/write cycles. I finally declared it dead at the end of round 2,279, when the number of bad sectors reached the 50% threshold. Here's what its progress graph looked like:

    Sample #3, however, has not yet reached the 2,000 read/write cycle mark. At the rate it's going, it will probably be sometime in May 2024 before it gets to that point.

    Last updated: 2/25/2024

    Gigastone 32GB

    • Obtained from: Amazon
    • Price paid: $6.48
    • Advertised capacity: 32GB
    • Logical capacity: Unknown
    • Physical capacity: Unknown
    • Fake/skimpy flash: Unknown, but definitely not fake flash
    • Speed class markings: Class 10, U1
    • CID data:
      • Manufacturer ID: Unknown
      • OEM ID: Unknown
      • Product name: Unknown
      • Product revision: Unknown
      • Manufacture date: Unknown
      • Serial number: Unknown
    • Sequential read speed (MB/sec): Unknown
    • Sequential write speed (MB/sec): Unknown
    • Random read speed (IOPS/sec): Unknown
    • Random write speed (IOPS/sec): Unknown
    • Read/write cycles to first error: 1,785
    • Read/write cycles to total failure: 1,785
    • Total days to complete failure: 58
    • Card reader used: Probably a SmartQ Single
    • Package front: Not available
    • Package back: Not available
    • Card front:
    • Card back:

    Discussion

    I had tried to start this project a couple years back, but I lost track of some of the SD cards I purchased for the project. Instead of simply buying new ones, I was determined to figure out what happened to them -- and lost interest in the project after I failed to locate them. Back then, my goals and methods were not as well defined, and thus I don't have as much data on this card as I do on many of the others. This is more of an honorable mention than anything -- however, I did include the endurance data for this card in my overall results.

    I'll note that capacity was determined using f3probe, and endurance figures were determined using stressdisk. I don't recall what the card's exact capacity was, only that it was roughly 32GB -- close enough to be considered "not fake flash". In addition, while my other test rigs are laptops using Intel Core i7 processors, this card was tested on a Rock64 single-board computer, so it's possible that CPU speeds could have been a bottleneck on performance. While I didn't run proper speed tests, stressdisk did periodically log the average read/write speeds that it had been seeing -- and the last numbers it recorded before the card failed were a read speed of 80.66MB/sec and a write speed of 23.74MB/sec. If this had represented a proper sequential I/O test, it would put it slightly above average for read speeds, but slightly below average for write speeds. It is good enough to qualify for the Class 10 and U1 markings that it bore.

    The notable disadvantage to using stressdisk is that it operates at the filesystem level -- it writes files of a predetermined size to the filesystem, then reads them back in a random order. This means that it's not able to evenly test the entire user area of the flash, as space for things directory structures, file allocation tables, boot sectors, etc., would get written to at a different frequency than the test files. It's possible that this card would have behaved slightly differently -- perhaps it would have failed sooner or later than it did -- had the entire user area of the card been tested evenly instead. Stressdisk also deleted any partial files that it wrote (e.g., due to running out of space on the card) without verifying them -- so any data integrity errors in the portion of the card occupied by that space would have gone undetected. This is not to say that there is not value in testing a card using a tool like stressdisk -- it could be argued that the type of test run by stressdisk better simulates how something like a digital camera or digital video camera would use a card. However, for my purposes, I want to make sure the entire user area of the card is tested. That said, however, this card was able only able to endure 1,785 read/write cycles before it failed. Once it failed, it became completely unresponsive to commands from the reader.

    Last updated: 2/25/2024

    Hiksemi NEO 8GB

    • Obtained from: AliExpress
    • Price paid: $1.03
    • Advertised capacity: 8GB
    • Logical capacity: 7,989,624,832 bytes
    • Physical capacity: 7,989,624,832 bytes
    • Fake/skimpy flash: Skimpy (0.13% skimp)
    • Speed class markings: Class 10
    • CID data:
      • Manufacturer ID: 0x6f
      • OEM ID: 0x0303
      • Product name: 0x4342414453 (ASCII: CBADS*)
      • Product revision: 0x10
      • Manufacture date: Mar 2023

    * Keen-eyed observers might note that other cards in my survey have a product name of SDABC, and that this is simply that, but backwards. I wonder if there's an inside joke here?

    Card #123Average
    Serial number0xaa03666f0xaa009e750xaa00394eN/A
    Sequential read speed (MB/sec)89.4991.1490.6290.42
    Sequential write speed (MB/sec)47.0949.3749.9548.80
    Random read speed (IOPS/sec)2,150.541,607.761,626.131,794.81
    Random write speed (IOPS/sec)638.39492.78335.29488.82
    Read/write cycles to first errorNot yet determined3Not yet determined3
    Read/write cycles to complete failureNot yet determined5,917Not yet determined5,917
    Total days to complete failureNot yet determined35Not yet determined35
    Card reader usedSmartQ DuoJJS CR-UTC4AC*JJS CR-UTC4ACN/A
    Package frontN/A
    Package backNot availableN/A
    Card frontN/A
    Card backN/A

    * I think

    Discussion

    When I first started searching for SD cards on AliExpress, I decided to sort by price from lowest to highest -- and Hiksemi was a result that came up near the top of the list. They sell the 8GB card for just $0.01 -- but that's before shipping. Still, I have to say that it's a pretty effective strategy for getting people's attention, and the card is still an excellent value even when factoring in shipping costs.

    Honestly, though, I have to say that I was pleasantly surprised by Hiksemi's cards as a whole. This card's only speed class marking is a Class 10 mark, which it easily qualified for. Sequential read and write speeds were well above average (with sequential read speeds being towards the high end of the spectrum). Random read speeds were average (with sample #1 being above average, and samples #2 and #3 being slightly below average), and random write speeds were all above average.

    Endurance is where these cards have really shined. As of the time of this writing, sample #1 has survived 37,041 read/write cycles without any errors -- far outpacing any other card in my collection thus far. Sample #3 has survived 5,599 read/write cycles without any errors.

    Sample #2 had a 32 sector data mismatch error during round 3; however, it did not experience any further errors until round 5,918. During this round, a large number of sectors began experiencing data mismatch errors, with a significant portion of those sectors reading back as all 0xff's. The number of sectors that experienced data mismatch errors exceeded 50% of the total sectors on the card during this round, causing the test to end. The progress graph for this sample is going to be pretty boring, but here it is:

    Last updated: 2/25/2024

    Hiksemi NEO 32GB

    • Obtained from: AliExpress
    • Price paid: $1.93
    • Logical capacity: 31,271,157,760 bytes
    • Physical capacity: 31,271,157,760 bytes
    • Fake/skimpy flash: Skimpy (2.28% skimp)
    • Speed class markings: V10
    • CID data:
      • Manufacturer ID: 0x6f
      • OEM ID: 0x0305
      • Product name: 0x455a534431 (ASCII: EZSD1)
      • Product revision: 0x10
      • Manufacture date: Apr 2023
    Card #123Average
    Obtained fromAliExpressAliExpressAliExpressN/A
    Price paid$1.93$1.93$6.61$3.49
    Manufacture dateApr 2023Apr 2023Not yet testedN/A
    Serial number0xaa03c26c0xaa020f88Not yet testedN/A
    Sequential read speed (MB/sec)89.2090.85Not yet tested90.03
    Sequential write speed (MB/sec)27.1038.61Not yet tested32.86
    Random read speed (IOPS/sec)2,001.521,790.34Not yet tested1,895.93
    Random write speed (IOPS/sec)402.03360.17Not yet tested381.10
    Read/write cycles to first errorNot yet determined1,939Not yet tested1,939
    Read/write cycles to complete failureNot yet determinedNot yet determinedNot yet testedNot yet determined
    Total days to complete failureNot yet determinedNot yet determinedNot yet testedNot yet determined
    Card reader usedSmartQ SingleJJS CR-UTC4ACNot yet testedN/A
    Package frontNot yet testedN/A
    Package backNot availableNot yet testedN/A
    Card frontNot availableNot yet testedN/A
    Card backNot availableNot yet testedN/A

    Discussion

    While not quite as impressive as their smaller siblings, these cards are still pretty impressive overall. Its main disadvantage is that it didn't do as well on sequential write speeds -- they were only average. The only reason I ordered two instead of three is that at the time, AliExpress only allowed me to buy two. (Edit: I have a third one on the way.)

    Sample #1 is currently plugged into a SmartQ Single reader. As I noted earlier, I've had problems with these readers randomly failing every few days -- and this one has been no exception. I have code to allow the program to wait for the device to be reconnected and resume the endurance test; however, it took me a while to get the code right. This card did technically suffer some data verification errors, but I chalked them up to this issue -- as of this writing, it has completed 6,730 read/write cycles, and has not suffered any further data verification issues since fixing my code (about 2,000 read/write cycles ago). Sample #2 just barely missed the 2,000 read/write cycle mark -- it experienced a 64 sector wide data verification error during round 1,940. It has endured 2,133 read/write cycles total so far, and has not experienced any other errors since then.

    Last updated: 2/25/2024

    Hiksemi NEO 128GB

    • Obtained from: AliExpress
    • Advertised capacity: 128GB
    • Logical capacity: 125,085,155,328 bytes
    • Physical capacity: 125,085,155,328 bytes
    • Fake/skimpy flash: Skimpy (2.28% skimp)
    • Speed class markings: V30
    • CID data:
      • Manufacturer ID: 0x6f
      • OEM ID: 0x0305
      • Product name: 0x455a534431 (ASCII: EZSD1)
      • Product revision: 0x10
    Card #123Average
    Price paid$3.89$3.89$7.01$4.93
    Serial number0xaa005ac10xaa00b8530xaa00b386N/A
    Manufacture dateFeb 2023Feb 2023Feb 2023N/A
    Sequential read speed (MB/sec)79.2491.2690.0586.85
    Sequential write speed (MB/sec)50.7551.0350.1150.63
    Random read speed (IOPS/sec)2087.431782.331906.431925.40
    Random write speed (IOPS/sec)438.58431.70463.22444.50
    Read/write cycles to first errorNot yet determined109Not yet determined109
    Read/write cycles to complete failureNot yet determinedNot yet determinedNot yet determinedNot yet determined
    Total days to complete failureNot yet determinedNot yet determinedNot yet determinedNot yet determined
    Card reader usedPlatinum PT-CRSA1JJS CR-UTC4ACJJS CR-UTC4ACN/A
    Package frontN/A
    Package backN/A
    Card frontN/A
    Card backN/A

    Discussion

    After being initially impressed by the Hiksemi NEO 8GB, I went back to see what other options Hiksemi had available. I must have caught the 128GB while it was on sale (or mispriced), because they were priced at only $1.74 before shipping. Even after shipping, these cards are still an excellent value, coming out to just over 3 cents per gigabyte. The only reason why sample #3 was more expensive is because I gave one to a friend, then went back and re-ordered a replacement; the price had gone up in the meantime.

    On the performance front, this is another instance where it feels like Hiksemi undersold the performance of their cards; both samples I've tested so far easily surpassed the benchmark for the V30 mark. Sequential write speeds on all three samples were more than one standard deviation above the average.

    All three samples are still undergoing endurance testing. These cards will obviously take longer to complete their endurance test given their size relative to the others in the survey. Sample #1 made it past the 2,000 read/write cycle mark -- it has endured 2,066 read/write cycles without error so far. Sample #2 experienced a two sector wide data verification error during round 110; it has survived 654 read/write cycles in total so far and has not experienced any further errors since then. Sample #3 has not yet hit the 2,000 read/write cycle mark -- at the rate it's going, it's not expected to get there until sometime in July 2025.

    Overall, I feel like Hiksemi has been an unexpected standout among the cards I've tested. They're priced very competitively, and perform as well as -- or even better than -- many of their name-brand competitors.

    Last updated: 2/25/2024

    Kingston Canvas Select Plus 32GB

    • Advertised capacity: 32GB
    • Logical capacity: 30,945,574,912 bytes
    • Physical capacity: 30,945,574,912 bytes
    • Fake/skimpy flash: Skimpy (3.30% skimp)
    • Speed class markings: Class 10*, U1, V10, A1
    • CID data:
      • Manufacturer ID: 0x27**
      • OEM ID: 0x5048 (ASCII: PH)**
      • Product name: 0x5344333247 (ASCII: SD32G)
      • Product revision: 0x60

    * The Class 10 mark appears on the product packaging, but does not appear on the card itself.

    ** This manufacturer ID/OEM ID is well known to be associated with Phison Electronics Corporation.

    Card #123456Average
    Obtained fromAmazonAliExpressAmazonAliExpressAmazonAliExpressN/A
    Price paid$8.30$4.48$8.30$4.48$8.30$4.48$6.39
    Manufacture dateFeb 2023May 2023Feb 2023May 2023Feb 2023May 2023N/A
    Serial number0x6c5202a60x01af97810x6c5202f60x01aab8230x6c51ea110x01af8750N/A
    Sequential read speed (MB/sec)91.3690.9291.2386.3090.8391.4890.35
    Sequential write speed (MB/sec)38.2842.5836.4240.6236.9540.6239.25
    Random read speed (IOPS/sec)2215.152390.592072.703729.202407.142334.702524.91
    Random write speed (IOPS/sec)590.49638.31580.48688.02588.55633.21619.84
    Read/write cycles to first error479Not yet determinedNot yet determined2,7291265835
    Read/write cycles to complete failureNot yet determinedNot yet determinedNot yet determinedNot yet determinedNot yet determinedNot yet determinedNot yet determined
    Total days to complete failureNot yet determinedNot yet determinedNot yet determinedNot yet determinedNot yet determinedNot yet determined76.17
    Card reader usedLexar LRWM05U-7000JJS CR-UTC4ACJJS CR-UTC4ACJJS CR-UTC4ACJJS CR-UTC4ACJJS CR-UTC4ACN/A
    Package frontN/A
    Package backN/A
    Card frontN/A
    Card backN/A

    Discussion

    I have something of a bias against Kingston cards. I have a number of single-board computers that use microSD cards as their boot device; and while I've typically used SanDisk cards for this, occasionally a Kingston card or two has found its way into the mix, and it seems like the Kingston cards have always failed long before any of the SanDisk cards have. Because of this, I wanted to give them a fair chance to prove themselves -- so I purchased three from Amazon and three from AliExpress.

    The US and Chinese versions of the cards are -- as far as I can tell -- identical. The cards look physically the same (with an interesting color shifting stripe on one edge of the card), and the CID data (with the exception of the manufacture date and serial number) is identical. The only difference seems to be the packaging.

    Curiously, there's a notable difference between the US and Chinese versions of the packaging: the Chinese packaging is not tamper-evident. The card can be accessed by opening a simple flap on the front of the package; the card can be replaced, and the flap closed, without causing any damage to the packaging. If I were selling these in a retail store, I'd be forced to have them locked up in some fashion (security box, glass case, behind the counter, etc.) to make sure that unscrupulous customers couldn't tamper with the packaging and its contents before purchase.

    Performance-wise, these cards actually did rather well. All cards scored above average in all performance metrics, with random write speeds for all cards being more than one standard deviation above average. All cards easily met the thresholds for all of the performance marks that they bore.

    These cards are later additions to my collection; as such, they are still undergoing endurance testing. As of this writing:

    • Sample #1 experienced a data shift error during round 480. It has survived 3,150 read/write cycles in total so far, and has not experienced any further errors since then.
    • Sample #2 has not yet hit the 2,000 read/write cycle mark. It is currently expected to get there sometime in late March 2024.
    • Sample #3 has not yet hit the 2,000 read/write cycle mark. It is currently expected to get there near by the end of February 2024.
    • Sample #4 experienced a data shift error during round 2,729. It has survived 5,625 read/write cycles total so far, and has been experiencing errors occasionally since.
    • Sample #5 experienced a data shift error during round 127. It has survived 1,894 read/write cycles in total so far, and has experienced a few additional data shift errors since then.
    • Sample #6 experienced a data shift error during round 6. It has survived 1,895 read/write cycles in total since then, and has suffered occasional data shift errors since then.

    So how well have these cards performed overall? Performance-wise, they've done great -- they have some of the fastest random read and write speeds out of any of the cards I've tested. Endurance, however, is another story -- 2/3 of them have experienced errors before hitting the 2,000 read/write cycle mark, and the jury is still out on the remaining ones.

    Last updated: 2/25/2024

    Kioxia Exceria 32GB

    • Obtained from: Amazon
    • Price paid: $11.49
    • Advertised capacity: 32GB
    • Logical capacity: Unknown
    • Physical capacity: Unknown
    • Fake/skimpy flash: Unknown, but definitely not fake flash
    • Speed class marks*: C10**, U1
    • CID data:
      • Manufacturer ID: Unknown
      • OEM ID: Unknown
      • Product name: Unknown
      • Product revision: Unknown
      • Manufacture date: Unknown
      • Serial number: Unknown
    • Sequential read speed (MB/sec): Unknown
    • Sequential write speed (MB/sec): Unknown
    • Random read speed (IOPS/sec): Unknown
    • Random write speed (IOPS/sec): Unknown
    • Number of read/write cycles to first error: 2,568
    • Number of read/write cycles to complete failure: 2,568
    • Total days to complete failure: 66
    • Card reader used: Probably a SmartQ single
    • Package front: Not available
    • Package back: Not available
    • Card front: Not available
    • Card back: Not available

    * I don't have the card (or the package) any longer, so this information is based on the pictures on Amazon.

    ** The Class 10 marking appears on the product packaging, but does not appear on the card itself.

    Discussion

    This card is another one that I purchased a couple years back when I first intended to start this project, so it's primarily here as an honorable mention. I didn't record the card's actual capacity, but I don't recall it being fake flash.

    As with the Gigastone card earlier, I used a combination of f3probe and stressdisk to test this card. The logs from stressdisk indicate that the average read speed at the time of failure was 86.74MB/sec, while the average write speed was 18.38MB/sec. While the write speeds are not great, this would be enough to qualify for both the Class 10 and U1 markings. However, keep in mind that this card was tested using an Orange Pi 4 -- so like the Gigastone, it's possible that the limited CPU speed could have been a bottleneck when testing this card.

    This card endured 2,568 read/write cycles before failing -- making it past the 2,000 read/write cycle minimum that I've established. The test ended when the card made itself read-only; stressdisk did not note any data mismatch errors before that point. I have to wonder if this was an intended behavior, or if some other issue occurred that caused the card to make itself read-only. If it was an intended behavior, it would be useful in that it would give a user the opportunity to retrieve their data off of a failing card before it failed completely.

    Last updated: 2/25/2024

    Kioxia Exceria G2 64GB

    • Obtained from: AliExpress
    • Price paid: $4.79*
    • Advertised capacity: 64GB
    • Logical capacity: 61,891,149,824 bytes
    • Physical capacity: 61,891,149,824 bytes
    • Fake/skimpy flash: Skimpy (3.30% skimp)
    • Speed class markings: Class 10, U30, V30, A1
    • CID data:
      • Manufacturer ID: 0x02**
      • OEM ID: 0x544d (ASCII: TM)**
      • Product name: 0x5345303634 (ASCII: SE064)
      • Product revision: 0x89

    * The price shown is for the 32GB version. See the discussion for more information.

    ** This manufacturer ID/OEM ID is well known to be associated with Toshiba/Kioxia.

    Card #123Average
    Serial number0xf4847fb30xf484c2b30xf484c1b3N/A
    Manufacture dateOct 2022Oct 2022Oct 2022N/A
    Sequential read speed (MB/sec)87.7991.1194.0590.98
    Sequential write speed (MB/sec)50.9350.0362.0654.34
    Random read speed (IOPS/sec)3416.562294.912367.292692.92
    Random write speed (IOPS/sec)826.33610.67683.05706.68
    Read/write cycles to first error5,109895Not yet determined895
    Read/write cycles to complete failureNot yet determinedNot yet determinedNot yet determinedNot yet determined
    Total days to complete failureNot yet determinedNot yet determinedNot yet determinedNot yet determined
    Card reader usedSmartQ SingleJJS CR-UTC4ACJJS CR-UTC4ACN/A
    Package frontN/A
    Package backNot availableN/A
    Card frontN/A
    Card backNot availableN/A

    Discussion

    First things first -- I actually ordered the 32GB version; the seller sent me the 64GB version. I don't know if the seller simply made a mistake or if they were out of the 32GB version and sent me the 64GB as a replacement -- but whatever. Free upgrade!

    Performance-wise, these cards actually did rather well. All three cards had sequential write and random write speeds that were more than one standard deviation above average. Sample #3 had the highest sequential write speed out of any of the cards in my collection, and sample #1 actually had random write speeds that were more than two standard deviations above average!

    As of this writing, all three cards are still undergoing endurance testing. Sample #1 has experienced errors, but it made it well past the 2,000 read/write cycle mark before doing so -- its first error was during round 5,110, and it has survived 5,217 read/write cycles overall so far. Sample #2 survived 895 read/write cycles before it experienced a data mismatch error; however, the error only affected 8 sectors and has not recurred since. It has currently survived 2,308 read/write cycles so far. Sample #3 has not yet hit the 2,000 read/write cycle mark; it is currently expected to get there sometime in late March 2024.

    Last updated: 2/25/2024

    Kioxia Exceria Plus 32GB

    • Obtained from: AliExpress
    • Price paid: $8.19
    • Advertised capacity: 32GB
    • Logical capacity: 30,937,186,304 bytes
    • Physical capacity: 30,937,186,304 bytes
    • Fake/skimpy flash: Skimpy (3.32% skimp)
    • Speed class markings: Class 10*, U3, V30, A1*
    • CID data:
      • Manufacturer ID: 0x02**
      • OEM ID: 0x544d (ASCII: TM)**
      • Product name: 0x5545304441 (ASCII: UE0DA)
      • Product revision: 0x71

    * The Class 10 and A1 markings appear on the product packaging, but do not appear on the card.

    ** This manufacturer ID/OEM ID combination is pretty well known to be associated with Toshiba/Kioxia.

    Sample #123Average
    Manufacture dateMar 2020Mar 2020Not yet testedN/A
    Serial number0xecb7cbb30xecb7b3b3Not yet testedN/A
    Sequential read speed (MB/sec)74.9369.04Not yet tested71.99
    Sequential write speed (MB/sec)49.3448.21Not yet tested48.78
    Random read speed (IOPS/sec)1,251.781,356.44Not yet tested1,304.11
    Random write speed (IOPS/sec)487.09530.83Not yet tested508.96
    Read/write cycles to first errorNot yet determinedNot yet determinedNot yet testedNot yet determined
    Read/write cycles to complete failureNot yet determinedNot yet determinedNot yet testedNot yet determined
    Total days to complete failureNot yet determinedNot yet determinedNot yet testedNot yet determined
    Card reader usedJJS CR-UTC4ACJJS CR-UTC4ACNot yet testedN/A
    Package frontNot yet testedN/A
    Package backNot yet testedN/A
    Card frontNot yet testedN/A
    Card backNot yet testedN/A

    Discussion

    The Kioxia Exceria G2's performed well in all of the performance tests, which made me curious to see what else Kioxia had to offer.

    I was a little surprised to see this card set a new record for skimp in a non-fake flash card, coming at 3.32% -- beating out the previous contender, the Kioxia Exceria G2, at 3.30%. I was also a little surprised to see it perform worse in all performance metrics than the Kioxia Exceria G2. It did, however, perform more than one standard deviation above average in sequential write speeds, and above average in random write speeds, but only average in sequential read speeds and below average in random read speeds.

    The card bears the U3 and V30 marks, and performance was enough to qualify for these marks. The package also bears the Class 10 and A1 marks; and while performance was good enough to qualify for the Class 10 mark, it wasn't good enough to qualify for the A1 mark. Interestingly, most other cards that bear the A1 mark have less trouble meeting the threshold for random read operations, and more trouble meeting the threshold for random write operations. This card was the opposite: sample #2 met the 500 random write operations per second threshold, and sample #1 came within 3% of that threshold. Random read scores, on the other hand, were farther off the mark.

    Endurance tests for these cards are still ongoing. Samples #1 and #2 have not yet hit the 2,000 read/write cycle mark. Both are currently expected to reach that point sometime in mid-April 2024. Sample #3 is still in the package waiting to be tested.

    Last updated: 2/25/2024

    Kodak Ultra Performance 32GB

    • Obtained from:
    • Price paid: $7.47
    • Advertised capacity: 32GB
    • Logical capacity: 31,164,727,296 bytes
    • Physical capacity: 31,164,727,296 bytes
    • Fake/skimpy flash: Skimpy (2.61% skimp)
    • Speed class markings: Class 10, U3, V30, A1
    • CID data:
      • Manufacturer ID: 0x9f
      • OEM ID: 0x5449 (ASCII: TI)
      • Product name: 0x3030303030 (ASCII: 00000)
      • Product revision: 0x00
    • Sequential read speed (MB/sec): 88.95
    • Sequential write speed (MB/sec): 13.43
    • Random read speed (IOPS/sec): 1709.83
    • Random write speed (IOPS/sec): 187.58
    • Read/write cycles to first error: Not yet determined
    • Read/write cycles to complete failure: Not yet determined
    • Card reader used: SmartQ Single*
    Sample #123Average
    Obtained fromAliExpressAliExpressAliExpressN/A
    Price paid$7.47$1.79$1.79$3.68
    Serial number0xb8201f91Not yet testedNot yet testedN/A
    Manufacture dateJun 2023Not yet testedNot yet testedN/A
    Sequential read speed (MB/sec)88.95Not yet testedNot yet tested88.95
    Sequential write speed (MB/sec)13.43Not yet testedNot yet tested13.43
    Random read speed (IOPS/sec)1,709.83Not yet testedNot yet tested1,709.83
    Random write speed (IOPS/sec)187.58Not yet testedNot yet tested187.58
    Read/write cycles to first errorNot yet determinedNot yet testedNot yet testedNot yet determined
    Read/write cycles to complete failureNot yet determinedNot yet testedNot yet testedNot yet determined
    Total days to complete failureNot yet determinedNot yet testedNot yet testedNot yet determined
    Card reader usedSmartQ Single*Not yet testedNot yet testedN/A
    Package frontNot yet testedNot yet testedN/A
    Package backNot availableNot yet testedNot yet testedN/A
    Card frontNot yet testedNot yet testedN/A
    Card backNot yet testedNot yet testedN/A

    * I think.

    Discussion

    When I started this project, I searched for SD cards on AliExpress, then sorted the results in ascending order by price. I believe this is one came up as one of the early results. The price point was a little more than I wanted to pay -- which is why I only ordered one of them initially. (I later decided to try to get 3 of each model, which is why I ordered the other two.) I'll note that many of the results manipulated their position in the search results by including a variation of the product which was simply a microSD-to-SD adapter, which the sellers can afford to sell for a much lower price than the cards themselves -- and which appears as the price for the item in the search results. This is the case on this item as of the time of this writing (with them listing a microSD-to-SD adapter for $0.56, excluding shipping), and I believe it was the case at the time I purchased it.

    Performance-wise, this card did well on sequential read performance and average on random read performance, but write performance was disappointing. Both sequential write and random write speeds were below average, with sequential write speeds being more than one standard deviation below average. It did well enough to merit the Class 10 marking that it bears, but not well enough for any of the others. Perhaps it would have done better if it had been tested under the proper test conditions. Perhaps I'll get better results out of samples #2 and #3.

    Curiously, the 32GB and 64GB versions appear to have been made by different manufacturers, as indicated by the data in their respective CID registers. The 64GB version did markedly better on write performance (although, interestingly, markedly worse on read performance). Both versions are similar in their packaging (although the 64GB version came with a microSD-to-SD adapter, whereas the 32GB version did not), and both bear the information of Dexxon Groupe, indicating (to me, at least) that they were likely sold by Dexxon under license from Kodak. Indeed, their website indicates that they sell storage and IT products for a number of various well-known brands, including Kodak. It appears that Dexxon simply chose different manufacturers for the two versions of this card. It's unclear exactly what the reason for this is.

    As of this writing, sample #1 has survived 2,300 read/write cycles without errors. While impressive, this is only one sample -- samples #2 and #3 are still in the package waiting to be tested. I'll be interested to see how those two fare.

    Last updated: 2/25/2024

    Kodak Ultra Performance 64GB

    • Advertised capacity: 64GB
    • Logical capacity:
    • Physical capacity:
    • Fake/skimpy flash: Skimpy (2.26% skimp)
    • Speed class markings: Class 10, U3, V30, A1
    • CID data:
      • Manufacturer ID: 0x6f
      • OEM ID: 0x0303
      • Product name: 0x5344414243 (ASCII: SDABC)
      • Product revision: 0x10
    • Read/write cycles to first error: Not yet determined
    • Read/write cycles to complete failure: Not yet determined
    • Card reader used: SmartQ Duo
    Sample #123Average
    Obtained fromAliExpressAliExpressAliExpressN/A
    Logical capacity62,552,276,992 bytes62,544,412,672 bytes62,544,412,672 bytes62,547,034,112 bytes
    Physical capacity62,552,276,992 bytes62,544,412,672 bytes62,544,412,672 bytes62,547,034,112 bytes
    Fake/skimpy flashSkimpy (2.26% skimp)Skimpy (2.27% skimp)Skimpy (2.27% skimp)N/A
    Price paid$4.16$1.79$1.79$2.58
    Manufacture dateFeb 2023Jun 2023Jun 2023N/A
    Serial number0xaa000c380xaa000aeb0xaa0002fbN/A
    Sequential read speed (MB/sec)51.7989.8789.6077.09
    Sequential write speed (MB/sec)34.6339.3236.8536.93
    Random read speed (IOPS/sec)2,559.741,872.581,814.412,082.24
    Random write speed (IOPS/sec)554.12471.09452.61492.61
    Read/write cycles to first error2,518Not yet determinedNot yet determined2,518
    Read/write cycles to complete failureNot yet determinedNot yet determinedNot yet determinedNot yet determined
    Total days to complete failureNot yet determinedNot yet determinedNot yet determinedNot yet determined
    Card reader usedSmartQ DuoJJS CR-UTC4ACJJS CR-UTC4ACN/A
    Package frontN/A
    Package backN/A
    Card frontN/A
    Card backN/A

    Discussion

    I believe that I found this item as a result of recommendations that AliExpress made while I was looking at the Kodak Ultra Performance 32GB card above. Curiously, they were being sold by different sellers -- sample #1 of the 32GB card was being sold by "Kodak Store", while sample #1 of the 64GB card was being sold by "Kodak Global Store". As I noted above, the two versions also have different manufacturer IDs; however, I'm not convinced that these two facts are related to each other. Additionally, astute readers will note that sample #1 was actually cheaper than sample #1 of the 32GB version. This card was sold with free shipping, while the 32GB card was not; however, even before shipping costs, the 64GB card was still cheaper -- as I paid $4.16 for it, and $5.00 for the 32GB version (before shipping). This price was still above what I wanted to pay at the time, however, so I initially only ordered one of them. (I later decided that I should try to have at least three of each model, and I managed to get them through one of AliExpress's sales.)

    Sequential read speeds on sample #1 was disappointing, but samples #2 and #3 were able to make up for it. All other performance metrics were above average for all three samples. Sample #1 met the requirements for all of the speed class markings that it bore; however, samples #2 and #3 fell short of the 500 random write operations per second needed to qualify for the A1 marking. They got close enough, however, that my standard disclaimer of "these cards may have done better had they been tested under proper conditions" might actually have gotten it past the 500 operations per second mark.

    On the endurance front: sample #1 made it past the 2,000 read/write cycle mark without errors. It experienced its first error during round 2,518. This error may have been related to the fact that I pulled it from its reader during testing so that I could read the registers off of it with the Realtek reader. However, my program was well into the readback portion of the round when I pulled it -- any data waiting to be written to the card's flash should have been long since written before then. Regardless, the symptoms do seem to be consistent with a cached write that was only partially flushed. As of this writing, it has gone a total of 3,078 read/write cycles and has not experienced any other errors.

    Samples #2 and #3 have not yet reached the 2,000 read/write cycle mark. They are currently expected to reach that point sometime in early August 2024.

    Last updated: 2/29/2024

    "Lenovo" 128GB

    • Obtained from: AliExpress
    • Price paid: $3.98
    • Advertised capacity: 128GB
    • Logical capacity: 134,218,776,576 bytes
    • Physical capacity: 8,052,895,232 bytes
    • Fake/skimpy flash: Fake flash
    • Speed class markings: None
    • CID data:
      • Manufacturer ID: 0x00
      • OEM ID: 0x0000
      • Product name: 0x4150505344 (ASCII: APPSD)
      • Product revision: 0x00
      • Manufacture date: Oct 2022
      • Serial number: 0x12800006
    • Sequential read speed (MB/sec): 16.51
    • Sequential write speed (MB/sec): 4.47
    • Random read speed (IOPS/sec): 1,283.48
    • Random write speed (IOPS/sec): 1.01
    • Read/write cycles to first error: 327
    • Read/write cycles to complete failure: Not yet determined
    • Total days to complete failure: Not yet determined
    • Card reader used: SanDisk MobileMate
    • Package front:
    • Package back:
    • Card front:
    • Card back:

    Discussion

    This is one I found while browsing randomly through AliExpress, and one I heavily suspected would be fake flash when I ordered it. I was curious to see whether lower and higher capacity models would both be fake flash, or if these sellers would limit their fake flash to just higher capacity models -- so I bought a single 128GB card (which was the lowest capacity they offered) and a single 2TB card. Spoiler: they were both fake flash.

    Disclaimer: I don't think Lenovo had anything to do with this card. I think this is an unlicensed knock-off (hence why "Lenovo" is in quotes).

    I've noticed a number of trends with some (though not all) fake flash. For example, many fake flash cards bear the name of well-known electronics manufacturer, even though the manufacturer is not known for selling SD cards. All of them (or at least, the ones I've been able to read the CID data from) have had their manufacturer ID set to 00, presumably to hide the identity of their manufacturer. Additionally, these cards also tend to have pretty abysmal performance across the board. This card is no exception: all performance results were more than one standard deviation below average, with the exception of random read speeds (which were still below average). This particular seller attempted to be sneaky by not including any of the standard speed class marks. Instead, they opted to include the Nintendo Switch icon instead -- which, last I checked, wasn't an indicator of speed. (They did include the UHS-I mark, but this mark by itself doesn't make any assertions as to the card's read or write speeds.)

    This card has been chugging along on its endurance test for quite some time; however, it only managed to go 327 read/write cycles before starting to display data mismatch errors. At first, the errors only affected two sectors; however, the number of sectors has only increased nearly every round since then. (Almost all of these errors have been bit-flip errors.) This has actually caused problems for my code's device detection logic: the program keeps a copy of the data that it wrote to two 1MB segments on the card. When a device is disconnected or reconnected, or when the program is interrupted and restarted, it searches for devices that are the same size as the one it was testing; it then reads back both 1MB segments and ensures that at least one of them matches the data expected. This is done to ensure that it can correctly identify the device that it was previously working on. However, these 1MB segments are linear and in static locations on the device; this card has had so many sectors go bad that both of these regions are no longer stable. When an issue occurs, I've had to restart the endurance test from scratch. (I plan to add some strategies to work around this at some point in the future.) At this point in the current endurance test, about 30% of all the sectors on the card have experienced data mismatch errors, and it has survived a total of 2,595 read/write cycles so far.

    Last updated: 2/25/2024

    "Lenovo" 2TB

    • Obtained from: AliExpress
    • Price paid: $4.27
    • Advertised capacity: 2TB
    • Logical capacity: 2,147,483,648,000 bytes
    • Physical capacity: 8,032,673,792 bytes
    • Fake/skimpy flash: Fake flash
    • Speed class markings: None
    • CID data:
      • Manufacturer ID: 0x00
      • OEM ID: 0x0000
      • Product name: 0x0000000000
      • Product revision: 0x00
      • Manufacture date: Aug 2023
      • Serial number: 0x000040a4
    • Sequential read speed (MB/sec): 21.05
    • Sequential write speed (MB/sec): 12.91
    • Random read speed (IOPS/sec): 1289.84
    • Random write speed (IOPS/sec): 0.91
    • Read/write cycles to first error: 5,601
    • Read/write cycles to complete failure: 11,633
    • Total days to complete failure: 162
    • Card reader used: SanDisk MobileMate
    • Package front:
    • Package back:
    • Card front:
    • Card back:

    Discussion

    As with the 128GB above, I wanted to get a card that was obviously fake flash and one that could have been ambiguous to see if only one would be fake, or if they would both be fake. It turns out they were both fake.

    Disclaimer: I don't believe Lenovo had anything to do with this card. I think this is an unlicensed knock-off (hence why "Lenovo" is in quotes).

    This card continues the fake flash trend of terrible performance. While it did better on the sequential I/O tests than its 128GB sibling, it did about the same on the random I/O tests. All results were below average, and with the exception of the random read test, all results were more than one standard deviation below average. As with the 128GB card, the seller only put the UHS-I mark on this card -- there are no speed class marks to test for.

    Surprisingly, however, this card endured far better than its smaller sibling: it completed 5,601 read/write cycles before showing any errors. Curiously, when data mismatch errors occurred, they were mostly happening as a single group of 64 contiguous sectors -- with the data read not at all seeming to resemble the data written -- which are then separated by a number of read/write cycles where no data mismatch errors occur. The number of rounds between data mismatch errors seemed to be random, ranging from as few as 5 to as many as 625. This implies to me that the card was employing some sort of wear leveling (probably dynamic wear leveling), the bad sectors weren't being detected by the card, and the card was simply recycling the bad sectors as part of its wear leveling algorithm.

    During round 11,626, it started experiencing a number of missing data errors; however, the number of sectors affected during this round -- as well as the next 5 rounds -- represented only a fraction of a percent of the total sectors on the device. However, this escalated during round 11,632 -- during this round, the total number of bad sectors on the device went from 0.126% to 3.52%. By the end of round 11,633, that number shot up 43.089%. Sometime during round 11,634, the card stopped responding to commands altogether, and the endurance test was considered "complete" at that point.

    So...while this card was much smaller than advertised and performed terribly, I'm forced to conclude that it was more reliable than average. However, I have two more samples on the way -- we'll have to see how those do compared to this one.

    Last updated: 2/26/2024

    Lexar Blue 633x 32GB

    • Obtained from: AliExpress
    • Price paid: $1.99
    • Advertised capacity: 32GB
    • Logical capacity: 31,719,424,000 bytes
    • Physical capacity: 31,719,424,000 bytes
    • Fake/skimpy flash: Skimpy (0.88% skimp)
    • Speed class markings: Class 10*, U1, V10, A1
    • CID data:
      • Manufacturer ID: 0xad
      • OEM ID: 0x4c53 (ASCII: LS)
      • Product name: 0x4c58333247 (ASCII: LX32G)
      • Product revision: 0x10
    Sample #123Average
    Serial number0x3a0097a20x41b403fd0x41af03f6N/A
    Manufacture dateAug 2023Aug 2023Aug 2023N/A
    Sequential read speed (MB/sec)89.8990.4990.1090.16
    Sequential write speed (MB/sec)28.6628.3027.9228.29
    Random read speed (IOPS/sec)2,446.172,411.092,475.372,444.21
    Random write speed (IOPS/sec)698.86668.24677.34681.48
    Read/write cycles to first error157267Not yet determined212
    Read/write cycles to complete failureNot yet determinedNot yet determinedNot yet determinedNot yet determined
    Total days to complete failureNot yet determinedNot yet determinedNot yet determinedNot yet determined
    Card reader usedJJS CR-UTC4ACJJS CR-UTC4ACJJS CR-UTC4ACN/A
    Package frontN/A
    Package backN/A
    Card frontN/A
    Card backN/A

    Discussion

    By mid-January 2023, I had completed performance testing on two of the Lexar Professional 1000x 64GB cards, and it became obvious that these cards had a pretty significant data integrity issue (see the discussion on those cards for more info). However, seeing as those were the only Lexar cards in my collection, I thought that it would be a pretty poor representation of Lexar as a whole -- so I decided it would be good to include another Lexar model. I obtained three of these cards; however, only two of them are in testing at this time -- the third is still in the package waiting to be tested.

    There's one particular data point that strikes me as odd: the manufacturer ID. None of the sources I looked at listed manufacturer ID 0xad as belonging to Lexar -- or anyone at all. This manufacturer ID is shared by two other brands in my collection: Chuxia and OV. In fact, all three not only had the same manufacturer ID, but also the same OEM ID. This could be a sign that these cards were fake; however, I didn't see any other signs indicating that the card is fake -- capacity is as advertised, and printing (on both the card and the packaging) was clear and high quality. The markings on the back of the card appear to have been printed on -- as opposed the Lexar Professional 1000x 64GB, where it appears the markings were laser-etched -- but this about the only inconsistency I could spot off the bat. If this is a fake, it's a pretty convincing fake.

    However, I think there's a more mundane explanation. The Lexar Professional 1000x 64GB cards have manufacture dates of Jan 2017 and Feb 2017, while these cards have a manufacture date of Aug 2023. Lexar was owned by Micron up until August of 2017, when they made the decision to sell the Lexar brand name to Shenzhen Longsys Electronics Co. -- meaning that the two Lexar Professional 1000x 64GB cards would have been made by Micron, and these two would have been made by Longsys. Given that, I think manufacturer ID 0xad is probably assigned to Longsys.

    Performance-wise, these cards did above average in all categories except sequential write speeds, which were slightly below average. However, random write speeds -- a category which a lot of cards struggled with -- were more than one standard deviation above average. These cards easily surpassed the thresholds for all of the speed class marks that they bore. Honestly -- not bad for a card that was only $1.99.

    All three samples are still undergoing endurance testing; however, sample #1 experienced a data shift error after only 157 read/write cycles, and sample #2 experienced a data shift error after only 267 read/write cycles. As of this writing, samples #1 and #2 have each survived 817 read/write cycles. I just started testing on sample #3 about a week and a half ago -- it has not yet hit the 2,000 read/write cycle mark. It's currently expected to get there sometime in late April 2024.

    Last updated: 2/25/2024

    Lexar Professional 1000x 64GB

    • Obtained from: Amazon
    • Advertised capacity: 64GB
    • Fake/skimpy flash: No
    • Speed class markings: Class 10, U3

    * This manufacturer ID/OEM ID is well known to be associated with Lexar.

    Card #123Average
    Price paid$13.99$12.99$11.95$12.98
    Logical capacity64,087,916,544 bytes64,087,916,544 bytes64,172,851,200 bytes64,116,228,096 bytes
    Physical capacity64,087,916,544 bytes64,087,916,544 bytes64,172,851,200 bytes64,116,228,096 bytes
    Manufacturer ID0x28*0x28*0x27**N/A
    OEM ID0x4245 (ASCII: BE)*0x4245 (ASCII: BE)*0x5048 (ASCII: PH)**N/A
    Product name0x363842484f (ASCII: 68BHO)0x363842484f (ASCII: 68BHO)0x3659444c50 (ASCII: 6YDLP)N/A
    Product revision0x080x080x07N/A
    Manufacture dateJan 2017Feb 2017Apr 2017N/A
    Serial number0x663b0e7f0x863b1c8f0xda874480N/A
    Sequential read speed (MB/sec)164.16170.52151.99162.22
    Sequential write speed (MB/sec)35.4935.8949.9740.45
    Random read speed (IOPS/sec)2883.531,050.902,336.092,090.17
    Random write speed (IOPS/sec)125.79231.28584.21313.76
    Read/write cycles to first error00Not yet determined0
    Read/write cycles to complete failureNot yet determinedNot yet determinedNot yet determinedNot yet determined
    Total days to complete failureNot yet determinedNot yet determinedNot yet determined72.33
    Card reader usedLexar LRWM05U-7000JJS CR-UTC4ACJJS CR-UTC4ACN/A
    Package frontN/A
    Package backN/A
    Card frontN/A
    Card backN/A

    * This manufacturer ID/OEM ID combination is pretty well known to belong to Lexar.

    ** This manufacturer ID/OEM ID combination is pretty well known to belong to Phison.

    Discussion

    Oh boy, do I have a thing or two to say about these cards. So here we go.

    I purchased sample #1 because I wanted to be able to have at least one UHS-II card in my results. UHS-II cards tend to be pretty expensive (comparatively speaking), which is why I initially only ordered one. It came in retail packaging, complete with a Lexar LRWM05U-7000 UHS-II card reader, and I initially planned to test it with this card reader -- but fate (or Lexar?) apparently had other ideas. It almost immediately had issues, unable to make it through even its authenticity or performance tests. After a few tries, I was able to get it to complete both tests -- but

    I bought the first of these cards because I wanted to be able to have at least one UHS-II card in my results. UHS-II cards tend to be pretty expensive (comparatively speaking), so I initially only ordered one. It arrived in retail packaging, which included a Lexar LRWM05U-7000 UHS-II card reader. I planned to test it using this card reader; however, it started to experience I/O errors soon after tests began. On the next attempt, I was able to get it to complete its authenticity and performance tests; but it then started experiencing I/O errors during the first round of endurance testing. Restarting the endurance test didn't seem to help -- so I decided to move it to one of the JJS CR-UTC4ACs instead.

    The I/O errors stopped under the JJS reader, but then a different issue surfaced: in every round of the endurance test, there would be a handful of data verification failures. But when I looked at the data being read back and compared it to what was being written to the card, I noticed something odd. Here's a snippet of my logs -- see if you can spot the issue:

    [Sat Nov 11 02:19:40 2023] Expected data was:
    [Sat Nov 11 02:19:40 2023]     00000009e2a70200: 3e 78 78 ef e5 e9 fe cc     42 60 17 ae b7 6a 4f a6
    [Sat Nov 11 02:19:40 2023]     00000009e2a70210: dd d6 24 cc 5c 53 f0 f4     16 47 f8 e5 80 04 47 df
    [Sat Nov 11 02:19:40 2023]     00000009e2a70220: 51 9b cc 84 03 85 8e f0     aa c5 2a d4 72 c7 35 97
    [Sat Nov 11 02:19:40 2023]     00000009e2a70230: af e9 18 b3 7d ad 77 a4     5b 31 f4 fe d1 e0 75 e2
    ...

    [Sat Nov 11 02:19:40 2023] Actual data was:
    [Sat Nov 11 02:19:40 2023]     00000009e2a70200: 3e 78 78 ef e5 e9 fe cc     42 60 17 ae b7 6a 4f a6
    [Sat Nov 11 02:19:40 2023]     00000009e2a70210: 7f 45 ea b4 5c 53 f0 f4     16 47 f8 e5 80 04 47 df
    [Sat Nov 11 02:19:40 2023]     00000009e2a70220: 51 9b cc 84 03 85 8e f0     aa c5 2a d4 72 c7 35 97
    [Sat Nov 11 02:19:40 2023]     00000009e2a70230: af e9 18 b3 7d ad 77 a4     5b 31 f4 fe d1 e0 75 e2
    ...

    And another mismatch that happened a couple weeks later:

    [Wed Nov 29 05:10:17 2023] Expected data was:
    [Wed Nov 29 05:10:17 2023]     000000034dafc200: db cb 0e bb 8e 05 2b b4     c0 80 c0 f9 5e ca 84 bd
    [Wed Nov 29 05:10:17 2023]     000000034dafc210: 38 88 89 c0 8f 4c eb c9     43 1a df b9 fc 8a 84 df
    [Wed Nov 29 05:10:17 2023]     000000034dafc220: 39 e2 88 ce fc 87 4d a9     11 e9 70 be eb 85 53 8e
    [Wed Nov 29 05:10:17 2023]     000000034dafc230: 20 8a 3d c2 03 5b ee e4     cd f2 ed ac 55 1a 70 aa
    ...

    [Wed Nov 29 05:10:17 2023] Actual data was:
    [Wed Nov 29 05:10:17 2023]     000000034dafc200: db cb 0e bb 8e 05 2b b4     c0 80 c0 f9 5e ca 84 bd
    [Wed Nov 29 05:10:17 2023]     000000034dafc210: f6 19 bb eb 8f 4c eb c9     43 1a df b9 fc 8a 84 df
    [Wed Nov 29 05:10:17 2023]     000000034dafc220: 39 e2 88 ce fc 87 4d a9     11 e9 70 be eb 85 53 8e
    [Wed Nov 29 05:10:17 2023]     000000034dafc230: 20 8a 3d c2 03 5b ee e4     cd f2 ed ac 55 1a 70 aa
    ...

    See that? It's always bytes 16-19 that are mismatched. Every. Single. Time.

    "OK", I thought to myself, "maybe I just got a bad card. It happens. I'll just order another one." So I did, and from the same Amazon seller. This one looked pretty much identical to the first one, complete with another Lexar LRWM05U-7000 card reader. This time, I decided to set that one aside, and I put it straight into one of the JJS CR-UTC4AC readers. And as soon as the endurance test started running? It started having the same issue -- right down to the same four bytes being mismatched:

    [Mon Nov 20 20:36:07 2023] Expected data was:
    [Mon Nov 20 20:36:07 2023]     00000001e4b04200: 2c 7d 0a a6 e0 d2 23 8f     b6 9b f3 0a 44 f8 6b a2
    [Mon Nov 20 20:36:07 2023]     00000001e4b04210: 9c 4e d8 fe 8e 51 ae 43     b1 62 fe b8 aa 3d 6c 77
    [Mon Nov 20 20:36:07 2023]     00000001e4b04220: 39 f8 4f 95 15 43 c2 9d     8f f6 5b 82 57 32 85 e4
    [Mon Nov 20 20:36:07 2023]     00000001e4b04230: 09 79 d8 bb 17 70 11 ff     68 97 be 96 a3 d9 c5 8d
    ...

    [Mon Nov 20 20:36:07 2023] Actual data was:
    [Mon Nov 20 20:36:07 2023]     00000001e4b04200: 2c 7d 0a a6 e0 d2 23 8f     b6 9b f3 0a 44 f8 6b a2
    [Mon Nov 20 20:36:07 2023]     00000001e4b04210: 61 1a 0b 86 8e 51 ae 43     b1 62 fe b8 aa 3d 6c 77
    [Mon Nov 20 20:36:07 2023]     00000001e4b04220: 39 f8 4f 95 15 43 c2 9d     8f f6 5b 82 57 32 85 e4
    [Mon Nov 20 20:36:07 2023]     00000001e4b04230: 09 79 d8 bb 17 70 11 ff     68 97 be 96 a3 d9 c5 8d
    ...

    This was too weird to be coincidence. I considered that maybe they were both part of the same batch, and that there was an issue with that particular batch -- but the two cards have different manufacturing dates (and wildly different serial numbers). That means that either there was a manufacturing issue that went undetected for multiple batches, or there's a design flaw with this card.

    For a while, I was going to leave it at that; but at some point, I decided that I should try to have at least three samples of all the cards I'm testing -- so I went back to the same Amazon seller and ordered a third one. Here's where the story took a twist: the product packaging was identical, it included another Lexar LRWM05U-7000 card reader, the card design was the same -- but the CID data indicates that it's a completely different card! Every single field in the CID register was different than the other two samples. Now, the manufacturer ID indicates that it was made by Phison -- which has been known to make Lexar-branded cards in the past -- so my guess is that Lexar simply contracted out part of the production of these cards to Phison.

    The package advertises read speeds of up to 150MB/sec and write speeds of up to 45MB/sec. All three samples managed to surpass 150MB/sec on sequential read speeds (putting it more than 2 standard deviations above average), but only sample #3 (the Phison-produced sample) managed to hit the 45MB/sec mark on sequential write speeds. Samples #1 and #2 ended up being just slightly above average in this category; sample #3 ended up being more than one standard deviation above average.

    Random I/O speeds were pretty inconsistent. When tested with the Lexar LRWM05U-7000, sample #1 got random read speeds that were more than one standard deviation above average. However, the same card, tested on the same machine with a JJS CR-UTC4AC, only managed to get about 1/4 of that. Both random read speeds and random write speeds ran the gamut from "well below average" to "more than one standard deviation above average", depending on the card. I can't say for sure whether the Phison-produced samples or the Lexar-produced samples were better for random read speeds, but it did seem like the Phison-produced sample was significantly better for random write speeds.

    All three samples scored well enough to merit the Class 10 and U3 markings; but frankly, I would have expected better for a name-brand card that had "Professional" as part of its name -- especially when there are UHS-I cards that were able to get better write speeds.

    All three samples are still undergoing endurance testing. None of the three samples has made it to the 2,000 read/write cycle mark yet.

    Of course, there's one more strangeness to add to this whole thing: by round 294, the errors with sample #1 stopped completely. As of this writing, it has gone a total of 893 read/write cycles, and has not experienced any further errors -- even on the sectors that were previously flagged as bad. Did it finally detect the bad blocks and stop using them? (It's times like these that make me wish I could see into what's going on inside the microSD card...) Meanwhile, sample #2 has gone through over 1,514 read/write cycles, and it's still turning up a handful of errors every round.

    I'd like to see how the Phison-produced sample does on its endurance tests. It is currently expected to hit the 2,000 read/write cycle mark sometime in July 2024. But overall, I don't think I would recommend buying this card. While some of the performance metrics were good-to-impressive, it doesn't make up for the data integrity issues that the Lexar-produced samples experienced. As evidenced by the fact that I bought all three samples from the same seller and got two different cards, I think it's fair to say there's no way of knowing which one you'll get at the time of ordering. Had I used this in a digital camera, it's likely that some of my pictures would have been corrupted the very first time I used the card -- and any photographer will tell you that's just not acceptable.

    Last updated: 2/25/2024

    Microdrive "Bart Simpson" 16GB

    • Obtained from: AliExpress
    • Price paid: $2.89
    • Advertised capacity: 16GB
    • Logical capacity: 15,732,310,016 bytes
    • Physical capacity: 15,732,310,016 bytes
    • Fake/skimpy flash: Skimpy (1.67% skimp)
    • Speed class markings: Class 10, U1
    • CID data:
      • Manufacturer ID: 0x6f
      • OEM ID: 0x0303
      • Product name: 0x5344414243 (ASCII: SDABC)
      • Product revision: 0x10
    Card #123Average
    Manufacture dateMay 2023Jan 2013Jun 2023N/A
    Serial number0xaa0000b00xaa00038e0xaa000189N/A
    Sequential read speed (MB/sec)64.1979.7089.3877.76
    Sequential write speed (MB/sec)23.2517.6549.9530.28
    Random read speed (IOPS/sec)1,562.661,722.911,665.231,650.27
    Random write speed (IOPS/sec)378.03214.84542.5378.46
    Read/write cycles to first error4,270Not yet determinedNot yet determined4,270
    Read/write cycles to complete failure8,570Not yet determinedNot yet determinedNot yet determined
    Total days to complete failure183Not yet determinedNot yet determined183
    Card reader usedPrograde Digital Dual Slot Mobile ReaderJJS CR-UTC4ACJJS CR-UTC4ACN/A
    Package frontNot availableN/A
    Package backNot availableN/A
    Card frontN/A
    Card backN/A

    Discussion

    This is a card that I bought during my first round of SD card purchases from AliExpress, and I very clearly remember the thing that stood out to me about these cards: Bart Simpson peeking in from the side of the card. I'm sure Fox would love to hear about this.

    Now, a disclaimer: I think these were made by Microdrive, but I'm not 100% certain. The card itself doesn't have any brand name on it, and neither does the package it came in -- it came in a generic red package that had no brand name, no indication of the size of the card in the package, no speed markings, and no manufacturer information. It's substantially identical to the packaging that the Auotkn, knockoff Lenovo, QEEDNS, and knockoff Sony cards came in. (What's funny to me is that the package has a telephone icon that says "tech support" above it, but there's no indication of where to go to get said tech support -- there are no websites, no phone numbers, no mailing addresses...nothing.) However, these cards came from an AliExpress store called "MD Factory Promotional Store", and many of the other products they sell are Microdrive branded -- so I'm choosing to believe that these cards were made by Microdrive as well. For the longest time, I had these in my list as simply "Unbranded Simpsons card" because I wasn't 100% sure they were Microdrive cards.

    Curiously, sample #2's CID data indicated a manufacturing date of January 2013 -- which would have been more than 10 years before I purchased it -- while samples #1 and #3 had more recent dates of May 2023 and June 2023, respectively. When I noticed this, I went back and re-read the CID from the card to make sure I hadn't made a mistake (such as transcribing the CID value to my spreadsheet by hand and mistyping something) -- but alas, I had it correct the first time. Given that sample #2's packaging didn't make it look like it had been sitting around for 10 years, I'm inclined to think that its manufacture date was a mistake, and that it was actually made more recently.

    Performance-wise, these cards did OK. Not great, just OK. Sequential read speeds, random read speeds, and random write speeds were close to average, while sequential write speeds were below average. However, despite being just OK, it was good enough to qualify for the Class 10 and U1 markings that it carried.

    Endurance-wise -- this card actually did pretty well. All three samples made it past the 2,000 read/write cycle mark without errors, making it only one of two models I've tested to do so. Sample #2 has gone 3,748 read/write cycles thus far, while sample #3 has gone 2,430. Neither has experienced any errors.

    Last updated: 2/25/2024

    Netac Pro 16GB

    • Obtained from: AliExpress
    • Price paid: $1.99
    • Advertised capacity: 16GB
    • Logical capacity: 15,942,025,216 bytes
    • Physical capacity: 15,942,025,216 bytes
    • Fake/skimpy flash: Skimpy (0.36% skimp)
    • Speed class markings: U1*, V10, A1
    • CID data:
      • Manufacturer ID: 0x6f
      • OEM ID: 0x0303
      • Product name: 0x4342414453 (ASCII: CBADS)
      • Product revision: 0x10

    * The U1 mark only appears on the card -- it does not appear on the packaging.

    Sample #123Average
    Manufacture dateJun 2023Not yet testedNot yet testedN/A
    Serial number0xaa000667Not yet testedNot yet testedN/A
    Sequential read speed (MB/sec)28.40Not yet testedNot yet tested28.40
    Sequential write speed (MB/sec)21.35Not yet testedNot yet tested21.35
    Random read speed (IOPS/sec)1,192.89Not yet testedNot yet tested1,192.89
    Random write speed (IOPS/sec)263.39Not yet testedNot yet tested263.39
    Read/write cycles to first errorNot yet determinedNot yet testedNot yet testedNot yet determined
    Read/write cycles to complete failureNot yet determinedNot yet testedNot yet testedNot yet determined
    Total days to complete failureNot yet determinedNot yet testedNot yet testedNot yet determined
    Card reader usedJJS CR-UTC4ACNot yet testedNot yet testedN/A
    Package frontNot yet testedNot yet testedN/A
    Package backNot yet testedNot yet testedN/A
    Card frontNot yet testedNot yet testedN/A
    Card backNot yet testedNot yet testedN/A

    Discussion

    Netac has the special distinction of being the first brand I've come across where the card was actually bigger than what was advertised. Note that it's not this card -- I received an 8GB Netac card (not the Pro) card with my 3D printer. Upon closer inspection, however, I found that the card had only been partitioned to 8GB -- and was, in fact, a 16GB card. I'll admit that it did make me a little curious to see if any of Netac's other cards would be the same way.

    I've only tested one of these cards so far, but the results from sample #1 were disappointing. All performance metrics were below average, with sequential read speeds being more than one standard deviation below average. It's enough to qualify for the U1 and V10 markings, but both of the random I/O metrics fell short of what's required for the A1 marking. I'll throw in my standard "perhaps this card would have performed better if it had been tested under proper conditions" disclaimer. Who knows -- I have two more samples left to test. Maybe one of them will do better.

    Endurance tests are still ongoing for this card. As of the time of this writing, sample #1 has not yet hit the 2,000 read/write cycle mark. It is currently expected to get there sometime in late March 2024. Samples #2 and #3 are still in the package waiting to be tested.

    Last updated: 2/25/2024

    OV 32GB

    • Obtained from: AliExpress
    • Price paid: $5.48
    • Advertised capacity: 32GB
    • Logical capacity: 31,719,424,000 bytes
    • Physical capacity: 31,719,424,000 bytes
    • Fake/skimpy flash: Skimpy (0.88% skimp)
    • Speed class markings: Class 10, U1*, U3, V10*, V30, A1*, A2**
    • CID data:
      • Manufacturer ID: 0xad
      • OEM ID: 0x4c53 (ASCII: LS)
      • Product name: 0x5553443030 (ASCII: USD00)
      • Product revision: 0x10

    * The U1, V10, and A1 marks only appear on the packaging -- they do not appear on the card.

    ** The A2 mark only appears on the card -- it does not appear on the packaging.

    Card #123Average
    Manufacture dateMar 2023Mar 2023Mar 2023N/A
    Serial number0x41bf31be0x41bf32400x41b91835N/A
    Sequential read speed (MB/sec)40.9862.1251.9751.69
    Sequential write speed (MB/sec)23.2718.9620.0620.76
    Random read speed (IOPS/sec)287.82271.89310.91290.21
    Random write speed (IOPS/sec)316.99262.28339.32306.20
    Read/write cycles to first error4042,202Not yet determined882
    Read/write cycles to complete failureNot yet determinedNot yet determinedNot yet determinedNot yet determined
    Total days to complete failureNot yet determinedNot yet determinedNot yet determinedNot yet determined
    Card reader usedPrograde Digital Dual Slot Mobile ReaderJJS CR-UTC4ACJJS CR-UTC4ACN/A
    Package frontN/A
    Package backN/A
    Card frontN/A
    Card backN/A

    Discussion

    This is another one I found on AliExpress after doing some more digging. I appreciated that they put at least a little bit of work in designing the artwork for both the packaging and the card, although the two designs seem to be completely different -- almost as if two different people were working on the designs, and they weren't coordinating with each other. It appears that this particular manufacturer has their own line of memory products -- including not only microSD cards, but also USB flash drives, SSDs (both internal and external), and RAM.

    The package and card bear a strange combination of conflicting speed class marks, which would support my "the card and the packaging were designed by two different people" theory. Despite the disagreement, none of the three samples performed well enough to meet the threshold for the U3, V30, A1, and A2 marks. Perhaps they would have performed well enough to qualify for the U3 and V30 marks had they been tested under the right conditions; but given how poorly they performed on the random I/O tests, I doubt that it would have performed well enough for either the A1 or A2 marks even under the right conditions.

    On the endurance front, it's looking like a mixed bag. As of this writing, sample #1 has completed 3,296 read/write cycles. It experienced a few I/O errors during round 404, a partial write during round 460, and a single bit flip during round 1,235, but has not had any further issues since then. Sample #2 managed to get past the 2,000 read/write cycle mark without issues; its first error was a data shift error during round 2,203. It has completed 2,814 read/write cycles total so far. Sample #3 is still undergoing endurance tests; it has not yet passed the 2,000 read/write cycle mark. It is currently estimated to get there sometime in late April 2024.

    Last updated: 2/22/2024

    QEEDNS 8GB

    • Obtained from: AliExpress
    • Price paid: $2.57
    • Advertised capacity: 8GB
    • Logical capacity: 8,053,063,680 bytes
    • Physical capacity: 8,053,063,680 bytes
    • Fake/skimpy flash: No
    • Speed class markings: Class 10, U1
    • CID data:
      • Manufacturer ID: 0x00
      • OEM ID: 0x0000
      • Product name: 0x534d492020 (ASCII: SMI)
      • Product revision: 0x00
      • Manufacture date: Nov 2015
      • Serial number: 0x0x000007ff
    • Sequential read speed (MB/sec): 17.94
    • Sequential write speed (MB/sec): 14.12
    • Random read speed (IOPS/sec): 1170.16
    • Random write speed (IOPS/sec): 35.89
    • Read/write cycles to first error: 6,111
    • Read/write cycles to complete failure: 6,111
    • Total days to complete failure: 79
    • Card reader used: SanDisk MobileMate
    • Package front:
    • Package back:
    • Card front:
    • Card back:

    Discussion

    QEEDNS (I'm just assuming it's spelled in all upper-case, because that's how it's printed on all of their cards) is another brand that popped up with some regularity when I was browsing AliExpress. This card arrived in a generic red packaging that seems to have been shared with a few other brands, such as Auotkn, Microdrive, the knockoff Lenovo cards, SanDian, and the knockoff Sony cards. This packaging did not have any brand name, manufacturer information, the size of the card, or class markings on it -- it was about as generic a package as you could get for an SD card. I think I only bought one of these because this was another case where I wanted to see if I could find fake and genuine cards from the same manufacturer.

    This card had its manufacturer ID and OEM ID set to all zeroes, a trait which is shared by all of the brands I just listed -- with the exception of Microdrive (who had the manufacturer ID and OEM set to 0x6f and 0x0303, respectively) and the knockoff Sony 32GB card (who had the OEM ID set to 0x3432). I suspect that this was done intentionally because whoever manufactured these cards likely doesn't want their name associated with it. Bunnie (from Bunnie Studios) used the term "ghost shift" to describe runs of SD cards that are generally run off the books and using marginal material that would normally be disposed of -- and I suspect that these cards are likely a result of ghost shifts.

    Performance-wise, this card performed pretty poorly in comparison to many of the others I tested -- and yet, somehow it did well enough to qualify for the Class 10 and U1 marks that it carries. All speed measurements were well below average, with sequential read and random write speeds being more than one standard deviation below average. (Sequential write speeds were just barely less than one standard deviation below average.)

    This card actually did fairly well on its endurance tests -- right up until it failed. One day, I decided to mount my USB hubs on the wall of my server closet, and a few days later, I decided to mount the AC adapters for these hubs by hammering cable tacks into the wall where the cords were going into it. I must have jarred something when I was doing this, because all of the card readers on that machine disconnected from the machine. I had to reset the entire USB controller to get them working again. I managed to get all of the other cards working again, but this card refused to come back to life -- it simply refused to respond to commands. I made several attempts (including with my trusty Realtek reader), but to no avail -- at which point I decided to simply declare the card dead.

    Last updated: 2/25/2024

    QEEDNS 512GB

    • Obtained from: AliExpress
    • Price paid: $12.17
    • Advertised capacity: 512GB
    • Logical capacity: 536,871,960,576 bytes
    • Physical capacity: 31,434,108,416 bytes
    • Fake/skimpy flash: Fake flash
    • Speed class markings: Class 10, U3
    • CID data:
      • Manufacturer ID: 0x00
      • OEM ID: 0x00
      • Product name: 0x4150505344 (ASCII: APPSD)
      • Product revision: 0x00
      • Manufacture date: Sep 2021
      • Serial number: 0x12800000
    • Sequential read speed (MB/sec): 12.48
    • Sequential write speed (MB/sec): 9.55
    • Random read speed (IOPS/sec): 472.4
    • Random write speed (IOPS/sec): 3.65
    • Read/write cycles to first error: 447
    • Read/write cycles to complete failure: Not yet determined
    • Total days to complete failure: Not yet determined
    • Card reader used: Lexar LRWM05U-7000
    • Package front:
    • Package back:
    • Card front:
    • Card back:

    Discussion

    This is another card that I bought because I wanted to see if I could find genuine and fake flash in the same brand. And, it turns out that the answer is "Yes. Yes you can."

    As with the 8GB card, this card had its manufacturer ID and OEM ID set to all zeroes -- and combined with the generic red packaging, it's pretty obvious that this seller is trying to hide who is manufacturing these cards for them.

    Performance with this card was pretty abysmal -- even more abysmal with its smaller sibling. All performance metrics were more than one standard deviation below average. Sequential write speeds were just shy of what would be needed to qualify for Class 10 -- and it's possible that it would have made it over the 10MB/sec threshold had it been tested under proper conditions. However, it fell well short of what would be needed to qualify for the U3 marking.

    Endurance tests for this sample are still ongoing. However, I'll note that this card has had a few errors that started during round 448. It has endured 1,410 read/write cycles in total so far.

    Last updated: 2/25/2024

    QWQ Extreme Pro 16GB

    • Obtained from: AliExpress
    • Price paid: $2.99
    • Advertised capacity: 16GB
    • Logical capacity: 16,106,127,360 bytes
    • Physical capacity: 8,478,740,480 bytes
    • Fake/skimpy flash: Fake flash
    • Speed class markings: Class 10, A1
    • CID data:
      • Manufacturer ID: 0x00
      • OEM ID: 0x0000
      • Product name: 0x0000000000
      • Product revision: 0x00
    Sample #123456Average
    Manufacture dateSep 2023Not yet testedNot yet testedNot yet testedNot yet testedNot yet testedN/A
    Serial number0x00023786Not yet testedNot yet testedNot yet testedNot yet testedNot yet testedN/A
    Sequential read speed (MB/sec)21.74Not yet testedNot yet testedNot yet testedNot yet testedNot yet tested21.74
    Sequential write speed (MB/sec)11.17Not yet testedNot yet testedNot yet testedNot yet testedNot yet tested11.17
    Random read speed (IOPS/sec)1,098.46Not yet testedNot yet testedNot yet testedNot yet testedNot yet tested1,098.46
    Random write speed (IOPS/sec)0.82Not yet testedNot yet testedNot yet testedNot yet testedNot yet tested0.82
    Read/write cycles to first error18Not yet testedNot yet testedNot yet testedNot yet testedNot yet tested18
    Read/write cycles to complete failureNot yet determinedNot yet testedNot yet testedNot yet testedNot yet testedNot yet testedNot yet determined
    Total days to complete failureNot yet determinedNot yet testedNot yet testedNot yet testedNot yet testedNot yet testedNot yet determined
    Card reader usedJJS CR-UTC4ACNot yet testedNot yet testedNot yet testedNot yet testedNot yet testedN/A
    Package frontNot yet testedNot yet testedNot yet testedNot yet testedNot yet testedN/A
    Package backNot yet testedNot yet testedNot yet testedNot yet testedNot yet testedN/A
    Card frontNot yet testedNot yet testedNot yet testedNot yet testedNot yet testedN/A
    Card backNot yet testedNot yet testedNot yet testedNot yet testedNot yet testedN/A

    Discussion

    In early 2024, AliExpress started running sales where items -- seemingly from a single seller -- were priced at either $1.99, $2.99, or $3.99, and you were allowed to purchase any combination of 10 items...I think per day? This one caught my attention for a couple of reasons: first, the bright orange color; and second, the fact that they offered it in a 621GB capacity -- it's rather odd for an SD card manufacturer to be offering a card in a size that isn't a power of 2. However, given that the prices on all of the sizes were practically identical, the 618GB card is almost certainly fake, and hence I didn't buy any of them (yet).

    This particular brand also has two different card designs: one whose cards had a primarily orange and white design, and one whose cards had a primarily blue and black design. When I ordered these, I must have thought that there was a significant difference between the two -- like maybe only one of them had the "Extreme Pro" label on it -- but after receiving them and looking at them more closely, I can't see a difference between them. They both appear to have the "Extreme Pro" label -- and thus, I'm going to lump them both under this section.

    I was surprised that this card turned out to be fake -- usually smaller capacity cards like this are genuine. But, I suppose there are sellers who will skimp on just about anything to make a buck.

    I've only tested one of these cards so far, but the performance on the one was...terrible. All performance metrics were below average. And, except for the random read speeds, all performance metrics were more than one standard deviation below average. Surprisingly, however, this card had the best sequential read speeds of any card in the "fake flash" category so far -- if only that meant something.

    This card bears the Class 10 and A1 marks; and while performance was good enough to qualify for the Class 10 mark -- although just barely -- it missed the mark on both random read and random write speeds that would be needed for the A1 mark. And while I'll throw in my standard disclaimer -- that perhaps this card would have done better had it been tested under the proper conditions -- I highly doubt it, especially with random write speeds as terrible as they were.

    Endurance tests for sample #1 are still ongoing; however, it only managed to go for 18 read/write cycles before it experienced its first error. It has survived 783 read/write cycles total so far. Samples #2-#6 are still in the package waiting to be tested.

    Last updated: 2/25/2024

    Reletech 32GB

    • Obtained from: AliExpress
    • Price paid: $2.99
    • Advertised capacity: 32GB
    • Logical capacity: 31,266,439,168 bytes
    • Physical capacity: 31,266,439,168 bytes
    • Fake/skimpy flash: Skimpy (2.29% skimp)
    • Speed class markings: Class 10, U3, A1
    • CID data:
      • Manufacturer ID: 0xfe
      • OEM ID: 0x3432 (ASCII: 42)
      • Product name: 0x5344313647 (ASCII: SD16G)
      • Product revision: 0x20
    Sample #123Average
    Manufacture dateJun 2023Not yet testedNot yet testedN/A
    Serial number0x00001fe3Not yet testedNot yet testedN/A
    Sequential read speed (MB/sec)86.22Not yet testedNot yet testedN/A
    Sequential write speed (MB/sec)19.33Not yet testedNot yet tested19.33
    Random read speed (IOPS/sec)1,564.81Not yet testedNot yet tested1,564.81
    Random write speed (IOPS/sec)289.82Not yet testedNot yet tested289.82
    Read/write cycles to first errorNot yet determinedNot yet testedNot yet testedNot yet determined
    Read/write cycles to complete failureNot yet determinedNot yet testedNot yet testedNot yet determined
    Total days to complete failureNot yet determinedNot yet testedNot yet testedNot yet determined
    Card reader usedJJS CR-UTC4ACNot yet testedNot yet testedN/A
    Package frontNot yet testedNot yet testedN/A
    Package backNot yet testedNot yet testedN/A
    Card frontNot yet testedNot yet testedN/A
    Card backNot yet testedNot yet testedN/A

    Discussion

    In early 2024, AliExpress started running sales where items -- seemingly from a single seller -- were priced at either $1.99, $2.99, or $3.99, and you were allowed to purchase any combination of 10 items...I think per day? This caught my attention, so I looked through and found a few brands of microSD cards that I hadn't seen before, including this one.

    The product packaging was a little unusual, in that it had a mixture of English and French...and an office address in Germany. This leads me to believe that they wanted buyers to think that this was a North American or European brand -- but then someone ruined the illusion by slapping a sticker on the back that says "Shenzhen Guanlin International Trade Co.,Ltd". On the bright side, at least this particular card isn't fake flash. They do have some bigger sizes, and the prices on those scale up with size, so I'm guessing that those aren't fake flash either. Who knows, I might have to try those out sometime.

    I've only tested one sample so far, but performance was just "meh". Sequential read speeds were a little above average, while sequential write speeds were pretty well below average. Random read and write speeds were just average. While this was good enough to qualify for the Class 10 mark, it fell well short of the 30MB/sec write speeds required for the U3 mark, and well short of the 500 random write operations per second required for the A1 mark. Perhaps this card would have done better had it been tested under proper conditions -- but somehow I doubt it.

    Endurance tests for sample #1 are still ongoing. It has not yet reached the 2,000 read/write cycle mark, so it's too early to draw any conclusions on its reliability. It's currently expected to get there sometime in May 2024. Samples #2 and #3 are still in the package, waiting to be tested.

    Last updated: 2/25/2024

    Samsung EVO Plus 32GB

    • Obtained from: Amazon
    • Price paid: $11.99
    • Advertised capacity: 32GB
    • Logical capacity: 32,010,928,128 bytes
    • Physical capacity: 32,010,928,128 bytes
    • Fake/skimpy flash: No
    • Speed class markings: Class 10, U1
    • CID data:
      • Manufacturer ID: 0x1b*
      • OEM ID: 0x534d (ASCII: SM)*
      • Product name: 0x4542315154 (ASCII: EB1QT)
      • Product revision: 0x30

    * This manufacturer ID/OEM ID is well known to be associated with Samsung.

    Sample #123Average
    Price paid$11.99$11.80$11.80$11.86
    Manufacture dateFeb 2020Feb 2020Not yet testedN/A
    Serial number0x1d4e67b60x34146748Not yet testedN/A
    Sequential read speed (MB/sec)91.2190.69Not yet tested90.95
    Sequential write speed (MB/sec)28.4828.23Not yet tested28.36
    Random read speed (IOPS/sec)1,672.431,677.64Not yet tested1,675.04
    Random write speed (IOPS/sec)352.26424.28Not yet tested388.27
    Read/write cycles to first errorNot yet determinedNot yet determinedNot yet testedNot yet determined
    Read/write cycles to complete failureNot yet determinedNot yet determinedNot yet testedNot yet determined
    Total days to complete failureNot yet determinedNot yet determinedNot yet testedNot yet determined
    Card reader usedJJS CR-UTC4ACJJS CR-UTC4ACNot yet testedN/A
    Package frontNot yet testedN/A
    Package backNot yet testedN/A
    Card frontNot yet testedN/A
    Card backNot yet testedN/A

    Discussion

    Samsung is a pretty well known name in the electronics industry, and flash memory is no exception. I purchased this one because I wanted to have a few legitimately obtained, name brand cards in my collection to compare the AliExpress samples to. I would like to have a couple more samples to test, but these cards are a bit more expensive than many of the others in my collection and it'll have to wait until I can spare the money to buy some more.

    One thing of consequence that I'll note: Samsung is one of two mainstream brands (of the ones I evaluated) whose flash was neither fake nor skimpy (Lexar being the other). Both of the Samsung cards in my collection currently are 32GB cards, and both offered at least 32 billion bytes of user space. Many of the other name brands -- including Kioxia, SanDisk, and Kingston -- provided cards that were all skimpy, so I was pleasantly surprised to see that Samsung was not.

    Performance-wise, I was actually a bit disappointed. Sequential read speeds were well above average, but all of the other scores were just...average. For such a well-recognized brand, I would have expected better. However, this card did perform well enough to qualify for the Class 10 and U1 marks that it carried.

    Endurance-wise, sample #1 has done pretty well. As of this writing, it has gone 3,272 read/write cycles and has not experienced any errors. Sample #2 has not yet hit the 2,000 read/write cycle mark; it is currently expected to get there sometime in May 2024. Sample #3 is still in the package waiting to be tested.

    Last updated: 2/25/2024

    Samsung EVO Plus 64GB

    • Obtained from: AliExpress
    • Price paid: $3.99
    • Advertised capacity: 64GB
    • Logical capacity: 64,088,965,120 bytes
    • Physical capacity: 64,088,965,120 bytes
    • Fake/skimpy flash: No
    • Speed class markings: Class 10*, U1, V10, A1
    • CID data:
      • Manufacturer ID: 0x1b**
      • OEM ID: 0x534d (ASCII: SM)**
      • Product name: 0x4543315335 (ASCII: EC1S5)
      • Product revision: 0x30

    * The Class 10 mark appears on the package, but does not appear on the card itself.

    ** This manufacturer ID/OEM ID combination is pretty well known to be associated with Samsung.

    Sample #123Average
    Manufacture dateJul 2023Not yet testedNot yet testedN/A
    Serial number0x09a55f26Not yet testedNot yet testedN/A
    Sequential read speed (MB/sec)150.44Not yet testedNot yet tested150.44
    Sequential write speed (MB/sec)27.20Not yet testedNot yet tested27.20
    Random read speed (MB/sec)2,913.70Not yet testedNot yet tested2,913.70
    Random write speed (MB/sec)446.07Not yet testedNot yet tested446.07
    Read/write cycles to first errorNot yet determinedNot yet testedNot yet testedNot yet determined
    Read/write cycles to complete failureNot yet determinedNot yet testedNot yet testedNot yet determined
    Total days to complete failureNot yet determinedNot yet testedNot yet testedNot yet determined
    Card reader usedJJS CR-UTC4ACNot yet testedNot yet testedN/A
    Package frontNot yet testedNot yet testedN/A
    Package backNot yet testedNot yet testedN/A
    Card frontNot yet testedNot yet testedN/A
    Card backNot yet testedNot yet testedN/A

    Discussion

    I'm not 100% sure why I decided to buy these. I think that it might have been because of the sale that AliExpress was running on these, and I figured that it might make a good substitute for having three of the EVO Plus 32GB's (before I decided to buy two more of them).

    With a skimp rating of -0.14%, Samsung continued their reputation here of being one of the only name-brands that has not skimped on storage space.

    The package advertises that this card gets transfer speeds of "up to 130MB/s". Of course, it doesn't specify whether that's referring to read speeds or write speeds, but I think it's pretty obvious (to me, at least) that it's referring to read speeds. I've only tested one sample so far, but it managed to meet that expectation -- even going beyond it -- and getting a sequential read speed that was more than two standard deviations above average. Random read scores were more than one standard deviation above average, and random write scores were above average. Sequential write scores, however, were slightly below average. These metrics are good enough for the U1 and V10 marks that it carries -- and the Class 10 mark on the package -- but not quite good enough for the A1 mark (as that requires a random write speed of at least 500 writes per second). Perhaps this card would have met the mark had it been tested under the right conditions. I'm curious to see how the other two samples will perform.

    Sample #1 has not yet hit the 2,000 read/write cycle mark. It is currently expected to reach that point sometime in late June 2024. Samples #2 and #3 are still in the package, waiting to be tested.

    Last updated: 2/25/2024

    Samsung PRO Endurance 32GB

    • Obtained from: Amazon
    • Price paid: $6.99
    • Advertised capacity: 32GB
    • Logical capacity: 32,044,482,560 bytes
    • Physical capacity: 32,044,482,560 bytes
    • Fake/skimpy flash: No
    • Speed class markings: Class 10*, U1, V10
    • CID data:
      • Manufacturer ID: 0x1b*
      • OEM ID: 0x534d (ASCII: SM)*
      • Product name: 0x4a42315135 (ASCII: JB1Q5)
      • Product revision: 0x30

    * This manufacturer ID/OEM ID is pretty well known to be associated with Samsung.

    Sample #123Average
    Manufacture dateAug 2023Jan 2024Dec 2023N/A
    Serial number0x418e5fef0x656057b50xc4b65783N/A
    Sequential read speed (MB/sec)89.9683.2383.0185.40
    Sequential write speed (MB/sec)28.7028.3128.8628.62
    Random read speed (IOPS/sec)4,365.762,881.032,784.603,343.80
    Random write speed (IOPS/sec)450.28527.10526.92501.43
    Read/write cycles to first error3,687Not yet determinedNot yet determined3,687
    Read/write cycles to complete failureNot yet determinedNot yet determinedNot yet determinedNot yet determined
    Total days to complete failureNot yet determinedNot yet determinedNot yet determinedNot yet determined
    Card reader usedSmartQ SingleJJS CR-UTC4ACJJS CR-UTC4ACN/A
    Package frontN/A
    Package backN/A
    Card frontN/A
    Card backN/A

    Discussion

    This is one I purchased because -- I think -- I wanted to see how "high endurance" cards perform compared to their contemporary (low endurance?) cousins.

    As I stated above, Samsung is a pretty well-known player in the electronics industry, and their SD cards are no exception. And, as with the Samsung EVO Plus, it's nice to see that Samsung didn't skimp on storage -- in fact, this one is slightly larger than the EVO Plus.

    Performance-wise, this card did well on read tests, but I was a little disappointed by write performance. All three samples got above average sequential read and random write speeds, and scored more than one standard deviation above average on random read tests, but got below average sequential write speeds. It did well enough to qualify for all of the marks that appeared on it (nearly by a factor of 3), but when compared to the other name-brand cards I tested, it did worse on the sequential write test, and only average on the random write test.

    All three cards are still undergoing endurance testing. Sample #1 has survived 6,652 read/write cycles so far. It experienced data verification failures earlier on, but I was able to chalk those errors up to issues with my code. The first errors that I wasn't able to attribute to code issues happened during round 3,688. Samples #2 and #3 have not yet reached the 2,000 read/write cycle mark; they're currently expected to reach that point sometime in early June 2024.

    I haven't decided on a benchmark for high endurance cards...but it seems like it should be at least twice what should be expected from a normal card.

    Last updated: 2/29/2024

    SanDian Extreme PRO 128GB

    • Obtained from: AliExpress
    • Price paid: $5.22
    • Advertised capacity: 128GB
    • Logical capacity: 134,218,776,576 bytes
    • Fake/skimpy flash: Fake flash
    • Speed class markings: U3, V30, A2
    • CID data:
      • Manufacturer ID: 0x00
      • OEM ID: 0x0000
      • Product name: 0x4150505344 (ASCII: APPSD)
      • Product revision: 0x00
    Card #123Average
    Physical capacity32,193,277,440 bytes32,054,865,408 bytes33,894,067,712 bytes32,714,070,186 bytes
    Manufacture dateAug 2017Aug 2017Aug 2017N/A
    Serial number0x128000050x128000000x12800002N/A
    Sequential read speed (MB/sec)16.7315.1816.0115.97
    Sequential write speed (MB/sec)8.927.0910.738.91
    Random read speed (IOPS/sec)490.391,200.131,107.44932.65
    Random write speed (IOPS/sec)0.490.380.360.41
    Read/write cycles to first error101519Not yet determined310
    Read/write cycles to complete failureNot yet determined618Not yet determinedNot yet determined
    Total days to complete failureNot yet determined46Not yet determinedNot yet determined
    Card reader usedJJS CR-UTC4ACJJS CR-UTC4ACTogconn TOG-SD-CRN/A
    Package frontN/A
    Package backN/A
    Card frontN/A
    Card backN/A

    Discussion

    SanDian is a name that came up fairly frequently in my AliExpress searches, and it was pretty apparent that they were trying to rip off SanDisk -- from the product lineup names ("Ultra", "Extreme", "Extreme PRO"), to the similar visual design, to the logo -- which copies the styled "S" from SanDisk's logo. Seeing as how they had several options to choose from, I decided to order a few of each one -- in the 128GB and 1TB denominations. However -- and I'm going to bury the lead here -- they didn't hold a candle to SanDisk (at least so far).

    Initially I was going to lump them into the "off-brand" category; however, given just how closely they're copying SanDisk's design, I decided to re-categorize them as knockoffs.

    I found it interesting that these cards came in a package that appeared to be for a USB cable rather than the normal clamshell packaging that most SD cards come in.

    This is another instance of a seller who set the manufacturer ID and OEM ID to all zeroes to mask their identity and/or the identity of whoever manufactured these cards for them. If the remainder of the CID data is to be believed, then it would mean that these cards were over 6 years old by the time they made it to me. I did manage to find a SanDian store on AliExpress, but their front page made it appear that they were selling women's clothing -- and to boot, they had no actual products listed at the time I looked. This might mean that the SanDian name is being retired (and/or the seller has gone out of business) and that sellers who purchased their cards are simply trying to offload their remaining inventory.

    Another thing I found interesting was that physical capacity differed between the three samples. Honestly, I'm at a loss to explain this.

    Performance was pretty abysmal, with all metrics being well below average. Even when compared to other fake flash cards in my collection, scores were below average -- with the exception of sample #1's sequential read speed (which was only slightly above average) and sample #2's random read speed (which was just shy of one standard deviation above average). Performance was not good enough to qualify for any of the speed class markings this card carried. I'll add my standard "perhaps this card would have performed better if it had been tested under proper conditions" disclaimer, but I highly doubt it would have done much better. Honestly, I would have expected more from a card labeled "Extreme PRO". Much more. But then again, this is a knockoff brand.

    On the endurance front, things are not looking good so far. Sample #1 has only completed 473 read/write cycles so far; its first error was a series of bit flip errors affecting two sectors during round 102. It's been seeing a number of bit flip errors every few rounds since then. Sample #2's first error was a series of bit flip errors affecting about 3,400 sectors during round 521. The problem became progressively worse over the following rounds of testing, reaching the point where about 4.27% of the sectors on the device had experienced errors. It finally stopped responding to commands during round 619. Sample #3 has not yet hit the 2,000 read/write cycle mark; it is currently expected to reach that point sometime in September 2024.

    Last updated: 2/25/2024

    SanDian Extreme PRO 1TB

    • Obtained from: AliExpress
    • Price paid: $6.62
    • Advertised capacity: 1TB
    • Logical capacity: 1,072,694,296,576 bytes
    • Physical capacity: 29,943,033,344 bytes
    • Fake/skimpy flash: Fake flash
    • Speed class markings: U3, V30, A2
    • CID data:
      • Manufacturer ID: 0x00
      • OEM ID: 0x0000
      • Product name: 0x4150505344 (ASCII: APPSD)
      • Product revision: 0x00
    Card #123Average
    Manufacture dateApr 2014Not yet testedNot yet testedN/A
    Serial number0x12800006Not yet testedNot yet testedN/A
    Sequential read speed (MB/sec)16.71Not yet testedNot yet tested16.71
    Sequential write speed (MB/sec)15.33Not yet testedNot yet tested15.33
    Random read speed (IOPS/sec)415.03Not yet testedNot yet tested415.03
    Random write speed (IOPS/sec)9.94Not yet testedNot yet tested9.94
    Read/write cycles to first error41Not yet testedNot yet tested41
    Read/write cycles to complete failureNot yet determinedNot yet testedNot yet testedNot yet determined
    Total days to complete failureNot yet determinedNot yet testedNot yet testedNot yet determined
    Card reader usedJJS CR-UTC4ACNot yet testedNot yet testedN/A
    Package frontNot yet testedNot yet testedN/A
    Package backNot yet testedNot yet testedN/A
    Card frontNot yet testedNot yet testedN/A
    Card backNot yet testedNot yet testedN/A

    Discussion

    There's not much to say about this card that is going to be different than the 128GB version. Like its smaller sibling, this card was disappointing at best.

    Performance metrics were well below average and were only marginally better than the 128GB version -- and, like the 128GB version, were not good enough to merit any of the performance marks that it carried.

    Sample #1 is still undergoing endurance testing. It only managed to go 41 read/write cycles without errors, and as of this writing, it has survived 508 read/write cycles in total. Samples #2 and #3 are still in the "package", waiting to be tested.

    Last updated: 2/25/2024

    SanDisk Extreme 32GB

    • Advertised capacity: 32GB
    • Logical capacity: 31,914,983,424 bytes
    • Physical capacity: 31,914,983,424 bytes
    • Fake/skimpy flash: Skimpy (0.27% skimp)
    • Speed class markings: U3, V30, A1
    • CID data:
      • Manufacturer ID: 0x03*
      • OEM ID: 0x5344 (ASCII: SD)*
      • Product name: 0x534d333247 (ASCII: SM32G)
      • Product revision: 0x80

    * This manufacturer ID/OEM ID combination are pretty well known to be associated with SanDisk.

    Card #123Average
    Obtained fromAmazonAliExpressAliExpressN/A
    Price paid$10.49$9.70$9.70$9.96
    Product name0x534d333247 (ASCII: SM32G)0x534e333247 (ASCII: SN32G)0x534e333247 (ASCII: SN32G)N/A
    Manufacture dateApr 2020Sep 2023Sep 2023N/A
    Serial number0x5340b8ea0xfb2337720xfb233938N/A
    Sequential read speed (MB/sec)76.73126.87151.46118.35
    Sequential write speed (MB/sec)46.1449.2550.1448.51
    Random read speed (IOPS/sec)2,097.002,668.372,606.132,457.17
    Random write speed (IOPS/sec)339.00452.93449.49413.81
    Read/write cycles to first errorNot yet determined7470Not yet determined
    Read/write cycles to complete failureNot yet determinedNot yet determinedNot yet determinedNot yet determined
    Total days to complete failureNot yet determinedNot yet determinedNot yet determinedNot yet determined
    Card reader usedJJS CR-UTC4ACJJS CR-UTC4ACJJS CR-UTC4ACN/A
    Package frontN/A
    Package backN/A
    Card frontN/A
    Card backN/A

    Discussion

    Ok, it's time to move on to one of my favorite brands.

    Yes, I'm biased in favor of SanDisk. I've been using their microSD cards in some of my other projects for years (specifically, the SanDisk Ultra, usually the 16GB size) and have found them to be pretty rock-solid. That said, I wanted to try to be objective here. Additionally, before starting this project, my only experience was with the Ultras -- I hadn't used the Extremes or the Extreme PROs.

    I'll note here that I ordered these cards in different batches. The first batch came from Amazon, and consisted of one of each of the SanDisk Extreme and SanDisk Extreme PRO, in both the 32GB and 64GB sizes. The second batch came from AliExpress, and consisted of two each of the SanDisk Extreme and SanDisk Extreme PRO, in the 32GB size. Why order different sizes? Because SanDisk advertises different maximum speeds between the two. This version is supposed to get up to 100MB/sec read speeds, and 60MB/sec write speeds. Additionally, the 64GB model had the A2 mark, while the 32GB model had the A1 mark instead.

    I think I got slightly different versions from the two sources: the version I got from Amazon has a product name of SM32G, while the two I got from AliExpress have a product name of SN32G. There's also a noticeable difference in performance between the two: sample #1 only got about 3/4 of the way to the 100MB/sec mark, but samples #2 and #3 went well past it. (How did they do it? SanDisk apparently has some tricks up their sleeve -- see the discussion on the SanDisk Extreme PRO 64GB for more info.)

    How does this stack up against the other cards I tested? All three samples got above average scores in all performance metrics. Samples #2 and #3 got sequential read and sequential write scores that were more than one standard deviation above average. Sample #3's sequential read speeds were actually more than two standard deviations above average. Sample #2 also got a random read speed that was more than one standard deviation above average.

    This card carries the U3, V30, and A1 markings on it. The results I got are good enough to satisfy the requirements of the U3 and V30 marks; however, the A1 mark requires a random write speed of at least 500 IOPS/sec, and no single card met that requirement. Again, I'll give my standard disclaimer of "perhaps this card would have done better had it been tested under proper conditions". The two AliExpress samples were close enough to this mark that this could actually be true.

    Endurance tests for these cards are still ongoing. Sample #1 did manage to make it past the 2,000 read/write cycle mark without errors; it has currently survived 2,977 read/write cycles and still has not experienced any errors. Samples #2 and #3 only managed to go about about 70 read/write cycles each before they experienced their first error; they have survived 1,033 and 1,036 read/write cycles (respectively) so far.

    Last updated: 2/22/2024

    SanDisk Extreme 64GB

    • Obtained from: Amazon
    • Price paid: $10.43
    • Advertised capacity: 64GB
    • Logical capacity: 63,864,569,856 bytes
    • Physical capacity: 63,864,569,856 bytes
    • Fake/skimpy flash: Skimpy (0.21% skimp)
    • Speed class markings: U3, V30, A2
    • CID data:
      • Manufacturer ID: 0x03*
      • OEM ID: 0x5344 (ASCII: SD)*
      • Product name: 0x534e363447 (ASCII: SN64G)
      • Product revision: 0x86
      • Serial number: 0xd84929ad
      • Manufacture date: Sep 2023
    • Sequential read speed (MB/sec): 85.94
    • Sequential write speed (MB/sec): 51.68
    • Random read speed (IOPS/sec): 3334.23
    • Random write speed (IOPS/sec): 293.81
    • Read/write cycles to first error: 1,269
    • Read/write cycles to complete failure: Not yet determined
    • Total days to complete failure: Not yet determined
    • Card reader used: SanDisk MobileMate
    • Package front:
    • Package back:
    • Card front:
    • Card back:

    * This manufacturer ID/OEM ID combination is pretty well known to be associated with SanDisk.

    Discussion

    Continuing my (hopefully objective) evaluation of SanDisk cards, I purchased both the 32GB and the 64GB versions of this card. As I alluded to earlier, I purchased the 64GB version for a very particular reason.

    SanDisk has a "gimmick" with some of their cards: they're UHS-I cards, but SanDisk advertises speeds that are beyond what should be possible under the UHS-I spec. Under UHS-I, the maximum clock speed for an SD card is 208MHz, and SD cards have four lines for transferring data -- which means that the maximum possible speed should be 832Mbit/sec, or 104MB/sec. However, this card advertises that it can get read speeds of up 170MB/sec and write speeds of up to 80MB/sec. I don't know exactly how they do this, but if you look closely at the package, there's an asterisk: it requires a "compatible device capable of reaching such speeds". There's also a note on the front of the package that says "Compatible with SanDisk Professional PRO-READER SD and microSD to achieve stated read speeds". I suspect that these card readers have some mechanism to detect whether the card is one that should support these higher speeds; if they do, I suspect that the reader simply overclocks the card to get those speeds.

    I don't have one of the SanDisk Professional PRO-READER SD or microSD readers; however, I do have several SanDisk MobileMate microSD readers -- and on the package, it says -- quite prominently -- "Enables SanDisk enhanced UHS-I microSD card speeds". This should mean that I should be able to use this reader with this card and get the speeds they advertise (or close to it), right? Well...nope. Actual read/write speeds only got about halfway to the maximum stated on the package.

    Compared to the other cards in my collection, sequential read and sequential write speeds were above average, with sequential write speeds being more than one standard deviation above average. Random read speeds were more than one standard deviation above average as well; however, random write speeds were slightly below average. Compared to the other name-brand cards that I tested, sequential read and random write speeds were below average. While this is good enough for the U3 and V30 marks that it carries, the A2 mark requires random read speeds of 4,000 IOPS/sec and random write speeds of 2,000 IOPS/sec -- and this card fell well short of that.

    Side note: no card I've tested so far has met the performance thresholds for the A2 mark. To reach the speeds required for the A2 mark requires some pretty advanced features of the SD spec, which probably requires hardware beyond what I have. However, this card's random write speeds weren't even good enough for the A1 mark -- and seeing as how I have other cards in my collection that did meet the threshold for the A1 mark, I doubt that it would have performed well enough for the A2 mark even if it had been tested under the right conditions.

    Endurance tests for this card are still ongoing. This card suffered several data shift errors starting in round 1,270. It has survived 3,225 read/write cycles in total. While disappointing that this card couldn't make it past the 2,000 read/write cycle mark without errors, the number of sectors affected so far has been fairly small (only 114).

    Final note: At some point I want to get some additional samples of this card and see how they compare to this one. I'll update this once I have those results. (Update: I have some additional samples on the way.)

    Last updated: 2/25/2024

    SanDisk Extreme PRO 32GB

    • Advertised capacity: 32GB
    • Logical capacity: 31,914,983,424 bytes
    • Physical capacity: 31,914,983,424 bytes
    • Fake/skimpy flash: Skimpy (0.27% skimp)
    • Speed class markings: U3, V30, A1
    • CID data:
      • Manufacturer ID: 0x03*
      • OEM ID: 0x5344 (ASCII: SD)*
      • Product name: 0x5350333247 (ASCII: SP32G)
      • Product revision: 0x80

    * This manufacturer ID/OEM ID combination is pretty well known to be associated with SanDisk.

    Card #123Average
    Obtained fromAmazonAliExpressAliExpressN/A
    Price paid$12.63$8.55$8.55$9.91
    Serial number0x7a8797900x8958014d0x87b80078N/A
    Manufacture dateJun 2023Mar 2023Mar 2023N/A
    Sequential read speed (MB/sec)88.3687.2388.0587.88
    Sequential write speed (MB/sec)54.3553.9353.6953.99
    Random read speed (IOPS/sec)1,867.131,882.371,830.301,859.93
    Random write speed (IOPS/sec)424.56442.15430.39432.37
    Read/write cycles to first errorNot yet determined117155136
    Read/write cycles to complete failureNot yet determinedNot yet determinedNot yet determinedNot yet determined
    Total days to complete failureNot yet determinedNot yet determinedNot yet determinedNot yet determined
    Card reader usedJJS CR-UTC4ACJJS CR-UTC4ACJJS CR-UTC4ACN/A
    Package frontN/A
    Package backN/A
    Card frontN/A
    Card backN/A

    Discussion

    In addition to the SanDisk Extremes, I wanted to test out some SanDisk Extreme PROs as well to see if there was any significant difference between the two.

    Like the SanDisk Extreme 32GB, this card doesn't make any extravagant speed claims -- just "speeds" (it doesn't specifically call out read or write speeds) of up to 100MB/sec. However, unlike the Extreme 32GB, I did not receive different models from Amazon vs. AliExpress -- both versions had their product name set to SP32G. All performance metrics for all three samples were above average, with sequential write speeds -- again, on all three samples -- being more than one standard deviation above average. Sequential read/write speeds and random write speeds were slightly better than SM32G, although random read speeds were worse. Compared to the SN32Gs, however, read speeds (both sequential and random) were considerably worse, and write speeds (both sequential and random) were on par. Compared to the other name-brand cards that I tested, sequential read speeds were slightly below average, but all other metrics slightly better. Performance was good enough to merit the U3 and V30 marks; however, the A1 mark requires a write performance of at least 500 IOPS/sec, and all three samples fell a little short here. This is going to be another case where I'll throw in my standard disclaimer: these cards may have done better here if they had been tested under proper conditions. They came close enough to the 500 IOPS/sec mark that this might actually be true.

    Endurance tests for this card are still ongoing. Sample #1 did make it past the 2,000 read/write cycle mark without experiencing any errors; it has currently survived 2,977 read/write cycles and still has not yet experienced any errors. Samples #2 and #3, on the other hand, only survived 117 and 155 read/write cycles -- respectively -- before running into data shift errors. They have each survived 1,170 read/write cycles total so far.

    Last update: 2/25/2024

    SanDisk Extreme PRO 64GB

    • Obtained from: Amazon
    • Price paid: $12.99
    • Advertised capacity: 64GB
    • Logical capacity: 63,864,569,856 bytes
    • Physical capacity: 63,864,569,856 bytes
    • Fake/skimpy flash: Skimpy (0.21% skimp)
    • Speed class markings: U3, V30, A2
    • CID data:
      • Manufacturer ID: 0x03*
      • OEM ID: 0x5344 (ASCII: SD)*
      • Product name: 0x5352363447 (ASCII: SR64G)
      • Product revision: 0x86
      • Serial number: 0xa5f89e85
      • Manufacture date: Sep 2023
    • Sequential read speed (MB/sec): 86.43
    • Sequential write speed (MB/sec): 60.34
    • Random read speed (IOPS/sec): 2,023.75
    • Random write speed (IOPS/sec): 349.67
    • Read/write cycles to first error: Not yet determined
    • Read/write cycles to complete failure: Not yet determined
    • Total days to complete failure: Not yet determined
    • Card reader used: JJS CR-UTC4AC
    • Package front:
    • Package back:
    • Card front:
    • Card back:

    * This manufacturer ID/OEM ID combination is pretty well known to be associated with SanDisk.

    Discussion

    As with the SanDisk Extreme 64GB, this card makes some pretty extravagant performance claims -- which is why I got it. This one's claims are even more extravagant than the SanDisk Extreme 64GB -- it claims you can get read speeds of up to 200MB/sec and write speeds of up to 90MB/sec.

    Before I talk about performance, I want to talk a little bit about the card reader I used for this card: the JJS CR-UTC4AC. JJS doesn't specify which chip they use, but some deduction can tell us which one they probably used. The reader gives its vendor ID as 0x05e3 and its product ID as 0x0764. Vendor ID 0x05e3 belongs to Genesys Logic, Inc. The Linux USB project maintains a list of known vendor ID/product ID combinations; however, this list doesn't have an entry for product ID 0x0764. We're not finished yet, however.

    If we go to Genesys Logic's website and look at the list of the card reader controllers that they offer, we see that they offer -- as of this writing -- 20 different options:

    A screenshot from Genesys Logic's website showing a list of card reader controllers they offer.

    We can filter out some of these options based on what we know:

    • The last two options -- the GL9750 and the GL9755 are PCI Express (not USB), so we can knock them off the list.
    • The three options directly above that -- the GL835, GL835T, and GL892S -- are only USB 2.0, so we can knock those off the list.
    • The GL3227E and GL3224E are eMMC controllers, so we can knock those off the list.
    • The GL3232, GL3232S, GL3213L, and GL3233T are all single-LUN readers, so we can knock them off the list.
    • UHS-II was added in version 4 of the SD card specification. The GL3230, GL3231, GL3223, GL3224, GL3224L, and GL3235 only support version 3 of the SD card spec, so we can knock those off the list.
    • If we pull up the product page for the GL3239, it only mentions support for version 1.0, 1.1, 2.0, and 3.0 of the SD specification -- no mention of version 4.0, which means we can knock this one off the list as well.

    This leaves us with only two options: the GL3230S and the GL3231S. The GL3230S is a controller that supports a wide array of memory card types: not just SD/MMC, but also CompactFlash and Memory Stick (and its many derivatives). The GL3231S, on the other hand, only supports SD/MMC (and their derivatives). In addition, the GL3230S is a 4-LUN chip, while the GL3230S is a 2-LUN chip. It's been my experience that multi-LUN card readers generally present all of their LUNs to the host as soon as it's plugged in (regardless of whether or not there's a card plugged into it) -- and these readers only present two to my system. (Additionally, the GL3230S is probably more expensive than the GL3231S -- and JJS probably wouldn't have paid extra for those extra LUNs unless they planned to actually use them.)

    Based on this, I think it's probably safe to say that these readers use the GL3231S.

    Why all the detective work? Well...if you look at the product page for this reader, there's a statement that stands out to me. It's even in the very first paragraph on the page:

    Screenshot from Genesys Logic's website, from the product page for the GL3231S.  The statement "GL3231S also supports SANDISK EXTREME 160MB/s microSD UHS-I CARD" is highlighted.

    Now...you could make the argument that this statement is only saying that it supports the card itself -- not the enhanced transfer rates that this card offers. But if that's the case, why bother making that statement at all? Without the enhanced transfer rates, the SanDisk Extreme cards are just regular SD cards -- and they don't bother to call out any other SD cards by name. To me, this means that this reader should support the enhanced transfer rates offered by the SanDisk Extremes. (I'm also choosing to believe that it supports the SanDisk Extreme PROs as well.)

    But...the performance measurements tell a different story. Sure, all of the measurements were above average, but were far below the maximum speeds advertised on the package. I was, frankly, disappointed.

    Of course...this card reader was able to get higher speeds with the Extreme 32GB -- even going well past what SanDisk advertised -- so it's not the card reader that's the issue here.

    Now...if we look at it for what it is? Like I said, all performance metrics were above average -- with write speeds being more than one standard deviations above average -- being beaten out only by one of the Kioxia Exceria G2s. However, when compared to the other name-brand cards I tested, all performance metrics (with the exception of sequential write speeds) were actually below average. Performance was more than enough to merit the U3 and V30 marks, but -- as with the SanDisk Extreme 64GB -- random write performance was well short of what would have been needed for even the A1 mark, let alone the A2 mark.

    Endurance tests for this card are still ongoing; it has not yet hit the 2,000 read/write cycle mark. It is currently expected to get there sometime in late April 2024.

    Final note: At some point, I want to order a couple more samples of this card. I'll update this page once I've done that and I've had a chance to test them. (Update: I have some more samples on the way.)

    Last updated: 2/25/2024

    SanDisk High Endurance 64GB

    • Obtained from: Amazon
    • Advertised capacity: 64GB
    • Logical capacity: 63,864,569,856 bytes
    • Physical capacity: 63,864,569,856 bytes
    • Fake/skimpy flash: Skimpy (0.21% skimp)
    • Speed class markings: Class 10*, U3, V30*
    • CID data:
      • Manufacturer ID: 0x03**
      • OEM ID: 0x5344 (ASCII: SD)
      • Product name: 0x5348363447 (ASCII: SH64G)
      • Product revision: 0x80
    Card #123Average
    Price paid$10.89$9.99$9.99$10.29
    Serial number0x8eaecd1c0xd78e8cd40x8655b086N/A
    Manufacture dateJun 2023Jun 2023Apr 2023N/A
    Sequential read speed (MB/sec)87.2082.4584.9484.86
    Sequential write speed (MB/sec)47.9144.3143.7245.31
    Random read speed (IOPS/sec)1,323.571,389.351,543.151,418.69
    Random write speed (IOPS/sec)217.65448.83433.76366.75
    Read/write cycles to first errorNot yet determinedNot yet determined159159
    Read/write cycles to complete failureNot yet determinedNot yet determinedNot yet determinedNot yet determined
    Total days to complete failureNot yet determinedNot yet determinedNot yet determinedNot yet determined
    Card reader usedSmartQ SingleJJS CR-UTC4ACJJS CR-UTC4ACN/A
    Package frontN/A
    Package backNot availableN/A
    Card frontN/A
    Card backN/A

    * The Class 10 and V30 markings appeared on the card, but did not appear on the packaging.

    ** This manufacturer ID/OEM ID combination is pretty well known to be associated with SanDisk.

    Discussion

    At one point in time, I decided that I wanted to try out some "high endurance" cards to see if they really held up better on the endurance tests than other cards. For this, I got both this card and the Samsung PRO Endurance.

    Performance-wise, compared to the other cards I tested, this card did rather well in sequential read/write speeds (with sample #1 getting sequential write speeds that were more than one standard deviation above average), but relatively poorly on random read/write tests. Performance was more than enough to qualify for the Class 10, U3, and V30 markings that it carried. Compared to just the name brand cards, this card performed about average on the sequential write tests, and below average on sequential read and random read/write tests. However, if I stop to think about it for a minute, this makes sense: these cards were probably designed to be used in things like security cameras or dashcams, where video is constantly being recorded to the card and old footage is being overwritten. This type of activity involves a lot of sequential writing, so a card being used for this type of activity benefits from having better sequential write speeds.

    Endurance tests are still ongoing with this card; however, as of this writing, sample #1 has survived 3,260 read/write cycles without issues. Samples #2 has not yet hit the 2,000 read/write cycle mark; it is currently expected to reach that point sometime in mid-May 2024. Sample #3 suffered a data shift error after only 159 read/write cycles; it has endured 555 read/write cycles so far. Again, I haven't decided on a baseline for high endurance cards -- so I don't know what's a good metric for a high endurance card. It'll be interesting to keep an eye on these cards and see how long they last.

    Last updated: 2/25/2024

    SanDisk Industrial 8GB

    • Obtained from: Amazon
    • Price paid: $8.17
    • Advertised capacity: 8GB
    • Logical capacity: 7,948,206,080 bytes
    • Physical capacity: 7,948,206,080 bytes
    • Fake/skimpy flash: Skimpy (0.65% skimpy)
    • Speed class markings: Class 10, U1
    • CID data:
      • Manufacturer ID: 0x03*
      • OEM ID: 0x5344 (ASCII: SD)*
      • Product name: 0x5341303847
      • Product revision: 0x80

    * This manufacturer ID/OEM ID is pretty well known to be associated with SanDisk.

    Sample #123Average
    Manufacture dateMar 2019Mar 2019Not yet testedN/A
    Serial number0xcc54e0d30x8b4dd1bfNot yet testedN/A
    Sequential read speed (MB/sec)87.6288.48Not yet tested88.05
    Sequential write speed (MB/sec)30.1133.03Not yet tested31.57
    Random read speed (IOPS/sec)1,576.831,667.88Not yet tested1,622.36
    Random write speed (IOPS/sec)321.35350.69Not yet tested336.02
    Read/write cycles to first errorNot yet determinedNot yet determinedNot yet testedNot yet determined
    Read/write cycles to complete failureNot yet determinedNot yet determinedNot yet testedNot yet determined
    Total days to complete failureNot yet determinedNot yet determinedNot yet testedNot yet determined
    Card reader usedJJS CR-UTC4ACJJS CR-UTC4ACNot yet testedN/A
    Package frontNot yet testedN/A
    Package backNot yet testedN/A
    Card frontNot yet testedN/A
    Card backNot yet testedN/A

    Ok...why did I buy this one? Because I wanted to see what other offerings SanDisk has, but also because I think that at this point, I'm just on a mission to figure out who makes the most reliable microSD cards.

    I thought it was interesting that these cards came in a simple plastic case. I'm guessing SanDisk only sells these cards by the tray, and the seller simply repackaged them to sell them individually.

    As far as performance goes, this card is almost the definition of the "average" card. Sequential read speeds were slightly above average, while all other performance metrics were right around average. Overall...it was just...average.

    Endurance tests for this card are still ongoing. Samples #1 and #2 have not yet hit the 2,000 read/write cycle mark. Sample #1 is expected to reach the 2,000 read/write cycle mark sometime in mid-March 2024; sample #2 is expected to reach this point sometime in late March 2024. Sample #3 is still in the package waiting to be tested.

    Last updated: 2/29/2024

    SanDisk Ultra 32GB

    • Obtained from: AliExpress
    • Price paid: $6.49
    • Advertised capacity: 32GB
    • Logical capacity: 31,914,983,424 bytes
    • Physical capacity: 31,914,983,424 bytes
    • Fake/skimpy flash: Skimpy (0.27% skimp)
    • Speed class markings: Class 10, U1*, A1
    • CID data:
      • Manufacturer ID: 0x03**
      • OEM ID: 0x5344 (ASCII: SD)**
      • Product name: 0x5344333247 (ASCII: SD32G)
      • Product revision: 0x85

    * The U1 marking appeared on the card, but did not appear on the package.

    ** This manufacturer ID/OEM ID is pretty well known to be associated with SanDisk.

    Card #123Average
    Serial number0x5ce0bc8b0x5cf0bc89Not yet testedN/A
    Manufacture dateDec 2022Dec 2022Not yet testedN/A
    Sequential read speed (MB/sec)83.9692.48Not yet tested88.22
    Sequential write speed (MB/sec)23.7624.15Not yet tested23.96
    Random read speed (IOPS/sec)3,386.413,777.71Not yet tested3,582.06
    Random write speed (IOPS/sec)469.10381.76Not yet tested425.43
    Read/write cycles to first error1,9051,583Not yet tested1,744
    Read/write cycles to complete failureNot yet determinedNot yet determinedNot yet testedNot yet determined
    Total days to complete failureNot yet determinedNot yet determinedNot yet testedNot yet determined
    Card reader usedTogconn TOG-SD-CRSanDisk MobileMateNot yet testedN/A
    Package frontNot yet testedN/A
    Package backNot yet testedN/A
    Card frontNot yet testedN/A
    Card backNot yet testedN/A

    Discussion

    The SanDisk Ultra has been my go-to SD card for a number of years now. I run a farm of single-board computers, and I've been primarily using these cards (in the 16GB denomination) as the primary storage device for these devices -- and in general, I've found them to be cheap and reliable. I've had good luck with them, but I wanted to be objective here and make sure that I ran these through the same paces as the other cards in my collection.

    Performance-wise, these cards did well in both sequential read and random read/write speeds, but slightly below average in sequential write speeds. Both samples tested so far performed more than one standard deviation above average in random read speeds, with sample #1 performing more than two standard deviations above average. This was enough to merit the Class 10 and U1 markings; however, it fell short of the 500 IOPS/sec of random write performance required for the A1 mark. I'll throw in my standard "perhaps this card would have done better if it had been tested under proper conditions" disclaimer here -- sample #1 was close enough that this may actually be true.

    This is another UHS-I card that advertises speeds higher than what should be possible under the UHS-I standard: the package advertises (in Chinese) "speeds up to 120MB/second". To give this card a fair chance, I tested one of them using one of the SanDisk MobileMate readers, but it didn't seem to perform significantly better with this reader than it did with the Togconn reader.

    Endurance tests for these cards are still ongoing. Sample #1's first error was a data shift error during round 1,906; it has survived 2,171 read/write cycles so far. Sample #2's first error was a data shift error during round 1,584; it has survived 3,828 read/write cycles so far.

    Last updated: 2/25/2024

    Sansumg Pro Plus 2TB

    • Obtained from: AliExpress
    • Price paid: $4.63
    • Advertised capacity: 2TB
    • Logical capacity: 2,147,483,648,000 bytes
    • Physical capacity: 8,489,271,296 bytes
    • Fake/skimpy flash: Fake flash
    • Speed class markings: U3, V30, A2
    • CID data:
      • Manufacturer ID: Unknown*
      • OEM ID: Unknown*
      • Product name: Unknown*
      • Product revision: Unknown*
      • Serial number: Unknown*
      • Manufacture date: Unknown*
    • Sequential read speed (MB/sec): 9.98
    • Sequential write speed (MB/sec): 9.07
    • Random read speed (IOPS/sec): 574.04
    • Random write speed (IOPS/sec): 0.79
    • Read/write cycles to first error: 1,970
    • Read/write cycles to complete failure: 1,970
    • Total days to complete failure: 45
    • Card reader used: SmartQ Single**
    • Package front:
    • Package back: Not available
    • Card front:
    • Card back:

    * These values are unknown because I didn't have the idea to dump the card registers until later in this project; by the time I thought to do it, this card had already died.

    ** I think. Seeing as how this is one of the first cards I tested, I would have only had SmartQ Single's at that point in time.

    Discussion

    Before I go any further: yes, "Sansumg" is misspelled. No, it's not a typo. This is one of the first cards that I bought off of AliExpress, and I spotted the misspelling immediately -- in fact, it was the whole reason I ordered it. The makers of this card even went so far as to try to make their logo look like Samsung's -- taking Samsung's logo and switching the "M" and "N" around.

    Being fake flash, this card did about as abysmally as I expected on its performance tests -- maybe even worse. All performance metrics were more than one standard deviation below average. This is not a unique distinction -- it's shared by a few other cards in my collection -- however, what does make this card stand apart is the fact that it had the lowest score in the sequential read test out of any of the cards I tested. In fact, not only does it not qualify for any of the performance marks that it carries, but it didn't even meet any single threshold for any of its performance marks.

    I was about to be impressed by how long this card managed to last in its endurance tests; however, it failed just shy of the 2,000 read/write cycle mark. It failed pretty suddenly, and just suddenly stopped responding to commands from the system.

    Last updated: 2/25/2024

    "Sony" 32GB

    • Obtained from: AliExpress
    • Price paid: $4.66
    • Advertised capacity: 32GB
    • Logical capacity: 31,266,439,168 bytes
    • Physical capacity: 31,266,439,168 bytes
    • Fake/skimpy flash: Skimpy (2.29% skimp)
    • Speed class markings: Class 10, U1, A1
    • CID data:
      • Manufacturer ID: 0x00
      • OEM ID: 0x3432 (ASCII: 42)
      • Product name: 0x5344313647 (ASCII: SD16G)
      • Product revision: 0x20
      • Serial number: 0x00000378
      • Manufacture date: Sep 2023
    • Sequential read speed (MB/sec): 67.63
    • Sequential write speed (MB/sec): 17.57
    • Random read speed (IOPS/sec): 1448.45
    • Random write speed (IOPS/sec): 273.42
    • Read/write cycles to first error: 518
    • Read/write cycles to complete failure: Not yet determined
    • Total days to complete failure: Not yet determined
    • Card reader used: JJS CR-UTC4AC
    • Package front:
    • Package back:
    • Card front:
    • Card back:

    Discussion

    This is another card that I bought for two reasons: to see if I could find genuine flash and fake flash in the same brand, and to evaluate a knockoff brand. I believe I succeeded on both points here.

    Knockoff brands like these usually follow a pretty similar M.O.: they take the name of a brand that's a pretty well known electronics manufacturer, but who isn't known for producing flash media (or usually any storage media whatsoever). In this respect, Sony fits this bill. Perhaps they can do this so that it's harder to disprove that their product is genuine -- if there's no genuine article to compare it to, then it's harder for someone to say that their product isn't genuine. That said, I heavily suspected that this card was going to be a knockoff when I ordered it.

    This card is another example where the manufacturer set the manufacturer ID to all zeroes, likely in an attempt to mask the manufacturer's true identity. However, there are a number of cards in my collection that all share the same OEM ID and product ID, including the three Cloudisk cards, one of the Auotkn Extreme 8GB cards, and one of the Bekit 8GB cards -- I'm willing to bet that all of these were made by the same manufacturer.

    Performance on this card was mediocre overall. Read performance (both sequential and random) and random write performance were all average or slightly below average, while sequential write performance was pretty solidly below average. Compared to the other knockoff cards I evaluated, however, this card actually did quite well: sequential read and random write speeds were more than two standard deviations above average, and sequential write and random read speeds were one standard deviation above average. These scores were enough to merit the Class 10 and U1 markings it carries; however, both random read and random write performance fell short of the threshold for the A1 marking. I honestly don't think there's any way that this card would qualify for the A1 marking -- and I can say that because I'm not scared of "Sony" coming after me for that comment.

    Endurance tests for this card are still ongoing. It experienced a data verification failure during round 518 that affected 32 contiguous sectors, which was probably the result of a failed write operation earlier in the round. Since then, it's been experiencing a few bit flip errors every few rounds since then. It has survived a total of 1,061 read/write cycles so far.

    Last updated: 2/25/2024

    "Sony" 1TB

    • Obtained from: AliExpress
    • Price paid: $5.17
    • Advertised capacity: 1TB
    • Logical capacity: 1,073,742,872,576 bytes
    • Physical capacity: 31,224,393,216 bytes
    • Fake/skimpy flash: Fake flash
    • Speed class markings: Class 10, U1, A1
    • CID data:
      • Manufacturer ID: 0x00
      • OEM ID: 0x0000
      • Product name: 0x0050ffffb0
      • Product revision: 0x00
      • Serial number: 0x12800188
      • Manufacture date: Aug 2013
    • Sequential read speed (MB/sec): 11.83
    • Sequential write speed (MB/sec): 10.08
    • Random read speed (IOPS/sec): 492.28
    • Random write speed (IOPS/sec): 6.01
    • Read/write cycles to first error: 359
    • Read/write cycles to complete failure: 460
    • Total days to complete failure: 48
    • Card reader used: JJS CR-UTC4AC
    • Package front:
    • Package back:
    • Card front:
    • Card back:

    Discussion

    Like the smaller 32GB sibling, I bought this to see if I could find genuine flash and fake flash in the same brand, as well as to evaluate some knockoff brands. Unsurprisingly, this card turned out to be fake flash -- which I heavily suspected would be the case when I ordered it. It was a bit of a surprise that it turned out to have 32GB of space -- as opposed to some of the other fake cards I have, which were 4GB and 8GB.

    This card did pretty abysmally in terms of performance, falling more than one standard deviation below average on all performance metrics. It even fell well below average when compared to the other knockoff cards I evaluated. It was barely enough to merit the Class 10 and U1 marks that it bore, but it fell well short of the speeds it would need to merit the A1 mark.

    Where this card surprised me was on its endurance tests: it only managed to go for 359 read/write cycles before it started showing issues, and only 460 cycles before it stopped responding to commands. This puts it well below average, even when compared to the other knockoff cards I tested, and -- as of the time of this writing -- the knockoff card that has survived the least number of read/write cycles before failing.

    Last updated: 2/25/2024

    "Xiaomi" 16GB

    • Obtained from: AliExpress
    • Price paid: $5.38
    • Advertised capacity: 16GB
    • Logical capacity: 16,106,127,360 bytes
    • Physical capacity: 4,026,329,600 bytes
    • Fake/skimpy flash: Fake flash
    • Speed class markings: Class 10, U3, A1
    • CID data:
      • Manufacturer ID: 0x00
      • OEM ID: 0x0000
      • Product name: 0x0000000000
      • Product revision: 0x00
      • Serial number: 0x000048bd
      • Manufacture date: Jan 2023
    • Sequential read speed (MB/sec): 18.96
    • Sequential write speed (MB/sec): 7.29
    • Random read speed (IOPS/sec): 1028.13
    • Random write speed (IOPS/sec): 1.48
    • Read/write cycles to first error: 0
    • Read/write cycles to complete failure: 6,618
    • Total days to complete failure: 90
    • Card reader used: JJS CR-UTC4AC
    • Package front:
    • Package back:
    • Card front:
    • Card back:

    Discussion

    This is another card that I purchased for a couple of reasons: first, because I wanted to see if it was possible to find both fake flash and non-fake flash in the same brand, but also because I wanted to evaluate a few knockoff cards. (For those of you outside of China: Xiaomi is a pretty well known electronics maker in China -- many have dubbed it "the Apple of China" -- but from what I can tell, they don't sell microSD cards...or any storage products whatsoever. This seems to be a pretty common M.O. for knockoff media sellers -- they will label something using the name of a pretty well known electronics manufacturer, even though the manufacturer they're knocking off isn't known for making flash media.)

    I purchased two samples: a 16GB and a 2TB. What surprised me is that both samples were fake flash -- I expected the 2TB card to be fake, but I didn't expect the 16GB card to be fake.

    Performance metrics were -- as to be expected -- pretty abysmal. All performance metrics were below average; and with the exception of the random read metric, all performance metrics were more than one standard deviation below average. Scores were not good enough to qualify for any of the performance marks that it bore. Perhaps it would have done better had it been tested under proper conditions, but I highly doubt it.

    On the endurance front, this card started having issues almost immediately. During the first round of testing, a 1.8MB "hole" appeared, where reads from sectors in the hole resulted in all zeroes being read back. This hole persisted in size and location during subsequent rounds. Several more such holes (of varying sizes) appeared during subsequent rounds, but did not persist for more than a few rounds. Additionally, data verification failures happened during a few rounds of testing, affecting ranges in size from a few hundred kilobytes to several megabytes. Curiously, however, these issues stopped between rounds 1,599 and 5,239 (with the exception of the original hole discovered during the first round); at this point, the card began to suffer a lot of bit flip errors. It finally failed during round 6,619 -- when any attempt to write to the card resulted in an I/O error.

    Given that the hole that appeared during the first round of testing -- which I'll call the "origi-hole" -- persisted during all rounds of testing, and combined with the fact that all subsequent errors happened after the location of the origi-hole, it could be that the origi-hole marks the end of the intended physical space, and that the remaining space is being used for wear leveling. I haven't seen any other cards exhibit this kind of behavior. If that's the case, then the true size of the device would be 3,824,201,728 bytes instead. But...that's just my guess.

    Last updated: 2/25/2024

    "Xiaomi" 2TB

    • Obtained from: AliExpress
    • Price paid: $5.89
    • Advertised capacity: 2TB
    • Logical capacity: 2,147,483,648,000 bytes
    • Physical capacity: 4,010,738,176 bytes
    • Fake/skimpy flash: Fake flash
    • Speed class markings: Class 10, U3, A1
    • CID data:
      • Manufacturer ID: 0x00
      • OEM ID: 0x0000
      • Product name: 0x0000000000
      • Product revision: 0x00
      • Serial number: 0x00000ee2
      • Manufacture date: Aug 2023
    • Sequential read speed (MB/sec): 21.33
    • Sequential write speed (MB/sec): 10.29
    • Random read speed (IOPS/sec): 655.33
    • Random write speed (IOPS/sec): 1.94
    • Read/write cycles to first error: 49
    • Read/write cycles to complete failure: Not yet determined
    • Total days to complete failure: Not yet determined
    • Card reader used: JJS CR-UTC4AC
    • Package front:
    • Package back:
    • Card front:
    • Card back:

    Discussion

    Once again, this is a card I purchased -- along with the smaller 16GB sibling -- to see if I could find fake flash and genuine flash, and to have some knockoff cards in my results. While I didn't expect the 16GB version to be fake flash, I did expect the 2TB to be fake. Admittedly, however, I was a little surprised to see that they were both 4GB -- but perhaps I should have expected that. Surprisingly, this earned it two titles: highest price per gigabyte (at $1.469 per gigabyte), and skimpiest card (offering just 0.2% of the advertised capacity).

    Performance-wise, sequential read and write scores were more than one standard deviation below average. However, when compared to the other knockoff cards in my collection, they were pretty close to average. Random read/write speeds were below average as well, even when compared to the other knockoff cards. Performance was good enough to meet the qualifications for the Class 10 mark, but not good enough for the U3 or A1 marks. I'll throw in my standard "perhaps it would have done better under the right testing conditions" disclaimer -- but I highly doubt it would have made a difference.

    Endurance tests for this card are still ongoing. The card experienced about 16MB of data verification errors during round 50; I don't know exactly where on the card these errors took place, because the version of my program that I was running at the time didn't log this information. The sectors in question here have continued to exhibit data verification failures on subsequent rounds of testing. Curiously, however, every few rounds, the errors go away and these sectors will verify correctly -- but then go back to being bad on the next round. The number of rounds between this happening seems to be variable. I'm not sure what to make of this -- if this were an artifact of wear leveling, I'd expect the "bad" sectors to reappear elsewhere on the card, which they don't seem to do. The card is still chugging along, however -- it has survived 6,990 read/write cycles so far, and has only experienced errors on about 1% of the total sectors on the device.

    Last updated: 2/26/2024

    XrayDisk High Endurance 32GB

    • Obtained from: AliExpress
    • Price paid: $3.70
    • Advertised size: 32GB
    • Logical capacity: 31,275,876,352 bytes
    • Physical capacity: 31,275,876,352 bytes
    • Fake/skimpy flash: Skimpy (2.26% skimp)
    • Speed class markings: Class 10, U1, A1
    • CID data:
      • Manufacturer ID: 0x6f
      • OEM ID: 0x0303
      • Product name: 0x5344414243 (ASCII: SDABC)
      • Product revision: 0x10
    Card #123Average
    Serial number0xaa0008a10xaa0008da0xaa0008d3N/A
    Manufacture dateMay 2023May 2023May 2023N/A
    Sequential read speed (MB/sec)58.2180.7166.9468.62
    Sequential write speed (MB/sec)47.9645.7933.1242.29
    Random read speed (IOPS/sec)1,429.201,451.991,454.281,445.16
    Random write speed (IOPS/sec)112.60394.5910.76172.65
    Read/write cycles to first error1226727
    Read/write cycles to complete failureNot yet determinedNot yet determinedNot yet determinedNot yet determined
    Total days to complete failureNot yet determinedNot yet determinedNot yet determinedNot yet determined
    Card reader usedSmartQ SingleJJS CR-UTC4ACJJS CR-UTC4ACN/A
    Package frontN/A
    Package backN/A
    Card frontN/A
    Card backN/A

    Discussion

    This is an off-brand product that came up early in my AliExpress searches, and I think the "High Endurance" part of the name may have been what inspired me to obtain the SanDisk High Endurance and Samsung PRO Endurance to have some name-brand samples to compare it to.

    Performance-wise, sequential read and random read speeds were close to average. Sequential write speeds were above average, while random write speeds were below average. Compared to the other off-brand cards I tested, however, sequential speeds and random read speeds were above average, while random write speeds were below average. Performance on all three cards was good enough to qualify for the Class 10 and U1 markings that they carried, but no single card scored well enough to qualify for the A1 marking. Given that all three cards got close to the 1,500 IOPS/sec threshold for random read operations, and sample #2 got somewhat close to the 500 IOPS/sec threshold for random write operations, it's possible that they would have performed better under proper testing conditions.

    I wish measurements had been clustered closer together -- but the fact that they're not could indicate inconsistencies with how these cards were manufactured.

    What really disappointed me, however, was endurance: all three of these cards only managed to go for a few read/write cycles before hitting their first error. The fact that this happened with all three cards and that the data points are so close together points to a possible quality control issue (although who am I kidding, these cards didn't go through any quality control). On the bright side, these cards did display some ability to self-heal, as all three cards stopped displaying errors after round 136. However, endurance tests are still ongoing: as of the time of this writing, sample #1 is the only one of the three that has made it past the 2,000 read/write cycle mark, having survived 4,602 read/write cycles so far, 3,498 of those without issues. (In the interests of full disclosure, I will say that there were more errors after round 136, but those were attributable to problems with my code that handles device disconnects/reconnects. Once those problems were fixed, the card stopped experiencing errors.) Samples #2 experienced a series of bit flip errors affecting 8 sectors starting in round 3; it has survived 2,133 read/write cycles total so far and has not experienced any further issues since then. Sample #3 experienced a series of bit flip errors affecting 18 sectors during round 68; it has survived 787 read/write cycles total so far and has not experienced any further issues since then.

    Last updated: 2/25/2024

    Known Issues

    If I'm looking at this from a scientific point of view, there are a number of issues with the way I conducted this test. I didn't have clear goals when I started this project, and that probably contributed to these issues. Below are some issues I can think of.

    Card Readers

    I experimented with various card readers during the course of this experiment, trying to determine which ones would not only perform best, but also allow me to test as many cards as possible simultaneously. This resulted in using a mix of various card readers, which may have affected my results. While the obvious difference (if any) would be in performance, it's also possible that some of the other errors I encountered were due to the card reader rather than the card. (This was certainly the case with the SmartQ Single due to its tendency to randomly stop working: if it stopped working during a write operation, a certain amount of data -- usually around 1MB -- would be lost. I had to account for this in my code by rewriting the missing data when the card reader was reconnected.)

    Performance Test Method

    The SD Card Association's Physical Layer Specification provides a number of criteria for how speed tests are to be performed -- including block size, commands to be used, preconditioning of the card, size of write operations, size of the area to be written to, length of the test, etc. These criteria were not followed for a number of reasons -- primarily owing to the fact that USB card readers don't expose a lot of the functionality needed. I would like to develop something that could run on an FPGA and run the tests using the conditions prescribed in the specification. (I have an FPGA starter kit that I'm learning on now, but I will need a faster one at some point in the future, as I can only run the SD bus at 25MHz with the one I have. Side note: I did try to do this with an Arduino Duo as a proof of concept, but I was only able to run the SD bus at about 10KHz with it -- and the clock signal was not very stable with it.)

    Endurance Test Method

    The endurance test is a continuous test -- during each round, the host overwrites the entire user area of the card, as fast as conditions will allow. Once this process has finished, the host immediately proceeds to read back the entire user area of the card -- again, as fast as conditions will allow. While this is representative of some uses cases, it fails to take some other common use cases into account.

    One such use case would be in a mobile phone or mobile gaming console (yes, I'm looking at you, Nintendo Switch), where the card would have a tendency to heat up and cool down according to when the user uses their device. A possible follow-up experiment would be to perform an endurance test where testing is paused (and the device is allowed to cool down) between every round or every few rounds of testing, or where the card is removed from the card reader and placed in a cold environment (such as a refrigerator or freezer) for a certain amount of time before being returned to the card reader.

    Another such use case would be in a digital camera, where the ability to retain data for long periods of time is an important factor. A possible follow-up experiment would be to perform an endurance test where the card is overwritten, then placed in storage for a certain amount of time, then read back and compared to the original data written.

    Host Machines Used

    While I don't think it had much of an influence on my results, I did use two different machines for this experiment. Let's face it -- I'm trying to do this on the cheap, so I grabbed a couple of old laptops I had sitting around, put RAM and a hard drive back in one of them, installed Ubuntu on them, and put them to work. The first laptop I used was an MSI GE62VR-7RF that had an i7-7700HQ; the other one was a Lenovo Y580 that had an i7-3630QM. Theoretically there could have been some irregularity in the results caused by, say, differences in the USB host controller -- but at this point in time, I don't have any reason to suspect this is the case.

    Ubuntu Version Used

    As I mentioned above, I used two different machines for running this experiment. I set them up at different times, as I didn't expect that I was going to need a second machine. I apparently set them up with two different versions of Ubuntu: for the first machine (which was the MSI, by the way), I grabbed a Ubuntu boot stick I had laying around -- which had Ubuntu Desktop 20.04 on it -- and installed that. Since I didn't need/want the desktop environment on there, I used Ubuntu Server 22.04 for the second machine. The two are running practically the same Linux Kernel version (one is running 5.15.0-79-generic, the other is running 5.15.0-78-generic). Again, it's possible that the difference between the two introduced some irregularity into my results -- but I don't have any reason to suspect this is the case.

    Heat Dissipation

    These cards get hot. Really hot. How hot? This hot:

    For you non-Americans, here it is in non-Freedom units:

    Now...is it an issue? I don't know. I spot checked the specs for a few of the cards I'm testing, and they all listed the maximum operating temperature as 185ºF (85ºC) -- and my measurements were well below that. But does that mean that all of my cards are rated up to that temperature? Well...they probably are, but I don't know for sure.

    This rig is in a small closet (probably less than 40 sq. ft.) with its own air conditioner, constantly trying to keep the room at 72ºF -- but it can only do so much. And I just don't know if that amount of heat is causing issues with the cards themselves, or if it's causing the USB hub that it's attached to (which is absorbing a lot of this heat).

    Conclusion

    I think there's a number of conclusions I could make from this data:

    • In terms of performance, name-brand cards (regardless of whether they come from Amazon or AliExpress) are generally better than off-brand cards, and off-brand cards are generally better than knock-off cards.
    • If it's a knock-off card, expect it to be fake and low-quality flash.
    • And, of course, if the price sounds too good to be true for the capacity, it's probably going to be fake flash (although Hiksemi proved me wrong in that department).

    There are a few comments I want to make about certain brands in particular -- but I don't want to say anything until I have more data from the endurance tests.

    I think I'll conclude this by leaving you with words I once heard a wise person say:

    Further study is needed.

    Comments