Since the compilation time in JIT c

Since the compilation time in JIT compilation adds directly to the application’s total execution time, the quality of the code optimization is severely constrained by compilation speed. Dynamic compilation addresses this problem of JIT compilation by optimizing only the portions of the code that are most frequently executed, i.e., programhotspots. Most programs spend the majority of the time executing only a small fraction of their code. Thus, optimizing only the hotspot methods should yield a large performance gain while keeping the compilation speed relatively fast. Sun’sHotspotJVM [The Java Hotspot Performance Engine Architecture] uses dynamic compilation to generate optimized native machine code during runtime. The Hotspot engine contains both a run-time compiler and an interpreter. The first time a method is executed, it is interpreted using a profiling interpreter that gathers run-time information about the method. This information is used to detect hotspots in the program and to gather information about program behavior that can be used to optimize generated native code in later stages of program execution. After the hotspot methods are identified, they are dynamically compiled to generate optimized native machine code. Infrequently executed code continues to be interpreted, decreasing the amount of time and memory spent on native code generation. Because a program is likely to spend the majority of its execution time in the hotspot regions detected by the interpreter, the compiler can spend more time optimizing the generated code for these sections of the program than a JITcompiler while still producing an overall improvement in execution time. During code generation, the dynamic compiler performs conventional compiler optimizations, Java specific optimizations, and inlining of static and dynamic methods. The inlining optimizations are designed to be reversible due to the problems associated with dynamic class loading. IBM’sJalapenoJVM [Burke et al. 1999] includes an adaptive dynamic optimizing compiler that generates optimized machine code as the program is executed. The Jalapeno JVM does not use an interpreter. Instead, the first execution of a method is handled by quickly compiling a method into an unoptimized executable code. The dynamic optimizing compiler later generates optimized executable code from the bytecodes of the hotspot (i.e., frequently executed) methods as determined by runtime profile information. The Jalapeno optimizing compiler first compiles Java bytecodes into a virtual register-based high-level intermediate representation (HIR). It then generates a control flow graph for the method. After applying compiler optimizations on the HIR, the intermediate executable is converted to a low-level representation (LIR) that includes references to specific implementation details, such as parameter passing mechanisms and object layouts in memory. The LIR is then optimized further and converted to a native code representation using a Bottom-Up Rewrite System [Proebsting 1992] approach. Finally, this machine specific representation (MIR) is optimized and assembled into machine executable code. The optimizing compiler performs inlining both during bytecode-to-IR translation and during HIR optimization. Inlining of virtual functions is handled by predicting the type of the virtual function and performing a run-time check to determine the validity of the prediction. If the prediction is incorrect, the program performs a normal virtual function invocation. Otherwise, the program proceeds with the inlined function. The program adaptation in Jalapeno starts with the instrumentation and recompilation of executable code. The executable code is instrumented to gather context sensitive profile information to aid optimization. The profile information is used to detect program hotspots. When a certain performance threshold is reached, the dynamic optimizing compiler is invoked to recompile the hotspot methods using context specific optimizations at all levels of representations (HIR, LIR, and MIR). The unoptimized code is then replaced by optimized code based on the collected profile information. Program adaptation continues in this cycle, with executable code being improved on every optimization iteration.

ผลลัพธ์ (ไทย) 1:

