[Note 7 Questions & Answers] BarryH_GEG:
You folks are losing sight of how Android manages memory. In the majority of cases apps are designed to utilize a small memory footprint to account for the various amounts of memory available to them. Probably 85+% of phones in use have less than 2GB of RAM.

Regardless, Android prioritizes memory usage at the OS level yielding memory to the app in focus.

From Google:

The ActivityManager, among other things, is responsible for making sure that

apps that are most important to the user and/or essential remain active.

It does this by dynamically assigning values that roughly indicate the app's importance. When memory gets low these values are used to

find the apps that need to be "trimmed." The memory from these "trimmed" apps is freed, making more available for the more important apps.

The adjustments are used by the Linux kernel to determine which process should be terminated. The kernel knows about these adjustments via the sysfs interface to lowmemorykiller. The lowmemorykiller is a kernel module that moves the roll of managing out of memory (OOM) issues to the user space. It does this by allowing the user-space to maintain a list of adjustments and a corresponding list of thresholds (units are in memory pages - usually 4K) at which point processes with these adjustments should be killed.

https://gist.github.com/blixtra/ca6e1f289462fe2679af​

Also from Google:

To maintain a functional multi-tasking environment,

Android sets a hard limit on the heap size for each app.

The exact heap size limit varies between devices based on how much RAM the device has available overall. If your app has reached the heap capacity and tries to allocate more memory, it will receive an OutOfMemoryError.

In some cases, you might want to query the system to determine exactly how much heap space you have available on the current device—for example, to determine how much data is safe to keep in a cache. You can query the system for this figure by calling getMemoryClass(). This returns an integer indicating the number of megabytes available for your app's heap. This is discussed further below, under Check how much memory you should use.

Instead of using swap space when the user switches between apps,

Android keeps processes that are not hosting a foreground ("user visible") app component in a least-recently used (LRU) cache.

For example, when the user first launches an app, a process is created for it, but when the user leaves the app, that process does not quit. The system keeps the process cached, so if the user later returns to the app, the process is reused for faster app switching.

If your app has a cached process and it retains memory that it currently does not need, then your app—even while the user is not using it—is constraining the system's overall performance.

So, as the system runs low on memory, it may kill processes in the LRU cache beginning with the process least recently used, but also giving some consideration toward which processes are most memory intensive. To keep your process cached as long as possible, follow the advice in the following sections about when to release your references.

https://developer.android.com/training/articles/memory.html​

So all of the above means that RAM heavy applications (EG: games) running in the foreground should perform the same with 4GB or 6GB of RAM. The wild card here is crappy poorly written apps that don’t observe Google’s memory usage guidelines can hog memory affecting other apps you’re using.

The bottom line is the biggest difference between 4GB and 6GB of RAM is how many background process can remain open. As the OnePlus RAM debacle has proven keeping too many unneeded apps open in the background affects battery performance. And the CPU/GPU are more important to app speed and performance than RAM. And DDR4 RAM isn't going to r/w any faster on a 10nm process or 4GB vs. 6GB.

This discussion is really about whether Samsung’s latest flagship should have the best available tech (EG: S-821/3, 6GB of RAM) from a marketing perspective not whether it’s going to perform well or be at the highest end of the spec heap.