4. HIGH-PERFORMANCE JAVA EXECUTION

4. HIGH-PERFORMANCE JAVA EXECUTION TECHNIQUES
Direct compilers or bytecode-to-source translators can improve Java performance by generating optimized native codes or intermediate language codes. However this high performance may come at the expense of a loss of portability and flexibility. JIT compilers, on the other hand, support both portability and flexibility, but they cannot achieve performance comparable to directly compiled code as only limited-scope optimizations can be performed. A number of execution techniques have been developed that attempt to improve Java performance by optimizing the Java source code or the bytecodes so that portability is not lost. Some techniques apply dynamic optimizations to the JIT compilation approach to improve the quality of the compiled native machine code within the limited time available to a JIT compiler. Some other techniques improve various features of the JVM, such as thread synchronization, remote method invocation (RMI), and garbage collection, that aid in improving the overall performance of Java programs. In this section, we describe these high-performance Java execution techniques.
4.1. Byte code Optimization
One technique for improving the execution time performance of Java programs is to optimize the bytecodes. The Briki compiler applies a number of optimizations to bytecodes to improve the execution time performance [Cierniak and Li 1997a,b]. The front-end of the offline mode of the Briki compiler [Cierniak and Li 1997a] reconstructs the high-level program structure of the original Java program from the bytecodes. This high-level view of the input bytecodes is stored in an intermediate representation called JavaIR. A number of optimizations can then be applied to this JavaIR. Finally, the optimized JavaIR is transformed back into Java source code and executed by a Java compiler.
Converting Java bytecodes to JavaIR is very expensive, however, requiring an order of magnitude more time than the time required to perform the optimizations themselves. In an on-line version of Briki [Cierniak and Li 1997b], the same optimizations are performed while recovering only as much of the structure information as needed and using faster analysis techniques than those used in traditional compilers. This on-line version of Briki is integrated with the Kaffe JIT compiler [Wilkinson, Kaffe v0.10.0], using Kaffe to generate an IR. The compiler analyzes and transforms the Kaffe IR into an optimized IR which the Kaffe JIT backend then translates into native code.
One optimization in Briki attempts to improve memory locality by data remapping. Briki groups together similar fields within objects onto consecutive memory locations, increasing the probability that fields will reside on the same cache line. However, the specific criterion used by the Briki compiler to determine similar fields has not been described [Cierniak and Li 1997a,b]. Briki also attempts to remap array dimensions when dimension remapping will improve memory access time. For example, in a two-dimensional array A, location A[i][j] might be remapped to A[j][i] if such a remapping is advantageous. However, this remapping poses a number of problems. First, Java arrays are not standard rectangular arrays but rather are implemented as an array of arrays. Therefore, array elements in a given dimension are not guaranteed to be of the same size. A[i] might reference an array of size 2 while A[j] references an array of size 3, for instance. Since array remapping is valid only for rectangular arrays, Briki constrains remapping to cases where all dimensions of the array are accessed. Second, subscript expressions in arrays can have potential sideeffects. For instance, the calculation of a subscript may, as a side-effect, assign a value to a variable. Remapping the array dimensions may cause problems since the renaming changes the evaluation order of these expressions. To remedy this problem, Briki evaluates subscript expressions in the correct order before the arrays are actually referenced.
TheDashO Pro[DashO Pro] bytecode optimizer applies several optimization techniques to improve runtime performance and reduce the size of the Java executable. These techniques include shortening the names of all the classes, methods, and fields, removing all unused methods, fields, and constant-pool entries (both constants and instance variables), extracting classes from accessible thirdparty packages or libraries, and so on. DashO produces one file that contains only the class files needed for the Java program resulting in smaller and faster Java bytecode files.
Krintz et al. [1999] proposed a Java class file splitting and prefetching technique to reduce the transfer delay of bytecodes sent over the Internet. Class file splitting partitions a Java class file into separate hotandcold class files to eliminate transferring code in the cold class file that is very rarely (or never) used. Class file prefetching inserts special prefetch instructions into the Java class file to overlap bytecode transfer with execution. These optimizations use compiletime analysis and profiling to select code to split and to insert prefetch instructions. Experimental results showed that class file splitting was able to reduce startup time for Java programs by 10% while prefetching combined with splitting reduced the overall bytecode transfer delay by 25% on average.
The Java application extractor Jax [Tip et al. 1999] applies several techniques, such as the elimination of redundant methods/fields and class hierarchy specialization [Tip and Sweeney 1997], to reduce the size of a Java class file archive (e.g., zip or jar files). Jax performs a wholeprogram analysis on a Java class file to determine the classes, methods, and fields that must be retained to preserve program behavior. It then removes the unnecessary components of the class files to reduce the archive size. Additionally, Jax applies a class hierarchy transformation that reduces the archive size by eliminating classes entirely or by merging adjacent classes in the hierarchy. It also replaces original class, method, and field names with shorter names. Once methods are removed from a class file, some entries in the constant pool may appear to be redundant. Thus, when the archive is rewritten after all the transformations are applied, a new constant pool is created from scratch to contain only the classes, methods, fields, and constants that are referenced in the transformed class file. Using Jax on a number of Java archives resulted in a 13.4–90.2% reduction in size [Tip et al. 1999].

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

