การสร้างโค้ดเนทีฟ

ด้วยการสนับสนุนการสร้างโค้ดเนทีฟของ Luau สคริปต์¹ ในเกมของคุณสามารถถูกคอมไพล์โดยตรงเป็นคำสั่งโค้ดเครื่องที่ CPU ประมวลผล แทนที่จะเป็นไบต์โค้ดปกติที่ Luau VM ทำงานอยู่ ฟีเจอร์นี้สามารถปรับปรุงความเร็วในการประมวลผลสำหรับสคริปต์ที่รองรับบางตัว โดยเฉพาะอย่างยิ่งสำหรับสคริปต์ที่มีการคำนวณเชิงตัวเลขมากและมีการเรียกใช้ห้องสมุด Luau หรือ Roblox API ที่หนักน้อย

¹ การสร้างโค้ดเนทีฟรองรับเฉพาะสคริปต์ฝั่งเซิร์ฟเวอร์และสคริปต์ฝั่งลูกค้าในอุปกรณ์ Android เท่านั้น ในอนาคต อาจมีอุปกรณ์เพิ่มเติมที่รองรับ

เปิดใช้งานการสร้างโค้ดเนทีฟ

เพื่อเปิดใช้งานการสร้างโค้ดเนทีฟสำหรับ Script ให้เพิ่ม --!native คอมเมนต์ที่ด้านบน:²

--!native

print("สวัสดีจากโค้ดเนทีฟ!")

นี่จะเปิดใช้งานการสร้างโค้ดเนทีฟสำหรับฟังก์ชันทั้งหมดในสคริปต์ และขอบเขตระดับบนสุด หากถือว่ามีประโยชน์ ไม่มีการเปลี่ยนแปลงเพิ่มเติมที่จำเป็น; พฤติกรรมของสคริปต์ที่ทำงานเนทีฟจะเหมือนเดิมและมีเพียงประสิทธิภาพที่แตกต่างกัน ฟีเจอร์ทั้งหมดของภาษา Luau และ Roblox API ทั้งหมดยังคงรองรับ

นอกจากนี้ คุณสามารถเปิดใช้งานการสร้างโค้ดเนทีฟสำหรับฟังก์ชันเฉพาะโดยการเพิ่มแอตทริบิวต์ @native:

@native
local function f(x)
  return (x + 1)
end

แนวทางปฏิบัติที่ดีที่สุด

เคล็ดลับต่อไปนี้จะช่วยให้คุณได้รับประโยชน์สูงสุดจากการสร้างโค้ดเนทีฟ:

• ควรเปิดใช้งานฟีเจอร์นี้ภายในสคริปต์ที่ทำการคำนวณมากโดยตรงใน Luau หากคุณมีการดำเนินการทางคณิตศาสตร์มากมายในตารางและโดยเฉพาะอย่างยิ่งประเภท buffer สคริปต์อาจเป็นผู้สมัครที่ดี

• ฟังก์ชันในสคริปต์เท่านั้นที่ถูกคอมไพล์เป็นเนทีฟ ฟังก์ชัน โค้ดใน ขอบเขต ภายนอกระดับบนสุดมักจะถูกประมวลผลเพียงครั้งเดียวและไม่ได้รับประโยชน์มากนักเมื่อเปรียบเทียบกับฟังก์ชันที่ถูกเรียกใช้หลายครั้ง โดยเฉพาะฟังก์ชันที่ถูกเรียกใช้ทุกเฟรม

• แนะนำให้คุณวัดเวลาที่สคริปต์หรือฟังก์ชันใช้ไปเมื่อมีและไม่มีการคอมไพล์เนทีฟเพื่อพิจารณาว่าเมื่อใดควรใช้ Script Profiler เครื่องมือสามารถวัดประสิทธิภาพของฟังก์ชันเพื่อให้คุณตัดสินใจได้อย่างมีข้อมูล

• อาจมีความล่อลวงในการวางคอมเมนต์ --!native ใน ทุก สคริปต์เพื่อป้องกันไม่ให้บางส่วนทำงานได้เร็วขึ้น แต่การสร้างโค้ดเนทีฟมีข้อเสียบางประการ:

  • ต้องใช้เวลาในการคอมไพล์โค้ดซึ่งอาจเพิ่มเวลาเริ่มต้นของเซิร์ฟเวอร์
  • ใช้หน่วยความจำเพิ่มเติมในการจัดเก็บโค้ดที่คอมไพล์เป็นเนทีฟ
  • มีข้อจำกัดในจำนวนโค้ดที่คอมไพล์เป็นเนทีฟทั้งหมดในเกม

ปัญหาเหล่านี้สามารถแก้ไขได้ด้วยการใช้แอตทริบิวต์ @native อย่างรอบคอบ

โค้ดที่ควรหลีกเลี่ยง

