4.2. Parallel and Distributed Execu

4.2. Parallel and Distributed Execution Techniques
A number of techniques parallelize Java source code or bytecodes to improve the execution-time performance of the application. The parallelization typically is achieved through Java language-level support for multithreading. Thus, these techniques maintain the portability of the transformed parallel Java programs. Most of these techniques exploit implicit parallelism in Java programs for parallel execution on shared-memory multiprocessor systems using Java multithreading and synchronization primitives. Some approaches extend the Java language itself to support parallel and distributed Java programs. The performance improvement obtained when using these techniques depends on the amount of parallelism that can be exploited in the application program.
TheHigh Performance Javaproject [Bik and Gannon 1997; Bik and Gannon 1998] exploits implicit parallelism in loops and multiway recursive methods to generate parallel code using the standard Java multithreading mechanism. TheJAVAR [Bik and Gannon 1997] tool, which is a source-to-source restructuring compiler, relies on explicit annotations in a sequential Java program to transform a sequential Java source code into a corresponding parallel code. The transformed program can be compiled into bytecodes using any standard Java compiler. The JAVAB[Bik and Gannon 1998] tool, on the other hand, works directly on Java bytecodes to automatically detect and exploitimplicit loop parallelism. Since the parallelism is expressed in Java itself using Java’s thread libraries and synchronization primitives, the parallelized bytecodes can be executed on any platform with a JVM implementation that supports native threads.
TheJava Speculative Multithreading (JavaSpMT) parallelization technique [Kazi and Lilja 2000] uses a speculative thread pipelining execution model to exploit implicit loop-level parallelism on shared-memory multiprocessors for general-purpose Java application programs. Its support of control speculation combined with its run-time datadependence checking allows JavaSpMT to parallelize a wide variety of loop constructs, including do–while loops. JavaSpMT is implemented using the standard Java multithreading mechanism. The parallelism is expressed by a Java source-to-source transformation.
The Do!project [Launay and Pazat 1997] provides a parallel framework embedded in Java to ease parallel and distributed programming in Java. The parallel framework supports both data parallelism and control (or task) parallelism. The framework provides a model for parallel programming and a library of generic classes. Relevant library classes can be extended for a particular application or new framework classes can be defined for better tuning of the application.
Tiny Data-Parallel Java[Ichisugi and Roudier 1997] is a Java language extension for data-parallel programming. The language defines data-parallel classes whose methods are executed on a large number of virtual processors. An extensible Java preprocessor, EPP, is used to translate the data-parallel code into standard Java code using the Java thread libraries and synchronization primitives. The preprocessor can produce Java code for multiprocessor and distributed systems as well. However, the Tiny DataParallel Java language does not yet have sufficient language features to support high-performance parallel programs. DPJ[Ivannikov et al. 1997] defines a parallel framework through a Java class library for the development of dataparallel programs.

4.3. Dynamic Compilation
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:

