OpenCL
OpenCL via Mathematics.NET is available on Windows and Linux machines with compatible GPUs. Please note that support is limited, and its features are subject to change drastically until an official release of the package has been made.
Matrix Multiplication Example
Here is an example of matrix multiplication on an NVIDIA GeForce RTX 2080 Ti. More methods will be added in the future that will allow users to get more information about their GPUs.
Setup
One way to set up OpenCL for Mathematics.NET is with the following:
using CommunityToolkit.HighPerformance;
using Mathematics.NET.Core;
using Mathematics.NET.GPU;
using Mathematics.NET.GPU.OpenCL;
using Mathematics.NET.LinearAlgebra;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
var builder = Host.CreateApplicationBuilder();
// Configure the service.
builder.Services.AddSingleton<IComputeService, OpenCLService>(provider =>
{
var logger = provider.GetRequiredService<ILogger<OpenCLService>>();
return new OpenCLService(
logger,
OpenCLService.Vendors.NVIDIA,
x => x.Name == "NVIDIA GeForce RTX 2080 Ti");
});
// Add logging filters.
#if DEBUG
builder.Logging.AddFilter(logLevel => logLevel >= LogLevel.Debug);
#elif RELEASE
builder.Logging.AddFilter(logLevel => logLevel >= LogLevel.Warning);
#endif
// Build the application.
var app = builder.Build();
We can also instantiate OpenCLService directly, but for this example, we will use the former. To get the service, use
// Get the OpenCL service.
using var openCL = app.Services.GetRequiredService<IComputeService>();
Matrix Multiplication Without Padding
Suppose we want to compute , where
and
We can use the method MatMul to perform matrix multiplication on the GPU.
// Create and fill the left matrix.
Span2D<Real> matA = new Real[4, 16];
for (int i = 0; i < 4; i++)
{
for (int j = 0; j < 16; j++)
{
matA[i, j] = 16 * i + j;
}
}
// Create and fill the right matrix.
Span2D<Real> matB = new Real[16, 8];
for (int i = 0; i < 16; i++)
{
for (int j = 0; j < 8; j++)
{
matB[i, j] = 8 * i + j;
}
}
// Perform the computation on a chosen device with global and local work sizes of { 4, 8 }.
var result = openCL.MatMul(openCL.Devices[0], new(4, 8), new(4, 8), matA, matB);
Console.WriteLine(result.ToDisplayString());
This gives us the following result:
Matrix Multiplication with Padding
Sometimes, the matrices we want to multiply my not have ideal dimensions; more specifically, the dimensions of the matrices are such that they cannot be evenly divided by our local work size. In such a case, we have to pad our matrices to get them to the proper dimensions. Now, suppose
and
We can use Pad to add zeros to the right and bottom of each of these matrices so that and have dimensions 4 x 8 and 8 x 8, respectively.
var pMatA = matA.Pad(4, 8);
var pMatB = matB.Pad(8, 8);
Then using the same method above, we can perform matrix multiplication with the two matrices.
var result = openCL.MatMul(openCL.Devices[0], new(4, 8), new(4, 4), pMatA, pMatB);
Console.WriteLine(result.Slice(0, 0, 3, 5).ToDisplayString());
Here, we chose a local work size of { 4, 4 }, which is a multiple of our global work size.
For performance reasons, matrices should only be padded once. When finished, use Slice, or the 2D version from CommunityToolkit, to get the unpadded result.
With that, we now have our result: