เหตุใดโปรแกรมของฉันจึงช้าเมื่อวนลูปมากกว่า 8192 องค์ประกอบ

นี่คือสารสกัดจากโปรแกรมที่เป็นปัญหา เมทริกซ์img[][]มีขนาด SIZE × SIZE และเริ่มต้นได้ที่:

img[j][i] = 2 * j + i

จากนั้นคุณสร้างเมทริกซ์res[][]และแต่ละฟิลด์ในที่นี้จะถูกทำให้เป็นค่าเฉลี่ยของ 9 ฟิลด์รอบ ๆ มันในเมทริกซ์ img เส้นขอบจะเหลือ 0 เพื่อความเรียบง่าย

for(i=1;i<SIZE-1;i++) 
    for(j=1;j<SIZE-1;j++) {
        res[j][i]=0;
        for(k=-1;k<2;k++) 
            for(l=-1;l<2;l++) 
                res[j][i] += img[j+l][i+k];
        res[j][i] /= 9;
}

นั่นคือทั้งหมดที่มีให้กับโปรแกรม เพื่อความสมบูรณ์ 'นี่คือสิ่งที่มาก่อน ไม่มีรหัสมา อย่างที่คุณเห็นมันเป็นเพียงการเริ่มต้น

#define SIZE 8192
float img[SIZE][SIZE]; // input image
float res[SIZE][SIZE]; //result of mean filter
int i,j,k,l;
for(i=0;i<SIZE;i++) 
    for(j=0;j<SIZE;j++) 
        img[j][i] = (2*j+i)%8196;

โดยทั่วไปโปรแกรมนี้จะช้าเมื่อ SIZE มีค่าเท่ากับ 2048 เช่นเวลาดำเนินการ:

SIZE = 8191: 3.44 secs
SIZE = 8192: 7.20 secs
SIZE = 8193: 3.18 secs

คอมไพเลอร์คือ GCC จากสิ่งที่ฉันรู้นี่เป็นเพราะการจัดการหน่วยความจำ แต่ฉันไม่รู้เกี่ยวกับเรื่องนั้นมากเกินไปซึ่งเป็นสาเหตุที่ฉันถามที่นี่

นอกจากนี้วิธีการแก้ไขนี้จะดี แต่ถ้ามีคนสามารถอธิบายเวลาดำเนินการเหล่านี้ฉันมีความสุขมากพอ

ฉันรู้แล้วว่า malloc / free แต่ปัญหาไม่ใช่จำนวนหน่วยความจำที่ใช้มันเป็นเพียงเวลาดำเนินการดังนั้นฉันจึงไม่ทราบว่าจะช่วยได้อย่างไร

ความแตกต่างนั้นเกิดจากปัญหาการจัดเรียงแนวเดียวกันจากคำถามที่เกี่ยวข้องต่อไปนี้:

• ทำไมการโอนเมทริกซ์ที่ 512x512 ช้ากว่าการแปลงเมทริกซ์ที่ 513x513 มาก?
• การคูณเมทริกซ์: ความแตกต่างเล็กน้อยในขนาดเมทริกซ์, ความแตกต่างในการกำหนดเวลาขนาดใหญ่

แต่นั่นเป็นเพราะมีปัญหาอีกอย่างหนึ่งเกี่ยวกับรหัส

เริ่มต้นจากวงเดิม:

for(i=1;i<SIZE-1;i++) 
    for(j=1;j<SIZE-1;j++) {
        res[j][i]=0;
        for(k=-1;k<2;k++) 
            for(l=-1;l<2;l++) 
                res[j][i] += img[j+l][i+k];
        res[j][i] /= 9;
}

การสังเกตครั้งแรกว่าลูปภายในทั้งสองนั้นเล็กน้อย พวกเขาสามารถ unrolled ดังนี้

for(i=1;i<SIZE-1;i++) {
    for(j=1;j<SIZE-1;j++) {
        res[j][i]=0;
        res[j][i] += img[j-1][i-1];
        res[j][i] += img[j  ][i-1];
        res[j][i] += img[j+1][i-1];
        res[j][i] += img[j-1][i  ];
        res[j][i] += img[j  ][i  ];
        res[j][i] += img[j+1][i  ];
        res[j][i] += img[j-1][i+1];
        res[j][i] += img[j  ][i+1];
        res[j][i] += img[j+1][i+1];
        res[j][i] /= 9;
    }
}

นั่นก็ทำให้วงรอบนอกทั้งสองวงที่เราสนใจ

ในตอนนี้เราสามารถเห็นปัญหาได้เหมือนกันในคำถามนี้: เหตุใดลำดับของลูปจึงมีผลต่อประสิทธิภาพเมื่อวนซ้ำแถว 2 มิติ

คุณกำลังทำซ้ำคอลัมน์เมทริกซ์ฉลาดแทนแถวฉลาด

เพื่อแก้ปัญหานี้คุณควรแลกเปลี่ยนสองลูป

for(j=1;j<SIZE-1;j++) {
    for(i=1;i<SIZE-1;i++) {
        res[j][i]=0;
        res[j][i] += img[j-1][i-1];
        res[j][i] += img[j  ][i-1];
        res[j][i] += img[j+1][i-1];
        res[j][i] += img[j-1][i  ];
        res[j][i] += img[j  ][i  ];
        res[j][i] += img[j+1][i  ];
        res[j][i] += img[j-1][i+1];
        res[j][i] += img[j  ][i+1];
        res[j][i] += img[j+1][i+1];
        res[j][i] /= 9;
    }
}

