ในสถาปัตยกรรมคอมพิวเตอร์ช่องหน่วงเวลาคือช่องคำสั่งที่ถูกดำเนินการโดยไม่ได้รับผลกระทบจากคำสั่งก่อนหน้า^{[ 1 ]}รูปแบบที่พบได้บ่อยที่สุดคือคำสั่งเดียวแบบสุ่มที่อยู่ถัดจากคำสั่งกระโดด ใน สถาปัตยกรรม RISCหรือDSP ทันที คำสั่งนี้จะดำเนินการแม้ว่าการกระโดดก่อนหน้าจะเกิดขึ้นก็ตาม ซึ่งทำให้คำสั่งนี้ดำเนินการนอกลำดับเมื่อเทียบกับตำแหน่งในโค้ดภาษาแอสเซมเบลอร์ ดั้งเดิม

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

โดยทั่วไปแล้ว หน่วยประมวลผลกลางจะดำเนินการตามคำสั่งจากรหัสเครื่องโดยใช้กระบวนการสี่ขั้นตอน ขั้นแรก คำสั่งจะถูกอ่านจากหน่วยความจำ จากนั้นถอดรหัสเพื่อทำความเข้าใจว่าต้องดำเนินการอะไร จากนั้นจึงดำเนินการตามการกระทำเหล่านั้น และสุดท้าย ผลลัพธ์ใดๆ จะถูกเขียนกลับไปยังหน่วยความจำ ในการออกแบบยุคแรกๆ แต่ละขั้นตอนเหล่านี้จะดำเนินการตามลำดับ ดังนั้นคำสั่งจึงใช้เวลาหลายเท่าของรอบสัญญาณนาฬิกา ของเครื่อง ในการดำเนินการให้เสร็จสมบูรณ์ ตัวอย่างเช่น ในZilog Z80จำนวนสัญญาณนาฬิกาขั้นต่ำที่จำเป็นในการดำเนินการคำสั่งให้เสร็จสมบูรณ์คือสี่ แต่บางคำสั่ง (ที่หายาก) อาจใช้เวลามากถึง 23 สัญญาณนาฬิกา^{[ 2 ]}

ในแต่ละขั้นตอนของการประมวลผลคำสั่ง จะมีเพียงส่วนเดียวของชิปที่เกี่ยวข้อง ตัวอย่างเช่น ในระหว่างขั้นตอนการดำเนินการ โดยทั่วไปจะมีเพียงหน่วยคำนวณและตรรกะ (ALU) เท่านั้นที่ทำงาน ในขณะที่หน่วยอื่นๆ เช่น หน่วยที่โต้ตอบกับหน่วยความจำหลักหรือถอดรหัสคำสั่ง จะไม่ได้ทำงาน วิธีหนึ่งในการปรับปรุงประสิทธิภาพโดยรวมของคอมพิวเตอร์คือการใช้ไปป์ไลน์คำสั่งซึ่งจะเพิ่มวงจรเพิ่มเติมเพื่อเก็บสถานะกลางของคำสั่งขณะที่ไหลผ่านหน่วยต่างๆ แม้ว่าสิ่งนี้จะไม่ปรับปรุงจังหวะเวลาของคำสั่งใดๆ แต่แนวคิดคือการอนุญาตให้คำสั่งที่สองใช้หน่วยย่อย CPU อื่นๆ เมื่อคำสั่งก่อนหน้าได้ดำเนินการต่อไปแล้ว^{[ 3 ]}

ตัวอย่างเช่น ในขณะที่คำสั่งหนึ่งกำลังใช้ ALU คำสั่งถัดไปจากโปรแกรมอาจอยู่ในตัวถอดรหัส และคำสั่งที่สามอาจถูกดึงมาจากหน่วยความจำ ใน การจัดเรียงแบบ สายการผลิต นี้ จำนวนคำสั่งทั้งหมดที่ประมวลผลในเวลาใด ๆ สามารถปรับปรุงได้มากถึงจำนวนขั้นตอนของไปป์ไลน์ ตัวอย่างเช่น ใน Z80 ไปป์ไลน์สี่ขั้นตอนสามารถปรับปรุงปริมาณงานโดยรวมได้ถึงสี่เท่า อย่างไรก็ตาม เนื่องจากความซับซ้อนของจังหวะเวลาของคำสั่ง จึงไม่ใช่เรื่องง่ายที่จะนำไปใช้สถาปัตยกรรมชุดคำสั่ง (ISA) ที่เรียบง่ายกว่ามากของMOS 6502อนุญาตให้รวมไปป์ไลน์สองขั้นตอน ซึ่งทำให้มีประสิทธิภาพประมาณสองเท่าของ Z80 ที่ความเร็วสัญญาณนาฬิกาใด ๆ ก็ตาม^{[ 4 ]}

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

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

