Should I get A1 or A2 spec'd Micro SD card for my phone?


Question

I'm currently running with Samsung EVO Micro SD card in my phone (GT-i9195 or serranoltexx) in Adoptable storage mode.



I'm looking for a faster card to improve performance. I was about to get Sandisk Extreme A2 card for my phone.



However, I found the official pages about A1 and A2 class by SD Association. According to the official documentation,



A1:




The Application Performance Class 1 (A1) was defined by SD Physical
5.1 specification.




A2:




The Application Performance Class 2 (A2) is defined by SD Physical 6.0
specification. It makes SD memory card much higher performance than A1
performance by using functions of Command Queuing and Cache.




Note that A2 uses extra tricks to achieve better performance, especially Command Queuing (A2 spec'd cards have minimum support of 2 for Command Queuing depth).



I'm looking for a card that has as low latency as possible for a single read. Should I get A1 spec'd card instead of A2 because even though A2 has higher random access "minimum" IOPS, it may only get it with QD32 queues? I'm looking for a good random 4K read QD1.



I wish storage manufacturers specified random 4K read QD1 performance. It seems that only storage with manufacturer published numbers is Intel Optane series where those numbers don't look too bad.



Update: more information:



Another document on the official site explains A2 features a bit more:



Command Queue:




The new CQ mechanism allows the SD memory card to accept several
commands in a series (without their associated data) and execute them
(with the data) whenever the memory card is ready. It contributes
mainly to random read performance.




Note that this clearly uses "random read performance" as average IOPS, not the maximum time for any given read operation.



Cache function:




In order to overcome the relatively limited write speed operation of
flash memory, the Cache function allows the card to accumulate the
data accepted by the host in a high-speed memory (e.g., RAM[)] [...]
Data loss is allowed if the data is not moved to non-volatile storage.




So... high write IOPS is allowed to be writing to card internal RAM and data loss is acceptable? The OS can already do exactly the same thing with higher performance!



Self-Maintenance:




Card-initiated operation allows the SD memory card to perform internal
maintenance operations while the host bus is idle. When a new command
is received, the card must ensure that new command is serviced without
violating SD standard timing (Read Command, 100 milliseconds; Write
Command, 250 milliseconds).




And if card has entered "card initiated self-maintenance" mode (which A2 card is allowed to enter any time no commands are in the queue) the effective read IOPS may go down to 10 and effective write IOPS may go down to 4.



I think A2 spec has way too huge tolerances for bad performance. Calling the above as "minimum 4K read: 4000 IOPS" and "minimum 4K write: 2000 IOPS" is a lie.



(I'm wondering if I should get Sandisk Extreme A1 card when those are still available on the market. Samsung EVO+ cards have nice performance in benchmarks, too, but if I've understood correctly those are meant for non-application usage and have worse wear leveling algorithm than Sandisk Extreme cards. The same thing with Sandisk Ultra cards - they don't last having the same sectors written repeatedly.)


Answer

TL;DR: Get an A1 card unless you know for sure that your workload greatly benefits from Command Queuing (CQ) and your host hardware supports CQ.


Long answer:


After looking around a lot it seems that the A2 specification could allow better performance but actual hardware implementations are slow enough that A1 is better choice nowadays (year 2019).


Thomas Kaiser has collected info about A1 and A2 rated SD cards and says



Application Performance Class 1 (A1)


This performance class requires at least 1500/500 read/write IOPS (IO
operations per second) with a 4k blocksize (small data chunks) and at
least 10 MB/s sustained sequential write performance. No special host
requirements are needed, the card simply has to exceed the performance
requirements on its own.



and



Application Performance Class 2 (A2)


A2 promises even better performance with 4000/2000 read/write IOPS
minimum but there's a problem since as outlined by the SD Association
A2 cards show "much higher performance than A1 performance by using
functions of Command Queuing and Cache".


Cache and Command Queuing require host (driver) support since the host
needs to activate those new features first
. The cache feature on A2
rated cards makes use of volatile RAM on the card [...] involving the
risk of data losses
[...]



Another user wrote about real world performance between Sandisk Extreme A1 and A2 cards:



I did some searching online and found a few other SD card benchmark
results where A2 cards performed worse than A1 cards, so my results
seemed to be what others were finding as well.


[...]
A2 cards not only require special hardware and/or software for maximum
performance, they actually perform WORSE than A1 cards without it


[...]
[Sandisk fine print about A2 cards]: Up to 160MB/s read speeds,
engineered with proprietary technology to reach speeds
beyond UHS-I 104MB/s, requires compatible
devices capable of reaching such speeds


[...]
As far as I can find, the only "compatible device" is the SanDisk
Mobilemate USB 3.0 micro SD card reader



James A. Chambers has tested A1 and A2 cards with Raspberry Pi:



A2 is not supported by Raspberry Pi yet (or almost anything else
really) so A1 is the important mark to hit.



So the current status seems to be that A1 is strictly about card hardware speed and A2 is about card + host hardware/firmware/software solution. The only bit about A2 which in fact could improve performance is Command Queuing (CQ) which allows card to process some requests slower and still allow higher average troughput even for small I/O operations. And if you care about worst case latency (QD1) then any queuing is never worth it so you do not even want this feature.


However, it seems that with current hardware (year 2019) of A2 cards the latency for any single request has been increased from A1 cards. I guess this is caused by too slow embedded processors inside the cards that try to do a bit too much. The firmware is probably optimized for benchmark throughput (the card can handle lots of requests in paraller but execute each request a bit slower) and as a result, the latency for any single request has gone up. As a result, if your host device doesn't support CQ feature of A2 cards, you get the worst of two worlds: the latency will go up and overall throughput will suffer.


In the end, if your host does not support A2 feature, get an A1 card. And if you care about QD1 performance, get an A1 card even if your host hardware/firmware + software does support all the A2 features.


According to latest benchmarks I would recommend either SanDisk Extreme A1 cards or A-Data Premier A1 cards. According to StorageReview benchmark, the A-Data Premier A1 card has highest random 4K performance: 2971 IOPS for 4K read, 1190 IOPS for 4K write. The SanDisk Extreme A1 cards is better known, though, so it may be a safer bet. The SanDisk Extreme A1 is already hard to find because SanDisk prefers to sell A2 variants now especially for bigger flash sizes.


I wouldn't be surprised if current crop of A2 cards were cheaper to manufacture than A1 cards because the manufacturers can use lesser spec'd internal processor to achieve the A2 minimum random access performance thanks to more buffering and queuing. I can only wish more benchmarking sites would focus on request latency over throughput.


Topics


2D Engines   3D Engines   9-Patch   Action Bars   Activities   ADB   Advertisements   Analytics   Animations   ANR   AOP   API   APK   APT   Architecture   Audio   Autocomplete   Background Processing   Backward Compatibility   Badges   Bar Codes   Benchmarking   Bitmaps   Bluetooth   Blur Effects   Bread Crumbs   BRMS   Browser Extensions   Build Systems   Bundles   Buttons   Caching   Camera   Canvas   Cards   Carousels   Changelog   Checkboxes   Cloud Storages   Color Analysis   Color Pickers   Colors   Comet/Push   Compass Sensors   Conferences   Content Providers   Continuous Integration   Crash Reports   Credit Cards   Credits   CSV   Curl/Flip   Data Binding   Data Generators   Data Structures   Database   Database Browsers   Date &   Debugging   Decompilers   Deep Links   Dependency Injections   Design   Design Patterns   Dex   Dialogs   Distributed Computing   Distribution Platforms   Download Managers   Drawables   Emoji   Emulators   EPUB   Equalizers &   Event Buses   Exception Handling   Face Recognition   Feedback &   File System   File/Directory   Fingerprint   Floating Action   Fonts   Forms   Fragments   FRP   FSM   Functional Programming   Gamepads   Games   Geocaching   Gestures   GIF   Glow Pad   Gradle Plugins   Graphics   Grid Views   Highlighting   HTML   HTTP Mocking   Icons   IDE   IDE Plugins   Image Croppers   Image Loaders   Image Pickers   Image Processing   Image Views   Instrumentation   Intents   Job Schedulers   JSON   Keyboard   Kotlin   Layouts   Library Demos   List View   List Views   Localization   Location   Lock Patterns   Logcat   Logging   Mails   Maps   Markdown   Mathematics   Maven Plugins   MBaaS   Media   Menus   Messaging   MIME   Mobile Web   Native Image   Navigation   NDK   Networking   NFC   NoSQL   Number Pickers   OAuth   Object Mocking   OCR Engines   OpenGL   ORM   Other Pickers   Parallax List   Parcelables   Particle Systems   Password Inputs   PDF   Permissions   Physics Engines   Platforms   Plugin Frameworks   Preferences   Progress Indicators   ProGuard   Properties   Protocol Buffer   Pull To   Purchases   Push/Pull   QR Codes   Quick Return   Radio Buttons   Range Bars   Ratings   Recycler Views   Resources   REST   Ripple Effects   RSS   Screenshots   Scripting   Scroll Views   SDK   Search Inputs   Security   Sensors   Services   Showcase Views   Signatures   Sliding Panels   Snackbars   SOAP   Social Networks   Spannable   Spinners   Splash Screens   SSH   Static Analysis   Status Bars   Styling   SVG   System   Tags   Task Managers   TDD &   Template Engines   Testing   Testing Tools   Text Formatting   Text Views   Text Watchers   Text-to   Toasts   Toolkits For   Tools   Tooltips   Trainings   TV   Twitter   Updaters   USB   User Stories   Utils   Validation   Video   View Adapters   View Pagers   Views   Watch Face   Wearable Data   Wearables   Weather   Web Tools   Web Views   WebRTC   WebSockets   Wheel Widgets   Wi-Fi   Widgets   Windows   Wizards   XML   XMPP   YAML   ZIP Codes