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

developer

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

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

ในตอนที่แล้วเราพูดเกี่ยวกับความเป็นมาของคอมพิวเตอร์คร่าวๆ กันไปแล้ว (นั่นคร่าวๆ แล้วนะ) มีบุคคลสำคัญในเรื่องนี้ 2 คน หนึ่งในนั้นเราถูกถึงผ่านๆ ไปแล้วในครั้งที่แล้วคือ Alan Turing ผู้เป็นหนึ่งทีมถอดรหัสของฝ่ายสัมพันธมิตร และเป็นผู้คิดค้นเครื่อง Turing Machine ส่วนอืกคนคือ Von Neumann หนึ่งในผู้พัฒนาเครื่อง ENIAC

Von Neumann (ซ้าย) / Alan Turing (ขวา)

เครื่องที่ทั้งสองคนคิดขึ้นในระหว่างสงครามซึ่งทำงานแบบ General Purpose คือคำนวนงานอย่างเดียว (คำนวนการตั้งองศาปืนใหญ่ก็ทำได้อยู่แค่นั้น) ภายหลังสงคราม Von Neumann ได้เสนอเอกสารฉบับหนึ่งซึ่งเป็นการออกแบบเครื่องจักรที่ชื่อว่า IAS (มีไอเดียที่คล้ายๆ กับเครื่องจักรของทัวริงอยู่) ซึ่งสถาปัตยกรรมการออกแบบของเครื่อง IAS เนี่ยก็เป็นต้นแบบต่อมาของการออกแบบโครงสร้างภายใจของคอมพิวเตอร์ทั่วโลกจนถึงปัจจุบันนี้เลยล่ะ! (ไม่เหมือนเป๊ะ มีการพัฒนาต่อมาทำให้มันดีขึ้นกว่าเดิมแต่กว่า 80% ก็ยังใช้คอนเซ็ปนี้อยู่ เจ๋งป่ะล่ะๆ)

Architec. แบบแรกของ Von Neumann

รูปแบบการดีไซน์ของ วอน นิวแมน กล่าวไว้ว่าการจะสร้างเครื่องจักรสำหรับคำนวนและประมวลผลนั้นจะต้องมีส่วนประกอบหลักคือ

1. Computation (CA) – เป็นส่วนที่เอาไว้คำนวนผลทางคณิตศาสตร์ ปัจจุบันเราเรียกมันว่า “ALU”

2. Control (CC) – เป็นส่วนควบคุมการลำดับทำงานของระบบทั้งหมด ปัจจุบันเราเรียกมันว่า “CU”

3. Storage (M) – เป็นส่วนเอาไว้เก็บค่า เก็บตัวแปร เหมือนกับกระดาษทดเวลาเราคิดเลข ปัจจุบันเราเรียกมันว่า “Memory” หรือ RAM นั่นเอง

4. Input (I) – เป็นส่วนที่เอาไว้ให้ผู้ใช้สั่งงานได้ ปัจจุบันเราเรียกรวมทั้ง Input-Output ว่า “I/O” เลย

5. Output (O) – ส่วนสำหรับแสดงผลคำตอบให้คนเห็น

จากนั้นเขาก็เอา 5 ส่วนประกอบหลักที่ว่าไปเมื่อกี้น่ะมาเชื่อมต่อกันโดยมี CC เป็นตัวกลางเอาไว้ควบคุม (พูดง่ายๆ คือไม่ว่าข้อมูลจะไหลไปทางไหน มันต้องผ่านการสั่งการโดย CC ไงล่ะ) … แต่ปัจจุบันไม่ได้เป็นอย่างนี้แล้วนะ มันมีการพัฒนาต่อมาอีกนิดหน่อยนั่นคือสร้างเส้นเชื่อมระหว่าง I/O กับ Memory ขึ้นมาเรียกว่า DMA หรือ Direct Memory Access

สาเหตุที่ต้องเพิ่มเข้ามาก็เพราะว่าในดีไซน์ตามสถาปัตยกรรมของ วอน นิวแมน นั้นออกแบบมาโดยคิดว่าคอมพิวเตอร์จะทำงานแบบ Single-Task หรือรันได้ทีละโปรแกรมเท่านั้น (ซึ่งก็ไม่ผิด เพราะสมัยก่อนก็ยังไม่มีแนวคิดเรื่อง Multitasking แบบตอนนี้) แต่พอเอาดีไซน์แบบนี้มาใช้กับการรันโปรแกรม Multi-Task จะเกิดอะไรขึ้นล่ะ?

