Intro: ฉันเขียนโค้ดประสิทธิภาพสูงใน C # ใช่ฉันรู้ว่า C ++ จะให้การเพิ่มประสิทธิภาพที่ดีขึ้น แต่ฉันก็ยังเลือกที่จะใช้ C # ฉันไม่ต้องการที่จะอภิปรายทางเลือกนั้น แต่ฉันอยากได้ยินจากคนที่พยายามเขียนโค้ดประสิทธิภาพสูงบน. NET Framework
คำถาม:
- เหตุใดตัวดำเนินการในรหัสด้านล่างจึงช้ากว่าการเรียกเมธอดเทียบเท่า ??
- เหตุใดวิธีการส่งผ่านสองคู่ในโค้ดด้านล่างเร็วกว่าวิธีการที่เทียบเท่ากันโดยผ่านโครงสร้างที่มีสองคู่อยู่ภายใน (A: JIT รุ่นเก่าปรับโครงสร้างให้เหมาะสมไม่ดี)
- มีวิธีรับ. NET JIT Compiler เพื่อจัดการโครงสร้างอย่างง่ายได้อย่างมีประสิทธิภาพเทียบเท่ากับสมาชิกของโครงสร้างหรือไม่ (A: รับ JIT ใหม่กว่า)
สิ่งที่ฉันคิดว่าฉันรู้: คอมไพเลอร์. NET JIT ดั้งเดิมจะไม่อินไลน์อะไรที่เกี่ยวข้องกับโครงสร้าง ควรใช้โครงสร้างที่แปลกประหลาดเฉพาะเมื่อคุณต้องการประเภทค่าขนาดเล็กที่ควรปรับให้เหมาะสมเช่นบิวท์อิน แต่เป็นจริง โชคดีที่ใน. NET 3.5SP1 และ. (ฉันเดาว่าพวกเขาทำอย่างนั้นเพราะไม่เช่นนั้นโครงสร้างซับซ้อนใหม่ที่พวกเขาแนะนำจะมีประสิทธิภาพที่น่ากลัว ... ไม่เกี่ยวข้องกับปัญหานี้มากเกินไป
สิ่งที่การทดสอบของฉันแสดงให้เห็น: ฉันได้ตรวจสอบแล้วว่าฉันมี JIT Optimizer รุ่นใหม่กว่าโดยตรวจสอบว่าไฟล์ C: \ Windows \ Microsoft.NET \ Framework \ v2.0.50727 \ mscorwks.dll มีเวอร์ชัน> = 3053 ดังนั้นควรมีการปรับปรุงเหล่านั้น ไปยังเครื่องมือเพิ่มประสิทธิภาพ JIT อย่างไรก็ตามแม้จะเป็นเช่นนั้นสิ่งที่ฉันกำหนดเวลาและดูการถอดชิ้นส่วนทั้งสองแสดงคือ:
รหัสที่ผลิตโดย JIT สำหรับการส่งผ่านโครงสร้างที่มีสองคู่นั้นมีประสิทธิภาพน้อยกว่ารหัสที่ส่งผ่านสองคู่โดยตรง
โค้ดที่สร้างโดย JIT สำหรับเมธอด struct จะส่งผ่าน 'this' ได้อย่างมีประสิทธิภาพมากกว่าถ้าคุณส่ง struct เป็นอาร์กิวเมนต์
JIT ยังคงอินไลน์ได้ดีกว่าหากคุณผ่านสองคู่แทนที่จะส่งผ่านโครงสร้างด้วยสองคู่แม้ว่าจะมีตัวคูณเนื่องจากอยู่ในวงอย่างชัดเจน
การกำหนดเวลา: จริงๆแล้วการดูการถอดชิ้นส่วนฉันรู้ว่าเวลาส่วนใหญ่ในลูปเป็นเพียงการเข้าถึงข้อมูลการทดสอบจากรายการ ความแตกต่างระหว่างสี่วิธีในการโทรเดียวกันนั้นแตกต่างกันอย่างมากหากคุณแยกรหัสเหนือศีรษะของลูปและการเข้าถึงข้อมูล ฉันได้รับทุกที่ตั้งแต่ 5x ถึง 20x speedups สำหรับการทำ PlusEqual (double, double) แทนที่จะเป็น PlusEqual (Element) และ 10x ถึง 40x สำหรับการทำ PlusEqual (double, double) แทนตัวดำเนินการ + = ว้าว. เศร้า.
นี่คือการกำหนดเวลาชุดเดียว:
Populating List<Element> took 320ms.
The PlusEqual() method took 105ms.
The 'same' += operator took 131ms.
The 'same' -= operator took 139ms.
The PlusEqual(double, double) method took 68ms.
The do nothing loop took 66ms.
The ratio of operator with constructor to method is 124%.
The ratio of operator without constructor to method is 132%.
The ratio of PlusEqual(double,double) to PlusEqual(Element) is 64%.
If we remove the overhead time for the loop accessing the elements from the List...
The ratio of operator with constructor to method is 166%.
The ratio of operator without constructor to method is 187%.
The ratio of PlusEqual(double,double) to PlusEqual(Element) is 5%.
รหัส:
namespace OperatorVsMethod
{
public struct Element
{
public double Left;
public double Right;
public Element(double left, double right)
{
this.Left = left;
this.Right = right;
}
public static Element operator +(Element x, Element y)
{
return new Element(x.Left + y.Left, x.Right + y.Right);
}
public static Element operator -(Element x, Element y)
{
x.Left += y.Left;
x.Right += y.Right;
return x;
}
/// <summary>
/// Like the += operator; but faster.
/// </summary>
public void PlusEqual(Element that)
{
this.Left += that.Left;
this.Right += that.Right;
}
/// <summary>
/// Like the += operator; but faster.
/// </summary>
public void PlusEqual(double thatLeft, double thatRight)
{
this.Left += thatLeft;
this.Right += thatRight;
}
}
[TestClass]
public class UnitTest1
{
[TestMethod]
public void TestMethod1()
{
Stopwatch stopwatch = new Stopwatch();
// Populate a List of Elements to multiply together
int seedSize = 4;
List<double> doubles = new List<double>(seedSize);
doubles.Add(2.5d);
doubles.Add(100000d);
doubles.Add(-0.5d);
doubles.Add(-100002d);
int size = 2500000 * seedSize;
List<Element> elts = new List<Element>(size);
stopwatch.Reset();
stopwatch.Start();
for (int ii = 0; ii < size; ++ii)
{
int di = ii % seedSize;
double d = doubles[di];
elts.Add(new Element(d, d));
}
stopwatch.Stop();
long populateMS = stopwatch.ElapsedMilliseconds;
// Measure speed of += operator (calls ctor)
Element operatorCtorResult = new Element(1d, 1d);
stopwatch.Reset();
stopwatch.Start();
for (int ii = 0; ii < size; ++ii)
{
operatorCtorResult += elts[ii];
}
stopwatch.Stop();
long operatorCtorMS = stopwatch.ElapsedMilliseconds;
// Measure speed of -= operator (+= without ctor)
Element operatorNoCtorResult = new Element(1d, 1d);
stopwatch.Reset();
stopwatch.Start();
for (int ii = 0; ii < size; ++ii)
{
operatorNoCtorResult -= elts[ii];
}
stopwatch.Stop();
long operatorNoCtorMS = stopwatch.ElapsedMilliseconds;
// Measure speed of PlusEqual(Element) method
Element plusEqualResult = new Element(1d, 1d);
stopwatch.Reset();
stopwatch.Start();
for (int ii = 0; ii < size; ++ii)
{
plusEqualResult.PlusEqual(elts[ii]);
}
stopwatch.Stop();
long plusEqualMS = stopwatch.ElapsedMilliseconds;
// Measure speed of PlusEqual(double, double) method
Element plusEqualDDResult = new Element(1d, 1d);
stopwatch.Reset();
stopwatch.Start();
for (int ii = 0; ii < size; ++ii)
{
Element elt = elts[ii];
plusEqualDDResult.PlusEqual(elt.Left, elt.Right);
}
stopwatch.Stop();
long plusEqualDDMS = stopwatch.ElapsedMilliseconds;
// Measure speed of doing nothing but accessing the Element
Element doNothingResult = new Element(1d, 1d);
stopwatch.Reset();
stopwatch.Start();
for (int ii = 0; ii < size; ++ii)
{
Element elt = elts[ii];
double left = elt.Left;
double right = elt.Right;
}
stopwatch.Stop();
long doNothingMS = stopwatch.ElapsedMilliseconds;
// Report results
Assert.AreEqual(1d, operatorCtorResult.Left, "The operator += did not compute the right result!");
Assert.AreEqual(1d, operatorNoCtorResult.Left, "The operator += did not compute the right result!");
Assert.AreEqual(1d, plusEqualResult.Left, "The operator += did not compute the right result!");
Assert.AreEqual(1d, plusEqualDDResult.Left, "The operator += did not compute the right result!");
Assert.AreEqual(1d, doNothingResult.Left, "The operator += did not compute the right result!");
// Report speeds
Console.WriteLine("Populating List<Element> took {0}ms.", populateMS);
Console.WriteLine("The PlusEqual() method took {0}ms.", plusEqualMS);
Console.WriteLine("The 'same' += operator took {0}ms.", operatorCtorMS);
Console.WriteLine("The 'same' -= operator took {0}ms.", operatorNoCtorMS);
Console.WriteLine("The PlusEqual(double, double) method took {0}ms.", plusEqualDDMS);
Console.WriteLine("The do nothing loop took {0}ms.", doNothingMS);
// Compare speeds
long percentageRatio = 100L * operatorCtorMS / plusEqualMS;
Console.WriteLine("The ratio of operator with constructor to method is {0}%.", percentageRatio);
percentageRatio = 100L * operatorNoCtorMS / plusEqualMS;
Console.WriteLine("The ratio of operator without constructor to method is {0}%.", percentageRatio);
percentageRatio = 100L * plusEqualDDMS / plusEqualMS;
Console.WriteLine("The ratio of PlusEqual(double,double) to PlusEqual(Element) is {0}%.", percentageRatio);
operatorCtorMS -= doNothingMS;
operatorNoCtorMS -= doNothingMS;
plusEqualMS -= doNothingMS;
plusEqualDDMS -= doNothingMS;
Console.WriteLine("If we remove the overhead time for the loop accessing the elements from the List...");
percentageRatio = 100L * operatorCtorMS / plusEqualMS;
Console.WriteLine("The ratio of operator with constructor to method is {0}%.", percentageRatio);
percentageRatio = 100L * operatorNoCtorMS / plusEqualMS;
Console.WriteLine("The ratio of operator without constructor to method is {0}%.", percentageRatio);
percentageRatio = 100L * plusEqualDDMS / plusEqualMS;
Console.WriteLine("The ratio of PlusEqual(double,double) to PlusEqual(Element) is {0}%.", percentageRatio);
}
}
}
IL: (aka. สิ่งที่รวบรวมไว้ข้างต้น)
public void PlusEqual(Element that)
{
00000000 push ebp
00000001 mov ebp,esp
00000003 push edi
00000004 push esi
00000005 push ebx
00000006 sub esp,30h
00000009 xor eax,eax
0000000b mov dword ptr [ebp-10h],eax
0000000e xor eax,eax
00000010 mov dword ptr [ebp-1Ch],eax
00000013 mov dword ptr [ebp-3Ch],ecx
00000016 cmp dword ptr ds:[04C87B7Ch],0
0000001d je 00000024
0000001f call 753081B1
00000024 nop
this.Left += that.Left;
00000025 mov eax,dword ptr [ebp-3Ch]
00000028 fld qword ptr [ebp+8]
0000002b fadd qword ptr [eax]
0000002d fstp qword ptr [eax]
this.Right += that.Right;
0000002f mov eax,dword ptr [ebp-3Ch]
00000032 fld qword ptr [ebp+10h]
00000035 fadd qword ptr [eax+8]
00000038 fstp qword ptr [eax+8]
}
0000003b nop
0000003c lea esp,[ebp-0Ch]
0000003f pop ebx
00000040 pop esi
00000041 pop edi
00000042 pop ebp
00000043 ret 10h
public void PlusEqual(double thatLeft, double thatRight)
{
00000000 push ebp
00000001 mov ebp,esp
00000003 push edi
00000004 push esi
00000005 push ebx
00000006 sub esp,30h
00000009 xor eax,eax
0000000b mov dword ptr [ebp-10h],eax
0000000e xor eax,eax
00000010 mov dword ptr [ebp-1Ch],eax
00000013 mov dword ptr [ebp-3Ch],ecx
00000016 cmp dword ptr ds:[04C87B7Ch],0
0000001d je 00000024
0000001f call 75308159
00000024 nop
this.Left += thatLeft;
00000025 mov eax,dword ptr [ebp-3Ch]
00000028 fld qword ptr [ebp+10h]
0000002b fadd qword ptr [eax]
0000002d fstp qword ptr [eax]
this.Right += thatRight;
0000002f mov eax,dword ptr [ebp-3Ch]
00000032 fld qword ptr [ebp+8]
00000035 fadd qword ptr [eax+8]
00000038 fstp qword ptr [eax+8]
}
0000003b nop
0000003c lea esp,[ebp-0Ch]
0000003f pop ebx
00000040 pop esi
00000041 pop edi
00000042 pop ebp
00000043 ret 10h