งบล็อคแพงแค่ไหน?

ฉันได้ทดลองกับการประมวลผลแบบหลายเธรดและการประมวลผลแบบขนานและฉันต้องการตัวนับเพื่อทำการนับพื้นฐานและการวิเคราะห์ทางสถิติเกี่ยวกับความเร็วของการประมวลผล เพื่อหลีกเลี่ยงปัญหาในการใช้คลาสของฉันพร้อมกันฉันได้ใช้คำสั่งล็อคกับตัวแปรส่วนตัวในคลาสของฉัน:

private object mutex = new object();

public void Count(int amount)
{
 lock(mutex)
 {
  done += amount;
 }
}

แต่ฉันสงสัยว่า ... การล็อคตัวแปรแพงแค่ไหน? ผลเสียต่อประสิทธิภาพคืออะไร?

นี่คือบทความที่เกี่ยวข้องกับต้นทุน คำตอบสั้น ๆ คือ 50ns

คำตอบทางเทคนิคคือเป็นไปไม่ได้ที่จะหาปริมาณมันขึ้นอยู่กับสถานะของบัฟเฟอร์การเขียนกลับของหน่วยความจำ CPU และปริมาณข้อมูลที่รวบรวมไว้ล่วงหน้าจะต้องถูกทิ้งและอ่านใหม่ ซึ่งมีทั้งแบบไม่กำหนดปัจจัย ฉันใช้ 150 CPU Cycle เป็นการประมาณด้านหลังของซองจดหมายที่หลีกเลี่ยงความผิดหวังครั้งใหญ่

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

เพื่อให้ได้ตัวเลขที่ยากคุณจะต้องวัด Visual Studio มีตัววิเคราะห์การทำงานพร้อมกันที่ลื่นไหลพร้อมใช้งานเป็นส่วนขยาย

อ่านเพิ่มเติม:

ฉันต้องการนำเสนอบทความบางส่วนของฉันซึ่งมีความสนใจในการทำข้อมูลเบื้องต้นเกี่ยวกับการซิงโครไนซ์ทั่วไปและพวกเขากำลังขุดลงใน Monitor พฤติกรรมคำสั่งล็อค C # คุณสมบัติและค่าใช้จ่ายขึ้นอยู่กับสถานการณ์ที่แตกต่างกันและจำนวนเธรด มีความสนใจเป็นพิเศษเกี่ยวกับการสิ้นเปลืองของ CPU และระยะเวลาทรูพุตเพื่อทำความเข้าใจว่าสามารถผลักดันงานผ่านสถานการณ์ต่างๆได้มากเพียงใด:

https://www.codeproject.com/Articles/1236238/Unified-Concurrency-I-Introduction https://www.codeproject.com/Articles/1237518/Unified-Concurrency-II-benchmarking-methodologies https: // www. codeproject.com/Articles/1242156/Unified-Concurrency-III-cross-benchmarking

คำตอบเดิม:

โอ้ที่รัก!

ดูเหมือนว่าคำตอบที่ถูกต้องถูกตั้งค่าสถานะไว้ที่นี่เนื่องจากคำตอบนั้นไม่ถูกต้องโดยเนื้อแท้! ฉันอยากจะขอให้ผู้เขียนตอบด้วยความเคารพที่จะอ่านบทความที่เชื่อมโยงจนจบ บทความ

ผู้เขียนบทความจากปี 2003 บทความได้รับการวัดบนเครื่อง Dual Core เท่านั้นและในกรณีที่วัดแรกเขาวัดล็อคกับหัวข้อเดียวเท่านั้นและผลที่ได้คือประมาณ 50ns ต่อการเข้าถึงล็อค

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

ดังนั้นผู้เขียนจึงกล่าวว่าด้วยสองเธรดบน Dual Core การล็อคจะมีราคา 120ns และ 3 เธรดจะไปที่ 180ns ดังนั้นดูเหมือนว่าจะขึ้นอยู่กับจำนวนเธรดที่เข้าถึงล็อกพร้อมกันอย่างชัดเจน

ดังนั้นจึงเป็นเรื่องง่ายไม่ใช่ 50 ns เว้นแต่จะเป็นเธรดเดียวซึ่งการล็อคจะไร้ประโยชน์

