GPU and CPU version outputs differ

[robertleeplummerjr]

I'm getting different outputs for this scenario which is mirrored in CPU and GPU: https://jsfiddle.net/robertleeplummerjr/qhx8k7da/20/

The kernel function looks like:

function newRunMe(a, b, c, lda, ldb, ldc, m, n, k) {
  const cIndex = (ldc * this.thread.y) + this.thread.x;
  let sum = c[cIndex] * this.constants.beta;

  for (let i = 0; i < k; i++) {
    const aIndex = (lda * i) + this.thread.x;
    const bIndex = (ldb * this.thread.y) + i;
    sum += a[aIndex] * this.constants.alpha * b[bIndex];
  }

  return sum;
}

[robertleeplummerjr]

For clarity, this is the original CPU version:

const alpha = 0.3;
const beta = -1.2;
function runMe(a, b, c, lda, ldb, ldc, m, n, k) {
  //colOfEx: (col) => (col - colBase) * lda - rowBase,
  const result = c.slice(0);
  for (let j = 1; j <= n; j++) {
    const coorCJ = (j - 1) * ldc - 1;
    const coorBJ = (j - 1) * ldb - 1;
    for (let i = 1; i <= m; i++) {
      result[coorCJ + i] *= beta;
    }

    for (let l = 1; l <= k; l++) {
      let temp = alpha * b[coorBJ + l];
      const coorAL = (l-1)*lda -1;
      for (let i = 1; i <= m; i++) {
        result[coorCJ + i] += temp  * a[coorAL + i];
      }
    }
  }
  return result;
}

[robertleeplummerjr]

Example of breakage: https://jsfiddle.net/robertleeplummerjr/qhx8k7da/24/

[jacobbogers]

nice work so far, its not entrirely trivial I must confess,

[jacobbogers]

how is it going with this issue?

[kamil-kielczewski]

The result of gpu verions of fiddle returns matrix with all elements equal to -1.7014118346046923e+38 - it quite large number (numerical error?)

[kamil-kielczewski]

For trivial case when

a, b, c = [
  0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0,
];

we have similar result for GPU: -1.7014118346046923e+38. May be te error is connected with single/double precission (gpu=singe, cpu=double) ?

https://jsfiddle.net/qhx8k7da/25/

[kamil-kielczewski]

The problem is in read value from array a or b in loop in newRunMe kernel (for arry c everything works good)

https://jsfiddle.net/qhx8k7da/26/

[kamil-kielczewski]

WORKAROUND: The problem disappears if we remove constans binding from kernel (I change constans to regular kernel parameters):

function newRunMe(a, b, c, lda, ldb, ldc, m, n, k, alpha, beta) { ... }

...

const gpuKernelNoConst = gpu.createKernel(newRunMe, {
  output: [4, 6],
//  constants: {
//   	beta: beta,
//  	alpha: alpha
// } 
});

...

const gpuNoConstOutput = gpuKernelNoConst(a, b, c, lda, ldb, ldc, m, n, k, alpha, beta);

https://jsfiddle.net/qhx8k7da/27/

[robertleeplummerjr]

I've not been able to make any progress just yet for the GPU bug, though I'm sure it is probably a small bug. The erroneous value returned from the GPU for those interested (me) is an exponential of "-1.7014118346046923e+38", which we can convert to the real representation using this script (which I found on https://stackoverflow.com/a/18719988/1324039) and slightly modified:

function noExponents(n) {
    var data= String(n).split(/[eE]/);
    if(data.length== 1) return data[0]; 

    var  z= '', sign= n<0? '-':'',
    str= data[0].replace('.', ''),
    mag= Number(data[1])+ 1;

    if(mag<0){
        z= sign + '0.';
        while(mag++) z += '0';
        return z + str.replace(/^\-/,'');
    }
    mag -= str.length;  
    while(mag--) z += '0';
    return str + z;
}

Which gives us: "-17014118346046923000000000000000000000"

I was curious what this number actually was, because I'm not a rocket scientist, and thus I used this script https://stackoverflow.com/a/30524915/1324039 (modified to handle larger number):

// numToWords :: (Number a, String a) => a -> String
function numToWords (n) {
  let a = [
    '', 'one', 'two', 'three', 'four',
    'five', 'six', 'seven', 'eight', 'nine',
    'ten', 'eleven', 'twelve', 'thirteen', 'fourteen',
    'fifteen', 'sixteen', 'seventeen', 'eighteen', 'nineteen'
  ];
  let b = [
    '', '', 'twenty', 'thirty', 'forty',
    'fifty', 'sixty', 'seventy', 'eighty', 'ninety'
  ];
  let g = [
    '', 'thousand', 'million', 'billion', 'trillion', 'quadrillion',
    'quintillion', 'sextillion', 'septillion', 'octillion', 'nonillion', 'decillion', 'undecillion'
  ];
  // this part is really nasty still
  // it might edit this again later to show how Monoids could fix this up
  let makeGroup = ([ones,tens,huns]) => {
    return [
      num(huns) === 0 ? '' : a[huns] + ' hundred ',
      num(ones) === 0 ? b[tens] : b[tens] && b[tens] + '-' || '',
      a[tens+ones] || a[ones]
    ].join('');
  };
  // "thousands" constructor; no real good names for this, i guess
  let thousand = (group,i) => group === '' ? group : `${group} ${g[i]}`;
  // execute !
  if (typeof n === 'number') return numToWords(String(n));
  if (n === '0')             return 'zero';
  const arr = x => Array.from(x);
  const num = x => Number(x) || 0;
  const str = x => String(x);
  const isEmpty = xs => xs.length === 0;
  const take = n => xs => xs.slice(0,n);
  const drop = n => xs => xs.slice(n);
  const reverse = xs => xs.slice(0).reverse();
  const comp = f => g => x => f (g (x));
  const not = x => !x;
  const chunk = n => xs =>
    isEmpty(xs) ? [] : [take(n)(xs), ...chunk (n) (drop (n) (xs))];
  return comp (chunk(3)) (reverse) (arr(n))
    .map(makeGroup)
    .map(thousand)
    .filter(comp(not)(isEmpty))
    .reverse()
    .join(' ');
};

to arrive at: (negative) "seventeen undecillion fourteen decillion one hundred eighteen nonillion three hundred forty-six octillion forty-six septillion nine hundred twenty-three sextillion"

Just fyi.

[robertleeplummerjr]

WORKAROUND: The problem disappears

Nice find @kamil-kielczewski! This at least narrows down the issue substantially.

[kamil-kielczewski]

@robertleeplummerjr can you give some approximate time when this (critical) bug will be fixed? Or maybe works on gpu.js are currently suspended?

[robertleeplummerjr]

@robertleeplummerjr can you give some approximate time when this (critical) bug will be fixed?

I'll look into it sometime this week.

Or maybe works on gpu.js are currently suspended?

They definitely are not, just hectic time of year for work.