4.2 ขนานและกระจายเทคนิคการดำเนิน
จำนวนเทคนิค parallelize ซอร์สโค้ดจาวาหรือ bytecodes เพื่อปรับปรุงประสิทธิภาพการดำเนินงานของโปรแกรม parallelization มักจะประสบความสำเร็จผ่านการสนับสนุนภาษาจาวาระดับ multithreading ดังนั้นเทคนิคเหล่านี้รักษาพกพาของเปลี่ยนโปรแกรมจาวาขนานที่สุดของเทคนิคเหล่านี้ใช้ประโยชน์จากความเท่าเทียมนัยในโปรแกรมจาวาสำหรับการดำเนินการคู่ขนานในระบบมัลติโปรเซสเซอร์หน่วยความจำที่ใช้ร่วมกันโดยใช้ java multithreading และการประสานวิทยาการ วิธีการบางส่วนขยายภาษาจาวาของตัวเองเพื่อรองรับการขนานและกระจายโปรแกรมจาวาปรับปรุงประสิทธิภาพการทำงานที่ได้รับเมื่อใช้เทคนิคเหล่านี้ขึ้นอยู่กับปริมาณของการทำงานแบบขนานที่สามารถใช้ประโยชน์ในโปรแกรมประยุกต์
javaproject thehigh ประสิทธิภาพ [Bik และนอน 1997; Bik และนอน 1998] หาประโยชน์เท่าเทียมนัยในลูปและวิธีการซ้ำ Multiway เพื่อสร้างรหัสขนานใช้กลไก java multithreading มาตรฐานthejavar [Bik และนอน 1997] เครื่องมือซึ่งเป็นคอมไพเลอร์ปรับโครงสร้างแหล่งที่มาอาศัยประกอบที่ชัดเจนในโปรแกรม java ลำดับที่จะเปลี่ยนรหัสแหล่ง java ลำดับเป็นรหัสขนานที่สอดคล้องกัน โปรแกรมแปลงสามารถเรียบเรียง bytecodes โดยใช้คอมไพเลอร์จาวามาตรฐาน javab [Bik และนอน 1998] เครื่องมือในมืออื่น ๆ ,ทำงานโดยตรงบน bytecodes java ในการตรวจสอบโดยอัตโนมัติและ exploitimplicit ห่วงขนาน ตั้งแต่ขนานจะแสดงตัวเองใน java ใช้ห้องสมุดด้าย java และวิทยาการประสาน bytecodes parallelized สามารถดำเนินการได้บนแพลตฟอร์มใด ๆ กับการดำเนิน JVM ที่สนับสนุนหัวข้อพื้นเมือง
thejava multithreading เก็งกำไร (javaspmt) เทคนิค parallelization [Kazi และ Lilja 2000] ใช้ด้ายรูปแบบการดำเนิน pipelining เก็งกำไรจะใช้ประโยชน์จากความเท่าเทียมห่วงระดับนัยในมัลติหน่วยความจำที่ใช้ร่วมกันสำหรับโปรแกรมจาวาทั่วไปการสนับสนุนของการเก็งกำไรการควบคุมรวมกับการตรวจสอบ datadependence ของเวลาทำงานให้ javaspmt ที่จะทำคู่ขนานที่หลากหลายของโครงสร้างห่วงรวมทั้งทำในขณะที่ลูป javaspmt จะดำเนินการใช้กลไก java multithreading มาตรฐาน ขนานจะแสดงโดย java การเปลี่ยนแปลงแห​​ล่งที่มา
ทำโครงการ [Launay และ pazat 1997] ให้กรอบคู่ขนานที่ฝังอยู่ในจาวาเพื่อความสะดวกในการเขียนโปรแกรมแบบขนานและจัดจำหน่ายใน java กรอบคู่ขนานสนับสนุนทั้งขนานข้อมูลและการควบคุม (หรืองาน) ขนาน กรอบให้รูปแบบการเขียนโปรแกรมแบบขนานและห้องสมุดของชั้นเรียนทั่วไปเรียนห้องสมุดที่เกี่ยวข้องสามารถขยายได้สำหรับการประยุกต์ใช้โดยเฉพาะอย่างยิ่งการเรียนหรือกรอบการทำงานใหม่ที่สามารถกำหนดสำหรับการปรับดีขึ้นของโปรแกรม
ข้อมูลขนานเล็ก java [ichisugi และ roudier 1997] เป็นส่วนขยายของภาษาจาวาสำหรับการเขียนโปรแกรมข้อมูลแบบขนาน ภาษากำหนดข้อมูลชั้นเรียนแบบขนานที่มีวิธีการที่จะดำเนินการเกี่ยวกับการเป็นจำนวนมากของตัวประมวลผลเสมือนpreprocessor ​​java ขยาย EPP จะใช้ในการแปลรหัสข้อมูลแบบขนานเป็นรหัสจาวามาตรฐานโดยใช้ด้ายห้องสมุด java และวิทยาการการประสาน preprocessor ​​สามารถผลิตรหัสจาวาเพื่อมัลติและระบบกระจายได้เป็นอย่างดี อย่างไรก็ตามภาษาจาวา dataparallel เล็ก ๆ ยังไม่ได้มีคุณสมบัติภาษาเพียงพอที่จะสนับสนุนโปรแกรมแบบขนานที่มีประสิทธิภาพสูง DPJ [ivannikov ตอัล 1997] กำหนดกรอบคู่ขนานผ่านห้องสมุดชั้นจาวาสำหรับการพัฒนาโปรแกรม dataparallel.

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

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

