Объединяйтесь Внешний / Пользовательский код

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

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

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

Этот пример иллюстрирует, как интегрировать функциональный cublasSgemm от библиотеки Basic Linear Algebra Subroutines (CUBLAS) NVIDIA^® CUDA^® в сгенерированном коде. Эта функция выполняет умножение матриц на Графическом процессоре (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 единичная матрица.

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

Объединяйтесь Внешний / Пользовательский код

Смотрите также

Похожие темы

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

Поддержка