top: lw t0 , 0 ( a0 ) ; โหลดค่าจากที่อยู่หน่วยความจำในรีจิสเตอร์ a0 ไปยังรีจิสเตอร์ t0 lw t1 , 4 ( a0 ) ; โหลดค่าจากที่อยู่หน่วยความจำ [ค่าของรีจิสเตอร์ a0 บวก 4] ไปยังรีจิสเตอร์ t1 add t2 , t0 , t1 ; บวกค่ารีจิสเตอร์ t0, t1 เข้าด้วยกันในรีจิสเตอร์ t2 sw t2 , 0 ( a1 ) ; เก็บค่าในรีจิสเตอร์ t2 ไปยังที่อยู่หน่วยความจำในรีจิสเตอร์ a1 lw t4 , 8 ( a0 ) ; โหลดค่าจากที่อยู่หน่วยความจำ [ค่าของรีจิสเตอร์ a0 บวก 8] ไปยังรีจิสเตอร์ t4

ในกรณีนี้ โปรแกรมเป็นแบบเชิงเส้นและสามารถใช้การประมวลผลแบบไปป์ไลน์ได้อย่างง่ายดาย ทันทีที่lwคำสั่งแรก (โหลดคำ) ถูกอ่านและกำลังถอดรหัสlwคำสั่งที่สองก็สามารถอ่านจากหน่วยความจำได้ เมื่อคำสั่งแรกเริ่มทำงาน ค่าจากคำสั่งที่สองก็addจะถูกอ่านจากหน่วยความจำในขณะที่คำสั่งที่สองlwกำลังถอดรหัส และเป็นเช่นนี้เรื่อยไป แม้ว่าการประมวลผลคำสั่งแรกจะยังคงใช้จำนวนรอบเท่าเดิมlwแต่เมื่อเสร็จสิ้นแล้ว ค่าจากคำสั่งที่สองก็จะพร้อมใช้งานและ CPU สามารถบวกค่าทั้งสองได้ทันที ในโปรเซสเซอร์ที่ไม่ใช้การประมวลผลแบบไปป์ไลน์ คำสั่งสี่คำสั่งแรกจะใช้เวลา 16 รอบในการประมวลผล แต่ในโปรเซสเซอร์แบบไปป์ไลน์ จะใช้เวลาเพียงห้ารอบเท่านั้น

ทีนี้ลองพิจารณาสิ่งที่เกิดขึ้นเมื่อมีการเพิ่มสาขา:

top: lw t0 , 0 ( a0 ) ; โหลดค่าจากที่อยู่หน่วยความจำในรีจิสเตอร์ a0 ไปยังรีจิสเตอร์ t0 lw t1 , 4 ( a0 ) ; โหลดค่าจากที่อยู่หน่วยความจำ [ค่าของรีจิสเตอร์ a0 บวก 4] ไปยังรีจิสเตอร์ t1 add t2 , t0 , t1 ; บวกค่ารีจิสเตอร์ t0, t1 เข้าด้วยกันในรีจิสเตอร์ t2 li t3 , 1000 ; ตั้งค่ารีจิสเตอร์ t3 เป็น 1000 bgt t2 , t3 , top ; ถ้า t2 > t3 ให้กลับไปที่ "top:" ; มิฉะนั้น: sw t2 , 0 ( a1 ) ; เก็บค่าในรีจิสเตอร์ t2 ไปยังที่อยู่หน่วยความจำในรีจิสเตอร์ a1 lw t4 , 8 ( a0 ) ; โหลดค่าจากที่อยู่หน่วยความจำ [ค่าของรีจิสเตอร์ a0 บวก 8] ไปยังรีจิสเตอร์ t4

