under-the-hood | 📚 Go : Under The Hood | Go 语言原本

(V8 developer here.)

Many things in V8 have more than one implementation, for various reasons: in this case, there's the C++ way of adding an entry to an OrderedHashMap (which you've found), and there's also a generated-code way of doing it. If you grep for MapPrototypeSet, you'll find TF_BUILTIN(MapPrototypeSet, ... in builtins-collections-gen.cc, which is the canonical implementation of Map.prototype.set. Since that's a piece of code that runs at V8 build time to generate a "stub" which is then embedded into the binary, there's no direct way of setting a breakpoint into that stub. One way to do it is to insert a DebugBreak() call into the stub-generating code, and recompile.

Not all builtins are implemented in the same way:

• some (like M.p.set) are generated "CSA builtins" in src/builtins/*-gen.cc
• some are regular C++ in src/builtins/*.cc
• some are written in Torque (src/builtins/*.tq) which is V8's own DSL that translates to CSA
• some have fast paths directly in the compiler(s)
• some have their meat in "runtime functions" (src/runtime/*.cc)

Many have more than one implementation (typically a fully spec-compliant "slow" fallback, often but not always in C++, and then one or more fast paths that take shortcuts for common situations, often but not always in various forms of generated code). There are probably also a few special cases I'm forgetting right now; and as this post ages over the years, the enumeration above will become outdated (e.g. there used to be builtins in handwritten assembly, but we got rid of (almost all) of them; there used to be builtins generated by the old Crankshaft compiler, but we replaced that; there used to be builtins written in JavaScript, but we got rid of them; CSA was new at some point; Torque was new at some point; who knows what'll come next).

One consequence of all this is that questions like "how exactly does JavaScript's feature X work under the hood?" often don't have a concise answer.

Have fun with your investigation!

(V8 developer here.) "C++ array of ints" is a bit of a simplification, but the key idea described in that article is correct, and an array [0, 1, 2, 3] will be stored as an array of "Smis".

What's a "Smi"? While every Number in JavaScript must behave like an IEEE754 double, V8 internally represents numbers as "small integer" (31 bits signed integer value + 1 bit tag) when it can, i.e. when the number has an integral value in the range -2**30 to 2**30-1, to improve efficiency. Engines can generally do whatever they want under the hood, as long as things behave as if the implementation followed the spec to the letter. So when the spec (or MDN documentation) says "all Numbers are doubles", what it really means from the engine's (or an engine developer's) point of view is "all Numbers must behave as if they were doubles".

When an array contains only Smis, then the array itself keeps track of that fact, so that values loaded from such arrays know their type without having to check. This matters e.g. for a[i] + 1, where the implementation of + doesn't have to check whether a[i] is a Smi when it's already known that a is a Smi array.
When the first number that doesn't fit the Smi range is stored in the array, it'll be transitioned to an array of doubles (strictly speaking still not a "C++ array", rather a custom array on the garbage-collected heap, but it's similar to a C++ array, so that's a good way to explain it).
When the first non-Number is stored in an array, what happens depends on what state the array was in before: if it was a "Smi array", then it only needs to forget the fact that it contains only Smis. No rewriting is needed, as Smis are valid object pointers thanks to their tag bit. If the array was a "double array" before, then it does have to be rewritten, so that each element is a valid object pointer. All the doubles will be "boxed" as so-called "heap numbers" (objects on the managed heap that only wrap a double value) at this point.

In summary, I'd like to point out that in the vast majority of cases, there's no need to worry about any of these internal implementation tricks, or even be aware of them. I certainly understand your curiosity though! Also, array representations are one of the more common reasons why microbenchmarks that don't account for implementation details can easily be misleading by suggesting results that won't carry over to a larger app.

Addressing comments:

V8 does sometimes even use int16 or lower.

Nope, it does not. It may or may not start doing so in the future; though if anything does change, I'd guess that untagged int32 is more likely to be introduced than int16; also if anything does change about the implementation then of course the observable behavior would not change.
If you believe that your application would benefit from int16 storage, you can use an Int16Array to enforce that, but be sure to measure whether that actually benefits you, because quite likely it won't, and may even decrease performance depending on what your app does with its arrays.

It may start to be a double when you make it a decimal

Slightly more accurately: there are several reasons why an array of Smis needs to be converted to an array of doubles, such as:

• storing a fractional value in it, e.g. 0.5
• storing a large value in it, e.g. 2**34
• storing NaN or Infinity or -0 in it

What does this typeSwitch() method do?

The invokeDynamic instruction (upon first being hit) calls the SwitchBootstraps.typeSwitch() method. This method then returns what method call should be executed (this is what invokedynamic generally does).

The last argument of the SwitchBootstraps.typeSwitch() method (the labels parameter) is in this case the list of classes in the switch: Number.class, Enum.class, String.class

The SwitchBootstraps.typeSwitch() bootstrap method checks the labels parameter for correctness and then returns a ConstantCallSite for the SwitchBootstraps.doTypeSwitch() method that does the effective handling (i.e. the final execution of the invokeDynamic instruction).

If you look at what SwitchBootstraps.doTypeSwitch() does: it iterates over the list of classes and returns the first found match.

What's the purpose of the additional int passed?

The additional parameter (startIndex) is needed because of this case:

You can use getEffectsMetadata to verify dispatch is set to false. This method returns the config of an effect.

timestamp type supports KNN with GiST indexes using the <-> operator created by the btree_gist extension.

You can check if a specific column of a specific index supports it, like this:

I used IHTMLDocument2.write and it appears to work well.

If you're looking for differences in implementation, the best place to go would be the source code. In this case it seems like there are no differences aside from the different exception thrown, the source for both methods is otherwise identical.

checkNotNull

However I'm still at a loss to understand how non-standard operators like this are actually implemented, especially considering that this one seems to 'just work', regardless of whether it's being used by {rlang} functions.

It doesn’t “just work” with arbitrary functions — on the contrary: functions do need to be aware of tidy evaluation. And as you probably guessed there’s no {{ operator. Instead, ‘rlang’ uses NSE to capture the unevaluated argument and then checks whether the parse tree of the expression contains two nested { calls. It then takes the unevaluated expression and transforms it appropriately.

Here is a sample query I believe would work...