Pipeline (ไปป์ไลน์)

Pipeline (ไปป์ไลน์)

- การทำงานของ Pipeline

- ประสิทธิภาพของ Pipeline
- การเชื่อมต่อของ Pipeline

- การขาดอิสระในการทำงานของ Pipelin

- ปัญหาของ Pipeline(Pipeline Hazards)

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

การทำงานของ Pipeline

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

ขั้นตอนหลักๆในการทำงานทั้งหมดมี 5 ขั้นตอน คือ

     • Instruction Fetch หรือ ภาครับคำสั่งจะทำหน้าที่รับคำสั่งใหม่ๆ ทั้งจากหน่วยความจำหลัก
หรือจากใน Instruction Cache เข้ามา เพื่อส่งต่อให้ภาคต่อไปจัดการต่อ
     • Instruction Decode หรือ ภาคการแปลคำสั่ง คือ จะทำหน้าที่แยกแยะคำสั่งต่างๆ ของ CISC
ซึ่งในตอนที่แล้ว เราทราบแล้วว่า CISC นั้น ในแต่ละคำสั่งจะมีขนาดที่ไม่แน่นอน ตรง
ส่วนนี้ก็จะทำการซอยคำสั่งนั้นเป็นคำสั่งย่อยๆ ให้มีความยาวเท่าๆกัน ในลักษณะเช่นเดียว
กับ RISC เรียกคำ สั่งย่อยๆ นั้นว่า Micro Operation
     • Get Operands หรือ ภาครับข้อมูล คือ รับข้อมูลที่จะใช้ในการประมวลผลเข้ามาเก็บไว้ เช่น
จากขั้นตอนที่ 2 เรารู้ว่าจะใช้การ "บวก" ก็ต้องรับค่าที่จะใช้ในการบวก มาด้วยอีก 2 ค่า
บางทีขั้นตอนนี้ ก็ถูกรวมเข้ากับขั้นตอนที่ 2
     • Execute หรือ ภาคประมวลผล เป็นขั้นตอนที่ทำการประมวลผลตามคำสั่งและ operand ที่
ได้รับมาจากขั้นที่ 2 และ 3 ซึ่ง ถ้าให้ขั้นที่ 2 เป็นการถอดรหัสว่าเป็นการบวก ขั้นที่ 3 รับ
ค่าที่จะบวก ขั้นนี้ ( ขั้นที่ 4 ) ก็จะทำการบวกให้ได้ผลลัพธ์ออกมา

     • Write Result หรือ ภาคการเขียนข้อมูลกลับ เมื่อทำการประมวลผลเสร็จสิ้น ผลลัพธ์ที่ได้ก็
จะนำ ไปเก็บไว้ใน register หรือ ใน Data Cache ซึ่งบางที ขั้นตอนนี้ ก็ถูกมองรวมไว้กับขั้น
ที่4  

 

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

     Pipeline จะทำการประมวลผลในแต่ละคำสั่งด้วยความเร็วสูง ถ้าการ fetch และ
execute ใช้เวลาใกล้เคียงกัน โดยจะทำให้เวลาในการทำงานจะเหลือครึ่งหนึ่ง การ execute
ในแต่ละขั้นตอนนั้นจะมีความแตกต่างกัน แบ่งออกได้เป็น 2 ข้อดังนี้
1. execute time จะใช้เวลามากกว่าเวลาที่ใช้ในการ fetch ซึ่งการ execute นั้นยังก่อ
ให้เกิดการอ่านและการสะสมในแต่ละขั้นตอน ซึ่งขั้นตอนการ fetch จะใช้เวลารอในการ fetch
หาที่ว่าง
2. การเปลี่ยนแปลง address ของชุดคำสั่งจะทำให้ชุดคำสั่งถัดไปไม่มีการ fetch โดย
ขั้นตอนการ fetch จะต้องรอจนกระทั่งรับคำสังจากชุดคำสั่งถัดไปจากขั้นตอนการ execute

