[แปล+สรุป] Computer Architecture – ตอนที่ 1.1 Evolution of Computer

developer

บทความชุด: Computer Architecture and Organization

บทความนี้แปลจากวีดีโอรายวิชา Introduction to Computer Architecture
บรรยายโดย อาจารย์ชัยวัฒน์ สุเมธพงศ์ (ICT มหิดล)

- ตอนที่ 1.1 Evolution of Computer
- ตอนที่ 1.2 Evolution of Computer
- ตอนที่ 2.1 Computer Functions

Computer Architecture หรือชื่อภาษาไทยคือ สถาปัตยกรรมคอมพิวเตอร์ เป็นวิชาที่พูดถึงการออกแบบภายในของคอมพิวเตอร์ ชุดคำสั่งที่ใช้ รีจิสเตอร์คืออะไร แรมมีไว้เพื่ออะไร ซึ่งจะเน้นในด้านฮาร์ดแวร์มากกว่า (ควรจะรู้เรื่อง Digital System มาก่อนจะดีมาก ใครยังไม่รู้กดไปอ่านได้เลย จิ้มที่นี่)

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

กว่าจะมาถึงวันนี้คอมพิวเตอร์ก็ผ่านอะไรมาเยอะนะ

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

ในช่วงสงครามโลกครั้งที่2 หรือ WWII เป็นช่วงที่ยังไม่มีจรวดมิสไซด์ ยุคนั้นยังใช้ปืนใหญ่ยิงอัดกันอยู่ แล้วปืนใหญ่ของสมัยนั้นเช่นที่ติดอยู่บนเรือประจัญบานยิงได้ไกลกว่า 20-30กม. การจะเล็งเป้าพวกนี้จะใช้มือคนปรับองศากระบอกปืนทั้งหมด อัตราที่มันจะเข้าเป้าน่ะสู้สมัยนี่ที่ใช้คอมพิวเตอร์ควบคุมชนิดที่ว่าล็อกเป้าหมายกันเป็นจุดไม่ได้เลย

สมัยนั้นมีการพัฒนาโปรเจคเครื่องคำนวนองศาการยิงปืนใหญ่ชื่อ ENIAC ซึ่งมันใช้เวลาพัฒนาถึง 3 ปี! แน่นอนว่าสงครามสิ้นสุดไปแล้ว แต่พวกเขาก็ไม่ปล่อยให้มันเสียไปเปล่าๆ เครื่องนี้จึงกลายมาเป็นต้นแบบของคอมพิวเตอร์ในปัจจุบันด้วยแนวคิดที่ว่าเราเอาเจ้าเครื่องนี้มาพัฒนาให้มันคำนวนอย่างอื่นก็ได้นี่นา

ในช่วงที่ผ่านมามีหนังเรื่อง Imitation Game ซึ่งเล่าประวัติของ อลัน ทัวริง นักคณิศาสตร์ที่สร้างจักรสำหรับถอดรหัสลับเครื่องอินิกม่าของฝ่ายเยอรมัน นั่นก็เป็นการพัฒนาอย่างหนึ่งกว่าจะมาเป็นคอมพิวเตอร์ในปัจจุบันเหมือนกัน

จากในหนังจะเห็นว่าเครื่องคำนวนสมัยก่อนมีขนาดใหญ่มาก มีราคาแพง ทำงานช้า แถมทำงานได้เฉพาะอย่างด้วย (แบบในหนังเครื่องนี้ใช้ถอดรหัสอินิกม่าได้อย่างเดียว)

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

เริ่มจากมหาวิทยาลัย

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

ยุคนั้นยังไม่มีคอมพิวเตอร์ PC (คอมพิวเตอร์เครื่องเล็กที่ยุคนี้พบได้ทั่วไปตามบ้านนั่นแหละ) มีแต่เครื่องใหญ่ๆ ซึ่งเรื่องกว่า Mainframe จากนั้นจึงพัฒนามาต่อเป็น Mini Computer ซึ่งอย่าโดนชื่อมันหลอกนะ มันยังเครื่องใหญ่อยู่ แค่เล็กกว่า Mainframe เท่านั้นเอง จนในที่สุดบริษัทก็ทำ PC (Personal Computer) ออกมาเพื่อขายให้คนธรรมดาได้ใช้คอมพิวเตอร์ด้วย

