Roofline-on-NVIDIA-GPUs代码分析

已于 2023-08-12 09:42:43 修改
阅读量2.2k 收藏 4
点赞数 2
分类专栏： NVIDIA Roofline 文章标签： Roofline 深度学习 gpu 性能分析
于 2021-12-04 10:28:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yiran103/article/details/121711485
版权

Roofline 代码现状：

下面对 NERSC/roofline-on-nvidia-gpus 进行介绍。

NERSC/roofline-on-nvidia-gpus 展示了在 NVIDIA GPU 尤其是在 V100上使用 Roofline 分析方法。仓库的结构如下所示。

  • /example-codes 包含一些玩具内核kernel_abc.cu和一个真正的 HPC 迷你应用程序 GPP，提取自材料科学代码 BerkeleyGW。

  • /ncu-section-files 包含 CUDA 11 中 Nsight Compute 附带的默认 Speed of Light 节文件，以及几个用于分层 Roofline 分析的自定义节文件，用于双精度、单精度、半精度和张量核心操作。这些节文件旨在使用 Nsight Compute（ncu） 自动收集屋顶线数据并进行可视化。

  • run.ncu演示了如何在 CUDA 11 中运行 Nsight Compute，而run.gpp.ncu是一个 Slurm 作业脚本，用于在 Cori GPU 上运行五个版本的 GPP 示例。

  • /custom-scripts 提供了一套作业启动、后处理和可视化脚本，可用于手动的 Roofline 数据采集和可视化。这样做的目的是使用户更容易将 Roofline 分析集成到自己的工作流中。

Customized ncu-based Roofline Workflow

为了与用户的其他工作流集成，/custom-scripts 提供了一套用于手动度量收集和 Roofline 可视化的脚本。

  • run.gpp.customized
  • postprocess.py and roofline.py

