The Inland Performance Plus 2TB SSD Review: Phison's E18 NVMe Controller Tested
by Billy Tallis on May 13, 2021 8:00 AM ESTConclusion
With drives like the Inland Performance Plus, Phison's E18 controller has kept them in competition for the consumer SSD performance crown. The Inland Performance Plus is an extremely fast drive that sets a few new performance records, but more often it ends up tied or slightly slower than a competing PCIe 4.0 flagship SSD. The difference between this drive and other top PCIe 4.0 drives like the WD Black SN850 would not be noticeable during real-world usage, so the question of which one is fastest is more about bragging rights than tangible benefits.
Phison is the only company already on their second generation of PCIe 4.0 controllers, but they still have some room for improvement. The Inland Performance Plus consistently had high power consumption and poor efficiency during our testing. It's not completely out of line for a high-end drive that needs to prioritize performance over power efficiency, but the bar is being raised by the in-house controllers from several of the major NAND manufacturers. A second round of Phison E18-based products will be coming to market soon using Micron's 176L TLC rather than the current 96L TLC, and that should enable slightly improved performance and power efficiency. It might be enough to bump the new E18 drives into first place on more performance tests, and will definitely help keep this market segment highly competitive.
Our most difficult (and least realistic) tests revealed that the Inland Performance Plus and the Phison E18 controller and firmware also have some difficulties with performance consistency, for random read latency and for write performance where the SLC caching behavior occasionally leaves something to be desired. These aren't serious performance problems, but they are blemishes that we would prefer not to have on top-tier products. Firmware improvements may be able to help these issues, but a lot of the brands selling Phison drives aren't very good about making firmware updates available to end users.
| PCIe 4.0 NVMe SSD Prices May 13, 2021 |
|||||||
| 480-512 GB | 960 GB-1 TB | 2 TB | |||||
| Inland Performance Plus Phison E18 |
$189.99 (19¢/GB) | $379.99 (19¢/GB) | |||||
| Sabrent Rocket 4 Plus Phison E18 |
$199.98 (20¢/GB) | $449.15 (22¢/GB) | |||||
| Mushkin GAMMA Phison E18 |
$259.99 (26¢/GB) | $499.99 (25¢/GB) | |||||
| ADATA XPG Gammix S70 Innogrit IG5236 |
$179.99 (18¢/GB) | $349.99 (17¢/GB) | |||||
| Samsung 980 PRO Samsung Elpis |
$119.99 (24¢/GB) | $199.99 (20¢/GB) | $399.99 (20¢/GB) | ||||
| Sabrent Rocket 4.0 Phison E16 |
$89.98 (18¢/GB) | $159.98 (16¢/GB) | $399.99 (20¢/GB) | ||||
| WD Black SN850 WD G2 |
$128.74 (26¢/GB) | $199.99 (20¢/GB) | $399.99 (20¢/GB) | ||||
| ADATA XPG Gammix S50 Lite SM2267 (4ch) |
$139.99 (14¢/GB) | $259.99 (13¢/GB) | |||||
| PCIe 3.0 SSDs: | |||||||
| SK hynix Gold P31 | $74.99 (15¢/GB) | $134.99 (13¢/GB) | |||||
| Samsung 970 EVO Plus | $89.99 (18¢/GB) | $159.90 (16¢/GB) | $299.99 (15¢/GB) | ||||
| WD Black SN750 | $69.99 (14¢/GB) | $129.99 (13¢/GB) | $309.99 (15¢/GB) | ||||
Micro Center's in store only pricing for the Inland Performance Plus makes it the cheapest Phison E18 drive on the market, though Sabrent's more widely available Rocket 4 Plus is only $10 more for the 1TB model. With the exception of the Inland, most of the E18 drives seem to be priced at or above where the other second-wave PCIe 4.0 flagships are. The cheapest of the new PCIe 4.0 flagships is ADATA's Gammix S70 using Innogrit's controller. The older Phison E16 drives with TLC NAND are starting to get harder to find, but some such as the Sabrent Rocket 4.0 are a good mid-point between the latest top of the line drives and mainstream PCIe 3.0 drives.
For consumers with access to Micro Center's in-store pricing, the Inland Performance Plus is a reasonable choice since it's a bit cheaper than the flagships from Samsung and WD—but keep in mind that Micro Center is only offering a three year warranty rather than the usual five. For everyone else who has to deal with the online prices on other brands' Phison E18 drives, going for the WD Black SN850 instead makes more sense, especially for the 2TB models. The WD Black has more consistent performance and substantially less heat output.
However, all of the high-end PCIe 4.0 drives still carry a very steep price premium over even the best PCIe 3.0 drives. Recent increases in retail SSD prices have affected mainstream models more than the premium PCIe 4.0 drives, but the price gap is going to remain pretty wide. Those more mainstream models still provide almost as much real-world performance and a wider range of capacity options. Until a more compelling use case for PCIe 4.0 performance shows up, saving $50-100 by sticking with PCIe 3.0 storage seems like a great way to deal with high prices on other PC components.
Facebook
Twitter
RSS
118 Comments
View All Comments
mode_13h - Sunday, May 16, 2021 - link
> programs were doing their own thing, till OS's began to clamp down.DOS was really PCs' biggest Achilles heel. It wasn't until Windows 2000 that MS finally offered a mainstream OS that really provided all the protections available since the 386 (some, even dating back to the 286).
Even then, it took them 'till Vista to figure out that ordinary users having admin privileges was a bad idea.
In the Mac world, Apple was doing even worse. I was shocked to learn that MacOS had *no* memory protection until OS X! Of course, OS X is BSD-derived and a fully-decent OS.
FunBunny2 - Monday, May 17, 2021 - link
" I was shocked to learn that MacOS had *no* memory protection until OS X! "IIRC, until Apple went the *nix way, it was just co-operative multi-tasking, which is worth a box of Kleenex.
Oxford Guy - Tuesday, May 18, 2021 - link
Apple had protected memory long before Microsoft did — and before Motorola had made a non-buggy well-functioning MMU to get it working at good speed.One of the reasons the Lisa platform was slow was because Apple has to kludge protected memory support.
The Mac was originally envisioned as a $500 home computer, which was just above toy pricing in those days. It wasn’t designed to be a minicomputer on one’s desk like the Lisa system, which also had a bunch of other data-safety features like ECC and redundant storage of file system data/critical files — for hard disks and floppies.
The first Mac had a paltry amount of RAM, no hard disk support, no multitasking, no ECC, no protected memory, worse resolution, a poor-quality file system, etc. But, it did have a GUI that was many many years ahead of what MS showed itself to be capable of producing.
mode_13h - Tuesday, May 18, 2021 - link
> Apple had protected memory long before Microsoft didI mean in a mainstream product, enabled by default. Through MacOS 8, Apple didn't even enable virtual memory by default!
> The first Mac
I'm not talking about the first Mac. I'm talking about the late 90's, when Macs were PowerPC-based and MS had Win 9x & NT 4. Linux was already at 2.x (with SMP-support), BeOS was shipping, and OS/2 was sadly well on its way out.
mode_13h - Sunday, May 16, 2021 - link
> C has been described as the universal assembler.It was created as a cross-platform alternative to writing operating systems in assembly language!
> a C program can be blazingly fast, if the code treats the machine as a Control Program would.
No, that's just DOS. C came out of the UNIX world, where C programs are necessarily as well-behaved as anything else. The distinction you're thinking of is really DOS vs. real operating systems!
> I'm among those who spent more time than I wanted, editing with Norton Disk Doctor.
That's cuz you be on those shady BBS' dog!
mode_13h - Sunday, May 16, 2021 - link
> I think there's been a view inculcated against C++C++ is a messy topic, because it's been around for so long. It's a litle hard to work out what someone means by it. STL, C++11, and generally modern C++ style have done a lot to alleviate the grievances many had with it. Before the template facility worked well, inheritance was the main abstraction mechanism. That forced more heap allocations, and the use of virtual functions often defeated compilers' ability to perform function inlining.
It's still the case that C++ tends to hide lots of heap allocations. Where a C programmer would tend to use stack memory for string buffers (simply because its easiest), the easiest thing in C++ is basically to put it on the heap. Now, an interesting twist is that heap overrun bugs are both easier to find and less susceptible to exploits than on stack. So, what used to be seen as a common inefficiency of C++ code is now regarded as providing reliability and security benefits.
Another thing I've noticed about C code is that it tends to do a lot of work in-place, whereas C++ does more copying. This makes C++ easier to debug, and compilers can optimize away some of those copies, but it does work to the benefit of C. The reason is simple: if a C programmer wants to copy anything beyond a built-in datatype, they have to explicitly write code to do it. In C++ the compiler generally emits that code for you.
The last point I'll mention is restricted pointers. C has them (since C99), while C++ left them out. Allegedly, nearly all of the purported performance benefits of Fortran disappear, when compared against C written with restricted pointers. That said, every C++ compiler I've used has a non-standard extension for enabling them.
> if C++, do things in an excessive object-oriented way
Before templates came into more common use, and especially before C++11, you would typcially see people over-relying on inheritance. Since then, it's a lot more common to see functional-style code. When the two styles are mixed judiciously, the combination can be very powerful.
GeoffreyA - Monday, May 17, 2021 - link
Yes! I was brought up like that, using inheritance, though templates worked as well. Generally, if a class had some undefined procedure, it seemed natural to define it as a pure virtual function (or even a blank body), and let the inherited class define what it did. Passing a function object, using templates, was possible but felt strange. And, as you said, virtual functions came at a cost, because they had to be resolved at run-time.Concerning allocation on the heap, oh yes, another concern back then because of its overhead. Arrays on the stack are so fast (and combine those buggers with memcpy or memmove, and one's code just burns). I first started off using string classes, but as I went on, switched to char/wchar_t buffers as much as possible---and that meant you ended up writing a lot of string functions to do x, y, z. And learning about buffer overruns, had to go back and rewrite everything, so buffer sizes were respected. (Unicode brought more hassle too.)
"whereas C++ does more copying"
I think it's a tendency in C++ code, too much is returned by value/copy, simply because of ease. One can even be guilty of returning a whole container by value, when the facility is there to pass by reference or pointer. But I think the compiler can optimise a lot of that away. Still, not good practice.
mode_13h - Tuesday, May 18, 2021 - link
> though templates worked as wellIt actually took a while for compilers (particularly MSVC) to be fully-conformant in thier template implementations. That's one reason they took longer to catch on -- many programmers had gotten burned in early attempts to use templates.
> Passing a function object, using templates, was possible but felt strange.
Templates give you another way to factor out common code, so that you don't have to force otherwise unrelated data types into an inheritance relationship.
> I think it's a tendency in C++ code, too much is returned by value/copy, simply because of ease.
Oh yes. It's clean, side effect-free and avoids questions about what happens to any existing container elements.
> One can even be guilty of returning a whole container by value, when the facility is there
> to pass by reference or pointer. But I think the compiler can optimise a lot of that away.
It's called (N)RVO and C++11 took it to a new level, with the introduction of move-constructors.
> Still, not good practice.
In a post-C++11 world, it's now preferred. The only time I avoid it is when I need a function to append some additional values to a container. Then, it's most efficient to pass in a reference to the container.
GeoffreyA - Wednesday, May 19, 2021 - link
"many programmers had gotten burned in early attempts to use templates"It could be tricky getting them to work with classes and compile. If I remember rightly, the notation became quite unwieldy.
"C++11 took it to a new level, with the introduction of move-constructors"
Interesting. I suppose those are the counterparts of copy constructors for an object that's about to sink into oblivion. Likely, just a copying over of the pointers (or of all the variables if the compiler handles it)?
mode_13h - Thursday, May 20, 2021 - link
> > "many programmers had gotten burned in early attempts to use templates"> It could be tricky getting them to work with classes and compile.
I meant that early compiler implementations of C++ templates were riddled with bugs. After people started getting bitten by some of these bugs, I think templates got a bad reputation, for a while.
Apart from that, it *is* a complex language feature that probably could've been done a bit better. Most people are simply template consumers and maybe write a few simple ones.
If you really get into it, templates can do some crazy stuff. Looking up SFINAE will quickly take you down the rabbit hole.
> If I remember rightly, the notation became quite unwieldy.
I always used a few typedefs, to deal with that. Now, C++ expanded the "using" keyword to serve as a sort of templatable typedef. The repurposed "auto" keyword is another huge help, although some people definitely use it too liberally.