คอมไพเลอร์ just-in-time (JIT) ทำอะไร

528

คอมไพเลอร์ JIT ทำอะไรเป็นพิเศษเมื่อเทียบกับคอมไพเลอร์ที่ไม่ใช่ของ JIT ใครสามารถให้คำอธิบายสั้น ๆ และเข้าใจง่าย

compilation  compiler-construction  jit 
— Michiel Borkent
แหล่งที่มา
1
— TechDog
2
— Akash Narayan
2
ฉันพบyoutube.com/watch?v=yQ27DjKnxwoว่าเป็นประโยชน์
— Adam Zerner

คำตอบ:

518

คอมไพเลอร์ JIT ทำงานหลังจากที่โปรแกรมเริ่มต้นและรวบรวมรหัส (โดยปกติคือ bytecode หรือคำสั่ง VM บางชนิด) ได้ทันที ชุดคำสั่ง JIT มีการเข้าถึงข้อมูลรันไทม์แบบไดนามิกในขณะที่คอมไพเลอร์มาตรฐานไม่สามารถและเพิ่มประสิทธิภาพที่ดีขึ้นเช่นฟังก์ชั่นอินไลน์ที่ใช้บ่อย

นี่ตรงกันข้ามกับคอมไพเลอร์ดั้งเดิมที่รวบรวมรหัสทั้งหมดเป็นภาษาเครื่องก่อนที่โปรแกรมจะทำงานครั้งแรก

ในการถอดความคอมไพเลอร์ทั่วไปจะสร้างโปรแกรมทั้งหมดเป็นไฟล์ EXE ก่อนที่คุณจะรันครั้งแรก สำหรับโปรแกรมสไตล์ที่ใหม่กว่าแอสเซมบลีจะถูกสร้างขึ้นด้วย pseudocode (รหัส p) เฉพาะหลังจากที่คุณรันโปรแกรมบนระบบปฏิบัติการ (เช่นโดยการดับเบิลคลิกที่ไอคอน) คอมไพเลอร์ (JIT) จะเตะและสร้างรหัสเครื่อง (m-code) ที่โปรเซสเซอร์ที่ใช้ Intel หรืออะไรก็ตามที่จะเข้าใจ

— มาร์คซิด
แหล่งที่มา
16
และในทางตรงกันข้ามกับรหัสที่แปลความหมายซึ่งเริ่มต้นใช้งานคำสั่ง bytecode หรือ VM ทันทีโดยไม่ชักช้า แต่จะเรียกใช้คำสั่งช้ากว่าภาษาเครื่อง
— แอรอน
3
JIT มักใช้กับโค้ดที่แปลเพื่อแปลงเป็นภาษาเครื่อง แต่ใช่โค้ดที่แปลอย่างหมดจด (โดยไม่มี JITting) ช้า แม้แต่ Java bytecode ที่ไม่มี JITter ก็ช้ามาก
— Mark Cidade
48
เป้าหมายไม่จำเป็นต้องเป็นรหัสเครื่อง JRuby มีคอมไพเลอร์ JIT ซึ่งจะรวบรวมซอร์สโค้ด Ruby ไปยัง Java bytecode หลังจากการเรียกใช้สองสามครั้ง จากนั้นหลังจากการเรียกใช้อีกสองสามครั้งคอมไพเลอร์ JVM JIT เตะและคอมไพล์ bytecode เป็นโค้ดเนทีฟ
— Jörg W Mittag
4
เป็นที่น่าสังเกตว่าตามที่Jörgพูดถึง JIT ไม่จำเป็นต้องเรียกใช้ทันที บ่อยครั้งที่รหัสจะถูกตีความจนกว่าจะมีการพิจารณาว่าจะมีค่า JITting เนื่องจาก JITting สามารถแนะนำความล่าช้าจึงอาจไม่เร็วกว่าที่จะไม่ใช้ JIT บางรหัสหากใช้น้อยและการตอบสนองที่รวดเร็วจึงมีความสำคัญมากกว่ารันไทม์โดยรวม
— Adam Jaskiewicz
3
@ErikReppen: หากเครื่องใหม่ออกมาการคอมไพล์และปรับโปรแกรมให้เหมาะสมสำหรับเครื่องใหม่ที่ใช้คอมไพเลอร์ทั่วไปน่าจะให้ผลลัพธ์ได้เร็วกว่า JIT บนมืออื่น ๆ , JIT ที่เหมาะสำหรับการที่เครื่องใหม่จะสามารถที่จะสามารถเพิ่มประสิทธิภาพการทำงานของรหัสที่ถูกตีพิมพ์ก่อนที่เครื่องใหม่ถูกคิดค้น
— supercat
255

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