4 ที่มีประสิทธิภาพสูงเทคนิคการดำเนิน java
คอมไพเลอร์โดยตรงหรือแปล bytecode ไปแหล่งที่สามารถปรับปรุงประสิทธิภาพการทำงานของจาวาโดยการสร้างรหัสพื้นเมืองที่ดีที่สุดหรือรหัสภาษากลาง แต่มีประสิทธิภาพสูงนี้อาจจะมาที่ค่าใช้จ่ายของการสูญเสียในการพกพาและความยืดหยุ่น คอมไพเลอร์ JIT ในมืออื่น ๆ ที่สนับสนุนทั้งการพกพาและความยืดหยุ่นแต่พวกเขาไม่สามารถบรรลุผลการดำเนินงานเทียบได้กับการรวบรวมรหัสโดยตรงเป็นเพียงการเพิ่มประสิทธิภาพ จำกัด ขอบเขตสามารถดำเนินการ จำนวนของเทคนิคการดำเนินการได้รับการพัฒนาความพยายามที่จะปรับปรุงประสิทธิภาพการทำงานโดยการเพิ่มประสิทธิภาพ java ซอร์สโค้ดจาวาหรือ bytecodes ที่เพื่อการพกพาที่ไม่ได้หายไปเทคนิคบางอย่างใช้การเพิ่มประสิทธิภาพแบบไดนามิกเพื่อ JIT รวบรวมวิธีการปรับปรุงคุณภาพของรหัสเครื่องพื้นเมืองที่รวบรวมภายในเวลาที่ จำกัด ที่มีการเรียบเรียง บางเทคนิคอื่น ๆ ปรับปรุงคุณสมบัติต่างๆของ JVM เช่นประสานด้ายวิธีการภาวนาระยะไกล (RMI) และเก็บขยะช่วยในการปรับปรุงประสิทธิภาพโดยรวมของโปรแกรมจาวาที่ในส่วนนี้เราจะอธิบายที่มีประสิทธิภาพสูงเหล่านี้เทคนิคการดำเนิน java.
4.1 การเพิ่มประสิทธิภาพของรหัสไบต์
หนึ่งเทคนิคสำหรับการปรับปรุงประสิทธิภาพการทำงานของเวลาการทำงานของโปรแกรมจาวาคือการเพิ่มประสิทธิภาพ bytecodes คอมไพเลอร์ briki ใช้จำนวนของการเพิ่มประสิทธิภาพในการ bytecodes ในการปรับปรุงประสิทธิภาพการทำงานของเวลาปฏิบัติการ [cierniak และ li 1997a, b]front-end ของโหมดออฟไลน์ของ briki คอมไพเลอร์ [cierniak และ li 1997a] reconstructs โครงสร้างโปรแกรมระดับสูงของโปรแกรม java ต้นฉบับจาก bytecodes มุมมองระดับสูงของ bytecodes ข้อมูลจะถูกเก็บไว้ในการเป็นตัวแทนกลางที่เรียกว่า javair จำนวนของการเพิ่มประสิทธิภาพนั้นจะสามารถนำไปใช้กับ javair นี้ ในที่สุดjavair ที่ดีที่สุดจะถูกเปลี่ยนกลับเข้ามาในซอร์สโค้ดจาวาและดำเนินการโดยคอมไ​​พเลอร์จาวา
แปลง bytecodes จาวาเพื่อ javair มีราคาแพงมาก แต่ต้องลำดับความสำคัญเวลามากขึ้นกว่าระยะเวลาที่จำเป็นในการดำเนินการเพิ่มประสิทธิภาพของตัวเอง ในรุ่นในสายของ briki [cierniak และ li 1997b]การเพิ่มประสิทธิภาพเดียวกันจะดำเนินการในขณะที่การกู้คืนเป็นเพียงมากของข้อมูลโครงสร้างตามความจำเป็นและการใช้เทคนิคการวิเคราะห์ได้เร็วขึ้นกว่าที่ใช้ในคอมไพเลอร์แบบดั้งเดิม นี้รุ่นในสายของ briki จะรวมกับ Kaffe JIT คอมไพเลอร์ [วิลกินสัน Kaffe v0.10.0] โดยใช้ Kaffe เพื่อสร้าง irรวบรวมวิเคราะห์และแปลง ir Kaffe เป็น ir ที่ดีที่สุดซึ่ง JIT แบ็กเอนด์ Kaffe แล้วแปลเป็​​นรหัสพื้นเมือง
หนึ่งในการเพิ่มประสิทธิภาพ briki ความพยายามที่จะปรับปรุงสถานที่หน่วยความจำโดยแมปข้อมูล กลุ่ม briki เอาเขตข้อมูลที่คล้ายกันภายในวัตถุไปยังสถานที่หน่วยความจำต่อเนื่องที่เพิ่มขึ้นน่าจะเป็นที่เขตข้อมูลจะอยู่ในบรรทัดเดียวกันแคช อย่างไรก็ตามเกณฑ์ที่เฉพาะเจาะจงโดยใช้คอมไพเลอร์ briki เพื่อกำหนดเขตข้อมูลที่คล้ายกันยังไม่ได้รับการอธิบาย [cierniak และ li 1997a, b] briki ยังพยายามที่จะแมปขนาดอาร์เรย์มิติเมื่อแมปจะปรับปรุงเวลาในการเข้าถึงหน่วยความจำ ตัวอย่างเช่นในอาร์เรย์สองมิติสถานที่ [i] [j] อาจจะมีการแมปไป [j] [i] ถ้าเช่นแมปเป็นประโยชน์ อย่างไรก็ตามแมปนี้ poses จำนวนของปัญหา แรกอาร์เรย์ java ไม่อาร์เรย์สี่เหลี่ยมมาตรฐาน แต่จะดำเนินการเป็นอาร์เรย์ของอาร์เรย์ ดังนั้นองค์ประกอบมากมายในมิติที่กำหนดจะไม่ได้รับประกันว่าจะมีขนาดเท่ากัน [i] อาจอ้างอิงอาร์เรย์ของขนาดที่ 2 ในขณะที่ [j] อ้างอิงอาร์เรย์ขนาด 3 ตัวอย่างเช่น ตั้งแต่แมปอาร์เรย์สามารถใช้งานได้กับอาร์เรย์สี่เหลี่ยมbriki constrains แมปกับกรณีที่ทุกมิติของอาร์เรย์มีการเข้าถึง สองสำนวนห้อยในอาร์เรย์สามารถมี sideeffects ที่มีศักยภาพ เช่นการคำนวณจากตัวห้อยอาจเป็นผลข้างเคียง, กำหนดค่าให้กับตัวแปร แมปขนาดอาร์เรย์อาจทำให้เกิดปัญหาตั้งแต่การเปลี่ยนชื่อที่มีการเปลี่ยนแปลงเพื่อการประเมินผลของการแสดงออกเหล่านี้ เพื่อแก้ไขปัญหานี้briki ประเมินการแสดงออกห้อยในลำดับที่ถูกต้องก่อนที่จะอาร์เรย์มีการอ้างอิงจริง
thedasho โปร [dasho โปร] bytecode เพิ่มประสิทธิภาพการใช้เทคนิคการเพิ่มประสิทธิภาพหลายอย่างเพื่อปรับปรุงประสิทธิภาพการทำงานรันไทม์และลดขนาดของโปรแกรมประมวลผลจาวา เทคนิคเหล่านี้รวมถึงการตัดทอนชื่อของทุกชั้นเรียนวิธีการและเขตข้อมูลที่ไม่ได้ใช้วิธีการเอาเขตข้อมูลทั้งหมด,และรายการคงที่สระว่ายน้ำ (ทั้งคงที่และตัวแปรเป็นต้น) สกัดจากแพคเกจเรียน thirdparty เข้าถึงหรือห้องสมุดและอื่น ๆ dasho ผลิตไฟล์เดียวที่มีเฉพาะไฟล์ชั้นที่จำเป็นสำหรับโปรแกรมจาวาที่มีผลในขนาดเล็กและเร็ว java ไฟล์ bytecode
krintz ตอัล[1999] เสนอแยกแฟ้มคลาส java และเทคนิค prefetching เพื่อลดความล่าช้าในการโอน bytecodes ส่งผ่านทางอินเทอร์เน็ต แยกแฟ้มคลาสพาร์ติชันแฟ้มคลา java เป็นไฟล์ชั้น hotandcold แยกที่จะกำจัดการถ่ายโอนไฟล์รหัสในระดับที่เย็นมากไม่ค่อย (หรือไม่) ที่ใช้prefetching แฟ้มคลาแทรกคำแนะนำ prefetch พิเศษในไฟล์ java ชั้นทับซ้อนโอน bytecode กับการดำเนิน การเพิ่มประสิทธิภาพเหล่านี้ใช้การวิเคราะห์ compiletime และโปรไฟล์เพื่อเลือกรหัสที่จะแยกและแทรกคำแนะนำ prefetchผลการทดลองแสดงให้เห็นว่าแยกไฟล์ชั้นเรียนก็สามารถที่จะลดเวลาในการเริ่มต้นสำหรับโปรแกรมจาวา 10% ในขณะที่ prefetching รวมกับแยกลดความล่าช้าในการโอน bytecode โดยรวม 25% โดยเฉลี่ย
java โปรแกรม JAX ระบาย [et al, ปลาย 1999] ใช้เทคนิคหลายเช่นการกำจัดของซ้ำซ้อนวิธีการสาขา / และลำดับชั้นความเชี่ยวชาญ [เคล็ดลับและสวีนีย์ 1997] เพื่อลดขนาดของข้อมูลที่เก็บแฟ้มคลาสจาวา (เช่นไปรษณีย์หรือขวดไฟล์) JAX ทำการวิเคราะห์ wholeprogram ในไฟล์ java ชั้นเรียนเพื่อตรวจสอบวิธีการและเขตข้อมูลที่จะต้องเก็บไว้เพื่อรักษาการทำงานของโปรแกรมก็เอาส่วนที่ไม่จำเป็นของไฟล์ชั้นเพื่อลดขนาดข้อมูลที่เก็บ นอกจากนี้ JAX ใช้การเปลี่ยนแปลงลำดับชั้นที่ช่วยลดขนาดของข้อมูลที่เก็บโดยการกำจัดการเรียนทั้งหมดหรือโดยการรวมการเรียนที่อยู่ใกล้เคียงในลำดับชั้น ยังแทนที่ชั้นเรียนเดิมวิธีการและชื่อเขตข้อมูลที่มีชื่อที่สั้นลง เมื่อวิธีการที่จะถูกลบออกจากไฟล์ชั้นเรียนบางรายการในสระว่ายน้ำคงที่อาจจะเป็นที่ซ้ำซ้อน ดังนั้นเมื่อเก็บจะเขียนใหม่หลังจากการเปลี่ยนแปลงทั้งหมดจะถูกนำไปใช้สระว่ายน้ำคงที่ใหม่จะถูกสร้างขึ้นจากรอยขีดข่วนที่จะมีเพียงชั้นเรียนวิธีการเขตและค่าคงที่ที่ได้รับการอ้างอิงในแฟ้มคลาเปลี่ยน ใช้ JAX กับจำนวนของที่เก็บ java มีผลในการลดลง 13.4-90.2% ในขนาด [et al, ปลาย 1999].

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

