Jacket Floating Point Performance (GFlops)

function [] = flopsMx2( Size, Dname, Fname, TitleStr, State )
% flopsMx2 GFlops count by use of matrix multiplication
 
%% GFlops benchmark based on multiplication of two matrices.
% (C) Torben Larsen, Aalborg University, 24-JUL-2010
%     E-mail: tl.jacket@es.aau.dk
%     http://wiki.accelereyes.com/wiki/index.php/Torben%27s_Corner
%
 
% Minimum execution time for the individual benchmark point
Tmin = 1;
 
% Max. number of repetitions in loop timing estimation
MaxAvg = 1E9;
 
 
%% INITIALIZE VECTORS
Mem_MB = zeros(length(Size),1);
Fname = ['flopsMx2_' Fname];
 
 
%% PREALLOCATE ARRAYS ETC. - IF "RESUME" IS USED THEN LOAD DATA
% If State==RESUME, data is loaded from the existing file for the given
% benchmark and continued from where it came to.
if strcmp(State,'RESUME')
    load([ Dname '/' Fname '.mat']);
    ii = length(find(GFlops_cpu>0));
    SizeN = Size(ii+1:end);
else
    GFlops_cpu = zeros(length(Size),1);
    GFlops_gpu = zeros(length(Size),1);
    T_CPU = zeros(length(Size),1);
    T_CPU_tot = zeros(length(Size),1);
    T_GPU = zeros(length(Size),1);
    T_GPU_tot = zeros(length(Size),1);
    ii = 0;
    SizeN = Size;
end
 
 
%% PERFORM ANALYSIS
for N=SizeN
    ii = ii + 1;
 
    % Define matrices
    Ac = randn(N,N,'single');
    Bc = randn(N,N,'single');
 
    % Print matrix size
    fprintf('%4.0f / %4.0f', N, max(Size));
 
    % CPU test begin --------------------------------------------------
    whilecount = 0;
    Telap_cpu = -1;
    while Telap_cpu < Tmin
        whilecount = whilecount + 1;
        if Telap_cpu == -1
            t1 = tic;
            Rc = Ac*Bc;   %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% HERE %%%
            Rc = Ac*Bc;   %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% HERE %%%
            Telap_cpu = toc(t1)/2;
            NoRunsCPU = ceil(1.5*Tmin/Telap_cpu);
        else
            NoRunsCPU = ceil(1.5*whilecount*NoRunsCPU/Telap_cpu*Tmin);
        end
 
        % Warm-up        
        for no=1:NoRunsCPU
            Rc = Ac*Bc;   %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% HERE %%%
        end
 
        % Benchmark
        tstart1 = tic;
        for no=1:NoRunsCPU
            Rc = Ac*Bc;   %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% HERE %%%
        end
        Telap_cpu = toc(tstart1);
    end
 
    % Determine time for CPU loop alone
    RPT = min(5E3,ceil(MaxAvg/NoRunsCPU));
    tstart = tic;
    for AvgNo=1:RPT
        for no=1:NoRunsCPU
        end
    end
    T_CPU_Loop = toc(tstart)/RPT;
 
    % Compute CPU times
    T_CPU(ii) = max((Telap_cpu-T_CPU_Loop)/NoRunsCPU,2.5E-10);
    T_CPU_tot(ii) = Telap_cpu;
    fprintf('  |  T_CPU: %6.1f,', T_CPU_tot(ii));
    GFlops_cpu(ii) = (2*N^3-N^2)/(T_CPU(ii)*1E9);
    fprintf('   %7.1f [GFlops]', GFlops_cpu(ii));
    % CPU test end   --------------------------------------------------
 
    % GPU test begin --------------------------------------------------
    Ag = gsingle(Ac);
    Bg = gsingle(Bc);
    geval(Ag,Bg);
 
    whilecount = 0;
    Telap_gpu = -1;
    while Telap_gpu < Tmin
        whilecount = whilecount + 1;
        if Telap_gpu == -1
            gsync;
            t1 = tic;
            Rg = Ag*Bg;   %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% HERE %%%
            geval(Rg);
            Rg = Ag*Bg;   %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% HERE %%%
            geval(Rg);
            gsync;
            Telap_gpu = toc(t1)/2;
            NoRunsGPU = ceil(1.5*Tmin/Telap_gpu);
        else
            NoRunsGPU = ceil(1.5*whilecount*NoRunsGPU/Telap_gpu*Tmin);
        end
 
        % Warm-up
        gsync;
        for no=1:NoRunsGPU
            Rg = Ag*Bg;   %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% HERE %%%
            geval(Rg);
        end
 
        % Benchmark
        gsync;
        tstart1 = tic;
        for no=1:NoRunsGPU
            Rg = Ag*Bg;   %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% HERE %%%
            geval(Rg);
        end
        gsync;
        Telap_gpu = toc(tstart1);
    end
 
    % Determine time for GPU loop alone
    RPT = min(5E3,ceil(MaxAvg/NoRunsGPU));
    tstart = tic;
    for AvgNo=1:RPT
        for no=1:NoRunsGPU
        end
    end
    T_GPU_Loop = toc(tstart)/RPT;
 
    % Compute GPU times
    T_GPU(ii) = max((Telap_gpu-T_GPU_Loop)/NoRunsGPU,2.5E-10);
    T_GPU_tot(ii) = Telap_gpu;
    fprintf('   |   T_GPU: %6.1f,', T_GPU_tot(ii));
    GFlops_gpu(ii) = (2*N^3-N^2)/(T_GPU(ii)*1E9);
    fprintf('   %7.1f [GFlops]', GFlops_gpu(ii));
    gpu_info = gpu_entry(13);
    Mem_MB(ii) = gpu_info.gpu_free/1E6;
    clear gpu_hook;
    fprintf('   |   Mem free [MB]:  %6.1f', Mem_MB(ii));
    % GPU test end   --------------------------------------------------
 
    % Print *** as a warning for simulation time violation
    % (should not be possible unless something spookey is going on)
    if T_CPU_tot(ii)>=Tmin && T_GPU_tot(ii)>=Tmin
        fprintf('\n');
    else
        fprintf('  ***\n');
    end
 
    % Save data and plot for every 10 data points
    if ii/10==floor(ii/10)
        save([ Dname '/' Fname '.mat'], 'Size', ...
             'T_CPU', 'T_CPU_tot', 'GFlops_cpu', ...
             'T_GPU', 'T_GPU_tot', 'GFlops_gpu');
 
        figure(1); clf(1);
        plot((2*Size(1:ii).^3-Size(1:ii).^2)/1E9, GFlops_cpu(1:ii), 'r-', ...
             (2*Size(1:ii).^3-Size(1:ii).^2)/1E9, GFlops_gpu(1:ii), 'g-', ...
             'Linewidth',1.5);
        grid;
        xlabel('Complexity   [GFlop]');
        ylabel('Performance   [GFlops]');
        legend('CPU', 'GPU', 'Location', 'SouthEast');
        title(['Mx2: ' TitleStr]);
 
        % Save figure
        print( gcf, '-djpeg99', '-r100', [ Dname '/' Fname '.jpg'] );
        print( gcf, '-depsc2', '-r2400', [ Dname '/' Fname '.eps'] );
    end