ตั้งแต่เวลารวบรวมในการรวบรวม JIT จะเพิ่มโดยตรงกับเวลาปฏิบัติการของโปรแกรมทั้งหมดที่มีคุณภาพของการเพิ่มประสิทธิภาพรหัสที่มีข้อ จำกัด อย่างรุนแรงจากความเร็วในการรวบรวม แบบไดนามิกที่รวบรวมที่อยู่ปัญหาของ JIT รวบรวมนี้โดยการเพิ่มประสิทธิภาพเพียงบางส่วนของรหัสที่จะดำเนินการมากที่สุดคือ programhotspots,โปรแกรมส่วนใหญ่ใช้เวลาส่วนใหญ่ของเวลาที่ดำเนินการเพียงส่วนเล็ก ๆ ของรหัสของพวกเขา ดังนั้นการเพิ่มประสิทธิภาพเพียงวิธีการที่ฮอตสปอตควรผลผลิตได้รับประสิทธิภาพมากขณะที่การรักษาความเร็วในการรวบรวมความรวดเร็ว sun'shotspotjvm [java ฮอตสปอตสถาปัตยกรรมเครื่องยนต์ประสิทธิภาพ] ใช้แบบไดนามิกรวบรวมที่ดีที่สุดในการสร้างรหัสเครื่องพื้นเมืองในระหว่างรันไทม์ฮอตสปอตเครื่องยนต์มีทั้งคอมไพเลอร์ใช้เวลาและล่าม ครั้งแรกที่วิธีการที่จะดำเนินการก็คือการตีความโดยใช้ล่ามโปรไฟล์ที่รวบรวมข้อมูลเวลาทำงานเกี่ยวกับวิธีการที่ข้อมูลนี้จะถูกนำมาใช้ในการตรวจสอบฮอตสปอตในโปรแกรมและรวบรวมข้อมูลเกี่ยวกับการทำงานของโปรแกรมที่สามารถใช้ในการเพิ่มประสิทธิภาพของรหัสพื้นเมืองสร้างขึ้นในขั้นตอนต่อมาของการทำงานของโปรแกรม หลังจากวิธีการฮอตสปอตจะมีการระบุพวกเขาจะรวบรวมแบบไดนามิกในการสร้างการเพิ่มประสิทธิภาพรหัสเครื่องพื้นเมือง รหัสการดำเนินการอย่างต่อเนื่องนาน ๆ ครั้งที่จะตีความลดปริมาณของเวลาและหน่วยความจำที่ใช้ในการสร้างรหัสพื้นเมือง เนื่องจากโปรแกรมมีแนวโน้มที่จะใช้เวลาส่วนใหญ่ของเวลาการดำเนินการในภูมิภาคฮอตสปอตที่ตรวจพบโดยล่ามคอมไพเลอร์สามารถใช้เวลามากขึ้นการเพิ่มประสิทธิภาพของรหัสที่สร้างขึ้นสำหรับส่วนนี้ของโปรแกรมกว่า jitcompiler ขณะที่ยังคงการผลิตการปรับปรุงโดยรวมในระยะเวลาดำเนินการ .ในระหว่างการสร้างรหัสที่คอมไพเลอร์แบบไดนามิกดำเนินการเพิ่มประสิทธิภาพการชุมนุมคอมไพเลอร์, การเพิ่มประสิทธิภาพที่เฉพาะเจาะจง java และ inlining ของวิธีการแบบคงที่และแบบไดนามิก การเพิ่มประสิทธิภาพ inlining ถูกออกแบบมาให้กลับได้เนื่องจากปัญหาที่เกี่ยวข้องกับการโหลดแบบไดนามิกชั้น ibm'sjalapenojvm [เบิร์คและอัล1999] รวมถึงการเพิ่มประสิทธิภาพการปรับตัวคอมไพเลอร์แบบไดนามิกที่สร้างรหัสเครื่องเป็นโปรแกรมที่ดีที่สุดที่จะดำเนินการ JVM Jalapeno ไม่ได้ใช้ล่าม แทนการดำเนินการครั้งแรกของวิธีการจะถูกจัดการได้อย่างรวดเร็วโดยการรวบรวมวิธีการลงในรหัสปฏิบัติการไม่ได้เพิ่มประสิทธิภาพ คอมไพเลอร์เพิ่มประสิทธิภาพแบบไดนามิกภายหลังสร้างรหัสปฏิบัติการการเพิ่มประสิทธิภาพจาก bytecodes ของฮอตสปอต (i.อี. ดำเนินการบ่อย) วิธีการตามที่กำหนดโดยข้อมูลรายละเอียดรันไทม์ คอมไพเลอร์เพิ่มประสิทธิภาพ Jalapeno แรกรวบรวม bytecodes java เป็นเสมือนการลงทะเบียนตามระดับสูงแทนกลาง (hir) มันก็จะสร้างกราฟการไหลของการควบคุมสำหรับวิธีการ หลังจากที่ใช้คอมไพเลอร์ในการเพิ่มประสิทธิภาพ hir,ปฏิบัติการกลางจะถูกแปลงไปเป็นตัวแทนในระดับต่ำ (lir) ที่มีการอ้างอิงถึงรายละเอียดการดำเนินงานที่เฉพาะเจาะจงเช่นกลไกพารามิเตอร์ผ่านและรูปแบบวัตถุในหน่วยความจำ lir เหมาะแล้วต่อไปและแปลงเป็นรหัสแทนการใช้พื้นเมืองล่างขึ้นระบบเขียน [proebsting 1992] วิธีการ ในที่สุดนี้แสดงเฉพาะเครื่อง (mir) จะเพิ่มประสิทธิภาพและประกอบเป็นเครื่องรหัสปฏิบัติการ คอมไพเลอร์เพิ่มประสิทธิภาพการดำเนิน inlining ทั้งในระหว่างการแปล bytecode เพื่อ ir และในระหว่างการเพิ่มประสิทธิภาพ hir inlining หน้าที่เสมือนจะถูกจัดการโดยทำนายชนิดของฟังก์ชั่นเสมือนจริงและมีประสิทธิภาพการตรวจสอบใช้เวลาในการตรวจสอบความถูกต้องของการทำนายถ้าคำทำนายไม่ถูกต้องโปรแกรมจะดำเนินการอุทธรณ์หน้าที่เสมือนปกติ มิฉะนั้นโปรแกรมรายได้ด้วยฟังก์ชั่น inlined การปรับตัวโปรแกรมใน Jalapeno เริ่มต้นด้วยการใช้เครื่องมือและคอมไพล์ของรหัสปฏิบัติการ รหัสปฏิบัติการเป็นเครื่องมือวัดที่จะรวบรวมข้อมูลส่วนตัวของบริบทที่มีความสำคัญที่จะช่วยเพิ่มประสิทธิภาพข้อมูลรายละเอียดที่ใช้ในการตรวจสอบโปรแกรมฮอตสปอต เมื่อเกณฑ์การปฏิบัติงานบางอย่างถึงคอมไพเลอร์เพิ่มประสิทธิภาพแบบไดนามิกจะเรียกวิธีการที่จะคอมไพล์ฮอตสปอตที่ใช้การเพิ่มประสิทธิภาพโดยเฉพาะบริบทในทุกระดับของการเป็นตัวแทน (hir, lir และ mir) รหัสไม่ได้เพิ่มประสิทธิภาพถูกแทนที่ด้วยรหัสที่ดีที่สุดขึ้นอยู่กับข้อมูลที่เก็บรวบรวมรายละเอียดการปรับตัวโปรแกรมยังคงอยู่ในวงจรนี้ด้วยรหัสปฏิบัติการได้รับการปรับปรุงให้ดีขึ้นในการเพิ่มประสิทธิภาพของการทำซ้ำทุก

