สร้างเคอร์เนลระบบปฏิบัติการด้วยตัวเองตั้งแต่ต้น

 (popovicu.com)
38 คะแนน โดย GN⁺ 2025-09-16 | 1 ความคิดเห็น | แชร์ทาง WhatsApp
  • แชร์ประสบการณ์การสร้าง prototype kernel ของระบบปฏิบัติการแบบ time-sharing บน สถาปัตยกรรม RISC-V
  • อธิบายแนวคิดและวิธีการทำงานของ เคอร์เนลแบบ time-sharing โดยเน้นการลงมือปฏิบัติ และเลือกใช้ Zig แทน C เพื่อให้ทำซ้ำได้ง่ายขึ้น
  • ใช้แนวทาง unikernel ที่รวมเคอร์เนลและโค้ดผู้ใช้ไว้ในไบนารีเดียว พร้อมวางเลเยอร์โดยใช้ OpenSBI สำหรับการพิมพ์ออกคอนโซลและควบคุมตัวจับเวลา
  • เธรดทำงานใน โหมดผู้ใช้ (U-mode) ส่วนเคอร์เนลทำ context switch ใน โหมด supervisor (S-mode) ผ่าน timer interrupt และข้ามขอบเขตด้วย system call
  • หัวใจสำคัญคือเทคนิคการ สลับ stack frame ที่ interrupt prologue/epilogue สร้างไว้ เพื่อกู้คืนชุดรีจิสเตอร์และ CSR ของอีกเธรดหนึ่งแล้วสลับการไหลของโปรแกรม
  • มอบสภาพแวดล้อมการเรียนรู้ที่ใครก็ทำซ้ำได้ด้วย QEMU virtual machine และ OpenSBI เวอร์ชันล่าสุด พร้อมเชื่อมโยงเชิงแนวคิดของสเปกตรัมการจำลองเสมือนอย่าง thread·process·container ทำให้เป็นเนื้อหาพื้นฐานที่เหมาะสำหรับการศึกษาและการฝึกปฏิบัติ

ภาพรวม

  • แนะนำกระบวนการสร้างเคอร์เนลระบบปฏิบัติการแบบ time-sharing ด้วยตัวเองบนสถาปัตยกรรม RISC-V
  • ผู้อ่านหลักคือผู้เริ่มต้นด้าน system software และ computer architecture นักศึกษา และวิศวกรที่สนใจทำความเข้าใจหลักการทำงานระดับล่าง
  • การทดลองนี้ใช้ ภาษา Zig แทนภาษา C แบบเดิมเพื่อให้การทำซ้ำภาคปฏิบัติทำได้ง่ายขึ้นและติดตั้งไม่ยุ่งยาก
  • โค้ดสุดท้ายเผยแพร่อยู่ในรีโพซิทอรี popovicu/zig-time-sharing-kernel และอาจต่างจากเนื้อหาในบทความเล็กน้อย
    • แนะนำให้ถือเวอร์ชันในรีโพซิทอรีเป็น แหล่งอ้างอิงหลักเพียงหนึ่งเดียว มากกว่าตัวอย่างโค้ดที่ยกมาในบทความ
    • เพื่อความสะดวกในการทดลอง ควรตั้งค่าสภาพแวดล้อมตาม linker script·build option ของรีโพซิทอรี

Recommended reading

  • บทความนี้ตั้งอยู่บนพื้นฐานว่าเข้าใจ พื้นฐาน computer architecture เช่น รีจิสเตอร์ การระบุที่อยู่หน่วยความจำ และอินเทอร์รัปต์
    • เนื้อหาที่แนะนำให้อ่านก่อนคือ Bare metal on RISC-V, กระบวนการบูตของ SBI, และ ตัวอย่าง timer interrupt
    • บทความ micro Linux distro ก็มีประโยชน์เพิ่มเติมสำหรับทำความเข้าใจแนวคิดการแยกพื้นที่ kernel กับ user space

Unikernel

  • เลือกใช้โครงแบบ unikernel ที่ลิงก์แอปพลิเคชันและ OS kernel เป็นไฟล์ปฏิบัติการเดียว
    • ช่วยหลีกเลี่ยงความซับซ้อนของ loader·linker ใน runtime และทำให้การโหลด โค้ดผู้ใช้ เข้าหน่วยความจำพร้อมเคอร์เนลง่ายขึ้น
    • สำหรับเป้าหมายด้านการศึกษาและการทำซ้ำ มีข้อดีเรื่อง ความเรียบง่ายในการแจกจ่าย และ ความสม่ำเสมอของสภาพแวดล้อม

