yuichiis
commented
1 year ago Hi
Before starting this topic.... I found a bug when using float64. I just fixed it now. please update with "composer update".
Well, Sorry for the lack of documentation for developers using only the rindow-math libraries. Because so few people have ever done it.
The manual does not describe how to program to use the GPU. However, it is made so that you can easily switch to GPU when using it in rindow-neuralnetworks. There is also a manual. But you should only want to use the rindow-math libraries.
The processing speed of the composer is very fast. If that time bothers you, there's more to do.
1) About linear algebra functions and rawmode-LA
The cross() function trades speed for convenience. You should use the gemm function in linear algebra.
The la() function calls linear algebra functions. Using raw mode, which omits emulation, saves even more time overhead. Using laRawMode() without emulation eliminates even more time overhead. Use gemm() in linear algebra functions to find matrix products.
2) Consider using GPU
You haven't used the GPU yet in your source code. If you don't need to use GPU, you don't need rindow_opencl and rindow_clblast. No need to install them or write to PHP.INI
However, GPU has the effect of speeding up when handling large data. Or even if you have programmed asynchronous operations. Since the CPU and GPU work asynchronously, the more times you wait for the results of the calculations, the slower the overall processing speed will be compared to the CPU alone. Speed also depends on the performance of the GPU manufacturer's OpenCL driver.
Here is an example of how to make a CPU and GPU in blocking mode.
<?php
include('vendor/autoload.php');
use Rindow\Math\Matrix\MatrixOperator;
use Interop\Polite\Math\Matrix\NDArray;
use Interop\Polite\Math\Matrix\OpenCL;
$mo = new MatrixOperator;
//$mode = 'CPU-NORMAL';
//$mode = 'CPU-RAW';
$mode = 'GPU';
$size = 1000;
$epochs = 100;
//$dtype = NDArray::float32;
$dtype = NDArray::float64;
switch($mode) {
case 'CPU-NORMAL': {
$la = $mo->la();
break;
}
case 'CPU-RAW': {
$la = $mo->laRawMode();
break;
}
case 'GPU': {
$la = $mo->laAccelerated('clblast',['deviceType'=>OpenCL::CL_DEVICE_TYPE_GPU]);
echo "blocking mode...\n";
$la->blocking(true);
break;
}
default: {
throw new Exception('Invalid mode');
}
}
//$la = $mo->la();
$accel = $la->accelerated()?'GPU':'CPU';
echo "Mode:$accel($mode)\n";
$fp64 = $la->fp64()?'TRUE':'FALSE';
echo "Supports float64 on this device: $fp64\n";
if($dtype==NDArray::float64 && $fp64=='FALSE') {
$dtype = NDArray::float32;
}
if($accel=='CPU') {
$name = $la->getBlas()->getCorename();
echo "CPU core name :$name\n";
$theads = $la->getBlas()->getNumThreads();
echo "CPU theads:$theads\n";
} else {
$i = 0;
$devices = $la->getContext()->getInfo(OpenCL::CL_CONTEXT_DEVICES);
$name = $devices->getInfo(0,OpenCL::CL_DEVICE_NAME);
echo "GPU device name :$name\n";
$cu = $devices->getInfo($i,OpenCL::CL_DEVICE_MAX_COMPUTE_UNITS);
echo "GPU Compute units :$cu\n";
}
$strdtype = $mo->dtypetostring($dtype);
echo "data type: $strdtype\n";
echo "computing size: [$size,$size]\n";
echo "epochs: $epochs\n";
$a = $mo->arange($size*$size,dtype:$dtype)->reshape([$size,$size]);
$b = $mo->arange($size*$size,dtype:$dtype)->reshape([$size,$size]);
$a = $la->array($a);
$b = $la->array($b);
$start = microtime(true);
for($i=0;$i<$epochs;$i++) {
$c = $la->gemm($a,$b);
}
echo "elapsed time:".(microtime(true)-$start)."\n";3) About parallel computing
Even in CPU mode, rindow-math runs multithreaded by the openblas library.
In GPU mode, in non-blocking mode, the CPU and GPU work asynchronously, so even if the function returns from the call, the processing is not finished. Therefore, while the GPU is operating, the CPU can also operate in parallel. In order to receive the calculation result of GPU, it is necessary to wait for completion by the finish() function. If you are familiar with parallel programming, you should try this method.
Good luck!
GajowyJ
Hi @yuichiis , I have to say that speed improvement is impressive! I have 10x acceleration, what means that calculations done in the past for 7 days are now calculated in just a few hours. I've found that this can be even more productive, when using threads from PHP parallel extension (to be honest it's a bit surprising to me - does this mean GPU units still have some free time when using rindow extenstion?). And is was enough that only one function (matrices multiplication = cross product) was migrated. Thank you for your excellent work with parallelism in PHP! Since time is crutial for my purposes, I must resign from any unncecessary code. That's why I avoid using composer/autoloader (well, checking PHP version against 5.6 and cascade of includes and function calls each time is time-wasting). So I found minimal configuration that works:
And in the php.ini I added:
As you noticed, there is nothing about
rindow_clblast. Does it means that this extension is not for matrix manipulation? If I add it, will I get extra speed up in any way?