├── .gitignore ├── LICENSE ├── Makefile ├── README.md ├── BenchmarkIOPS32.c ├── BenchmarkFLOPS32.c ├── BenchmarkFLOPS64.c └── BenchmarkIOPS64.c /.gitignore: -------------------------------------------------------------------------------- 1 | flops32 2 | flops64 3 | iops32 4 | iops64 5 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE 2 | Version 2, December 2004 3 | 4 | Copyright (C) 2020 Shaswata Das 5 | 6 | Everyone is permitted to copy and distribute verbatim or modified 7 | copies of this license document, and changing it is allowed as long 8 | as the name is changed. 9 | 10 | DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE 11 | TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 12 | 13 | 0. You just DO WHAT THE FUCK YOU WANT TO. 14 | -------------------------------------------------------------------------------- /Makefile: -------------------------------------------------------------------------------- 1 | CC = gcc 2 | CFLAGS = -lpthread -Wno-overflow -pthread 3 | 4 | TARGET1 = flops32 5 | FILE1 = BenchmarkFLOPS32.c 6 | TARGET2 = flops64 7 | FILE2 = BenchmarkFLOPS64.c 8 | TARGET3 = iops32 9 | FILE3 = BenchmarkIOPS32.c 10 | TARGET4 = iops64 11 | FILE4 = BenchmarkIOPS64.c 12 | 13 | all: $(TARGET1) $(TARGET2) $(TARGET3) $(TARGET4) 14 | 15 | $(TARGET1): $(FILE1) 16 | $(CC) $(CFLAGS) -o $(TARGET1) $(FILE1) 17 | 18 | $(TARGET2): $(FILE2) 19 | $(CC) $(CFLAGS) -o $(TARGET2) $(FILE2) 20 | 21 | $(TARGET3): $(FILE3) 22 | $(CC) $(CFLAGS) -o $(TARGET3) $(FILE3) 23 | 24 | $(TARGET4): $(FILE1) 25 | $(CC) $(CFLAGS) -o $(TARGET4) $(FILE4) 26 | 27 | install: all 28 | mv -t /usr/bin/ iops32 iops64 flops32 flops64 29 | 30 | uninstall: all 31 | rm /usr/bin/{iops32,iops64,flops32,flops64} 32 | 33 | clean: 34 | rm $(TARGET1) $(TARGET2) $(TARGET3) $(TARGET4) 35 | 36 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # BenchUtil 2 | CPU Benchmarking Tool by calculating IOPS and FLOPS. 3 | 4 | ## Build Binaries 5 | ```fish 6 | $ make 7 | ``` 8 | 9 | ## Cleaning Old Build 10 | ```fish 11 | $ make clean 12 | ``` 13 | 14 | ## Install Binaries 15 | ```fish 16 | $ sudo make install 17 | ``` 18 | 19 | ## Uninstall Binaries 20 | ```fish 21 | $ sudo make uninstall 22 | ``` 23 | 24 | ## Usage 25 | ```sh 26 | $ iops32 $(nproc) 27 | $ iops64 $(nproc) 28 | $ flops32 $(nproc) 29 | $ flops64 $(nproc) 30 | ``` 31 | 32 | ## Benchmark Results!! 33 | Hey, if you used this tool to benchmark your processor's raw IOPS and FLOPS you can add it here by a Pull Request! 34 | You PR your test results for different devices, diversity is great! 35 | 36 | --- 37 | ### user: [shaswata56](https://github.com/shaswata56) 38 | 39 | ### CPU: Intel(R) Core(TM) i7-8550U CPU @ 1.80GHz 40 | 41 | ``` 42 | ./iops64 8 43 | Benchmarking for 64 Bit Integer operations per second 44 | 1| Tr 1: 1124851040 Tr 2: 793884201 Tr 3: 771428733 Tr 4: 1005115326 Tr 5: 734654499 Tr 6: 876540800 Tr 7: 1652518115 Tr 8: 1639176159 IOPS = 8598168873 45 | Maximum CPU Throughput: 8.598168 Gigaiops. 46 | Maximum Single Core Throughput: 1.652518 Gigaiops. 47 | 48 | ./flops64 8 49 | Benchmarking for 64 Bit Floating point operations per second 50 | 1| Tr 1: 1224104106 Tr 2: 1490004774 Tr 3: 632462621 Tr 4: 994263362 Tr 5: 632271057 Tr 6: 1349505497 Tr 7: 994876034 Tr 8: 637448332 FLOPS = 7954935783 51 | Maximum CPU Throughput: 7.954936 Gigaflops. 52 | Maximum Single Core Throughput: 1.490005 Gigaflops. 53 | ``` 54 | -------------------------------------------------------------------------------- /BenchmarkIOPS32.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | void initIOPS32 (const int POOL); 7 | void *calculateIOPS32 (void *arg); 8 | 9 | int main (int argc, char** argv) { 10 | int n; 11 | if (argc == 1) { 12 | printf("Number of CPU cores to run Benchmark: "); 13 | scanf("%d", &n); 14 | } else { 15 | n = atoi(argv[1]); 16 | } 17 | printf("Benchmarking for 32 Bit Integer operations per second\n"); 18 | initIOPS32(n); 19 | return 0; 20 | } 21 | 22 | void *calculateIOPS32 (void *arg) { 23 | unsigned long long noOfOperations = 0, loopOperations = 30; 24 | int a = 124235250001, b = 21241201001, c = 2342234320000, d = 233240000000001, e= 2341200000100000, g = 123112003001, h =56740012007, k =240010001001, l =34224003003006, m= 3242352500060006, n = 512412487236, o = 24223432, p = 11234142738462, r = 8532114414, s = 31125646724, t =67451241564, u = 34447892317, w =3244427389, x =8913189230, y =12323782349, v1 =0000001000023, v2 = 3000009000009, v3 = 565000000204, v4 = 30000090009, v5 = 78743777777; 25 | 26 | while (1) { 27 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 28 | *((unsigned long long *)arg) = noOfOperations += loopOperations; 29 | } 30 | } 31 | 32 | 33 | void initIOPS32 (const int POOL) { 34 | 35 | time_t now; time(&now); 36 | pthread_t memThreads[POOL]; 37 | unsigned long long iopsLog[POOL][6]; 38 | unsigned long long iops[6], tFlops[POOL], maxiops = 0, temp = 0, singleCoreMax = 0; 39 | 40 | for (int i = 0 ; i < 1; i++) { 41 | if (i == 0) 42 | for (int r = 0; r < POOL; r++) { 43 | tFlops[r] = 0; 44 | iopsLog[r][i] = 0; 45 | pthread_create(&memThreads[r], NULL, calculateIOPS32, &tFlops[r]); 46 | } 47 | sleep(60); 48 | for (int r = 0; r < POOL; r++) 49 | iopsLog[r][i] = tFlops[r]; 50 | } 51 | 52 | for (int i = 0; i < POOL; i++) 53 | pthread_cancel(memThreads[i]); 54 | 55 | FILE *fptr; 56 | fptr = fopen("iopsBench.txt", "a"); 57 | fprintf(fptr, "\n%s", ctime(&now)); 58 | fprintf(fptr, "Benchmarking for 32 Bit Integer operations per second\n"); 59 | 60 | for (int i = 0; i < 1; i++) { 61 | iops[i] = 0; 62 | printf("%d| ", i + 1); 63 | fprintf(fptr, "%d| ", i + 1); 64 | for (int r = 0; r < POOL; r++) { 65 | temp = (i == 0) ? (iopsLog[r][i] / 60) : (iopsLog[r][i] - iopsLog[r][i - 1]) / 60; 66 | iops[i] += temp; 67 | singleCoreMax = (temp > singleCoreMax) ? temp : singleCoreMax; 68 | printf("Tr %d: %llu ", r + 1, temp); 69 | fprintf(fptr, "Tr %d: %llu ", r + 1, temp); 70 | } 71 | printf("IOPS = %llu\n", iops[i]); 72 | fprintf(fptr, "IOPS = %llu\n", iops[i]); 73 | maxiops = (iops[i] > maxiops) ? iops[i] : maxiops; 74 | } 75 | printf("Maximum CPU Throughput: %lf Gigaiops.\n", maxiops / 1000000000.0f); 76 | printf("Maximum Single Core Throughput: %lf Gigaiops.\n", singleCoreMax / 1000000000.0f); 77 | fprintf(fptr, "Maximum CPU Throughput: %lf Gigaiops.\n", maxiops / 1000000000.0f); 78 | fprintf(fptr, "Maximum Single Core Throughput: %lf Gigaiops.\n", singleCoreMax / 1000000000.0f); 79 | fclose(fptr); 80 | } 81 | -------------------------------------------------------------------------------- /BenchmarkFLOPS32.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | void initFLOPS32 (const int POOL); 7 | void *calculateFLOPS32 (void *arg); 8 | 9 | int main (int argc, char** argv) { 10 | int n; 11 | if (argc == 1) { 12 | printf("Number of CPU cores to run Benchmark: "); 13 | scanf("%d", &n); 14 | } else { 15 | n = atoi(argv[1]); 16 | } 17 | printf("Benchmarking for 32 Bit Floating point operations per second\n"); 18 | initFLOPS32(n); 19 | return 0; 20 | } 21 | 22 | void *calculateFLOPS32 (void *arg) { 23 | unsigned long long noOfOperations = 0, loopOperations = 30; 24 | float a = 124.235250001, b = 21.241201001, c = 2342.234320000, d = 23.3240000000001, e= 2.341200000100000, g = 1231.12003001, h =567.40012007, k =24.0010001001, l =342.24003003006, m= 324.2352500060006, n = 51.2412487236, o = 242.23432, p = 112.34142738462, r = 853.2114414, s = 31.125646724, t =67.451241564, u = 34.447892317, w =3.244427389, x =89.13189230, y =123.23782349, v1 =0.000001000023, v2 = 3.000009000009, v3 = 56.5000000204, v4 = 0.00000090009, v5 = 787.43777777; 25 | 26 | while (1) { 27 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 28 | *((unsigned long long *)arg) = noOfOperations += loopOperations; 29 | } 30 | } 31 | 32 | 33 | void initFLOPS32 (const int POOL) { 34 | 35 | time_t now; time(&now); 36 | pthread_t memThreads[POOL]; 37 | unsigned long long flopsLog[POOL][6]; 38 | unsigned long long flops[6], tFlops[POOL], maxflops = 0, temp = 0, singleCoreMax = 0; 39 | 40 | for (int i = 0 ; i < 1; i++) { 41 | if (i == 0) 42 | for (int r = 0; r < POOL; r++) { 43 | tFlops[r] = 0; 44 | flopsLog[r][i] = 0; 45 | pthread_create(&memThreads[r], NULL, calculateFLOPS32, &tFlops[r]); 46 | } 47 | sleep(60); 48 | for (int r = 0; r < POOL; r++) 49 | flopsLog[r][i] = tFlops[r]; 50 | } 51 | 52 | for (int i = 0; i < POOL; i++) 53 | pthread_cancel(memThreads[i]); 54 | 55 | FILE *fptr; 56 | fptr = fopen("flopsBench.txt", "a"); 57 | fprintf(fptr, "\n%s", ctime(&now)); 58 | fprintf(fptr, "Benchmarking for 32 Bit Floating point operations per second\n"); 59 | 60 | for (int i = 0; i < 1; i++) { 61 | flops[i] = 0; 62 | printf("%d| ", i + 1); 63 | fprintf(fptr, "%d| ", i + 1); 64 | for (int r = 0; r < POOL; r++) { 65 | temp = (i == 0) ? (flopsLog[r][i] / 60) : (flopsLog[r][i] - flopsLog[r][i - 1]) / 60; 66 | flops[i] += temp; 67 | singleCoreMax = (temp > singleCoreMax) ? temp : singleCoreMax; 68 | printf("Tr %d: %llu ", r + 1, temp); 69 | fprintf(fptr, "Tr %d: %llu ", r + 1, temp); 70 | } 71 | printf("FLOPS = %llu\n", flops[i]); 72 | fprintf(fptr, "FLOPS = %llu\n", flops[i]); 73 | maxflops = (flops[i] > maxflops) ? flops[i] : maxflops; 74 | } 75 | printf("Maximum CPU Throughput: %lf Gigaflops.\n", maxflops / 1000000000.0f); 76 | printf("Maximum Single Core Throughput: %lf Gigaflops.\n", singleCoreMax / 1000000000.0f); 77 | fprintf(fptr, "Maximum CPU Throughput: %lf Gigaflops.\n", maxflops / 1000000000.0f); 78 | fprintf(fptr, "Maximum Single Core Throughput: %lf Gigaflops.\n", singleCoreMax / 1000000000.0f); 79 | fclose(fptr); 80 | } 81 | -------------------------------------------------------------------------------- /BenchmarkFLOPS64.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | void initFLOPS64 (const int POOL); 7 | void *calculateFLOPS64 (void *arg); 8 | 9 | int main (int argc, char** argv) { 10 | int n; 11 | if (argc == 1) { 12 | printf("Number of CPU cores to run Benchmark: "); 13 | scanf("%d", &n); 14 | } else { 15 | n = atoi(argv[1]); 16 | } 17 | printf("Benchmarking for 64 Bit Floating point operations per second\n"); 18 | initFLOPS64(n); 19 | return 0; 20 | } 21 | 22 | void *calculateFLOPS64 (void *arg) { 23 | unsigned long long noOfOperations = 0, loopOperations = 30 * 52; 24 | double a = 124.235250001, b = 21.241201001, c = 2342.234320000, d = 23.3240000000001, e= 2.341200000100000, g = 1231.12003001, h =567.40012007, k =24.0010001001, l =342.24003003006, m= 324.2352500060006, n = 51.2412487236, o = 242.23432, p = 112.34142738462, r = 853.2114414, s = 31.125646724, t =67.451241564, u = 34.447892317, w =3.244427389, x =89.13189230, y =123.23782349, v1 =0.000001000023, v2 = 3.000009000009, v3 = 56.5000000204, v4 = 0.00000090009, v5 = 787.43777777; 25 | 26 | while (1) { 27 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 28 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 29 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 30 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 31 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 32 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 33 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 34 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 35 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 36 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 37 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 38 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 39 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 40 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 41 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 42 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 43 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 44 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 45 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 46 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 47 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 48 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 49 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 50 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 51 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 52 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 53 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 54 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 55 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 56 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 57 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 58 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 59 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 60 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 61 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 62 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 63 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 64 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 65 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 66 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 67 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 68 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 69 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 70 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 71 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 72 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 73 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 74 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 75 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 76 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 77 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 78 | 79 | *((unsigned long long *)arg) = noOfOperations += loopOperations; 80 | } 81 | } 82 | 83 | 84 | void initFLOPS64 (const int POOL) { 85 | 86 | time_t now; time(&now); 87 | pthread_t memThreads[POOL]; 88 | unsigned long long flopsLog[POOL][6]; 89 | unsigned long long flops[6], tFlops[POOL], maxflops = 0, temp = 0, singleCoreMax = 0; 90 | 91 | for (int i = 0 ; i < 1; i++) { 92 | if (i == 0) 93 | for (int r = 0; r < POOL; r++) { 94 | tFlops[r] = 0; 95 | flopsLog[r][i] = 0; 96 | pthread_create(&memThreads[r], NULL, calculateFLOPS64, &tFlops[r]); 97 | } 98 | sleep(60); 99 | for (int r = 0; r < POOL; r++) 100 | flopsLog[r][i] = tFlops[r]; 101 | } 102 | 103 | for (int i = 0; i < POOL; i++) 104 | pthread_cancel(memThreads[i]); 105 | 106 | FILE *fptr; 107 | fptr = fopen("flopsBench.txt", "a"); 108 | fprintf(fptr, "\n%s", ctime(&now)); 109 | fprintf(fptr, "Benchmarking for 64 Bit Floating point operations per second\n"); 110 | 111 | for (int i = 0; i < 1; i++) { 112 | flops[i] = 0; 113 | printf("%d| ", i + 1); 114 | fprintf(fptr, "%d| ", i + 1); 115 | for (int r = 0; r < POOL; r++) { 116 | temp = (i == 0) ? (flopsLog[r][i] / 60) : (flopsLog[r][i] - flopsLog[r][i - 1]) / 60; 117 | flops[i] += temp; 118 | singleCoreMax = (temp > singleCoreMax) ? temp : singleCoreMax; 119 | printf("Tr %d: %llu ", r + 1, temp); 120 | fprintf(fptr, "Tr %d: %llu ", r + 1, temp); 121 | } 122 | printf("FLOPS = %llu\n", flops[i]); 123 | fprintf(fptr, "FLOPS = %llu\n", flops[i]); 124 | maxflops = (flops[i] > maxflops) ? flops[i] : maxflops; 125 | } 126 | printf("Maximum CPU Throughput: %lf Gigaflops.\n", maxflops / 1000000000.0f); 127 | printf("Maximum Single Core Throughput: %lf Gigaflops.\n", singleCoreMax / 1000000000.0f); 128 | fprintf(fptr, "Maximum CPU Throughput: %lf Gigaflops.\n", maxflops / 1000000000.0f); 129 | fprintf(fptr, "Maximum Single Core Throughput: %lf Gigaflops.\n", singleCoreMax / 1000000000.0f); 130 | fclose(fptr); 131 | } 132 | -------------------------------------------------------------------------------- /BenchmarkIOPS64.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | void initIOPS64 (const int POOL); 7 | void *calculateIOPS64 (void *arg); 8 | 9 | int main (int argc, char** argv) { 10 | int n; 11 | if (argc == 1) { 12 | printf("Number of CPU cores to run Benchmark: "); 13 | scanf("%d", &n); 14 | } else { 15 | n = atoi(argv[1]); 16 | } 17 | printf("Benchmarking for 64 Bit Integer operations per second\n"); 18 | initIOPS64(n); 19 | return 0; 20 | } 21 | 22 | void *calculateIOPS64 (void *arg) { 23 | unsigned long long noOfOperations = 0, loopOperations = 30 * 52; 24 | long long int a = 124235250001, b = 21241201001, c = 2342234320000, d = 233240000000001, e= 2341200000100000, g = 123112003001, h =56740012007, k =240010001001, l =34224003003006, m= 3242352500060006, n = 512412487236, o = 24223432, p = 11234142738462, r = 8532114414, s = 31125646724, t =67451241564, u = 34447892317, w =3244427389, x =8913189230, y =12323782349, v1 =0000001000023, v2 = 3000009000009, v3 = 565000000204, v4 = 30000090009, v5 = 78743777777; 25 | 26 | while (1) { 27 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 28 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 29 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 30 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 31 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 32 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 33 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 34 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 35 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 36 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 37 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 38 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 39 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 40 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 41 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 42 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 43 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 44 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 45 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 46 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 47 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 48 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 49 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 50 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 51 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 52 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 53 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 54 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 55 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 56 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 57 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 58 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 59 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 60 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 61 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 62 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 63 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 64 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 65 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 66 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 67 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 68 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 69 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 70 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 71 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 72 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 73 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 74 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 75 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 76 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 77 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 78 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 79 | c *= ((((d + e) + (v5 * v5)) * ((a * (v1 + v2)) + (b * (o + p))) + ((g * h) + (x * y)) * (t + u) + ((k * l) + (g * k)) * (w * l)) * (((m * n) + (k + n)) + ((r * s) + (v3 * v4)))); 80 | 81 | *((unsigned long long *)arg) = noOfOperations += loopOperations; 82 | } 83 | } 84 | 85 | 86 | void initIOPS64 (const int POOL) { 87 | 88 | time_t now; time(&now); 89 | pthread_t memThreads[POOL]; 90 | unsigned long long iopsLog[POOL][6]; 91 | unsigned long long iops[6], tFlops[POOL], maxiops = 0, temp = 0, singleCoreMax = 0; 92 | 93 | for (int i = 0 ; i < 1; i++) { 94 | if (i == 0) 95 | for (int r = 0; r < POOL; r++) { 96 | tFlops[r] = 0; 97 | iopsLog[r][i] = 0; 98 | pthread_create(&memThreads[r], NULL, calculateIOPS64, &tFlops[r]); 99 | } 100 | sleep(60); 101 | for (int r = 0; r < POOL; r++) 102 | iopsLog[r][i] = tFlops[r]; 103 | } 104 | 105 | for (int i = 0; i < POOL; i++) 106 | pthread_cancel(memThreads[i]); 107 | 108 | FILE *fptr; 109 | fptr = fopen("iopsBench.txt", "a"); 110 | fprintf(fptr, "\n%s", ctime(&now)); 111 | fprintf(fptr, "Benchmarking for 64 Bit Integer operations per second\n"); 112 | 113 | for (int i = 0; i < 1; i++) { 114 | iops[i] = 0; 115 | printf("%d| ", i + 1); 116 | fprintf(fptr, "%d| ", i + 1); 117 | for (int r = 0; r < POOL; r++) { 118 | temp = (i == 0) ? (iopsLog[r][i] / 60) : (iopsLog[r][i] - iopsLog[r][i - 1]) / 60; 119 | iops[i] += temp; 120 | singleCoreMax = (temp > singleCoreMax) ? temp : singleCoreMax; 121 | printf("Tr %d: %llu ", r + 1, temp); 122 | fprintf(fptr, "Tr %d: %llu ", r + 1, temp); 123 | } 124 | printf("IOPS = %llu\n", iops[i]); 125 | fprintf(fptr, "IOPS = %llu\n", iops[i]); 126 | maxiops = (iops[i] > maxiops) ? iops[i] : maxiops; 127 | } 128 | printf("Maximum CPU Throughput: %lf Gigaiops.\n", maxiops / 1000000000.0f); 129 | printf("Maximum Single Core Throughput: %lf Gigaiops.\n", singleCoreMax / 1000000000.0f); 130 | fprintf(fptr, "Maximum CPU Throughput: %lf Gigaiops.\n", maxiops / 1000000000.0f); 131 | fprintf(fptr, "Maximum Single Core Throughput: %lf Gigaiops.\n", singleCoreMax / 1000000000.0f); 132 | fclose(fptr); 133 | } 134 | --------------------------------------------------------------------------------