หลอดสุญญากาศ vs ทรานซิสเตอร์

หนึ่งในสิ่งที่คอมพิวเตอร์ต้องการเพื่อให้มันทำงานได้คือ Semi-Conductor หรือสารกึ่งตัวนำ ซึ่งเป็นส่วนประกอบของชิป เมมโมรี่ ส่วนประกอบหลักของคอมพิวเตอร์ แต่ในสมัยก่อนนั้นคอมพิวเตอร์เริ่มโดยการใช้ หลอดสุญญากาศ (Vacuum Tube)

อย่างที่เรารู้กันว่าหน่วยพื้นฐานของคอมพิวเตอร์คือ bit ซึ่งเก็บค่า 0 และ 1 เท่านั้น (บอกแล้วนะ ใครยังไม่รู้เรื่อง Digital System ให้กลับไปอ่านก่อน หึหึ) แล้วเจ้า bit นึงเนี่ยเราก็ใช้หลอดสุญญากาศ 1 หลอดในการเก็บสถานนะ (state) ของมัน แปลว่าถ้าจะใช้ 1 byte เราก็ต้องใช้หลอดเนี่ยถึง 8 หลอด โอ้!

แล้วหลอดนึงเนี่ยมันใหญ่ประมาณห่อขนมสแน็กบาร์1ห่อ ถ้าเอามาใช้กับยุคนี้ที่ใช้หน่วยพื้นฐานระดับ KB (10³) MB (10⁶) GB (10⁹) หรือตอนนี้เราไปถึง TB (10¹²) กันแล้ว ... เอาแค่ 1 KB ที่ปัจจุบันสร้างไฟล์ notepad เปล่าๆ ก็แทบจะ 1KB แล้วนะ คือ 1024 byte = 8 x 1024 = 8192 bits

นั่นหมายความว่าเราต้องการหลอดสุญญากาศ 8192 หลอดเชียวนะ! วางไปทีล้นห้อง

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

จากบัตรเจาะรูถึงการสั่งงานด้วยคำพูด

เราเรียนในวิชาการเขียนโปรแกรมไปแล้วว่าการทำงานของคอมพิวเตอร์จะเริ่มจาก Input -> Process -> Output

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

แต่ก่อนที่จะมีของพวกเนี้ย เขาสั่งงานคอมพิวเตอร์กันยังไงล่ะ ... คำตอบก็คือใช้

บัตรเจาะรู หรือ Punch Card

เป็นบัตรกระดาษที่จะมีช่องให้เราเจาะรู (อย่าถามว่าเราเคยใช้มั้ยนะ เพราะขนาดอาจารย์เรายังไม่เคยใช้เลย เก่าแค่ไหนคิดดูละกัน) แล้ววิธีใช้ ใช้ไงล่ะ?

บัตรเจาะรูจะแบ่งเป็นแถว แล้วแต่ว่าเครื่องคอมพิวเตอร์นั้นกำหนดไว้ว่าอะไร แถวหนึ่งอาจจะมีรูให้เจาะ8-10รู ให้เราเลือกเจาะได้ว่าจะเอารูไหนบ้าง

ยังไม่มี if-else loop หรือ x = 1 หรอกนะ

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

LOAD AX, #FF00

ถ้าใครรู้จักภาษา Assembly อาจจะคุ้นนิดๆ (เหรอ?) กับคำสั่งแบบนี้ ความหมายของมันคือให้คอมพิวเตอร์โหลดค่าจากเมมโมรี่ตำแหน่ง FF00 เข้ามายังรีจิสเตอร์ชื่อว่า AX (อะไรนะ? ไม่เข้าใจ รออ่านในบทต่อไปละกัน) แต่อ้าว ไหนบอกว่าคอมพิวเตอร์เข้าใจแค่เลข 0 กับ 1 ... แม่นแล้ว มันเข้าใจแค่นั้น ดังนั้นเราจะสั่งให้มัน LOAD ข้อมูลเข้ามาเราต้องรู้ก่อนว่า LOAD เป็นรหัสฐาน₂ ว่าอะไร เช่น 00010011

แต่แค่นั้นก็ยังไม่พอนะ AX และตำแหน่ง FF00 มันก็ไม่รู้จักดังนั้นไปแปลงให้มันเป็นฐาน₂ด้วยนะ