ส่วนหนึ่งต้องรู้ก่อนว่า I/O นั้นทำงานช้ากว่า CPU และ Memory มาก (เพราะมันเป็น Physical หรือของจริง ไม่ใช่กระแสไฟฟ้าไหลๆ) ตัวอย่างเช่นการอ่าน/เขียนไฟล์จาก HDD ล่ะ … อ้อ HDD ก็ถือเป็น I/O ได้นะ มันไม่ถือเป็นเมมโมรี่หลักที่เอาไว้รันโปรแกรม แค่เอาไว้เก็บข้อมูลเท่านั้น สมมุติโปรแกรมเราต้องการอ่านข้อมูลจาก HDD เข้ามา แน่นอนว่าข้อมูลที่ใช้งานได้ (พร้อมรันให้โปรแกรมใช้) จะต้องอยู่ในเมมโมรี่หลัก แปลว่าเราต้องอ่านข้อมูลจาก HDD เข้ามาไว้ใน RAM ก่อนใช่มั้ยล่ะ จังหวะนั้นจะทำให้เกิดการ idle หรือการว่างงานของ CPU ได้

สรุปคือในจังหวะที่เกิดการ idle พวกนั้น ถ้า Memory กับ I/O มันคุยกันได้เอง (ในเคสตัวอย่างคือก๊อปข้อมูลจาก HDD ไป RAM ได้เอง) โดนไม่ต้องผ่านการสั่งงานของCPU เจ้าCPUก็จะเอาเวลาเนี้ยไปรันโปรแกรมอื่นแทนได้ ไม่เสียเวลารออย่างเปล่าประโยชน์ ส่วนถ้าพวกแกคุยกันเสร็จแล้วค่อยกลับมาเรียกฉันให้ไปรันคำสั่งต่อไปก็แล้วกัน (ซึ่งเราเรียกกันว่า Interrupt! นั่นเอง)

IAS Words

ถ้าใครรู้ภาษา Assembly อาจจะคุ้นๆ คำว่า “Word” อยู่บ้าง … แต่ถ้าไม่คุ้นก็ไม่เป็นไร เดี๋ยวเราทวนให้ก็ได้

ปกติหน่วยของขนาด data ในคอมพิวเตอร์จะใช้หน่วยเป็น bit ซึ่งเล็กที่สุด ใหญ่ขึ้นมาหน่อยก็จะเป็น byte ซึ่งก็คือแค่ 8-bits เท่านั้น แต่ข้อมูลแค่8บิตเนี่ยมันเก็บค่าได้แค่ 28 = 256 ตัวเท่านั้น ซึ่งมันน้อยไป! เขาเลยต้องมีการตั้งหน่วยใหม่ขึ้นมาเรียกว่า

Word = หน่วยที่ใช้บอกประมาณว่า dataหนึ่งตัวใหญ่ประมาณเท่านี้นะ

ในสมัยนั้นเขากำหนดว่า 1 Word จะมีค่าเท่ากับ 40-bits (ปัจจุบันขนาดของ 1 Word จะเป็นเลข 2n เช่น 16 32 64 128 …) อืม มันเป็นตัวเลขที่ไม่ค่อยดีเท่าไหร่แต่ในเวลานั้นยังไม่มีคอนเซ็ปเรื่องเลข 2n นะ

เมมโมรี่คือ’ไรน่ะ?

ขอปรับความเข้าใจเล็กน้อย…

คุณรู้หรือเปล่าว่า เมมโมรี่มีไว้ทำไม?

ถ้าตอบว่าเอาไว้เก็บข้อมูลไงล่ะ งั้นขอถามต่อหน่อย แล้วเมมโมรี่หลัก (RAM) กับ เมมโมรี่รอง (พวก hard disk) ต่างกันยังไง

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

ส่วนเมมโมรี่หลัก หรือที่เราเรียกกันว่า RAM ลองสังเกตดูว่าปกติแล้วขนาดของ RAM จะไม่เยอะเมื่อเทียบกับ HDD, ตอนนี้ HDD ขนาดขั้นต่ำก็หลายร้อย GB แล้ว ส่วนใหญ่ขึ้นหลัก TB กันแล้วด้วยซ้ำ แต่ในขณะเเดี่ยวกัน หน่วยความจำหลักกลับมีขนาดแค่ 2-8 GB เท่านั้น จริงๆ มีเยอะกว่านั้นนะถ้ายอมจ่ายแพง (ฮา) แปลว่าเจ้า RAM เนี่ยมันไม่ได้เอาไว้เก็บข้อมูลของเราแน่ๆ แล้วมันใช้เก็บอะไรล่ะ นั่นสิ?

