Интеграция внешнего/пользовательского кода

В этом примере показано, как интегрировать внешний или пользовательский код для повышения производительности созданного кода. Несмотря на то, что MATLAB ® Coder™ создает оптимизированный код для большинства приложений, вы можете использовать пользовательский код, оптимизированный в соответствии с вашими конкретными требованиями. Например:

Пользовательские библиотеки оптимизированы для целевой среды.
Имеются пользовательские библиотеки для функций, не поддерживаемых кодером MATLAB.
Имеются пользовательские библиотеки, соответствующие стандартам, установленным компанией.

В таких случаях можно интегрировать пользовательский код с кодом, сгенерированным MATLAB Coder.

В этом примере показано, как интегрировать функцию cublasSgemm из библиотеки подпрограмм NVIDIA ® ^CUDA ® Basic Linear Algebra Subroutines (CUBLAS) в сгенерированном коде. Эта функция выполняет умножение матрицы на графическом процессоре (GPU).

Определение класса ExternalLib_API которая происходит от класса coder.ExternalDependency. ExternalLib_API определяет интерфейс с CUBLAS с помощью следующих методов:

getDescriptiveName: Возвращает описательное имя для ExternalLib_API используется для сообщений об ошибках.
isSupportedContext: Определяет, поддерживает ли контекст построения CUBLAS библиотека.
updateBuildInfo: Добавление путей к файлам заголовков и файлов ссылок в информацию о построении.
GPU_MatrixMultiply: Определяет интерфейс с CUBLAS библиотечная функция cublasSgemm.

ExternalLib_API.m