ในขณะที่ฟีเจอร์ทั้งหมดจะทำงานเหมือนกันไม่ว่าจะเปิดใช้งานการสร้างโค้ดเนทีฟหรือไม่ แต่บางฟีเจอร์จะไม่ทำงานเป็นเนทีฟและอาจทำให้เกิดการลดประสิทธิภาพหรือกลับไปใช้การประมวลผลแบบตีความ ฟีเจอร์เหล่านี้รวมถึง:

• การใช้การเรียก getfenv()/setfenv() ที่เลิกใช้แล้ว
• การใช้ฟังก์ชันในตัวของ Luau ต่างๆ เช่น math.asin() กับอาร์กิวเมนต์ที่ไม่ใช่ตัวเลข
• การส่งพารามิเตอร์ที่มีประเภทไม่ถูกต้องไปยังฟังก์ชันที่มีประเภท เช่น การเรียก foo(true) เมื่อ foo ถูกประกาศเป็น function foo(arg: string) อย่าลืมใช้ การระบุประเภท ที่ถูกต้องเสมอ

เมื่อใช้ Script Profiler คุณสามารถเปรียบเทียบเวลาที่ใช้โดยฟังก์ชันเวอร์ชันปกติกับฟังก์ชันที่คอมไพล์เป็นเนทีฟ หากฟังก์ชันภายในสคริปต์ --!native หรือที่ทำเครื่องหมายด้วย @native ไม่ปรากฏว่าเป็นการทำงานเนทีฟ อาจมีปัจจัยหนึ่งหรือหลายปัจจัยจากรายการข้างต้นที่ทำให้เกิดการลดประสิทธิภาพ

ใช้การระบุประเภท

การสร้างโค้ดเนทีฟพยายามที่จะอนุมานประเภทที่น่าจะเป็นไปได้มากที่สุดสำหรับตัวแปรที่กำหนดเพื่อเพิ่มประสิทธิภาพเส้นทางโค้ด ตัวอย่างเช่น ถือว่าการดำเนินการ a + b จะทำกับตัวเลข หรือว่าตารางถูกเข้าถึงใน t.X อย่างไรก็ตาม เนื่องจากการโอเวอร์โหลดของตัวดำเนินการ a และ b อาจเป็นตารางหรือประเภท Vector3 หรือ t อาจเป็นประเภท Roblox

ในขณะที่การสร้างโค้ดเนทีฟจะรองรับประเภทใด ๆ การคาดเดาที่ผิดพลาดอาจทำให้เกิดการตรวจสอบที่ไม่จำเป็น ส่งผลให้การประมวลผลโค้ดช้าลง

เพื่อแก้ไขปัญหาทั่วไปบางประการ การระบุประเภท Luau บนพารามิเตอร์ฟังก์ชันจะถูกตรวจสอบ แต่แนะนำให้ระบุพารามิเตอร์ Vector3:

--!native

-- "v" ถูกถือว่าคือ ตาราง; ฟังก์ชันทำงานช้าลงเนื่องจากการตรวจสอบตาราง
local function sumComponentsSlow(v)
	return v.X + v.Y + v.Z
end

-- "v" ถูกประกาศว่าเป็น Vector3; โค้ดที่เฉพาะเจาะจงสำหรับเวกเตอร์ถูกสร้างขึ้น
local function sumComponentsFast(v: Vector3)
	return v.X + v.Y + v.Z
end

เครื่องมือใน Studio

เครื่องมือใน Studio ต่อไปนี้รองรับสำหรับสคริปต์ --!native และฟังก์ชัน @native

การดีบัก

การ ดีบัก สคริปต์ทั่วไปได้รับการสนับสนุน แต่การแสดงผลสำหรับตัวแปรท้องถิ่น/ค่าที่ใช้ร่วมกันอาจไม่สมบูรณ์และขาดตัวแปรจากเฟรม สแต็กการเรียก ที่ทำงานเป็นเนทีฟ

นอกจากนี้ โปรดทราบว่าเมื่อดีบักโค้ดที่เลือกสำหรับการคอมไพล์เนทีฟ การวาง จุดพัก จะปิดการทำงานเนทีฟสำหรับฟังก์ชันเหล่านั้น

Script Profiler

ใน Script Profiler ฟังก์ชันที่ทำงานเป็นเนทีฟจะแสดง <native> ข้างๆ:

หากฟังก์ชันที่ทำเครื่องหมาย @native หรือภายในสคริปต์ --!native ไม่แสดงการทำเครื่องหมาย <native> ฟังก์ชันนั้นอาจไม่ทำงานเป็นเนทีฟเนื่องจากการวาง จุดพัก การใช้ โค้ดที่ไม่แนะนำ หรือการระบุประเภทที่ไม่ตรงกัน type annotations