คอมพิวเตอร์ไม่มีความจำ แต่โปรแกรมกับตัวแปรที่ใช้ในโปรแกรมต้องการที่อยู่นะ!

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

คำตอบคือไม่ใช่แน่ๆ เราต้องเสียพื้นที่เก็บตัวแปรตัวนี้ไง … สรุปคือ RAM เมมโมรี่หลักนั้นน่ะเอาไว้เก็บข้อมูล คำสั่ง และตัวแปรของโปรแกรมที่กำลังรันอยู่ในขณะนั้น ถ้าโปรแกรมไหนเรายังไม่ใช่งานมัน ก็ปล่อยมันนอนเล่นรอในฮาร์ดดิสไปก่อน พอเราจะใช้ปุ๊บนั่นล่ะ ต้องโหลดมันเข้า RAM ก่อนถึงจะใช้ได้ โอเคนะ แล้วถ้ารันโปรแกรมหลายๆ ตัวพร้อมกันคอมถึงได้ช้าลงไง เพราะเนื้อที่ RAM เริ่มจะหมดแล้ว อย่าลืมว่าคอมไม่ได้รันโปรแกรมแค่ที่เรากำลังใช้งานนะ OS (เช่น Windows, OS X) กับ Driver (การ์ดจอการ์ดเสียง แลนการ์ดพวกนั้น) พวกนี้ก็ถือเป็นโปรแกรมนะ ลองดูตอนเพิ่งเปิดคอมก็ได้ จะเห็นว่าแค่เปิดคอม RAM ก็หายไปแล้วประมาณ 1-2 GB เพราะเจ้าพวกนั้นเอาไปใช้แล้วยังไงล่ะ

เมมโมรี่ก็เหมือนตู้ล๊อกเกอร์เก็บของ

เมมโมรี่ประกอบกันขึ้นมาจากหน่วยเล็กที่สุดนั่นคือ bit แต่บอกไปเมื่อกี้แล้วนะว่า bit เล็กเกินจนทำอะไรไม่ได้ เขาจึงคิดหน่วย Word ขึ้นมา ซึ่งเป็นหน่วยที่มีขนาดไม่แน่นอน ปกติจะออกแบบให้พอดีกับความต้องการของระบบ เช่นสมัย วอน นิวแมน 1 word = 40 bits แต่ปัจจุบันอาจจะมีขนาดเท่ากับ 1 word = 64 bits แล้วก็ได้เพื่อตอบโจทย์ขนาดโปรแกรมและ data ที่ใหญ่ขึ้น

ลองนึกภาพตู้ล๊อกเกอร์ดู ตู้ล๊อกเกอร์แต่ละตู้สามารถเก็บหนังสือเรียนได้จำนวนหนึ่ง (เทียบหนึ่งสือหนึ่งเล่มเป็น 1 bit ละกันนะ) ทางโรงเรียนคงปวดหัวตายถ้าให้นักเรียนขอจองใช้ล๊อกเกอร์โดยให้นักเรียนบอกว่าแต่ละคนต้องการเก็บหนังสือกี่เล่ม บางคนต้องการเก็บ10เล่ม บางคน15เล่ม แต่บางคนขอ1เล่มก็พออะไรแบบนั้น

ทางโรงเรียนจึงนำตู้ล๊อกเกอร์เข้ามาใช้แทน โดยบอกไปเลยว่าล๊อกเกอร์ 1 ตู้เก็บหนังสือได้ 40 เล่มนะ (เทียบกับ 1 word = 40 bits นะ) ใครอยากได้กี่ช่องก็มาขอจองได้เลย ในเคสนี้เราจะยอมให้แต่ละช่องอาจจะเหลือที่ก็ได้ เช่นมันเก็บได้40เล่ม คุณจะเก็บแค่25เล่มก็ได้ แต่เพื่อความง่ายในการจัดการ คุณต้องจองเป็นตู้เท่านั้น ไม่มีสิทธิ์จองแบบ15เล่มเงี้ย ไม่เอานะๆ

จากเหตุผลนี้ทำให้เราไม่ค่อยแคร์มันเท่าไหร่หรอกว่า 1 word จะมีขนาดท่าไหร่ ก็แล้วแต่ดีไซน์ของระบบนั้นออกแบบมานั่นแหละนะ

Data & Instruction

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

ของที่จะเก็บไว้ในเมมมี 2 อย่างหลักๆ คือ “ข้อมูล” และ “คำสั่ง” เช่น

จะเห็นว่าแค่ประโยคง่ายๆ แบบนี้ก็มี data 2 ตัวคือ x, y และ คำสั่ง 2 คำสั่งคือ =, + แล้วนะ

