Architecting Software Systems: Performance (นานา Latency ใน serial request)

เราจะพูดถึงเรื่อง Latency ที่เป็นของ serial request (หรือ single request) ในส่วนต่างๆ กัน

Latency คืออะไร?

Latency (เลเทนซี) หรือ เวลาแฝง คือ ระยะเวลาในการเดินทางของข้อมูลจากต้นทางไปยังปลายทาง มีหน่วยวัดเป็น มิลลิวินาที (millisecond) ส่งผลต่อประสิทธิภาพของในการทำงานต่างๆ ของระบบ

เพื่อที่จะปรับปรุงประสิทธิภาพของระบบ เราจำเป็นต้องลดเวลาในการ response ลง โดยเวลาแฝงนั้นมีอยู่ 2 ประเภท คือ

เวลาแฝงของ request แบบอนุกรม (serial / single request latency)
เวลาแฝงของ request แบบขนาน (parallel request latency)

ในหัวข้อนี้เราจะกล่าวถึงเวลาแฝงที่เป็นแบบอนุกรม หรือ single request latency เป็นหลัก

Network transfer latency

ถ้าพูดถึง network latency นั้น หมายถึง เวลาที่ใช้ในการส่งข้อมูลจากจุดหนึ่งไปยังอีกจุดหนึ่งในเครือข่าย

ดังนั้นถ้าพูดถึงเวลาแฝงของเครือข่าย เราจะสามารถแบ่งมันออกมาเป็น 2 เครือข่ายใหญ่ๆ คือ

Internet

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

Intranet

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

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

Minimizing network transfer latency

เวลาแฝงของเครือข่ายมีองค์ประกอบที่สำคัญ 2 ประการ
1. เวลาแฝงที่เกี่ยวข้องกับการถ่ายโอนข้อมูล
2. เวลาแฝงที่เกี่ยวข้องกับการสร้างการเชื่อมต่อ

Memory access latency

เวลาแฝงหน่วยความจำนั้น เราจะรู้ๆ กันอยู่แล้วว่า มันจะเกิดจากข้อจำกัดของขนาด memory (แมมเต็ม) แต่ถ้าหากเราลองเจาะลึกลงไป เราจะเห็นว่า จริงๆ แล้ว latency ที่เกิดขึ้นนั้น ไม่ได้มีแค่การเก็บข้อมูลที่เยอะๆ ลงไปใน memory เท่านั้น มันมีสาเหตุอื่นที่ลึกว่านั้นอยู่ด้วย

หน่วยความจำฮีปจำกัด (finite heap memory)

ปัญหาแรกเลย คือ ถ้าเราเข้าใจเรื่อง Heap กับ Stack เราะก็จะรู้ว่า heap นั้น จะช่วยเราบริหารจัดการ memory ได้ดีกว่า stack

แต่ใน heap memory นั้น มันมีการจัดการ memory เพิ่มเข้ามา คือ Garbage Collectors (GC) ที่ทำหน้าที่คอยเคลียข้อมูลที่ไม่ได้ใช้งานแล้วออกไป ซึ่งแต่ละภาษาจะมีวิธีการเคลียไม่เหมือนกัน และมันส่งผลต่อเวลาในการจัดการตรงนี้ด้วย

โดยส่วนใหญ่เราไม่ได้เข้ามาจัดการในส่วนนี้ เพราะตัวภาษามาจัดการให้เอง การแก้ปัญหาเรื่องนี้เลยไม่ค่อยได้พบเจอบ่อยๆ

หน่วยความจำฮีปขนาดใหญ่ (Large Heap Memory)

ในการใช้งาน heap memory นั้น จริงๆ แล้วมันอาจจะใช้หน่วยความจำมากกว่าที่มีอยู่ในเครื่องนั้น ดังนั้น heap memory มีโอกาศที่จะใหญ่กว่า physical memory จริงๆ และถ้าหากเป็นอย่างนั้นตัว os ก็จะต้องใช้ hard disk เพื่อรองรับหน่วยความจำที่เกินมาสำหรับ heap memory ที่เกิดขึ้น ทำให้เกิดการแลกเปลี่ยนข้อมูล (swapping of data) ภายใน physical memory และระหว่าง physical memory กับ hard disk นั่นเอง ซึ่งมันจะส่งผลให้เกิดความช้าเกิดขึ้น

ต่อให้ physical memory ของเราจะใหญ่มากแค่ไหน นั่นก็หมายความว่า heap ของเราก็จะใหญ่ขึ้นตามไปด้วย เวลาที่จะเคลียขยะ ก็จะทำงานหนักตามไปด้วยเช่นกัน ซึ่งมันจะทำให้อัลกอริธึมของตัวรวบรวมขยะช้าลงไปด้วย

