cpp
/
sol2_test
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Rework the tests into separate functions and do a dumb randomizing for now.

Browse Source
master
Zed A. Shaw 5 hours ago
parent 6ac65bff27
commit 90543ee138
3 changed files with 41 additions and 108 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 1
      meson.build
  2. 1
      tests/main.cpp
  3. 145
      tests/perf_tests.cpp

1
meson.build
Unescape View File

@ -12,6 +12,7 @@ cpp_args=[
'-Wno-unused-variable',
'-Wno-unused-but-set-variable',
'-Wno-deprecated-declarations',
'-Wno-maybe-uninitialized', # only because of error in release_build
]
link_args=[]
# these are passed as override_defaults

1
tests/main.cpp
Unescape View File

@ -1,4 +1,5 @@
#include <fuc2/run.hpp>
TEST_SET(sol2_tests);
TEST_SET(bao_tests);
TEST_SET(soa_tests);

145
tests/perf_tests.cpp
Unescape View File

@ -160,25 +160,17 @@ namespace perf_tests {
std::vector<Stats> soa_many_for;
std::vector<Stats> ls_big_for;
std::vector<Stats> ls_many_for;
std::vector<Stats> ls_many_for_fast;
std::vector<Stats> moa_big_for;
std::vector<Stats> moa_many_for;
std::vector<Stats> moa_many_for_fast;
};
void run_test(Samples& samples, int sample_size, int sample_number) {
void test_large_soa(Samples& samples, int sample_size, int sample_number) {
auto soa = new LargeSOA();
auto ls = new std::vector<LargeStruct>;
auto moa = new MultipleSOA();
for(int i = 0; i < sample_size; i++) {
soa->push_back(i);
ls->push_back({i});
moa->push_back(i);
}
fmt::println("Data Size: {}", sizeof(LargeStruct) * sample_size);
Stats big_for;
for(int i = 0; i < sample_number; i++) {
auto start = big_for.time_start();
@ -205,8 +197,6 @@ namespace perf_tests {
}
big_for.sample_time(start);
}
big_for.dump("soa big for");
fmt::println("-------------\n");
samples.soa_big_for.push_back(big_for);
Stats many_for;
@ -233,9 +223,15 @@ namespace perf_tests {
for(int i = 0; i < sample_size; i++) soa->a19[i] += soa->a20[i] + i;
many_for.sample_time(start);
}
many_for.dump("soa many for");
fmt::println("-------------\n");
samples.soa_many_for.push_back(many_for);
}
void test_large_struct(Samples& samples, int sample_size, int sample_number) {
auto ls = new std::vector<LargeStruct>;
for(int i = 0; i < sample_size; i++) {
ls->push_back({i});
}
Stats ls_big_for;
for(int i = 0; i < sample_number; i++) {
@ -263,8 +259,7 @@ namespace perf_tests {
}
ls_big_for.sample_time(start);
}
ls_big_for.dump("ls big for");
fmt::println("-------------\n");
samples.ls_big_for.push_back(ls_big_for);
Stats ls_many_for;
@ -291,37 +286,16 @@ namespace perf_tests {
for(auto& el : *ls) el.a19 += el.a20 + i;
ls_many_for.sample_time(start);
}
ls_many_for.dump("ls many for");
fmt::println("-------------\n");
samples.ls_many_for.push_back(ls_many_for);
}
Stats ls_many_for_fast;
for(int i = 0; i < sample_number; i++) {
auto start = ls_many_for_fast.time_start();
for(int i = 0; i < sample_size; i++) (*ls)[i].a01 += (*ls)[i].a02 + i;
for(int i = 0; i < sample_size; i++) (*ls)[i].a02 += (*ls)[i].a03 + i;
for(int i = 0; i < sample_size; i++) (*ls)[i].a03 += (*ls)[i].a04 + i;
for(int i = 0; i < sample_size; i++) (*ls)[i].a04 += (*ls)[i].a05 + i;
for(int i = 0; i < sample_size; i++) (*ls)[i].a05 += (*ls)[i].a06 + i;
for(int i = 0; i < sample_size; i++) (*ls)[i].a06 += (*ls)[i].a07 + i;
for(int i = 0; i < sample_size; i++) (*ls)[i].a07 += (*ls)[i].a08 + i;
for(int i = 0; i < sample_size; i++) (*ls)[i].a08 += (*ls)[i].a09 + i;
for(int i = 0; i < sample_size; i++) (*ls)[i].a09 += (*ls)[i].a10 + i;
for(int i = 0; i < sample_size; i++) (*ls)[i].a10 += (*ls)[i].a11 + i;
for(int i = 0; i < sample_size; i++) (*ls)[i].a11 += (*ls)[i].a12 + i;
for(int i = 0; i < sample_size; i++) (*ls)[i].a12 += (*ls)[i].a13 + i;
for(int i = 0; i < sample_size; i++) (*ls)[i].a13 += (*ls)[i].a14 + i;
for(int i = 0; i < sample_size; i++) (*ls)[i].a14 += (*ls)[i].a15 + i;
for(int i = 0; i < sample_size; i++) (*ls)[i].a15 += (*ls)[i].a16 + i;
for(int i = 0; i < sample_size; i++) (*ls)[i].a16 += (*ls)[i].a17 + i;
for(int i = 0; i < sample_size; i++) (*ls)[i].a17 += (*ls)[i].a18 + i;
for(int i = 0; i < sample_size; i++) (*ls)[i].a18 += (*ls)[i].a19 + i;
for(int i = 0; i < sample_size; i++) (*ls)[i].a19 += (*ls)[i].a20 + i;
ls_many_for_fast.sample_time(start);
void test_moa_style(Samples& samples, int sample_size, int sample_number) {
auto moa = new MultipleSOA();
for(int i = 0; i < sample_size; i++) {
moa->push_back(i);
}
ls_many_for_fast.dump("ls many for");
fmt::println("-------------\n");
samples.ls_many_for_fast.push_back(ls_many_for_fast);
Stats moa_big_for;
for(int i = 0; i < sample_number; i++) {
@ -353,8 +327,6 @@ namespace perf_tests {
}
moa_big_for.sample_time(start);
}
moa_big_for.dump("moa big for");
fmt::println("-------------\n");
samples.moa_big_for.push_back(moa_big_for);
Stats moa_many_for;
@ -381,7 +353,6 @@ namespace perf_tests {
moa->s2[i].a08 += moa->s3[i].a09 + i;
}
for(auto& el : moa->s3) {
el.a09 += el.a10 + i;
el.a10 += el.a11 + i;
@ -411,82 +382,42 @@ namespace perf_tests {
moa_many_for.sample_time(start);
}
moa_many_for.dump("moa many for");
fmt::println("-------------\n");
samples.moa_many_for.push_back(moa_many_for);
Stats moa_many_for_fast;
for(int i = 0; i < sample_number; i++) {
auto start = moa_many_for_fast.time_start();
for(int i = 0; i < sample_size; i++) {
moa->s1[i].a01 += moa->s1[i].a02 + i;
moa->s1[i].a02 += moa->s1[i].a03 + i;
moa->s1[i].a03 += moa->s1[i].a04 + i;
}
for(int i = 0; i < sample_size; i++) {
moa->s1[i].a04 += moa->s2[i].a05 + i;
}
for(int i = 0; i < sample_size; i++) {
moa->s2[i].a05 += moa->s2[i].a06 + i;
moa->s2[i].a06 += moa->s2[i].a07 + i;
moa->s2[i].a07 += moa->s2[i].a08 + i;
}
for(int i = 0; i < sample_size; i++) {
moa->s2[i].a08 += moa->s3[i].a09 + i;
}
for(int i = 0; i < sample_size; i++) {
moa->s3[i].a09 += moa->s3[i].a10 + i;
moa->s3[i].a10 += moa->s3[i].a11 + i;
moa->s3[i].a11 += moa->s3[i].a12 + i;
}
for(int i = 0; i < sample_size; i++) {
moa->s3[i].a12 += moa->s4[i].a13 + i;
}
for(int i = 0; i < sample_size; i++) {
moa->s4[i].a13 += moa->s4[i].a14 + i;
moa->s4[i].a14 += moa->s4[i].a15 + i;
moa->s4[i].a15 += moa->s4[i].a16 + i;
}
void test_soa_performance() {
Samples samples;
for(int i = 0; i < sample_size; i++) {
moa->s4[i].a16 += moa->s5[i].a17 + i;
}
int sample_size = 1000;
int sample_count = 1000;
for(int i = 0; i < sample_size; i++) {
moa->s5[i].a17 += moa->s5[i].a18 + i;
moa->s5[i].a18 += moa->s5[i].a19 + i;
moa->s5[i].a19 += moa->s5[i].a20 + i;
}
moa_many_for_fast.sample_time(start);
for(int i = 0; i < 100; i++) {
// quick and dirty "randomness"
if(i % 2 == 0) {
test_large_soa(samples, sample_size, sample_count);
test_large_struct(samples, sample_size, sample_count);
test_moa_style(samples, sample_count, sample_count);
} else if(i % 3 == 0) {
test_large_struct(samples, sample_size, sample_count);
test_large_soa(samples, sample_size, sample_count);
test_moa_style(samples, sample_count, sample_count);
} else {
test_moa_style(samples, sample_count, sample_count);
test_large_struct(samples, sample_size, sample_count);
test_large_soa(samples, sample_size, sample_count);
}
moa_many_for_fast.dump("moa many for");
fmt::println("-------------\n");
samples.moa_many_for_fast.push_back(moa_many_for_fast);
}
void test_soa_performance() {
Samples samples;
for(int i = 0; i < 10; i++) {
run_test(samples, 100, 100);
}
fmt::println("soa_bf soa_mf ls_bf ls_mf moa_bf moa_mf");
for(size_t i = 0; i < samples.soa_big_for.size(); i++) {
fmt::println("{:.2f} {:.2f} {:.2f} {:.2f}!={:.2f} {:.2f} {:.2f}!={:.2f}",
fmt::println("{:.2f} {:.2f} {:.2f} {:.2f} {:.2f} {:.2f}",
samples.soa_big_for[i].mean(),
samples.soa_many_for[i].mean(),
samples.ls_big_for[i].mean(),
samples.ls_many_for[i].mean(),
samples.ls_many_for_fast[i].mean(),
samples.moa_big_for[i].mean(),
samples.moa_many_for[i].mean(),
samples.moa_many_for_fast[i].mean());
samples.moa_many_for[i].mean());
}
}

Write Preview
Loading…
Cancel
Save