คุณควรเริ่มคิดถึงการแสดง ณ จุดใด

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

การปฏิบัติที่ไม่ถูกต้องในการพิจารณาประสิทธิภาพตลอดกระบวนการพัฒนาหรือไม่ ฉันควรผลักดันข้อควรพิจารณาเหล่านี้ออกไปจนกว่าการปฏิบัติจริงจะเป็นแท็งก์น้ำหรือไม่?

ปรับปรุง

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

การเลื่อนการพิจารณาผลการปฏิบัติงานบางครั้งขึ้นอยู่กับการใช้วลีที่ไม่เหมาะสม:

การเพิ่มประสิทธิภาพก่อนวัยอันควรเป็นรากของความชั่วร้ายทั้งหมด

หากคุณอ่านใบเสนอราคาที่สมบูรณ์สิ่งที่ Knuth พยายามพูดคือ micro-optimisation ที่นำไปใช้ในระหว่างการพัฒนาโดยที่ไม่มีการทำโปรไฟล์มักจะไม่สามารถทำได้เนื่องจากพวกเขานำไปสู่โค้ดที่สามารถบำรุงรักษาได้น้อยลง

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

มีหลายสิ่งที่คุณสามารถทำได้ในระหว่างการพัฒนาเพื่อให้ได้ประสิทธิภาพที่ดีโดยไม่มีการเพิ่มประสิทธิภาพแบบลึกลับ (และก่อนกำหนด):

1. ใช้สถาปัตยกรรมที่สมเหตุสมผลและมีความคิดดี
2. ใช้โครงสร้างข้อมูลอย่างถูกต้อง
3. ใช้เทคโนโลยี (ไลบรารีเฟรมเวิร์ก) ที่ทำงานได้อย่างเพียงพอ

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

นี่คือสิ่งที่ไม่ต้องคิดเกี่ยวกับ:

• คือ++iเร็วกว่าi++?
• คือswitchเร็วกว่าif?
• ฉันควรinlineทำหน้าที่ของฉันหรือไม่
• ฟังก์ชั่นเสมือนจริงช้าหรือไม่
• C ++ / Java / C # เร็วกว่า / ช้ากว่าอีกไหม
• blah, blah, ...

นี่คือสิ่งที่คิดเกี่ยวกับ:

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

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

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

ไม่คุณควรคิดถึงประสิทธิภาพ (โดยเฉพาะในการออกแบบฐานข้อมูล) ตั้งแต่เริ่มต้น ผู้คนที่คิดว่าการเพิ่มประสิทธิภาพใด ๆ นั้นเป็นอันตรายต่ออุตสาหกรรมของเราเป็นอย่างมาก คำพูดนี้มีจุดมุ่งหมายเพื่อป้องกันไม่ให้ผู้คนมองหาการปรับให้เหมาะสมแบบไมโครก่อนเกิดปัญหา มันไม่ได้ตั้งใจจะไม่ทำการปรับแต่งใด ๆ เลย ในฐานข้อมูลนั้นมีหลายคนรู้จักเทคนิคที่ทำงานได้ไม่ดี การหลีกเลี่ยงสิ่งเหล่านั้นในการออกแบบนั้นเป็นส่วนหนึ่งของสิ่งที่คุณต้องทำ เป็นการยากมากที่จะทำการปรับฐานข้อมูลที่มี 100,000,000 เร็กคอร์ดเนื่องจากออกแบบมาโดยใช้เทคนิคการตัดต่อที่ไม่ดีและเราไม่สามารถหลีกเลี่ยงปัญหานี้ได้ด้วยการซื้อฮาร์ดแวร์ที่ดีกว่า

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

80% ของประสิทธิภาพกำลังเลือกอัลกอริธึมที่เหมาะสมและโครงสร้างข้อมูลสำหรับปัญหาที่เกิดขึ้น Quicksort ที่ได้รับการปรับปรุงคุณภาพไม่ดีนั้นยังคงเอาชนะจังหวะของการจัดเรียงฟองที่มีประสิทธิภาพสูงในกรณีเฉลี่ย (กรณีที่แย่ที่สุดคือการดึง)

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

¹โดยที่ "ความถูกต้อง" หมายถึง "การปฏิบัติตามข้อกำหนด" ซึ่งไม่เหมือนกันกับ "ปราศจากข้อบกพร่อง"

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

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

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

ในการหาตัวชี้วัดเหล่านั้นคุณต้องเข้าใจว่าระบบของคุณต้องทำอะไร ตัวอย่างเช่นตัวชี้วัดประสิทธิภาพที่แน่นอนเรียกว่า (การตอบสนองภายในเวลา X) หรือการวัดปริมาณงานที่เรียกว่าสำหรับ (การตอบสนอง X ต่อ Y ครั้ง)? ปริมาณงานและการเพิ่มประสิทธิภาพเวลาที่แน่นอนต้องการวิธีการที่แตกต่างกันและถ้าคุณไม่รู้ว่าอะไรสำคัญจริง ๆ คุณอาจกำลังปรับวิธีผิด

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

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

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

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