ผลลัพธ์ (ไทย) 2:

เนื่องจากเวลาคอมไพล์คอมไพล์ JIT เพิ่มโดยตรงกับเวลาดำเนินการรวมแอพลิเคชัน คุณภาพของรหัสถูกจำกัด โดยความเร็วในการคอมไพล์อย่างรุนแรง คอมไพล์แบบไดนามิกอยู่ปัญหาของคอมไพล์ JIT โดยปรับให้เหมาะสมเฉพาะบางส่วนของรหัสที่บ่อยดำเนิน เช่น programhotspots โปรแกรมส่วนใหญ่ใช้เวลาส่วนใหญ่ของเวลาดำเนินการเพียงส่วนเล็ก ๆ ของรหัสของพวกเขา ดังนั้น การเพิ่มประสิทธิภาพเฉพาะวิธีจุดควรผลผลิตเพิ่มประสิทธิภาพขนาดใหญ่ขณะที่รักษาความเร็วในการคอมไพล์ค่อนข้างรวดเร็ว Sun'sHotspotJVM [เดอะ Java จุดประสิทธิภาพเครื่องยนต์สถาปัตยกรรม] ใช้คอมไพล์แบบไดนามิกสร้างรหัสเครื่องดั้งเดิมให้เหมาะขณะรันไทม์ เครื่องยนต์จุดประกอบด้วยคอมไพเลอร์ขณะใช้งานและการล่าม ครั้งแรกที่วิธีดำเนินการ จะถูกแปลล่ามสร้างโพรไฟล์ที่รวบรวมข้อมูลขณะทำงานเกี่ยวกับวิธีการใช้ ใช้ข้อมูลนี้เพื่อตรวจสอบฮอตสปอในโปรแกรม และรวบรวมข้อมูลเกี่ยวกับพฤติกรรมของโปรแกรมที่สามารถใช้เพื่อเพิ่มประสิทธิภาพสร้างรหัสภาษาในขั้นตอนต่อไปของโปรแกรม หลังจากที่มีระบุวิธีการเชื่อมโยง พวกเขาจะคอมไพล์แบบไดนามิกสร้างรหัสเครื่องดั้งเดิมให้เหมาะ รหัสดำเนินการขึ้นนาน ๆ ครั้งยังตีความ ลดระยะเวลาและหน่วยความจำที่ใช้ในการสร้างรหัสภาษา เนื่องจากโปรแกรมจะใช้เวลาส่วนใหญ่ของเวลาปฏิบัติการในภูมิภาคจุดที่ตรวจพบ โดยตัวแปล คอมไพเลอร์สามารถใช้เวลาเพิ่มประสิทธิภาพสร้างรหัสสำหรับโปรแกรมกว่า JITcompiler มีส่วนเหล่านี้ในขณะที่ยังคง ผลิตการปรับปรุงโดยรวมในการดำเนินการ ในระหว่างการสร้างรหัส คอมไพเลอร์แบบไดนามิกทำเพิ่มประสิทธิภาพของคอมไพเลอร์ปกติ เพิ่มประสิทธิภาพเฉพาะ Java และ inlining ของวิธีการแบบคง และแบบไดนามิก เพิ่มประสิทธิภาพ inlining ถูกออกแบบมาให้กลับเนื่องจากปัญหาที่เกี่ยวข้องกับชั้นแบบไดนามิกที่โหลด IBM'sJalapenoJVM [ลิตี้เบอร์ก et al ปี 1999] รวมถึงมีการปรับแบบไดนามิกประสิทธิภาพคอมไพเลอร์ที่สร้างรหัสของเครื่องให้เหมาะกับโปรแกรมจะดำเนินการ Jalapeno JVM ใช้การล่าม แทน การดำเนินการครั้งแรกของวิธีจัดการ โดยรวบรวมวิธีเข้ารหัสปฏิบัติการ unoptimized อย่างรวดเร็ว คอมไพเลอร์ประสิทธิภาพแบบไดนามิกสร้างรหัสเพิ่มประสิทธิภาพปฏิบัติจาก bytecodes ของฮอตสปอต (i ในภายหลังe. ดำเนินการบ่อย) วิธีข้อมูลส่วนกำหนดค่าการใช้งานจริง คอมไพเลอร์ประสิทธิภาพ Jalapeno คอมไพล์ Java bytecodes ก่อนเข้าตัวเสมือนตามทะเบียนระดับสูงระดับกลางแทน (HIR) แล้วสร้างกราฟสำหรับวิธีขั้นตอนการควบคุม หลังจากใช้คอมไพเลอร์เพิ่มประสิทธิภาพบน HIR ปฏิบัติปานกลางจะถูกแปลงเป็นตัวระดับล่างแทน (LIR) ที่มีการอ้างอิงถึงรายละเอียดการใช้งานเฉพาะ เช่นพารามิเตอร์ผ่านกลไกและรูปแบบวัตถุในหน่วยความจำ LIR ถูกปรับเพิ่มเติมแล้ว และแปลงเป็นการแสดงรหัสดั้งเดิมที่ใช้วิธีการแบบล่างขึ้นเขียนระบบ [Proebsting 1992] สุดท้าย นี้แสดงเฉพาะเครื่อง (มีร์) ปรับให้เหมาะสม และประกอบเป็นเครื่องรหัสปฏิบัติการได้ คอมไพเลอร์ประสิทธิภาพทำ inlining ระหว่างแปล bytecode IR และ ระหว่าง HIR เพิ่มประสิทธิภาพ Inlining ของฟังก์ชันเสมือนจะถูกจัดการ โดยการคาดการณ์ชนิดของฟังก์ชันเสมือน และดำเนินการตรวจสอบขณะทำงานเพื่อพิจารณาคำทำนาย ถ้าคำทำนายไม่ถูกต้อง โปรแกรมทำการเรียกฟังก์ชันเสมือนปกติ มิฉะนั้น โปรแกรมดำเนิน ด้วยฟังก์ชัน inlined ปรับโปรแกรมใน Jalapeno เริ่มต้น ด้วยการใช้เครื่องมือการวาดของรหัสที่ปฏิบัติการได้ รหัสปฏิบัติเป็น instrumented เพื่อรวบรวมข้อมูลส่วนกำหนดค่าคำอธิบายพึ่งบริบทเพื่อช่วยเพิ่มประสิทธิภาพ ใช้ข้อมูลส่วนกำหนดค่าเพื่อตรวจสอบโปรแกรมฮอตสปอ เมื่อถึงขีดจำกัดประสิทธิภาพการทำงานที่แน่นอน คอมไพเลอร์ประสิทธิภาพแบบไดนามิกจะถูกเรียกเมื่อต้องการคอมไพล์ใหม่วิธีจุดใช้บริบทเฉพาะเพิ่มประสิทธิภาพแทน (HIR, LIR และมีร์) ทุกระดับ รหัส unoptimized จะถูกแทนที่ ด้วยรหัสให้เหมาะตามโพรไฟล์ถูกเก็บรวบรวมข้อมูลแล้ว ปรับโปรแกรมอย่างต่อเนื่องในรอบนี้ กับรหัสปฏิบัติปรับปรุงในการเกิดซ้ำปรับทุก