สิ่งนี้จะกำจัดการเข้าถึงที่ไม่ต่อเนื่องทั้งหมดอย่างสมบูรณ์ดังนั้นคุณจะไม่ได้รับการชะลอตัวแบบสุ่มในการเพิ่มพลังสองครั้งใหญ่อีกต่อไป

Core i7 920 @ 3.5 GHz

รหัสเดิม:

8191: 1.499 seconds
8192: 2.122 seconds
8193: 1.582 seconds

Interchanged Outer-Loops:

8191: 0.376 seconds
8192: 0.357 seconds
8193: 0.351 seconds

มีการทดสอบต่อไปนี้กับคอมไพเลอร์ Visual C ++ ตามที่ใช้โดยการติดตั้ง Qt Creator เริ่มต้น (ฉันเดาว่าไม่มีการตั้งค่าสถานะการปรับให้เหมาะสม) เมื่อใช้ GCC ไม่มีความแตกต่างอย่างใหญ่หลวงระหว่างเวอร์ชั่นของ Mystical และรหัส "ที่ได้รับการปรับปรุง" ของฉัน ดังนั้นข้อสรุปคือการเพิ่มประสิทธิภาพของคอมไพเลอร์จะดูแลการเพิ่มประสิทธิภาพของไมโครดีกว่ามนุษย์ (ในที่สุดฉัน) ฉันออกจากส่วนที่เหลือของคำตอบของฉันสำหรับการอ้างอิง

การประมวลผลภาพด้วยวิธีนี้ไม่มีประสิทธิภาพ มันจะดีกว่าที่จะใช้อาร์เรย์มิติเดียว การประมวลผลพิกเซลทั้งหมดจะทำในหนึ่งวง การเข้าถึงจุดแบบสุ่มสามารถทำได้โดยใช้:

pointer + (x + y*width)*(sizeOfOnePixel)

โดยเฉพาะอย่างยิ่งในกรณีนี้การคำนวณและแคชผลรวมของกลุ่มพิกเซลทั้งสามในแนวนอนจะดีกว่าเพราะจะใช้กลุ่มละสามครั้ง

ฉันทำแบบทดสอบเสร็จแล้วและฉันคิดว่ามันคุ้มค่าที่จะแบ่งปัน ผลลัพธ์แต่ละรายการมีค่าเฉลี่ยห้าการทดสอบ

รหัสเดิมโดย user1615209:

8193: 4392 ms
8192: 9570 ms

เวอร์ชั่นของ Mystical:

8193: 2393 ms
8192: 2190 ms

สองรอบโดยใช้อาร์เรย์ 1D: ผ่านครั้งแรกสำหรับผลบวกในแนวนอน, สองสำหรับผลรวมแนวตั้งและค่าเฉลี่ย การผ่านสองครั้งด้วยตัวชี้สามตัวและการเพิ่มขึ้นเช่นนี้:

imgPointer1 = &avg1[0][0];
imgPointer2 = &avg1[0][SIZE];
imgPointer3 = &avg1[0][SIZE+SIZE];

for(i=SIZE;i<totalSize-SIZE;i++){
    resPointer[i]=(*(imgPointer1++)+*(imgPointer2++)+*(imgPointer3++))/9;
}

8193: 938 ms
8192: 974 ms

สองรอบโดยใช้อาร์เรย์ 1D และจัดการกับสิ่งนี้:

for(i=SIZE;i<totalSize-SIZE;i++){
    resPointer[i]=(hsumPointer[i-SIZE]+hsumPointer[i]+hsumPointer[i+SIZE])/9;
}

8193: 932 ms
8192: 925 ms

One pass caching เป็นผลบวกตามแนวนอนเพียงแถวเดียวข้างหน้าดังนั้นพวกมันจึงอยู่ในแคช:

// Horizontal sums for the first two lines
for(i=1;i<SIZE*2;i++){
    hsumPointer[i]=imgPointer[i-1]+imgPointer[i]+imgPointer[i+1];
}
// Rest of the computation
for(;i<totalSize;i++){
    // Compute horizontal sum for next line
    hsumPointer[i]=imgPointer[i-1]+imgPointer[i]+imgPointer[i+1];
    // Final result
    resPointer[i-SIZE]=(hsumPointer[i-SIZE-SIZE]+hsumPointer[i-SIZE]+hsumPointer[i])/9;
}

8193: 599 ms
8192: 652 ms

สรุป:

• ไม่มีประโยชน์ในการใช้ตัวชี้หลายตัวและเพิ่มขึ้นเพียงครั้งเดียว (ฉันคิดว่ามันจะเร็วขึ้น)
• การแคชผลรวมแนวนอนนั้นดีกว่าการคำนวณหลายครั้ง
• สองรอบไม่เร็วกว่าสามเท่าสองครั้งเท่านั้น
• สามารถทำได้เร็วขึ้น 3.6 เท่าโดยใช้ทั้งการผ่านครั้งเดียวและการแคชผลลัพธ์ตัวกลาง

ฉันแน่ใจว่ามันเป็นไปได้ที่จะทำดีกว่ามาก

หมายเหตุ โปรดทราบว่าฉันเขียนคำตอบนี้เพื่อกำหนดเป้าหมายปัญหาประสิทธิภาพทั่วไปมากกว่าปัญหาแคชที่อธิบายไว้ในคำตอบที่ยอดเยี่ยมของ Mystical ในตอนแรกมันเป็นรหัสหลอกๆ ฉันถูกขอให้ทำการทดสอบในความคิดเห็น ... นี่เป็นเวอร์ชั่นที่ได้รับการปรับปรุงใหม่อย่างสมบูรณ์พร้อมการทดสอบ