මෙන්න ඉතා සුවිශේෂී හැසිරීමක් පෙන්වන C ++ කේත කැබැල්ලක්. කිසියම් අමුතු හේතුවක් නිසා, දත්ත ආශ්චර්යමත් ලෙස වර්ග කිරීම මඟින් කේතය හය ගුණයකින් වේගවත් කරයි:
#include <algorithm>
#include <ctime>
#include <iostream>
int main()
{
// Generate data
const unsigned arraySize = 32768;
int data[arraySize];
for (unsigned c = 0; c < arraySize; ++c)
data[c] = std::rand() % 256;
// !!! With this, the next loop runs faster.
std::sort(data, data + arraySize);
// Test
clock_t start = clock();
long long sum = 0;
for (unsigned i = 0; i < 100000; ++i)
{
// Primary loop
for (unsigned c = 0; c < arraySize; ++c)
{
if (data[c] >= 128)
sum += data[c];
}
}
double elapsedTime = static_cast<double>(clock() - start) / CLOCKS_PER_SEC;
std::cout << elapsedTime << std::endl;
std::cout << "sum = " << sum << std::endl;
}- නොමැතිව
std::sort(data, data + arraySize);, කේතය තත්පර 11.54 කින් ධාවනය වේ. - වර්ග කළ දත්ත සමඟ කේතය තත්පර 1.93 කින් ක්රියාත්මක වේ.
මුලදී, මෙය හුදෙක් භාෂාවක් හෝ සම්පාදක විෂමතාවයක් විය හැකි යැයි මම සිතුවෙමි, එබැවින් මම ජාවා උත්සාහ කළෙමි:
import java.util.Arrays;
import java.util.Random;
public class Main
{
public static void main(String[] args)
{
// Generate data
int arraySize = 32768;
int data[] = new int[arraySize];
Random rnd = new Random(0);
for (int c = 0; c < arraySize; ++c)
data[c] = rnd.nextInt() % 256;
// !!! With this, the next loop runs faster
Arrays.sort(data);
// Test
long start = System.nanoTime();
long sum = 0;
for (int i = 0; i < 100000; ++i)
{
// Primary loop
for (int c = 0; c < arraySize; ++c)
{
if (data[c] >= 128)
sum += data[c];
}
}
System.out.println((System.nanoTime() - start) / 1000000000.0);
System.out.println("sum = " + sum);
}
}සමාන නමුත් අඩු ආන්තික ප්රති .ලයක් සමඟ.
මගේ පළමු සිතුවිල්ල වූයේ වර්ග කිරීම මඟින් දත්ත හැඹිලිය තුළට ගෙන එනු ඇති බවයි, නමුත් පසුව මම සිතුවේ අරාව ජනනය වී ඇති නිසා එය කෙතරම් මෝඩකමක්ද යන්නයි.
- මොනවද වෙන්නේ?
- වර්ගීකරණය කරන ලද අරාවක් සැකසීම, වර්ගීකරණය නොකළ අරාවක් සැකසීමට වඩා වේගවත් වන්නේ ඇයි?
කේතය සමහර ස්වාධීන යෙදුම් සාරාංශ කරයි, එබැවින් ඇණවුම වැදගත් නොවේ.
170
Woops ... re: Meltdown and Specter
—
KyleMit
Ach සචින්වර්මා මගේ හිස මුදුනේ සිට: 1) කොන්දේසි සහිත පියවරයන් භාවිතා කිරීමට තරම් ජේවීඑම් අවසානයේ දක්ෂ විය හැකිය. 2) කේතය මතකයෙන් බැඳී ඇත. 200M CPU හැඹිලියට සරිලන තරම් විශාලය. එබැවින් කාර්ය සාධනය අතු බෙදීම වෙනුවට මතක කලාප පළල මගින් බාධා කරනු ඇත.
—
අද්භූත
@ ගුප්ත, 2 ක් පමණ). මම සිතුවේ පුරෝකථන වගුව රටාවන් නිරීක්ෂණය කරයි (එම රටාව සඳහා පරීක්ෂා කරන ලද සත්‍ය විචල්යයන් නොසලකා) සහ ඉතිහාසය මත පදනම්ව පුරෝකථන ප්රතිදානය වෙනස් කරයි. කරුණාකර මට හේතුවක් දෙන්න, සුපිරි විශාල පෙළක් ශාඛා අනාවැකි වලින් ප්‍රයෝජන නොගන්නේ මන්ද?
—
සචින් වර්මා
Ach සචින්වර්මා එය සිදු කරයි, නමුත් අරාව එතරම් විශාල වූ විට ඊටත් වඩා විශාල සාධකයක් ක්රියාත්මක වේ - මතක කලාප පළල. මතකය සමතලා නොවේ . මතකයට ප්‍රවේශ වීම ඉතා මන්දගාමී වන අතර සීමිත කලාප පළලක් ඇත. දේවල් ඕනෑවට වඩා සරල කිරීම සඳහා, නිශ්චිත කාලයක් තුළ CPU සහ මතකය අතර මාරු කළ හැකි බයිට් විශාල ප්‍රමාණයක් ඇත. මෙම ප්‍රශ්නයේ ඇති කේතය වැනි සරල කේතය වැරදි අනාවැකි මගින් මන්දගාමී වුවද එම සීමාවට පැමිණෙනු ඇත. 32768 (128KB) පෙළක් සමඟ මෙය සිදු නොවේ, මන්ද එය CPU හි L2 හැඹිලියට ගැලපේ.
—
අද්භූත
BranchScope නමින් නව ආරක්ෂක දෝෂයක් තිබේ: cs.ucr.edu/~nael/pubs/asplos18.pdf
—
Veve