ผลลัพธ์ (ไทย) 3:

นับตั้งแต่ที่เวลารวบรวมในรวบรวมด่านอีป้องเพิ่มโดยตรงกับเวลาในการประมวลผลรวมของแอปพลิเคชันที่มี คุณภาพ ของการปรับแต่งซอร์สโค้ดที่มีจำกัดโดยรวบรวมความเร็วอย่างรุนแรง แอดเดรสแบบไดนามิกรวบรวมปัญหานี้ของรวบรวมด่านอีป้องโดยการปรับเฉพาะบางส่วนของรหัสที่จะดำเนินการบ่อยที่สุดเช่น programhotspotsโปรแกรมส่วนใหญ่ใช้เวลาส่วนใหญ่ของเวลาที่ได้ดำเนินการเพียงเศษส่วนขนาดเล็กของรหัสของพวกเขา ดังนั้นการปรับแต่งเฉพาะวิธีการฮอตสปอตจะให้ผลตอบแทน ประสิทธิภาพ การทำงานเพิ่มขนาดใหญ่ในขณะที่ยังคงรักษาไว้ซึ่งความเร็วรวบรวมค่อนข้างรวดเร็ว แสงแดด' shotspotjvm [ java ฮอตสปอต ประสิทธิภาพ เครื่องยนต์สถาปัตยกรรม]จะใช้รวบรวมแบบไดนามิกในการสร้างรหัสเครื่องเดิมที่ปรับแต่งในขณะทำงานเครื่องยนต์ฮอตสปอตที่ประกอบด้วยคอมไพเลอร์เวลาใช้งานและผู้เป็นล่ามทั้งสอง ในครั้งแรกที่ใช้วิธีที่จะถูกประหารชีวิตมันจะถูกแปลโดยใช้ไมโครโฟนสำหรับล่ามโปรไฟล์ที่รวบรวมข้อมูลเวลาใช้งานเกี่ยวกับวิธีการที่ข้อมูลนี้จะถูกนำไปใช้ในการตรวจหาฮอตสปอตในการเข้าร่วมโปรแกรมและเพื่อรวบรวมข้อมูลเกี่ยวกับพฤติกรรมการโปรแกรมที่สามารถใช้เพื่อเพิ่ม ประสิทธิภาพ สร้างรหัสพื้นเมืองในขั้นตอนของการทำงานของโปรแกรมใน ภายหลัง หลังจากวิธีการฮอตสปอตที่มีการระบุว่าจะได้รับในการสร้างรหัสเครื่องเดิมที่ปรับแต่งแบบไดนามิก รหัสนานๆครั้งดำเนินการอย่างต่อเนื่องได้รับการตีความการลดจำนวนของหน่วยความจำและเวลาที่ใช้ในการสร้างรหัสพื้นเมือง เนื่องจากโปรแกรมมีโอกาสที่จะใช้เวลาส่วนใหญ่ของเวลาในการประมวลผลในเขตพื้นที่ฮอตสปอตที่ตรวจพบโดยผู้เป็นล่ามที่คอมไพเลอร์ที่สามารถใช้ช่วงเวลาที่มากกว่าการปรับรหัสสร้างขึ้นสำหรับส่วนนี้ของโปรแกรมที่มากกว่า jitcompiler ในขณะที่ยังคงอยู่การผลิตการปรับปรุงระบบทั้งหมดในเวลาในการประมวลผลในระหว่างการสร้างคอมไพเลอร์รหัสแบบไดนามิกที่จะทำการปรับปรุง ประสิทธิภาพ คอมไพเลอร์ทั่วไปได้รับการปรับแต่งเฉพาะ Java และ inlining ของวิธีการแบบคงที่และแบบไดนามิก การปรับแต่ง inlining ที่ได้รับการออกแบบมาเพื่อจะกลับได้เนื่องจากปัญหาที่เกี่ยวข้องกับการโหลดแบบไดนามิก IBM ' sjalapenojvm [เบิร์ก et al .1999 ]รวมถึงคอมไพเลอร์การปรับแต่งแบบไดนามิกที่ปรับตัวได้ที่จะสร้างรหัสเครื่องที่ปรับแต่งเป็นโปรแกรมที่จะถูกประหารชีวิต jalapeno ของ Sun JVM แล้ว Control Panel ที่ไม่ได้ใช้ผู้เป็นล่าม แทนการทำงานครั้งแรกของวิธีการที่จะดำเนินการได้อย่างรวดเร็วการรวบรวมวิธีการเข้าสู่รหัส unoptimized ที่ปฏิบัติการได้ที่ คอมไพเลอร์การปรับแต่งแบบไดนามิกได้ใน ภายหลัง จะสร้างโค้ดปฏิบัติการที่ปรับแต่งจาก bytecodes ของฮอตสปอต( IE .ที่ถูกประหารชีวิต)วิธีการตามที่กำหนดโดยข้อมูลโปรไฟล์แอพพลิเคชัน การปรับแต่งค่าคอมไพเลอร์ jalapeno ครั้งแรกที่รวบรวม bytecodes Java เข้าสู่การเป็นตัวแทนระดับกลางระดับสูงลงทะเบียนแบบเสมือน( hir ) มันก็จะสร้างกราฟควบคุมการไหลสำหรับวิธีการที่ หลังจากได้รับการปรับแต่งการใช้คอมไพเลอร์บน hir ได้ไฟล์ที่สามารถรันได้ระหว่างทางที่จะถูกแปลงเป็นระดับต่ำการเป็นตัวแทน( lir )ซึ่งรวมถึงการอ้างถึงรายละเอียดในการนำไปใช้งานเฉพาะเช่นพารามิเตอร์ผ่านกลไกและแผนผังวัตถุในหน่วยความจำ lir จะได้รับการปรับแต่งเพิ่มเติมและปรับเปลี่ยนเพื่อการแสดงรหัสพื้นเมืองโดยใช้วิธีการ bottom-up เขียนระบบ[ proebsting 1992 ]แล้ว ในที่สุดเครื่องนี้เป็นตัวแทนเฉพาะ( MIR )ได้รับการปรับแต่งและประกอบเข้ากับรหัสที่ปฏิบัติการได้เครื่อง การทำการปรับแต่งคอมไพเลอร์จะทำ inlining ทั้งในช่วงการแปล bytecode แบบอินฟราเรดและในระหว่างการปรับแต่ง hir inlining ของฟังก์ชันการทำงานเสมือนจริงถูกจัดการโดยการคาดการณ์ของ ประเภท ที่ทำงานเสมือนจริงและการตรวจสอบเวลาใช้งานที่จะกำหนดความสมบูรณ์ของการคาดการณ์หากการคาดการณ์ที่ไม่ถูกต้องโปรแกรมจะทำตามหน้าที่เสมือนจริงตามปกติ หรือมิเช่นนั้นแล้วโปรแกรมจะดำเนินการต่อไปพร้อมด้วยฟังก์ชัน inlined ได้ การปรับเปลี่ยนโปรแกรมใน jalapeno จะเริ่มต้นด้วยต้องคอมไพล์อีกครั้งและเครื่องมือของโค้ดปฏิบัติการที่ รหัสที่ปฏิบัติการได้มีตัวเพื่อรวบรวมข้อมูลโปรไฟล์ตามบริบทเพื่อช่วยการปรับแต่งข้อมูลโปรไฟล์ที่ใช้ในการตรวจพบฮอตสปอตโปรแกรม เมื่อค่า ประสิทธิภาพ การทำงานบางอย่างที่มีการทำการปรับแต่งแบบไดนามิกถึงคอมไพเลอร์ที่มีการปลุกเร้าขึ้นเพื่อสร้างวิธีใดวิธีหนึ่งฮอตสปอตที่ได้รับการปรับแต่งเฉพาะใช้บริบทในทุกระดับของการรับรอง( hir lir และ MIR ) รหัส unoptimized ที่ถูกแทนที่ด้วยรหัสที่ปรับแต่งตามข้อมูลโปรไฟล์เก็บรวบรวมไว้แล้วการปรับเปลี่ยนโปรแกรมจะยังคงดำเนินต่อไปในการนี้ด้วยโค้ดปฏิบัติการที่มีการปรับปรุงให้ดีขึ้นในทุกย้ำการปรับแต่ง