หน่วยความจำ Luau

ใน Luau heap โปรไฟล์ หน่วยความจำที่ใช้โดยฟังก์ชันเนทีฟจะแสดงเป็น [native] ในกราฟ

การวิเคราะห์ขนาด

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

เพื่อติดตามขนาดโค้ดเนทีฟของฟังก์ชันและสคริปต์แต่ละตัว:

1. ตรวจสอบให้แน่ใจว่าคุณอยู่ในมุมมอง Server ผ่านปุ่ม client/server toggle
2. เรียกใช้ debug.dumpcodesize() จาก Command Bar

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

สำหรับแต่ละสคริปต์ ผลลัพธ์จะแสดงจำนวนฟังก์ชันที่ถูกคอมไพล์และการใช้หน่วยความจำโค้ดเนทีฟ ฟังก์ชันแต่ละตัวจะถูกจัดเรียงตามขนาดโค้ดเนทีฟจากมากไปน้อย โดยฟังก์ชันที่ไม่ระบุชื่อจะแสดงเป็น [anonymous] และสคริปต์ทั้งหมดจะแสดงเป็น [top level] ในคอลัมน์สุดท้าย เปอร์เซ็นต์จะถูกคำนวณตามขีดจำกัดขนาดโค้ดเนทีฟ โปรดทราบว่าขนาดโค้ดเนทีฟของฟังก์ชันจะถูกรายงานอย่างแม่นยำ แต่การใช้หน่วยความจำสำหรับสคริปต์จะถูกปัดขึ้นไปยังขนาดหน้าที่ใกล้ที่สุด

ข้อจำกัดและการแก้ไขปัญหา

การคอมไพล์โค้ดเป็นคำสั่งสำหรับ CPU เฉพาะต้องการหน่วยความจำจัดเก็บเพิ่มเติม นอกจากนี้ การเพิ่มประสิทธิภาพสำหรับฟังก์ชันที่ซับซ้อนอาจใช้เวลามากเกินไปในการดำเนินการ การถึงขีดจำกัดภายในจะรายงานข้อผิดพลาดในหน้าต่าง Output ของ Studio รวมถึง:

ข้อผิดพลาดนี้หมายความว่าบล็อกโค้ดเดียวภายในฟังก์ชันใช้คำสั่งมากกว่า 64K สามารถหลีกเลี่ยงได้โดยการทำให้ฟังก์ชันเรียบง่ายลงหรือโดยการแบ่งออกเป็นฟังก์ชันขนาดเล็กแต่ละตัว

ข้อผิดพลาดนี้หมายความว่าฟังก์ชันเดียวมีบล็อกโค้ดภายในมากกว่า 32K บล็อกโค้ดภายในไม่ตรงกับบล็อกการควบคุมในสคริปต์ของคุณ แต่ข้อผิดพลาดนี้สามารถหลีกเลี่ยงได้โดยการทำให้การควบคุมในฟังก์ชันเรียบง่ายลงหรือโดยการแบ่งออกเป็นฟังก์ชันขนาดเล็กแต่ละตัว

ข้อผิดพลาดนี้หมายความว่าฟังก์ชันโดยรวมได้ถึงขีดจำกัด 1 ล้านคำสั่งสำหรับสคริปต์ทั้งหมด ในบางกรณี ฟังก์ชันที่รายงานอาจมีคำสั่งมากมาย หรือขีดจำกัดอาจถูกถึงโดยฟังก์ชันก่อนหน้านี้ในสคริปต์ เพื่อหลีกเลี่ยงปัญหานี้ แนะนำให้ย้ายฟังก์ชันที่มีขนาดใหญ่โดยเฉพาะไปยังสคริปต์ที่ไม่เป็นเนทีฟแยกต่างหากหรือใช้ @native กับฟังก์ชันอื่น ๆ คุณยังสามารถลองทำเครื่องหมายสคริปต์แยกนั้นด้วย --!native แต่ 1 ล้านคำสั่งใช้หน่วยความจำมากและคุณอาจเกินขีดจำกัดหน่วยความจำ

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

ข้อผิดพลาดนี้หมายความว่าขีดจำกัดหน่วยความจำโดยรวมสำหรับข้อมูลโค้ดเนทีฟได้ถูกถึงแล้ว เพื่อหลีกเลี่ยงนี้ ให้ลองลบ --!native จากสคริปต์ที่ใช้หน่วยความจำมากขึ้น ทำให้สคริปต์ขนาดเล็กอื่น ๆ สามารถอยู่ภายใต้ขีดจำกัดได้มากขึ้น ทางเลือกอื่นคือย้ายฟังก์ชันขนาดใหญ่หรือที่เรียกใช้น้อยไปยังโมดูลที่ไม่เป็นเนทีฟแยกต่างหาก