क्या L2 HW प्रीफ़ेचर वास्तव में मददगार है?


10

मैं व्हिस्की लेक i7-8565U पर हूं और 512 काउंटर डेटा (L2 कैश आकार से दोगुना अधिक) की प्रतिलिपि बनाने के लिए सही काउंटरों और समय का विश्लेषण कर रहा हूं और L2 HW प्रीफेचर के काम के बारे में कुछ गलतफहमी का सामना करना पड़ा।

में इंटेल मैनुअल Vol.4 MSR वहाँ MSR है 0x1A4बिट 0 (अक्षम करने के लिए 1) एल 2 HW prefetcher controlloing के लिए है की।


निम्नलिखित बेंचमार्क पर विचार करें:

memcopy.h:

void *avx_memcpy_forward_lsls(void *restrict, const void *restrict, size_t);

memcopy.S:

avx_memcpy_forward_lsls:
    shr rdx, 0x3
    xor rcx, rcx
avx_memcpy_forward_loop_lsls:
    vmovdqa ymm0, [rsi + 8*rcx]
    vmovdqa [rdi + rcx*8], ymm0
    vmovdqa ymm1, [rsi + 8*rcx + 0x20]
    vmovdqa [rdi + rcx*8 + 0x20], ymm1
    add rcx, 0x08
    cmp rdx, rcx
    ja avx_memcpy_forward_loop_lsls
    ret

main.c:

#include <string.h>
#include <stdlib.h>
#include <inttypes.h>
#include <x86intrin.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include "memcopy.h"

#define ITERATIONS 1000
#define BUF_SIZE 512 * 1024

_Alignas(64) char src[BUF_SIZE];
_Alignas(64) char dest[BUF_SIZE];

static void __run_benchmark(unsigned runs, unsigned run_iterations,
                    void *(*fn)(void *, const void*, size_t), void *dest, const void* src, size_t sz);

