อ่าน 3 นาที
อินเทอร์เฟซฟังก์ชันต่างประเทศ
อินเทอร์เฟซฟังก์ชันภายนอก ( FFI ) คือกลไกที่ช่วยให้โปรแกรมที่เขียนด้วย ภาษาโปรแกรม หนึ่ง สามารถเรียกใช้ รูทีน ที่ใช้งานร่วมกันได้...
อินเทอร์เฟซฟังก์ชันต่างประเทศ
อินเทอร์เฟซฟังก์ชันภายนอก ( FFI )คือกลไกที่ช่วยให้โปรแกรมที่เขียนด้วยภาษาโปรแกรม หนึ่ง สามารถเรียกใช้ รูทีน ที่ใช้งานร่วมกันได้หรือใช้บริการที่เขียนหรือคอมไพล์ด้วยภาษาโปรแกรมอื่นได้ FFI มักใช้ในบริบทที่มีการเรียกใช้ไลบรารีแบบไดนามิกไบนารี
การตั้งชื่อ
คำนี้มาจากข้อกำหนดสำหรับCommon Lisp ซึ่งอ้างถึงคุณลักษณะของภาษาโปรแกรมที่เปิดใช้ งานการเรียกใช้ข้ามภาษาอย่างชัดเจน[ 1 ]คำนี้ยังถูกใช้อย่างเป็นทางการโดยเอกสาร ประกอบ ตัวแปลและคอมไพเลอร์ สำหรับHaskell [ 2 ] Rust [ 3 ] PHP [ 4 ] Pythonและ LuaJIT ( Lua ) [ 5 ] [ 6 ] : 35 [ 7 ]ภาษาอื่นๆ ใช้คำศัพท์อื่น: Adaมี language bindingsในขณะที่JavaมีJava Native Interface (JNI), Java Native Access (JNA) หรือตั้งแต่ Java 22 เป็นต้นมา มี Foreign Function and Memory API Foreign function interface ได้กลายเป็นคำศัพท์ทั่วไปสำหรับกลไกที่ให้บริการดังกล่าว
การดำเนินการ
หน้าที่หลักของอินเทอร์เฟซฟังก์ชันภายนอก (Foreign Function Interface หรือ FFI) คือการเชื่อมโยงความหมายและข้อกำหนดการเรียกใช้ของภาษาโปรแกรมหนึ่ง ( ภาษา โฮสต์หรือภาษาที่กำหนด FFI) กับความหมายและข้อกำหนดของอีกภาษาหนึ่ง ( ภาษา เกสต์ ) กระบวนการนี้ต้องคำนึงถึงสภาพแวดล้อมการทำงานและอินเทอร์เฟซไบนารีของแอปพลิเคชันของทั้งสองภาษาด้วย ซึ่งสามารถทำได้หลายวิธี:
- กำหนดให้ฟังก์ชันของภาษาแขกที่สามารถเรียกใช้ได้ในภาษาโฮสต์ต้องได้รับการระบุหรือใช้งานในลักษณะเฉพาะ ซึ่งมักจะใช้ไลบรารี ความเข้ากันได้ บางประเภท
- ใช้เครื่องมือเพื่อสร้างโค้ดเชื่อมต่อที่เหมาะสมโดยอัตโนมัติสำหรับฟังก์ชันภาษาของผู้ใช้งานซึ่งจะทำการแปลที่จำเป็นทั้งหมด
- การใช้ไลบรารีตัวห่อหุ้ม
- การจำกัดชุดความสามารถของภาษาโฮสต์ที่สามารถใช้งานข้ามภาษาได้ ตัวอย่างเช่น ฟังก์ชัน C++ ที่เรียกใช้จาก C โดยทั่วไปแล้วจะไม่สามารถมีพารามิเตอร์อ้างอิงหรือโยนข้อยกเว้นได้
C++ เข้ากันได้กับ C ได้อย่างง่ายดาย อย่างไรก็ตาม เนื่องจาก C++ ใช้การแปลงชื่อ (name mangling ) สัญลักษณ์ที่จะส่งออกในไลบรารีที่ใช้ร่วมกันจะต้องถูกห่อด้วยบล็อกextern "C"extern "C" ซึ่งจะป้องกันการแปลงชื่อ ฟังก์ชันอาจเรียกใช้โค้ด C++ ภายในได้ แต่ต้องส่งคืนเฉพาะประเภท C และห้ามโยนข้อยกเว้น
สถาบันการเงินต่างประเทศอาจมีความซับซ้อนมากขึ้นเนื่องจากปัจจัยต่อไปนี้:
- หากภาษาหนึ่งรองรับการจัดการ หน่วยความจำอัตโนมัติ ( Garbage Collectionหรือ GC) ในขณะที่อีกภาษาหนึ่งไม่รองรับ จะต้องระมัดระวังไม่ให้โค้ดในภาษาที่ไม่รองรับ GC ทำงานผิดพลาดจนทำให้ GC ในอีกภาษาหนึ่งล้มเหลว ตัวอย่างเช่น ใน JNI โค้ด C ที่ "เก็บรักษา" การอ้างอิงวัตถุที่ได้รับจาก Java จะต้องสื่อสารข้อมูลนี้ไปยังJava Virtual MachineหรือJava Runtime Environment (JRE) ให้สำเร็จ มิเช่นนั้น Java อาจลบวัตถุเหล่านั้นก่อนที่โค้ด C จะใช้งานเสร็จ (โค้ด C จะต้องปล่อยการเชื่อมโยงกับวัตถุเหล่านั้นอย่างชัดเจนเมื่อโค้ด C ไม่ต้องการวัตถุนั้นอีกต่อไป)
- วัตถุหรือชนิดข้อมูลที่ซับซ้อนหรือไม่ธรรมดา อาจทำให้การแปลงจากสภาพแวดล้อมหนึ่งไปยังอีกสภาพแวดล้อมหนึ่งเป็นเรื่องยาก
- เนื่องจากปัญหาการแมปที่กล่าวมาข้างต้น อาจเป็นไปไม่ได้ที่ทั้งสองภาษาจะรักษาการอ้างอิงไปยังอินสแตนซ์เดียวกันของอ็อบเจ็กต์ที่เปลี่ยนแปลงได้
- ภาษาหนึ่งหรือทั้งสองภาษาอาจทำงานอยู่บนเครื่องเสมือน (VM) และหากทั้งสองภาษาทำงานอยู่บนเครื่องเสมือน เครื่องเสมือนเหล่านั้นมักจะเป็นเครื่องที่แตกต่างกัน
- การสืบทอดคุณสมบัติข้ามภาษาและความแตกต่างอื่นๆ เช่น ความแตกต่างระหว่างระบบประเภทข้อมูลหรือระหว่าง แบบจำลอง การประกอบวัตถุอาจเป็นเรื่องที่ยากเป็นพิเศษ