แล้วในเมื่อเราต้องเก็บทั้ง Data และ Instruction ลงไปในเมมโมรี่ จะแบ่งพื้นที่กันยังไงดีล่ะ สมมุติเมมโมรี่มีขนาด 100 words จะให้ 1-50 สำหรับ Data และ 51-100 สำหรับ Instruction ดีมั้ยนะ?

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

วิธีการล้ำลึกที่เขาใช้ นั่นคือ…

“Dynamic Allocation”

ก็ใช้หลักการการจองพื้นที่แบบไดนามิคไปเลยสิ ตรงไหนจะเป็น Data ตรงไหนจะเป็น Instruction ก็ได้ไง นี่ก็เป็นอีกสาเหตุนึงนะที่ออกแบบให้ทุกอย่างในเมมใช้หน่วย word

Number Word

ถึงจะบอกว่าเป็น Data แต่ Data ในสมัยนั้นมีแต่ Integer only! หรือจำนวนเต็มล้วนๆ เท่านั้น ยังไม่มีชนิดข้อมูลอื่น String อะไรพวกนั้นไม่ต้องคิดเลยเพราะ Float ยังไม่มีเลย ส่วนระบบตัวเลขก็ยังโบราณมากนั่นคือ Sign-Magnitude โดยต่อมาถึงมีการพัฒนาไปใช้ 2’s Complement ต่อไป (ไม่อธิบายว่าคืออะไรแล้วนะ ไปอ่านใน Digital System เอาเอง จิ้มที่นี่)

นั่นหมายความว่า word ที่เป็น Data จะมี 1 ช่องที่เป็น sign (ตัวบอกว่าเลขตัวนี้เป็นค่า + หรือ – นะ) กับ magnitude อีก 39 ช่อง สรุปคือ ตัวเลขในสมัยนั้นจะเก็บค่าได้ตั้งแต่ -239 ถึง +239 ซึ่งถือว่าเป็นตัวเลขจำนวนมากกกกกกกกกกกกกกกสำหรับสมัยนั้นเลย

Instruction Word

ใช้วิธีเก็บแบบ left/right half-word คือแบ่งครึ่งกัน โดยใน 1 word จะเก็บ instruction ได้ถึง 2 ตัวด้วยกัน

โครงสร้องของ Instruction จะแบ่งเป็น 2 ส่วน ส่วนแรกเรียกว่า OpCode หรือ Operation-Code 8 ช่อง กับอีกส่วนคือ Address อีก 12 ช่อง … พอมันเก็บได้ 2 ตัวมันก็เลยเป็น OpCode Addr. OpCode Addr.

ทีนี้! ใครมีข้อสงสัยบ้าง?

ไหนบอกว่าให้พยายามออกแบบทุกอย่างให้ขนาดเท่า word

แล้วทำไมออกแบบให้ ตัวเลขขนาด 1 word แต่ที Instruction ออกแบบให้ใหญ่แค่ครึ่ง word ล่ะ

สาเหตุที่เขากำหนดให้ 1 word ใหญ่ 40-bits นั้นถือเป็น Simple Idea ที่ง่ายๆ มากๆ คือ… เขาต้องการจะให้มันเก็บตัวเลขได้เยอะๆ อืม เหตุผลง่ายเนอะ

งั้นมาต่อที่คำถามที่สอง แล้ว’ไมต้องแบ่ง instruction ออกเป็นครึ่งนึงล่ะ ใช้ขนาดเต็มไปเลย 1 instruction = 1 word ไม่ได้เหรอ (อ้อ บอกไว้หน่อย ในปัจจุบันเป็น 1 instruction = 1 word แล้วล่ะนะ)

ก่อนจะรู้เหตุผล คุณต้องรู้ก่อนว่า อะไรคือOpCode และอะไรคือAddress ถ้ารู้แล้วคุณจะเข้าใจว่าทำไมเขาต้องแบ่งมันออกเป็น 2 ส่วนในสมัยนั้น

OpCode

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

  • 1 หมายถึงคำสั่ง LOAD
  • 2 หมายถึงคำสั่ง STORE
  • 18 หมายถึงคำสึ่ง ADD
  • 23 หมายถึงคำสั่ง SUB

แต่ขอเพิ่มอีกนิด ตัวเลขรหัสในที่นี้อยู่ในรูปของเลขฐาน2นะ (ไม่ต้องเบื่อหรอกนะ ถ้าคุณเรียนเกี่ยวกับ Hardware ยังไงก็เจอเลขฐานนี้แน่ๆ)