จาก 2 เหตุผลดังกล่าวทำ ให้ลดการเสียเวลาที่ใช้ในการสุ่มเลือก เมื่อมีการปรุบเปลี่ยน
ชุดคำ สั่งที่ผ่านการ fetch จากขั้นตอนการ execute ขั้นตอนการ fetch จะทำ การ fetch ชุดคำ สั่ง
ถัดไปภายในหน่วยความจำ หลัก ถ้าสาขาของ Pipeline ไม่มีการทำ งานก็จะไม่เสียเวลาในการ
ทำ งาน แต่ถ้าสาขาของ Pipeline มีการทำ งานเกิดขึ้น การ fetch ชุดคำ สั่งจะต้องยกเลิกไปและ
จะต้องทำ การ fetch ในชุดคำ สั่งใหม่
     ขณะที่ปัจจัยดังกล่าวสามารถลดผลกระทบของ Pipeline ได้ทั้งสองขั้นตอน และสามารถ
เพิ่มความเร็วในการทำ งานได้มากขึ้น ดังนั้นเราต้องคำ นึงถึงการประมวลผลชุดคำสั่งที่ต้องแบ่ง
ออกเป็นส่วนๆ
- Fetch instruction (FI) : การอ่านขุดคำ สั่งที่จะเข้าสู่การประมวลผล
- Decode instruction (DI) : การกำหนด opcode และ operand
- Caculate operands (CO) : การคำนวณผลกระทบที่ต่างๆ เช่น involve
displacement ,register indirect ,indirect เป็นต้น
- Fetch operands (FO) : การ fetch ในแต่ละ operand จากหน่วยความหลัก
- Execute instruction (EI) : การแสดงการทำงานและเก็บผลที่ได้จากการประมวลผล
- Write operand (WO) : การเก็บผลที่ได้จากการประมวลผลในหน่วยความจำหลัก
จากข้อความข้างต้นแสดงให้เห็นว่าในแต่ละชุดคำ สั่งควรจะใช้ทั้งหมด 6 ขั้นตอนใน
Pipeline แต่นั่นก็ไม่เสมอไป ดังเช่นตัวอย่าง ,การดึงชุดคำ สั่งนั้นไม่จำ เป็นต้องใช้ขั้นตอน WO
อย่างไรก็ตาม Pipeline แบบง่ายๆ ใน hardware เวลาก็จะกำหนดขึ้นเมื่อมีการเรียกจากทั้งหมด
6 ขั้นตอน โดยในแต่ละขั้นตอนนั้นจะมีการทำงานที่คล้ายคลึงกัน ดังเช่นตัวอย่าง ,ขั้นตอน FI
,FO และ WO กำลังอยู่ในระหว่างการเข้าถึงหน่วยความจำ และถ้ามีพื้นที่ว่างภายในหน่วยความ
ดังกล่าวจะมีการเข้าถึงข้อมูลเกิดขึ้นในเวลาเดียวกันอย่างไรก็ตาม อาจจะมีการเก็บข้อมูลต่างๆ
ในขั้นตอน FO และ WO อาจจะใช่ไม่ได้ การใช้เวลามากๆ ในการทำงานซึ่งจะทำให้หน่วยความ
จำ ที่เก็บข้อมูลที่ต่างกัน ซึ่งจะทำ ให้การทำงานของ Pipeline ช้าลง
อีกหลายๆ ปัจจัยที่มีผลทำ ให้ประสิทธิภาพในการทำงานสูงขึ้น ถ้าขั้นตอนที่กล่าวมาทั้ง
6 นั้นไม่มีความสมดุลกันก็จะทำให้เสียเวลาในการทำงานในแต่ละขั้นตอน และอีกหนึ่งปัจจัยที่มี
ส่วนสำ คัญในการปรับเปลี่ยนชุดคำสั่ง โดยที่สามารถทำให้การ fetch ชุดคำสั่งให้ไม่สามารถใช้
งานได้ และไม่สามารถที่จะทำการคาดเดาได้ทำให้การทำงานหยุดชะงักลง
ดังที่กล่าวมาแล้ว การทำงานจะแสดงให้เห็นถึงการทำงานของ Pipeline ที่ใช้เวลาใน
execute ชุดคำสั่งได้อย่างดี โดยเห็นได้จากเครื่อง IBM S/360 ชี้ให้เห็นถึงปัจจัยหลักๆ 2 ข้อ
ซึ่งจะเข้าไปทำลายระบบที่มีผลต่อประสิทธิภาพในการทำงาน
1. ในแต่ละขั้นตอนของ Pipeline ซึ่งจะก่อให้เกิดการเคลื่อนที่ของข้อมูล และในการ
ทำ งานจะทำให้เกิดความพร้อมและประโยชน์ในหลายๆ ด้าน โดยจะใช้เวลามากพอสมควรใน

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