อัลกอริธึมของ GC (Garbage Collectors Algorithm)

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

ถ้าเราไม่ทำอย่างนั้น ถ้าเราต้องทำงานที่มีการ process ข้อมูลเยอะๆ ก็จะเจอกับปัญหาเรื่อง performance แน่นอน

สรุปง่ายๆ คือ เลือกภาษาที่ใช้นั่นแหละ เพราะเราไม่สามารถเข้าไปเปลี่ยน algorithm ของภาษานั้นได้ ดังนั้นก็เลือกภาษาให้เหมาะกับงาน

หน่วยความจำที่จำกัดของฐานข้อมูล (finite buffer memory on database side)

ตัวนี้ทุกคนน่าจะรู้จักกันดี เพราะการอ่านหรือเขียนอะไรใดๆ ที่เกิดขึ้นกับ database มันจะเกิดขึ้นบน memory ของ database อยู่แล้ว

สมมติว่า เราจะทำการเขียนข้อมูลลง database สิ่งที่จะเกิดขึ้นเลย คือ ระบบของ database จะไปอ่านข้อมูลก่อน โดยไปดึงข้อมูลจาก hard disk มาไว้ที่ memory แล้วก็ทำงานของมันไปจนเสร็จ แล้วค่อยนำกลับไปเขียนลง hard disk อีกทีหนึ่ง

ดังนั้น การใช้งานหน่วยความจำของ database มันจึงสำคัญมากๆ และมันมักจะเกิดปัญหาในส่วนนี้บ่อยๆ ด้วยเช่นกัน

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

Minimizing memory access latency

ข้างบนก็มีการบอกวิธีการแก้ปัญหาไว้บ้างแล้ว ดังนั้นสรุปเป็นภาพเหมือนเดิม

Disk Latency

เนื่องจาก disk I/O เป็นหนึ่งใน I/O ที่ช้าที่สุด ถ้าเทียบกับตัวอื่นๆ แต่แทบทุกอย่างในระบบต้องมีการใช้งาน disk I/O เพราะจำเป็นต้องทำการบันทึกข้อมูล รวมถึงเก็บ logging อยู่เสมอ

ความช้าของ disk I/O นั้น มีผลกระทบต่อประสิทธิภาพในการเข้าถึงข้อมูลบน disk ด้วยเช่นกัน ซึ่งเราจะเห็นมันได้ชัดกับการพวก database หรือ web application

โดยในกรณีของ web application นั้น ความช้า (เวลาแฝง) ของ disk อาจเห็นได้จากการที่ต้องไปดึงเนื้อหาจากไฟล์ HTML, JavaScript, CSS หรือไฟล์รูปภาพจาก hard disk

ส่วน database นั้น เวลาแฝงของ disk เป็นอะไรที่ค่อนข้างท้าทายหน่อย เนื่องจากข้อมูลต่างๆ ที่ถูกอ่านหรือเขียนบน database สุดท้ายมันจะถูกดึงมาจาก hard disk หรือ ถูกส่งกลับไปยัง hard disk ดังนั้น database จึงเป็นอีกจุดหนึ่งที่เวลาแฝงของ disk และมีความสำคัญมากๆ

เมื่อถึงจุดหนึ่ง ที่การทำงานของระบบเริ่มช้ามากๆ เราต้องมาพิจารณาในส่วนนี้ด้วยเสมอ

Disk Latency Approaches

CPU Processing Latency

ตัวสุดท้ายที่จะพูดถึงเกี่ยวกับเวลาแฝงของ serial request คือ เวลาแฝงของ CPU

โดยทั่วไปแล้วการที่เกิด CPU latency นั้นมักจะมีเหตุผล 2 ข้อ คือ

Inefficient Algorithms: อัลกอริทึมที่ไม่มีประสิทธิภาพ (แก้ไขได้โดย developers)
Context switching: การสลับบริบทซึ่งมักไม่ชัดเจนและส่งผลกระทบต่อทั้งระบบ

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

ส่วน context switching นั้น เป็นอะไรที่ค่อนข้างลงลึกเข้าไปอีกหน่อย ซึ่งจะโฟกัสที่ตัวนี้

ก่อนอื่น เราจะดูว่าการ switch context มันลดประสิทธิภาพของระบบได้อย่างไร จากนั้นเราจะดูแนวทางในการเอาชนะผลกระทบของการ switch context หรือวิธีลดกา switch context ให้เหลือน้อยที่สุด