ผลสุดท้ายแล้วหน้าตาคำสั่งก็จะออกมาเป็นแบบ

00010011 00011011 11110000

เอาล่ะ พอเราได้รหัสพวกนี้มาแล้ว หน้าที่ของเราก็คือเราไปเจาะรูเจ้าพันช์การ์ดให้เป็นรู้ตามนำแหน่ง บางเครื่องอาจจะตั้งไว้ 0 คือไม่ต้องเจาะรู ส่วน 1 คือให้เจาะรูก็ได้ ก็นั่งเจาะตาลายกันไปตามนั้น ทีละคำสั่ง

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

แล้วหลังจากไปหาอะไรกิน เดินเล่น อ่านการ์ตูนสัก3ชั่วโมงคุณก็กลับมาที่คอมพิวเตอร์ของคุณอีกครั้ง มันโปรเซสเสร็จแล้วล่ะ คุณยกกระดาษที่มันปริ๊นออกมาขึ้นดู...

Error!

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

จะเห็นว่ากว่าจะรันโปรแกรมได้ในสมัยก่อนช่างทรมานมาก สมัยนี้เราแค่พิมพ์ภาษาคอมสมัยใหม่เช่น Java php พอพิมพ์เสร็จเรากดคอมไพล์ คอมพิวเตอร์ทำงานอย่างรวดเร็วแจ้งออกมาเลยว่ามัน Error หรือสามารถรันได้ ชีวิตช่างง่ายดายนัก ก็ขอแสดงความยินดีกับพวกคุณที่เกิดมาในสมัยนี้ด้วยละกัน (ฮา)

Dump Machine, ยุคสมัยแห่ง Server-Terminal

สำหรับ PC มันประกอบด้วยหน้าจอ คีย์บอร์ด-เมาส์ เมมโมรี่/ฮาร์ดดิส และโปรเซสเซอร์ในตัวมันเอง แต่สำหรับสมัยก่อนที่คอมพิวเตอร์แพงมาก มหาวิทยาลัยที่สร้างได้ แต่การสร้างคอมพิวเตอร์แพงๆ ขึ้นมาถ้าใช้ได้แค่เครื่องเดียวคงจะไม่คุ้มนัก เพราะอย่างนี้โปรเซสเซอร์1ตัวจึงต้องมีหน้าจอและคีย์บอร์ดหลายอันนั้นเอง

คอมพิวเตอร์รู้แบบนี้เราเรียกว่า Server-Terminal นั่นคือมีเครื่องโปรเซสเซอร์ตัวเดียว แค่ใช้ประมวลผลให้คอมได้หลายเครื่อง เจ้าคอมหลายๆ เครื่องนี่เปรียบได้กับ Dump Machine หรือเครื่องจักรที่ทำอะไรไม่ได้เลย มีแค่ หน้าจอ-คีย์บอร์ดเท่านั้น ทุกครั้งที่พิมพ์อะไรก็ตามมันจะส่งคำสั่งกลับไปให้ Server ทำงาน พอฝั่งโน้นทำเสร็จก็จะส่งคำตอบกลับมาแสดงที่หน้าจอ

General Function สำหรับคอมพิวเตอร์

เป็นคอนเซ็ปที่บอกว่าคอมพิวเตอร์เครื่องหนึ่งๆ เนี่ยมันควรจะทำอะไรได้บ้าง ซึ่งหลักๆ แล้วมี 4 อย่างคือ

1. Data Storage - ต้องเก็บข้อมูลได้ เช่นพวกแรม ฮาร์ดดิส
2. Data Movement - ต้องมีการส่ง/รับข้อมูลได้ เช่นbus สายแลน เคเบิล
3. Data Processing - ต้องประมวลผลข้อมูลได้ ก็คือCPU
4. Control - มีส่วนควบคุมการทำงานด้วย อันนี้ไม่มีอุปกรณ์ แต่หมายถึงการควบคุมการทำงานนะ

เมื่อมีฟังก์ชันการทำงานหลายแบบ เราจะต้องมีการออกแบบระบบจัดการ (Organization) ให้ระบบทำงานได้อย่างราบลี่นเปรียบเหมือนบริษัทที่มีหลายแผนก แต่ทุกแผนกจะโดนควบคุมและสั่งงานโดนผู้จัดการนั่นแหละ