end
 
end

%% MASTER SCRIPT FOR GFLOPS COUNT
 
% IMPORTANT NOTE:  The name of the benchmark file MUST be like:
%                  Name_FCT.m where FCT is the name of the function
%                  to be benchmarked (all capital letters) - e.g. BESSELJ.
%                  A full name could be: AsusG51J_BESSELJ.m or
%                  Asus_G51J_BESSELJ.
%
% Platform:        Asus G51J
% CPU:             Intel Core i7-720QM 1.6GHz
% CPU GFlops:      25.6 (http://www.intel.com/support/processors/sb/cs-023143.htm)
% CPU mem.:        4 GB
% GPU:             NVIDIA GTX260M
% GPU GFlops:      462 (http://www.nvidia.com/object/product_geforce_gtx_260m_us.html)
% GPU mem.:        1024 MB
% Operating sys.:  Microsoft Windows 7 x64
% Jacket ver.:     1.4.0 (build 6080)
% NVIDIA driver:   257.21
% CUDA Toolkit:    3.1
 
%% SET UP INPUT DATA
% Set number of threads to 1
maxNumCompThreads(1);
 
% Matrix size
Size = [2:1:3390];
 
% Core name of plot and data files
Fname = 'Asus_G51J_01';
Dname = './Asus.GTX260M';
 
% Name of title in plot
TitleStr = 'Asus G51J: Core i7-720QM (25.6 GFlops) & GTX260M (462 GFlops)';
 
% Computation type;
%   State = 'BENCH' for cold start
%   State = 'RESUME' for continuation of computations
State = 'BENCH';
 
% Perform computation
flopsMx2( Size, Dname, Fname, TitleStr, State );