SBI layer

  • RISC-V ใช้โมเดลสิทธิ์แบบ M/S/U mode และการทดลองนี้วาง OpenSBI ไว้ที่ M-mode ให้เคอร์เนลทำงานใน S-mode
    • มอบหมายการพิมพ์ออกคอนโซลและการควบคุม อุปกรณ์ตัวจับเวลา ให้ SBI เพื่อให้ได้ ความสามารถในการพกพา
    • หากไม่มี SBI จะใช้ UART MMIO เป็น fallback แต่สำหรับการทดลองแนะนำให้ใช้ OpenSBI เวอร์ชันใหม่ล่าสุด

Goal for the kernel

  • เพื่อลดความซับซ้อน จึงรองรับเฉพาะ static thread และเธรดถูกประกอบเป็น ฟังก์ชันที่ไม่สิ้นสุดการทำงาน
    • เธรดทำงานใน U-mode และส่ง system call ไปยังเคอร์เนลใน S-mode
    • สร้าง time-sharing scheduling บนสมมติฐาน single core เพื่อให้สามารถสลับไปยังอีกเธรดได้ทุกครั้งที่เกิด timer tick

Virtualization and what exactly is a thread

  • time-sharing threading เป็นรูปแบบของ virtualization ที่ทำให้งานหลายอย่างดำเนินไปพร้อมกันบน single core โดย ไม่เปลี่ยน programming model
    • ต่างจาก cooperative scheduling ตรงที่การสลับเกิดขึ้นจาก timer interrupt โดยไม่ต้องมี yield แบบชัดเจน
    • แต่ละเธรดมี ชุดรีจิสเตอร์และสแตกที่แตะต้องข้ามกันไม่ได้ ส่วนหน่วยความจำที่เหลืออาจใช้ร่วมกันได้

The stack and memory virtualization

  • เธรดต้องมี stack แยกต่างหาก ซึ่งจำเป็นต่อการรักษาบริบทการทำงานตาม calling convention เช่น ตัวแปร local และการเก็บ ra
    • สเปกตรัมของ virtualization เรียงต่อกันเป็น thread < process < container < VM โดยระดับการแยกและ มุมมอง (view) จะแตกต่างกัน
    • ใน Linux นั้น container ถูกสร้างจาก การผสมกลไกของเคอร์เนล เช่น chroot, cgroups

Virtualizing a thread

  • เป้าหมายขั้นต่ำของการจำลองเธรดในงานทดลองนี้คือ คง programming model เดิม, ปกป้องรีจิสเตอร์และ CSR บางส่วน, และ จัดสรร stack แยกให้แต่ละเธรด
    • เน้นย้ำว่าหากไม่ปกป้องมุมมองของรีจิสเตอร์ การคำนวณที่มีความหมายจะเป็นไปไม่ได้
    • มีการ seed ค่าอย่าง a0 ลงในสแตกตั้งแต่ต้น เพื่อส่งอาร์กิวเมนต์ให้เธรดตอนเริ่มทำงานได้อย่างกระชับ

Interrupt context

  • อินเทอร์รัปต์สามารถเข้าใจได้ว่าเป็น โมเดลคล้ายการเรียกฟังก์ชัน ที่มี prologue/epilogue สำหรับเก็บและกู้คืนรีจิสเตอร์ลงสแตก
    • จำเป็นต้องปฏิบัติตาม กติกาการเก็บรักษา เพื่อไม่ให้ timer interrupt แบบ asynchronous ทำลายค่ารีจิสเตอร์
    • แอสเซมบลีตัวอย่างเก็บและกู้คืนไม่เพียง x0–x31 แต่รวมถึง CSR อย่าง sstatus, sepc, scause, stval ด้วย

Implementation (high-level)

Leveraging the interrupt stack convention

  • ตัวแกนของ interrupt routine อยู่ระหว่าง prologue และ epilogue และหาก สลับ sp ไปยังพื้นที่หน่วยความจำอื่น ก็จะกู้คืน ชุดรีจิสเตอร์ของอีกบริบทหนึ่ง แทน
    • สิ่งนี้ก็คือ context switch และเป็นแนวคิดหลักของการทำ time-sharing ในการทดลองนี้
    • timer interrupt จะเข้ามาแทรกเป็นระยะเพื่อให้ main flow และ interrupt flow ทำงานสลับกัน