วิธีการที่สมดุลจะดีกว่า ประสิทธิภาพเป็นสิ่งสำคัญ แต่ไม่สำคัญเท่ากับการทำสิ่งต่าง ๆ ดังนั้น:

1. ก่อนอื่นให้สร้างคุณลักษณะที่พยายามคิดเล็กน้อยเกี่ยวกับสิ่งที่คุณทำและวิธีการทำของคุณ (ใช้เวลาเล็กน้อยในการคิดเกี่ยวกับประสิทธิภาพ แต่ไม่มาก)
2. ทดสอบมัน
3. ครั้งหนึ่งกำลังเริ่มต้นคิดว่ามีความจำเป็นจริง ๆ หรือไม่ที่จะทำให้ดีขึ้น (โดยทั่วไปคุณจะไม่คุ้นเคย แต่ในบางกรณีคุณอาจจะ)

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

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

มีวิธีหนึ่งในการชะลอการคิดอย่างปลอดภัยเกี่ยวกับประสิทธิภาพ: ใช้ภาษาเฉพาะโดเมนทุกที่ที่เป็นไปได้

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

มันเป็นวิธีที่ดีกว่ามากจากจุดบำรุงรักษาของ veiw เช่นกัน

คุณควรคำนึงถึงประสิทธิภาพด้วย อย่างไรก็ตามคุณต้องวาดเส้นเพื่อทำเครื่องหมายจุดสิ้นสุดของการปรับตั้งเนื่องจาก (โดยปกติ) เวลาของคุณมีความสำคัญมากกว่าของคอมพิวเตอร์

บทความข้อความที่ดีมากต่อประสิทธิภาพการทำงานคือประสิทธิภาพคอมพิวเตอร์เกมเชลล์

เกมเชลล์ประสิทธิภาพของคอมพิวเตอร์หรือที่รู้จักกันในชื่อ "find the bottleneck" มักเล่นระหว่างทรัพยากรทั้งสี่นี้:

• ซีพียู
• ดิสก์
• เครือข่าย
• หน่วยความจำ

คอมพิวเตอร์ของคุณกำลังรอการดำเนินการบางอย่างเพื่อทำให้ทรัพยากรเหล่านี้สมบูรณ์ แต่อันไหน: CPU, หน่วยความจำ, ดิสก์, หรือเครือข่าย? หากคุณสนใจประสิทธิภาพการทำงานสิ่งแรกที่คุณต้องทำคือพิจารณาว่าคอขวดใดที่กำลังขัดขวางการปฏิบัติงานและกำจัดมัน

วิธีที่ "ดีที่สุด" เป็นคำที่โหลดมากและคำตอบอาจขึ้นอยู่กับปัจจัยที่ไม่รู้จักจนกระทั่งรันไทม์

• คุณมีหน่วยความจำมากมายหรือไม่? - คุณจะได้ประสิทธิภาพที่ดีขึ้นด้วยโครงสร้างข้อมูล "หน่วยความจำทั้งหมด" แต่หากคุณมีการสลับหน่วยความจำไม่เพียงพอจะทำให้ประสิทธิภาพการทำงานของคุณแย่ลง
• คุณต้องการความอดทนไหม? ฐานข้อมูลให้ความสมบูรณ์ แต่ช้ากว่าโครงสร้างข้อมูล "all-in-memory" ด้านบน มากช้าลง
• คุณแคชผลลัพธ์ได้ไหม วานิชสามารถช่วยได้! http://www.varnish-cache.org/

รายการไปบนและบน.

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

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

อย่างน้อยในทางทฤษฎีคุณควรเริ่มคิดเกี่ยวกับประสิทธิภาพเมื่อคุณอยู่ในการทดสอบเบต้าและไม่เคยมาก่อน

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

หากการออกแบบของคุณเป็นไปตามแนวปฏิบัติที่ดีที่สุด (ทุกอย่างในรูปแบบปกติที่ 3 การซ่อนข้อมูลที่เหมาะสมในชั้นเรียนของคุณการใช้ซิงเกิลน้อยที่สุด ฯลฯ ) และมีปัญหาด้านประสิทธิภาพในภายหลังมันจะง่ายต่อการจัดการ (สร้างดัชนีที่นี่ ใช้แคชที่นั่น)

HTH

