什么是测量我的应用程序(多线程,使用OpenMP编写)使用的带宽最简单和最有效的方法?我运行STREAM以获取最大可持续带宽,现在想知道是否饱和了整个可用带宽。
我找到了一些相关问题(例如主内存带宽测量),但我找不到这个问题的答案;
遗憾的是,我不能使用VTune,但我可以使用PAPI计数器;
我的主要目标是找出我的应用程序的可扩展性差是否与内存带宽的饱和有关。
谢谢
我找到了一些相关问题(例如主内存带宽测量),但我找不到这个问题的答案;
遗憾的是,我不能使用VTune,但我可以使用PAPI计数器;
我的主要目标是找出我的应用程序的可扩展性差是否与内存带宽的饱和有关。
谢谢
有许多方法可以(从命令行)获取整个应用程序的带宽,但听起来您想单独查看一些内核。在这种情况下,使用PAPI调用包装代码的部分是完全合理的方法。
您可以在系统上使用PAPI事件计数器(papi_avail
)来找到总的加载/存储指令数量,并且如果你知道你的加载/存储大小,就可以得到内存带宽。或者,您可以计算缓存中的命中次数,并乘以线路大小来推断系统中实际传输的数据量。PAPI wiki的各个地方都有文档,例如这里提供高级接口,这里提供一些有用的派生公式。
这里有一个编码简单示例,以明智的方式和不友好的转置方式进行矩阵-向量乘法。请注意,调用PAPI_read_counters会重置计数器,这正是我们想要的。
#include <stdio.h>
#include <stdlib.h>
typedef char * caddr_t;
#include <papi.h>
#include <sys/time.h>
int init(float ***a, float **x, float **y, int size);
void report_results(char *tname, long_long *values, const int n, double wtime);
void sensible_matvec(float **a, float *x, float *y, int size);
void wrong_order_matvec(float **a, float *x, float *y, int size);
void tick(struct timeval *t);
double tock(struct timeval *t);
#define NUM_EVENTS 3
int main(int argc, char **argv) {
const int matsize = 4096;
float **a, *x, *y;
init(&a, &x, &y, matsize);
int events[NUM_EVENTS] = {PAPI_L1_DCM, PAPI_LST_INS, PAPI_FP_INS};
long_long values[NUM_EVENTS];
double walltime;
struct timeval t;
if (PAPI_start_counters(events, NUM_EVENTS) != PAPI_OK) {
fprintf(stderr, "Error starting PAPI counters; aborting\n");
exit(1);
}
tick(&t);
sensible_matvec(a, x, y, matsize);
PAPI_read_counters(values, NUM_EVENTS);
walltime = tock(&t);
report_results("Sensible", values, NUM_EVENTS, walltime);
tick(&t);
wrong_order_matvec(a, x, y, matsize);
PAPI_stop_counters(values, NUM_EVENTS);
walltime = tock(&t);
report_results("Wrong order", values, NUM_EVENTS, walltime);
return 0;
}
void report_results(char *tname, long_long *values, const int n, double wtime) {
long_long total_mem = values[1];
long_long total_flops = values[2];
long_long l1misses = values[0];
printf("Test %s: time elapsed = %f, memory accesses = %lld, flop = %lld\n",
tname, wtime, total_mem, total_flops);
printf("\tMemory bandwidth (MB/sec) = %f\n", 1.0*total_mem*sizeof(float)/(wtime*1024*1024));
printf("\tL1 cache miss rate = %f\n", 1.0*l1misses/total_mem);
printf("\tMFLOPS = %lf\n\n", 1.0*total_flops/(wtime*1024*1024));
}
int alloc2d(float ***a, int n);
int free2d(float ***a, int n);
int alloc1d(float **x, int n);
int free1d(float **x, int n);
int init(float ***a, float **x, float **y, int size) {
if (alloc2d(a,size))
return -2;
if (alloc1d(x,size)) {
free2d(a,size);
return -2;
}
if (alloc1d(y,size)) {
free2d(a,size);
free1d(x,size);
return -3;
}
for (int i=0; i<size; i++) {
(*x)[i] = (float)i;
(*y)[i] = 0.;
}
for (int i=0; i<size; i++) {
for (int j=0; j<size; j++) {
(*a)[i][j] = i;
}
}
return 0;
}
void sensible_matvec(float **a, float *x, float *y, int size) {
for (int i=0; i<size; i++) {
for (int j=0; j<size; j++) {
y[i] += a[i][j]*x[j];
}
}
}
void wrong_order_matvec(float **a, float *x, float *y, int size) {
for (int j=0; j<size; j++) {
for (int i=0; i<size; i++) {
y[i] += a[i][j]*x[j];
}
}
}
void tick(struct timeval *t) {
gettimeofday(t, NULL);
}
double tock(struct timeval *t) {
struct timeval now;
gettimeofday(&now, NULL);
return (double)(now.tv_sec - t->tv_sec) + ((double)(now.tv_usec - t->tv_usec)/1000000.);
}
void freeall(float ***a, float **x, float **y, int size) {
free2d(a, size);
free1d(x, size);
free1d(y, size);
return;
}
int alloc2d(float ***a, int n) {
float *data = (float *)malloc(n*n*sizeof(float));
if (data == NULL) return -1;
*a = (float **)malloc(n*sizeof(float *));
if (*a == NULL) {free(data); return -1;};
for (int i=0; i<n; i++)
(*a)[i] = &(data[i*n]);
return 0;
}
int free2d(float ***a, int n) {
free (&((*a)[0][0]));
free(*a);
return 0;
}
int alloc1d(float **a, int n) {
*a = (float *)malloc(n*sizeof(float));
if (*a == NULL) return -1;
return 0;
}
int free1d(float **a, int n) {
free(*a);
return 0;
}
运行结果如下:
$ gcc -o papi-test papi-test.c -I${PAPI_INC_DIR} -L${PAPI_LIB_DIR} -lpapi -Wall -std=c99
$ ./papi-test
Test Sensible: time elapsed = 0.121877, memory accesses = 302020775, flop = 33580481
Memory bandwidth (MB/sec) = 9453.119330
L1 cache miss rate = 0.003921
MFLOPS = 262.763624
Test Wrong order: time elapsed = 0.537639, memory accesses = 302026751, flop = 39629352
Memory bandwidth (MB/sec) = 2142.963254
L1 cache miss rate = 0.094045
MFLOPS = 70.295301
#pragam omp parallel for
for(int i=0; i<n; i++) {
x[i] = k;
}
#pragma omp parallel for
for(int i=0; i<n; i++) {
y[i] = x[i];
}
-ffast-math
编译):#pragma omp parallel for reduction(+:sum)
for(int i=0; i<n; i++) {
sum += x[i]*y[i];
}
STREAM的测试都是读写测试。我编写了自己的带宽工具,只进行写操作、读写操作和仅读操作。
不幸的是,写入数据的测试无法接近峰值带宽。原因是为了写入数据,它们必须先将数据读入缓存中。这就是为什么在我的系统上STREAM无法接近峰值带宽的原因。为了在进行写操作时获得峰值带宽,需要进行非临时存储,这种存储只会直接写入数据,而不会先将其读入缓存。
例如,使用SSE并假设x
和y
是浮点数数组,可以像这样进行读写测试:
#pragma omp parallel for
for(int i=0; i<n/4; i++) {
__m128 v = _mm_load_ps(&x[4*i]);
_mm_stream_ps(&y[4*i], v);
}
memset
和memcpy
做的这个工作。实际上,他的asmlib和我刚才提到的例子在我的系统上获得了85% (45 GB/s out of 51 GB/s) 的带宽, 而STREAM测试只能获得约45%的带宽。