4.2 การขนาน และ เทคนิคการดำเนินการกระจาย
จำนวนเทคนิค parallelize รหัสแหล่งที่มาของ Java หรือ bytecodes เพื่อปรับปรุงประสิทธิภาพการทำงานของแอพลิเคชันการเวลาดำเนินการ Parallelization ที่มักจะทำผ่าน Java ภาษาระดับสนับสนุนมัลติเธรด ดังนั้น เทคนิคเหล่านี้รักษาพกพาโปรแกรม Java พร้อมแปรรูป ส่วนใหญ่เทคนิคเหล่านี้ใช้ parallelism นัยในโปรแกรมจาวาสำหรับการดำเนินการแบบขนานบนระบบมัลติโปรเซสเซอร์จำใช้ร่วมกันโดยใช้ Java มัลติเธรดและนำซิงโครไนส์ บางวิธีขยายภาษา Java เพื่อรองรับโปรแกรม Java แบบขนาน และแบบกระจาย ปรับปรุงประสิทธิภาพการทำงานที่ได้รับเมื่อใช้เทคนิคเหล่านี้ขึ้นอยู่กับจำนวนของ parallelism ที่สามารถนำไปในโปรแกรมประยุกต์
Javaproject TheHigh ประสิทธิภาพ [Bik และ Gannon 1997 Bik และ Gannon 1998] ประโยชน์นัย parallelism ในลูปและซ้ำ multiway วิธีสร้างรหัสแบบขนานโดยใช้กลไกมาตรฐาน Java มัลติเธรด เครื่องมือ TheJAVAR [Bik และ Gannon 1997] ซึ่งเป็นที่แหล่งต้นทางโครงสร้างคอมไพเลอร์ อาศัยคำอธิบายชัดเจนในโปรแกรม Java ตามลำดับเพื่อแปลงรหัสแหล่งที่มาของ Java ตามลำดับเป็นรหัสขนานสอดคล้องกัน โปรแกรมแปรรูปสามารถถูกคอมไพล์เป็น bytecodes ใด ๆ มาตรฐานจาวาคอมไพล์เลอร์ JAVAB [Bik และ Gannon 1998] มือ ในทางกลับกัน ทำงานบน Java bytecodes การและ exploitimplicit วน parallelism เนื่องจาก Java เองแสดง parallelism การ ใช้ไลบรารีเธรดของจาวา และซิงโครไนส์นำ parallelized bytecodes สามารถดำเนินการกับแพลตฟอร์มใด ๆ พร้อมใช้งาน JVM ที่สนับสนุนเจ้าของกระทู้
เทคนิค parallelization มัลติ TheJava เก็งเธรด (JavaSpMT) [Kazi และ Lilja 2000] ใช้เธรดเก็ง pipelining รุ่นดำเนินการกดขี่ขูดรีดนัย parallelism ระดับวงบนนี้จำใช้ร่วมกันสำหรับโปรแกรมประยุกต์ Java เม็ด การสนับสนุนของการเก็งกำไรการควบคุมร่วมกับการตรวจสอบขณะใช้งาน datadependence JavaSpMT parallelize หลากหลายของโครงสร้างการวนซ้ำ รวม do–while วนรอบได้ JavaSpMT จะดำเนินการโดยใช้กลไกมาตรฐาน Java มัลติเธรด Parallelism การแสดง ด้วยการเปลี่ยนแปลงต้นฉบับจาวา
ทำโครงการ [นวยและ Pazat 1997] ให้กรอบคู่ขนานใน Java ให้ขนาน และกระจายการเขียนโปรแกรมใน Java กรอบคู่ขนานสนับสนุนข้อมูล parallelism และ parallelism ควบคุม (หรืองาน) กรอบให้รูปแบบการเขียนโปรแกรมแบบขนานและไลบรารีของคลาทั่วไป สามารถขยายคลาไลบรารีที่เกี่ยวข้องสำหรับโปรแกรมประยุกต์เฉพาะ หรือเรียนกรอบใหม่สามารถกำหนดสำหรับปรับแต่งดีกว่าของแอพลิเคชัน
เล็ก Java ข้อมูลขนาน [Ichisugi และ Roudier 1997] นามสกุลเป็นภาษาจาวาสำหรับเขียนข้อมูลพร้อมกันได้ ภาษากำหนดชั้นข้อมูลขนานที่มีวิธีดำเนินการบนตัวประมวลผลเสมือนเป็นจำนวนมาก มี extensible Java preprocessor, epp เป่า ใช้ในการแปลรหัสข้อมูลขนานโค้ดจาวามาตรฐานใช้ไลบรารีเธรดของจาวาและซิงโครไนส์นำ Preprocessor ที่สามารถผลิตโค้ด Java สำหรับมัลติโปรเซสเซอร์ และเผยแพร่ระบบเช่น อย่างไรก็ตาม ภาษาจาวา DataParallel เล็ก ๆ ยังไม่มีคุณลักษณะภาษาที่เพียงพอเพื่อสนับสนุนประสิทธิภาพสูงโปรแกรมแบบขนาน DPJ [Ivannikov et al. 1997] กำหนดกรอบคู่ขนานผ่านไลบรารีคลาส Java ในการพัฒนาของโปรแกรม dataparallel

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

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