#define run_benchmark(runs, run_iterations, fn, dest, src, sz) \
    do{\
        printf("Benchmarking " #fn "\n");\
        __run_benchmark(runs, run_iterations, fn, dest, src, sz);\
    }while(0)

int main(void){
    int fd = open("/dev/urandom", O_RDONLY);
    read(fd, src, sizeof src);
    run_benchmark(20, ITERATIONS, avx_memcpy_forward_lsls, dest, src, BUF_SIZE);
}

static inline void benchmark_copy_function(unsigned iterations, void *(*fn)(void *, const void *, size_t),
                                               void *restrict dest, const void *restrict src, size_t sz){
    while(iterations --> 0){
        fn(dest, src, sz);
        fn(dest, src, sz);
        fn(dest, src, sz);
        fn(dest, src, sz);
        fn(dest, src, sz);
        fn(dest, src, sz);
        fn(dest, src, sz);
        fn(dest, src, sz);
        fn(dest, src, sz);
        fn(dest, src, sz);
        fn(dest, src, sz);
        fn(dest, src, sz);
        fn(dest, src, sz);
        fn(dest, src, sz);
        fn(dest, src, sz);
        fn(dest, src, sz);
        fn(dest, src, sz);
        fn(dest, src, sz);
        fn(dest, src, sz);
        fn(dest, src, sz);
        fn(dest, src, sz);
        fn(dest, src, sz);
        fn(dest, src, sz);
        fn(dest, src, sz);
        fn(dest, src, sz);
        fn(dest, src, sz);
        fn(dest, src, sz);
        fn(dest, src, sz);
        fn(dest, src, sz);
        fn(dest, src, sz);
        fn(dest, src, sz);
        fn(dest, src, sz);
    }
}

static void __run_benchmark(unsigned runs, unsigned run_iterations,
                    void *(*fn)(void *, const void*, size_t), void *dest, const void* src, size_t sz){
    unsigned current_run = 1;
    while(current_run <= runs){
        benchmark_copy_function(run_iterations, fn, dest, src, sz);
        printf("Run %d finished\n", current_run);
        current_run++;
    }
}

संकलित के 2 रन पर विचार करें main.c

मैं ।

MSR:

$ sudo rdmsr -p 0 0x1A4
0

Run:

$ taskset -c 0 sudo ../profile.sh ./bin 

 Performance counter stats for './bin':

    10 486 164 071      L1-dcache-loads                                               (12,13%)
    10 461 354 384      L1-dcache-load-misses     #   99,76% of all L1-dcache hits    (12,05%)
    10 481 930 413      L1-dcache-stores                                              (12,05%)
    10 461 136 686      l1d.replacement                                               (12,12%)
    31 466 394 422      l1d_pend_miss.fb_full                                         (12,11%)
   211 853 643 294      l1d_pend_miss.pending                                         (12,09%)
     1 759 204 317      LLC-loads                                                     (12,16%)
            31 007      LLC-load-misses           #    0,00% of all LL-cache hits     (12,16%)
     3 154 901 630      LLC-stores                                                    (6,19%)
    15 867 315 545      l2_rqsts.all_pf                                               (9,22%)
                 0      sw_prefetch_access.t1_t2                                      (12,22%)
         1 393 306      l2_lines_out.useless_hwpf                                     (12,16%)
     3 549 170 919      l2_rqsts.pf_hit                                               (12,09%)
    12 356 247 643      l2_rqsts.pf_miss                                              (12,06%)
                 0      load_hit_pre.sw_pf                                            (12,09%)
     3 159 712 695      l2_rqsts.rfo_hit                                              (12,06%)
     1 207 642 335      l2_rqsts.rfo_miss                                             (12,02%)
     4 366 526 618      l2_rqsts.all_rfo                                              (12,06%)
     5 240 013 774      offcore_requests.all_data_rd                                     (12,06%)
    19 936 657 118      offcore_requests.all_requests                                     (12,09%)
     1 761 660 763      offcore_response.demand_data_rd.any_response                                     (12,12%)
       287 044 397      bus-cycles                                                    (12,15%)
    36 816 767 779      resource_stalls.any                                           (12,15%)
    36 553 997 653      resource_stalls.sb                                            (12,15%)
    38 035 066 210      uops_retired.stall_cycles                                     (12,12%)
    24 766 225 119      uops_executed.stall_cycles                                     (12,09%)
    40 478 455 041      uops_issued.stall_cycles                                      (12,05%)
    24 497 256 548      cycle_activity.stalls_l1d_miss                                     (12,02%)
    12 611 038 018      cycle_activity.stalls_l2_miss                                     (12,09%)
        10 228 869      cycle_activity.stalls_l3_miss                                     (12,12%)
    24 707 614 483      cycle_activity.stalls_mem_any                                     (12,22%)
    24 776 110 104      cycle_activity.stalls_total                                     (12,22%)
    48 914 478 241      cycles                                                        (12,19%)

      12,155774555 seconds time elapsed

      11,984577000 seconds user
       0,015984000 seconds sys

द्वितीय।

MSR:

$ sudo rdmsr -p 0 0x1A4
1

Run:

$ taskset -c 0 sudo ../profile.sh ./bin

 Performance counter stats for './bin':

    10 508 027 832      L1-dcache-loads                                               (12,05%)
    10 463 643 206      L1-dcache-load-misses     #   99,58% of all L1-dcache hits    (12,09%)
    10 481 296 605      L1-dcache-stores                                              (12,12%)
    10 444 854 468      l1d.replacement                                               (12,15%)
    29 287 445 744      l1d_pend_miss.fb_full                                         (12,17%)
   205 569 630 707      l1d_pend_miss.pending                                         (12,17%)
     5 103 444 329      LLC-loads                                                     (12,17%)
            33 406      LLC-load-misses           #    0,00% of all LL-cache hits     (12,17%)
     9 567 917 742      LLC-stores                                                    (6,08%)
     1 157 237 980      l2_rqsts.all_pf                                               (9,12%)
                 0      sw_prefetch_access.t1_t2                                      (12,17%)
           301 471      l2_lines_out.useless_hwpf                                     (12,17%)
       218 528 985      l2_rqsts.pf_hit                                               (12,17%)
       938 735 722      l2_rqsts.pf_miss                                              (12,17%)
                 0      load_hit_pre.sw_pf                                            (12,17%)
         4 096 281      l2_rqsts.rfo_hit                                              (12,17%)
     4 972 640 931      l2_rqsts.rfo_miss                                             (12,17%)
     4 976 006 805      l2_rqsts.all_rfo                                              (12,17%)
     5 175 544 191      offcore_requests.all_data_rd                                     (12,17%)
    15 772 124 082      offcore_requests.all_requests                                     (12,17%)
     5 120 635 892      offcore_response.demand_data_rd.any_response                                     (12,17%)
       292 980 395      bus-cycles                                                    (12,17%)
    37 592 020 151      resource_stalls.any                                           (12,14%)
    37 317 091 982      resource_stalls.sb                                            (12,11%)
    38 121 826 730      uops_retired.stall_cycles                                     (12,08%)
    25 430 699 605      uops_executed.stall_cycles                                     (12,04%)
    41 416 190 037      uops_issued.stall_cycles                                      (12,04%)
    25 326 579 070      cycle_activity.stalls_l1d_miss                                     (12,04%)
    25 019 148 253      cycle_activity.stalls_l2_miss                                     (12,03%)
         7 384 770      cycle_activity.stalls_l3_miss                                     (12,03%)
    25 442 709 033      cycle_activity.stalls_mem_any                                     (12,03%)
    25 406 897 956      cycle_activity.stalls_total                                     (12,03%)
    49 877 044 086      cycles                                                        (12,03%)

      12,231406658 seconds time elapsed

      12,226386000 seconds user
       0,004000000 seconds sys

मैंने काउंटर देखा:

12 611 038 018 cycle_activity.stalls_l2_miss v / s
25 019 148 253 cycle_activity.stalls_l2_miss

यह सुझाव देते हुए कि L2 HW प्रीफ़ैचर को अक्षम करने वाला MSR लागू किया जा रहा है। इसके अलावा अन्य एल 2 / एलएलसी संबंधित सामान में काफी भिन्नता है। अंतर अलग-अलग रनों में प्रतिलिपि प्रस्तुत करने योग्य है । समस्या यह है कि total timeचक्र और चक्र में लगभग कोई अंतर नहीं है:

48 914 478 241 cycles v / s
49 877 044 086 cycles

12,155774555 seconds time elapsed v / s
12,231406658 seconds time elapsed

प्रश्न:
क्या L2 अन्य प्रदर्शन सीमाओं द्वारा छिपा हुआ है?
यदि हां, तो क्या आप सुझाव दे सकते हैं कि इसे समझने के लिए काउंटरों को क्या देखना है?


4
अंगूठे के एक नियम के रूप में: किसी भी गैर-अप्राकृतिक रूप से लागू मेमोरी कॉपी मेमोरी बाउंड है। यहां तक ​​कि जब यह केवल L1 कैश हिट करता है। किसी भी मेमोरी एक्सेस के ओवरहेड्स केवल एक सीपीयू को दो और दो को एक साथ जोड़ने की तुलना में बहुत अधिक होते हैं। आपके मामले में, आप प्रति कॉपी बाइट के निर्देशों की मात्रा को कम करने के लिए AVX निर्देशों का उपयोग कर रहे हैं। जहां भी आपका डेटा पाया जाता है (L1, L2, LLC, मेमोरी), संबंधित मेमोरी घटक का थ्रूपुट आपकी अड़चन होगी।
— विस्फ़ोटक - मोनिका

जवाबों:


5

हां, L2 स्ट्रीमर वास्तव में बहुत समय के लिए सहायक है।

मेम्पी को छिपाने के लिए कोई कम्प्यूटेशनल विलंबता नहीं है, इसलिए मुझे लगता है कि यह ओओओ निष्पादन संसाधनों (आरओबी आकार) को वहन करने में सक्षम हो सकता है जो आपको अतिरिक्त एल 2 मिस ​​से प्राप्त अतिरिक्त लोड विलंबता को संभालता है, कम से कम इस मामले में जहां आपको सभी 3 हिट मिलते हैं मध्यम आकार के वर्किंग सेट (1MiB) का उपयोग करना जो कि L3 में फिट बैठता है, L3 हिट होने के लिए किसी भी पूर्व-निर्धारण की आवश्यकता नहीं है।

और केवल निर्देश लोड / स्टोर (और लूप ओवरहेड) हैं, इसलिए ओओओ विंडो में बहुत आगे तक मांग भार शामिल है।

IDK अगर L2 स्थानिक प्रीफ़ेचर और L1d प्रीफ़ेचर यहाँ कोई मदद कर रहे हैं।


इस परिकल्पना का परीक्षण करने की भविष्यवाणी : अपने सरणी को बड़ा करें ताकि आपको L3 की याद आती है और आपको संभवतः समग्र समय में अंतर दिखाई देगा एक बार जब ओओओ निष्पादन DRAM के सभी रास्ते जाने के लोड विलंब को छिपाने के लिए पर्याप्त नहीं है। आगे से एचजी प्रीफैच ट्रिगरिंग से कुछ मदद मिल सकती है।

HW प्रीफेचिंग के अन्य बड़े लाभ तब आते हैं जब यह कर सकता है अपने गणना के साथ बनाए रखने, तो आप एल 2 हिट मिल। (एक लूप में जिसमें मध्यम-लंबाई के साथ संगणना होती है, लेकिन लूप-आधारित निर्भरता श्रृंखला नहीं होती है।)

जब तक ROB क्षमता पर कोई अन्य दबाव न हो तब तक उपलब्ध (सिंगल थ्रेडेड) मेमोरी बैंडविड्थ का उपयोग करते हुए डिमांड लोड और OoO एक्ज़िकशन बहुत कुछ कर सकते हैं।


यह भी ध्यान दें कि इंटेल सीपीयू पर, हर कैश मिस पर निर्भर यूओपी के बैक-एंड रीप्ले (आरएस / शेड्यूलर से) खर्च हो सकता है , एल 1 डी और एल 2 में से एक के लिए जब डेटा आने की उम्मीद होती है। और उसके बाद, स्पष्ट रूप से कोर आशावादी रूप से यू 3 से आने के लिए डेटा की प्रतीक्षा करते हुए सबसे ऊपर है।

(देखें https://chat.stackoverflow.com/rooms/206639/discussion-on-question-by-beeonrope-are-load-ops-deallocated-from-the-rs-when-th और इनसे लोड किए गए ऑप्स लोड किए गए हैं रुपये जब वे प्रेषण, पूरा या कुछ अन्य समय? )

कैश-मिस लोड ही नहीं; इस मामले में यह स्टोर के निर्देश होंगे। अधिक विशेष रूप से, पोर्ट 4 के लिए स्टोर-डेटा यूओपी 4. यहां कोई फर्क नहीं पड़ता; 32-बाइट स्टोर और L3 बैंडविड्थ पर अड़चन का उपयोग करने का मतलब है कि हम प्रति घड़ी 1 पोर्ट 4 यूओपी के करीब नहीं हैं।


2
@ सेंटअनारियो: हुह? इसका कोई अर्थ नही बन रहा है; आप स्मृति-बद्ध हैं, इसलिए आपके पास फ्रंट-एंड टोंटी नहीं है, इसलिए LSD अप्रासंगिक है। (यह यूओपी कैश से उन्हें पुनः प्राप्त करने से बचता है, कुछ शक्ति की बचत करता है)। वे अभी भी आरओबी में जगह लेते हैं जब तक कि वे सेवानिवृत्त नहीं हो जाते। वे नहीं कर रहे हैं कि महत्वपूर्ण है, लेकिन नहीं नगण्य या तो।
— पीटर कॉर्ड्स

2
अपने एरे को बड़ा करें ताकि आपको L3 की याद आती है और आपको शायद एक अंतर दिखाई देगा, मैंने 16MiBबफर और 10पुनरावृत्तियों के साथ कई परीक्षण किए और वास्तव में 14,186868883 secondsबनाम 43,731360909 secondsऔर 46,76% of all LL-cache hitsबनाम मिला 99,32% of all LL-cache hits; 1 028 664 372 LLC-loadsबनाम 1 587 454 298 LLC-loads ।
— सेंटऑनारियो

4
@ सेंटअनारियो: रजिस्टर नामकरण द्वारा! यह ओओओ निष्पादन के सबसे प्रमुख टुकड़ों में से एक है, विशेष रूप से x86 जैसे रजिस्टर-खराब आईएसए पर। देखें कि एगनर के निर्देश तालिकाओं से अलग, हवेलवेल पर केवल 3 चक्र क्यों लगते हैं? (कई संचयकों के साथ एफपी छोरों को अनियंत्रित करना) । और BTW, आम तौर पर आप 2 लोड करना चाहते हैं तो 2 स्टोर, लोड / स्टोर लोड / स्टोर नहीं। 4k अलियासिंग स्टालों से बचने या कम करने का बेहतर मौका क्योंकि बाद में लोड (जिसे एचडब्ल्यू को पिछली दुकानों को ओवरलैप करने के रूप में पता लगाना है या नहीं) दूर हैं।
— पीटर कोर्ड्स

2
@ सेंटअनारियो: हाँ, बिल्कुल। Agner Fog का ऑप्टिमाइज़ेशन गाइड OOO को रजिस्टर नाम बदलने के साथ ही समझाता है, इसलिए विकिपीडिया करता है। BTW, रजिस्टर नामकरण भी WAW खतरों से बचा जाता है, केवल सच्ची निर्भरता (RAW) को छोड़कर। तो लोड भी एक ही वास्तुशिल्प रजिस्टर लिखने के लिए पिछले लोड के लिए इंतजार किए बिना, आदेश से पूरा कर सकते हैं । और हां, केवल लूप-एंग डिप चेन आरसीएक्स के माध्यम से है, ताकि चेन आगे चल सके। इसीलिए पते जल्दी तैयार हो सकते हैं, जबकि लोड / स्टोर यूओपी अभी भी पोर्ट 2/3 थ्रूपुट पर अड़चन हैं।
— पीटर कोर्ड्स

3
मुझे आश्चर्य है कि प्रीफ़ेटिंग ने L3 में मेम्ची के लिए मदद नहीं की। मुझे लगता है कि 10/12 LFBs उस मामले में "पर्याप्त" है। हालांकि अजीब लगता है: वहाँ सीमित कारक क्या है? कोर -> L2 का समय L2 -> L3 समय से कम होना चाहिए, इसलिए मेरे मानसिक मॉडल में दूसरे पैर के लिए अधिक बफ़र्स (अधिक कुल अधिभोग) होने चाहिए।
— BeeOnRope

3

हाँ, L2 HW प्रीफ़ेचर बहुत मददगार है!

उदाहरण के लिए, मेरी मशीन (i7-6700HQ) पर चलने वाले टिनिंबेनेच पर परिणाम देखें । परिणामों का पहला कॉलम सभी प्रीफैचर्स पर है, दूसरा परिणाम कॉलम एल 2 स्ट्रीमर ऑफ (लेकिन अन्य सभी प्रीफैचर्स अभी भी) के साथ है।

इस परीक्षण में 32 MiB स्रोत और गंतव्य बफ़र्स का उपयोग किया गया है, जो मेरी मशीन पर L3 की तुलना में बहुत बड़ा है, इसलिए यह DRAM के लिए अधिकतर मिसाइलों का परीक्षण करेगा।

==========================================================================
== Memory bandwidth tests                                               ==
==                                                                      ==
== Note 1: 1MB = 1000000 bytes                                          ==
== Note 2: Results for 'copy' tests show how many bytes can be          ==
==         copied per second (adding together read and writen           ==
==         bytes would have provided twice higher numbers)              ==
== Note 3: 2-pass copy means that we are using a small temporary buffer ==
==         to first fetch data into it, and only then write it to the   ==
==         destination (source -> L1 cache, L1 cache -> destination)    ==
== Note 4: If sample standard deviation exceeds 0.1%, it is shown in    ==
==         brackets                                                     ==
==========================================================================

                                                       L2 streamer ON            OFF
 C copy backwards                                     :   7962.4 MB/s    4430.5 MB/s
 C copy backwards (32 byte blocks)                    :   7993.5 MB/s    4467.0 MB/s
 C copy backwards (64 byte blocks)                    :   7989.9 MB/s    4438.0 MB/s
 C copy                                               :   8503.1 MB/s    4466.6 MB/s
 C copy prefetched (32 bytes step)                    :   8729.2 MB/s    4958.4 MB/s
 C copy prefetched (64 bytes step)                    :   8730.7 MB/s    4958.4 MB/s
 C 2-pass copy                                        :   6171.2 MB/s    3368.7 MB/s
 C 2-pass copy prefetched (32 bytes step)             :   6193.1 MB/s    4104.2 MB/s
 C 2-pass copy prefetched (64 bytes step)             :   6198.8 MB/s    4101.6 MB/s
 C fill                                               :  13372.4 MB/s   10610.5 MB/s
 C fill (shuffle within 16 byte blocks)               :  13379.4 MB/s   10547.5 MB/s
 C fill (shuffle within 32 byte blocks)               :  13365.8 MB/s   10636.9 MB/s
 C fill (shuffle within 64 byte blocks)               :  13588.7 MB/s   10588.3 MB/s
 -
 standard memcpy                                      :  11550.7 MB/s    8216.3 MB/s
 standard memset                                      :  23188.7 MB/s   22686.8 MB/s
 -
 MOVSB copy                                           :   9458.4 MB/s    6523.7 MB/s
 MOVSD copy                                           :   9474.5 MB/s    6510.7 MB/s
 STOSB fill                                           :  23329.0 MB/s   22901.5 MB/s
 SSE2 copy                                            :   9073.1 MB/s    4970.3 MB/s
 SSE2 nontemporal copy                                :  12647.1 MB/s    7492.5 MB/s
 SSE2 copy prefetched (32 bytes step)                 :   9106.0 MB/s    5069.8 MB/s
 SSE2 copy prefetched (64 bytes step)                 :   9113.5 MB/s    5063.1 MB/s
 SSE2 nontemporal copy prefetched (32 bytes step)     :  11770.8 MB/s    7453.4 MB/s
 SSE2 nontemporal copy prefetched (64 bytes step)     :  11937.1 MB/s    7712.1 MB/s
 SSE2 2-pass copy                                     :   7092.8 MB/s    4355.2 MB/s
 SSE2 2-pass copy prefetched (32 bytes step)          :   7001.4 MB/s    4585.1 MB/s
 SSE2 2-pass copy prefetched (64 bytes step)          :   7055.1 MB/s    4557.9 MB/s
 SSE2 2-pass nontemporal copy                         :   5043.2 MB/s    3263.3 MB/s
 SSE2 fill                                            :  14087.3 MB/s   10947.1 MB/s
 SSE2 nontemporal fill                                :  33134.5 MB/s   32774.3 MB/s

इन परीक्षणों में L2 स्ट्रीमर कभी धीमा नहीं होता है और अक्सर लगभग दोगुना होता है।

सामान्य तौर पर, आप परिणामों में निम्नलिखित पैटर्न देख सकते हैं:

  • आमतौर पर कॉपियां भरने से ज्यादा प्रभावित होती हैं।
  • standard memsetऔर STOSB fill(इस मंच पर एक ही बात करने के लिए इन फोड़ा नीचे), कम से कम प्रभावित प्रीफ़ेच परिणाम केवल कुछ% के बिना की तुलना में तेजी होने के साथ कर रहे हैं।
  • मानक memcpyशायद यहां एकमात्र प्रति है जो 32-बाइट एवीएक्स निर्देशों का उपयोग करता है, और यह प्रतियों के कम से कम प्रभावित होने के बीच है - लेकिन अभी भी प्रीफेटिंग बिना की तुलना में ~ 40% तेज है।

मैंने अन्य तीन प्रीफैचर्स को चालू और बंद करने की भी कोशिश की, लेकिन आम तौर पर उनके पास इस बेंचमार्क के लिए कोई औसत दर्जे का प्रभाव नहीं था।


(मजेदार तथ्य: vmovdqaएवीएक्स 1 "पूर्णांक" होने के बावजूद।) क्या आपको लगता है कि ओपी का लूप ग्लिबक मेमसीपी की तुलना में कम बैंडविड्थ दे रहा था? और इसीलिए 12 LFB एल 2 से अतिरिक्त एमएलपी का लाभ उठाए बिना, एल 3 में जाने वाले डिमांड लोड को ध्यान में रखने के लिए पर्याप्त थे <-> एल 3 सुपरक्वे जिस पर एल 2 स्ट्रीमर कब्जा कर सकते हैं? यह संभवतः आपके परीक्षण में अंतर है। L3 को कोर के समान गति से चलना चाहिए; आप दोनों के पास क्वाड-कोर स्काईलेक-क्लाइंट समतुल्य माइक्रोआर्किटेक्चर है ताकि संभवतः समान L3 विलंबता हो?
— पीटर कॉर्ड्स

@PeterCordes - क्षमा करें मुझे शायद स्पष्ट होना चाहिए: यह परीक्षण 32 MiB बफ़र्स के बीच था, इसलिए यह DRAM हिट्स L3 हिट्स का परीक्षण कर रहा है। हालांकि मैं टीबी आउटपुट बफर साइज का हूं, लेकिन मुझे लगता है कि यह नहीं है - उफ़! यह जानबूझकर किया गया था: मैं ओपी के 512 केबी परिदृश्य को वास्तव में समझाने की कोशिश नहीं कर रहा था, लेकिन सिर्फ इस सवाल का उत्तर दें कि क्या एल 2 स्ट्रीमर परिदृश्य के साथ उपयोगी है जो यह दिखाता है। मुझे लगता है कि मैंने एक छोटे बफर आकार का उपयोग किया है जो मैं परिणामों को कम या ज्यादा कर सकता हूं (मैंने पहले ही uarch-benchटिप्पणियों में उल्लिखित एक समान परिणाम देखा था )।
— 20

1
मैंने उत्तर में बफर आकार जोड़ा।
— 20

1
@ सेंटअनारियो: नहीं, यह कोई समस्या नहीं है। पता नहीं क्यों आपको लगता है कि यह एक समस्या हो सकती है; ऐसा नहीं है कि AVX1 और AVX2 निर्देशों के मिश्रण के लिए कोई जुर्माना है। मेरी टिप्पणी का मुद्दा यह था कि इस लूप को केवल AVX1 की आवश्यकता है, फिर भी इस उत्तर में AVX2 निर्देशों का उपयोग करने का उल्लेख है। AVX2 को शुरू करने के साथ ही इंटेल ने L1d लोड / स्टोर डेटा पथों को 32 बाइट्स तक चौड़ा करने का काम किया, इसलिए आप AVX2 की उपलब्धता का उपयोग कर सकते हैं, यदि आप रनटाइम विवाद कर रहे हैं तो आप एक यादगार कार्यान्वयन का चयन कैसे करेंगे ...
— पीटर Cordes

1
आपने प्रीफ़ेचर कैसे बंद किया और कौन सा? क्या यह software.intel.com/en-us/articles/… था ? फोरम सॉफ्टवेयर .intel.com/en-us/forums/intel-isa-extensions/topic/… कहता है कि कुछ बिट्स का अलग अर्थ होता है।
— osgx
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.