An exact memory number gives a profile away: a hundred steps

Any script on the page open in front of you reads the ceiling on the memory it may hold. Nothing asks you for permission and nothing on the page shows that it happened.

The value matters to the site for one reason: it does not describe the page. It is arithmetic done on the memory of the machine underneath.

The rounded answer is not rounding by eye but a place in a fixed table. The table sits inside the engine itself, and it holds exactly a hundred steps.

Each step keeps three significant digits, and neighbours stand about six percent apart. A number that falls between two of them never reaches the site as it was.

One step is handed to everyone whose real ceiling lands inside it. At the top of the table that band is 220 000 000 bytes wide, and very different machines answer identically.

An exact byte count works the other way round. It is the arithmetic of one machine and one build, it stays the same from visit to visit, and that is the kind of value a site collects.

77 of the hundred steps lie below a billion bytes. The table is finer at the bottom than at the top, so a small machine is described more closely than a large one.

The ceiling is two parts added together: a long lived part sized from memory, and a short lived part that comes from the build.

A desktop profile is owed half of its declared memory as the long lived part and a phone profile a quarter. Neither one goes below 256 MB or above 4 GB.

Your profile replaces only the long lived part, and the number the declared memory calls for takes its place. The short lived part rides along as it is: it belongs to the build, and writing it by hand would make a fresh tell out of nothing.

When the declared memory already agrees with the machine underneath, your profile leaves the value alone.

1. 1

   Declared memory sets the long part

   Half of it on a desktop profile and a quarter on a phone.

2. 2

   The short part rides along as it is

   It comes from the build and stays as it was.

3. 3

   The shape of the answer stays the same

   A step stays a step and an exact count stays exact.

You can check the number yourself: the finished browser gives you and the site the same answer. On the Windows build it came back as 4 192 MB against the 4 096 MB of long lived part the profile was owed.

The difference is the short lived part of that build. That number is not one of the hundred steps either, which is the browser answering the second way.

There are a hundred steps, and the bands between them differ in width. At the bottom of the table a band is six hundred thousand bytes, at the top two hundred and twenty million.

So a weak machine gets an almost exact answer while a strong one is coarsened heavily.

That is deliberate: values on weak machines sit closer together, and a coarse step there would say more about you than an exact number.

The memory figure itself is drawn from the profile's own seed, and there are two values: four gigabytes and eight. A desktop and a phone profile share the same choice.

The long part of the heap is counted from it: half for a desktop profile, a quarter for a phone one. Neither goes below two hundred and fifty-six megabytes or above four gigabytes.

Memory falls to a profile on its own draw, apart from the graphics card and the screen. So two of your profiles on one machine usually name different figures.

A match here is no trouble: four gigabytes is an ordinary number and plenty of people carry it. The worrying case is the opposite, when every profile answers the same.

On the Windows build a stock browser answered four thousand one hundred and ninety-two megabytes against the four thousand and ninety-six given to the profile. The gap is small, and it is exactly the one the engine itself produces.

We count that as a failed row rather than a detail. The measurement sits in the acceptance log, and the number for the site is taken from there rather than typed by hand.

One comparison is enough for a platform: an answer that lands on no step did not come from a browser. A stock browser always puts the figure on a step, so a value between steps is a foreign hand.

That is exactly why we do not round in our own way or invent tidy numbers. We put the answer on the very step the browser itself would have chosen.

The table is taken from the engine's own sources and sits with us as a file of a hundred rows. The first step is ten million bytes, the last three billion seven hundred and sixty million.

Anything above the last step did not come from the table. If your browser named a larger figure, it counted it itself rather than taking it from this row.

In a Chromium browser, open the developer console, read performance.memory.jsHeapSizeLimit and divide it by 1024 twice for megabytes.

You can recognise a rounded answer at once: three digits and then zeros all the way down. Anything above 3 760 000 000 never came out of the table.