classdef ExternalLib_API < coder.ExternalDependency
    %#codegen
    
    methods (Static)
        
        function bName = getDescriptiveName(~)
            bName = 'ExternalLib_API';
        end
        
        function tf = isSupportedContext(ctx)
            if  ctx.isMatlabHostTarget()
                tf = true;
            else
                error('CUBLAS library not available for this target');
            end
        end
        
        function updateBuildInfo(buildInfo, ctx)
            [~, linkLibExt, ~, ~] = ctx.getStdLibInfo();
            
            % Include header file path
            % Include header files later using coder.cinclude
            hdrFilePath = 'C:\My_Includes';
            buildInfo.addIncludePaths(hdrFilePath);
            
            % Include link files 
            linkFiles = strcat('libcublas', linkLibExt);
            linkPath = 'C:\My_Libs';
            linkPriority = '';
            linkPrecompiled = true;
            linkLinkOnly = true;
            group = '';
            buildInfo.addLinkObjects(linkFiles, linkPath, ...
                linkPriority, linkPrecompiled, linkLinkOnly, group);
            
            linkFiles = strcat('libcudart', linkLibExt);
            buildInfo.addLinkObjects(linkFiles, linkPath, ...
                linkPriority, linkPrecompiled, linkLinkOnly, group);
            
        end
        
        %API for library function 'cuda_MatrixMultiply'
        function C = GPU_MatrixMultiply(A, B)
            assert(isa(A,'single'), 'A must be single.');
            assert(isa(B,'single'), 'B must be single.');
            
            if(coder.target('MATLAB'))
                C=A*B;
            else
                
                % Include header files 
                %     for external functions and typedefs
                % Header path included earlier using updateBuildInfo
                coder.cinclude('"cuda_runtime.h"');
                coder.cinclude('"cublas_v2.h"');
                
                % Compute dimensions of input matrices
                m = int32(size(A, 1));
                k = int32(size(A, 2));
                n = int32(size(B, 2));
                
                % Declare pointers to matrices on destination GPU
                d_A = coder.opaque('float*');
                d_B = coder.opaque('float*');
                d_C = coder.opaque('float*');
                
                % Compute memory to be allocated for matrices
                % Single = 4 bytes
                size_A = m*k*4;
                size_B = k*n*4;
                size_C = m*n*4;
                
                % Define error variables 
                error = coder.opaque('cudaError_t');
                cudaSuccessV = coder.opaque('cudaError_t', ...
                    'cudaSuccess');
                
                % Assign memory on destination GPU 
                error = coder.ceval('cudaMalloc', ...
                    coder.wref(d_A), size_A);
                assert(error == cudaSuccessV, ...
                    'cudaMalloc(A) failed');
                error = coder.ceval('cudaMalloc', ...
                    coder.wref(d_B), size_B);
                assert(error == cudaSuccessV, ...
                    'cudaMalloc(B) failed');
                error = coder.ceval('cudaMalloc', ...
                    coder.wref(d_C), size_C);
                assert(error == cudaSuccessV, ...
                    'cudaMalloc(C) failed');
                
                % Define direction of copying 
                hostToDevice = coder.opaque('cudaMemcpyKind', ...
                    'cudaMemcpyHostToDevice');
                
                % Copy matrices to destination GPU 
                error = coder.ceval('cudaMemcpy',  ...
                    d_A, coder.rref(A), size_A, hostToDevice);
                assert(error == cudaSuccessV, 'cudaMemcpy(A) failed');
                
                error = coder.ceval('cudaMemcpy',  ...
                    d_B, coder.rref(B), size_B, hostToDevice);
                assert(error == cudaSuccessV, 'cudaMemcpy(B) failed');
                
                % Define type and size for result
                C = zeros(m, n, 'single');
                
                error = coder.ceval('cudaMemcpy', ...
                    d_C, coder.rref(C), size_C, hostToDevice);
                assert(error == cudaSuccessV, 'cudaMemcpy(C) failed');
                
                % Define handle variables for external library
                handle = coder.opaque('cublasHandle_t');
                blasSuccess = coder.opaque('cublasStatus_t', ...
                    'CUBLAS_STATUS_SUCCESS');
                
                % Initialize external library 
                ret = coder.opaque('cublasStatus_t');
                ret = coder.ceval('cublasCreate', coder.wref(handle));
                assert(ret == blasSuccess, 'cublasCreate failed');
                
               
                TRANSA = coder.opaque('cublasOperation_t', ...
                    'CUBLAS_OP_N');
                alpha = single(1);
                beta = single(0);
                
                % Multiply matrices on GPU 
                ret = coder.ceval('cublasSgemm', handle, ...
                    TRANSA,TRANSA,m,n,k, ...
                    coder.rref(alpha),d_A,m, ...
                    d_B,k, ...
                    coder.rref(beta),d_C,k);
                
                assert(ret == blasSuccess, 'cublasSgemm failed');
                
                % Copy result back to local host 
                deviceToHost = coder.opaque('cudaMemcpyKind', ...
                    'cudaMemcpyDeviceToHost');
                error = coder.ceval('cudaMemcpy', coder.wref(C), ...
                    d_C, size_C, deviceToHost);
                assert(error == cudaSuccessV, 'cudaMemcpy(C) failed');
                
            end
        end
    end
end

Для выполнения умножения матрицы с использованием интерфейса, определенного в методе GPU_MatrixMultiply и информацию о построении в ExternalLib_API, включите следующую строку в код MATLAB:
```
C= ExternalLib_API.GPU_MatrixMultiply(A,B);
```
Например, можно определить функцию MATLAB. Matrix_Multiply которая выполняет только это умножение матрицы.
```
function C = Matrix_Multiply(A, B) %#codegen
 C= ExternalLib_API.GPU_MatrixMultiply(A,B);
```
Определение MEX объект конфигурации с использованием coder.config. Для использования CUBLAS библиотеки, установите целевой язык для создания кода в C++.
```
cfg=coder.config('mex');
cfg.TargetLang='C++';
```
Создать код для Matrix_Multiply использование cfg как объект конфигурации и два 2 X 2 матрицы типа single в качестве аргументов. С тех пор cublasSgemm поддерживает умножение матрицы для типа данных float, соответствующие матрицы MATLAB должны иметь тип single.
```
codegen -config cfg Matrix_Multiply ...
            -args {ones(2,'single'),ones(2,'single')}
```
Протестируйте сгенерированные MEX функция Matrix_Multiply_mex использование двух 2 X 2 идентификационные матрицы типа single.
```
Matrix_Multiply_mex(eye(2,'single'),eye(2,'single'))
```
Выходные данные также являются 2 X 2 единичная матрица.

См. также

Связанные темы

Разработка интерфейса для внешнего кода C/C + +

Документация