ดังนั้นการ switch context จึงเป็นสิ่งที่ส่งผลกระทบต่อทั้งระบบ ดังนั้นเราจึงต้องใส่ใจกับการswitch context ใน context ของส่วนประกอบทั้งหมดภายในระบบ

ปัญหาของการ switch context คือ อะไร

การ context switching มักจะส่งผลต่อสภาพแวดล้อมที่เราใช้งานหลายกระบวนการบนเครื่อง หรือหลาย threads บนเครื่อง ซึ่งมันอยู่ในแทบทุกเครื่องที่เราใช้งาน ดังนั้นมันจึงส่งผลกระทบต่อส่วนประกอบทั้งหมดภายในระบบของเราค่อนข้างมาก

สมมติว่าเรามีเครื่อง CPU เครื่องเดียว และเครื่องนั้น เรากำลัง run อยู่ 2 process:

Process 1 และ Process 2

สถานการณ์นี้หากเรารัน 2 เธรดบนเครื่องนี้ กระบวนการทำงานภายในมันจะใกล้เคียงกัน สมมติว่าเราสามารถรันเธรด 1 และเธรด 2 ภายใน single process ได้ เลยขอพูดรวมๆ กันไปเลยละกัน

สมมติว่าตอนนี้ process ที่ 1 กำลังทำงานอยู่บนเครื่อง และกำลังครอบครอง CPU นี้อยู่ ดังนั้น process ที่ 2 จะต้องรอให้ตัว process ที่ 1 ถูกขับไล่ (ถูกดีดออก) จาก CPU ก่อน เพื่อให้สามารถเริ่มการทำงาน process ที่ 2 ได้ ซึ่งทั้งหมดนี้ทำโดย OS

สิ่งที่สามารถเกิดขึ้นได้ คือ สมมุติว่า process ที่ 1 พยายามทำ I/O บางอย่าง เช่น พยายามเข้าถึง disk หรืออาจลอง call ผ่าน network ซึ่งถ้ากำลังทำงานประเภทนี้ process นี้อยู่ละก็ OS จะเอา process นี้ ออกจาก CPU ไปก่อน แล้วเอา process ที่ 2 เข้ามาทำงานแทน

เมื่อ process ที่ 2 ทำงานเสร็จแล้ว หรือ ต้องรออะไรเพิ่มเติม ตัวระบบปฏิบัติการก็จะเอา process ที่ 2 ออกไปรอก่อน (หรือจบเลย) แล้วเอา process ที่ 1 มาทำต่อ นั่นเอง

ถ้าลงรายละเอียดอีกนึดนึง ทุกครั้งที่มีการเอา process ออกไปรอ cpu จะมีการเก็บ control block ไว้ที่ memory เพื่อบอกว่าทำอะไรไปถึงไหนแล้ว และเมื่อ process ที่ 2 โดนเอาออกจาก cpu ก็จะมีการบันทึกลง control block และสลับเอา process ที่ 1 มาทำต่อ โดยเข้าไปดูใน control block ว่าทำถึงไหนแล้ว กระบวนการทั้งหมดนี้จะเกิดขึ้นก่อนที่จะประมวลผล

การ switch context นี้เกิดขึ้นเนื่องจาก process ที่ 1 นี้ตัดสินใจทำ I/O ดังนั้นหากเราหลีกเลี่ยงการใช้งาน I/O ได้ เราจะลด cost ส่วนนี้ไปได้

ในทำนองเดียวกัน ถ้าเรายังคงทำสิ่งต่างๆ ที่ให้เกิดการรอของ cpu เช่น I/O ในระหว่างการประมวลผล process นี้ ก็จะถูก cpu ไล่ให้ออกเป็นทำกระบวนการนี้ก่อน จากนั้นจึงกลับมาที่สถานะดำเนินการต่อ

CPU ไม่ได้ไปอ่านข้อมูลตรงๆ จาก disk แต่จะไปอ่านบน memory ดังนั้นมันก็จะโดนสั่งให้ ไปเอาข้อมูลมาไว้บน memory ก่อน ตัว cpu จึงจะประมวลผลต่อได้

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

ดังนั้น นี่คือสิ่งที่ส่งผลต่อ performance ของระบบ เพราะหาก process ที่ควรทำให้เสร็จจริงใน 100 ms แต่ดันไปโดน cpu ไล่ออกไป 2-3 ครั้ง ก็อาจเพิ่มเวลาในการดำเนินการเข้าไปอีก 100 ms ก็ได้ (ไปดู cpu ของ database ได้)

CPU Latency Approaches

สุดท้าย ตัวอย่างของ latency cost