Kernel/user space separation

  • คงขอบเขตระหว่าง เคอร์เนล S-mode / ผู้ใช้ U-mode ไว้ โดยการจัดการอินเทอร์รัปต์และ system call ดำเนินใน S-mode trap handler
    • ลำดับการบูตคือ OpenSBI ใน M-mode → การเริ่มต้นเคอร์เนลใน S-mode → เริ่มเธรดใน U-mode
    • timer interrupt แบบเป็นคาบทำให้เกิด scheduling·context switching ได้

Implementation (code)

Assembly startup

  • ใน startup.S มีลำดับขั้นต่ำสำหรับ ล้างค่า BSS และตั้งค่า stack pointer เริ่มต้นก่อนกระโดดไปยัง main ของ Zig
    • จุดเข้าเคอร์เนลใช้กติกา export เพื่อเชื่อมกับ C ABI

Main kernel file and I/O drivers

  • kernel.zig ใน main จะตรวจสอบ ความสามารถของคอนโซล OpenSBI ก่อน และถ้าล้มเหลวจึง fallback ไปที่ UART MMIO
    • sbi.debug_print จะตั้งค่ารีจิสเตอร์ a0/a1/a6/a7 ตาม ECALL protocol ก่อนเรียกใช้งาน
    • หลังตั้งค่าตัวจับเวลาแล้ว จะลงทะเบียน S-mode interrupt handler และเปิดใช้งาน tick

S-mode handler and the context switch

  • handler เขียนด้วยกติกา naked ของ Zig เพื่อประกอบ prologue/epilogue แบบสมบูรณ์ รวมถึงการเก็บ CSR ด้วยตนเอง
    • ในตัวแกนจะเรียก handle_kernel(sp) และสลับเป็น sp ที่คืนกลับมา เพื่อกำหนดว่าจะมีการสลับบริบทหรือไม่
    • ใช้ scause เพื่อตรวจว่าเป็น ECALL จาก U-mode หรือ timer interrupt แล้วแยกเส้นทางจัดการ

The user space threads

  • โค้ดผู้ใช้ถูกรวมอยู่ใน ไบนารีเดียว กับเคอร์เนล และตัวอย่างเธรดจะทำซ้ำลำดับ พิมพ์สตริง → ลูปหน่วงเวลา
    • syscall.debug_print ใส่หมายเลข system call 64 ลงใน a7 และใส่ buffer/length ลงใน a0/a1 จากนั้นจึงทำ ECALL
    • ตอนเตรียมเธรด จะ seed return address·ค่ารีจิสเตอร์เริ่มต้น ลงบนสแตก เพื่อให้ใช้พารามิเตอร์ได้ทันทีในการ return ครั้งแรก

Running the kernel

  • การ build ใช้ zig build และการรันบน QEMU ระบุ virt machine + nographic + OpenSBI fw_dynamic
    • ตอนบูต หลัง OpenSBI banner จะเห็นเอาต์พุตตามรอบเวลาจากแต่ละ thread ID ปรากฏสลับกัน
    • หาก build ด้วย -Ddebug-logs=true จะเห็นรายละเอียดของ แหล่งที่มาของอินเทอร์รัปต์, สแตกปัจจุบัน, log การ queue·dequeue อย่างครบถ้วน

Conclusion

  • การทดลองนี้ปรับเคอร์เนลเพื่อการศึกษาให้ทันสมัยขึ้นด้วยชุดผสม RISC-V + OpenSBI + Zig ทำให้ได้ทั้ง การทำซ้ำได้ และ การอ่านเข้าใจง่าย
    • แม้จะมีการทำให้ง่ายลง เช่น การจัดการข้อผิดพลาดเพียงขั้นต่ำและ สแตกที่จัดเผื่อเกิน แต่จุดเน้นอยู่ที่การเรียนรู้ แก่นของ context switch และ การแยกสิทธิ์
    • การย้ายไปใช้กับเครื่องจริงยังเป็นไปได้ โดยมีเงื่อนไขว่าต้องปรับ ค่าคงที่ของ linker·driver และทำให้มั่นใจว่า SBI พร้อมใช้งาน