อีกประเด็นที่ต้องพิจารณาคือวัดเป็นเวลาเฉลี่ย !

หากจะวัดเวลาในการทำซ้ำจะมีช่วงเวลาระหว่าง 1ms ถึง 20ms ด้วยซ้ำเพียงเพราะส่วนใหญ่เร็ว แต่มีเธรดเพียงไม่กี่เธรดที่รอเวลาโปรเซสเซอร์และอาจเกิดความล่าช้าเป็นเวลานานถึงมิลลิวินาที

นี่เป็นข่าวร้ายสำหรับแอปพลิเคชันทุกประเภทที่ต้องการปริมาณงานสูงเวลาแฝงต่ำ

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

โปรดพิจารณาว่าเวลาผ่านไปกว่าหนึ่งทศวรรษแล้วนับจากปี 2546 ซึ่งเป็นโปรเซสเซอร์เพียงไม่กี่รุ่นที่ออกแบบมาโดยเฉพาะเพื่อให้ทำงานพร้อมกันได้อย่างสมบูรณ์และการล็อกก็ส่งผลเสียต่อประสิทธิภาพอย่างมาก

นี่ไม่ได้ตอบคำถามของคุณเกี่ยวกับประสิทธิภาพ แต่ฉันสามารถพูดได้ว่า. NET Framework มีInterlocked.Addวิธีการที่จะช่วยให้คุณสามารถเพิ่มของคุณamountไปยังdoneสมาชิกของคุณได้โดยไม่ต้องล็อกวัตถุอื่นด้วยตนเอง

lock (Monitor.Enter / Exit) มีราคาถูกมากถูกกว่าทางเลือกอื่นเช่น Waithandle หรือ Mutex

แต่ถ้ามันช้า (เล็กน้อย) คุณอยากจะมีโปรแกรมที่รวดเร็วพร้อมผลลัพธ์ที่ไม่ถูกต้องหรือไม่?

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

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace LockPerformanceConsoleApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            var stopwatch = new Stopwatch();
            const int LoopCount = (int) (100 * 1e6);
            int counter = 0;

            for (int repetition = 0; repetition < 5; repetition++)
            {
                stopwatch.Reset();
                stopwatch.Start();
                for (int i = 0; i < LoopCount; i++)
                    lock (stopwatch)
                        counter = i;
                stopwatch.Stop();
                Console.WriteLine("With lock: {0}", stopwatch.ElapsedMilliseconds);

                stopwatch.Reset();
                stopwatch.Start();
                for (int i = 0; i < LoopCount; i++)
                    counter = i;
                stopwatch.Stop();
                Console.WriteLine("Without lock: {0}", stopwatch.ElapsedMilliseconds);
            }

            Console.ReadKey();
        }
    }
}

เอาท์พุต:

With lock: 2013
Without lock: 211
With lock: 2002
Without lock: 210
With lock: 1989
Without lock: 210
With lock: 1987
Without lock: 207
With lock: 1988
Without lock: 208

มีหลายวิธีในการกำหนด "ต้นทุน" มีค่าใช้จ่ายที่แท้จริงในการรับและปลดล็อค ดังที่เจคเขียนนั่นเป็นเรื่องเล็กน้อยเว้นแต่การดำเนินการนี้จะดำเนินการหลายล้านครั้ง

ความเกี่ยวข้องมากขึ้นคือผลกระทบที่มีต่อขั้นตอนการดำเนินการ รหัสนี้สามารถป้อนได้ทีละเธรดเท่านั้น หากคุณมีเธรด 5 เธรดที่ดำเนินการนี้เป็นประจำ 4 เธรดจะสิ้นสุดลงด้วยการรอให้คลายล็อกจากนั้นจะเป็นเธรดแรกที่กำหนดให้ป้อนโค้ดส่วนนั้นหลังจากคลายล็อกนั้น ดังนั้นอัลกอริทึมของคุณจะได้รับผลกระทบอย่างมาก ขึ้นอยู่กับอัลกอริทึมและความถี่ในการเรียกการดำเนินการ .. คุณไม่สามารถหลีกเลี่ยงได้โดยไม่แนะนำเงื่อนไขการแข่งขัน แต่คุณสามารถแก้ไขได้โดยการลดจำนวนการโทรไปยังรหัสที่ล็อก