wehub/alibaba--mnn
1
0
Fork 0
Code Issues Pull Requests Actions 1 Deployments Models Agent Notes Packages Projects Releases Wiki Activity

chore: import upstream snapshot with attribution

Browse Source
This commit is contained in:
wehub-resource-sync
2026-07-13 13:33:03 +08:00
commit 5b57521aa1
8226 changed files with 3425766 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tools/cpp/getPerformance.cpp
+239
View File
@@ -0,0 +1,239 @@
//
// getPerformance.cpp
// MNN
//
// Created by MNN on 2019/03/12.
// Copyright © 2018, Alibaba Group Holding Limited
//
#include <string.h>
#include <chrono>
#include <cstdint>
#include <vector>
#include <thread>
#include <MNN/AutoTime.hpp>
#include <stdlib.h>
#include <MNN/MNNDefine.h>
#include "core/Macro.h"
#ifdef MNN_USE_NEON
#include <arm_neon.h>
#endif
class Timer {
private:
std::chrono::high_resolution_clock::time_point inTime, outTime;
public:
void startTimer() {
inTime = std::chrono::high_resolution_clock::now();
}
// unit ms
float getCostTimer() {
outTime = std::chrono::high_resolution_clock::now();
return (float)(std::chrono::duration_cast<std::chrono::microseconds>(outTime - inTime).count());
}
};
int getCpuCounts() {
FILE* fp = fopen("/proc/cpuinfo", "rb");
if (fp == nullptr) {
MNN_PRINT("fopen error ! \n");
return 0;
}
int cpuCounts = 0;
char data[1024];
while (!feof(fp)) {
char* a = fgets(data, 1024, fp);
if (a == nullptr) {
break;
}
if (memcmp(data, "processor", 9) == 0) {
cpuCounts++;
}
}
fclose(fp);
fp = nullptr;
return cpuCounts;
}
// 0 max 1 min 2 cur
void getFreqKhz(int cpuid, std::vector<int>& freqVector) {
char path[256];
int freqKhz = -1;
// max
sprintf(path, "/sys/devices/system/cpu/cpu%d/cpufreq/cpuinfo_max_freq", cpuid);
FILE* fp = fopen(path, "rb");
if (nullptr == fp) {
MNN_PRINT("cpuinfo_max_freq fopen error ! \n");
freqVector.emplace_back(0);
} else {
fscanf(fp, "%d", &freqKhz);
fclose(fp);
freqVector.push_back(freqKhz);
}
// min
sprintf(path, "/sys/devices/system/cpu/cpu%d/cpufreq/cpuinfo_min_freq", cpuid);
fp = fopen(path, "rb");
if (nullptr == fp) {
MNN_PRINT("cpuinfo_min_freq fopen error ! \n");
freqVector.emplace_back(0);
} else {
freqKhz = -1;
fscanf(fp, "%d", &freqKhz);
fclose(fp);
freqVector.push_back(freqKhz);
}
// cur
// sprintf(path, "/sys/devices/system/cpu/cpu%d/cpufreq/cpuinfo_cur_freq", cpuid);
// fp = fopen(path, "rb");
// if(nullptr == fp){
// MNN_PRINT("cpuinfo_cur_freq fopen error ! \n");
// }else{
// freqKhz = -1;
// fscanf(fp, "%d", &freqKhz);
// fclose(fp);
// freqVector.push_back(freqKhz);
// }
}
void cpuFloatMlaTest(int32_t loopCounts) {
#ifdef MNN_USE_NEON
#ifndef __aarch64__
__asm__ __volatile__(
"mov r12, %0\n"
"0: \n"
"vmla.f32 q15, q15, d0[0] \n"
"vmla.f32 q14, q14, d0[1] \n"
"vmla.f32 q13, q13, d1[0] \n"
"vmla.f32 q12, q12, d1[1] \n"
"vmla.f32 q11, q11, d2[0] \n"
"vmla.f32 q10, q10, d2[1] \n"
"vmla.f32 q9, q9, d3[0] \n"
"vmla.f32 q8, q8, d3[1] \n"
"vmla.f32 q7, q7, d4[0] \n"
"vmla.f32 q6, q6, d4[1] \n"
"vmla.f32 q5, q5, d5[0] \n"
"vmla.f32 q4, q4, d5[1] \n"
"vmla.f32 q3, q3, d6[0] \n"
"subs r12, r12, #1 \n"
"bne 0b \n"
:
: "r"(loopCounts)
: "cc", "memory", "r12", "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7", "q8", "q9", "q14", "q15"
);
#else
__asm__ __volatile__(
"mov w9, %w0\n"
"0: \n"
"fmla v31.4s, v31.4s, v0.s[0]\n"
"fmla v30.4s, v30.4s, v0.s[1]\n"
"fmla v29.4s, v29.4s, v0.s[2]\n"
"fmla v28.4s, v28.4s, v0.s[3]\n"
"fmla v27.4s, v27.4s, v1.s[0]\n"
"fmla v26.4s, v26.4s, v1.s[1]\n"
"fmla v25.4s, v25.4s, v1.s[2]\n"
"fmla v24.4s, v24.4s, v1.s[3]\n"
"fmla v23.4s, v23.4s, v3.s[0]\n"
"fmla v22.4s, v22.4s, v3.s[1]\n"
"fmla v21.4s, v21.4s, v3.s[2]\n"
"fmla v20.4s, v20.4s, v3.s[3]\n"
"fmla v19.4s, v19.4s, v4.s[0]\n"
"fmla v18.4s, v18.4s, v4.s[1]\n"
"fmla v17.4s, v17.4s, v4.s[2]\n"
"fmla v16.4s, v16.4s, v4.s[3]\n"
"fmla v15.4s, v15.4s, v5.s[0]\n"
"fmla v14.4s, v14.4s, v5.s[1]\n"
"fmla v13.4s, v13.4s, v5.s[2]\n"
"fmla v12.4s, v12.4s, v5.s[3]\n"
"fmla v11.4s, v11.4s, v6.s[0]\n"
"fmla v10.4s, v10.4s, v6.s[1]\n"
"fmla v9.4s, v9.4s, v6.s[2]\n"
"fmla v8.4s, v8.4s, v6.s[3]\n"
"fmla v7.4s, v7.4s, v2.s[0]\n"
"subs w9, w9, #1 \n"
"bne 0b \n"
:
: "r"(loopCounts)
: "cc", "memory", "w9", "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15"
);
#endif
#endif
}
void cpuFLOPSPerformance() {
int32_t loopCounts = 100000000;
MNN_PRINT("CPU PERFORMANCE -> loopCounts : %d \n", loopCounts);
std::vector<int> freqVector;
for (int i = 0; i < getCpuCounts(); i++) {
freqVector.clear();
getFreqKhz(i, freqVector);
MNN_PRINT("core %d : max : %d, min : %d \n",i, freqVector.at(0), freqVector.at(1));
}
// warm up
cpuFloatMlaTest(loopCounts);
Timer timeInstance;
timeInstance.startTimer();
cpuFloatMlaTest(loopCounts);
#ifdef MNN_USE_NEON
#ifndef __aarch64__
auto number = (double)loopCounts * 13;
#else
auto number = (double)loopCounts * 25;
#endif
#else
auto number = 0.0;
#endif
//FUNC_PRINT(number);
float costTime_ms = timeInstance.getCostTimer();
double costTime_s = (double)(costTime_ms) / 1000000.0f;
// MNN_PRINT("cost time : %f \n", costTime_s);
double mlaCounts_g = number * 4 / 1000000000.0f;
float gflops = mlaCounts_g / costTime_s;
MNN_PRINT(" ======================== float ===============================\n");
MNN_PRINT("CPU float gflops : %f\n", gflops);
}
static void _testMemcpy() {
int size = 1024 * 1024;
int loop = 10000;
std::vector<std::thread> threads;
int threadNumber = 2;
std::vector<std::vector<int8_t>> tmp(threadNumber);
for (int i=0; i<threadNumber; ++i) {
tmp[i].resize(size);
}
MNN::Timer _t;
for (int i=0; i<threadNumber; ++i) {
threads.emplace_back(std::thread([size, loop, i, &tmp]() {
auto t0 = tmp[i].data();
for (int i=0; i<loop; ++i) {
::memset(t0, 0, size);
}
}));
}
for (auto& t : threads) {
t.join();
}
float timeInS = (float)_t.durationInUs() / 1000.0f / 1000.0f;
float speed = (float)size * (float)threads.size() / 1024.0f / 1024.0f / 1024.0f * (float)loop / timeInS;
MNN_PRINT("Memcpy speed: %f GB / s\n", speed);
}
int main(int argc, const char* argv[]) {
MNN_PRINT("Start PERFORMANCE !!! \n");
cpuFLOPSPerformance();
_testMemcpy();
return 0;
}