本頁面暫無您所用語言的版本,您正在閱讀英文原文。
Glossary
Hardware concurrency
Hardware concurrency is the number of logical processors a browser reports to any page that asks for it.
What a page does with the number
The reading takes one line and needs no permission. What makes it useful to a site is that the same number can be asked for in several places at once.
Reads it in the document
The plain reading, taken as the page loads and stored next to everything else it collected.
Asks a background thread
A worker reports the same property. Two answers that differ say more about the browser than either number does.
Asks an embedded frame
A frame is a third place to ask, and a value changed in the document alone does not reach it.
Sizes its own work by it
Pages split heavy work by the count they were given, so the number also has to be plausible for the machine doing the work.
Your machine right now
These values are read in your browser on this page. They are the three a site reads together when it wants to know what kind of machine you are on.
此刻您的裝置
- Logical processors
- 正在您的裝置上測量
- Device memory
- 正在您的裝置上測量
- Platform
- 正在您的裝置上測量
在您的瀏覽器中讀取並在此顯示,不會傳送到任何地方。
Cores next to the graphics card
A core count is believable or not only next to the graphics card. Integrated laptop graphics of one generation top out at eight threads, so sixteen cores beside them describe a machine that was never built.
Apple chips are stricter still. The count is set by the chip rather than chosen: the plain generations report eight, the larger ones ten or twelve, the largest fourteen or sixteen.
The card decides the range
Every card the app can claim carries the core counts machines with that card actually report.
The pair is read first
Processor next to graphics is among the first things a defence system compares, and an impossible pair is louder than any single value.
The memory figure joins them
Cores, memory and the card are one description of one machine, and all three are drawn from the same profile seed.
What our engine does
The count arrives as one seed on the launch line, before the first line of page code runs, and it is drawn from the counts that fit the card the profile was given.
It answers the same in the document, in a frame and in a background thread, because the engine reports it in one place for all three.
- 1
The editor offers what the generator gives
The list is derived from the same pools, so a profile the app made never shows an empty slot in its own card.
- 2
A count that does not fit is refused
Save a hand-picked count that contradicts the card and the field is named as refused rather than quietly applied.
- 3
An old edit is left alone
The check runs when you save, not at launch, so a profile that has walked around with a value for months does not change machine.
What the shipping build answers
Three measurements from the acceptance run of the build shipping today, on a Windows profile whose seed asked for eight.
The document reported the seed
Measured on a build host with a different processor to the one the profile claims.
8The frame and the thread agreed
Both were asked for the count and the platform, and both answered as the document did.
same in all threeThe population holds several counts
Across four hundred generated profiles more than two counts appear, so the number alone links no profile to another.
more than two
How to check your own
The panel above shows what this browser reports. The free check on this site puts the count and the memory figure on one row, which is how a site reads them.
Inside the app the self-test runs in a profile against the engine that profile launched. It compares the count to the seed and then asks a frame and a background thread the same question.
What this does not do
- It does not add processors to your computer. A count far from what the machine can actually do makes a profile easier to spot, because work split across those cores still takes as long as the real machine takes.
- It does not accept any number you type. The choice holds what machines of that platform report, between four and sixteen, and a value outside the list is refused rather than applied.
- It does not give one site a different count. The number belongs to the profile, and a count that differs between the page and a background thread is louder than any value could be.
- It does not make two profiles unrelated by itself. Behaviour, address reputation and account history close more accounts than any hardware reading does.
Check it
Every number above comes from a file you can open.
- The core count checks in the self-test
- apps/desktop/src/lib/fpAudit.js
- Where the count comes from
- packages/shared/src/index.js
- The parts have to agree with each other
- apps/desktop/test/fingerprint-consistency.js
- The editor offers only what the generator gives
- packages/shared/test/выбор-редактора-полон.js
Questions
- Why not claim thirty two cores?
- Because almost nobody reports that, the card beside it would contradict it, and heavy work would still finish at the speed of the real machine. A rare number attracts the attention it was meant to avoid.
- Can a background thread answer differently?
- It should not, and the self-test asks it on purpose. A count patched in the document alone is found by the first page that starts a thread.
- Is an odd count suspicious?
- Not by itself: some shipping chips really do report an odd number. What matters is that the count fits the chip the profile claims to be.
- Do two profiles get different counts?
- Yes, within what their cards allow. The count follows the card that fell to the profile, so profiles made on one computer do not share one description.
See what your own profile answers
The self-test runs inside a profile and shows all 29 measurements, green and red alike.