ประสิทธิภาพของ Pipeline

     ในส่วนย่อยๆ นั้น เราสามารถพัฒนาการทำงานของ Pipeline และการเพิ่มความรวดเร็ว
ของเวลาที่ใช้ในการทำงาน cycle time (T) ของชุดคำสั่งที่ทำงานโดย Pipeline คือเวลาที่
ต้องการให้เกิดการพัฒนาในขั้นตอนของ Pipeline

การเชื่อมต่อของ Pipeline

     ปัญหาใหญ่ในการออกแบบชุดคำสั่ง Pipeline คือการทำให้ผลที่ได้ออกมาได้ผลดีในขั้น
ตอนแรกของชุดคำสั่งปัญหาแรกคือการปรับเปลี่ยนของชุดคำสั่งจนกระทั่งจะมีการ execute
ซึ่งเป็นไปไม่ได้ที่จะกำหนดสาขาของ Pipeline

ประสิทธิภาพเบื้องต้นของ Pipelining
Pipelining จะทำ ให้ชุดคำ สั่งใน CPU ทำ งานเร็วขึ้นโดยชุดคำ สั่งที่สมบูรณ์ต่อหน่วยเวลา
แต่ไม่สามารถลดเวลาในการทาํ งานในการแยกชุดคาํ สั่ง ในขอ้ เทจ็ จรงิ โดยปกตแิ ลว้ เวลาในการ
ทำ งานเพิ่มขึ้นเล็กน้อย ชุดคำ สั่งจะกำ หนดโดย overhead ที่ควบคุมโดย pipeline ในการเพิ่มชุดคำ สั่ง
นั้น คือ ตัว program สามารถ runได้รวดเร็วและเวลาในการ executing น้อย
ข้อจำ กัดที่เหมาะสมของ pipeline จะเกิดขึ้นจาก
-! pipeline latency : เกี่ยวกับเวลาในการ executue ของชุดคำ สั่งทุกชุดคำ สั่งนั้น ไม่ทำ ให้ข้อจำ กัด
ของการเกิด pipeline ลดลง
-! Imbalanc among pipeline stage : การไม่เหมาะสมของจำ นวน pipeline ทำ ให้ประสิทธิภาพนั้น
ลดลง clock time ไม่สามารถ run ได้รวดเร็วกว่าเวลาที่ต้องการ ทำ ให้ขั้นตอนการ pipeline นั้น
ช้าลง
-! pipeline overhead : pipeline overhead เกิดจากการรวมของ pipelining register delay (เวลาใน
การเกิดข้นรวมกับเวลาในการแพร่กระจาย) and clock skew

ปัญหาที่เป็นอุปสรรคของ Pipeline

ปัญหาที่เกิดจาก pipeline คือ
1.Structural Hazards : เกิดจากการขัดแย้งเมื่อ hardware ไม่สามารถรองรับการรวมชุดคำ สั่งพร้อม
กันในเวลาเดียวกัน เกิดการทับซ้อนกันเมื่อมีการ execute
2. Data Hazards : เกิดจากการทีชุดคำสั่งทับซ้อนกัน ไม่สามารถที่จะ execute
3.Control Hazard : pipe line ที่แยกชุดคำสั่งไม่สามารถควบคุมสัญญาณได้
ปัญหา pipe line แก้ได้โดย ใช้ตัวถ่วงเวลา
-! A cache miss : ชุดคำสั่งทั้งหมดของ pipe line ทั่งก่อนและหลังขาดหายไป
-! A hazard in pipe line : ชุดคำสั่งของ pipe line จะยอมรับการ process โดยที่ตัวอื่นๆช้าลง เมื่อ มี
การถ่วงเวลาจะทำให้ชุดคำสั่งช้าลงด้วย ปัญหาที่เกิดขึ้น จากโครงสร้าง (Structural Hazard)
เมื่อมีการทำ Pipeline มีการทับซ้อนกันของชุดคำ สั่ง ในการทำงาน เมื่อ functional unit เกิด
การทำซํ้าเป็นไปได้ที่ชุดคำสั่งมีการรวมกันในการทำ Pipeline ถ้าการรวมชุดคำสั่งไม่สามารถจะ
บรรลุเป้าหมายได้ เพราะเกิดการขัดข้องของเครื่องเรียกว่า Structural hazard
ตัวอย่างการเกิด Structural hazard เมื่อ
-! functional unit ไม่เต็มที่ของ Pipeline โดยลำดับของชุดคำสั่งไม่เป็นแบบ pipe line ถ้าไม่
สามารถทำ การ
-! process rate of one per clock cycleเมื่อบางส่วนไม่สามารถทำงานซํ้าได้ ทำให้ไม่สามารถรวม
ชุดคำ สั่งได้ เมื่อมีการทำ pipe line
ข้อเสนอแนะ
ก่อนที่ประสิทธิภาพจะลดลง เราสามารถออกแบบ Structural hazard ได้อย่างไร
-! ลดการสูญเสีย และเครื่องสามารถรองรับชุดคำสั่งได้
-! ลด latency of the unit