บันทึกเพิ่มเติม: สรุปสเปกตรัมของ virtualization

  • Threads: เน้น virtualization ของรีจิสเตอร์และสแตก โดยมีโอกาสสูงที่หน่วยความจำจะใช้ร่วมกันได้
  • Process: ทำ memory isolation ผ่านการจำลอง address space และอาจมีหลายเธรดอยู่ภายใน
  • Container: เป็นหน่วยแยกที่ประกอบจากการผสาน filesystem·network namespace และมุมมองของสภาพแวดล้อม
  • VM: มุ่งสู่ การจำลองฮาร์ดแวร์แบบสมบูรณ์

สรุปจุดสำคัญของการลงมือสร้าง

  • ทำ context switch ผ่าน การสลับ interrupt stack
  • เก็บและกู้คืน สถานะทั้งหมดรวม CSR ใน S-mode trap handler
  • ทำเส้นทางเอาต์พุตซ้ำซ้อนแบบ SBI ก่อน, UART MMIO เป็น fallback
  • ใช้ scheduling แบบเรียบง่ายโดยยึด static thread·single core·time slice เป็นหลัก
  • ทำให้ขอบเขต U/S ชัดเจนด้วย system call based ECALL

บทความที่เกี่ยวข้อง

1 ความคิดเห็น

 
GN⁺ 2025-09-16
ความคิดเห็นบน Hacker News

  • งานคล้ายกันนี้สามารถลองได้ในรูปแบบ "แพ็กเกจ" จาก "Operating System in 1000 Lines of Code" ฉันเคยทำตามด้วย Zig มาก่อน (แปลงโค้ดตัวอย่าง C เป็น Zig ไปด้วย) และสนุกมาก โค้ดกับ VOD ของฉันอยู่ที่นี่ https://github.com/kristoff-it/kristos/

    • สงสัยว่าต้องรู้จัก Zig มากแค่ไหนถึงจะทำแบบฝึกหัดนี้ได้ ถ้าไม่เคยแตะ Zig เลย ในทางปฏิบัติควรเริ่มลองอย่างไรบ้าง อยากฟังคำแนะนำโดยสมมติว่ามีพื้นฐาน C++

  • นี่เป็นโพสต์ที่ผู้เขียนบทความส่งแยกไว้เอง https://news.ycombinator.com/item?id=45236479 ผู้เขียนได้สร้าง Tiny OS Kernel ขึ้นมาใหม่ด้วยตัวเอง โดยตั้งใจอยากทดลองกับสภาพแวดล้อม RISC-V และ OpenSBI และใช้ Zig แทน C แบบดั้งเดิม จริง ๆ คิดว่าถ้าจะทำตามด้วย C หรือ Rust ก็น่าจะทำได้ไม่ยากนัก กระบวนการทั้งหมดอาจจะยังค่อนข้างหยาบ ๆ แต่เป็นการทดลองและบทนำสำหรับก้าวแรกในการเรียนรู้การพัฒนา OS Kernel และสถาปัตยกรรมคอมพิวเตอร์ คิดว่าเป็นโปรเจ็กต์ที่น่าลองเล่นสนุกในช่วงสุดสัปดาห์ โดยสามารถดู walkthrough ทั้งหมดและลิงก์ Github ได้จากด้านบน

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

    • ที่น่าสนุกกว่านั้นคือ ตอนปล่อย Linux ครั้งแรก Torvalds เขียนไว้ในอีเมลว่า "เป็นแค่งานอดิเรก และคงไม่ใหญ่หรือเป็นมืออาชีพเหมือน GNU" https://groups.google.com/g/comp.os.minix/c/dlNtH7RRrGA/m/SwRavCzVE7gJ

    • ฉันไม่ได้คิดว่าโปรเจ็กต์แบบนี้ <i>น่า</i>ประทับใจขนาดนั้น วิธีสร้างเคอร์เนลมัลติทาสกิงแบบมินิมอลเป็นเส้นทางที่รู้กันมาหลายสิบปีแล้ว การสร้างเคอร์เนลที่บูตขึ้นมาและทำงานง่าย ๆ ได้เป็นเรื่องที่คนฉลาดพอสมควรและมีความสม่ำเสมอก็ทำได้ ถ้าทำบน RISC-V ก็ซับซ้อนกว่า x86 นิดหน่อย แต่ข้อมูลการตั้งค่าฮาร์ดแวร์หาได้ง่าย (https://wiki.osdev.org/RISC-V_Meaty_Skeleton_with_QEMU_virt_board ดูได้ที่นี่) และในโปรเจ็กต์นี้ผู้เขียนเองก็พูดชัดว่าเป็น "การทำแบบฝึกหัดจากวิชา operating systems อีกรอบ" ฉันคิดว่าเป็นระดับที่ใครก็ตามที่จบวิศวกรรมซอฟต์แวร์ก็น่าจะทำได้ แน่นอนว่าอาจมีบั๊กหรือส่วนที่ยังไม่เสร็จ แต่การทำหลายโปรเซสหรือแยกโปรเซสด้วย MMU นั้นเดี๋ยวนี้ไม่ใช่เรื่องยากแล้ว

    • พอ ๆ กับ Linux การที่ Stallman เริ่มทำ C compiler และยูทิลิตี Unix ในปี 1984 ก็ถือว่าเปิดทางให้โอเพนซอร์ส Unix ไปอยู่บนเครื่องนับพันล้านเครื่องเช่นกัน

  • Zig ดีมากสำหรับการพัฒนา operating system และ RISC-V ก็เช่นกัน ฉันเองก็เริ่มงานแบบเดียวกันนี้บน x86 แต่หมดแรงเร็วเพราะมี legacy boilerplate เยอะเกินไป ฝั่ง RISC-V แทบไม่มีเรื่องนั้น ทำให้เริ่มพัฒนาได้ง่ายกว่ามาก https://github.com/Fingel/aeros-v

    • ฉันคิดว่าถ้าเริ่มบน x86 แล้วใช้ bootloader ให้ดี ก็ไม่ได้มี boilerplate เยอะขนาดนั้น multiboot loader มักจะจัดการ real mode ไว้ให้ และเพราะคนส่วนใหญ่ต้องการ protected mode ก็แค่ตั้งค่าตารางบางอย่างแล้วกระโดดไป ถ้าอยากปิด legacy interrupt controller ก็จะมีงานเพิ่มอีกหน่อย แต่ข้อดีคือสามารถบูตบนเดสก์ท็อปพีซีได้เลย (ต้องระวังเรื่องอินเทอร์เฟซคอนโซล) OS งานอดิเรกของฉันเคยใช้ BIOS boot กับฟังก์ชัน VGA บางอย่าง แล้วต้องลำบากเพราะความเข้ากันได้ไม่ดี serial console ง่ายกว่ามาก แต่คอมพิวเตอร์สมัยนี้มักไม่มี serial port แล้ว

    • โดยพื้นฐานแล้วมันคือการหยิบความปลอดภัยของ Object Pascal หรือ Modula-2 กลับมา แล้วห่อใหม่ด้วยไวยากรณ์แบบ C นั่นเอง C ไม่ได้มีอะไรพิเศษนักนอกจากแพร่หลายเพราะไลเซนส์ของ UNIX

    • ฉันก็อยากลองทำเองเหมือนกัน เลยสงสัยว่ารันเคอร์เนล RISC-V บนสภาพแวดล้อมแบบไหน ใช้แค่ Qemu หรือมีฮาร์ดแวร์จริงที่แนะนำด้วยก็บอกหน่อย

  • ฉันคิดว่า ISA ของ RISC-V เข้าถึงง่ายมาก เอกสารก็ดีเยี่ยม ตัวอย่างก็เยอะมาก และอีมูเลเตอร์ก็มีจำนวนมากเช่นกัน machine code แบบไม่บีบอัดก็อ่านง่าย ฉันกำลังเขียนหนังสือเองให้ลูกสาว พร้อมสร้าง OS ขนาดเล็กที่มี Forth และ timesharing ไปด้วย https://punkx.org/projekt0/book/part1/os.html ถ้าเป็น x86 ฉันคงไม่เริ่มเลยด้วยซ้ำ ระหว่างทางฉันได้เรียนทั้ง Forth และแอสเซมบลี RISC-V ไปพร้อมกันและสนุกมาก ถ้าอยากสร้าง OS ของเล่นขึ้นมาจากศูนย์ ตอนนี้เป็นช่วงเวลาที่เหมาะมากจริง ๆ (น่าตื่นเต้นพอ ๆ กับยุค 1980) หา RISC-V board ราคาถูกสักตัว (เช่น rp2350) แล้วอัปโหลดส่วนของคู่มือที่เกี่ยวข้องให้ AI อย่าง Claude ก็ช่วยได้มากเวลาติดขัด

    • ฉันเพิ่งลองค้นหาราคาบอร์ดในประเทศตัวเอง แล้วตกใจว่าถูกกว่าที่คิดมาก ตอนนี้กำลังลังเลอยู่ 90% ว่าจะซื้อมาเล่นสักตัวดีไหม

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

  • (อ้างคำพิพากษาภาษาสเปน) จะบล็อก http ก็ว่าไปอย่าง แต่นี่มันเกินไป...

    • ได้ยินมาว่าในสเปน Cloudflare (และอาจรวมถึงรายอื่น) โดนบล็อกพลาดเพราะปัญหาเรื่องการถ่ายทอดฟุตบอล เลยสงสัยว่าคนที่นั่นหลบเลี่ยงปัญหานี้กันอย่างไร ใช้ VPN กันหรือเปล่า? ถ้า IP สำคัญโดนบล็อก งานก็น่าจะได้รับผลกระทบด้วย

    • (จากคำพิพากษา) พอเห็นว่าฝั่งที่เริ่มเรื่องคือสมาคมฟุตบอลอาชีพสเปนกับ Telefónica Audiovisual Digital ก็ทำให้ฉันคิดว่าคนพวกนี้คืออาชญากร

    • ...อะไรนะ? หมายความว่าองค์กรฟุตบอลของสเปนมีสิทธิจำกัดการเข้าถึงอินเทอร์เน็ตของคนทั้งประเทศงั้นหรือ?

  • สงสัยว่าจะหา RISC hardware ราคาถูกได้อย่างไร

    • AliExpress ขายบอร์ดชื่อ Milk-V Duo S ในราคา 10 ดอลลาร์ ช่วงนี้เด้งขึ้นมาในรายการแนะนำบ่อยมาก สเปกหลักคือมาพร้อม SG2000 master รุ่นอัปเกรดและ RAM 512MB, IO กว้างขึ้น, บางรุ่นมี WI-FI6/BT5 (ยกเว้นรุ่น 512M-Basic/eMMC), พอร์ต USB 2.0 host, Ethernet 100Mbps รองรับ PoE, dual MIPI CSI, และรองรับสวิตช์สลับบูต RISC-V กับ ARM https://aliexpress.com/w/wholesale-Milk%2525252dV-Duo-S.html

    • มีหลายบอร์ดอยู่แล้ว แต่ตัวที่ฉันสนใจจนลงเงินสนับสนุนคือ VisionFive 2 Lite https://www.kickstarter.com/projects/starfive/visionfive-2-lite-unlock-risc-v-sbc-at-199/description ฉันไม่มี VisionFive2 รุ่นแรก แต่ได้ยินรีวิวดีและบอกว่า ecosystem กำลังเติบโตขึ้นเรื่อย ๆ แม้จะยังมีส่วนที่ไม่สมบูรณ์อยู่บ้าง แต่ก็หวังว่าจะเริ่มส่งของเร็ว ๆ นี้ ส่วนตัวที่ฉันใช้อยู่คือ PolarFire SoC Discovery Kit เป็นบอร์ด RISC-V แบบ quad-core ที่มี FPGA อยู่ด้วย ค่อนข้างแพง (130 ดอลลาร์) และอาจไม่เหมาะกับทุกคน แต่เรื่องที่น่าสนใจคือบอร์ดกลับถูกกว่าตัวชิปเอง https://www.microchip.com/en-us/development-tool/MPFS-DISCO-KIT เอกสารและ toolchain ของ Microchip ค่อนข้างเก่าและไม่ค่อยดีนัก แต่พอคุ้นแล้ว การรันโค้ด RISC-V แบบ bare-metal นั้นง่ายมาก และตัวอย่าง Linux/bare-metal ก็ทำไว้เป็นมิตรดี

    • ขอแนะนำว่าแม้ยังไม่มีฮาร์ดแวร์จริง ก็ลองรันผ่านอีมูเลเตอร์บนเครื่อง x86 หรือ Apple ก่อนจะดีกว่า พัฒนาได้เร็วกว่าใช้บอร์ดจริง และใช้ QEMU ก็เริ่มได้ทันที https://www.qemu.org/docs/master/system/target-riscv.html

    • Raspberry Pi Pico 2 ก็รองรับ RISC-V เหมือนกัน ใช้ได้ดี https://www.raspberrypi.com/products/raspberry-pi-pico-2/

    • ขอบคุณทุกคนสำหรับคำตอบ ส่วนคนที่กดโหวตลบคำถามของฉัน ฉันไม่เห็นว่าควรได้รับคำขอบคุณอะไร