compiler – ตอนที่ 2 ว่าด้วยการประมวลผล “ภาษา” … Tombstone Diagrams

อ่านตอนก่อนหน้านี้ได้ที่ #Compiler

Processor … เราจะ “สั่ง” ให้คอมพิวเตอร์ทำงาน!

คอมพิวเตอร์ทำงาน ด้วยหลักการ input -> process -> output ใครเคยเรียนวิชาการเขียนโปรแกรมกับเราคงรู้ว่าเราเน้นเรื่องนี้เป็นอันดับ แรกๆ

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

  1. Program ตัวโปรแกรมจริงๆ เลย
  2. Machine เครื่องที่ใช้รันโปรแกรม
  3. Translator ตัวแปลภาษา
  4. Interpreter ตัวแปลงโปรแกรม

เอาล่ะ ฟังอย่างนี้คงเข้าใจยากไปหน่อย ลองมาดูเป็นแบบ Tombstone Diagrams กันดีกว่า

Tombstone Diagrams

เป็น diagram ที่คิดขึ้นมาเพื่ออธิบายการทำงานของโปรแกรมโดยอิงเครื่องที่เราใช้รันโปรแกรมเป็นหลัก

จากรูปจะเห็นว่าเรามี symbol ทั้งหมด 4 แบบ

สำหรับ Program กับ Machine คงอธิบายได้ไม่ยาก ขอพูดถึง2ตัวนี้ก่อนเลยละกันนะ


Program + Machine

Program จะแบ่งเป็น2ส่วนคือบนกับล่าง ข้างบนจะบอกว่าโปรแกรมนี้ชื่ออะไร ส่วนข้างล่างจะบอกว่าโปรแกรมนี้จะรันได้ต้องรันด้วยภาษา (ด้วยเครื่อง) แบบไหน

ซึ่งถ้าเราจะเอาโปรแกรม P ไปรันบนเครื่องแบบ M เขาก็จะเขียนกันประมาณนี้

แต่ก็นะ … เจ้าตัว Translator ก็คล้ายๆ กับ Program นั่นแหละ ไม่ต่างกันเท่าไหร่หรอก (เฉพาะเวลารันนะ)

แต่ประเด็นสำคัญของการเอาโปรแกรมไปรันก็คือ ตัวภาษาของโปรแกรมนั้นจะต้องตรงกับเครื่องที่ใช้รัน

ถ้ามันไม่ตรงกันเช่นเอาโปรแกรม P ที่รันด้วย A ไปรันบนเครื่อง M มันก็รันไม่ได้ไงเพราะภาษาไม่ตรงกัน

อ๊ะ แล้วแบบนี้จะรันโปรแกรมได้ยังไงล่ะ

Interpreter

คำตอบก็คือใช้โปรแกรมพิเศษ! ที่เรียกว่า “อินเทอพรีเตอรฺ์” มาช่วย

ตัว Interpreter นี่มันก็เหมือนกับตัวกลาง ถ้าเรา (เผอิญ) มี Interpreter A -> M พอดี เราก็เอาเจ้านี้มาแทรกกลางระหว่าง Program และ Machine ซะ (ฮา)

แค่นั้นแหละ จะต่อกี่ตัวก็ได้เหมือนโดมิโน่

แล้วก็เหลือตัวเดียว นั่นคือ

Translator

ทรานสะเลเตอร์ หรือมันก็คือต้นแบบของ “คอมไพเลอร์” นั่นเอง

ให้คิดว่า Translator เป็น Program ประเภทหนึ่ง แต่มันไม่ใช่โปรแกรมสำหรับทำงานทั่วไป แต่มันใช้สำหรับแปลงโปรแกรมอีกทีหนึ่ง

ตัว Translator จะแบ่งเป็นส่วนบนและล่างเหมือนกับ Program แต่ต่างกันที่สัญลักษณ์ที่เป็นขอบเหลี่ยมไม่ใช่ขอบมนแค่นั้น เอ๊ย! ต่างกันที่ส่วนบนของ Translator จะเขียนว่ามันใช้แปลงโปรแกรม (ที่ใช้ภาษา) S ให้กลายเป็น (ภาษา) T

อ่ะ มาดูตัวอย่างการใช้งานกัน เรามี Translator S -> T with M หรือ Translator ที่ใช้แปลงโปรแกรมภาษา S ให้กลายเป็นโปรแกรมเดิมที่รันด้วยภาษา T ซึ่งทำงานบนเครื่องแบบ M