มันขึ้นอยู่กับ. มันมีประโยชน์ที่จะต้องคำนึงถึงกฎ 80/20: ส่วนใหญ่ (สมมติว่า 80%) ของรหัสในแอปพลิเคชันจะไม่ถูกเรียกใช้งานบ่อยพอที่จะสร้างความแตกต่างที่เห็นได้ชัดเจนในประสิทธิภาพ คุณต้องมุ่งเน้นไปที่ส่วนที่เหลืออีก 20% ซึ่งแอพจะต้องใช้เวลาในการประมวลผลประมาณ 80%

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

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

ขึ้นอยู่กับขั้นตอนการพัฒนาของคุณ

1) ถ้าคุณสร้างฟังก์ชันการทำงานของซอฟต์แวร์ของคุณให้ทำงานต่อไปและตรวจสอบให้แน่ใจว่าทำงานได้ดี (เช่นต้องการและมีประสิทธิภาพ)

2) เมื่อ Building Block รวมเข้าด้วยกันคุณจะได้รับคำแนะนำของ hogger ทรัพยากรที่นั่นคุณมีพื้นที่สำหรับเพิ่มประสิทธิภาพ

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

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

การกระทำที่สมเหตุสมผลเพียงอย่างเดียวส่วนใหญ่จะไม่ทำอะไรเลย: คุณระบุว่าโค้ดของคุณจะไม่ถูกเรียกใช้บ่อยพอสำหรับปัญหาด้านประสิทธิภาพที่จะสังเกตได้ - อาจเป็นรหัสเริ่มต้นที่ทำงานหนึ่งครั้งต่อคอมพิวเตอร์หนึ่งเครื่องสำหรับ 1% ของฐานผู้ใช้ที่มีศักยภาพของคุณอาจเป็นรหัสเซิร์ฟเวอร์ซ้ำซ้อนเล็กน้อยจมน้ำตายในการเข้าถึงฐานข้อมูลที่ช้าอาจเป็นเพียงการกำหนดจำนวนเต็มในส่วนที่ไม่สำคัญของรหัส

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

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

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

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

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

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

จากนั้นปรับใช้ระบบให้ง่ายที่สุด หากเกิดปัญหาเรื่องประสิทธิภาพให้ปรับให้เหมาะสม

ตัวอย่างเช่นสมมติว่าคุณมีไคลเอนต์ GUI ที่รับข้อมูลผ่านบริการบางประเภท (SOAP, REST HTTP และอื่น ๆ ) สิ่งที่สำคัญที่สุดสำหรับประสิทธิภาพสูง / ความสามารถในการขยายคือการโทรน้อยที่สุดเท่าที่จะเป็นไปได้การโทรแต่ละครั้งจะส่งคืนข้อมูลจำนวนมากแทนที่จะโทรจำนวนมากส่งข้อมูลเล็กน้อยแต่ละครั้ง

เมื่อใช้ระบบประเภทนี้ฉันจะไม่สนใจจำนวนการโทรระหว่างระบบมากนัก แต่ฉันจะทำให้แน่ใจว่ารหัสฐานจะทำให้มันง่ายสำหรับฉันในการปรับโครงสร้าง / เพิ่มประสิทธิภาพเมื่อความต้องการเกิดขึ้น

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

คุณอาจต้องการสร้างนิสัยที่มีประสิทธิภาพ แต่สิ่งเหล่านี้จะขึ้นอยู่กับภาษา ใน C ++ ตัวอย่างเช่น "++ i;" อย่างน้อยที่สุดก็จะดีเท่ากับ "i ++;" และอาจมีประสิทธิภาพมากกว่า ในกรณีส่วนใหญ่คุณควรเขียนโค้ดที่ชัดเจนและเชื่อถือคอมไพเลอร์ การมีนิสัยกังวลเรื่องไมโครประสิทธิภาพจะทำให้คุณมีปัญหามากกว่าที่จะแก้ สำหรับแอปบนเดสก์ท็อปคอมไพเลอร์อย่างน้อยก็ฉลาดเหมือนคุณเกี่ยวกับอย่างi >> 1vs. i / 2หรือวิธีที่ดีที่สุดในการปรับปรุงประสิทธิภาพคือรับคอมไพเลอร์ที่ดีขึ้นดังนั้นอย่ากังวลไป

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

