diff --git a/container/stream/openeuler-bisheng2-hmpi2-stream-1.8.def b/container/stream/openeuler-bisheng2-hmpi2-stream-1.8.def new file mode 100644 index 0000000000000000000000000000000000000000..24cafbbaa15eff400570b11e2a3acfee93e91322 --- /dev/null +++ b/container/stream/openeuler-bisheng2-hmpi2-stream-1.8.def @@ -0,0 +1,35 @@ +BootStrap: docker +From: openeuler/openeuler + +%environment + source /etc/profile || true + source /etc/profile.d/modules.sh + cd /hpcrunner + source init.sh + source env.sh + +%post + # Install the necessary development environment + yum install -y environment-modules git wget unzip make flex tar + source /etc/profile || true + git config --global http.sslVerify false + git clone https://gitee.com/openeuler/hpcrunner + cd hpcrunner + source ./init.sh + ./jarvis -i + # Switch config + ./jarvis -use templates/stream/1.8/data.stream.arm.cpu.config + # download dependency + ./jarvis -d + # install dependency + ./jarvis -dp + # build stream + ./jarvis -b + # run test + ./jarvis -r + # clean cache and downloads directory + yum clean all + rm -rf downloads + +%labels + Author shaoyuteng \ No newline at end of file diff --git a/container/stream/openeuler-gcc-10.3.0-oneapi1-stream-1.8.def b/container/stream/openeuler-gcc-10.3.0-oneapi1-stream-1.8.def new file mode 100644 index 0000000000000000000000000000000000000000..4043de60f5c72c51a520557de3549ca51bcd2984 --- /dev/null +++ b/container/stream/openeuler-gcc-10.3.0-oneapi1-stream-1.8.def @@ -0,0 +1,35 @@ +BootStrap: docker +From: openeuler/openeuler + +%environment + source /etc/profile || true + source /etc/profile.d/modules.sh + cd /hpcrunner + source env.sh + +%post + # Install the necessary development environment + yum install -y environment-modules git flex wget vim tar unzip coreutils + # Install base gcc + yum install -y gcc gcc-c++ gcc-gfortran glibc-devel make libgfortran + source /etc/profile || true + git config --global http.sslVerify false + git clone https://gitee.com/openeuler/hpcrunner.git + cd hpcrunner + source ./init.sh + ./jarvis -i + # Switch config + ./jarvis -use templates/stream/1.8/data.stream.x86.cpu.config + # downloads stream + ./jarvis -d + # install dependency + ./jarvis -dp + # build stream + ./jarvis -b + # run stream + ./jarvis -r + # clean downloads directory + rm -rf downloads + +%labels + Author shaoyuteng \ No newline at end of file diff --git "a/doc/stream/\343\200\212\345\237\272\344\272\216openEuler\347\232\204stream\350\275\257\344\273\266\346\265\213\350\257\225\346\212\245\345\221\212\343\200\213.md" "b/doc/stream/\343\200\212\345\237\272\344\272\216openEuler\347\232\204stream\350\275\257\344\273\266\346\265\213\350\257\225\346\212\245\345\221\212\343\200\213.md" new file mode 100644 index 0000000000000000000000000000000000000000..b406ff2e9dc8c19fe060daa224f9235aa3e5dd2d --- /dev/null +++ "b/doc/stream/\343\200\212\345\237\272\344\272\216openEuler\347\232\204stream\350\275\257\344\273\266\346\265\213\350\257\225\346\212\245\345\221\212\343\200\213.md" @@ -0,0 +1,1064 @@ +# 《基于openEuler的imb软件测试报告》 + +## 1.规范性自检 + +使用对项目Clang-Format对文件进行格式化 + +Clang-Format是一个广泛使用的C代码格式化器。我们在使用编辑器的缩进（TAB）功能时，由于不同编辑器的差别，有的插入的是制表符，有的是2个空格，有的是4个空格。这样如果别人用另一个编辑器来阅读程序时，可能会由于缩进的不同，导致阅读效果一团糟。为了解决这个问题，使用Clang-Format，它可以自动重新缩进，并手动指定空格的数量，自动格式化源文件。它是可以通过命令行使用，也可以作为插件，在其他IDE中使用。 + +文件格式化配置参考文件`.clang-format`，文件内容如下 + +```clang-format +--- +Language: Cpp +# BasedOnStyle: LLVM +AccessModifierOffset: -2 +AlignAfterOpenBracket: Align +AlignConsecutiveMacros: false +AlignConsecutiveAssignments: false +AlignConsecutiveDeclarations: false +AlignEscapedNewlines: Right +AlignOperands: true +AlignTrailingComments: true +AllowAllArgumentsOnNextLine: true +AllowAllConstructorInitializersOnNextLine: true +AllowAllParametersOfDeclarationOnNextLine: true +AllowShortBlocksOnASingleLine: Never +AllowShortCaseLabelsOnASingleLine: false +AllowShortFunctionsOnASingleLine: All +AllowShortLambdasOnASingleLine: All +AllowShortIfStatementsOnASingleLine: Never +AllowShortLoopsOnASingleLine: false +AlwaysBreakAfterDefinitionReturnType: None +AlwaysBreakAfterReturnType: None +AlwaysBreakBeforeMultilineStrings: false +AlwaysBreakTemplateDeclarations: MultiLine +BinPackArguments: true +BinPackParameters: true +BraceWrapping: + AfterCaseLabel: false + AfterClass: false + AfterControlStatement: false + AfterEnum: false + AfterFunction: false + AfterNamespace: false + AfterObjCDeclaration: false + AfterStruct: false + AfterUnion: false + AfterExternBlock: false + BeforeCatch: false + BeforeElse: false + IndentBraces: false + SplitEmptyFunction: true + SplitEmptyRecord: true + SplitEmptyNamespace: true +BreakBeforeBinaryOperators: None +BreakBeforeBraces: Attach +BreakBeforeInheritanceComma: false +BreakInheritanceList: BeforeColon +BreakBeforeTernaryOperators: true +BreakConstructorInitializersBeforeComma: false +BreakConstructorInitializers: BeforeColon +BreakAfterJavaFieldAnnotations: false +BreakStringLiterals: true +ColumnLimit: 80 +CommentPragmas: '^ IWYU pragma:' +CompactNamespaces: false +ConstructorInitializerAllOnOneLineOrOnePerLine: false +ConstructorInitializerIndentWidth: 4 +ContinuationIndentWidth: 4 +Cpp11BracedListStyle: true +DeriveLineEnding: true +DerivePointerAlignment: false +DisableFormat: false +ExperimentalAutoDetectBinPacking: false +FixNamespaceComments: true +ForEachMacros: + - foreach + - Q_FOREACH + - BOOST_FOREACH +IncludeBlocks: Preserve +IncludeCategories: + - Regex: '^"(llvm|llvm-c|clang|clang-c)/' + Priority: 2 + SortPriority: 0 + - Regex: '^(<|"(gtest|gmock|isl|json)/)' + Priority: 3 + SortPriority: 0 + - Regex: '.*' + Priority: 1 + SortPriority: 0 +IncludeIsMainRegex: '(Test)?$' +IncludeIsMainSourceRegex: '' +IndentCaseLabels: false +IndentGotoLabels: true +IndentPPDirectives: None +IndentWidth: 2 +IndentWrappedFunctionNames: false +JavaScriptQuotes: Leave +JavaScriptWrapImports: true +KeepEmptyLinesAtTheStartOfBlocks: true +MacroBlockBegin: '' +MacroBlockEnd: '' +MaxEmptyLinesToKeep: 1 +NamespaceIndentation: None +ObjCBinPackProtocolList: Auto +ObjCBlockIndentWidth: 2 +ObjCSpaceAfterProperty: false +ObjCSpaceBeforeProtocolList: true +PenaltyBreakAssignment: 2 +PenaltyBreakBeforeFirstCallParameter: 19 +PenaltyBreakComment: 300 +PenaltyBreakFirstLessLess: 120 +PenaltyBreakString: 1000 +PenaltyBreakTemplateDeclaration: 10 +PenaltyExcessCharacter: 1000000 +PenaltyReturnTypeOnItsOwnLine: 60 +PointerAlignment: Right +ReflowComments: true +SortIncludes: true +SortUsingDeclarations: true +SpaceAfterCStyleCast: false +SpaceAfterLogicalNot: false +SpaceAfterTemplateKeyword: true +SpaceBeforeAssignmentOperators: true +SpaceBeforeCpp11BracedList: false +SpaceBeforeCtorInitializerColon: true +SpaceBeforeInheritanceColon: true +SpaceBeforeParens: ControlStatements +SpaceBeforeRangeBasedForLoopColon: true +SpaceInEmptyBlock: false +SpaceInEmptyParentheses: false +SpacesBeforeTrailingComments: 1 +SpacesInAngles: false +SpacesInConditionalStatement: false +SpacesInContainerLiterals: true +SpacesInCStyleCastParentheses: false +SpacesInParentheses: false +SpacesInSquareBrackets: false +SpaceBeforeSquareBrackets: false +Standard: Latest +StatementMacros: + - Q_UNUSED + - QT_REQUIRE_VERSION +TabWidth: 8 +UseCRLF: false +UseTab: Never +... +``` + +### 1.1.选择统计文件类型 + +统计项目文件类型及其文件数量 + +使用python编写脚本文件 + +```python +# -*- coding: utf-8 -*- + +import os + +print (os.getcwd()) + +def getAllFiles(targetDir): + files = [] + listFiles = os.listdir(targetDir) + for i in range(0, len(listFiles)): + path = os.path.join(targetDir, listFiles[i]) + if os.path.isdir(path): + files.extend(getAllFiles(path)) + elif os.path.isfile(path): + files.append(path) + return files + +all_files=getAllFiles(os.curdir) +type_dict=dict() + +for each_file in all_files: + if os.path.isdir(each_file): + type_dict.setdefault("文件夹",0) + type_dict["文件夹"]+=1 + else: + ext=os.path.splitext(each_file)[1] + type_dict.setdefault(ext,0) + type_dict[ext]+=1 + +for each_type in type_dict.keys(): + print ("当前文件夹下共有[%s]的文件%d个" %(each_type,type_dict[each_type])) +``` + +在imb项目根目录下运行,运行结果如下 + +```bash +[root@192 stream-1.8]# python ../count.py +/root/stream-1.8 +当前文件夹下共有[]的文件3个 +当前文件夹下共有[.c]的文件2个 +当前文件夹下共有[.f]的文件1个 +当前文件夹下共有[.o]的文件2个 + +### 1.3.统计不符合要求的总行数 + +对文件后缀名为`c`的所有文件进行格式，后缀名为`f`的文件的代码是由Fortran77编写，现网支持的fortran格式化工具fprettify只支持f90以及更高的版本，所以无法对其进行格式。 +通过git与clang-format结合的方式进行统计 + +```bash +[root@host- src]# [root@192 stream]# find . -regex '.*\.\(c\|h\)' | xargs clang-format -style=LLVM -i +[root@host- src]# git commit -m "format" +[master aff8b23] format + 2 files changed, 873 insertions(+), 858 deletions(-) + rewrite stream/mysecond.c (68%) + rewrite stream/stream_mpi.c (63%) +``` + +### 1.4.统计结果 + +综上信息，项目中代码规范性自检检查结果为 + +通过率 : 40.13% 1-858/1433*100% + +不通过率 : 59.87% 858/1433*100% + +## 2.功能性测试 + +### 2.1.所选测试案例 + +stream提供了运行的不同二进制文件，本次选取stream_mpi_c对MPI以及程序的运行情况进行检测。 + +在项目根目录下执行命令来运行Benchmark + +```bash +export OMP_NUM_THREADS=4; +./stream_mpi_c +``` + +### 2.2.运行结果 + +```bash +[root@host-10-208-220-226 Stream-1.8]# ./stream_mpi_c +------------------------------------------------------------- +STREAM version $Revision: 1.8 $ +------------------------------------------------------------- +This system uses 8 bytes per array element. +------------------------------------------------------------- +Total Aggregate Array size = 34603008 (elements) +Total Aggregate Memory per array = 264.0 MiB (= 0.3 GiB). +Total Aggregate memory required = 792.0 MiB (= 0.8 GiB). +Data is distributed across 1 MPI ranks + Array size per MPI rank = 34603008 (elements) + Memory per array per MPI rank = 264.0 MiB (= 0.3 GiB). + Total memory per MPI rank = 792.0 MiB (= 0.8 GiB). +------------------------------------------------------------- +Each kernel will be executed 20 times. + The *best* time for each kernel (excluding the first iteration) + will be used to compute the reported bandwidth. +The SCALAR value used for this run is 0.420000 +------------------------------------------------------------- +Your timer granularity/precision appears to be 1 microseconds. +Each test below will take on the order of 35916 microseconds. + (= 35916 timer ticks) +Increase the size of the arrays if this shows that +you are not getting at least 20 timer ticks per test. +------------------------------------------------------------- +WARNING -- The above is only a rough guideline. +For best results, please be sure you know the +precision of your system timer. +------------------------------------------------------------- +VERBOSE: total setup time for rank 0 = 0.095054 seconds +------------------------------------------------------------- +Function Best Rate MB/s Avg time Min time Max time +Copy: 15488.3 0.037941 0.035746 0.042000 +Scale: 15173.8 0.037793 0.036487 0.041473 +Add: 12718.6 0.065584 0.065296 0.066783 +Triad: 12637.4 0.066013 0.065715 0.067098 +------------------------------------------------------------- +VERBOSE: rank 0, AvgErrors 1.332268e-15 4.440892e-16 1.776357e-15 +Solution Validates: avg error less than 1.000000e-13 on all three arrays +Results Validation Verbose Results: + Expected a(1), b(1), c(1): 2.769001 1.144215 3.868538 + Observed a(1), b(1), c(1): 2.769001 1.144215 3.868538 + Rel Errors on a, b, c: 4.811366e-16 3.881168e-16 4.591805e-16 +------------------------------------------------------------- +VERBOSE: total shutdown time for rank 0 = 0.281207 seconds +``` + +测试结果 + +运行正常，说明各类型函数和功能都响应正常。测试通过。 + +## 3.性能测试 + +### 3.1.测试平台信息对比 + +| | arm信息 | x86信息 | +| -------- | -------------------------------- | --------------------- | +| 操作系统 | openEuler 22.03 (LTS) | openEuler 22.03 (LTS) | +| 内核版本 | 4.19.90-2012.4.0.0053.oe1.aarch64 | 4.19.90-2109.1.0.0108.oe1.x86_64 | + +### 3.2.测试软件环境信息对比 + +| | arm信息 | x86信息 | +| --- | ------------- | --------- | +| gcc | bisheng 2.1.0 | gcc 10.3.0 | +| mpi | hmpi 1.2.0 | oneapi 2021.1.0 | +| stream | 1.8 | 1.8 | + +### 3.3.测试硬件性能信息对比 + +| | arm信息 | x86信息 | +| ------ | ----------- | -------- | +| cpu | Kunpeng 920 | | +| 核心数 | 16 | 4 | +| 内存 | 32 GB | 8 GB | +| 磁盘io | 1.3 GB/s | 400 MB/s | +| 虚拟化 | KVM | KVM | + +### 3.4.测试选择的案例 + +stream进行内存带宽测试 + +### 3.6.ARM运行结果 + +#### stream_mpi_c + +```shell +------------------------------------------------------------- +STREAM version $Revision: 1.8 $ +------------------------------------------------------------- +This system uses 8 bytes per array element. +------------------------------------------------------------- +/*-----------------------------------------------------------------------*/ +/* License: */ +/* 1. You are free to use this program and/or to redistribute */ +/* this program. */ +/* 2. You are free to modify this program for your own use, */ +/* including commercial use, subject to the publication */ +/* restrictions in item 3. */ +/* 3. You are free to publish results obtained from running this */ +/* program, or from works that you derive from this program, */ +/* with the following limitations: */ +/* 3a. In order to be referred to as "STREAM benchmark results", */ +/* published results must be in conformance to the STREAM */ +/* Run Rules, (briefly reviewed below) published at */ +/* http://www.cs.virginia.edu/stream/ref.html */ +/* and incorporated herein by reference. */ +/* As the copyright holder, John McCalpin retains the */ +/* right to determine conformity with the Run Rules. */ +/* 3b. Results based on modified source code or on runs not in */ +/* accordance with the STREAM Run Rules must be clearly */ +/* labelled whenever they are published. Examples of */ +/* proper labelling include: */ +/* "tuned STREAM benchmark results" */ +/* "based on a variant of the STREAM benchmark code" */ +/* Other comparable, clear, and reasonable labelling is */ +/* acceptable. */ +/* 3c. Submission of results to the STREAM benchmark web site */ +/* is encouraged, but not required. */ +/* 4. Use of this program or creation of derived works based on this */ +/* program constitutes acceptance of these licensing restrictions. */ +/* 5. Absolutely no warranty is expressed or implied. */ +/*-----------------------------------------------------------------------*/ + +# define _XOPEN_SOURCE 600 + +# include +# include +# include +# include +# include +# include +# include +# include +# include "mpi.h" + +/*----------------------------------------------------------------------- + * INSTRUCTIONS: + * + * 1) STREAM requires different amounts of memory to run on different + * systems, depending on both the system cache size(s) and the + * granularity of the system timer. + * You should adjust the value of 'STREAM_ARRAY_SIZE' (below) + * to meet *both* of the following criteria: + * (a) Each array must be at least 4 times the size of the + * available cache memory. I don't worry about the difference + * between 10^6 and 2^20, so in practice the minimum array size + * is about 3.8 times the cache size. + * Example 1: One Xeon E3 with 8 MB L3 cache + * STREAM_ARRAY_SIZE should be >= 4 million, giving + * an array size of 30.5 MB and a total memory requirement + * of 91.5 MB. + * Example 2: Two Xeon E5's with 20 MB L3 cache each (using OpenMP) + * STREAM_ARRAY_SIZE should be >= 20 million, giving + * an array size of 153 MB and a total memory requirement + * of 458 MB. + * (b) The size should be large enough so that the 'timing calibration' + * output by the program is at least 20 clock-ticks. + * Example: most versions of Windows have a 10 millisecond timer + * granularity. 20 "ticks" at 10 ms/tic is 200 milliseconds. + * If the chip is capable of 10 GB/s, it moves 2 GB in 200 msec. + * This means the each array must be at least 1 GB, or 128M elements. + * + * Version 5.10 increases the default array size from 2 million + * elements to 10 million elements in response to the increasing + * size of L3 caches. The new default size is large enough for caches + * up to 20 MB. + * Version 5.10 changes the loop index variables from "register int" + * to "ssize_t", which allows array indices >2^32 (4 billion) + * on properly configured 64-bit systems. Additional compiler options + * (such as "-mcmodel=medium") may be required for large memory runs. + * + * Array size can be set at compile time without modifying the source + * code for the (many) compilers that support preprocessor definitions + * on the compile line. E.g., + * gcc -O -DSTREAM_ARRAY_SIZE=100000000 stream.c -o stream.100M + * will override the default size of 10M with a new size of 100M elements + * per array. + */ + +// ----------------------- !!! NOTE CHANGE IN DEFINITION !!! ------------------ +// For the MPI version of STREAM, the three arrays with this many elements +// each will be *distributed* across the MPI ranks. +// +// Be careful when computing the array size needed for a particular target +// system to meet the minimum size requirement to ensure overflowing the caches. +// +// Example: +// Assume 4 nodes with two Intel Xeon E5-2680 processors (20 MiB L3) each. +// The *total* L3 cache size is 4*2*20 = 160 MiB, so each array must be +// at least 640 MiB, or at least 80 million 8 Byte elements. +// Note that it does not matter whether you use one MPI rank per node or +// 16 MPI ranks per node -- only the total array size and the total +// cache size matter. +// +#ifndef STREAM_ARRAY_SIZE +# define STREAM_ARRAY_SIZE 10000000 +#endif + +/* 2) STREAM runs each kernel "NTIMES" times and reports the *best* result + * for any iteration after the first, therefore the minimum value + * for NTIMES is 2. + * There are no rules on maximum allowable values for NTIMES, but + * values larger than the default are unlikely to noticeably + * increase the reported performance. + * NTIMES can also be set on the compile line without changing the source + * code using, for example, "-DNTIMES=7". + */ +#ifdef NTIMES +#if NTIMES<=1 +extern void checkSTREAMresults(STREAM_TYPE *AvgErrByRank, int numranks); +extern void computeSTREAMerrors(STREAM_TYPE *aAvgErr, STREAM_TYPE *bAvgErr, STREAM_TYPE *cAvgErr); +#ifdef TUNED +extern void tuned_STREAM_Copy(); +extern void tuned_STREAM_Scale(STREAM_TYPE scalar); +extern void tuned_STREAM_Add(); +extern void tuned_STREAM_Triad(STREAM_TYPE scalar); +#endif +#ifdef _OPENMP +extern int omp_get_num_threads(); +#endif +int +main() + { + int quantum, checktick(); + int BytesPerWord; + int i,k; + ssize_t j; + STREAM_TYPE scalar; + double t, times[4][NTIMES]; + double *TimesByRank; + double t0,t1,tmin; + int rc, numranks, myrank; + STREAM_TYPE AvgError[3] = {0.0,0.0,0.0}; + STREAM_TYPE *AvgErrByRank; + + /* --- SETUP --- call MPI_Init() before anything else! --- */ + + rc = MPI_Init(NULL, NULL); + t0 = MPI_Wtime(); + if (rc != MPI_SUCCESS) { + printf("ERROR: MPI Initialization failed with return code %d\n",rc); + exit(1); + } + // if either of these fail there is something really screwed up! + MPI_Comm_size(MPI_COMM_WORLD, &numranks); + MPI_Comm_rank(MPI_COMM_WORLD, &myrank); + + /* --- NEW FEATURE --- distribute requested storage across MPI ranks --- */ + array_elements = STREAM_ARRAY_SIZE / numranks; // don't worry about rounding vs truncation + array_alignment = 64; // Can be modified -- provides partial support for adjusting relative alignment + + // Dynamically allocate the three arrays using "posix_memalign()" + // NOTE that the OFFSET parameter is not used in this version of the code! + array_bytes = array_elements * sizeof(STREAM_TYPE); + k = posix_memalign((void **)&a, array_alignment, array_bytes); + if (k != 0) { + printf("Rank %d: Allocation of array a failed, return code is %d\n",myrank,k); + MPI_Abort(MPI_COMM_WORLD, 2); + exit(1); + } + k = posix_memalign((void **)&b, array_alignment, array_bytes); + if (k != 0) { + printf("Rank %d: Allocation of array b failed, return code is %d\n",myrank,k); + MPI_Abort(MPI_COMM_WORLD, 2); + exit(1); + } + k = posix_memalign((void **)&c, array_alignment, array_bytes); + if (k != 0) { + printf("Rank %d: Allocation of array c failed, return code is %d\n",myrank,k); + MPI_Abort(MPI_COMM_WORLD, 2); + exit(1); + } + + // Initial informational printouts -- rank 0 handles all the output + if (myrank == 0) { + printf(HLINE); + printf("STREAM version $Revision: 1.8 $\n"); + printf(HLINE); + BytesPerWord = sizeof(STREAM_TYPE); + printf("This system uses %d bytes per array element.\n", + BytesPerWord); + + printf(HLINE); +#ifdef N + printf("***** WARNING: ******\n"); + printf(" It appears that you set the preprocessor variable N when compiling this code.\n"); + printf(" This version of the code uses the preprocesor variable STREAM_ARRAY_SIZE to control the array size\n"); + printf(" Reverting to default value of STREAM_ARRAY_SIZE=%llu\n",(unsigned long long) STREAM_ARRAY_SIZE); + printf("***** WARNING: ******\n"); +#endif + if (OFFSET != 0) { + printf("***** WARNING: ******\n"); + printf(" This version ignores the OFFSET parameter.\n"); + printf("***** WARNING: ******\n"); + } + + printf("Total Aggregate Array size = %llu (elements)\n" , (unsigned long long) STREAM_ARRAY_SIZE); + printf("Total Aggregate Memory per array = %.1f MiB (= %.1f GiB).\n", + BytesPerWord * ( (double) STREAM_ARRAY_SIZE / 1024.0/1024.0), + BytesPerWord * ( (double) STREAM_ARRAY_SIZE / 1024.0/1024.0/1024.0)); + printf("Total Aggregate memory required = %.1f MiB (= %.1f GiB).\n", + (3.0 * BytesPerWord) * ( (double) STREAM_ARRAY_SIZE / 1024.0/1024.), + (3.0 * BytesPerWord) * ( (double) STREAM_ARRAY_SIZE / 1024.0/1024./1024.)); + printf("Data is distributed across %d MPI ranks\n",numranks); + printf(" Array size per MPI rank = %llu (elements)\n" , (unsigned long long) array_elements); + printf(" Memory per array per MPI rank = %.1f MiB (= %.1f GiB).\n", + BytesPerWord * ( (double) array_elements / 1024.0/1024.0), + BytesPerWord * ( (double) array_elements / 1024.0/1024.0/1024.0)); + printf(" Total memory per MPI rank = %.1f MiB (= %.1f GiB).\n", + (3.0 * BytesPerWord) * ( (double) array_elements / 1024.0/1024.), + (3.0 * BytesPerWord) * ( (double) array_elements / 1024.0/1024./1024.)); + + printf(HLINE); + printf("Each kernel will be executed %d times.\n", NTIMES); + printf(" The *best* time for each kernel (excluding the first iteration)\n"); + printf(" will be used to compute the reported bandwidth.\n"); + printf("The SCALAR value used for this run is %f\n",SCALAR); + +#ifdef _OPENMP + printf(HLINE); +#pragma omp parallel + { +#pragma omp master + { + k = omp_get_num_threads(); + printf ("Number of Threads requested for each MPI rank = %i\n",k); + } + } +#endif + +#ifdef _OPENMP + k = 0; +#pragma omp parallel +#pragma omp atomic + k++; + printf ("Number of Threads counted for rank 0 = %i\n",k); +#endif + + } + + /* --- SETUP --- initialize arrays and estimate precision of timer --- */ + +#pragma omp parallel for + for (j=0; j epsilon) { + err++; + printf ("Failed Validation on array a[], AvgRelAbsErr > epsilon (%e)\n",epsilon); + printf (" Expected Value: %e, AvgAbsErr: %e, AvgRelAbsErr: %e\n",aj,aAvgErr,abs(aAvgErr)/aj); + ierr = 0; + for (j=0; j epsilon) { + ierr++; +#ifdef VERBOSE + if (ierr < 10) { + printf(" array a: index: %ld, expected: %e, observed: %e, relative error: %e\n", + j,aj,a[j],abs((aj-a[j])/aAvgErr)); + } +#endif + } + } + printf(" For array a[], %d errors were found.\n",ierr); + } + if (abs(bAvgErr/bj) > epsilon) { + err++; + printf ("Failed Validation on array b[], AvgRelAbsErr > epsilon (%e)\n",epsilon); + printf (" Expected Value: %e, AvgAbsErr: %e, AvgRelAbsErr: %e\n",bj,bAvgErr,abs(bAvgErr)/bj); + printf (" AvgRelAbsErr > Epsilon (%e)\n",epsilon); + ierr = 0; + for (j=0; j epsilon) { + ierr++; +#ifdef VERBOSE + if (ierr < 10) { + printf(" array b: index: %ld, expected: %e, observed: %e, relative error: %e\n", + j,bj,b[j],abs((bj-b[j])/bAvgErr)); + } +#endif + } + } + printf(" For array b[], %d errors were found.\n",ierr); + } + if (abs(cAvgErr/cj) > epsilon) { + err++; + printf ("Failed Validation on array c[], AvgRelAbsErr > epsilon (%e)\n",epsilon); + printf (" Expected Value: %e, AvgAbsErr: %e, AvgRelAbsErr: %e\n",cj,cAvgErr,abs(cAvgErr)/cj); + printf (" AvgRelAbsErr > Epsilon (%e)\n",epsilon); + ierr = 0; + for (j=0; j epsilon) { + ierr++; +#ifdef VERBOSE + if (ierr < 10) { + printf(" array c: index: %ld, expected: %e, observed: %e, relative error: %e\n", + j,cj,c[j],abs((cj-c[j])/cAvgErr)); + } +#endif + } + } + printf(" For array c[], %d errors were found.\n",ierr); + } + if (err == 0) { + printf ("Solution Validates: avg error less than %e on all three arrays\n",epsilon); + } +#ifdef VERBOSE + printf ("Results Validation Verbose Results: \n"); + printf (" Expected a(1), b(1), c(1): %f %f %f \n",aj,bj,cj); + printf (" Observed a(1), b(1), c(1): %f %f %f \n",a[1],b[1],c[1]); + printf (" Rel Errors on a, b, c: %e %e %e \n",abs(aAvgErr/aj),abs(bAvgErr/bj),abs(cAvgErr/cj)); +#endif +} + +#ifdef TUNED +/* stubs for "tuned" versions of the kernels */ +void tuned_STREAM_Copy() +{ + ssize_t j; +#pragma omp parallel for + for (j=0; j + +- GITHUB托管地址： + +## 2.环境要求 + +- 操作系统：OpenEuler arm/x86 (本文档以 x86 架构为例) + +## 3.配置编译环境 + +配置环境指导，手动进行配置依赖环境。 + +### 3.1.环境总览 + +- 编译器： gcc + +- MPI：hmpi + + 具体版本和下载地址如下 + +| 名称 | 版本 | 软件下载地址 | +| -------- | ------ | ---------------------------------------------------------------------------------------------- | +| oneapi | 2021.1.0 | +| gcc | 10.3.0 | | + +### 3.2.创建文件夹 + +```bash +mkdir -p $HOME/build +mkdir -p $HOME/install +mkdir -p $HOME/tmp +``` + +### 3.3.安装预设 + +设置环境变量，方便修改自定义安装目录 + +- 编译目录为 $HOME/build , 根据实际情况进行修改 +- 软件安装目录为 $HOME/install , 根据实际情况进行修改 +- 下载目录为 $HOME/tmp , 根据实际情况进行修改 + +```bash +#为了方便自定义软件安装目录 +#环境变量DEP_INSTALL_DIR将在后文中作为软件安装目录的根目录 +export DEP_INSTALL_DIR=$HOME/install +#环境变量DEP_BUILD_DIR将在后文中作为编译的根目录 +export DEP_BUILD_DIR=$HOME/build +#环境变量DEP_DOWNLOAD_DIR将在后文中作为下载文件的保存目录 +export DEP_DOWNLOAD_DIR=$HOME/tmp + +#注： 以上变量只在一次会话中有效。如果中途断开ssh会话，则在后续的安装过程中不会生效，需要重新运行 +``` + +### 3.4.安装环境依赖和gcc编译器 + +```bash +#环境依赖 +yum -y install wget tar libatomic + +#安装bisheng编译器 +wget -P $DEP_DOWNLOAD_DIR https://ftp.gnu.org/gnu/gcc/gcc-10.3.0/gcc-10.3.0.tar.gz +tar -xf $DEP_DOWNLOAD_DIR/gcc-10.3.0.tar.gz -C $DEP_INSTALL_DIR +sed -i "35s/ftp/http/g" ./contrib/download_prerequisites +./contrib/download_prerequisites +./configure --disable-multilib --enable-languages="c,c++,fortran" --prefix=$1 --disable-static --enable-shared +make -j && make install +#设置环境变量 +echo "export PATH=$DEP_INSTALL_DIR/gcc-10.3.0/bin:$PATH" >> ~/.bashrc && source ~/.bashrc +export CC=`which clang` +export CXX=`which clang++` +``` + +## 3.5.下载并编译hmpi + +```bash +yum -y install libstdc++ libstdc++-devel +yum -y install unzip make autoconf automake git libtool +#下载解压源码文件 +wget https://github.com/kunpengcompute/hucx/archive/refs/tags/v1.1.1-huawei.zip -O $DEP_DOWNLOAD_DIR/hucx-1.1.1-huawei.zip +wget https://github.com/kunpengcompute/xucg/archive/refs/tags/v1.1.1-huawei.zip -O $DEP_DOWNLOAD_DIR/xucg-1.1.1-huawei.zip +wget https://github.com/kunpengcompute/hmpi/archive/refs/tags/v1.1.1-huawei.zip -O $DEP_DOWNLOAD_DIR/hmpi-1.1.1-huawei.zip + +cd $DEP_BUILD_DIR +unzip -q $DEP_DOWNLOAD_DIR/hucx-1.1.1-huawei.zip +unzip -q $DEP_DOWNLOAD_DIR/xucg-1.1.1-huawei.zip +unzip -q $DEP_DOWNLOAD_DIR/hmpi-1.1.1-huawei.zip +cp -rf xucg-1.1.1-huawei/* hucx-1.1.1-huawei/src/ucg/ + +#编译hucx +cd $DEP_BUILD_DIR/hucx-1.1.1-huawei +./autogen.sh +./contrib/configure-opt --prefix=$DEP_INSTALL_DIR/hmpi/hucx CFLAGS="-DHAVE___CLEAR_CACHE=1" --disable-numa --without-java +for file in `find . -name Makefile`;do sed -i "s/-Werror//g" $file;done +for file in `find . -name Makefile`;do sed -i "s/-implicit-function-declaration//g" $file;done +make -j +make install + +yum -y install flex +#编译hmpi +cd $DEP_BUILD_DIR/hmpi-1.1.1-huawei +./autogen.pl +./configure --prefix=$DEP_INSTALL_DIR/hmpi --with-platform=contrib/platform/mellanox/optimized --enable-mpi1-compatibility --with-ucx=$DEP_INSTALL_DIR/hmpi/hucx +make -j +make install + +echo "export PATH=$DEP_INSTALL_DIR/hmpi/bin:$PATH" >> ~/.bashrc && source ~/.bashrc +export CC=mpicc CXX=mpicxx FC=mpifort F77=mpifort +## 4.编译stream + +### 4.1.下载并编译stream + +获取stream软件源码并解压文件 + +```bash + +# 下载源码文件 +wget https://www.cs.virginia.edu/stream/FTP/Code/Versions/stream_mpi.c +wget https://www.cs.virginia.edu/stream/FTP/Code/Versions/stream_mpi.f +wget https://www.cs.virginia.edu/stream/FTP/Code/mysecond.c + +#编译源码 +export CC=mpicc CXX=mpicxx FC=mpifort F77=mpifort +mpiicc -O3 -ffreestanding -qopenmp -qopt-streaming-stores=always \ +-DSTREAM_ARRAY_SIZE=100000000 -DNTIMES=20 -DVERBOSE \ +stream_mpi.c -o stream_mpi_c +icc -c mysecond.c +mpiifort -c stream_mpi.f +mpiifort -O3 -qopenmp -qopt-streaming-stores=always stream_mpi.o mysecond.o -o stream_mpi_f +``` + +### 4.2. 运行测试文件 + +运行stream项目文件 + +```bash +${JARVIS_LIBS}/stream-1.8/bin/stream_mpi_c && ${JARVIS_LIBS}/stream-1.8/bin/stream_mpi_f +``` + +## 附A：使用hpcrunner进行一键安装 + +推荐使用hpcrunner进行安装stream + +### 1.克隆仓库 + +```bash +git clone https://gitee.com/openeuler/hpcrunner.git +``` + +## 2.初始化hpcrunner 和 安装必要软件包 + +初始化项目助手 + +```bash +cd hpcrunner +source init.sh +``` + +安装必要软件包 + +**arm / x86 需要的软件包不同，根据实际环境进行选择** + +```bash +# arm +yum install -y environment-modules git wget unzip make flex tar +# x86 +yum install -y environment-modules git wget unzip make flex tar +yum install -y gcc gcc-c++ gcc-gfortran glibc-devel libgfortran +yum install -y tcsh tcl lsof tk bc +``` + +### 3.选择平台对应配置文件 + +- arm平台的配置文件为 `templates/stream/1.8/data.stream.arm.cpu.config` + + ```bash + ./jarvis -use templates/stream/1.8/data.stream.arm.cpu.config + ``` + +- x86 平台的配置文件为 `templates/stream/1.8/data.stream.x86.cpu.config` + + ```bash + ./jarvis -use templates/stream/1.8/data.stream.x86.cpu.config + ``` + +### 4.下载stream源码 + +```bash +./jarvis -d +``` + +### 5.一键配置依赖环境 + +```bash +./jarvis -dp +./jarvis -r +``` + +## 附B：使用singularity运行容器 + +### 使用教程 + +### 下载容器镜像 + +通过链接下载： + +[百度云盘](https://pan.baidu.com/s/1b-pDtKfXEnWyqSQSnb27OQ?pwd=hus8) + +或者扫码下载： + +![百度云](data:image/png;base64,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) + +#### 1.安装singularity + +安装singularity， + +具体步骤如下 + +```bash +mkdir -p ~/install +mkdir -p ~/build + +#安装编译所需依赖 +yum -y install libatomic libstdc++ libstdc++-devel libseccomp-devel glib2-devel gcc squashfs-tools tar + +#安装bisheng编译器 +cd ~/build +wget https://mirrors.huaweicloud.com/kunpeng/archive/compiler/bisheng_compiler/bisheng-compiler-2.1.0-aarch64-linux.tar.gz +tar -C ~/install -xf bisheng-compiler-2.1.0-aarch64-linux.tar.gz +echo "export PATH=$HOME/install/bisheng-compiler-2.1.0-aarch64-linux/bin:$PATH" >> ~/.bashrc && source ~/.bashrc +export CC=`which clang` +export CXX=`which clang++` + +#安装go编译器 +cd ~/build +wget https://go.dev/dl/go1.19.linux-arm64.tar.gz +tar -C ~/install -xf go1.19.linux-arm64.tar.gz +echo "export PATH=$HOME/install/go/bin:$PATH" >> ~/.bashrc && source ~/.bashrc + +#安装singularity +cd ~/build +wget https://github.com/sylabs/singularity/releases/download/v3.10.2/singularity-ce-3.10.2.tar.gz +tar -xf singularity-ce-3.10.2.tar.gz +cd singularity-ce-3.10.2 +./mconfig --prefix=$HOME/install/singularity +make -C ./builddir +make -C ./builddir install +echo "export PATH=$HOME/install/singularity/bin:$PATH" >> ~/.bashrc && source ~/.bashrc +``` + +#### 2.构建镜像 + +```shell +# x86 +singularity build ./name-of-image.sif openeuler-gcc-10.3.0-oneapi1-stream-1.8.def +# arm +singularity build ./name-of-image.sif openeuler-bisheng2-hmpi2-stream-1.8.def +# 转换为沙盒 +singularity build --sandbox image-sandbox name-of-image.sif +``` + +#### 3.在沙盒中运行 + +```shell +#进入沙盒 +singularity shell -w image-sandbox +#在沙盒中运行内置的测试案例 +cd /hpcrunner +./jarvis -r +``` \ No newline at end of file diff --git a/templates/stream/1.8/data.stream.arm.cpu.config b/templates/stream/1.8/data.stream.arm.cpu.config new file mode 100644 index 0000000000000000000000000000000000000000..e6a1bbe2286828cd4d56adb866d34ec81a422ad9 --- /dev/null +++ b/templates/stream/1.8/data.stream.arm.cpu.config @@ -0,0 +1,52 @@ +[SERVER] +11.11.11.11 + +[DOWNLOAD] +stream_mpi.c/2014.10.21 https://www.cs.virginia.edu/stream/FTP/Code/Versions/stream_mpi.c +stream_mpi.f/2014.2.14 https://www.cs.virginia.edu/stream/FTP/Code/Versions/stream_mpi.f +mysecond.c/2009.2.19 https://www.cs.virginia.edu/stream/FTP/Code/mysecond.c + +[DEPENDENCY] +set -e +set -x +module purge +mkdir -p ${JARVIS_TMP}/stream-1.8 +module use ./software/modulefiles +./jarvis -install bisheng/2.1.0 com +module load bisheng/2.1.0 +export CC=clang CXX=clang++ FC=flang +./jarvis -install hmpi/1.2.0 clang +module load hmpi/1.2.0 +cd ${JARVIS_TMP} +mv ${JARVIS_DOWNLOAD}/stream_mpi.c ${JARVIS_TMP}/stream-1.8 +mv ${JARVIS_DOWNLOAD}/stream_mpi.f ${JARVIS_TMP}/stream-1.8 +mv ${JARVIS_DOWNLOAD}/mysecond.c ${JARVIS_TMP}/stream-1.8 + +[ENV] +module purge +module use ${JARVIS_ROOT}/software/modulefiles +module load bisheng/2.1.0 +export CC=clang CXX=clang++ FC=flang +module load hmpi/1.2.0 +export CC=mpicc CXX=mpicxx FC=mpifort F77=mpifort + +[APP] +app_name = stream +build_dir = ${JARVIS_TMP}/stream-1.8 +binary_dir = ${JARVIS_LIBS}/stream-1.8 +case_dir = + +[BUILD] +mpicc -O3 -ffreestanding -openmp -opt-streaming-stores=always \ +-DSTREAM_ARRAY_SIZE=34603008 -DNTIMES=20 -DVERBOSE \ +stream_mpi.c -o stream_mpi_c +mpicc -c mysecond.c +mpifort -c stream_mpi.f +mpifort -O3 -openmp -opt-streaming-stores=always mysecond.o stream_mpi.o -o stream_mpi_f +mkdir -p ${JARVIS_LIBS}/stream-1.8 +cp -r stream_mpi_* ${JARVIS_LIBS}/stream-1.8 + +[RUN] +run = ${JARVIS_LIBS}/stream-1.8/stream_mpi_f && ${JARVIS_LIBS}/stream-1.8/stream_mpi_c +binary = +nodes = 1 \ No newline at end of file diff --git a/templates/stream/1.8/data.stream.x86.cpu.config b/templates/stream/1.8/data.stream.x86.cpu.config new file mode 100644 index 0000000000000000000000000000000000000000..1704f4de6276ca2e5f52c7e853aab6173a72349d --- /dev/null +++ b/templates/stream/1.8/data.stream.x86.cpu.config @@ -0,0 +1,51 @@ +[SERVER] +11.11.11.11 + +[DOWNLOAD] +stream_mpi.c/2014.10.21 https://www.cs.virginia.edu/stream/FTP/Code/Versions/stream_mpi.c +stream_mpi.f/2014.2.14 https://www.cs.virginia.edu/stream/FTP/Code/Versions/stream_mpi.f +mysecond.c/2009.2.19 https://www.cs.virginia.edu/stream/FTP/Code/mysecond.c + +[DEPENDENCY] +set -x +set -e +module purge +./jarvis -install gcc/10.3.0 com +module use ./software/modulefiles +module load gcc/10.3.0 +export CC=`which gcc` +export CXX=`which g++` +export FC=`which gfortran` +./jarvis -install oneapi/2021.1.0 gcc +source /opt/intel/oneapi/setvars.sh +mkdir -p ${JARVIS_TMP}/stream-1.8 +cd ${JARVIS_TMP} +mv ${JARVIS_DOWNLOAD}/stream_mpi.c ${JARVIS_TMP}/stream-1.8 +mv ${JARVIS_DOWNLOAD}/stream_mpi.f ${JARVIS_TMP}/stream-1.8 +mv ${JARVIS_DOWNLOAD}/mysecond.c ${JARVIS_TMP}/stream-1.8 + +[ENV] +module purge +source /opt/intel/oneapi/setvars.sh +export CC=mpiicc FC=mpiifort F77=mpiifort + +[APP] +app_name = stream +build_dir = ${JARVIS_TMP}/stream-1.8 +binary_dir = ${JARVIS_LIBS}/stream-1.8 +case_dir = + +[BUILD] +mpiicc -O3 -ffreestanding -qopenmp -qopt-streaming-stores=always \ +-DSTREAM_ARRAY_SIZE=8650752 -DNTIMES=20 -DVERBOSE \ +stream_mpi.c -o stream_mpi_c +icc -c mysecond.c +mpiifort -c stream_mpi.f +mpiifort -O3 -qopenmp -qopt-streaming-stores=always stream_mpi.o mysecond.o -o stream_mpi_f +mkdir -p ${JARVIS_LIBS}/stream-1.8 +cp -r stream_mpi_* ${JARVIS_LIBS}/stream-1.8 + +[RUN] +run = ${JARVIS_LIBS}/stream-1.8/stream_mpi_c && ${JARVIS_LIBS}/stream-1.8/stream_mpi_f +binary = +nodes = 1 \ No newline at end of file diff --git a/test/test-stream.sh b/test/test-stream.sh new file mode 100644 index 0000000000000000000000000000000000000000..f175c76e90e5908696c73054a82566f3d0a76632 --- /dev/null +++ b/test/test-stream.sh @@ -0,0 +1,16 @@ +#!/bin/bash +cd .. +# release stream src code +rm -rf tmp/stream-1.8 +# copy templates +cp -rf templates/stream/1.8/data.stream.x86.cpu.config ./ +# switch to config +./jarvis -use data.stream.x86.cpu.config +# download stream src code +./jarvis -d +# install dependency +./jarvis -dp +# build +./jarvis -b +# run +./jarvis -r \ No newline at end of file