derek/TheBandwidthBenchmark
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'master' of github.com:RRZE-HPC/TheBandwidthBenchmark

Browse Source
This commit is contained in:
Jan Eitzinger
2020-04-29 12:09:19 +02:00
parent 532ac4d05f 3cb73d5ba0
commit 8a6951a0e6
40 changed files with 335 additions and 952 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
MainMemory/bench.pl
View File

@@ -1,23 +0,0 @@
#!/usr/bin/env perl
use strict;
use warnings;
use utf8;
my $CMD = $ARGV[0];
my @N = split /-/, $ARGV[1];
my $R = $ARGV[2];
my $MAX = 0; my $CORES = 0; my $BENCH = '';
my $SMT = $ARGV[3] ? $ARGV[3] : 2;
foreach my $numcores ( $N[0] ... $N[1] ) {
foreach ( 1 ... $R ) {
foreach my $ln ( split /\n/, `likwid-pin -c E:S0:$numcores:1:$SMT $CMD` ){
if ( $ln =~ /^([A-Za-z]+):[ ]+([0-9.]+) /) {
if ( $MAX < $2 ){
$MAX = $2; $CORES = $numcores; $BENCH = $1;
}
}
}
}
}
print "$BENCH was best using $CORES threads: $MAX\n";

89
MainMemory/src/affinity.c
View File

@@ -1,89 +0,0 @@
/*
* =======================================================================================
*
* Author: Jan Eitzinger (je), jan.treibig@gmail.com
* Copyright (c) 2019 RRZE, University Erlangen-Nuremberg
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
* =======================================================================================
*/
#ifdef __linux__
#ifdef _OPENMP
#include <stdlib.h>
#include <stdio.h>
#include <sched.h>
#include <unistd.h>
#include <sys/types.h>
#include <pthread.h>
#include <sys/syscall.h>
#define MAX_NUM_THREADS 128
#define gettid() syscall(SYS_gettid)
static int
getProcessorID(cpu_set_t* cpu_set)
{
int processorId;
for ( processorId = 0; processorId < MAX_NUM_THREADS; processorId++ )
{
if ( CPU_ISSET(processorId,cpu_set) )
{
break;
}
}
return processorId;
}
int
affinity_getProcessorId()
{
cpu_set_t cpu_set;
CPU_ZERO(&cpu_set);
sched_getaffinity(gettid(),sizeof(cpu_set_t), &cpu_set);
return getProcessorID(&cpu_set);
}
void
affinity_pinThread(int processorId)
{
cpu_set_t cpuset;
pthread_t thread;
thread = pthread_self();
CPU_ZERO(&cpuset);
CPU_SET(processorId, &cpuset);
pthread_setaffinity_np(thread, sizeof(cpu_set_t), &cpuset);
}
void
affinity_pinProcess(int processorId)
{
cpu_set_t cpuset;
CPU_ZERO(&cpuset);
CPU_SET(processorId, &cpuset);
sched_setaffinity(0, sizeof(cpu_set_t), &cpuset);
}
#endif /*__linux__*/
#endif /*_OPENMP*/

58
MainMemory/src/allocate.c
View File

@@ -1,58 +0,0 @@
/*
* =======================================================================================
*
* Author: Jan Eitzinger (je), jan.treibig@gmail.com
* Copyright (c) 2019 RRZE, University Erlangen-Nuremberg
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
* =======================================================================================
*/
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
void* allocate (int alignment, size_t bytesize)
{
int errorCode;
void* ptr;
errorCode = posix_memalign(&ptr, alignment, bytesize);
if (errorCode) {
if (errorCode == EINVAL) {
fprintf(stderr,
"Error: Alignment parameter is not a power of two\n");
exit(EXIT_FAILURE);
}
if (errorCode == ENOMEM) {
fprintf(stderr,
"Error: Insufficient memory to fulfill the request\n");
exit(EXIT_FAILURE);
}
}
if (ptr == NULL) {
fprintf(stderr, "Error: posix_memalign failed!\n");
exit(EXIT_FAILURE);
}
return ptr;
}

49
MainMemory/src/timing.c
View File

@@ -1,49 +0,0 @@
/*
* =======================================================================================
*
* Author: Jan Eitzinger (je), jan.treibig@gmail.com
* Copyright (c) 2019 RRZE, University Erlangen-Nuremberg
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
* =======================================================================================
*/
#include <stdlib.h>
#include <time.h>
double getTimeStamp()
{
struct timespec ts;
clock_gettime(CLOCK_MONOTONIC, &ts);
return (double)ts.tv_sec + (double)ts.tv_nsec * 1.e-9;
}
double getTimeResolution()
{
struct timespec ts;
clock_getres(CLOCK_MONOTONIC, &ts);
return (double)ts.tv_sec + (double)ts.tv_nsec * 1.e-9;
}
double getTimeStamp_()
{
return getTimeStamp();
}

31
MainMemory/Makefile → Makefile
View File

@@ -1,3 +1,27 @@
#=======================================================================================
#
# Author: Jan Eitzinger (je), jan.eitzinger@fau.de
# Copyright (c) 2019 RRZE, University Erlangen-Nuremberg
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
#
#=======================================================================================
#CONFIGURE BUILD SYSTEM #CONFIGURE BUILD SYSTEM
TARGET = bwbench-$(TAG) TARGET = bwbench-$(TAG)
@@ -9,6 +33,7 @@ Q ?= @
#DO NOT EDIT BELOW #DO NOT EDIT BELOW
include $(MAKE_DIR)/config.mk include $(MAKE_DIR)/config.mk
include $(MAKE_DIR)/include_$(TAG).mk include $(MAKE_DIR)/include_$(TAG).mk
include $(MAKE_DIR)/include_LIKWID.mk
INCLUDES += -I./src/includes INCLUDES += -I./src/includes
VPATH = $(SRC_DIR) VPATH = $(SRC_DIR)
@@ -30,12 +55,12 @@ asm: $(BUILD_DIR) $(ASM)
$(BUILD_DIR)/%.o: %.c $(BUILD_DIR)/%.o: %.c
@echo "===> COMPILE $@" @echo "===> COMPILE $@"
$(Q)$(CC) -c $(CPPFLAGS) $(CFLAGS) $< -o $@ $(CC) -c $(CPPFLAGS) $(CFLAGS) $< -o $@
$(Q)$(CC) $(CPPFLAGS) -MT $(@:.d=.o) -MM $< > $(BUILD_DIR)/$*.d $(Q)$(GCC) $(CPPFLAGS) -MT $(@:.d=.o) -MM $< > $(BUILD_DIR)/$*.d
$(BUILD_DIR)/%.s: %.c $(BUILD_DIR)/%.s: %.c
@echo "===> GENERATE ASM $@" @echo "===> GENERATE ASM $@"
$(Q)$(CC) -S $(CPPFLAGS) $(CFLAGS) $< -o $@ $(CC) -S $(CPPFLAGS) $(CFLAGS) $< -o $@
$(BUILD_DIR)/%.s: %.f90 $(BUILD_DIR)/%.s: %.f90
@echo "===> COMPILE $@" @echo "===> COMPILE $@"