การขาดอิสระในการทำงานของ Pipeline

     เมื่อเราทราบแล้วว่าการให้ CPU ทำงานโดยการใช้ Pipeline นั้นทำให้ประสิทธิภาพสูงขึ้น
จึงมีคำถามเกิดขึ้นว่า ทำไมถึงไม่ให้ CPU ใช้ Pipeline จำ นวนมาก ๆ เช่นอาจเพิ่มจำนวน Pipeline
ให้มากถึง 500 Pipeline
การให้ CPU ทำ งานโดยใช้ Pipeline นั้นทำ ให้ประสิทธิภาพนั้นดีขึ้น จริงอยู่ แต่การที่จะให้
มีการใช้ Pipeline เป็นจำ นวนมาก ๆ ถึง 500 Pipeline นั้นเป็นสิ่งที่เป็นไปได้ยาก เนื่องจากว่า การใช้
Pipeline จำ นวนมากขนาดนั้นจะทำ ให้ระบบการทำ งานภายใน Pipeline นั้นมีความยุ่งยากมากขึ้น
และที่สำ คัญคือ ขนาดของ Die จะต้องใหญ่ขึ้นกว่าเดิมถึง 500 เท่าหากเทียบกับ CPU ที่ทำ งานโดย
ไม่ใช้ Pipeline ซึ่งจะส่งผลให้ค่าใช้จ่ายสูงขึ้น และจะทำ ให้ CPU ตัวนั้นมีราคาแพงเกินไป
แม้ว่าการทำ งาน โดยใช้ Pipeline นั้นจะส่งผลดีต่อระบบ แต่โดยปกติแล้วคำ สั่งประมาณ
10-20% จะเป็นคำ สั่งย่อย ๆ เช่น คำ สั่งที่ 1 กำ หนดให้ค่าของ c=a+b และคำ สั่งที่ 2 ถ้าค่าของ c มาก
กว่า 4 ให้คูณค่าของ c ด้วย 2 โดยหากคำ สั่งมีลักษณะเช่นนี้ จะไม่สามารถทำ คำ สั่งที่ 2 ได้จนกว่าจะ
ได่ผลลัพธ์ของคำ สั่งที่ 1 ก่อน ซึ่งปัญหานี้ก็ได้เกิดขึ้นกับ การใช้ Pipeline ของ CPU เนื่องจากการ
ทำ งานในคำ สั่งที่ 1 นั้นยังไม่ได้มีการบันทึกผลลงหน่วยความจำ เลย ก็มีการคำ นวณในคำ สั่งที่ 2
แล้ว ดังนั้นเมื่อเกิดปัญหา เช่น ทำ ให้ Pipeline นั้นต้องมีการรอให้มีการบันทึกผลในคำ สั่งที่ 1 เสร็จ
สิ้นก่อนถึงจะทำ งานได้ ซึ่งการรอนี้จะส่งผลให้เสียเวลาไปอย่างน้อย 1 สัญญาณนาฬิกา ซึ่งอาจทำ
ให้ประสิทธิภาพของระบบลดลงได้ และหากใช้ Pipeline ที่มากกว่านี้ ก็จะมีการรอที่นานขึ้น