ฉันคิดว่าสิ่งที่ดีที่สุดที่คุณสามารถทำได้คือปฏิบัติตามแนวทางการออกแบบที่ดี (เช่นอย่าทำสิ่งที่คุณรู้ว่าจะเป็นอุปสรรคต่อการทำงาน) จนกว่าคุณจะได้งานอะไรสักอย่าง หากคุณไม่สามารถวัดการปรับปรุงคุณไม่สามารถทำการปรับปรุงได้ เมื่อคุณมีสิ่งที่คุณสามารถทดสอบได้แล้วก็มักจะเป็นความคิดที่ดีในการทำโปรไฟล์และรับความคิดที่ฮอตสปอต (ถ้ามี) หากสิ่งที่กระโดดออกมาจากคุณคุณควรพิจารณา refactoring หรือ rewriter พื้นที่ปัญหา แต่ถ้ามันไม่ได้เลวร้ายเกินไป (เพียงเพราะรหัสใช้เวลา 90% ของเวลาในสองหรือสามวิธีไม่ได้หมายความว่าอะไรถ้ามันมีประสิทธิภาพโดยรวมเพียงพอ) จากนั้นก็พัฒนาต่อไป สิ่งที่ฉันเห็นมากกว่าหนึ่งครั้งคือนักพัฒนาซอฟต์แวร์ที่ใช้เวลาหลายวันเพื่อปรับแต่งส่วนที่ซับซ้อนที่สุดของระบบ

ฉันควรเริ่มคิดเมื่อไหร่ ฉันควรใช้ความพยายามมากแค่ไหน? ขึ้นอยู่กับระดับของเบิร์นเบิร์นของโครงการ (กล่าวอีกนัยหนึ่งอะไรคือความเสี่ยงของการไม่มีประสิทธิภาพที่ดี?)

เรียนรู้พื้นฐานที่ดีล่วงหน้า (ดูคำตอบของ Robert Harvey ) เพื่อที่จะใช้การคิดเชิงประสิทธิภาพระหว่างขั้นตอนต่าง ๆ ของการพัฒนาซอฟต์แวร์ผู้พัฒนาจะต้องรู้ว่ามันอยู่ข้างในเพื่อที่ว่ากระบวนการคิดจะไม่ถูกขัดขวางโดยข้อพิจารณาพิเศษเหล่านั้น (กล่าวอีกนัยหนึ่งให้เริ่มคิดถึงการแสดงก่อนที่โครงงานจะเกิดขึ้น)

ในช่วงแรกของการพัฒนาให้ใช้เครื่องมือสร้างโปรไฟล์ประสิทธิภาพแบบเสรีและติดตามประวัติสถิติ ให้ความสนใจเป็นพิเศษในการจัดระเบียบข้อมูลดังกล่าวเพื่อให้มีประโยชน์สำหรับการตัดสินใจในภายหลัง

จากนั้นขึ้นอยู่กับลักษณะของโครงการและขนาดของเบิร์นเบิร์น:

• Rapid Prototyping หรือ "bang out code เหมือนที่ไม่มีวันพรุ่งนี้" หรือการพัฒนาภายในองค์กรที่มีผลกระทบทางธุรกิจต่ำ: เพียงเก็บสถิติไว้ อย่าคิดเกี่ยวกับการแสดงเลย ใช้ฟังก์ชันในวิธีที่ง่ายที่สุด ติดกับอัลกอริทึมแรกที่อยู่ในใจของคุณ

  • ในช่วงครึ่งหลังของโครงการจะมีการทดสอบประสิทธิภาพแบบเฉพาะกิจเพื่อระบุ "ฮอตสปอต" ตามกรณีการใช้งานจริง หากมีปัญหาประสิทธิภาพการทำงานใด ๆ ที่ทำให้ซอฟต์แวร์ใช้ไม่ได้ควรระบุได้อย่างง่ายดาย
  • สำหรับการพัฒนาภายในองค์กรที่มีผลกระทบทางธุรกิจต่ำเพียงปรับใช้รหัสและแก้ไขปัญหาด้านประสิทธิภาพในภายหลัง

• แอปพลิเคชั่นเดสก์ท็อปซึ่งต้องการวิธีการที่สอดคล้องและกลมกลืนกับประสิทธิภาพ ไม่จำเป็นต้องปรับให้เหมาะสมอย่างมาก อย่างไรก็ตามควรมี "แฮงค์" เพียงเล็กน้อย (ไม่ตอบสนอง) เท่าที่จะทำได้

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

• การคำนวณประสิทธิภาพสูงซึ่งต้องใช้ประสิทธิภาพสูงสุดจากฮาร์ดแวร์

  • แต่งตั้งบุคคลในทีมของคุณเพื่อรับผิดชอบในการวิเคราะห์และรายงานสถิติประสิทธิภาพ
  • สร้างทฤษฎีเกี่ยวกับคุณลักษณะของประสิทธิภาพตรวจสอบกับการทดลองและเปรียบเทียบกับการทำนายของคุณจากแบบจำลอง Comp Sci ที่ง่ายขึ้น
  * * * *

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

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

ฉันมักจะพึ่งพาสูตรง่ายๆ:

1. ทำให้มันใช้งานได้
2. ทำให้ถูกต้อง
3. ทำให้มันเร็ว

... เพื่อให้.

ตาม c2สูตรนี้จะนำมาประกอบกับเคนท์เบ็ค