จุด ประสงค์ก็คือ เรามีโปรแกรม P ที่รันบนเครื่อง S ในตอนแรก แต่แบบว่า มันไม่พอใจอ่ะ อยากได้โปรแกรม P ที่รันบนเครื่อง T แทน … และเนื่องจากเรามี Translator ที่ทำงานแบบนี้ได้อยู่พอดีก็จะเขียนได้แบบนี้

เอา Translator รันบนเครื่อง M ซึ่งตรงกันตามกฎ “โดมิโน่ (ตั้งเองนะ 55)” แล้วเราก็เอาโปรแกรม P ที่รันบน S ไปวางไปทางซ้ายของ Translator ซึ่งเป็นฝั่ง input

แน่นอน ถ้า input อยู่ทางซ้าย output ก็ต้องอยู่ทางขวา เราเลยจะได้ผลออกมาเป็นโปรแกรม P เหมือนเดิม แค่คราวนี้มันเอาไปรันบนเครื่อง Tได้แล้ว

ป.ล. อย่าสับสนว่าโปรแกรม P(S) ตอนแรกจะหายไปนะ แค่หลังจากทำเสร็จแล้ว เราจะได้โปรแกรม P(T) เพิ่มขึ้นมาอีกตัวหนึ่งแทน

มันผสมกันได้นะ!

เราสามารถเอาทั้ง Program Translator Interpreter Machine มารวมอยู่ในรูปเดียวกันได้เพราะมันจะทำให้โปรแกรมเรารันได้

Virtual Machine เครื่องปลอมที่ทำงานได้จริง

VM หรือ ศัพท์เทคนิคทางวิชาคอมไพเลอร์เรียกว่า Interpretive Compiler เป็นคอนเซ็ปที่ใช้สร้างภาษาที่เขียนครั้งเดียว แต่เอาไปรันในเครื่องคอมได้ทุกรุ่นทุกยี่ห้อ (Write Once, Run Anywhere)

ขอ ยกตัวอย่างภาษาที่ใช้คอนเซ็ปนี้ตัวเด่นๆ นั่นคือ Java ละกัน (ตัวอย่างภาษาอื่นเช่น C#.NET แต่เรารู้สึกว่ามันลอก Java ไปด้วยคอนเซ็ปเดียวกันเป๊ะเลยไม่ขอพูดถึงซ้ำละกัน)

โดย ทั่วไป ถ้าเรามีครื่องแบบ x86 (ส่วนใหญ่จะหมายถึง Windows แบบ 32-bit .. ถ้าเป็นแบบ 64-bit จะเรียกว่า x64) เรามีโปรแกรม P เราก็ควรจะเอาเจ้าโปรแกรม P นี้ไปสร้างให้เป็น P(x86) จริงม๊ะ?

มันจะได้รันในเครื่อง x86 เราได้ไงล่ะ

แต่ถ้าทำอย่างนั้น ก็แปลว่า P(x86) ของเราจะเอาไปรันในเครื่องอื่น เช่น เครื่องMac หรือ คอมที่ลงOSเป็น Linux ไม่ได้สินะ

แล้วทำยังไงดีล่ะ?

คำ ตอบก็คือแทนที่จะใช้ Translator แปลงเจ้าโปรแกรม P เป็น P(x86) ก็แปลงมันเป็นภาษากลางตัวหนึ่งแทน ในทีนี้ถ้าเราใช้ Java มันคือ JVM (Java Virtual Machine)

แต่..!

มันเป็นภาษาที่เอาไปใช้รันในเครื่องไหนไม่ได้เลยนะ เพราะไม่มีเครื่องJVM แล้วจะสร้างมันขึ้นมาทำไม

Javaมีคำตอบ นั่นคือสร้าง Interpreter JVM ให้ทุกระบบ OS เลย

สรุป คือ เราจะเหลือเครื่องแค่ JVM เพราะมี Interpreter ครอบ Machine ที่ต่างกันลงไปหมดแล้ว ดังนั้นโปรแกรมที่เราเขียน แต่จะต่างระบบกันก็เอาไปรันได้ทุกเครื่องแน่นอน

คอนเซ็ปนี้เอาไปใช้สร้างโปรแกรมแบบ Bootstrap อีกด้วย วันหลังจะมาเขียนเพิ่มเติมต่อ

247 Total Views 3 Views Today
Ta

Ta

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

ใส่ความเห็น

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