Shulou(Shulou.com)06/01 Report--

This article mainly introduces "what are the knowledge points of JavaScript8". In the daily operation, I believe many people have doubts about the knowledge points of JavaScript8. The editor consulted all kinds of materials and sorted out simple and easy-to-use methods of operation. I hope it will be helpful to answer the questions of "what are the knowledge points of JavaScript8?" Next, please follow the editor to study!

Single thread

If you are a Node developer, you should be familiar with the single-threaded features of V8. An JS execution context is proportional to the number of threads.

Of course, V8 manages operating system threading mechanisms in the background. It can work with multiple threads because it is complex software that can perform many tasks at the same time.

However, V8 creates only a single-threaded environment for each JavaScript execution context. The rest are under the control of V8.

Imagine the function call stack that JavaScript code should do. JavaScript works by stacking one function on top of another, following the insertion / call order of each function. Until we get to the contents of each function, we don't know if it calls other functions. If this happens, the called function will be placed after the caller in the stack.

For example, when callbacks are involved, they are placed at the end of the stack.

Managing the memory required for this stack organization and process is one of the main tasks of V8.

Ignition and TurboFan

Since the release of version 5.9 in May 2017, V8 comes with a new JavaScript execution pipeline, which is built on top of V8's interpreter Ignition. It also includes an updated and better optimized compiler-TurboFan.

These changes focus entirely on overall performance and the difficulties faced by Google developers in adapting the engine to all the rapid and significant changes brought about by the JavaScript world.

From the beginning of the project, V8 maintainers have been worried about how to find a good way to improve the performance of V8 while JavaScript continues to evolve.

Hidden Classes (Hidden Class)

This is another trick of V8. JavaScript is a dynamic language. This means that new attributes can be added, replaced, and deleted during execution. For example, in a language like Java, this is not possible. In Java, everything (classes, methods, objects, and variables) must be defined before the program executes and cannot be changed dynamically after the application starts.

Because of its special nature, the JavaScript interpreter usually performs a dictionary lookup based on the hash function (hash algorithm) to know exactly where the variable or object is allocated in memory.

This is very costly for the last process. In other languages, when objects are created, they receive an address (pointer) as one of their implicit properties. In this way, we can know exactly where they are in memory and how much space to allocate.

For JavaScript, this is impossible because we cannot map out content that does not exist. This is where Hidden Classes plays a role.

Hidden classes are almost the same as classes in Java: static and fixed classes have unique addresses to locate them. However, V8 is not executed before the program is executed, but is executed every time the object structure changes "dynamically" during the run.

Let's look at an example to illustrate the problem. Consider the following code snippet:

Function User (name, fone, address) {this.name = name this.phone = phone this.address = address}

In JavaScript's prototype-based features, each time a new user object is instantiated, assume:

Var user = new User ("John May", "+ 1 (555) 555-1234", "123 3rd Ave")

Then V8 creates a new hidden class. We call it _ User0.

Each object has a reference to its class representation in memory. It is a class pointer. At this point, since we have just instantiated a new object, only one hidden class has been created in memory. It's empty now.

When you execute the first line of code in this function, a new hidden class is created based on the previous one, this time _ User1

It is basically the memory address of the User with the name attribute. In our example, we do not use a user that only has name as a property, but each time we do so, this is the hidden class that V8 will load as a reference.

The name attribute is added to the offset 0 of the memory buffer, which means that this will be treated as the first attribute in the last order.

V8 will also add a conversion value to the _ User0 hidden class. This helps the interpreter understand that every time you add a name attribute to a User object, you must handle the conversion from _ User0 to _ User1.

When the second line in the function is called, the same process occurs again and a new hidden class is created.

You can see the hidden class tracking stack. In the chain maintained by the conversion value, one hidden class leads to another.

The order in which attributes are added determines how many hidden classes V8 will create. If you change the order of the lines in the code snippet we created, different hidden classes will also be created. This is why some developers try to keep the order of reusing hidden classes in order to reduce overhead.

Inline Caching (inline cache)

This is a very common term in JIT (Just-in-Time) compilers. It is directly related to the concept of hidden classes.

For example, every time you call a function and pass an object as an argument, V8 will see this action and think, "well, this object has been successfully passed two or more times as an argument."... why not store it in my cache for future calls instead of performing the entire time-consuming hidden class validation process again? "

Let's review the previous example:

Function User (name, fone, address) {/ / Hidden class _ User0 this.name = name / / Hidden class _ User1 this.phone = phone / / Hidden class _ User2 this.address = address / / Hidden class _ User3}

When we pass an instance of the User object to the function twice as an argument, V8 jumps to the hidden class lookup and goes directly to the property of the offset. It's much faster.

Keep in mind, however, that changing the order of any attribute assignment in a function will result in different hidden classes, so V8 will not be able to use inline caching.

This is a good example of how developers should not avoid learning more about engines. On the contrary, having this knowledge will help the code execute better.

Garbage Collecting (garbage collection)

Do you remember when we mentioned that V8 collects memory garbage in another thread? This is helpful because the execution of our program will not be affected.

V8 uses the well-known "mark and scan" strategy to collect old objects in memory. In this strategy, the phase in which GC scans memory objects to "mark" them for collection is a bit slow because it requires code execution to be paused.

However, V8 is incremental, that is, for each GC pause, V8 tries to mark as many objects as possible. It makes everything faster because you don't need to stop the entire execution until the collection is complete. In large applications, performance improvements vary greatly.

At this point, the study of "what are the knowledge points of JavaScript8" is over. I hope to be able to solve your doubts. The collocation of theory and practice can better help you learn, go and try it! If you want to continue to learn more related knowledge, please continue to follow the website, the editor will continue to work hard to bring you more practical articles!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.