run.gpp.customized自定义脚本以 GPP 为例展示了 Roofline 分析所需的 Nsight Compute 指标列表。这些指标使用 Nsight Compute ncu (或nv-nsight-cu-cli）命令行实用程序收集，并写入/custom-scripts中的.csv文件。

然后，postprocess.py使用 Pandas 对结果进行后处理，以计算每个被分析内核的算术强度（ Arithmetic Intensity，AI）和 FLOP/s 吞吐量。
处理完成后，postprocess.py将调用基于 Matplotlib 的roofline.py绘制 Roofline 图表，然后将图表保存到.png文件中。

这些脚本中使用的数据收集方法详述如下。它是 CUDA 11 中 Nsight Compute 的新功能。

  • Time:
    • sm__cycles_elapsed.avg / sm__cycles_elapsed.avg.per_second
  • FLOPs:
    • DP: sm__sass_thread_inst_executed_op_dadd_pred_on.sum + 2 x sm__sass_thread_inst_executed_op_dfma_pred_on.sum + sm__sass_thread_inst_executed_op_dmul_pred_on.sum
    • SP: sm__sass_thread_inst_executed_op_fadd_pred_on.sum + 2 x sm__sass_thread_inst_executed_op_ffma_pred_on.sum + sm__sass_thread_inst_executed_op_fmul_pred_on.sum
    • HP: sm__sass_thread_inst_executed_op_hadd_pred_on.sum + 2 x sm__sass_thread_inst_executed_op_hfma_pred_on.sum + sm__sass_thread_inst_executed_op_hmul_pred_on.sum
    • Tensor Core: 512 x sm__inst_executed_pipe_tensor.sum
  • Bytes:
    • DRAM: dram__bytes.sum
    • L2: lts__t_bytes.sum
    • L1: l1tex__t_bytes.sum

run.gpp.customized
run.gpp.customized
postprocess.py

Environment module 工具，常用于高性能计算集群的环境配置管理上。它可以将软件编译器、MPI 库、数学库、应用软件（计算类软件、分析类软件等）等，以模块的方式，统一到一个框架下，使得用户可以动态切换环境变量。

module load cuda/11.0.2
module load pgi/19.10

设置 Nsight Compute CLI 需要收集的指标。

# Time
metrics="sm__cycles_elapsed.avg,\
sm__cycles_elapsed.avg.per_second,"

# DP
metrics+="sm__sass_thread_inst_executed_op_dadd_pred_on.sum,\
sm__sass_thread_inst_executed_op_dfma_pred_on.sum,\
sm__sass_thread_inst_executed_op_dmul_pred_on.sum,"

# SP
metrics+="sm__sass_thread_inst_executed_op_fadd_pred_on.sum,\
sm__sass_thread_inst_executed_op_ffma_pred_on.sum,\
sm__sass_thread_inst_executed_op_fmul_pred_on.sum,"

# HP
metrics+="sm__sass_thread_inst_executed_op_hadd_pred_on.sum,\
sm__sass_thread_inst_executed_op_hfma_pred_on.sum,\
sm__sass_thread_inst_executed_op_hmul_pred_on.sum,"

# Tensor Core
metrics+="sm__inst_executed_pipe_tensor.sum,"

# DRAM, L2 and L1
metrics+="dram__bytes.sum,\
lts__t_bytes.sum,\
l1tex__t_bytes.sum"

Slurm 是一个开源、容错、高度可扩展的集群管理和作业调度系统，适用于大型和小型 Linux 集群。
srun 用于提交作业以便实时执行或启动作业步骤。
切换到 GPP 目录，编译并运行。
指定-k参数可以根据内核名称的正则表达式匹配来过滤内核。

cd ../example-codes/GPP/

input=gpp214unformatted.dat
dir=../../custom-scripts/
 
# Baseline
output=output.csv
profilestr="ncu -k sigma_gpp_gpu --metrics $metrics --csv"
echo Baseline version
git checkout gpp.f90
make clean
make
srun -n1 $profilestr ./gpp.x $input  > $dir/$output 2>&1

切换到优化的4种实现并执行。

# Four optimization steps 
for n in `seq 1 4`
do
	output=output$n.csv
	profilestr="ncu -k sigma_gpp_gpu --metrics $metrics --csv"
	echo Patch version: $n
	git checkout gpp.f90
	patch gpp.f90 step$n.patch
	make clean
	make
	srun -n1 $profilestr ./gpp.x $input   > $dir/$output 2>&1
done

调用 postprocess.py 生成 Roofline 图。

module load python/3.7-anaconda-2019.10
cd $dir
srun -n1 python postprocess.py

postprocess.py
postprocess.py
roofline

files为当前路径下"output"开头的csv文件列表

datadir='.'
files=[x for x in os.listdir(datadir) if x.endswith('.csv') and x.startswith('output')]
files.sort()
files=[os.path.join(datadir,file) for file in files]

变量名用file不太可取。
获取文件行数。
pandas.read_csv 读取时跳过最后一行。
pandas.DataFrame.groupby 使用映射器或一系列列对 DataFrame 进行分组，返回一个pandas.core.groupby.DataFrameGroupBy对象。
pandas.pivot_table 创建一个电子表格样式的数据透视表作为 DataFrame。
按’Kernel Name’和’Metric Name’两列分组求和。
pandas.DataFrame.shape 返回一个表示 DataFrame 维度的元组。
计算的结果放入了dfs[tag]中。

dfs={}
for file in files:
    tag, ext = os.path.splitext(os.path.basename(file))
    dfs[tag]=pd.DataFrame()
    with open(file,'r') as f:
        cnt=0
        while True:
            ln=f.readline()
            if not ln:
                break
            cnt+=1
            if 'Host Name' in ln:
                break
        df = pd.read_csv(file, skiprows=cnt-1)
        dft=df.groupby(['Kernel Name','Metric Name']).sum()
        dfmetric=pd.pivot_table(dft, index='Kernel Name', columns='Metric Name', values='Metric Value')
        dfmetric['Count']=df.groupby(['Kernel Name']).count()['ID'].div(dfmetric.shape[1])

t i m e = c y c l e s r a t e \mathrm{time} = \frac{\mathrm{cycles}}{\mathrm{rate}} time=ratecycles​

        dfmetric['Time']=dfmetric['sm__cycles_elapsed.avg'] \
                        / (dfmetric['sm__cycles_elapsed.avg.per_second'] /dfmetric['Count'] )

a d d + 2 × f m a + m u l \mathrm{add} + 2\times \mathrm{fma} + \mathrm{mul} add+2×fma+mul

        dfmetric['CC FLOPs']= 2 * dfmetric['sm__sass_thread_inst_executed_op_dfma_pred_on.sum'] \
                            + dfmetric['sm__sass_thread_inst_executed_op_dmul_pred_on.sum'] \
                            + dfmetric['sm__sass_thread_inst_executed_op_dadd_pred_on.sum'] \
                            + 2 * dfmetric['sm__sass_thread_inst_executed_op_ffma_pred_on.sum'] \
                            + dfmetric['sm__sass_thread_inst_executed_op_fmul_pred_on.sum'] \
                            + dfmetric['sm__sass_thread_inst_executed_op_fadd_pred_on.sum'] \
                            + 2 * dfmetric['sm__sass_thread_inst_executed_op_hfma_pred_on.sum'] \
                            + dfmetric['sm__sass_thread_inst_executed_op_hmul_pred_on.sum'] \
                            + dfmetric['sm__sass_thread_inst_executed_op_hadd_pred_on.sum']

F L O P t c = I n s t t c × 512 \mathrm{FLOP_{tc}} = \mathrm{Inst_{tc}}\times 512 FLOPtc​=Insttc​×512

        dfmetric['TC FLOPs']= 512 * dfmetric['sm__inst_executed_pipe_tensor.sum']
        dfmetric['all FLOPs']= dfmetric['CC FLOPs'] + dfmetric['TC FLOPs']

        dfmetric['AI HBM'] = dfmetric['all FLOPs'].div(dfmetric['dram__bytes.sum'])
        dfmetric['AI L2'] = dfmetric['all FLOPs'].div(dfmetric['lts__t_bytes.sum'])
        dfmetric['AI L1'] = dfmetric['all FLOPs'].div(dfmetric['l1tex__t_bytes.sum'])

        dfmetric['GFLOP/s'] = dfmetric['all FLOPs']/ dfmetric['Time'] /1024/1024/1024
        dfmetric['TC GFLOP/s'] = dfmetric['TC FLOPs']/ dfmetric['Time'] /1024/1024/1024
#         dfmetric.to_csv('pd_'+tag+'.csv')
        dfs[tag]=dfmetric

对于每个文件的结果，
pandas.Index.tolist 返回值列表。
pandas.Series.tolist 返回值列表。
这样 roofline 函数不再需要调用 Pandas 的库函数。

tags=dfs.keys()
flags=['all'] #'HBM','L2','L1' or 'all'
for tag in tags:
    for flag in flags:
        dfm=dfs[tag]
        LABELS = dfm.index.tolist()
        AIL1   = dfm['AI L1'].tolist()
        AIL2   = dfm['AI L2'].tolist()
        AIHBM  = dfm['AI HBM'].tolist()
        FLOPS  = dfm['GFLOP/s'].tolist()

        roofline(tag, FLOPS, AIHBM, AIL2, AIL1, LABELS, flag)

roofline

检查输入参数是否为空。

def roofline(filename, FLOPS, AIHBM, AIL2=None, AIL1=None, LABELS=None, flag='HBM'):

    if not FLOPS:
        print('FLOPS can not be empty!')
        return
    if max(FLOPS)==0:
        print('FLOPS are all 0s!')
        return
    if (not AIHBM) and (not AIL2) and (not AIL1):
        print('AIHBM, AIL2 and AIL1 can not all be empty!')
        return
    if (len(FLOPS) != len(AIHBM)) or (len(FLOPS) != len(AIL2)) or (len(FLOPS) != len(AIL1)):
        print('FLOPS needs to have the same length as AI!')
        return
    if (flag != 'HBM') and (flag != 'L2') and (flag != 'L1') and (flag != 'all'):
        print('flag needs to be one of HBM, L2, L1, and all!')
        return

memRoofs和cmpRoofs为提前确定好的值。
matplotlib.pyplot.figure 创建新图窗，或激活现有图窗。figsize为以英寸为单位的宽和高。
matplotlib.pyplot.clf 清除当前图形。
matplotlib.figure.Figure.gca 获取当前轴。
matplotlib.axes.Axes.set_xscale 设置 x 轴比例。
matplotlib.axes.Axes.set_xlabel 设置 x 轴的标签。
matplotlib.axes.Axes.set_xlim 设置 x 轴视图限制。
matplotlib.axes.Axes.get_xlim 返回 x 轴视图限制。
x 轴和 y 轴对数尺度，其中 x 轴的可见区间为 [ 1 0 x m i n , 1 0 x m a x ] [10^{x_{min}}, 10^{x_{max}}] [10xmin​,10xmax​]。

    LABELS = [x[:maxchar] for x in LABELS]

    memRoofs = [('L1', 54000.), ('L2', 2996.77),  ('HBM', 828.76)] 
    cmpRoofs = [('Tensor', 96.9),('DP', 7.8)]

    fig = plt.figure(1,figsize=(10.67,6.6))
    plt.clf()
    ax = fig.gca()
    ax.set_xscale('log')
    ax.set_yscale('log')
    ax.set_xlabel('Arithmetic Intensity [FLOPs/Byte]')
    ax.set_ylabel('Performance [GFLOP/sec]')

    nx   = 10000
    xmin = -3 
    xmax = 3
    ymin = 1
    ymax = 200000

    ax.set_xlim(10**xmin, 10**xmax)
    ax.set_ylim(ymin, ymax)

    ixx = int(nx*0.02)
    xlim = ax.get_xlim()
    ylim = ax.get_ylim()

numpy.logspace 返回在[10**xmin, 10**xmax)区间内对数刻度上nx个均匀间隔的数字。
x与memRoofs相乘即可得到 y 轴上的性能值。
对于cmpRoofs中的每一种，如果当前位置的计算小于 L1的限制而前一点的计算大于 L1的限制，则将前一点加入scomp_x_elbow和scomp_ix_elbow中。
对于memRoofs中的每一种，如果当前位置的内存带宽大于 Tensor 算力的限制而前一点的内存带宽小于 Tensor 算力的限制，则将前一点加入smem_x_elbow和smem_ix_elbow中。

    scomp_x_elbow  = []
    scomp_ix_elbow = []
    smem_x_elbow   = []
    smem_ix_elbow  = []

    x = np.logspace(xmin,xmax,nx)
    for roof in cmpRoofs:
        for ix in range(1,nx):
            if float(memRoofs[0][1] * x[ix]) >= roof[1]*1024 and (memRoofs[0][1] * x[ix-1]) < roof[1]*1024:
                scomp_x_elbow.append(x[ix-1])
                scomp_ix_elbow.append(ix-1)
                break

    for roof in memRoofs:
        for ix in range(1,nx):
            if (cmpRoofs[0][1]*1024 <= roof[1] * x[ix] and cmpRoofs[0][1]*1024 > roof[1] * x[ix-1]):
                smem_x_elbow.append(x[ix-1])
                smem_ix_elbow.append(ix-1)
                break

绘制 Roofline 的折线。
对于每种cmpRoofs，绘制转弯后的部分。
对于每种memRoofs，绘制转弯前的部分。
这里使用len(cmpRoofs)和len(memRoofs)可能会遇到访问错误，换成len(scomp_ix_elbow)和len(smem_ix_elbow)较为合适。
matplotlib.axes.Axes.plot 用于绘制 XY 坐标系的点、线或其他标记形状。
color 为黑色，linestyle 为实线，linewidth 为 2 个像素。

    for i in range(len(cmpRoofs)):
        roof = cmpRoofs[i][1]*1024
        y = np.ones(len(x)) * roof
        ax.plot(x[scomp_ix_elbow[i]:],y[scomp_ix_elbow[i]:],c='k',ls='-',lw='2')

    for i in range(len(memRoofs)):
        roof = memRoofs[i][1]
        y = x * roof
        ax.plot(x[:smem_ix_elbow[i]+1],y[:smem_ix_elbow[i]+1],c='k',ls='-',lw='2')

绘制 kernel 性能数据到图上。L1的为圆圈，L2的为方形标记，HBM 的为倒三角标记。
按照AIHBM的长度遍历，这样假定其总是存在且长度匹配的。
根据flag来决定绘制哪一部分的结果。
从 colors 列表中取不同的颜色。
LABELS 为图例中的标签。

    for i in range(len(AIHBM)):
        if flag == 'L1':
            ax.plot(float(AIL1[i]),float(FLOPS[i]),c=colors[i%10],marker=styles[0],\
                    linestyle='None',ms=markersize,markerfacecolor='none',\
                    markeredgewidth=markerwidth,label=LABELS[i] if LABELS else "unknown")
        elif flag == 'L2':
            ax.plot(float(AIL2[i]),float(FLOPS[i]),c=colors[i%10],marker=styles[1],\
                    linestyle='None',ms=markersize,markerfacecolor='none',\
                    markeredgewidth=markerwidth,label=LABELS[i] if LABELS else "unknown")
        elif flag == 'HBM':
            ax.plot(float(AIHBM[i]),float(FLOPS[i]),c=colors[i%10],marker=styles[2],\
                    linestyle='None',ms=markersize,markerfacecolor='none',\
                    markeredgewidth=markerwidth,label=LABELS[i] if LABELS else "unknown")
        elif flag == 'all':
            ax.plot(float(AIL1[i]),float(FLOPS[i]),c=colors[i%10],marker=styles[0],\
                    linestyle='None',ms=markersize,markerfacecolor='none',\
                    markeredgewidth=markerwidth,label=LABELS[i] if LABELS else "unknown")
            ax.plot(float(AIL2[i]),float(FLOPS[i]),c=colors[i%10],marker=styles[1],\
                    linestyle='None',ms=markersize,markerfacecolor='none',\
                    markeredgewidth=markerwidth,label=LABELS[i] if LABELS else "unknown")
            ax.plot(float(AIHBM[i]),float(FLOPS[i]),c=colors[i%10],marker=styles[2],\
                    linestyle='None',ms=markersize,markerfacecolor='none',\
                    markeredgewidth=markerwidth,label=LABELS[i] if LABELS else "unknown")

matplotlib.axes.Axes.plot 会返回 matplotlib.lines.Line2D 对象的列表。

    marker_handles = []  

    if flag == 'L1':
        marker_handles.append(ax.plot([],[],c='k',marker=styles[0],linestyle='None',ms=markersize,\
                markerfacecolor='none',markeredgewidth=markerwidth,label=memRoofs[0][0])[0])
    elif flag == 'L2':
        marker_handles.append(ax.plot([],[],c='k',marker=styles[1],linestyle='None',ms=markersize,\
                markerfacecolor='none',markeredgewidth=markerwidth,label=memRoofs[1][0])[0])
    elif flag == 'HBM':
        marker_handles.append(ax.plot([],[],c='k',marker=styles[2],linestyle='None',ms=markersize,\
                markerfacecolor='none',markeredgewidth=markerwidth,label=memRoofs[2][0])[0])
    elif flag == 'all':
        for i in range(len(memRoofs)):
            marker_handles.append(ax.plot([],[],c='k',marker=styles[i],linestyle='None',ms=markersize,\
                                  markerfacecolor='none',markeredgewidth=markerwidth,label=memRoofs[i][0])[0])

matplotlib.axes.Axes.text 向轴添加计算峰值和内存速率数据。

    for roof in cmpRoofs:
        ax.text(x[-ixx],roof[1]*1024,
              roof[0] + ': ' + '{0:.1f}'.format(roof[1]) + ' TFLOP/s',
              horizontalalignment='right',
              verticalalignment='bottom')

    for roof in memRoofs:
        ang = np.arctan(np.log10(xlim[1]/xlim[0]) / np.log10(ylim[1]/ylim[0])
                                   * fig.get_size_inches()[1]/fig.get_size_inches()[0] )
        if x[ixx]*roof[1] >ymin:
            ax.text(x[ixx],x[ixx]*roof[1]*(1+0.25*np.sin(ang)**2),
              roof[0] + ': ' + '{0:.1f}'.format(float(roof[1])) + ' GB/s',
              horizontalalignment='left',
              verticalalignment='bottom',
              rotation=180/np.pi*ang)
        else:
            ymin_ix_elbow=list()
            ymin_x_elbow=list()
            for ix in range(1,nx):
                if (ymin <= roof[1] * x[ix] and ymin > roof[1] * x[ix-1]):
                    ymin_x_elbow.append(x[ix-1])
                    ymin_ix_elbow.append(ix-1)
                    break
            ax.text(x[ixx+ymin_ix_elbow[0]],x[ixx+ymin_ix_elbow[0]]*roof[1]*(1+0.25*np.sin(ang)**2),
              roof[0] + ': ' + '{0:.1f}'.format(float(roof[1])) + ' GB/s',
              horizontalalignment='left',
              verticalalignment='bottom',
              rotation=180/np.pi*ang)

matplotlib.pyplot.legend 在右下方放置一个内存类型的图例marker_handles。
matplotlib.axes.Axes.add_artist 添加 Artist
matplotlib.patches.Patch 是具有外观和边缘颜色的 2D Artist。
leg2中使用的loc=4不易理解。
matplotlib.pyplot.savefig 保存当前图窗。

        
    leg1 = plt.legend(handles = marker_handles,loc='lower right', ncol=len(flag[0]) if 'all' not in flag else 3,bbox_to_anchor = (1,0))
    ax.add_artist(leg1)

    patch_handles = list()
    for i in range(0,len(AIHBM)):
        if FLOPS[i] > 0:
            patch_handles.append(mpatches.Patch(color=colors[i%10],label = LABELS[i] if LABELS else "unknown"))

    leg2 = plt.legend(handles = patch_handles,loc=4,ncol=1,bbox_to_anchor = (1,0.1),scatterpoints = 1)

    ax.text(xlim[0]*1.1,ylim[1]/1.1, '-'.join([filename,flag]), horizontalalignment='left',verticalalignment='top')
#     plt.title('-'.join([filename,flag]))

    plt.savefig('_'.join([filename,flag])+'.png')
#     plt.savefig('_'.join([filename,flag])+'.eps')

#    plt.show()

理想效果为：
roofline

参考资料：

图波列夫
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
小白使用超算slurm作业调度系统提交作业（看完这篇就够了）
qq_43155641的博客
03-21 3126
上传项目文件到超算，安装conda后，超算平台本身没有GPU，用sinfo查看后，如何调用GPU来运行项目？那就需要slurm作业调度系统来提交作业（其实就是提交项目，让他调用GPU来运行项目）
Roofline模型（一）：概念、基本公式、图像分析
sinat_35360418的博客
01-13 5647
并行计算Roofline性能分析
Ubuntu使用 NVIDIA GPU 和 CUDA 设置 LLM 的训练、微调和推理
知来者逆的博客
06-22 736
近年来，人工智能领域取得了令人瞩目的进步，其核心是图形处理单元（GPU）和并行计算平台的强大组合。大模型如 GPT、BER能够理解和生成具有前所未有的流畅性和连贯性的类人文本。然而，训练这些模型需要大量的数据和计算资源，因此 GPU 和 CUDA 是这一努力中不可或缺的工具。这个博客演示了在 Ubuntu 上设置 NVIDIA GPU 的过程，涵盖 NVIDIA 驱动程序、CUDA 工具包、cuDNN、PyTorch 等基本软件组件的安装。
Roofline模型初步
宋宝华
04-27 2532
在多核异构的时代，软件人员普遍面临的一个困惑是，面对如此复杂的系统，应该如何部署我们的算法，是应该让它运行在CPU，GPU还是甚至类似TPU的专门ASIC上才是最佳方案？另外给定特定的计算...
模型越小，推理越快？想多了。
idol24的博客
09-28 1763
‍‍点击上方“机器学习与生成对抗网络”，关注星标获取有趣、好玩的前沿干货！‍作者 田子宸@知乎来源 https://zhuanlan.zhihu.com/p/411522457编辑 极...
cs-roofline-toolkit:伯克利实验室的CS Roofline工具包的前叉
05-13
CS Roofline工具包 欢迎来到CS Roofline Toolkit Bitbucket网站。 目前可以在此处使用Empirical Roofline工具和Roofline Visualizer。 将来将在此处托管其他工具。 请参阅以获取更多信息。 有关Roofline性能模型...
云计算-面向GPU计算平台的若干并行优化关键技术研究.pdf
07-03
1. 分析和比较当前主流GPU架构的异同，提出了GPU程序性能优化的三大有效途径：提高片外带宽利用率，提高计算资源利用率和数据本地化。 2. 提出算法计算密度和硬件计算密度两个概念，并通过这两个概念的比较将GPU ...
RoofLine 理论的出处、起因、理论和示例
05-09
以NVIDIA的Nsight Compute工具为例，该工具可以用于分析GPU应用程序，并提供RoofLine视图。首先，Nsight Compute会收集应用运行时的统计信息，包括计算操作数、内存访问量等。然后，它将这些数据映射到RoofLine图上...
国科大-叶笑春、王展-并行处理-期末复习资料
06-09
### 结合Roofline模型优化Stencil程序 针对3-D 7点Jacobi Stencil算法，我们可以考虑以下几点优化策略： 1. **减少通信开销**：尽量减少数据交换的需求。 2. **提高计算密集度**：增加每个计算单元的数据处理量。 ...
slurm集群执行作业出现RuntimeError: No CUDA GPUs are available、CUDA_LAUNCH_BLOCKING=1等问题。
Ryan0828的博客
03-06 1440
解决了linux集群利用slurm工具在初期跑torch代码遇到的gpu不可用相关问题。
slurm运行GPU显卡相关参数设定
荣合技术外包服务
05-23 366
srun -p gpuq --gres=gpu:1 nvidia-smi 就会出现获取到的GPU信息，以NVIDIA-SMI形式显示。在slurm的节点分区上可以设定GPU及普通节点分别为2个分区。如将以上参数中的GPU:1改为GPU:2就会获取2张GPU资源。比如：debug为普通分区，gpuq为GPU节点计算分区。示例：获取一张GPU，
MMDeteceion V3版之系列一（环境安装、模型测试、训练以及模型后处理工具）
qq_41627642的博客
05-06 7378
1、MMDeteceion初识 MMDetection是一款优秀的基于PyTorch的深度学习目标检测工具箱，由香港中文大学(CUHK)多媒体实验室(mmlab)开发。基本上支持所有当前SOTA二阶段的目标检测算法，比如faster rcnn，mask rcnn，r-fcn，Cascade-RCNN等。读者可在 PyTorch 环境下测试不同的预训练模型及训练新的检测分割模型。 根据 GitHub 项目所述，MMDetection的主要特征可以总结为以下几个方面： 模块化设计：将检测或者分割任务分解成几个模
你真的了解nsight compute中的Roofline Charts吗？
duanmushuangquan的博客
02-23 664
你真的了解roofline吗？
Nsight Compute 是怎么计算Roofline的呢
最新发布
Hi20240217的博客
06-28 1217
发现Nsight Compute中的Peak Work跟峰值算力对不上.这里进一步分析。
Roofline Model与深度学习模型的性能分析
weixin_30662109的博客
03-22 746
原文链接： https://zhuanlan.zhihu.com/p/34204282最近在不同的计算平台上验证几种经典深度学习模型的训练和预测性能时，经常遇到模型的实际测试性能表现和自己计算出的复杂度并不完全吻合的现象，令人十分困惑。机缘巧合听了Momenta的技术分享后，我意识到问题的答案其实就在于 Roof-line Model 这个理论，于是认真研究了一下...
【体系结构】使用Roofline model 分析GPU性能
yao09605的博客
06-12 2915
Roofline model 评估深度学习模型在GPU上运行的性能 本文使用Roofline model方式评估GeForce RTX 2060和TITAN V两款GPU上分别运行AlexNet以及VGGnet的性能。 GPU性能参数 根据NVDIA官网数据，GeForce RTX 2060 的峰值算力是7.5 TFLOPS，存储器带宽是336GB/s，TITAN V的峰值算力是7.0 TFLO...
roofline性能分析模型
qq_21376807的博客
08-24 913
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值