Step by Step!

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

for( i=1; i<=100; i++){
    print(i);
}

ตัวอย่างโปรแกรมที่ง่ายสุดๆ ต้องการจะปริ๊นเลข 1-100 ถ้าคุณเขียนโปรแกรมเป็นแล้วน่าจะนึกภาพออกว่าโปรแกรมนี้ทำงานแบบ loop ดังนั้นการวนลูปทุกรอบจะต้องมีการเช็กเงื่อนไข ในที่นี้คือ i<=100 ทุกรอบ ลองคิดดูสิว่าถ้าให้คนมานั่งคิดแบบคอมทุกครั้ง เราเขียน1 จากนั้นเรานับ2 ต้องมาเช็กก่อนว่า2นั้นยังไม่ถึง100 จึงเขียน2 เรานับ3ต่อ คิดอีกทีว่า3ยังไม่ถึง100 เขียน3 บลาๆๆ... แค่คิดก็น่าเบื่อแล้วจริงไหม?

Instruction Cycle

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

เอาแบบคร่าวๆ ก่อน ใน1รอบของการทำงานคอมพิวเตอร์จะเริ่มโดยการไปดึงคำสั่งออกมา เรียกว่าการ Fetch (เรียกออกมา) Instruction (คำสั่ง) นั่นเอง ... จากนั้นจะทำการรันคำสั่งนั้น (Execute) แล้วจึงกลับไปดึงคำสั่งต่อไปมาทำ วนแบบนี้ไปเรื่อยๆ จนกว่าจะจบนั่นเอง

คอนเซ็ป (แบบภาษาคน) มีแค่นั้นแหละ แต่สั่งแค่นี้ไม่เพียงพอจะให้คอมเข้าใจแน่นอน งั้นเรามาดู Instruction Cycle แบบเต็มกันดีกว่า

เอาล่ะ นี่ละแบบเต็ม มีทั้งหมด 9 ขั้นตอน แต่ก่อนจะมาเจาะลึกพวกมันขอตกลงเรื่องคำศัพท์ก่อน

Instruction หมายถึงคำสั่ง เช่น X = Y + 5;

Operand หมายถึงตำดำเนินการ ในที่นี่คือ X กับ Y นั่นเอง

Operation หมายถึงจะให้ทำอะไร ในที่นี้คือ + และ = (เซ็ตค่า) นะ

สมมุติให้ คำสั่งตอนนี้เก็บอยู่ที่เมมโมรี่เบอร์ 1000 , X อยู่ในเมมโมรี่เบอร์ 2000 ,  Y อยู่ในเมมโมรี่เบอร์ 2000 , และการ + เป็นรหัส 123 ละกันนะ

เอาล่ะ มาดู9ขั้นตอนได้แล้ว...

1. Instruction Address Calculate
   คำสั่งคอมพิวเตอร์เรียงกันอยู่ในเมมโมรี่ (ยังไม่ต้องถามว่ามันมายังไง ถ้าไม่มีชุดคำสั่งพวกนี้คอมก็ไม่เริ่มทำงานนะจ๊ะ) ย้ำว่าต้องเรียงกันนะ เพราะคอมพิวเตอร์จะทำงานเรียงตามนี้ วางไม่เรียงมันก็ทำงานผิดไงล่ะ ... ดังนั้นขั้นตอนแรกจึงเป็นการหาตำแหน่งของคำสั่งว่ามันอยู่ที่ไหนกันนะ
   [ได้ว่าคำสั่งเราอยู่ที่ 1000]
2. Instruction Fetch
   หลังจากเจอแล้วว่าคำสั่งอยู่ที่ไหน ก็ไปดึงคำสั่งออกมาสิ! ดึงออกมาในที่นี้หมายถึงดึงออกมาจากเมมโมรี่ เข้ามาในCPUซะ (สมองของคอมพิวเตอร์คือCPU ถ้าจะทำงานก็ต้องอยู่ในCPUล่ะ)
   [ดึงคำสั่งออกมาจากตำแหน่ง 1000 ซึ่งอาจจะอยู่ในรูป 0001 1110 1010 1000 1111 0011 ...]
