সেটআপ করুন / এটি ধীর করে দিন
প্রথমত, প্রোগ্রামটি একই সময়ে নির্বিশেষে চলে:
sumspeed$ time ./sum_groups < groups_shuffled
11558358
real 0m0.705s
user 0m0.692s
sys 0m0.013s
sumspeed$ time ./sum_groups < groups_sorted
24986825
real 0m0.722s
user 0m0.711s
sys 0m0.012s
বেশিরভাগ সময় ইনপুট লুপে ব্যয় হয়। তবে যেহেতু আমরা এতে আগ্রহী তাই grouped_sum()আসুন এটিকে উপেক্ষা করুন।
10 থেকে 1000 পুনরাবৃত্তি থেকে বেঞ্চমার্ক লুপ পরিবর্তন করা, grouped_sum()রান সময়কে প্রাধান্য দেওয়া শুরু করে:
sumspeed$ time ./sum_groups < groups_shuffled
1131838420
real 0m1.828s
user 0m1.811s
sys 0m0.016s
sumspeed$ time ./sum_groups < groups_sorted
2494032110
real 0m3.189s
user 0m3.169s
sys 0m0.016s
পারফ ডিফ
এখন আমরা perfআমাদের প্রোগ্রামের হটেস্ট স্পটগুলি খুঁজতে ব্যবহার করতে পারি ।
sumspeed$ perf record ./sum_groups < groups_shuffled
1166805982
[ perf record: Woken up 1 times to write data ]
[kernel.kallsyms] with build id 3a2171019937a2070663f3b6419330223bd64e96 not found, continuing without symbols
Warning:
Processed 4636 samples and lost 6.95% samples!
[ perf record: Captured and wrote 0.176 MB perf.data (4314 samples) ]
sumspeed$ perf record ./sum_groups < groups_sorted
2571547832
[ perf record: Woken up 2 times to write data ]
[kernel.kallsyms] with build id 3a2171019937a2070663f3b6419330223bd64e96 not found, continuing without symbols
[ perf record: Captured and wrote 0.420 MB perf.data (10775 samples) ]
এবং তাদের মধ্যে পার্থক্য:
sumspeed$ perf diff
[...]
# Event 'cycles:uppp'
#
# Baseline Delta Abs Shared Object Symbol
# ........ ......... ................... ........................................................................
#
57.99% +26.33% sum_groups [.] main
12.10% -7.41% libc-2.23.so [.] _IO_getc
9.82% -6.40% libstdc++.so.6.0.21 [.] std::num_get<char, std::istreambuf_iterator<char, std::char_traits<c
6.45% -4.00% libc-2.23.so [.] _IO_ungetc
2.40% -1.32% libc-2.23.so [.] _IO_sputbackc
1.65% -1.21% libstdc++.so.6.0.21 [.] 0x00000000000dc4a4
1.57% -1.20% libc-2.23.so [.] _IO_fflush
1.71% -1.07% libstdc++.so.6.0.21 [.] std::istream::sentry::sentry
1.22% -0.77% libstdc++.so.6.0.21 [.] std::istream::operator>>
0.79% -0.47% libstdc++.so.6.0.21 [.] __gnu_cxx::stdio_sync_filebuf<char, std::char_traits<char> >::uflow
[...]
আরও সময় main(), যা সম্ভবত অন্তর্ভুক্ত করা হয়েছে grouped_sum()। দুর্দান্ত, অনেক ধন্যবাদ, পারফেক্ট।
পারফেক্ট টিকা
যেখানে ভিতরে সময় কাটানো আছে তার মধ্যে কোনও পার্থক্য আছেmain() ?
এলোমেলো:
sumspeed$ perf annotate -i perf.data.old
[...]
│ // This is the function whose performance I am interested in
│ void grouped_sum(int* p_x, int *p_g, int n, int* p_out) {
│ for (size_t i = 0; i < n; ++i) {
│180: xor %eax,%eax
│ test %rdi,%rdi
│ ↓ je 1a4
│ nop
│ p_out[p_g[i]] += p_x[i];
6,88 │190: movslq (%r9,%rax,4),%rdx
58,54 │ mov (%r8,%rax,4),%esi
│ #include <chrono>
│ #include <vector>
│
│ // This is the function whose performance I am interested in
│ void grouped_sum(int* p_x, int *p_g, int n, int* p_out) {
│ for (size_t i = 0; i < n; ++i) {
3,86 │ add $0x1,%rax
│ p_out[p_g[i]] += p_x[i];
29,61 │ add %esi,(%rcx,%rdx,4)
[...]
সাজানো:
sumspeed$ perf annotate -i perf.data
[...]
│ // This is the function whose performance I am interested in
│ void grouped_sum(int* p_x, int *p_g, int n, int* p_out) {
│ for (size_t i = 0; i < n; ++i) {
│180: xor %eax,%eax
│ test %rdi,%rdi
│ ↓ je 1a4
│ nop
│ p_out[p_g[i]] += p_x[i];
1,00 │190: movslq (%r9,%rax,4),%rdx
55,12 │ mov (%r8,%rax,4),%esi
│ #include <chrono>
│ #include <vector>
│
│ // This is the function whose performance I am interested in
│ void grouped_sum(int* p_x, int *p_g, int n, int* p_out) {
│ for (size_t i = 0; i < n; ++i) {
0,07 │ add $0x1,%rax
│ p_out[p_g[i]] += p_x[i];
43,28 │ add %esi,(%rcx,%rdx,4)
[...]
না, এটি একই দুটি নির্দেশকে প্রাধান্য দেয়। সুতরাং তারা উভয় ক্ষেত্রেই দীর্ঘ সময় নেয়, তবে ডেটা বাছাই করার সময় আরও খারাপ হয়।
পারফেক্ট স্ট্যাটাস
ঠিক আছে. তবে আমাদের এগুলি একই সংখ্যক বার চালানো উচিত, তাই প্রতিটি নির্দেশ অবশ্যই কোনও কারণে ধীর হতে চলেছে। দেখা যাক কী perf statবলে।
sumspeed$ perf stat ./sum_groups < groups_shuffled
1138880176
Performance counter stats for './sum_groups':
1826,232278 task-clock (msec) # 0,999 CPUs utilized
72 context-switches # 0,039 K/sec
1 cpu-migrations # 0,001 K/sec
4 076 page-faults # 0,002 M/sec
5 403 949 695 cycles # 2,959 GHz
930 473 671 stalled-cycles-frontend # 17,22% frontend cycles idle
9 827 685 690 instructions # 1,82 insn per cycle
# 0,09 stalled cycles per insn
2 086 725 079 branches # 1142,639 M/sec
2 069 655 branch-misses # 0,10% of all branches
1,828334373 seconds time elapsed
sumspeed$ perf stat ./sum_groups < groups_sorted
2496546045
Performance counter stats for './sum_groups':
3186,100661 task-clock (msec) # 1,000 CPUs utilized
5 context-switches # 0,002 K/sec
0 cpu-migrations # 0,000 K/sec
4 079 page-faults # 0,001 M/sec
9 424 565 623 cycles # 2,958 GHz
4 955 937 177 stalled-cycles-frontend # 52,59% frontend cycles idle
9 829 009 511 instructions # 1,04 insn per cycle
# 0,50 stalled cycles per insn
2 086 942 109 branches # 655,014 M/sec
2 078 204 branch-misses # 0,10% of all branches
3,186768174 seconds time elapsed
কেবল একটি জিনিস দাঁড়িয়ে আছে: স্থবির-চক্র-সম্মুখভাগ ।
ঠিক আছে, নির্দেশ পাইপলাইন স্টল হচ্ছে। সীমান্তে। ঠিক কী এর অর্থ সম্ভবত মাইক্রোয়ারিকটেকচারের মধ্যে পরিবর্তিত হয়।
যদিও আমার একটা ধারণা আছে। আপনি যদি উদার হন তবে আপনি এটিকে একটি অনুমানও বলতে পারেন।
অনুমান
ইনপুটটি বাছাই করে আপনি লেখকের লোকাল বাড়িয়ে তুলছেন। আসলে, তারা খুব স্থানীয় হবে; আপনি প্রায় সমস্ত সংযোজন পূর্ববর্তীটির মতো একই স্থানে লিখবেন।
এটি ক্যাশের পক্ষে দুর্দান্ত তবে পাইপলাইনের জন্য দুর্দান্ত নয়। আপনি পূর্বের সংযোজনটি শেষ না হওয়া অবধি পরবর্তী সংযোজন নির্দেশগুলি এগিয়ে যাওয়া থেকে বাধা প্রদান করে ডেটা নির্ভরতা প্রবর্তন করছেন (বা অন্যথায় ফলাফলটি সফল নির্দেশাবলীতে উপলভ্য করেছেন )
সেটাই তোমার সমস্যা.
আমি মনে করি.
এটা ঠিক করা
একাধিক যোগ ভেক্টর
আসলে, কিছু চেষ্টা করা যাক। যদি আমরা একাধিক সংখ্যক ভেক্টর ব্যবহার করি, প্রতিটি সংযোজনের জন্য তাদের মধ্যে স্যুইচিং করি এবং তারপরে শেষে তাদের সংক্ষিপ্তকরণ করি? এটি আমাদের সামান্য লোকাল ব্যয় করে তবে ডেটা নির্ভরতা অপসারণ করা উচিত।
(কোডটি সুন্দর নয়; আমাকে বিচার করবেন না, ইন্টারনেট !!)
#include <iostream>
#include <chrono>
#include <vector>
#ifndef NSUMS
#define NSUMS (4) // must be power of 2 (for masking to work)
#endif
// This is the function whose performance I am interested in
void grouped_sum(int* p_x, int *p_g, int n, int** p_out) {
for (size_t i = 0; i < n; ++i) {
p_out[i & (NSUMS-1)][p_g[i]] += p_x[i];
}
}
int main() {
std::vector<int> values;
std::vector<int> groups;
std::vector<int> sums[NSUMS];
int n_groups = 0;
// Read in the values and calculate the max number of groups
while(std::cin) {
int value, group;
std::cin >> value >> group;
values.push_back(value);
groups.push_back(group);
if (group >= n_groups) {
n_groups = group+1;
}
}
for (int i=0; i<NSUMS; ++i) {
sums[i].resize(n_groups);
}
// Time grouped sums
std::chrono::system_clock::time_point start = std::chrono::system_clock::now();
int* sumdata[NSUMS];
for (int i = 0; i < NSUMS; ++i) {
sumdata[i] = sums[i].data();
}
for (int i = 0; i < 1000; ++i) {
grouped_sum(values.data(), groups.data(), values.size(), sumdata);
}
for (int i = 1; i < NSUMS; ++i) {
for (int j = 0; j < n_groups; ++j) {
sumdata[0][j] += sumdata[i][j];
}
}
std::chrono::system_clock::time_point end = std::chrono::system_clock::now();
std::cout << (end - start).count() << " with NSUMS=" << NSUMS << std::endl;
return 0;
}
(ওহ, এবং আমি n_ গোষ্ঠী গণনাও স্থির করেছি; এটি একের পরে বন্ধ ছিল))
ফলাফল
সংকলকটিতে একটি -DNSUMS=...আর্গ দিতে আমার মেকফিলটি কনফিগার করার পরে , আমি এটি করতে পারলাম:
sumspeed$ for n in 1 2 4 8 128; do make -s clean && make -s NSUMS=$n && (perf stat ./sum_groups < groups_shuffled && perf stat ./sum_groups < groups_sorted) 2>&1 | egrep '^[0-9]|frontend'; done
1134557008 with NSUMS=1
924 611 882 stalled-cycles-frontend # 17,13% frontend cycles idle
2513696351 with NSUMS=1
4 998 203 130 stalled-cycles-frontend # 52,79% frontend cycles idle
1116188582 with NSUMS=2
899 339 154 stalled-cycles-frontend # 16,83% frontend cycles idle
1365673326 with NSUMS=2
1 845 914 269 stalled-cycles-frontend # 29,97% frontend cycles idle
1127172852 with NSUMS=4
902 964 410 stalled-cycles-frontend # 16,79% frontend cycles idle
1171849032 with NSUMS=4
1 007 807 580 stalled-cycles-frontend # 18,29% frontend cycles idle
1118732934 with NSUMS=8
881 371 176 stalled-cycles-frontend # 16,46% frontend cycles idle
1129842892 with NSUMS=8
905 473 182 stalled-cycles-frontend # 16,80% frontend cycles idle
1497803734 with NSUMS=128
1 982 652 954 stalled-cycles-frontend # 30,63% frontend cycles idle
1180742299 with NSUMS=128
1 075 507 514 stalled-cycles-frontend # 19,39% frontend cycles idle
সমষ্টি ভেক্টরের অনুকূল সংখ্যা সম্ভবত আপনার সিপিইউর পাইপলাইন গভীরতার উপর নির্ভর করবে। আমার 7 বছর বয়সী আল্ট্রাবুক সিপিইউ সম্ভবত নতুন অভিনব ডেস্কটপ সিপিইউর চেয়ে কম ভেক্টরগুলির সাথে পাইপলাইনটি সর্বাধিক বের করতে পারে।
স্পষ্টতই, আরও ভাল প্রয়োজন হয় না; যখন আমি 128 রাশির ভেক্টরগুলির সাথে পাগল হয়েছি, তখন আমরা ক্যাশে মিসগুলি থেকে বেশি ভোগতে শুরু করি - যেমনটি আপনি প্রত্যাশা করেছিলেন ঠিক যেমন বদলে যাওয়া ইনপুটটি বাছাইয়ের চেয়ে ধীর হয়ে উঠছে d আমরা পুরো বৃত্ত এসেছি! :)
রেজিস্টারে প্রতি গ্রুপের যোগফল
(এটি একটি সম্পাদনায় যুক্ত করা হয়েছিল)
আঃ, অহংকার স্নিপড ! আপনি যদি জানেন যে আপনার ইনপুটটি সাজানো হবে এবং আরও বেশি পারফরম্যান্সের সন্ধান করছেন, কমপক্ষে আমার কম্পিউটারে ফাংশনটির নিম্নলিখিত পুনর্লিখন (অতিরিক্ত অতিরিক্ত বিনা ব্যতীত) আরও দ্রুত।
// This is the function whose performance I am interested in
void grouped_sum(int* p_x, int *p_g, int n, int* p_out) {
int i = n-1;
while (i >= 0) {
int g = p_g[i];
int gsum = 0;
do {
gsum += p_x[i--];
} while (i >= 0 && p_g[i] == g);
p_out[g] += gsum;
}
}
এইটির মধ্যে কৌশলটি হ'ল এটি কম্পাইলারটিকে gsumভেরিয়েবল, গোষ্ঠীর যোগফলকে একটি রেজিস্টারে রাখার অনুমতি দেয়। আমি অনুমান করছি (তবে খুব ভুল হতে পারে) এটি দ্রুততর কারণ পাইপলাইনের প্রতিক্রিয়া লুপটি এখানে সংক্ষিপ্ত হতে পারে এবং / অথবা কম মেমোরি অ্যাক্সেস করতে পারে। একটি ভাল শাখার ভবিষ্যদ্বাণীকারী গ্রুপ সমতার জন্য অতিরিক্ত চেক তৈরি করবে।
ফলাফল
এলোমেলো ইনপুট জন্য এটি ভয়ানক ...
sumspeed$ time ./sum_groups < groups_shuffled
2236354315
real 0m2.932s
user 0m2.923s
sys 0m0.009s
... তবে সাজানো ইনপুটটির জন্য আমার "বহু অঙ্কের" সমাধানের চেয়ে প্রায় 40% দ্রুত।
sumspeed$ time ./sum_groups < groups_sorted
809694018
real 0m1.501s
user 0m1.496s
sys 0m0.005s
ছোট ছোট দলের প্রচুর কয়েক বড় বেশী তুলনায় ধীর হবে, সুতরাং হোক বা না হোক এই দ্রুত বাস্তবায়ন হবে হয় সত্যিই এখানে আপনার ডেটা উপর নির্ভর করে। এবং, সর্বদা হিসাবে, আপনার সিপিইউ মডেল।
বিট মাস্কিংয়ের পরিবর্তে অফসেট সহ একাধিক অঙ্কের ভেক্টর
সোপেল আমার বিট মাস্কিং পদ্ধতির বিকল্প হিসাবে চারটি অনিবন্ধিত সংযোজন প্রস্তাবিত। আমি তাদের পরামর্শের একটি সাধারণ সংস্করণ প্রয়োগ করেছি, যা বিভিন্নরকম পরিচালনা করতে পারে NSUMS। আমি আমাদের জন্য অভ্যন্তরীণ লুপটি আনরোলিং করে সংকলকটিতে গণনা করছি (এটি কমপক্ষে এটির জন্য হয়েছিল NSUMS=4)।
#include <iostream>
#include <chrono>
#include <vector>
#ifndef NSUMS
#define NSUMS (4) // must be power of 2 (for masking to work)
#endif
#ifndef INNER
#define INNER (0)
#endif
#if INNER
// This is the function whose performance I am interested in
void grouped_sum(int* p_x, int *p_g, int n, int** p_out) {
size_t i = 0;
int quadend = n & ~(NSUMS-1);
for (; i < quadend; i += NSUMS) {
for (int k=0; k<NSUMS; ++k) {
p_out[k][p_g[i+k]] += p_x[i+k];
}
}
for (; i < n; ++i) {
p_out[0][p_g[i]] += p_x[i];
}
}
#else
// This is the function whose performance I am interested in
void grouped_sum(int* p_x, int *p_g, int n, int** p_out) {
for (size_t i = 0; i < n; ++i) {
p_out[i & (NSUMS-1)][p_g[i]] += p_x[i];
}
}
#endif
int main() {
std::vector<int> values;
std::vector<int> groups;
std::vector<int> sums[NSUMS];
int n_groups = 0;
// Read in the values and calculate the max number of groups
while(std::cin) {
int value, group;
std::cin >> value >> group;
values.push_back(value);
groups.push_back(group);
if (group >= n_groups) {
n_groups = group+1;
}
}
for (int i=0; i<NSUMS; ++i) {
sums[i].resize(n_groups);
}
// Time grouped sums
std::chrono::system_clock::time_point start = std::chrono::system_clock::now();
int* sumdata[NSUMS];
for (int i = 0; i < NSUMS; ++i) {
sumdata[i] = sums[i].data();
}
for (int i = 0; i < 1000; ++i) {
grouped_sum(values.data(), groups.data(), values.size(), sumdata);
}
for (int i = 1; i < NSUMS; ++i) {
for (int j = 0; j < n_groups; ++j) {
sumdata[0][j] += sumdata[i][j];
}
}
std::chrono::system_clock::time_point end = std::chrono::system_clock::now();
std::cout << (end - start).count() << " with NSUMS=" << NSUMS << ", INNER=" << INNER << std::endl;
return 0;
}
ফলাফল
সময় পরিমাপ। নোট করুন যেহেতু আমি গতকাল / টেম্পে কাজ করছিলাম, আমার কাছে ঠিক একই ইনপুট ডেটা নেই। অতএব, এই ফলাফলগুলি পূর্ববর্তীগুলির সাথে সরাসরি তুলনামূলক নয় (তবে সম্ভবত যথেষ্ট নিকটবর্তী)।
sumspeed$ for n in 2 4 8 16; do for inner in 0 1; do make -s clean && make -s NSUMS=$n INNER=$inner && (perf stat ./sum_groups < groups_shuffled && perf stat ./sum_groups < groups_sorted) 2>&1 | egrep '^[0-9]|frontend'; done; done1130558787 with NSUMS=2, INNER=0
915 158 411 stalled-cycles-frontend # 16,96% frontend cycles idle
1351420957 with NSUMS=2, INNER=0
1 589 408 901 stalled-cycles-frontend # 26,21% frontend cycles idle
840071512 with NSUMS=2, INNER=1
1 053 982 259 stalled-cycles-frontend # 23,26% frontend cycles idle
1391591981 with NSUMS=2, INNER=1
2 830 348 854 stalled-cycles-frontend # 45,35% frontend cycles idle
1110302654 with NSUMS=4, INNER=0
890 869 892 stalled-cycles-frontend # 16,68% frontend cycles idle
1145175062 with NSUMS=4, INNER=0
948 879 882 stalled-cycles-frontend # 17,40% frontend cycles idle
822954895 with NSUMS=4, INNER=1
1 253 110 503 stalled-cycles-frontend # 28,01% frontend cycles idle
929548505 with NSUMS=4, INNER=1
1 422 753 793 stalled-cycles-frontend # 30,32% frontend cycles idle
1128735412 with NSUMS=8, INNER=0
921 158 397 stalled-cycles-frontend # 17,13% frontend cycles idle
1120606464 with NSUMS=8, INNER=0
891 960 711 stalled-cycles-frontend # 16,59% frontend cycles idle
800789776 with NSUMS=8, INNER=1
1 204 516 303 stalled-cycles-frontend # 27,25% frontend cycles idle
805223528 with NSUMS=8, INNER=1
1 222 383 317 stalled-cycles-frontend # 27,52% frontend cycles idle
1121644613 with NSUMS=16, INNER=0
886 781 824 stalled-cycles-frontend # 16,54% frontend cycles idle
1108977946 with NSUMS=16, INNER=0
860 600 975 stalled-cycles-frontend # 16,13% frontend cycles idle
911365998 with NSUMS=16, INNER=1
1 494 671 476 stalled-cycles-frontend # 31,54% frontend cycles idle
898729229 with NSUMS=16, INNER=1
1 474 745 548 stalled-cycles-frontend # 31,24% frontend cycles idle
হ্যাঁ, এর সাথে অভ্যন্তরীণ লুপটি NSUMS=8আমার কম্পিউটারে সবচেয়ে দ্রুত। আমার "স্থানীয় জিসম" পদ্ধতির সাথে তুলনা করে, এটিকে বদলে যাওয়া ইনপুটটির জন্য ভয়ঙ্কর না হওয়ার অতিরিক্ত সুবিধাও রয়েছে।
আকর্ষণীয় লক্ষণীয়: এর NSUMS=16চেয়ে খারাপ হয়ে যায় NSUMS=8। এর কারণ হ'ল আমরা আরও ক্যাশে মিস করতে শুরু করেছি, বা আমাদের অভ্যন্তরীণ লুপটি সঠিকভাবে আনরোল করার জন্য পর্যাপ্ত রেজিস্টর নেই।
.at()বা একটি ডিবাগ মোডoperator[]যা সীমাবদ্ধ করে আপনি দেখতে চাইছেন পরীক্ষা।