4.2 . หมายเลขแบบคู่ขนานและกระจายไปตามเทคนิค
เทคนิค parallelize bytecodes หรือซอร์สโค้ดจาวาในการปรับปรุง ประสิทธิภาพ การประมวลผลของแอปพลิเคชัน parallelization โดยปกติแล้วจะทำได้โดยผ่านการสนับสนุน ภาษา - ระดับ Java สำหรับมัลติเธรดดิ้ง ดังนั้นเทคนิคเหล่านี้คงพกพาของโปรแกรมจาวาเปลี่ยนแบบคู่ขนานเทคนิคเหล่านี้ได้มากที่สุดจากการทำงานแบบขนานได้โดยปริยายในโปรแกรม Java สำหรับการประมวลผลแบบคู่ขนานบนระบบมัลติโปรเซสเซอร์ใช้ร่วมกัน - หน่วยความจำโดยใช้ชนิดมูลฐานและการซิงโครไนซ์มัลติเธรดดิ้ง Java วิธีการบางอย่างการเพิ่ม ภาษา Java ที่ตัวมันเองในการสนับสนุนแบบคู่ขนานและเผยแพร่โปรแกรม Javaการปรับปรุง ประสิทธิภาพ การทำงานที่ได้รับเมื่อใช้เทคนิคเหล่านี้ขึ้นอยู่กับจำนวนของการทำงานแบบขนานที่สามารถนำมาตักตวงผลประโยชน์ในโปรแกรมแอปพลิเคชัน
thehigh javaproject [ bik ประสิทธิภาพ การทำงานและ gannon 1997 bik และ gannon 1998 ]ข้อบกพร่องของการทำงานแบบขนานได้โดยปริยายในวิธีการและกราวนด์ลูป multiway การสอบถามแบบสอบถามซ้ำในการสร้างรหัสแบบคู่ขนานโดยใช้กลไกการทำงานมัลติเธรดดิ้งที่มาตรฐาน Javathejavar [ bik และ gannon 1997 ]เครื่องมือปรับปรุงโครงสร้างหนี้ซึ่งเป็นคอมไพเลอร์แหล่งที่มาแบบจะขึ้นอยู่กับแหล่งที่มาอย่างชัดเจนมีหมายเหตุประกอบแบบในโปรแกรม Java แบบต่อเนื่องเป็นลำดับในการเปลี่ยนรหัสลำดับ Java แหล่งที่เป็นรหัสแบบคู่ขนานที่เกี่ยวข้อง ปรับเปลี่ยนโปรแกรมที่สามารถจะถูกรวบรวมไว้ใน bytecodes โดยใช้มาตรฐานใดๆคอมไพเลอร์ Java javab [ bik และ gannon 1998 ]เครื่องมือนี้บนมือถืออื่นๆใช้งานได้โดยตรงที่ bytecodes Java จะตรวจพบและการทำงานแบบขนาน exploitimplicit โดยอัตโนมัติแบบต่อพ่วง นับตั้งแต่การทำงานแบบขนานได้คือการแสดงในเกาะชวาในตัวมันเองโดยใช้ไลบรารีเกลียวของ Java ชนิดมูลฐานและการซิงโครไนซ์ bytecodes parallelized ที่สามารถดำเนินการบนแพลตฟอร์มที่มีการนำไปใช้งานของ Sun JVM แล้ว Control Panel ที่สนับสนุนเธรดแบบเนทีฟ
เทคนิคการเก็งกำไร parallelization thejava มัลติเธรดดิ้ง( javaspmt )[ kazi และ lilja 2000 ]จะใช้รุ่นการประมวลผลการทำงานแบบไปป์ไลน์เธรดการเก็งกำไรที่จะใช้ได้โดยปริยายแบบต่อพ่วงระดับ Thread บนได้ใช้ร่วมกัน - หน่วยความจำสำหรับโปรแกรมแอปพลิเคชัน Java ใช้งานทั่วไปการสนับสนุนของตนในการควบคุมการเก็งกำไรค่าเงินบาทด้วยการตรวจสอบการใช้งาน - เวลา datadependence ของโรงแรมช่วยให้ javaspmt parallelize เพื่อความหลากหลายของการประกอบสร้างแบบต่อพ่วงรวมถึงหูทำ - ในขณะที่ javaspmt ถูกนำไปใช้งานโดยใช้กลไกการทำงานมัลติเธรดดิ้งที่มาตรฐานจาวา การทำงานแบบขนานได้แสดงออกโดยการปรับเปลี่ยนรูปแบบมาเป็นแหล่ง Java ที่
ไม่ได้!โครงการ[ launay และ pazat 1997 ]จะให้กรอบงานแบบคู่ขนานที่ฝังอยู่ในเกาะชวาเพื่อความสะดวกง่ายดายแบบคู่ขนานและเผยแพร่การตั้งโปรแกรมในเกาะชวา กรอบแบบคู่ขนานที่สนับสนุนข้อมูลและการควบคุมการทำงานแบบขนาน(หรืองาน)ทั้งการทำงานแบบขนาน โครงงานที่จัดให้บริการสำหรับการตั้งโปรแกรมรุ่นแบบคู่ขนานและไลบรารีของชั้นเรียนทั่วไปชั้นเรียนไลบรารีที่เกี่ยวข้องสามารถที่จะได้รับการขยายสำหรับแอปพลิเคชันเฉพาะรายใดรายหนึ่งได้หรือชั้นเรียนโครงสร้างใหม่จะสามารถกำหนดสำหรับการปรับแต่งได้ดียิ่งขึ้นของแอปพลิเคชัน
ขนาดเล็ก data-parallel Java [ ichisugi และ roudier 1997 ]เป็นการเพิ่ม ภาษา Java สำหรับการตั้งโปรแกรมข้อมูลแบบขนาน ภาษา ที่กำหนดชั้นเรียนข้อมูลแบบขนานซึ่งมีวิธีการดำเนินการที่หมายเลขขนาดใหญ่ของโปรเซสเซอร์เสมือนพรีโพรเซสเซอร์ Java ที่สามารถขยายได้ EPP มีการใช้รหัสในการแปลข้อมูลแบบขนานที่เข้ารหัส Java มาตรฐานโดยใช้ชนิดมูลฐานการซิงโครไนซ์และไลบรารีเกลียว Java พรีโพรเซสเซอร์ที่สามารถสร้างโค้ดจาวาสำหรับระบบมัลติโปรเซสเซอร์และจัดจำหน่ายเป็นอย่างดี แต่ถึงอย่างไรก็ตามdataparallel ภาษา Java ขนาดเล็กที่ไม่มีคุณสมบัติเพียงพอที่จะมาสนับสนุน ภาษา โปรแกรมแบบคู่ขนาน ประสิทธิภาพ สูงแต่ dpj [ ivannikov et al . 1997 ]จะกำหนดกรอบแบบคู่ขนานที่ผ่านไลบรารี Java สำหรับการพัฒนาโปรแกรม dataparallel .

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