จนถึงจุดหนึ่งในการวิวัฒนาการของภาษาคอมไพเลอร์จะรวบรวมภาษาระดับสูงเป็นรหัสหลอกซึ่งจะถูกตีความ (โดยล่าม) เพื่อเรียกใช้โปรแกรมของคุณ สิ่งนี้จะกำจัดรหัสวัตถุและไฟล์ปฏิบัติการและทำให้ภาษาเหล่านี้สามารถพกพาไปยังระบบปฏิบัติการหลายระบบและแพลตฟอร์มฮาร์ดแวร์ได้ Pascal (ซึ่งรวบรวมไปยัง P-Code) เป็นหนึ่งในคนแรก Java และ C # เป็นตัวอย่างล่าสุด ในที่สุดคำ P-Code ก็ถูกแทนที่ด้วย bytecode เนื่องจากการดำเนินการหลอกส่วนใหญ่นั้นยาวไบต์

คอมไพเลอร์ Just-In-Time (JIT) เป็นคุณลักษณะของล่ามรันไทม์ซึ่งแทนที่จะตีความ bytecode ทุกครั้งที่มีการเรียกใช้เมธอดจะรวบรวม bytecode ลงในคำแนะนำรหัสเครื่องของเครื่องที่ทำงานแล้วเรียกสิ่งนี้ รหัสวัตถุแทน ในทางกลับกันประสิทธิภาพของการรันออบเจ็กต์โค้ดจะเอาชนะความไม่มีประสิทธิภาพในการคอมไพล์โปรแกรมใหม่ทุกครั้งที่รัน

— Craig Trader
แหล่งที่มา
5
อย่างไรก็ตามวลีนี้"คอมไพเลอร์ Just-In-Time (JIT) เป็นคุณลักษณะของตัวแปลเวลาทำงาน"ทำให้เกิดความสับสน เช่น - stackoverflow.com/questions/16439512/…
— Stephen C
11
ที่จริงแล้ว JIT เป็นส่วนเสริมและคุณยังสามารถปิดใช้งานได้โดยใช้พารามิเตอร์ -Xint กับ Java ดังนั้นจึงเป็นเพียงคุณสมบัติ
— Craig Trader
3
ฉันไม่เห็นด้วยอย่างเต็มที่ JIT ไม่ใช่วิวัฒนาการ - มันเป็นทางเลือกของคอมไพเลอร์คลาสสิค
— i486
1
JIT เป็นขั้นตอนเดียวในเส้นทางวิวัฒนาการจากสวิตช์เชิงกลแบบเดินสายยากไปจนถึงการระบุเกณฑ์การค้นหาโดยพูดว่า "OK Google" กับสมาร์ทโฟนของคุณ JIT ที่มีอยู่ในปัจจุบันเป็นส่วนหนึ่งของ Java 7/8 คือการก้าวกระโดดเกินขอบเขตที่มีอยู่ใน Java 2 ซึ่งเป็นวิวัฒนาการเช่นกัน
— Craig Trader
1
@ i486 - Sun / Oracle มี (AFAIK) ไม่เคยส่งคอมไพเลอร์แบบคลาสสิก ("ก่อนเวลา") สำหรับ Java ที่สร้างรหัสเนทิฟ มันเป็นการยืดเวลาให้เหตุผลว่า JIT เป็นทางเลือก ... เมื่อสิ่งที่พวกเขาคาดว่าจะเป็นทางเลือกสำหรับก็ไม่เคยส่ง (ฉันลดคอมไพเลอร์ GCJ AOT เนื่องจากไม่มีส่วนเกี่ยวข้องกับ Sun / Oracle และไม่ใช่โซลูชันที่สมบูรณ์เช่นกันตอนนี้ไม่สามารถใช้งานได้)
— Stephen C
69

JIT- ทันเวลาคำพูดของตัวเองบอกว่าเมื่อมันจำเป็น (ตามความต้องการ)

สถานการณ์ทั่วไป:

รหัสที่มาจะถูกแปลงเป็นรหัสเครื่องอย่างสมบูรณ์

สถานการณ์ JIT:

