WebWorkers - high performance computing for the front end

Before reading the full text, let me briefly introduce to you what WebWorkers are, and what is the relationship between WebWorkers and web high-performance computing.

First of all, what are WebWorkers?

Simply put, WebWorkers is a new API of HTML5. Web developers can use this API to run a script in the background without blocking the UI. It can be used to do things that require a lot of calculations and make full use of CPU multi-cores.

You can read this article introductionhttps://www.html5rocks.com/en/tutorials/workers/basics/, or the corresponding Chinese version.

The Web Workers specification defines an API for spawning background scripts in your web application. Web Workers allow you to do things like fire up long-running scripts to handle computationally intensive tasks, but without blocking the UI or other scripts to handle user interactions.

You can open this link (https: //nerget.com/rayjs-mt/rayjs.html) Experience the acceleration effect of WebWorkers yourself.

Now browsers basically support WebWorkers.

Parallel.js

It is still too cumbersome to use the WebWorkers interface directly. Fortunately, someone has already encapsulated it: Parallel.js.

Note that Parallel.js can be installed through node:

##$ npm install paralleljs

But this is used under

node.js, using the cluster module of node. If you want to use it in the browser, you need to directly apply js:

<script src="parallel.js"></script>

and then you can get a global variable, Parallel. Parallel provides two functional programming interfaces, map and reduce, which make concurrent operations very convenient.

Let’s first define our problem. Since the business is relatively complex, I will simplify the problem here into finding the sum of 1-1,0000,0000, and then subtract the Going from 1-1,0000,0000, the answer is obvious: 0! This is done because if the number is too large, there will be data accuracy problems, and the results of the two methods will be somewhat different, which will make people feel that the parallel method is unreliable. This problem takes about 1.5s if I simply run js under my mac pro chrome61 (our actual business problem takes 15s. In order to avoid killing the browser during user testing, we have simplified the problem).

const N = 100000000;// 总次数1亿
 
function sum(start, end) {
  let total = 0;
  for (let i = start; i<=end; i += 1) total += i;
  for (let i = start; i<=end; i += 1) total -= i;
  return total;
}
 
function paraSum(N) {
  const N1 = N / 10;//我们分成10分，没分分别交给一个web worker，parallel.js会根据电脑的CPU核数建立适量的workers
  let p = new Parallel([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
    .require(sum);
  return p.map(n => sum((n - 1) * 10000000 + 1, n * 10000000))// 在parallel.js里面没法直接应用外部变量N1
    .reduce(data => {
      const acc = data[0];
      const e = data[1];
      return acc + e;
    });
}

The code is relatively simple. Here I will talk about a few pitfalls I encountered when I first started using it.

require all required functions

For example, if sum is used in the appeal code, you need to require(sum in advance ), if another function f is used in sum, you also need to require(f). Similarly, if g is used in f, you also need to require(g) until you require all the defined functions used. . . .

Can't require the variable

In our appeal code, I originally defined N1, but it couldn't be used

Problems after ES6 was compiled into ES5 and Chrome did not report an error

In the actual project, we used the features of ES6 at the beginning: Array destructuring. Originally this was a very simple feature, but now most browsers support it. However, the babel I configured at that time will be compiled into ES5, so the code _slicedToArray will be generated. You can test it online with Babel, and it will never work under Chrome. There is no error message. After checking for a long time, I opened it in Firefox and found the error message:

##ReferenceError: _slicedToArray is not defined

It seems that Chrome is not omnipotent. . .

You can test it on this Demo page. The speed increase is about 4 times. Of course, it still depends on the number of cores of your computer's CPU. In addition, I later tested Firefox 55.0.3 (64-bit) on the same computer, and the appeal code actually only took 190ms! ! ! It is also about 190ms under Safari9.1.1. .

I will also introduce other attributes and indicators of front-end high-performance computing to you later, so please continue to pay attention.

The above is the detailed content of WebWorkers - high performance computing for the front end. For more information, please follow other related articles on the PHP Chinese website!