3. Instruction Operation 'DECODING'
   จากขั้นตอนที่แล้วทำให้ตอนนี้เรามีคำสั่งมานอนรออยู่ในCPUแล้ว แต่คำสั่งในที่นี้อยู่ในรูปของเลขฐาน₂ (อีกแล้วเรอะ!) นั่นทำให้เราต้องทำการ Decode หรือถอดรหัสคำสั่งนั้นก่อนถึงจะรู้ว่าคำสั่งเนี้ยมันสั่งให้ทำอะไรกันแน่
   [จากตัวอย่างจะได้ว่า คำสั่งเมื่อกี้น่ะมันแปลว่าเราจะทำ Y + 5 แล้วเอาไปเก็บไว้ใน X นะ]
4. Operand Address Calculate
   หลังจากแปลความหมายได้แล้ว ส่วนใหญ่คำสั่งจะมีการยุ่งเกี่ยวกับตัวแปร เช่น X กับ Y พวกนั้น แต่ตัวแปรจะถูกเก็บอยู่ในเมมโมรี่เช่นกัน ก็เลยต้องทำคล้ายๆ ข้อที่1นั่นคือคำนวนหาที่อยู่ตัวแปรซะก่อน
   [ในคำสั่ง Y + 5 ต้องการใช้ตัวแปร Y เป็นอยู่ในตำแหน่ง 2000 ไง]
5. Operand Fetch
   คำนวนที่อยู่ได้แล้วก็ไปดึงตัวแปรออกมาเก็บไว้ในCPUซะ (CPUจะมีช่องเก็บของที่เรียกว่ารีจิสเตอร์อยู่ แต่รีจิสเตอร์พวกนี้มีไม่มาก ดังนั้นต้องจัดการให้ดี)
   [โอเค ไปดึงค่าที่ช่อง 2000 ออกมา สมมุติว่ามีค่า 3]
6. Data 'Operation'
   พอได้ทั้งคำสั่งและตัวแปรที่ต้องทำงานแล้ว ก็ทำงานซะ! คำสั่งให้ + ก็บวก คำสั่งให้ - ก็ลบแบบนั้นเลย
   [ในตัวอย่างให้ทำ + ก็เอาค่า 3 ที่เพิ่งดึงออกมาเมื่อกี้ไปบวกกับ 5 จะได้ 8]
7. Operand Address Calculate
   ในขั้นตอนที่ผ่านมาทำให้เราได้คำตอบของคำสั่งนั้นแล้ว แต่คำตอบที่ได้น่ะมันยังคาอยู่ในCPU ปัญหาคือเราต้องใช้CPUเพื่อรันคำสั่งต่อไป (อย่างที่บอกไปว่ารีจิสเตอร์มีจำกัดไงล่ะ) เลยต้องย้ายคำตอบนี่ไปเก็บไว้ในตัวแปรในเมมโมรี่เสียก่อน
   [คำสั่งบอกว่าผลที่ได้ให้เอาไปใส่ตัวแปร X เลยต้องคำนวนให้ได้ก่อนว่า X คือตำแหน่ง 1000]
8. Operand Store
   ปกติในขั้นนี้เราจะทำการ Fetch แต่มาถึงตอนนี้มันจะกลับกัน คือค่าของเรามันอยู่ในCPUอยู่แล้ว เราจะเอาไปใส่ในเมมโมรี่ เลยเปลี่ยนจาก Fetch -> Store แทน ... เอาคำตอบไปใส่ในตำแหน่งที่ถูกต้องเป็นอันจบพิธี!
   [ก็เอาคำตอบคือ 8 เมื่อกี้ไปใส่คืนที่ตำแหน่ง 1000]
9. INTERRUPT!
   ทุกรอบที่คอมพิวเตอร์ทำงานจะมีการเช็กว่ามีความต้องการของระบบที่ขอขัดจังหวะซะหน่อยมั้ย ถ้ามีแล้วอนุญาตให้ทำพอดี คอมพิวเตอร์ก็จะแว๊บไปทำงานนั้นแป๊ปนึง

ในบทนี้พอแค่นี้ก่อนละกัน ในตอนต่อไปเราจะมาดูกันว่า Instruction Cycle นี่เมื่อมันทำงานจริงๆ จะต้องมี Register ที่ต้องที่ทำงานร่วนกันบ้างล่ะ