ในตัวอย่างนี้ ผลลัพธ์ของการเปรียบเทียบในบรรทัดที่สี่จะทำให้ "คำสั่งถัดไป" เปลี่ยนไป บางครั้งจะเป็นคำสั่งต่อไปนี้sw(เก็บคำ) ลงในหน่วยความจำ และบางครั้งจะเป็นคำสั่งlwจากหน่วยความจำด้านบน โดยปกติแล้วไปป์ไลน์ของโปรเซสเซอร์จะอ่านคำสั่งถัดไปเสร็จแล้วswเมื่อ ALU คำนวณเส้นทางที่จะใช้ นี่เรียกว่า " อันตรายจากสาขา" (branch hazard ) หากต้องกลับไปยังด้านบนswคำสั่งนั้นจะต้องถูกทิ้งและlwอ่านคำสั่งจากหน่วยความจำแทน ซึ่งใช้เวลาอย่างน้อยหนึ่งรอบการทำงานของคำสั่ง และส่งผลให้ไปป์ไลน์ว่างเปล่าอย่างน้อยหนึ่งช่วงเวลาของคำสั่ง นี่เรียกว่า "การหยุดชะงักของไปป์ไลน์" (pipeline stall) หรือ "ฟองอากาศ" (pipeline bubble) และขึ้นอยู่กับจำนวนสาขาในโค้ด อาจส่งผลกระทบอย่างเห็นได้ชัดต่อประสิทธิภาพโดยรวม

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

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

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

top: lw t0 , 0 ( a0 ) ; โหลดค่าจากที่อยู่หน่วยความจำในรีจิสเตอร์ a0 ไปยังรีจิสเตอร์ t0 lw t1 , 4 ( a0 ) ; โหลดค่าจากที่อยู่หน่วยความจำ [ค่าของรีจิสเตอร์ a0 บวก 4] ไปยังรีจิสเตอร์ t1 add t2 , t0 , t1 ; บวกค่ารีจิสเตอร์ t0, t1 เข้ากับรีจิสเตอร์ t2 li t3 , 1000 ; ตั้งค่ารีจิสเตอร์ t3 เป็น 1000 bgt t2 , t3 , top ; ถ้า t2 > t3 ให้กลับไปที่ "top:" ; หน่วงเวลา (จะถูกดำเนินการโดยไม่มีเงื่อนไข) lw t4 , 8 ( a0 ) ; โหลดค่าจากที่อยู่หน่วยความจำ [ค่าของรีจิสเตอร์ a0 บวก 8] ไปยังรีจิสเตอร์ t4 ; มิฉะนั้น: sw t2 , 0 ( a1 ) ; เก็บค่าในรีจิสเตอร์ t2 ไปยังที่อยู่หน่วยความจำในรีจิสเตอร์ a1

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

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

ผลข้างเคียงอีกประการหนึ่งคือ จำเป็นต้องมีการจัดการพิเศษเมื่อจัดการเบรกพอยต์บนคำสั่งต่างๆ รวมถึงการก้าวทีละขั้นขณะดีบักภายในช่องหน่วงเวลาการแตกสาขา ไม่สามารถเกิดการขัดจังหวะได้ในระหว่างช่องหน่วงเวลาการแตกสาขา และจะถูกเลื่อนออกไปจนกว่าจะสิ้นสุดช่องหน่วงเวลาการแตกสาขา^{[ 5 ] [ 6 ]} การวางคำสั่งแตกสาขาในช่องหน่วงเวลาการแตกสาขาเป็นสิ่งต้องห้ามหรือไม่แนะนำให้ใช้^{[ 7 ] [ 8 ] [ 9 ]}

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

ช่องหน่วงเวลาการแตกสาขาพบได้ส่วนใหญ่ในสถาปัตยกรรมDSP และ สถาปัตยกรรมRISC รุ่นเก่า MIPS , PA-RISC (สามารถระบุการแตกสาขาแบบหน่วงเวลาหรือไม่หน่วงเวลาได้) ^{[ 10 ]} ETRAX CRIS , SuperH (คำ ^สั่งแตกสาขาแบบไม่มีเงื่อนไขมีช่องหน่วงเวลาหนึ่งช่อง) ^{[ 11 ]} Am29000 [ ^{12 ]} Intel i860 (คำสั่งแตกสาขาแบบไม่มีเงื่อนไขมีช่องหน่วงเวลาหนึ่งช่อง) ^{[ 13 ]} MC88000 (สามารถระบุการแตกสาขาแบบหน่วงเวลาหรือไม่หน่วงเวลาได้) ^{[ 14 ]}และSPARCเป็นสถาปัตยกรรม RISC ที่แต่ละแบบมีช่องหน่วงเวลาการแตกสาขาเพียงช่องเดียวPowerPC , ARM , Alpha , V850และRISC-Vไม่มี สถาปัตยกรรม DSPที่แต่ละแบบมีช่องหน่วงเวลาการแตกสาขาเพียงช่องเดียว ได้แก่μPD77230 ^{[ 15 ]}และVS DSP SHARC DSPและMIPS-Xใช้ช่องหน่วงเวลาการแตกสาขาแบบคู่^{[ 16 ]}โปรเซสเซอร์ดังกล่าวจะดำเนินการคำสั่งคู่หนึ่งตามหลังคำสั่งกระโดดก่อนที่การกระโดดจะมีผล ทั้งTMS320C3x ^{[ 17 ]}และTMS320C4x ^{[ 8 ]}ใช้ช่องหน่วงเวลาการกระโดดสามช่อง TMS320C4x มีทั้งการกระโดดแบบไม่หน่วงเวลาและการกระโดดแบบหน่วงเวลา^{[ 8 ]}