ซอร์สโค้ดจะถูกแปลงเป็นภาษาแอสเซมบลีเช่นโครงสร้าง [สำหรับ ex IL (ภาษากลาง) สำหรับ C #, ByteCode สำหรับ java]

รหัสกลางจะถูกแปลงเป็นภาษาเครื่องเฉพาะเมื่อแอปพลิเคชันต้องการรหัสที่จำเป็นเท่านั้นที่จะถูกแปลงเป็นรหัสเครื่องเท่านั้น

JIT กับการเปรียบเทียบที่ไม่ใช่ของ JIT:

  • ใน JIT ไม่ใช่รหัสทั้งหมดจะถูกแปลงเป็นรหัสเครื่องก่อนส่วนหนึ่งของรหัสที่จำเป็นจะถูกแปลงเป็นรหัสเครื่องแล้วหากวิธีการหรือฟังก์ชันการทำงานที่เรียกว่าไม่ได้อยู่ในเครื่องแล้วจะกลายเป็นรหัสเครื่อง ... จะลดลง ภาระในซีพียู

  • เนื่องจากรหัสเครื่องจะถูกสร้างขึ้นในเวลาทำงาน .... คอมไพเลอร์ JIT จะผลิตรหัสเครื่องที่ปรับให้เหมาะสมสำหรับสถาปัตยกรรม CPU ของเครื่อง

ตัวอย่าง JIT:

  1. ใน Java JIT อยู่ใน JVM (Java Virtual Machine)
  2. ใน C # มันอยู่ใน CLR (Common Language Runtime)
  3. ใน Android นั้นอยู่ใน DVM (Dalvik Virtual Machine) หรือ ART (Android RunTime) ในเวอร์ชันที่ใหม่กว่า
— ดุสิตอมันทัน
แหล่งที่มา
7
JIT เสนอข้อได้เปรียบพิเศษในกรอบการทำงานด้วยการสนับสนุนชนิดทั่วไปจริง เป็นไปได้ที่จะกำหนดวิธีการทั่วไปซึ่งจะสามารถสร้างช่วงของประเภทที่ไม่ จำกัด แต่ละชนิดจะต้องมีรหัสเครื่องที่แตกต่างกัน แต่มีเพียง JIT สร้างรหัสสำหรับประเภทที่ผลิตจริง ในทางตรงกันข้ามใน C ++ มันจำเป็นที่คอมไพเลอร์จะสร้างโค้ดสำหรับทุกประเภทที่โปรแกรมจะใช้
— supercat
6
JVM ไม่ใช่รหัส JIT ในครั้งแรกที่เรียกใช้ สองสามครั้งแรกมันตีความ bytecode จากนั้นหากโค้ดนั้นทำงานบ่อยเพียงพออาจตัดสินใจรบกวน JITting
— ninjalj
1
คุณกำลังพูด JIT ใน Java เป็น JVM อย่างไรก็ตามเราได้เตรียมโค้ดที่คอมไพล์ให้กับ JVM แล้วใช่ไหม งั้นก็รวบรวมมันอีกครั้งคุณหมายถึงอะไร?
— Koray Tugay
@KorayTugay - เราให้บริการ Bytecodes เป็น JVM และ JVM จะแปลงส่วนหนึ่งของส่วนนั้นให้เป็นรหัสของเครื่องตามทรัพยากร demand.so
— Durai Amuthan.H
1
ใน Java JIT ไม่ใช่ JVM มันเป็นเพียงส่วนหนึ่งของมัน
— สุข
25

ดังที่คนอื่น ๆ ได้กล่าวถึง

JIT ย่อมาจาก Just-in-Time ซึ่งหมายความว่าโค้ดจะถูกรวบรวมเมื่อจำเป็นไม่ใช่ก่อนรันไทม์

เพียงเพื่อเพิ่มประเด็นการอภิปรายข้างต้น JVM ยังคงนับว่าเป็นเวลาเท่าไหร่ฟังก์ชั่นจะถูกดำเนินการ หากจำนวนนี้เกินขีด จำกัด ที่กำหนดไว้ล่วงหน้า JIT จะรวบรวมรหัสเป็นภาษาเครื่องซึ่งสามารถประมวลผลได้โดยตรงโดยโปรเซสเซอร์ (ซึ่งแตกต่างจากกรณีปกติที่ javac รวบรวมรหัสเป็น bytecode แล้วจาวา - ล่ามตีความบรรทัด bytecode นี้โดยสายแปลงเป็น รหัสเครื่องและดำเนินการ)

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

— Aniket Thakur
แหล่งที่มา
14

คอมไพเลอร์ JIT จะคอมไพล์โค้ดไบต์กับโค้ดเนทีฟที่เทียบเท่าในการเรียกใช้ครั้งแรก ตามการดำเนินการต่อเนื่องทุกครั้ง JVM จะใช้โค้ดเนทีฟที่คอมไพล์แล้วเพื่อเพิ่มประสิทธิภาพ

ป้อนคำอธิบายรูปภาพที่นี่

หากไม่มีคอมไพเลอร์ JIT ตัวแปล JVM จะแปลโค้ดไบต์ต่อบรรทัดเพื่อให้ปรากฏราวกับว่ามีการเรียกใช้แอปพลิเคชันดั้งเดิม

ป้อนคำอธิบายรูปภาพที่นี่

แหล่ง

1
การตีความ JIT ของฉันคือการทำหน้าที่เหมือนบันทึกช่วยจำซึ่งฟังก์ชั่นที่ใช้บ่อยคือ 'เก็บไว้' และค่าใช้จ่ายในการรวบรวมจาก java bytecode ถึงรหัส ISA ที่ขึ้นกับภาษาท้องถิ่นนั้นจะถูกข้าม ถ้านี่ถูกต้องทำไม java ไม่คอมไพล์รหัสพื้นเมืองอย่างสมบูรณ์ตั้งแต่เริ่มต้น? วิธีนี้จะลดการคอมไพล์รันไทม์และทำให้ java 'native' เป็นเครื่องได้หรือไม่
— Michael Choi
12

JIT ย่อมาจาก Just-in-Time ซึ่งหมายความว่าโค้ดจะถูกรวบรวมเมื่อจำเป็นไม่ใช่ก่อนรันไทม์

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

— Brian Lyttle
แหล่งที่มา
เหตุใดจึงไม่รวบรวมรหัสที่จัดเก็บไว้ในคอมพิวเตอร์ของผู้ใช้ดังนั้นครั้งต่อไปที่แอปพลิเคชันรัน JIT ไม่จำเป็นต้องคอมไพล์อีกครั้ง
— omerfarukdogan
ข้อสังเกตที่ดี เป็นไปได้ที่จะทำเช่นนี้ แต่ไม่ว่าจะเป็นประโยชน์หรือไม่นั้นขึ้นอยู่กับแพลตฟอร์มและการใช้งานแอพ การเพิ่มประสิทธิภาพ JIT ไม่จำเป็นต้องเหมือนกับออฟไลน์หรือการปรับให้เหมาะสมก่อนเวลาดังนั้นผลประโยชน์อาจเป็น 'ไม่ใช่การ JITting' ซึ่งอาจหรืออาจช่วยได้ไม่มากนัก
— Brian Lyttle
9

หลังจากโค้ดไบต์ (ซึ่งเป็นสถาปัตยกรรมที่เป็นกลาง) ถูกสร้างขึ้นโดยคอมไพเลอร์ Java การดำเนินการจะถูกจัดการโดย JVM (ใน Java) โค้ดไบต์จะถูกโหลดเข้าสู่ JVM โดยโหลดเดอร์จากนั้นคำสั่งแต่ละไบต์จะถูกตีความ

เมื่อเราต้องการเรียกวิธีการหลาย ๆ ครั้งเราจำเป็นต้องตีความรหัสเดียวกันหลาย ๆ ครั้งและอาจต้องใช้เวลามากกว่าที่จำเป็น ดังนั้นเราจึงมีคอมไพเลอร์ JIT (ทันเวลา) เมื่อโหลดไบต์ไปยัง JVM (เวลารัน) โค้ดทั้งหมดจะถูกคอมไพล์แทนที่จะแปลความหมายจึงช่วยประหยัดเวลา

คอมไพเลอร์ JIT ใช้งานได้เฉพาะในช่วงรันไทม์ดังนั้นเราจึงไม่มีเอาต์พุตไบนารีใด ๆ

— ผู้ใช้งาน
แหล่งที่มา
2
รหัสทั้งหมดไม่ได้รวบรวมเมื่อโหลดลงใน JVM เนื่องจากมีข้อมูลเล็กน้อย (อ่าน: คำแนะนำ) เกี่ยวกับวิธีการรวบรวม โปรดทราบว่าประสิทธิภาพเป็นเป้าหมายสูงสุด JIT ค่อนข้างเลือก: การตรวจสอบและเลือกวิธีที่นิยมที่สุดสำหรับการเพิ่มประสิทธิภาพ และมันยังคงทำเช่นนี้ไปจนถึงระดับสูงสุดของการเพิ่มประสิทธิภาพสำหรับแต่ละวิธี
— Yaw Boakye
7

Just In Time Compiler (JIT):
มันรวบรวม java bytecode เป็นคำสั่งเครื่องของ CPU เฉพาะนั้น

ตัวอย่างเช่นถ้าเรามีคำสั่งวนรอบในรหัส java ของเรา:

while(i<10){
    // ...
    a=a+i;
    // ...
 }

โค้ดลูปข้างต้นทำงาน 10 ครั้งหากค่าของ i เป็น 0

ไม่จำเป็นต้องคอมไพล์โค้ดไบต์เป็นเวลา 10 ครั้งซ้ำแล้วซ้ำอีกเพราะคำสั่งเดิมจะดำเนินการ 10 ครั้ง ในกรณีนั้นจำเป็นต้องรวบรวมรหัสนั้นเพียงครั้งเดียวและสามารถเปลี่ยนค่าตามจำนวนครั้งที่ต้องการ ดังนั้น Just In Time (JIT) คอมไพเลอร์ติดตามคำสั่งและวิธีการดังกล่าว (ดังที่ได้กล่าวไว้ก่อนหน้านี้) และรวบรวมรหัสไบต์ดังกล่าวเป็นรหัสเครื่องเพื่อประสิทธิภาพที่ดีขึ้น

อีกตัวอย่างที่คล้ายกันคือการค้นหารูปแบบโดยใช้ "นิพจน์ปกติ" ในรายการของสตริง / ประโยค

JIT Compiler ไม่ได้รวบรวมรหัสทั้งหมดไปยังรหัสเครื่อง มันรวบรวมรหัสที่มีรูปแบบที่คล้ายกันในเวลาทำงาน

ดูเอกสารของออราเคิลในหัวข้อทำความเข้าใจ JITเพื่ออ่านเพิ่มเติม

— Anands23
แหล่งที่มา
"ไม่จำเป็นต้องคอมไพล์โค้ดไบต์เป็นเวลา 10 ครั้งซ้ำแล้วซ้ำอีกเพราะคำสั่งเดิมจะดำเนินการ 10 ครั้ง" - คอมไพเลอร์ปกติจะเป็นอย่างไร? มันรวบรวมชิ้นส่วนนี้หลายครั้งหรือไม่?
— TT_
4

คุณมีรหัสที่บ่นเกี่ยวกับ IL (ภาษาระดับกลาง) เมื่อคุณเรียกใช้โปรแกรมคอมพิวเตอร์ไม่เข้าใจรหัสนี้ มันเข้าใจรหัสเนทีฟเท่านั้น ดังนั้นคอมไพเลอร์ JIT จะคอมไพล์ IL ของคุณเป็นโค้ดเนทีฟ มันเป็นเช่นนี้ในระดับวิธีการ

— ชาร์ลส์เกรแฮม
แหล่งที่มา
2
คุณหมายถึง "วิธีการระดับ"?
— Koray Tugay
4

ฉันรู้ว่านี่เป็นเธรดเก่า แต่การเพิ่มประสิทธิภาพรันไทม์เป็นอีกส่วนสำคัญของการรวบรวม JIT ที่ดูเหมือนจะไม่ได้กล่าวถึงที่นี่ โดยพื้นฐานแล้วคอมไพเลอร์ JIT สามารถมอนิเตอร์โปรแกรมในขณะที่มันรันเพื่อกำหนดวิธีในการปรับปรุงการดำเนินการ จากนั้นสามารถเปลี่ยนแปลงได้ทันที - ระหว่างรันไทม์ การเพิ่มประสิทธิภาพ Google JIT (javaworld มีบทความที่ดีเกี่ยวกับเรื่องนี้ )

— เอซ
แหล่งที่มา
3

Just in time compiler (JIT) เป็นซอฟต์แวร์ที่รับอินพุตที่ไม่สามารถเรียกทำงานได้และส่งคืนรหัสเครื่องที่เหมาะสมที่จะดำเนินการ ตัวอย่างเช่น:

Intermediate representation    JIT    Native machine code for the current CPU architecture

     Java bytecode            --->        machine code
     Javascript (run with V8) --->        machine code

ผลลัพธ์ของสิ่งนี้คือสำหรับสถาปัตยกรรม CPU บางตัวต้องติดตั้งคอมไพลเลอร์ JIT ที่เหมาะสม

คอมไพเลอร์, ล่ามและ JIT

แม้ว่าจะมีข้อยกเว้นโดยทั่วไปเมื่อเราต้องการแปลงรหัสต้นฉบับเป็นรหัสเครื่องที่เราสามารถใช้:

  1. คอมไพเลอร์ : รับซอร์สโค้ดและส่งคืนไฟล์ที่เรียกทำงานได้
  2. Interpreter : เรียกใช้งานคำสั่งโปรแกรมโดยคำสั่ง จะใช้ส่วนปฏิบัติการของรหัสที่มาและเปลี่ยนส่วนนั้นเป็นคำแนะนำเครื่อง กระบวนการนี้จะเกิดขึ้นซ้ำ ๆ จนกว่าซอร์สโค้ดทั้งหมดจะถูกแปลงเป็นคำสั่งเครื่องและดำเนินการ
  3. JIT : การใช้งานที่แตกต่างกันของ JIT เป็นไปได้ แต่ JIT มักจะเป็นการรวมกันของ compliler และล่าม JIT จะเปลี่ยนข้อมูลตัวกลางเป็นครั้งแรก (เช่น Java bytecode) ที่ได้รับเป็นภาษาเครื่องผ่านการตีความ JIT มักจะรู้สึกได้เมื่อมีการดำเนินการส่วนหนึ่งของรหัสบ่อยครั้งและจะรวบรวมส่วนนี้เพื่อการดำเนินการที่รวดเร็ว
— Willem van der Veen
แหล่งที่มา
2

Jit ย่อมาจากทันเวลาคอมไพเลอร์ jit เป็นโปรแกรมที่เปลี่ยนโค้ดจาวาไบต์เป็นคำสั่งที่สามารถส่งโดยตรงไปยังหน่วยประมวลผล

การใช้จาวาคอมไพเลอร์ทันเวลา (จริงๆคอมไพเลอร์ตัวที่สอง) ที่แพลตฟอร์มระบบโดยเฉพาะประมวลผล bytecode เป็นรหัสระบบเฉพาะเมื่อรหัสถูกคอมไพล์อีกครั้งโดย jit complier มันมักจะทำงานได้เร็วขึ้นในคอมพิวเตอร์

คอมไพเลอร์ทันเวลามาพร้อมกับเครื่องเสมือนจริงและใช้เป็นทางเลือก มันจะรวบรวม bytecode ลงในรหัสปฏิบัติการเฉพาะแพลตฟอร์มที่จะดำเนินการทันที

— user3459027
แหล่งที่มา
2

เพียงในเวลา (JIT) สะสม (ยังเป็นแบบไดนามิกแปลหรือการรวบรวมเวลาทำงาน) เป็นวิธีการดำเนินรหัสคอมพิวเตอร์ที่เกี่ยวข้องกับการรวบรวมในระหว่างการดำเนินของโปรแกรม - ในเวลาทำงาน - มากกว่าก่อนที่จะมีการดำเนินการ

การรวบรวมไอทีเป็นการผสมผสานระหว่างสองวิธีการดั้งเดิมในการแปลเป็นรหัสเครื่อง - การรวบรวมล่วงหน้า (AOT)และการตีความ - และรวมข้อดีและข้อเสียของทั้งสองอย่างเข้าด้วยกัน รวบรวม JIT รวมความเร็วของการรวบรวมรหัสที่มีความยืดหยุ่นในการตีความ

ลองพิจารณา JIT ที่ใช้ใน JVM

ตัวอย่างเช่นคอมไพเลอร์ HotSpot JVM JIT สร้างการปรับให้เหมาะสมแบบไดนามิก กล่าวคือพวกเขาตัดสินใจปรับให้เหมาะสมในขณะที่แอปพลิเคชัน Java กำลังทำงานและสร้างคำสั่งเครื่องที่มีประสิทธิภาพสูงซึ่งกำหนดเป้าหมายสำหรับสถาปัตยกรรมระบบพื้นฐาน

เมื่อวิธีถูกเลือกสำหรับการรวบรวม JVM ฟีดไบต์ของมันไปยัง Just-In-Time คอมไพเลอร์ (JIT) JIT จำเป็นต้องเข้าใจความหมายและไวยากรณ์ของ bytecode ก่อนจึงจะสามารถรวบรวมวิธีการได้อย่างถูกต้อง เพื่อช่วยให้ผู้รวบรวม JIT วิเคราะห์วิธีนั้นไบต์แรก ๆ ของมันจะถูกจัดรูปแบบใหม่ในรูปแบบภายในที่เรียกว่าร่องรอยต้นไม้ซึ่งคล้ายกับรหัสเครื่องอย่างใกล้ชิดกว่า bytecode การวิเคราะห์และปรับให้เหมาะสมนั้นจะดำเนินการบนต้นไม้ของวิธีการ ในตอนท้ายต้นไม้จะถูกแปลเป็นรหัสพื้นเมือง

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

อ้างอิง:

— สำคัญ
แหล่งที่มา
1

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

0

20% ของรหัสไบต์ใช้ 80% ของเวลา คอมไพเลอร์ JIT ได้รับสถิติเหล่านี้และเพิ่มประสิทธิภาพ 20% ของรหัสไบต์เพื่อให้ทำงานได้เร็วขึ้นโดยการเพิ่มวิธีการแบบอินไลน์การลบล็อคที่ไม่ได้ใช้ ฯลฯ และยังสร้างรหัสไบต์เฉพาะสำหรับเครื่องนั้น ฉันอ้างจากบทความนี้ฉันพบว่ามันมีประโยชน์ http://java.dzone.com/articles/just-time-compiler-jit-hotspot

— Santosh budhe
แหล่งที่มา
ไม่แน่ใจว่าทำไมจึงถูกทำเครื่องหมาย -1 ฉันคิดว่าจุดที่นี่คือสถิติเวลาทำงานที่ใช้เพื่อช่วยเพิ่มประสิทธิภาพ
— eze
ใช่ แต่คำตอบไม่ได้พูดอย่างนั้น แท้จริง JIT ไม่ได้เพิ่มประสิทธิภาพสูงสุด 20% ของรหัส
— mabraham
0

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

— Venkata Santhosh Piduri
แหล่งที่มา
2
ฉันจะหลีกเลี่ยงการตอบคำถามเช่นนี้หากคุณไม่ได้ให้สิ่งใหม่ / ดีกว่า หากคุณได้รับการตอบโต้ใด ๆ มันอาจเป็นการลงคะแนนเสียงหรือคำวิจารณ์: คำตอบของคุณไม่ชัดเจน "JIT" ไม่ได้ จำกัด อยู่ที่Java Virtual Machine "เร็วกว่า แต่ใช้หน่วยความจำมากขึ้น" เป็นผลที่น่าจะเกิดขึ้น แต่ไม่ได้เกิดจากแนวคิดของ JIT และวิธีการต่างๆมักไม่ถูกคอมไพล์ในการเรียกใช้ครั้งแรก การใช้เวลากับ JIT เป็นประโยชน์โดยรวม
— zapl
0

JVM ดำเนินขั้นตอนการคอมไพล์ระหว่างรันไทม์ด้วยเหตุผลด้านประสิทธิภาพ ซึ่งหมายความว่า Java ไม่มีการแยกการประมวลผลแบบคอมไพล์ ก่อนอื่นจะทำการรวบรวมแบบคงที่ที่เรียกว่าจากซอร์สโค้ด Java ไปเป็น bytecode จากนั้นโค้ดไบต์นี้จะถูกส่งไปยัง JVM เพื่อดำเนินการ แต่การประมวลผล bytecode ช้าดังนั้น JVM จะวัดความถี่ที่เรียกใช้ bytecode และเมื่อตรวจพบรหัส "ฮอตสปอต" ของรหัสที่ทำงานบ่อยมาก ดังนั้นโปรแกรม Java ในปัจจุบันจึงถูกรันด้วยการประมวลผลของโค้ด

— hi.nitish
แหล่งที่มา
0

Just In Time compiler หรือ JIT compiler ใช้สำหรับการปรับปรุงประสิทธิภาพใน Java มันถูกเปิดใช้งานโดยค่าเริ่มต้น เป็นการรวบรวมที่กระทำในเวลาดำเนินการค่อนข้างเร็วกว่า Java ได้รับความนิยมใช้ JIT คอมไพเลอร์โดยรวมไว้ใน JVM

— พระพิฆเนศ Giri
แหล่งที่มา
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.