4. เทคนิคปฏิบัติการ JAVA ประสิทธิภาพสูง
คอมไพเลอร์โดยตรงหรือแปล bytecode แหล่งสามารถเพิ่มประสิทธิภาพของจาวา โดยสร้างเป็นรหัสให้เหมาะหรือรหัสภาษากลางได้ อย่างไรก็ตาม ประสิทธิภาพสูงนี้อาจมาค่าใช้จ่ายของการขาดทุนของพอร์ตและความยืดหยุ่น JIT คอมไพเลอร์ คง สนับสนุนพอร์ตและความยืดหยุ่น แต่พวกเขาไม่สามารถบรรลุประสิทธิภาพเทียบได้กับรหัสที่คอมไพล์โดยตรงสามารถดำเนินการเพิ่มประสิทธิภาพเท่านั้นจำกัดขอบเขต เทคนิคการดำเนินการจำนวนหนึ่งได้รับการพัฒนาที่พยายามปรับปรุงประสิทธิภาพของ Java โดยเพิ่มรหัสแหล่งที่มาของ Java หรือ bytecodes ให้พอร์ตไม่สูญหาย บางเทคนิคที่ใช้เพิ่มประสิทธิภาพแบบไดนามิกวิธีคอมไพล์ JIT เพื่อปรับปรุงคุณภาพของรหัสภาษาเครื่องที่คอมไพล์ภายในเวลาที่จำกัดที่ใช้คอมไพเลอร์ JIT เทคนิคอื่น ๆ ปรับปรุงคุณสมบัติต่าง ๆ ของ JVM เช่นตรงหัวข้อ วิธีการระยะไกลเรียก (RMI), และเก็บรวบ รวมขยะ ที่ช่วยในการปรับปรุงประสิทธิภาพโดยรวมของโปรแกรม Java ในส่วนนี้ เราอธิบายเหล่านี้ประสิทธิภาพสูง Java ดำเนินการเทคนิคการ
4.1 รหัสไบต์เพิ่มประสิทธิภาพ
เทคนิคหนึ่งสำหรับการปรับปรุงประสิทธิภาพการทำงานของเวลาปฏิบัติการของโปรแกรม Java จะปรับ bytecodes คอมไพเลอร์ Briki ใช้จำนวนเพิ่มประสิทธิภาพ bytecodes เพื่อปรับปรุงประสิทธิภาพการดำเนินการเวลา [Cierniak และหลี่ 1997a, b] โปรแกรมพื้นฐานโครงสร้างของโปรแกรม Java ฉบับ bytecodes reconstructs เวอร์ของโหมดออฟไลน์ของคอมไพเลอร์ Briki [Cierniak และหลี่ 1997a] มุมมองระดับสูงของ bytecodes เข้าไว้ในการแสดงระดับกลางที่เรียกว่า JavaIR แล้วสามารถใช้จำนวนเพิ่มประสิทธิภาพกับ JavaIR นี้ สุดท้าย JavaIR ให้เหมาะจะเปลี่ยนกลับเป็นรหัสแหล่งที่มาของจาวา และปฏิบัติการ โดยคอมไพเลอร์จาวา
แปลง Java bytecodes JavaIR มีราคาแพงมาก แต่ ต้องการสั่งของขนาดเวลาเวลาที่ต้องการเพิ่มประสิทธิภาพเอง ในการรุ่นของ Briki [Cierniak และหลี่ 1997b], ดำเนินการเพิ่มประสิทธิภาพเดียวกันขณะที่กู้คืนเฉพาะมากที่สุดของโครงสร้างข้อมูลที่จำเป็น และใช้เทคนิคการวิเคราะห์ได้รวดเร็วกว่าใช้คอมไพเลอร์แบบดั้งเดิม รุ่นนี้ของ Briki รวมกับคอมไพเลอร์ Kaffe JIT ดาวเทียมสำรวจ [คลื่น Kaffe v0.10.0], ใช้ Kaffe สร้างใดมี คอมไพเลอร์วิเคราะห์ และแปลง Kaffe IR เป็น IR เพิ่มประสิทธิภาพที่ backend Kaffe JIT แล้วแปลเป็นรหัสภาษา
เพิ่มประสิทธิภาพหนึ่งใน Briki พยายามพัฒนาท้องถิ่นหน่วยความจำ remapping ข้อมูล Briki กลุ่มกันคล้ายฟิลด์ภายในวัตถุไปยังตำแหน่งหน่วยความจำต่อเนื่อง เพิ่มความเป็นไปได้ว่า ฟิลด์จะอยู่บรรทัดเดียวกันแคช อย่างไรก็ตาม ไม่ได้อธิบายเกณฑ์เฉพาะที่ใช้ โดยคอมไพเลอร์ Briki เพื่อกำหนดเขตข้อมูลคล้าย [Cierniak และหลี่ 1997a, b] Briki ยังพยายามที่จะแมปซ้ำขนาดของอาร์เรย์เมื่อ remapping มิติจะเพิ่มเวลาการเข้าถึงหน่วยความจำ ตัวอย่าง ในอาร์เรย์สองมิติ A ตำแหน่ง A [i] [j] อาจจะ remapped จะเป็น [j] [i] ถ้าเช่นการ remapping ได้ประโยชน์ อย่างไรก็ตาม remapping นี้ส่อเค้าปัญหา แรก Java เรย์เรย์มาตรฐานสี่เหลี่ยมไม่มี แต่จะ ถูกนำไปใช้เป็นอาร์เรย์ของอาร์เรย์ ดังนั้น ลำดับในขนาดที่กำหนดจะไม่รับประกันว่า จะขนาด [I] อาจอ้างอิงถึงอาร์เรย์ขนาด 2 ขณะ [j] การอ้างอิงอาร์เรย์ขนาด 3 ตัวอย่าง เนื่องจากอาร์เรย์ remapping นี้สำหรับอาร์เรย์แบบสี่เหลี่ยม Briki จำกัด remapping กรณีที่มีการเข้าถึงมิติทั้งหมดของอาร์เรย์ นิพจน์ที่สอง ตัวห้อยในอาร์เรย์ได้เป็น sideeffects ตัวอย่าง การคำนวณเป็นตัวห้อยอาจ เป็นการผลข้างเคียง กำหนดค่าให้ตัวแปร Remapping ขนาดของอาร์เรย์อาจทำให้เกิดปัญหาตั้งแต่เปลี่ยนชื่อการเปลี่ยนแปลงลำดับการประเมินนิพจน์เหล่านี้ การแก้ไขปัญหา Briki ประเมินนิพจน์ตัวห้อยในลำดับถูกต้องก่อนที่อาร์เรย์จะถูกอ้างอิงจริง
เพิ่มประสิทธิภาพ bytecode TheDashO Pro [ชายคัม Pro] ใช้หลายเทคนิคเพิ่มประสิทธิภาพเพื่อเพิ่มประสิทธิภาพขณะทำงาน และขนาดของ Java ปฏิบัติ เทคนิคเหล่านี้ประกอบด้วยชื่อของการเรียน วิธีการ และ ฟิลด์ เอาวิธีใช้ทั้งหมด เขตข้อมูล เนยขาว และสระว่ายน้ำคง (ค่าคงที่และตัวแปรอินสแตนซ์), แยกชั้นจากแพคเกจ thirdparty เข้าหรือไลบรารี และอื่น ๆ ชายคัมสร้างแฟ้มที่ประกอบด้วยเฉพาะแฟ้มคลาจำเป็นสำหรับโปรแกรม Java ในแฟ้ม bytecode ของ Java มีขนาดเล็กลง และเร็วขึ้น
Krintz et al [1999] เสนอแฟ้มคลาส Java แบ่ง และเทคนิคเพื่อลดความล่าช้าโอนของ bytecodes prefetching ส่งผ่านอินเทอร์เน็ต ชั้นแฟ้มแยกกั้นแฟ้มคลาส Java เป็นแฟ้มคลา hotandcold เพื่อกำจัดโอนรหัสในแฟ้มคลาที่เย็นที่มากไม่ค่อย (หรือไม่) ใช้แยกกัน ชั้นแฟ้ม prefetching แทรกคำสั่งดึงข้อมูลล่วงหน้าพิเศษในแฟ้มคลาส Java ทับ bytecode การโอนย้าย มีการดำเนินการ เพิ่มประสิทธิภาพเหล่านี้ใช้ compiletime การวิเคราะห์และการสร้างโพรไฟล์ให้เลือกรหัส การแยก และ การแทรกคำสั่งดึงข้อมูลล่วงหน้า ผลการทดลองพบว่า แบ่งแฟ้มคลาจะลดเวลาเริ่มต้นสำหรับโปรแกรม Java โดย 10% ขณะที่ prefetching รวมแบ่งลดการหน่วงเวลาการโอนย้ายรวม bytecode 25% โดยเฉลี่ย
จาวาแอพลิเคชัน extractor แจ๊กซ์เท [คำแนะนำและ al. 1999] ใช้เทคนิคหลาย เช่นการกำจัดวิธีซ้ำฟิลด์และระดับเฉพาะทางชั้น [คำแนะนำและปี 1997 Sweeney], ขนาด Java ชั้นแฟ้มเก็บถาวร (เช่น ไปรษณีย์หรือขวดแฟ้ม) แจ๊กซ์เททำการวิ wholeprogram บนแฟ้มคลาส Java เพื่อกำหนดชั้นเรียน วิธีการ และเขตข้อมูลที่ต้องเก็บไว้เพื่อรักษาลักษณะการทำงานของโปรแกรม แล้วมันเอาคอมโพเนนต์ที่ไม่จำเป็นแฟ้มคลาสเพื่อลดขนาดการเก็บถาวร นอกจากนี้ แจ๊กซ์เทใช้การเปลี่ยนแปลงลำดับชั้นคลาที่ลดขนาดเก็บ โดยตัดชั้นเรียนทั้งหมด หรือ โดยการรวมชั้นที่ติดกันในลำดับชั้น มันยังแทนชั้นเดิม วิธี และชื่อของเขตข้อมูล ด้วยชื่อที่สั้นลง เมื่อวิธีจะถูกเอาออกจากแฟ้มคลาส บางรายการในประเภทคงอาจปรากฏว่าซ้ำซ้อน ดังนั้น เมื่อจิตเก็บหลังจากแปลงทั้งหมดจะนำไปใช้ พูคงใหม่ถูกสร้างตั้งแต่มีเฉพาะชั้น วิธี ฟิลด์ และค่าคงที่ถูกอ้างอิงในแฟ้มคลาที่แปรรูป ใช้แจ๊กซ์เทจำนวน Java เก็บผลในการลด 13.4–90.2% ขนาด [คำแนะนำและ al. 1999] .

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

