Question

我正在尝试使用网络工作者制作并行版本的合并排序算法。

在小型阵列上，并行版本非常慢（由于我认为是promise和网络工作人员的开销），但令人惊讶的是，它在大型阵列上也比串行排序慢

并行版本

console.log(navigator.hardwareConcurrency + " threads")
var blob = new Blob([
    `onmessage = function(e) { 

function merge_sort(arr) {
  let length = arr.length;        
  if (length < 2) {
    return arr
  }
 let middle = Math.floor(length/2)
 let left = arr.slice(0, middle)     
 let right = arr.slice(middle)     
 return merge(merge_sort(left), merge_sort(right))
}

function merge(left, right) {
  let result = [];
  let i=0;
  let j=0;
  while(i < left.length && j < right.length) {
    if(left[i] < right[j]) {
      result.push(left[i]) ;
      i++;       
    } else {                       
      result.push(right[j]);
      j++;
    }
  }
  return result.concat(left.slice(i)).concat(right.slice(j))
} 
   if(e.data.job==='sort'){
    postMessage(merge_sort(e.data.arr));
}else{
     postMessage(merge(e.data.arr[0],e.data.arr[1]))
}
         }`
]);  
var blobURL = window.URL.createObjectURL(blob);
var v1 = new Worker(blobURL);
var v2 = new Worker(blobURL);
var v3 = new Worker(blobURL);
var v4 = new Worker(blobURL);

function merge(left, right) {
    let result = [];
    let i = 0;
    let j = 0;
    while (i < left.length && j < right.length) {
        if (left[i] < right[j]) {
            result.push(left[i]);
            i++;
        } else {
            result.push(right[j]);
            j++;
        }
    }
    return result.concat(left.slice(i)).concat(right.slice(j))
}

var arr = Array.from({
    length: 20000000
}, () => Math.floor(Math.random() * 50000000));

var half1 = []
var half2 = []
var half_1 = []
var half_2 = []
var half_3 = []
var half_4 = []
let middle = Math.floor(arr.length / 2)
half1 = arr.slice(0, middle)
half2 = arr.slice(middle)

let middlehalf1 = Math.floor(half1.length / 2)
half_1 = half1.slice(0, middlehalf1)
half_2 = half1.slice(middlehalf1)

let middlehalf2 = Math.floor(half2.length / 2)
half_3 = half2.slice(0, middlehalf2)
half_4 = half2.slice(middlehalf2)
var t0 = performance.now();

var p1 = new Promise((resolve, reject) => {
    v1.postMessage({
        job: 'sort',
        arr: half_1
    });
    v1.addEventListener('message', event => resolve(event.data));
    v1.addEventListener('error', reject);
})
var p2 = new Promise((resolve, reject) => {
    v2.postMessage({
        job: 'sort',
        arr: half_2
    });
    v2.addEventListener('message', event => resolve(event.data));
    v2.addEventListener('error', reject);
})
var p3 = new Promise((resolve, reject) => {
    v3.postMessage({
        job: 'sort',
        arr: half_3
    });
    v3.addEventListener('message', event => resolve(event.data));
    v3.addEventListener('error', reject);
})
var p4 = new Promise((resolve, reject) => {
    v4.postMessage({
        job: 'sort',
        arr: half_4
    });
    v4.addEventListener('message', event => resolve(event.data));
    v4.addEventListener('error', reject);
})

Promise.all([p1, p2, p3, p4]).then(function(results) {
    //console.log( )
    var p5 = new Promise((resolve, reject) => {
        v1.addEventListener('message', event => resolve(event.data));
        v1.addEventListener('error', reject);
    })
    var p6 = new Promise((resolve, reject) => {
        v2.addEventListener('message', event => resolve(event.data));
        v2.addEventListener('error', reject);
    })
    v1.postMessage({
        job: 'merge',
        arr: [results[0], results[1]]
    });
    v2.postMessage({
        job: 'merge',
        arr: [results[2], results[3]]
    });

    Promise.all([p5, p6]).then(function(arrays) {
        merge(arrays[0], arrays[1])
        var t1 = performance.now();
        console.log(`merge_sort took ${(t1 - t0) / 1000} seconds`)
    })

});

序列号

function merge_sort(arr) {
  let length = arr.length;        
  if (length < 2) {
    return arr
  }
 let middle = Math.floor(length/2)
 let left = arr.slice(0, middle)     
 let right = arr.slice(middle)     
 return merge(merge_sort(left), merge_sort(right))
}

function merge(left, right) {
  let result = [];
  let i=0;
  let j=0;
  while(i < left.length && j < right.length) {
    if(left[i] < right[j]) {
      result.push(left[i]) ;
      i++;       
    } else {                       
      result.push(right[j]);
      j++;
    }
  }
  return result.concat(left.slice(i)).concat(right.slice(j))
}
var BigArray =Array.from({ length: 20000000 }, ()=>Math.floor(Math.random() * 50000000)); 
var t0 = performance.now();
merge_sort(BigArray)
var t1 = performance.now();
console.log(`merge_sort took ${(t1 - t0) / 1000} seconds`)

我也在寻找一种更好的并行排序解决方案（我对promises的使用很糟糕）

Answer 1

鉴于您要在线程之间复制，然后至少不必要地复制一次（通过使用concat），因此，对于大型阵列使用它的速度较慢并不感到奇怪。

如果您确实要对数字进行排序，则可以来回使用数组的type array types和 transfer 所有权之一，而不用复制其内容。这样可以减少复制量。如果您的起点是单个数组，则唯一的复制将是为单个工作程序复制到各个类型的数组，然后再从这些单个数组复制回主数组。

您甚至可以通过使用shared memory根据需要支持的平台进行进一步操作，从而只有阵列的一个副本，并且每个工作程序都（最初）在它自己的一部分上工作。 Chrome在其站点隔离功能可以抵御Spectre风格的漏洞的平台上启用了共享内存。我最后一次检查它在Firefox中被禁用，或者在其他浏览器中被禁用或未实现。

但是，如果不是真正要排序的数字，那么它们都不与绑定的类型数组绑定。

使用网络工作者的并行排序比串行排序（合并排序）慢

1 个答案: