- Python เป็น โปรเซสเซอร์แบบคัสตอม ที่รันได้โดยตรงบนฮาร์ดแวร์ โดยไม่ต้องใช้ interpreter หรือ JIT
- เวลาไป-กลับของ GPIO บน PyXL อยู่ที่ 480ns เร็วกว่า PyBoard ที่ใช้ MicroPython ถึง 30 เท่า
- ทำงานบน Zynq-7000 FPGA โดยมี ARM CPU จัดการการตั้งค่าและหน่วยความจำ
- GPIO หมายถึง อินพุต/เอาต์พุตอเนกประสงค์ และ PyXL รันสิ่งนี้โดยตรงบนฮาร์ดแวร์โดยไม่ผ่าน VM หรือ ซอฟต์แวร์สแตก
- ให้ประสิทธิภาพแบบ กำหนดแน่นอน และ สม่ำเสมอ สำหรับ ระบบควบคุมแบบเรียลไทม์, หุ่นยนต์, ระบบอุตสาหกรรมแบบฝังตัว และอื่น ๆ
แนะนำ PyXL
- PyXL คือ โปรเซสเซอร์แบบคัสตอม ที่รัน Python ได้โดยตรงบนฮาร์ดแวร์
- รันโค้ด Python บน ซิลิคอน โดยไม่ต้องใช้ interpreter หรือ JIT
- แปลง CPython ByteCode เป็น custom assembly แล้วนำไปรันบน pipeline processor
คุณสมบัติของ PyXL
- ไม่ใช่ C หรือ inline loop
- ไม่ใช่ MicroPython หรือ JIT
- ไม่ได้รัน Linux หรือ ระบบปฏิบัติการ
- เป็นโปรเซสเซอร์สำหรับ Python โดยเฉพาะ ที่ออกแบบมาเพื่อความ กำหนดแน่นอน และ ความเร็ว
สภาพแวดล้อมการทำงานของ PyXL
- ทำงานบน Zynq-7000 FPGA โดยใช้ บอร์ดพัฒนา Arty-Z7-20
- คอร์ PyXL ทำงานที่ 100MHz
- ARM CPU จัดการการตั้งค่าและหน่วยความจำ ขณะที่ โค้ด Python รันโดยตรงบนฮาร์ดแวร์
GPIO คืออะไร?
- GPIO หมายถึง อินพุต/เอาต์พุตอเนกประสงค์ ซึ่งทำให้ ซอฟต์แวร์ สามารถควบคุม LED, ปุ่ม, เซ็นเซอร์, มอเตอร์ และอื่น ๆ ได้
- ใน MicroPython โค้ด Python จะโต้ตอบกับ ฟังก์ชัน C เพื่อจัดการรีจิสเตอร์ฮาร์ดแวร์
- PyXL รัน Python bytecode โดยตรงบนฮาร์ดแวร์ ทำงานบน native hardware โดยไม่ต้องมี interpreter หรือ function call
การทดสอบ GPIO
- ทดสอบโดยเชื่อมต่อพินสองขาของ บอร์ด Arty ด้วย สายจัมเปอร์
- เขียน โปรแกรม Python เพื่อวัดเวลาตั้งแต่ตั้งค่า GPIO pin 1 เป็น 1 จนกระทั่งวัดค่า 1 ได้จาก อีกพินหนึ่ง
- ยืนยันความต่างด้านประสิทธิภาพผ่าน วิดีโอ ที่เปรียบเทียบ PyXL กับ MicroPython VM บน PyBoard
โครงสร้างโปรแกรมของ PyXL
- โปรแกรม Python จะถูกคอมไพล์เป็น CPython Bytecode ก่อน แล้วแปลงเป็น PyXL assembly
- มีการสร้าง ไบนารี และส่งผ่าน เครือข่าย ไปยัง บอร์ด Arty
- ARM CPU รับ แอปพลิเคชัน แล้วคัดลอกไปยัง ฮาร์ดแวร์ PyXL และ หน่วยความจำที่ใช้ร่วมกัน ก่อนรัน
การเปรียบเทียบแพลตฟอร์ม
- เวลาแฝงไป-กลับของ GPIO: PyXL อยู่ที่ 480ns, ส่วน MicroPython (PyBoard) อยู่ที่ 14,741ns
- PyXL เร็วกว่า PyBoard 30 เท่า และเมื่อ normalize clock speed แล้วจะเร็วกว่า 50 เท่า
ข้อดีของ PyXL
- Python VM อาศัย software interpreter จึงก่อให้เกิด overhead และ ความซับซ้อน
- PyXL ขจัด อุปสรรค เหล่านี้ออกไป และรัน โค้ด Python โดยตรงบนฮาร์ดแวร์
- การเข้าถึง GPIO เป็นแบบ เชิงกายภาพ และ control flow สามารถคาดการณ์ได้ ให้ประสิทธิภาพที่ สม่ำเสมอ
การประยุกต์ใช้งานของ PyXL
- สามารถใช้งานใน ระบบควบคุมแบบเรียลไทม์ ด้วย Python ล้วน
- รองรับ ML inference และ sensor response loop ที่ต้องทำตาม ข้อจำกัดด้านเวลาที่เข้มงวด
- ใช้ใน งานหุ่นยนต์ เพื่อจัดการ motor feedback และ sensor fusion ด้วย ความแม่นยำระดับไซเคิล
- เหมาะสำหรับ ระบบอุตสาหกรรมแบบฝังตัว ที่ timing และ ความน่าเชื่อถือ เป็นสิ่งสำคัญ
6 ความคิดเห็น
แล้วรับมือกับการเปลี่ยนเวอร์ชันอย่างไร?
สำหรับวิศวกร HiL นี่อาจจะเป็นข่าวดีได้เหมือนกันนะ
โอ้ น่าสนใจดีนะ
ตื่นเต้นมากเลยครับ
นักพัฒนาโปรเจ็กต์นี้จะนำเสนอหัวข้อนี้ที่งาน PyCon US ครั้งนี้ ตอนรีวิวข้อเสนอเมื่อต้นปีก็เป็นประเด็นที่ถูกพูดถึงกันมากพอสมควรในหมู่รีวิวเวอร์ แต่เมื่อเทียบกันแล้ว คำแนะนำเซสชันกลับเรียบง่ายเกินไปนะครับ ใครที่จะไปงาน PyCon ก็ขอแนะนำว่าอย่าลืมไปฟังสักครั้ง
https://us.pycon.org/2025/schedule/presentation/40/
ความคิดเห็นจาก Hacker News
สงสัยว่ามีข้อจำกัดเกี่ยวกับโค้ดที่สามารถรันได้หรือไม่ นอกเหนือจากข้อจำกัดด้านหน่วยความจำหรือการโต้ตอบกับ OS คิดว่าแนวคิดในการทำไบต์โค้ดสำหรับรันไทม์ของภาษาแบบไดนามิกให้เป็นโปรเซสเซอร์แบบปรับแต่งเองนั้น ช่วงหลังมานี้ยังไม่ได้ถูกสำรวจมากพอ อยากรู้ว่าทำไมถึงเลือกแนวทางนี้ ทำไมจึงคิดว่าเป็นไอเดียที่ดี และมีการนำไปสร้างอย่างไร
ได้สร้างฮาร์ดแวร์โปรเซสเซอร์ที่รันโปรแกรม Python ได้โดยตรง โดยไม่ต้องมี VM หรืออินเทอร์พรีเตอร์แบบดั้งเดิม เบนช์มาร์กระยะแรก: เวลาไป-กลับของ GPIO อยู่ที่ 480ns ซึ่งเร็วกว่า MicroPython 30 เท่า
เป็นงานที่เจ๋งมาก สงสัยว่าชุดความสามารถสุดท้ายจะไปได้ไกลกว่าการสร้างฮาร์ดแวร์แบบปรับแต่งเอง หรือการคอมไพล์ภาษาแบบ type-safe ที่มีไวยากรณ์คล้าย Python ให้เป็นเนทีฟหรือไม่ การทำ garbage collection แบบเบื้องหลังนั้นไม่ได้ง่ายอย่างที่พูด แต่ก็กำลังพูดถึงคนที่ทำงานยากมากได้น่าประทับใจแล้ว
สงสัยว่าทำไมการ "คอมไพล์" Python ถึงไม่ใช่เรื่องปกติ เข้าใจว่าอินเทอร์พรีเตอร์ดีต่อการวนพัฒนาอย่างรวดเร็ว ความเข้ากันได้ ฯลฯ แต่ในโลกของ Python สงสัยว่าทำไมการยอมทิ้งข้อดีของการคอมไพล์แล้วเอาไฟล์ "source" ไปลงโปรดักชันตรง ๆ ถึงกลายเป็นแนวปฏิบัติที่ยอมรับกัน
น่าสนใจมาก สงสัยว่าข้อจำกัดทางกายภาพพื้นฐานคืออะไร เช่น ความแม่นยำของไทมิง ค่าหน่วง และจิตเตอร์ PyXL bytecode สามารถตอบสนองต่ออินพุตได้เร็วแค่ไหน มีสิ่งที่คล้ายกันชื่อ ARTIQ ซึ่งรันโค้ด Python ได้ด้วยประสิทธิภาพระดับ 'embedded' โดย ARTIQ มักใช้ในห้องแล็บฟิสิกส์ควอนตัม โค้ด Python กับ FPGA ต้องสื่อสารกัน ซึ่งในทางเทคนิคทำได้ยากและมีหลุมพรางมากมาย ถ้า PyXL ทำให้เรื่องนี้ง่ายขึ้นสำหรับผู้ใช้ นั่นเป็นประโยชน์อย่างมากสำหรับทุกคน
ตอนที่ C# ออกมาใหม่ ๆ เคยมั่นใจว่าจะต้องมีใครสักคนสร้างโปรเซสเซอร์ที่รัน .Net bytecode แบบเนทีฟขึ้นมา สงสัยว่าใช้ HDL อะไรในการออกแบบโปรเซสเซอร์ และสงสัยว่าจะสามารถแชร์ assembly language ของโปรเซสเซอร์ได้หรือไม่ อยากรู้ว่าการออกแบบโปรเซสเซอร์และสร้าง Python bytecode compiler เอง มีข้อดีอะไรเมื่อเทียบกับการสร้าง bytecode compiler สำหรับโปรเซสเซอร์ที่มีอยู่แล้ว (ARM/x86/RISCV เป็นต้น)
อยากถามนักพัฒนา Python ว่าเห็นโปรเจกต์นี้แล้วรู้สึกว่าน่าประทับใจ แต่ในฐานะคนนอกของภาษา กลับยังไม่ค่อยเข้าใจ a) สิ่งที่เคยรู้สึกว่ายากเพราะ Python b) เหตุผลที่ Python มีประโยชน์กับงานนี้ c) ความคิดเห็นที่มีต่อ Python เอง เคยเจอความลำบากจาก Python 2 และ 3, virtual environment, ไลบรารีของแต่ละเวอร์ชัน ฯลฯ ในฐานะนักพัฒนา PHP/Go ก็สนใจ แต่ปัญหาเหล่านี้ทำให้ยังลังเล
งานน่าทึ่งมาก ทุกครั้งที่เห็นการนำ FPGA ไปใช้งานได้ยอดเยี่ยม ก็อดเสียดายไม่ได้ที่ Tabula ไม่ประสบความสำเร็จ มันเป็น FPGA ที่ทั้งล้ำมากและเร็วมาก
สงสัยว่าความเข้าใจของผมถูกไหมว่า ASIC นี้กำลังรันไมโครคอนโทรลเลอร์ที่ออกแบบมาสำหรับ Python โดยเฉพาะ และมีไมโครโค้ดที่ปรับให้เข้ากับ Python มีคอมไพเลอร์ที่คอมไพล์ Python bytecode ไปเป็นไมโครโค้ด และมีโครงสร้างรองรับที่ส่ง bytecode ที่คอมไพล์แล้วไปยัง ASIC ฟังดูสนุกดี แค่อยากรู้ว่าเข้าใจถูกหรือไม่