4 . การประมวลผลคอมไพเลอร์ Java ตรงเทคนิค
ประสิทธิภาพ สูงหรือนักแปล bytecode - แหล่งที่มาจะสามารถปรับปรุง ประสิทธิภาพ Java โดยสร้างรหัสเดิมที่ปรับแต่งหรือรหัสกลาง ภาษา อย่างไรก็ตาม ประสิทธิภาพ สูงนี้อาจจะมาในค่าใช้จ่ายของการสูญเสียความยืดหยุ่นและความสามารถในการพกพา ด่านอีป้องคอมไพเลอร์บนมืออีกข้างหนึ่งให้การสนับสนุนทั้งความยืดหยุ่นและความสะดวกในการพกพาแต่พวกเขาไม่สามารถได้รับ ประสิทธิภาพ สูงเทียบได้กับรหัสคอมไพล์โดยตรงเป็นเพียงการปรับแต่งแบบจำกัดขอบเขตสามารถทำได้ หมายเลขที่ใช้เทคนิคการประมวลผลได้รับการพัฒนามีความพยายามที่จะปรับปรุง ประสิทธิภาพ Java โดยการปรับแต่งซอร์สโค้ดจาวาหรือ bytecodes ให้พกพาไม่ให้สูญหายบางส่วนของการใช้เทคนิคการปรับแต่งแบบไดนามิกการคอมไพล์ด่านอีป้องที่จะพัฒนา คุณภาพ ของเครื่องรหัสเดิมโดยที่ ภายใน เวลาจำกัด(มหาชน)ที่มีอยู่ในการคอมไพเลอร์ที่ด่านอีป้อง เทคนิคอื่นๆบางอย่างเพิ่มคุณสมบัติต่างๆของของ Sun JVM แล้ว Control Panel ได้เช่นการซิงโครไนซ์ชุดคำสั่ง( Thread )วิธีการเรียกใช้งานรีโมทคอนโทรล( rmi )และการเก็บขยะที่ช่วยในการเพิ่ม ประสิทธิภาพ การทำงานโดยรวมของโปรแกรม Javaในส่วนนี้เราจะอธิบายถึงเทคนิคการประมวลผล Java ประสิทธิภาพ สูงตัวนี้.
4.1 การปรับแต่งเทคนิค byte รหัส
หนึ่งสำหรับการปรับปรุง ประสิทธิภาพ การประมวลผลของโปรแกรม Java คือการเพิ่ม ประสิทธิภาพ bytecodes ได้ briki คอมไพเลอร์ที่จะใช้หมายเลขที่มีการปรับแต่งสำหรับ bytecodes เพื่อปรับปรุง ประสิทธิภาพ การประมวลผลที่[ cierniak และ Li 1997 b ]front - end )ที่ในโหมดออฟไลน์ของคอมไพเลอร์ briki [ cierniak และ Li 1997 ]ด้วยโครงเรื่องโครงสร้างโปรแกรมระดับสูงของโปรแกรม Java ต้นฉบับจาก bytecodes ได้ ดูระดับสูงนี้ของ bytecodes อินพุตที่ถูกจัดเก็บไว้ในการเป็นตัวแทนระดับกลางที่เรียกว่า javair จำนวนของการปรับแต่งสามารถนำไปใช้ในการ javair นี้แล้ว ในที่สุดjavair เหมาะที่จะถูกปรับเปลี่ยนกลับเข้าไปในโค้ดต้นฉบับ Java และดำเนินการโดยคอมไพเลอร์ Java
การแปลง bytecodes Java กับ javair มีราคาแพงมากแต่ถึงอย่างไรก็ตามยังมีการสั่งซื้อที่ของความสำคัญเวลามากกว่าเวลาที่ต้องใช้ในการได้รับการปรับแต่งเอง ในเวอร์ชันแบบออนไลน์ของ briki [ cierniak และ Li 1997 b ]การปรับแต่งเหมือนกันที่จะเกิดขึ้นในขณะที่การกู้คืนข้อมูลเท่านั้นเท่าข้อมูลโครงสร้างได้ตามความจำเป็นและใช้เทคนิคการวิเคราะห์ได้เร็วขึ้นกว่าที่ใช้ในคอมไพเลอร์แบบดั้งเดิม เวอร์ชันที่บรรทัดนี้ของ briki คือแบบอินทิเกรตพร้อมด้วย kaffe ด่านอีป้องคอมไพเลอร์ที่[วิลคินสัน kaffe v0. 10.0 ]โดยใช้ kaffe เพื่อสร้างอินฟราเรดให้การวิเคราะห์และคอมไพเลอร์ที่แปลง kaffe อินฟราเรดเข้าไปในอินฟราเรดที่ปรับแต่งได้ซึ่ง kaffe ด่านอีป้องส่วนหลังแล้วแปลงเป็นรหัสแบบเนทีฟ
หนึ่งการปรับแต่งใน briki ความพยายามที่จะปรับปรุงพื้นที่หน่วยความจำโดยกำหนดค่าข้อมูล กลุ่ม briki ฟิลด์ทั้งสองร่วมกันเหมือนกัน ภายใน มีวัตถุเข้ากับตำแหน่งหน่วยความจำเพิ่มขึ้นติดต่อกันโอกาสที่ว่าฟิลด์จะอยู่บนบรรทัดแคชเดียวกัน. แต่ถึงอย่างไรก็ตามเกณฑ์เฉพาะที่ใช้โดยคอมไพเลอร์ briki เพื่อตรวจสอบข้อมูลในฟิลด์ความเหมือนไม่มีการอธิบายไว้[ cierniak และ Li 1997 a , b ] briki ยังพยายามที่จะแมปนามสกุล Array ขนาดเมื่อกำหนดค่าขนาดจะปรับปรุงเวลาในการเข้าถึงหน่วยความจำ ตัวอย่างเช่นในที่หลากหลายแบบสองมิติที่มีที่ตั้งที่[ i ][ J ]อาจ remapped [ J ]ที่[ i ]หากกำหนดค่าที่เป็นประโยชน์ แต่ถึงอย่างไรก็ตามกำหนดค่านี้เป็นหมายเลขหนึ่งของปัญหา ครั้งแรกอาเรย์ Java มีไม่ได้อาเรย์มาตรฐานรูปสี่เหลี่ยมแต่ค่อนข้างจะเป็นจะนำมาใช้เป็นความหลากหลายของอาเรย์ ดังนั้นองค์ประกอบความหลากหลายในด้านของขนาดได้รับที่จะไม่ได้รับการรับประกันจะมีขนาดเท่ากัน [ i ]การอ้างอิงอาจจะเป็นความหลากหลายของขนาด 2 ในขณะที่[ J ]การอ้างอิงที่หลากหลายของขนาด 3 ตัวอย่างเช่น. กำหนดค่ามีความหลากหลายตั้งแต่อายุการใช้งานเฉพาะในอาเรย์รูปทรงสี่เหลี่ยมbriki constrains กำหนดค่าในกรณีที่ขนาดของอาร์เรย์ที่เข้าถึงได้ สำนวนที่สองตัวห้อยในอาเรย์สามารถมี sideeffects ศักยภาพ ตัวอย่างเช่นการคำนวณของตัวห้อยที่อาจเป็นด้านข้างมีผลที่กำหนดค่าเพื่อปรับได้ กำหนดค่าขนาดความหลากหลายอาจทำให้เกิดปัญหาเนื่องจากการเปลี่ยนชื่อการเปลี่ยนแปลงการสั่งซื้อการประเมินผลของสำนวนเหล่านี้ เพื่อแก้ไขปัญหานี้briki จะประเมินสถานการณ์ตัวห้อยในการสั่งซื้อที่ถูกต้องก่อนอาเรย์ที่ใช้อ้างอิงได้
thedasho Pro [ dasho Pro ]ปรับ ประสิทธิภาพ bytecode ใช้เทคนิคการปรับแต่งหลายอย่างเพื่อปรับปรุง ประสิทธิภาพ การทำงานและลดขนาดของไฟล์ที่สามารถรันได้ Java เทคนิคเหล่านี้รวมถึงให้สั้นลงชื่อในชั้นเรียนได้ทั้งหมดและวิธีการฟิลด์การถอดวิธีใดวิธีหนึ่งที่ไม่ใช้งานทั้งหมดในฟิลด์คงที่และรายการ - สระ(ค่าคงที่ทั้งสองและตัวแปรยกตัวอย่างเช่น)การแยกชั้นเรียนจากแพ็คเกจ thirdparty สามารถเข้าถึงได้หรือและไลบรารีที่จะเป็นไปได้ dasho ผลิตเป็นหนึ่งไฟล์ที่มีเพียงแห่งเดียวที่ไฟล์ Class ที่จำเป็นสำหรับโปรแกรม Java ที่เป็นผลในไฟล์ bytecode Java ขนาดเล็กกว่าและเร็วขึ้น
krintz et al .[ 1999 ]ที่เสนอเทคนิค Class ไฟล์การแยกและนำเสนอ Java ที่จะลดการหน่วงเวลาบริการรับส่งของ bytecodes ส่งผ่านทางอินเทอร์เน็ต การแยกไฟล์ Class พาร์ติชันแฟ้ม Java ที่อยู่ในแฟ้ม Class hotandcold แบบแยกพื้นที่ในการที่จะขจัดรหัสในการถ่ายโอนไฟล์ Class เย็นที่เป็นอย่างมากแทบจะไม่(ไม่)ที่ใช้แทรกแฟ้มนำเสนอระดับพิเศษ Prefetch :คำแนะนำลงในไฟล์ Java ที่จะถ่ายโอน bytecode สองส่วนทับซ้อนกันพอดีกับการ การปรับแต่งนี้จะใช้โปรไฟล์และการวิเคราะห์ compiletime เพื่อเลือกรหัสในการแยกและแทรกคำแนะนำ Prefetch :ผลการทดลองพบว่าการแยกไฟล์ Class ก็สามารถช่วยลดเวลาในการเริ่มทำงานสำหรับโปรแกรมจาวาโดย 10% ในขณะที่นำเสนอประกอบด้วยการแยกลดการหน่วงเวลาบริการรับส่ง bytecode โดยรวมโดย 25% โดยเฉลี่ย
Java เครื่องสกัดแอปพลิเคชัน JAX [ปลาย et al . 1999 ]จะใช้เทคนิคหลายแห่งเช่นการตัดของวิธีการสำรอง/ฟิลด์ลำดับชั้นและสาขาที่เชี่ยวชาญ(เคล็ดลับและเต็มไปด้วยเรื่องราวของผีสาง 1997 ]เพื่อลดขนาดของ Java Class ไฟล์เก็บถาวรข้อมูล(เช่นโถปั่นหรือไฟล์ Zip ) JAX จะทำการวิเคราะห์ wholeprogram ในไฟล์ Java ที่จะกำหนดชั้นเรียนวิธีการและฟิลด์ที่ต้องถูกจัดเก็บไว้ตลอดระยะเวลาในการรักษาพฤติกรรมโปรแกรมแล้วจะลบคอมโพเนนต์ที่ไม่จำเป็นออกไปของไฟล์คลาสที่จะลดขนาดแฟ้มจัดเก็บได้ นอกจากนี้ JAX ใช้กับการเปลี่ยนแปลงของโครงสร้างแบบลำดับชั้นที่ช่วยลดขนาดพื้นที่จัดเก็บถาวรโดยการขจัดชั้นเรียนทั้งหมดหรือโดยการรวมชั้นเรียนอยู่ใกล้ในลำดับชั้น นอกจากนั้นโรงแรมยังจะถูกนำมาใช้แทนชื่อฟิลด์และวิธีการแบบดั้งเดิมพร้อมด้วยชื่อสั้นลง เมื่อวิธีการใดวิธีการหนึ่งจะถูกลบออกจากไฟล์ Class Aรายการบันทึกบางรายการในสระอย่างต่อเนื่องอาจจะปรากฏขึ้นเป็นสำรอง ดังนั้นเมื่อจัดเก็บที่มีเขียนใหม่หลังจากการเปลี่ยนแปลงทั้งหมดจะถูกนำมาใช้สระคงที่ใหม่จะถูกสร้างขึ้นจากรอยขีดข่วนให้มีเฉพาะชั้นเรียนวิธีการฟิลด์และสิ่งที่ใช้อ้างอิงในไฟล์ Class ปรับเปลี่ยนได้ การใช้ JAX ในจำนวนที่ส่งผลให้การจัดเก็บข้อมูลของชวาในการลด 13.4% -90.2 ในขนาด:[ปลาย et al . 1999 ]..