ตัวอย่างต่อไปนี้แสดงการกระโดดแบบหน่วงเวลาในภาษาแอสเซมบลีสำหรับ SHARC DSP ซึ่งรวมถึงคู่คำสั่งหลังจากคำสั่ง RTS รีจิสเตอร์ R0 ถึง R9 จะถูกล้างเป็นศูนย์ตามลำดับหมายเลข (รีจิสเตอร์ที่ถูกล้างหลังจาก R6 คือ R7 ไม่ใช่ R9) ไม่มีคำสั่งใดทำงานมากกว่าหนึ่งครั้ง

R0 = 0 ; CALL fn ( DB ); /* เรียกฟังก์ชัน ด้านล่างที่ป้ายกำกับ "fn" */ R1 = 0 ; /* ช่องหน่วงเวลาแรก */ R2 = 0 ; /* ช่องหน่วงเวลาที่สอง */ /***** การเปลี่ยนแปลงไม่ต่อเนื่องตรงนี้ (การเรียกมีผล) *****/R6 = 0 ; /* การเรียก/RTS กลับมาที่นี่ ไม่ใช่ที่ "R1 = 0" */ JUMP end ( DB ); R7 = 0 ; /* ช่องหน่วงเวลาแรก */ R8 = 0 ; /* ช่องหน่วงเวลาที่สอง */ /***** ความไม่ต่อเนื่องตรงนี้ (JUMP มีผล) *****//* คำสั่ง 4 คำสั่งถัดไปถูกเรียกจากด้านบน ในรูปแบบฟังก์ชัน "fn" */ fn ​​: R3 = 0 ; RTS ( DB ); /* กลับไปยังผู้เรียก โดยผ่านช่วงเวลาหน่วงของผู้เรียก */ R4 = 0 ; /* ช่วงเวลาหน่วงแรก */ R5 = 0 ; /* ช่วงเวลาหน่วงที่สอง */ /***** การเปลี่ยนแปลงอย่างฉับพลัน (RTS มีผล) *****/สิ้นสุด: R9 = 0 ;

สล็อตหน่วงเวลาการโหลด (Load Delay Slot) คือคำสั่งที่ทำงานทันทีหลังจากโหลดข้อมูล (จากหน่วยความจำไปยังรีจิสเตอร์) แต่จะไม่เห็นผลลัพธ์ของการโหลด และไม่จำเป็นต้องรอผลลัพธ์นั้น สล็อตหน่วงเวลาการโหลดนั้นพบได้น้อยมาก เนื่องจากความล่าช้าในการโหลดนั้นคาดเดาได้ยากมากในฮาร์ดแวร์สมัยใหม่ การโหลดอาจทำได้จาก RAM หรือจากแคช และอาจช้าลงเนื่องจากการแย่งชิงทรัพยากร โดยทั่วไปแล้ว สล็อตหน่วงเวลาการโหลดจะพบได้ในแบบแผนการออกแบบโปรเซสเซอร์ RISC รุ่นแรกๆ สถาปัตยกรรม คำสั่ง MIPS I (ที่ใช้ใน ไมโครโปรเซสเซอร์ R2000และR3000 ) มีสล็อตประเภทนี้อยู่

ตัวอย่างต่อไปนี้เป็นโค้ดภาษาแอสเซมบลี MIPS I ซึ่งแสดงทั้งสล็อตหน่วงเวลาการโหลดและสล็อตหน่วงเวลาการกระโดด

lw v0 , 4 ( v1 ) # โหลดคำจากที่อยู่ v1+4 ลงใน v0 nop # เสียเวลาหน่วงการโหลดjr v0 # กระโดดไปยังที่อยู่ที่ระบุโดย v0 nop # เสียเวลาหน่วงการกระโดด

• การควบคุมการไหล
• บับเบิล (คอมพิวเตอร์)
• การทำนายสาขา