ถ้าสมมุติว่าคุณเป็น วอน นิวแมน แล้วคุณต้องคิดรูปแบบคำสั่งพวก LOAD, STORE, ADD, SUB, INC, DEC, บลาๆๆ พวกนี้น่ะ คุณคิดว่าคุณจะนึกได้สักกี่คำสั่งกัน อย่างมากก็ 50-60 คำสั่งก็เก่งแล้ว แน่นอนว่าสมัยนี้มันเยอะกว่านั้นมากๆ แต่สมัยนั้นเขาคิดได้แค่นั้น นั่นหมายความว่ามีคำสั่งตั้งแต่เลข 1-200 โดยประมาณ เผื่อให้นิดหน่อยด้วยนะ คงไม่เกินนี้หรอกนะ

แล้วเลข 200 ตัวเนี่ยต้องใช้กี่ bit ในการเก็บมันล่ะ?

คำตอบคือ 8-bits ซึ่งเก็บได้ถึง 256 ตัวไง (7-bits ไม่พอเพราะมันเก็บได้แค่ 128) เข้าใจแล้วนะ?

Address

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

ถ้าถามว่ารหัสไปรษณีย์มาตราฐาน 5 ช่องมีโอกาสมีเลขทั้งหมดกี่ตัว ก็คือตั้งแต่เลข 00000 – 99999 ทั้งหมดหนึ่งแสนตัว แต่อันนี้เป็นเลขฐาน10 ถ้าเป็นฐาน2ล่ะ?

Address ในสมัยนั้นมีขนาด 12-bits หมายความว่ามีเลข addr ได้ตั้งแต่ 0 – 212 = 0 – 4096 = 4K words

4พัน! words

ถือว่าเยอะมากแล้วสำหรับเมมโมรี่ในสมัยนั้น แต่ถ้าเป็นอย่างนี้ OpCode + Address รวมกันก็แค่ 20-bits แทนที่จะปล่อยอีกครึ่งว่างไว้เฉยๆ ใช้วิธีแบ่งครึ่งเอาเลยดีกว่า มาถึงตรงนี้น่าจะเข้าใจได้แล้วว่าทำไมปัจจุบันถึงเลิกใช้ระบบนี้แล้วไปใช้ 1 instruction = 1 word แทนได้ เพราะตอนนี้คำสั่งที่มีให้ใช้มันเพิ่มขึ้นและช่องล๊อกเกอร์ในเมมโมรี่ก็มีขนาดใหญ่ขึ้นแล้วยังไงล่ะ

แต่การทำแบบนี้หมายความว่าในรอบ Instruction Cycle (ในบทที่แล้วอ่ะ ยังจำได้ใช่มั้ย) มันจะทำการ Fetch Instruction ครั้งเดียวจะรันคำสั่งได้ 2 อย่าง เรามี instruction 50 คำสั่งก็ใช้แค่ 25 words ในการเก็บมัน ก็คือ fetch แค่ 25 ครั้งก็พอ

*Tip: ในเคสที่ instruction เป็นจำนวนคี่ เช่น 49 เราจะต้องใช้ 25 words เช่นเดิม แต่ปัญหาอยู่ที่ words สุดท้ายยังโบ๋อยู่ (มีแค่ครึ่งซ้าย ไม่มีครึ่งขวา) วิธีแก้ปัญหาก็คือเพิ่ม instruction ที่ชื่อ “NOP” หรือ no operation เข้าไป แล้วใส่ลงไปในช่องว่างครึ่งหลังนั่นเอง

ใน CPU มีอะไร?

ตามการออกแบบครั้งแรก CPU ของ IAS ประกอบด้วย CC และ CA แต่เพื่อความง่ายจะขอเรียกมันว่า CU และ ALU อย่างที่เราชินกันละกันนะ

ใน Intro to Digital System เราเรียนเรื่อง Register ไปแล้ว รีจิสเตอร์เป็นตัวเก็บข้อมูลสำหรับการคำนวนใน CPU ซึ่งมีความเร็วสูงที่สุดแล้ว แต่ความจุน้อยและราคาแพงสุดเลยล่ะ

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

แต่เราจะยังไม่พูดถึงมันต่อในตอนนี้ (ในวีดีโอมีพูด แต่ขอตัดไปตอนต่อไป) บล๊อกนี้กินพลังมากเลย เดี๋ยวไว้ต่อในบล๊อกถัดไปละกัน เราจะมาดูกันว่า CPU กับ Data/Instruction ทำงานประสานกันยังไง บายจ้า

5200 Total Views 3 Views Today
Ta

Ta

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

You may also like...

ใส่ความเห็น

อีเมลของคุณจะไม่แสดงให้คนอื่นเห็น ช่องที่ต้องการถูกทำเครื่องหมาย *