45
MemoryHierarchy/Makefile
View File

@@ -1,45 +0,0 @@
#CONFIGURE TOOL CHAIN
CC = gcc
OPENMP = -fopenmp
#CFLAGS = -O3 -xHost -qopt-zmm-usage=high -std=c99 $(OPENMP)
CFLAGS = -O3 -std=c99 $(OPENMP)
LFLAGS = $(OPENMP)
DEFINES = -D_GNU_SOURCE
#DEFINES += -DVERBOSE
#DEFINES += -DLIKWID_PERFMON
DEFINES += -DNTIMES=5
DEFINES += -DARRAY_ALIGNMENT=64
#CONFIGURE BUILD SYSTEM
TARGET = striad
BUILD_DIR = ./build
SRC_DIR = ./src
INCLUDES += -I./src/
#DO NOT EDIT BELOW
VPATH = $(SRC_DIR)
ASM = $(patsubst $(SRC_DIR)/%.c, $(BUILD_DIR)/%.s,$(wildcard $(SRC_DIR)/*.c))
OBJ = $(patsubst $(SRC_DIR)/%.c, $(BUILD_DIR)/%.o,$(wildcard $(SRC_DIR)/*.c))
CPPFLAGS := $(CPPFLAGS) $(DEFINES) $(INCLUDES)
${TARGET}: $(BUILD_DIR) $(OBJ)
${CC} ${LFLAGS} -o $(TARGET) $(OBJ) $(LIBS)
asm: $(BUILD_DIR) $(ASM)
$(BUILD_DIR)/%.o: %.c
$(CC) -c $(CPPFLAGS) $(CFLAGS) $< -o $@
$(BUILD_DIR)/%.s: %.c
$(CC) -S $(CPPFLAGS) $(CFLAGS) $< -o $@
$(BUILD_DIR):
@mkdir $(BUILD_DIR)
.PHONY: clean
clean:
@echo "===> CLEAN"
@rm -rf $(BUILD_DIR)
@rm -f $(TARGET)

38
MemoryHierarchy/bench.pl
View File

@@ -1,38 +0,0 @@
#!/usr/bin/env perl
use strict;
use warnings;
use utf8;
if ( $#ARGV < 2 ){
print "Usage: ./bench.pl <numcores> <seq|tp|ws> <SMT>\n";
exit;
}
my $numCores = $ARGV[0];
my $type = 0;
my $SMT = $ARGV[2] ? $ARGV[2] : 2;
my $N = 100;
if ( $ARGV[1] eq 'seq' ){
$type = 0;
} elsif ( $ARGV[1] eq 'tp' ){
$type = 1;
} elsif ( $ARGV[1] eq 'ws' ){
$type = 2;
}
print("# striad $numCores $SMT $ARGV[1]\n");
while ( $N < 8000000 ) {
my $result;
my $performance = '0.00';
while ( $performance eq '0.00' ){
$result = `likwid-pin -c E:S0:$numCores:1:$SMT -q ./striad $type $N`;
$result =~ /([0-9.]+) ([0-9.]+)/;
$performance = $2;
}
print $result;
$N = int($N * 1.2);
}

15
MemoryHierarchy/bench.plot
View File

@@ -1,15 +0,0 @@
set terminal png size 1024,768 enhanced font ,12
set output 'striad.png'
set xlabel 'Size [kB]'
set xrange [100:]
set yrange [0:]
set ylabel 'Performance [MFLOP/s]'
cpuname = system("likwid-topology | grep 'CPU name' | cut -d ':' -f2 | sort -u | xargs")
numcores = system("grep 'striad' striad.dat | cut -d ' ' -f 3")
smt = system("grep 'striad' striad.dat | cut -d ' ' -f 4")
type = system("grep 'striad' striad.dat | cut -d ' ' -f 5")
set title sprintf("Benchmark of stream triad A[i] = B[i] + C[i] * D[i]\nType '%s', Threads %s, SMT %s, CPU %s", type, numcores, smt, cpuname)
set logscale x
plot 'striad.dat' u 1:2 w linespoints title 'striad'

78
MemoryHierarchy/bench.py
View File

@@ -1,78 +0,0 @@
#!/usr/bin/env python3
# =======================================================================================
#
# Author: Thomas Gruber (tg), thomas.gruber@googlemail.com
# Copyright (c) 2019 RRZE, University Erlangen-Nuremberg
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
#
# =======================================================================================
import sys, subprocess, re
default_regex = "([0-9.]+) ([0-9.]+)"
default_smt = 2
striad_types = {"seq" : 0,
"tp" : 1,
"ws" : 2
}
start_N = 100
max_N = 8000000
scale_N = 1.2
if len(sys.argv) < 3 or len(sys.argv) > 4:
print("Usage: {} <numcores> <seq|tp|ws> (<smt>)".format(sys.argv[0]))
print("Default <smt> value is {}".format(default_smt))
sys.exit(1)
numcores = int(sys.argv[1])
striad_type = sys.argv[2]
striad_t = 0
if striad_type in striad_types:
striad_t = striad_types.get(striad_type)
else:
print("Invalid type for striad. Available types: {}".format(", ".join(striad_types.keys())))
sys.exit(1)
smt = int(sys.argv[3]) if len(sys.argv) == 4 else default_smt
print("# striad {} {} {}".format(numcores, smt, striad_type))
N = start_N
while N < max_N:
performance = 0
result = None
runcmd = "likwid-pin -c E:S0:{}:1:{} -q ./striad {} {}".format(numcores, smt,
striad_t, N)
while performance == 0:
p = subprocess.Popen(runcmd, stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
shell=True)
p.wait()
if p.returncode == 0:
result = p.stdout.read().decode('utf-8').strip()
m = re.search(default_regex, result)
if m:
performance = float(m.group(2))
else:
print("Execution failed: {}".format(runcmd))
break
print(result)
sys.stdout.flush()
N = int(N * scale_N)

36
MemoryHierarchy/src/affinity.h
View File

@@ -1,36 +0,0 @@
/*
* =======================================================================================
*
* Author: Jan Eitzinger (je), jan.treibig@gmail.com
* Copyright (c) 2019 RRZE, University Erlangen-Nuremberg
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
* =======================================================================================
*/
#ifndef AFFINITY_H
#define AFFINITY_H
extern int affinity_getProcessorId();
extern void affinity_pinProcess(int);
extern void affinity_pinThread(int);
#endif /*AFFINITY_H*/

33
MemoryHierarchy/src/allocate.h
View File

@@ -1,33 +0,0 @@
/*
* =======================================================================================
*
* Author: Jan Eitzinger (je), jan.treibig@gmail.com
* Copyright (c) 2019 RRZE, University Erlangen-Nuremberg
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
* =======================================================================================
*/
#ifndef __ALLOCATE_H_
#define __ALLOCATE_H_
extern void* allocate (int alignment, size_t bytesize);
#endif

216
MemoryHierarchy/src/main.c
View File

@@ -1,216 +0,0 @@
/*
* =======================================================================================
*
* Author: Jan Eitzinger (je), jan.treibig@gmail.com
* Copyright (c) 2019 RRZE, University Erlangen-Nuremberg
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
* =======================================================================================
*/
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <limits.h>
#include <float.h>
#ifdef _OPENMP
#include <omp.h>
#endif
#include <likwid_markers.h>
#include <timing.h>
#include <allocate.h>
#include <affinity.h>
#define HLINE "----------------------------------------------------------------------------\n"
#ifndef MIN
#define MIN(x,y) ((x)<(y)?(x):(y))
#endif
#ifndef MAX
#define MAX(x,y) ((x)>(y)?(x):(y))
#endif
#ifndef ABS
#define ABS(a) ((a) >= 0 ? (a) : -(a))
#endif
extern double striad_seq(double*, double*, double*, double*, int, int);
extern double striad_tp(double*, double*, double*, double*, int, int);
extern double striad_ws(double*, double*, double*, double*, int, int);
typedef double (*testFunc)(double*, double*, double*, double*, int, int);
int main (int argc, char** argv)
{
size_t bytesPerWord = sizeof(double);
size_t N;
int type;
size_t iter = 1;
size_t scale = 1;
double *a, *b, *c, *d;
double E, S;
double avgtime, maxtime, mintime;
double times[NTIMES];
double dataSize;
testFunc func;
char* testname;
if ( argc > 2 ) {
type = atoi(argv[1]);
N = atoi(argv[2]);
} else {
printf("Usage: %s <test type> <N>\n",argv[0]);
printf("Test types: 0 - sequential, 1 - OpenMP throughput, 2 - OpenMP worksharing\n");
exit(EXIT_SUCCESS);
}
LIKWID_MARKER_INIT;
switch ( type ) {
case 0:
func = striad_seq;
testname = "striad_seq";
break;
case 1:
func = striad_tp;
testname = "striad_tp";
#ifdef _OPENMP
#pragma omp parallel
{
#pragma omp single
scale = omp_get_num_threads();
LIKWID_MARKER_REGISTER("BENCH");
}
#endif
break;
case 2:
func = striad_ws;
testname = "striad_ws";
break;
default:
printf("Unknown test type: %d\n", type);
exit(EXIT_FAILURE);
}
a = (double*) allocate( ARRAY_ALIGNMENT, N * bytesPerWord );
b = (double*) allocate( ARRAY_ALIGNMENT, N * bytesPerWord );
c = (double*) allocate( ARRAY_ALIGNMENT, N * bytesPerWord );
d = (double*) allocate( ARRAY_ALIGNMENT, N * bytesPerWord );
#ifdef VERBOSE
printf(HLINE);
dataSize = 4.0 * bytesPerWord * N;
if ( dataSize < 1.0E06 ) {
printf ("Total allocated datasize: %8.2f KB\n", dataSize * 1.0E-03);
} else {
printf ("Total allocated datasize: %8.2f MB\n", dataSize * 1.0E-06);
}
#endif
avgtime = 0;
maxtime = 0;
mintime = FLT_MAX;
#ifdef VERBOSE
#ifdef _OPENMP
printf(HLINE);
#pragma omp parallel
{
int k = omp_get_num_threads();
int i = omp_get_thread_num();
#pragma omp single
printf ("OpenMP enabled, running with %d threads\n", k);
printf ("\tThread %d running on processor %d\n", i, affinity_getProcessorId());
}
#endif
#endif
S = getTimeStamp();
#pragma omp parallel for
for (int i=0; i<N; i++) {
a[i] = 2.0;
b[i] = 1.0;
c[i] = 0.8;
d[i] = 1.01;
}
E = getTimeStamp();
#ifdef VERBOSE
printf ("Timer resolution %.2e ", getTimeResolution());
printf ("Ticks used %.0e\n", (E-S) / getTimeResolution());
#endif
iter = 5;
times[0] = 0.0;
times[1] = 0.0;
while ( times[0] < 0.2 ){
times[0] = func(a, b, c, d, N, iter);
if ( times[0] > 0.1 ) break;
double factor = 0.2 / (times[0] - times[1]);
iter *= (int) factor;
times[1] = times[0];
}
#ifdef VERBOSE
printf ("Using %d iterations \n", iter);
#endif
for ( int k=0; k < NTIMES; k++) {
times[k] = func(a, b, c, d, N, iter);
}
for (int k=1; k<NTIMES; k++) {
avgtime = avgtime + times[k];
mintime = MIN(mintime, times[k]);
maxtime = MAX(maxtime, times[k]);
}
#ifdef VERBOSE
printf(HLINE);
printf("Function Rate(MB/s) Rate(MFlop/s) Avg time Min time Max time\n");
avgtime = avgtime/(double)(NTIMES-1);
double bytes = (double) 4.0 * sizeof(double) * N * iter * scale;
double flops = (double) 2.0 * N * iter * scale;
printf("%s %11.2f %11.2f %11.4f %11.4f %11.4f\n",
testname,
1.0E-06 * bytes/mintime,
1.0E-06 * flops/mintime,
avgtime,
mintime,
maxtime);
printf("Flops %e\n", flops);
printf(HLINE);
#else
double flops = (double) 2 * N * iter * scale;
printf("%d %.2f\n", N, 1.0E-06 * flops/mintime);
#endif
LIKWID_MARKER_CLOSE;
return EXIT_SUCCESS;
}

57
MemoryHierarchy/src/striad_seq.c
View File

@@ -1,57 +0,0 @@
/*
* =======================================================================================
*
* Author: Jan Eitzinger (je), jan.treibig@gmail.com
* Copyright (c) 2019 RRZE, University Erlangen-Nuremberg
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
* =======================================================================================
*/
#include <stdio.h>
#include <timing.h>
#include <likwid_markers.h>
double striad_seq(
double * restrict a,
const double * restrict b,
const double * restrict c,
const double * restrict d,
int N,
int iter
)
{
double S, E;
S = getTimeStamp();
LIKWID_MARKER_START("BENCH");
for(int j = 0; j < iter; j++) {
for (int i=0; i<N; i++) {
a[i] = b[i] + d[i] * c[i];
}
if (a[N-1] > 2000) printf("Ai = %f\n",a[N-1]);
}
LIKWID_MARKER_STOP("BENCH");
E = getTimeStamp();
return E-S;
}

62
MemoryHierarchy/src/striad_tp.c
View File

@@ -1,62 +0,0 @@
/*
* =======================================================================================
*
* Author: Jan Eitzinger (je), jan.treibig@gmail.com
* Copyright (c) 2019 RRZE, University Erlangen-Nuremberg
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
* =======================================================================================
*/
#include <stdio.h>
#include <timing.h>
#include <allocate.h>
double striad_tp(
double * restrict a,
const double * restrict b,
const double * restrict c,
const double * restrict d,
int N,
int iter
)
{
double S, E;
#pragma omp parallel
{
double* al = (double*) allocate( ARRAY_ALIGNMENT, N * sizeof(double));
#pragma omp single
S = getTimeStamp();
for(int j = 0; j < iter; j++) {
for (int i=0; i<N; i++) {
al[i] = b[i] + d[i] * c[i];
}
if (al[N-1] > 2000) printf("Ai = %f\n",al[N-1]);
}
#pragma omp single
E = getTimeStamp();
}
return E-S;
}

57
MemoryHierarchy/src/striad_ws.c
View File

@@ -1,57 +0,0 @@
/*
* =======================================================================================
*
* Author: Jan Eitzinger (je), jan.treibig@gmail.com
* Copyright (c) 2019 RRZE, University Erlangen-Nuremberg
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
* =======================================================================================
*/
#include <stdio.h>
#include <timing.h>
double striad_ws(
double * restrict a,
const double * restrict b,
const double * restrict c,
const double * restrict d,
int N,
int iter
)
{
double S, E;
S = getTimeStamp();
#pragma omp parallel
{
for(int j = 0; j < iter; j++) {
#pragma omp for
for (int i=0; i<N; i++) {
a[i] = b[i] + d[i] * c[i];
}
if (a[N-1] > 2000) printf("Ai = %f\n",a[N-1]);
}
}
E = getTimeStamp();
return E-S;
}

35
MemoryHierarchy/src/timing.h
View File

@@ -1,35 +0,0 @@
/*
* =======================================================================================
*
* Author: Jan Eitzinger (je), jan.treibig@gmail.com
* Copyright (c) 2019 RRZE, University Erlangen-Nuremberg
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
* =======================================================================================
*/
#ifndef __TIMING_H_
#define __TIMING_H_
extern double getTimeStamp();
extern double getTimeResolution();
extern double getTimeStamp_();
#endif

130
README.md
View File

@@ -1,13 +1,8 @@
# The Bandwidth Benchmark # The Bandwidth Benchmark
This is a collection of simple streaming kernels for teaching purposes. This is a collection of simple streaming kernels.
It consists of two banchmark applications: Apart from the micro-benchmark functionality this is also a blueprint for other micro-benchmark applications.
* [MainMemory](https://github.com/RRZE-HPC/TheBandwidthBenchmark/wiki/MainMemory)
* [MemoryHierarchy](https://github.com/RRZE-HPC/TheBandwidthBenchmark/wiki/MemoryHierarchy)
Apart from the microbenchmarking functionality this is also a blueprint for other microbenchmarking applications.
It contains C modules for: It contains C modules for:
* Aligned data allocation * Aligned data allocation
@@ -15,3 +10,124 @@ It contains C modules for:
* Accurate timing * Accurate timing
Moreover the benchmark showcases a simple generic Makefile that can be used in other projects. Moreover the benchmark showcases a simple generic Makefile that can be used in other projects.
## Overview
The benchmark is heavily inspired by John McCalpin's https://www.cs.virginia.edu/stream/ benchmark.
It contains the following streaming kernels with corresponding data access pattern (Notation: S - store, L - load, WA - write allocate). All variables are vectors, s is a scalar:
* init (S1, WA): Initilize an array: `a = s`. Store only.
* sum (L1): Vector reduction: `s += a`. Load only.
* copy (L1, S1, WA): Classic memcopy: `a = b`.
* update (L1, S1): Update vector: `a = a * scalar`. Also load + store but without write allocate.
* triad (L2, S1, WA): Stream triad: `a = b + c * scalar`.
* daxpy (L2, S1): Daxpy: `a = a + b * scalar`.
* striad (L3, S1, WA): Schoenauer triad: `a = b + c * d`.
* sdaxpy (L3, S1): Schoenauer triad without write allocate: `a = a + b * c`.
As added benefit the code is a blueprint for a minimal benchmarking application with a generic makefile and modules for aligned array allocation, accurate timing and affinity settings. Those components can be used standalone in your own project.
## Build
1. Configure the toolchain and additional options in `config.mk`:
```
# Supported: GCC, CLANG, ICC
TAG ?= GCC
ENABLE_OPENMP ?= false
ENABLE_LIKWID ?= false
OPTIONS = -DSIZE=40000000ull
OPTIONS += -DNTIMES=10
OPTIONS += -DARRAY_ALIGNMENT=64
#OPTIONS += -DVERBOSE_AFFINITY
#OPTIONS += -DVERBOSE_DATASIZE
#OPTIONS += -DVERBOSE_TIMER
```
The verbosity options enable detailed output about affinity settings, allocation sizes and timer resolution.
2. Build with:
```
make
```
You can build multiple toolchains in the same directory, but notice that the Makefile is only acting on the one currently set. Intermediate build results are located in the `<TOOLCHAIN>` directory.
To output the executed commands use:
```
make Q=
```
3. Clean up with:
```
make clean
```
to clean intermediate build results.
```
make distclean
```
to clean intermediate build results and binary.
4. (Optional) Generate assembler:
```
make asm
```
The assembler files will also be located in the `<TOOLCHAIN>` directory.
## Usage
To run the benchmark call:
```
./bwBench-<TOOLCHAIN>
```
The benchmark will output the results similar to the stream benchmark. Results are validated.
For threaded execution it is recommended to control thread affinity.
We recommend to use likwid-pin for benchmarking:
```
likwid-pin -c 0-3 ./bwbench-GCC
```
Example output for threaded execution:
```
-------------------------------------------------------------
[pthread wrapper]
[pthread wrapper] MAIN -> 0
[pthread wrapper] PIN_MASK: 0->1 1->2 2->3
[pthread wrapper] SKIP MASK: 0x0
threadid 140271463495424 -> core 1 - OK
threadid 140271455102720 -> core 2 - OK
threadid 140271446710016 -> core 3 - OK
OpenMP enabled, running with 4 threads
----------------------------------------------------------------------------
Function Rate(MB/s) Rate(MFlop/s) Avg time Min time Max time
Init: 22111.53 - 0.0148 0.0145 0.0165
Sum: 46808.59 46808.59 0.0077 0.0068 0.0140
Copy: 30983.06 - 0.0207 0.0207 0.0208
Update: 43778.69 21889.34 0.0147 0.0146 0.0148
Triad: 34476.64 22984.43 0.0282 0.0278 0.0305
Daxpy: 45908.82 30605.88 0.0214 0.0209 0.0242
STriad: 37502.37 18751.18 0.0349 0.0341 0.0388
SDaxpy: 46822.63 23411.32 0.0281 0.0273 0.0325
----------------------------------------------------------------------------
Solution Validates
```
## Benchmarking skript
A perl wrapper script (bench.pl) is also provided to scan ranges of thread counts and determine the absolute highest sustained main memory bandwidth. In order to use it `likwid-pin` has to be in your path. The script has three required and one optional command line arguments:
```
$./bench.pl <executable> <thread count range> <repetitions> [<SMT setting>]
```
Example usage:
```
$./bench.pl ./bwbench-GCC 2-8 6
```
The script will always use physical cores only, where two SMT threads is the default. For different SMT thread counts use the 4th command line argument. Example for a processor without SMT:
```
$./bench.pl ./bwbench-GCC 14-24 10 1
```

49
bench.pl Executable file
View File

@@ -0,0 +1,49 @@
#!/usr/bin/env perl
# =======================================================================================
#
# Author: Jan Eitzinger (je), jan.eitzinger@fau.de
# Copyright (c) 2019 RRZE, University Erlangen-Nuremberg
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
#
# =======================================================================================
use strict;
use warnings;
use utf8;
my $CMD = $ARGV[0];
my @N = split /-/, $ARGV[1];
my $R = $ARGV[2];
my $MAX = 0; my $CORES = 0; my $BENCH = '';
my $SMT = $ARGV[3] ? $ARGV[3] : 2;
foreach my $numcores ( $N[0] ... $N[1] ) {
foreach ( 1 ... $R ) {
foreach my $ln ( split /\n/, `likwid-pin -c E:S0:$numcores:1:$SMT $CMD` ){
if ( $ln =~ /^([A-Za-z]+):[ ]+([0-9.]+) /) {
if ( $MAX < $2 ){
$MAX = $2; $CORES = $numcores; $BENCH = $1;
}
}
}
}
}
print "$BENCH was best using $CORES threads: $MAX\n";

0
MainMemory/bench.py → bench.py
View File

1
MainMemory/config.mk → config.mk
View File

@@ -1,6 +1,7 @@
# Supported: GCC, CLANG, ICC # Supported: GCC, CLANG, ICC
TAG ?= GCC TAG ?= GCC
ENABLE_OPENMP ?= false ENABLE_OPENMP ?= false
ENABLE_LIKWID ?= false
#Feature options #Feature options
OPTIONS = -DSIZE=40000000ull OPTIONS = -DSIZE=40000000ull

3
MainMemory/include_CLANG.mk → include_CLANG.mk
View File

@@ -1,4 +1,5 @@
CC = clang CC = clang
GCC = gcc
LINKER = $(CC) LINKER = $(CC)
ifeq ($(ENABLE_OPENMP),true) ifeq ($(ENABLE_OPENMP),true)

3
MainMemory/include_GCC.mk → include_GCC.mk
View File

@@ -1,4 +1,5 @@
CC = gcc CC = gcc
GCC = gcc
LINKER = $(CC) LINKER = $(CC)
ifeq ($(ENABLE_OPENMP),true) ifeq ($(ENABLE_OPENMP),true)

3
MainMemory/include_ICC.mk → include_ICC.mk
View File

@@ -1,4 +1,5 @@
CC = icc CC = icc
GCC = gcc
LINKER = $(CC) LINKER = $(CC)
ifeq ($(ENABLE_OPENMP),true) ifeq ($(ENABLE_OPENMP),true)

10
include_LIKWID.mk Normal file
View File

@@ -0,0 +1,10 @@
LIKWID_INC ?= -I/usr/local/include
LIKWID_DEFINES ?= -DLIKWID_PERFMON
LIKWID_LIB ?= -L/usr/local/lib
ifeq ($(strip $(ENABLE_LIKWID)),true)
INCLUDES += ${LIKWID_INC}
DEFINES += ${LIKWID_DEFINES}
LIBS += -llikwid
LFLAGS += ${LIKWID_LIB}
endif

5
MemoryHierarchy/src/affinity.c → src/affinity.c
View File

@@ -1,7 +1,7 @@
/* /*
* ======================================================================================= * =======================================================================================
* *
* Author: Jan Eitzinger (je), jan.treibig@gmail.com * Author: Jan Eitzinger (je), jan.eitzinger@fau.de
* Copyright (c) 2019 RRZE, University Erlangen-Nuremberg * Copyright (c) 2019 RRZE, University Erlangen-Nuremberg
* *
* Permission is hereby granted, free of charge, to any person obtaining a copy * Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -53,7 +53,6 @@ getProcessorID(cpu_set_t* cpu_set)
return processorId; return processorId;
} }
int int
affinity_getProcessorId() affinity_getProcessorId()
{ {
@@ -85,5 +84,5 @@ affinity_pinProcess(int processorId)
CPU_SET(processorId, &cpuset); CPU_SET(processorId, &cpuset);
sched_setaffinity(0, sizeof(cpu_set_t), &cpuset); sched_setaffinity(0, sizeof(cpu_set_t), &cpuset);
} }
#endif /*__linux__*/
#endif /*_OPENMP*/ #endif /*_OPENMP*/
#endif /*__linux__*/

2
MemoryHierarchy/src/allocate.c → src/allocate.c
View File

@@ -1,7 +1,7 @@
/* /*
* ======================================================================================= * =======================================================================================
* *
* Author: Jan Eitzinger (je), jan.treibig@gmail.com * Author: Jan Eitzinger (je), jan.eitzinger@fau.de
* Copyright (c) 2019 RRZE, University Erlangen-Nuremberg * Copyright (c) 2019 RRZE, University Erlangen-Nuremberg
* *
* Permission is hereby granted, free of charge, to any person obtaining a copy * Permission is hereby granted, free of charge, to any person obtaining a copy

14
MainMemory/src/copy.c → src/copy.c
View File

@@ -1,7 +1,7 @@
/* /*
* ======================================================================================= * =======================================================================================
* *
* Author: Jan Eitzinger (je), jan.treibig@gmail.com * Author: Jan Eitzinger (je), jan.eitzinger@fau.de
* Copyright (c) 2019 RRZE, University Erlangen-Nuremberg * Copyright (c) 2019 RRZE, University Erlangen-Nuremberg
* *
* Permission is hereby granted, free of charge, to any person obtaining a copy * Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -26,6 +26,7 @@
*/ */
#include <timing.h> #include <timing.h>
#include <likwid-marker.h>
double copy( double copy(
double * restrict a, double * restrict a,
@@ -36,9 +37,14 @@ double copy(
double S, E; double S, E;
S = getTimeStamp(); S = getTimeStamp();
#pragma omp parallel for #pragma omp parallel
for (int i=0; i<N; i++) { {
a[i] = b[i]; LIKWID_MARKER_START("COPY");
#pragma omp for
for (int i=0; i<N; i++) {
a[i] = b[i];
}
LIKWID_MARKER_STOP("COPY");
} }
E = getTimeStamp(); E = getTimeStamp();

14
MainMemory/src/daxpy.c → src/daxpy.c
View File

@@ -1,7 +1,7 @@
/* /*
* ======================================================================================= * =======================================================================================
* *
* Author: Jan Eitzinger (je), jan.treibig@gmail.com * Author: Jan Eitzinger (je), jan.eitzinger@fau.de
* Copyright (c) 2019 RRZE, University Erlangen-Nuremberg * Copyright (c) 2019 RRZE, University Erlangen-Nuremberg
* *
* Permission is hereby granted, free of charge, to any person obtaining a copy * Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -26,6 +26,7 @@
*/ */
#include <timing.h> #include <timing.h>
#include <likwid-marker.h>
double daxpy( double daxpy(
double * restrict a, double * restrict a,
@@ -37,9 +38,14 @@ double daxpy(
double S, E; double S, E;
S = getTimeStamp(); S = getTimeStamp();
#pragma omp parallel for #pragma omp parallel
for (int i=0; i<N; i++) { {
a[i] = a[i] + scalar * b[i]; LIKWID_MARKER_START("DAXPY");
#pragma omp for
for (int i=0; i<N; i++) {
a[i] = a[i] + scalar * b[i];
}
LIKWID_MARKER_STOP("DAXPY");
} }
E = getTimeStamp(); E = getTimeStamp();

3
MainMemory/src/includes/affinity.h → src/includes/affinity.h
View File

@@ -1,7 +1,7 @@
/* /*
* ======================================================================================= * =======================================================================================
* *
* Author: Jan Eitzinger (je), jan.treibig@gmail.com * Author: Jan Eitzinger (je), jan.eitzinger@fau.de
* Copyright (c) 2019 RRZE, University Erlangen-Nuremberg * Copyright (c) 2019 RRZE, University Erlangen-Nuremberg
* *
* Permission is hereby granted, free of charge, to any person obtaining a copy * Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -33,4 +33,3 @@ extern void affinity_pinProcess(int);
extern void affinity_pinThread(int); extern void affinity_pinThread(int);
#endif /*AFFINITY_H*/ #endif /*AFFINITY_H*/

2
MainMemory/src/includes/allocate.h → src/includes/allocate.h
View File

@@ -1,7 +1,7 @@
/* /*
* ======================================================================================= * =======================================================================================
* *
* Author: Jan Eitzinger (je), jan.treibig@gmail.com * Author: Jan Eitzinger (je), jan.eitzinger@fau.de
* Copyright (c) 2019 RRZE, University Erlangen-Nuremberg * Copyright (c) 2019 RRZE, University Erlangen-Nuremberg
* *
* Permission is hereby granted, free of charge, to any person obtaining a copy * Permission is hereby granted, free of charge, to any person obtaining a copy

16
MemoryHierarchy/src/likwid_markers.h → src/includes/likwid-marker.h
View File

@@ -1,7 +1,7 @@
/* /*
* ======================================================================================= * =======================================================================================
* *
* Author: Jan Eitzinger (je), jan.treibig@gmail.com * Author: Jan Eitzinger (je), jan.eitzinger@fau.de
* Copyright (c) 2019 RRZE, University Erlangen-Nuremberg * Copyright (c) 2019 RRZE, University Erlangen-Nuremberg
* *
* Permission is hereby granted, free of charge, to any person obtaining a copy * Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -30,7 +30,16 @@
#ifdef LIKWID_PERFMON #ifdef LIKWID_PERFMON
#include <likwid.h> #include <likwid.h>
#else #define LIKWID_MARKER_INIT likwid_markerInit()
#define LIKWID_MARKER_THREADINIT likwid_markerThreadInit()
#define LIKWID_MARKER_SWITCH likwid_markerNextGroup()
#define LIKWID_MARKER_REGISTER(regionTag) likwid_markerRegisterRegion(regionTag)
#define LIKWID_MARKER_START(regionTag) likwid_markerStartRegion(regionTag)
#define LIKWID_MARKER_STOP(regionTag) likwid_markerStopRegion(regionTag)
#define LIKWID_MARKER_CLOSE likwid_markerClose()
#define LIKWID_MARKER_RESET(regionTag) likwid_markerResetRegion(regionTag)
#define LIKWID_MARKER_GET(regionTag, nevents, events, time, count) likwid_markerGetRegion(regionTag, nevents, events, time, count)
#else /* LIKWID_PERFMON */
#define LIKWID_MARKER_INIT #define LIKWID_MARKER_INIT
#define LIKWID_MARKER_THREADINIT #define LIKWID_MARKER_THREADINIT
#define LIKWID_MARKER_SWITCH #define LIKWID_MARKER_SWITCH
@@ -39,6 +48,7 @@
#define LIKWID_MARKER_STOP(regionTag) #define LIKWID_MARKER_STOP(regionTag)
#define LIKWID_MARKER_CLOSE #define LIKWID_MARKER_CLOSE
#define LIKWID_MARKER_GET(regionTag, nevents, events, time, count) #define LIKWID_MARKER_GET(regionTag, nevents, events, time, count)
#endif #define LIKWID_MARKER_RESET(regionTag)
#endif /* LIKWID_PERFMON */
#endif /*LIKWID_MARKERS_H*/ #endif /*LIKWID_MARKERS_H*/

2
MainMemory/src/includes/timing.h → src/includes/timing.h
View File

@@ -1,7 +1,7 @@
/* /*
* ======================================================================================= * =======================================================================================
* *
* Author: Jan Eitzinger (je), jan.treibig@gmail.com * Author: Jan Eitzinger (je), jan.eitzinger@fau.de
* Copyright (c) 2019 RRZE, University Erlangen-Nuremberg * Copyright (c) 2019 RRZE, University Erlangen-Nuremberg
* *
* Permission is hereby granted, free of charge, to any person obtaining a copy * Permission is hereby granted, free of charge, to any person obtaining a copy

14
MainMemory/src/init.c → src/init.c
View File

@@ -1,7 +1,7 @@
/* /*
* ======================================================================================= * =======================================================================================
* *
* Author: Jan Eitzinger (je), jan.treibig@gmail.com * Author: Jan Eitzinger (je), jan.eitzinger@fau.de
* Copyright (c) 2019 RRZE, University Erlangen-Nuremberg * Copyright (c) 2019 RRZE, University Erlangen-Nuremberg
* *
* Permission is hereby granted, free of charge, to any person obtaining a copy * Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -26,6 +26,7 @@
*/ */
#include <timing.h> #include <timing.h>
#include <likwid-marker.h>
double init( double init(
double * restrict a, double * restrict a,
@@ -36,9 +37,14 @@ double init(
double S, E; double S, E;
S = getTimeStamp(); S = getTimeStamp();
#pragma omp parallel for #pragma omp parallel
for (int i=0; i<N; i++) { {
a[i] = scalar; LIKWID_MARKER_START("INIT");
#pragma omp for
for (int i=0; i<N; i++) {
a[i] = scalar;
}
LIKWID_MARKER_STOP("INIT");
} }
E = getTimeStamp(); E = getTimeStamp();

21
MainMemory/src/main.c → src/main.c
View File

@@ -1,7 +1,7 @@
/* /*
* ======================================================================================= * =======================================================================================
* *
* Author: Jan Eitzinger (je), jan.treibig@gmail.com * Author: Jan Eitzinger (je), jan.eitzinger@fau.de
* Copyright (c) 2019 RRZE, University Erlangen-Nuremberg * Copyright (c) 2019 RRZE, University Erlangen-Nuremberg
* *
* Permission is hereby granted, free of charge, to any person obtaining a copy * Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -38,6 +38,7 @@
#include <timing.h> #include <timing.h>
#include <allocate.h> #include <allocate.h>
#include <affinity.h> #include <affinity.h>
#include <likwid-marker.h>
#define HLINE "----------------------------------------------------------------------------\n" #define HLINE "----------------------------------------------------------------------------\n"
@@ -89,8 +90,8 @@ int main (int argc, char** argv)
double E, S; double E, S;
double avgtime[NUMBENCH], double avgtime[NUMBENCH],
maxtime[NUMBENCH], maxtime[NUMBENCH],
mintime[NUMBENCH]; mintime[NUMBENCH];
double times[NUMBENCH][NTIMES]; double times[NUMBENCH][NTIMES];
@@ -105,6 +106,19 @@ int main (int argc, char** argv)
{"SDaxpy: ", 4, 2} {"SDaxpy: ", 4, 2}
}; };
LIKWID_MARKER_INIT;
#pragma omp parallel
{
LIKWID_MARKER_REGISTER("INIT");
LIKWID_MARKER_REGISTER("SUM");
LIKWID_MARKER_REGISTER("COPY");
LIKWID_MARKER_REGISTER("UPDATE");
LIKWID_MARKER_REGISTER("TRIAD");
LIKWID_MARKER_REGISTER("DAXPY");
LIKWID_MARKER_REGISTER("STRIAD");
LIKWID_MARKER_REGISTER("SDAXPY");
}
a = (double*) allocate( ARRAY_ALIGNMENT, N * bytesPerWord ); a = (double*) allocate( ARRAY_ALIGNMENT, N * bytesPerWord );
b = (double*) allocate( ARRAY_ALIGNMENT, N * bytesPerWord ); b = (double*) allocate( ARRAY_ALIGNMENT, N * bytesPerWord );
c = (double*) allocate( ARRAY_ALIGNMENT, N * bytesPerWord ); c = (double*) allocate( ARRAY_ALIGNMENT, N * bytesPerWord );
@@ -200,6 +214,7 @@ int main (int argc, char** argv)
printf(HLINE); printf(HLINE);
check(a, b, c, d, N); check(a, b, c, d, N);
LIKWID_MARKER_CLOSE;
return EXIT_SUCCESS; return EXIT_SUCCESS;
} }

14
MainMemory/src/sdaxpy.c → src/sdaxpy.c
View File

@@ -1,7 +1,7 @@
/* /*
* ======================================================================================= * =======================================================================================
* *
* Author: Jan Eitzinger (je), jan.treibig@gmail.com * Author: Jan Eitzinger (je), jan.eitzinger@fau.de
* Copyright (c) 2019 RRZE, University Erlangen-Nuremberg * Copyright (c) 2019 RRZE, University Erlangen-Nuremberg
* *
* Permission is hereby granted, free of charge, to any person obtaining a copy * Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -26,6 +26,7 @@
*/ */
#include <timing.h> #include <timing.h>
#include <likwid-marker.h>
double sdaxpy( double sdaxpy(
double * restrict a, double * restrict a,
@@ -37,9 +38,14 @@ double sdaxpy(
double S, E; double S, E;
S = getTimeStamp(); S = getTimeStamp();
#pragma omp parallel for #pragma omp parallel
for (int i=0; i<N; i++) { {
a[i] = a[i] + b[i] * c[i]; LIKWID_MARKER_START("SDAXPY");
#pragma omp for
for (int i=0; i<N; i++) {
a[i] = a[i] + b[i] * c[i];
}
LIKWID_MARKER_STOP("SDAXPY");
} }
E = getTimeStamp(); E = getTimeStamp();

14
MainMemory/src/striad.c → src/striad.c
View File

@@ -1,7 +1,7 @@
/* /*
* ======================================================================================= * =======================================================================================
* *
* Author: Jan Eitzinger (je), jan.treibig@gmail.com * Author: Jan Eitzinger (je), jan.eitzinger@fau.de
* Copyright (c) 2019 RRZE, University Erlangen-Nuremberg * Copyright (c) 2019 RRZE, University Erlangen-Nuremberg
* *
* Permission is hereby granted, free of charge, to any person obtaining a copy * Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -26,6 +26,7 @@
*/ */
#include <timing.h> #include <timing.h>
#include <likwid-marker.h>
double striad( double striad(
double * restrict a, double * restrict a,
@@ -38,9 +39,14 @@ double striad(
double S, E; double S, E;
S = getTimeStamp(); S = getTimeStamp();
#pragma omp parallel for #pragma omp parallel
for (int i=0; i<N; i++) { {
a[i] = b[i] + d[i] * c[i]; LIKWID_MARKER_START("STRIAD");
#pragma omp for
for (int i=0; i<N; i++) {
a[i] = b[i] + d[i] * c[i];
}
LIKWID_MARKER_STOP("STRIAD");
} }
E = getTimeStamp(); E = getTimeStamp();

14
MainMemory/src/sum.c → src/sum.c
View File

@@ -1,7 +1,7 @@
/* /*
* ======================================================================================= * =======================================================================================
* *
* Author: Jan Eitzinger (je), jan.treibig@gmail.com * Author: Jan Eitzinger (je), jan.eitzinger@fau.de
* Copyright (c) 2019 RRZE, University Erlangen-Nuremberg * Copyright (c) 2019 RRZE, University Erlangen-Nuremberg
* *
* Permission is hereby granted, free of charge, to any person obtaining a copy * Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -26,6 +26,7 @@
*/ */
#include <timing.h> #include <timing.h>
#include <likwid-marker.h>
double sum( double sum(
double * restrict a, double * restrict a,
@@ -36,9 +37,14 @@ double sum(
double sum = 0.0; double sum = 0.0;
S = getTimeStamp(); S = getTimeStamp();
#pragma omp parallel for reduction(+:sum) #pragma omp parallel
for (int i=0; i<N; i++) { {
sum += a[i]; LIKWID_MARKER_START("SUM");
#pragma omp for reduction(+:sum)
for (int i=0; i<N; i++) {
sum += a[i];
}
LIKWID_MARKER_STOP("SUM");
} }
E = getTimeStamp(); E = getTimeStamp();

3
MemoryHierarchy/src/timing.c → src/timing.c
View File

@@ -1,7 +1,7 @@
/* /*
* ======================================================================================= * =======================================================================================
* *
* Author: Jan Eitzinger (je), jan.treibig@gmail.com * Author: Jan Eitzinger (je), jan.eitzinger@fau.de
* Copyright (c) 2019 RRZE, University Erlangen-Nuremberg * Copyright (c) 2019 RRZE, University Erlangen-Nuremberg
* *
* Permission is hereby granted, free of charge, to any person obtaining a copy * Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -46,4 +46,3 @@ double getTimeStamp_()
{ {
return getTimeStamp(); return getTimeStamp();
} }

14
MainMemory/src/triad.c → src/triad.c
View File

@@ -1,7 +1,7 @@
/* /*
* ======================================================================================= * =======================================================================================
* *
* Author: Jan Eitzinger (je), jan.treibig@gmail.com * Author: Jan Eitzinger (je), jan.eitzinger@fau.de
* Copyright (c) 2019 RRZE, University Erlangen-Nuremberg * Copyright (c) 2019 RRZE, University Erlangen-Nuremberg
* *
* Permission is hereby granted, free of charge, to any person obtaining a copy * Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -26,6 +26,7 @@
*/ */
#include <timing.h> #include <timing.h>
#include <likwid-marker.h>
double triad( double triad(
double * restrict a, double * restrict a,
@@ -38,9 +39,14 @@ double triad(
double S, E; double S, E;
S = getTimeStamp(); S = getTimeStamp();
#pragma omp parallel for #pragma omp parallel
for (int i=0; i<N; i++) { {
a[i] = b[i] + scalar * c[i]; LIKWID_MARKER_START("TRIAD");
#pragma omp for
for (int i=0; i<N; i++) {
a[i] = b[i] + scalar * c[i];
}
LIKWID_MARKER_STOP("TRIAD");
} }
E = getTimeStamp(); E = getTimeStamp();

14
MainMemory/src/update.c → src/update.c
View File

@@ -1,7 +1,7 @@
/* /*
* ======================================================================================= * =======================================================================================
* *
* Author: Jan Eitzinger (je), jan.treibig@gmail.com * Author: Jan Eitzinger (je), jan.eitzinger@fau.de
* Copyright (c) 2019 RRZE, University Erlangen-Nuremberg * Copyright (c) 2019 RRZE, University Erlangen-Nuremberg
* *
* Permission is hereby granted, free of charge, to any person obtaining a copy * Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -26,6 +26,7 @@
*/ */
#include <timing.h> #include <timing.h>
#include <likwid-marker.h>
double update( double update(
double * restrict a, double * restrict a,
@@ -36,9 +37,14 @@ double update(
double S, E; double S, E;
S = getTimeStamp(); S = getTimeStamp();
#pragma omp parallel for #pragma omp parallel
for (int i=0; i<N; i++) { {
a[i] = a[i] * scalar; LIKWID_MARKER_START("UPDATE");
#pragma omp for
for (int i=0; i<N; i++) {
a[i] = a[i] * scalar;
}
LIKWID_MARKER_STOP("UPDATE");
} }
E = getTimeStamp(); E = getTimeStamp();