FFI จำนวนมากสามารถสร้างขึ้นโดยอัตโนมัติได้ เช่นSWIGอย่างไรก็ตาม ในกรณีของภาษาส่วนขยายอาจเกิดการผกผันทางความหมายของความสัมพันธ์ระหว่างแขกและโฮสต์ได้ เมื่อภาษาส่วนขยายขนาดเล็กกว่าเป็นแขกที่เรียกใช้บริการในภาษาโฮสต์ขนาดใหญ่กว่า เช่น การเขียนปลั๊กอินขนาดเล็ก[ 8 ]สำหรับ GIMP [ 9 ]
FFI บางตัวจำกัดเฉพาะ ฟังก์ชันอิสระในขณะที่บางตัวอนุญาตให้เรียกใช้ฟังก์ชันที่ฝังอยู่ในอ็อบเจ็กต์หรือคลาส (มักเรียกว่าการเรียกใช้เมธอด ) และบางตัวยังอนุญาตให้ย้ายข้อมูลหรืออ็อบเจ็กต์ประเภทซับซ้อนข้ามขอบเขตภาษาได้อีกด้วย
ในกรณีส่วนใหญ่ FFI จะถูกกำหนดโดยภาษาโปรแกรมระดับสูงเพื่อให้สามารถใช้บริการที่กำหนดและใช้งานในภาษาโปรแกรมระดับต่ำซึ่งโดยทั่วไปแล้วจะเป็นภาษาโปรแกรมระบบเช่นCหรือC++โดยปกติแล้วจะทำเช่นนี้เพื่อเข้าถึง บริการ ของระบบปฏิบัติการ (OS) ในภาษาที่กำหนด API ของระบบปฏิบัติการ หรือเพื่อเป้าหมายด้านประสิทธิภาพ
FFI หลายแห่งยังจัดเตรียมวิธีการให้ภาษาที่ถูกเรียกสามารถเรียกใช้บริการในภาษาโฮสต์ได้ด้วยเช่นกัน
โดยทั่วไปแล้ว คำว่า "อินเทอร์เฟซฟังก์ชันภายนอก" (Foreign Function Interface หรือ FFI) จะไม่ถูกนำมาใช้เพื่ออธิบายรันไทม์หลายภาษา เช่น Microsoft Common Language Runtime ( CLR) ซึ่งมี โครงสร้างพื้นฐานทั่วไปที่ช่วยให้ภาษาใดๆ ที่สอดคล้องกับ CLR สามารถใช้บริการที่กำหนดไว้ในภาษาอื่นๆ ได้ (อย่างไรก็ตาม ในกรณีนี้ CLR ก็มี FFI คือP/Invokeสำหรับเรียกใช้จากภายนอกรันไทม์) นอกจากนี้ สถาปัตยกรรมคอมพิวเตอร์แบบกระจายหลายแบบ เช่นJava Remote Method Invocation (RMI), RPC, CORBA , SOAPและD-Busอนุญาตให้เขียนบริการต่างๆ ในภาษาที่แตกต่างกันได้ สถาปัตยกรรมดังกล่าวโดยทั่วไปจะไม่ถือว่าเป็น FFI
กรณีพิเศษ
มีบางกรณีพิเศษที่ภาษาต่างๆ คอมไพล์เป็นไบต์โค้ด VM เดียวกัน เช่นClojureและJavaรวมถึงElixirและErlangเนื่องจากไม่มีอินเทอร์เฟซ จึงไม่ใช่ FFI อย่างแท้จริง แต่ก็มีฟังก์ชันการทำงานเดียวกันให้ผู้ใช้ใช้งาน
ดูเพิ่มเติม
- ความสามารถในการทำงานร่วมกันของภาษา
- ภาษานิยามอินเทอร์เฟซ
- การประชุมทางโทรศัพท์
- การบิดเบือนชื่อ
- อินเทอร์เฟซการเขียนโปรแกรมแอปพลิเคชัน
- อินเทอร์เฟซไบนารีแอปพลิเคชัน
- การเปรียบเทียบเครื่องเสมือนแอปพลิเคชัน
- สวีจ
- การเรียกใช้ฟังก์ชันระยะไกล
- libffi
ลิงก์ภายนอก
- c2.com: อินเทอร์เฟซฟังก์ชันต่างประเทศ
- อินเทอร์เฟซฟังก์ชันภายนอกของ Haskell 98
- อัลเลโกร คอมมอน ลิสป์ เอฟเอฟไอ
สรุปเนื้อหา
ข้อมูลสำคัญจากบทความ
ข้อมูลสำคัญเกี่ยวกับ อินเทอร์เฟซฟังก์ชันต่างประเทศ
อินเทอร์เฟซฟังก์ชันภายนอก ( FFI ) คือกลไกที่ช่วยให้โปรแกรมที่เขียนด้วย ภาษาโปรแกรม หนึ่ง สามารถเรียกใช้ รูทีน ที่ใช้งานร่วมกันได้...
การตั้งชื่อ
คำนี้มาจากข้อกำหนดสำหรับ Common Lisp ซึ่งอ้างถึงคุณลักษณะของภาษาโปรแกรมที่เปิดใช้ งาน การเรียกใช้ข้ามภาษาอย่างชัดเจน [ 1 ] คำนี้ยังถูกใช้อย่างเป็นทางการโดย เอกสาร ประกอบ ตัวแปล และ คอมไพเลอร์ สำหรับHaskell [ 2 ] Rust [ 3 ] PHP [ 4 ] Python และ LuaJIT ( Lua )...
การดำเนินการ
หน้าที่หลักของอินเทอร์เฟซฟังก์ชันภายนอก (Foreign Function Interface หรือ FFI) คือการเชื่อมโยงความหมายและ ข้อกำหนดการเรียกใช้ ของภาษาโปรแกรมหนึ่ง ( ภาษา โฮสต์ หรือภาษาที่กำหนด FFI) กับความหมายและข้อกำหนดของอีกภาษาหนึ่ง ( ภาษา เกสต์ ) กระบวนการนี้ต้องคำนึงถึง...
กรณีพิเศษ
มีบางกรณีพิเศษที่ภาษาต่างๆ คอมไพล์เป็นไบต์โค้ด VM เดียวกัน เช่น Clojure และ Java รวมถึง Elixir และ Erlang เนื่องจากไม่มีอินเทอร์เฟซ จึงไม่ใช่ FFI อย่างแท้จริง แต่ก็มีฟังก์ชันการทำงานเดียวกันให้ผู้ใช้ใช้งาน