High Level Programming
Byte Code Jit Jvm Interpreter
קוד ביניים (Bytecode), ה-JVM, הידור JIT, Interpreter ומודל הטעינה של מחלקות ב-Java.
בחרו את הרמה שמתאימה לכם ואת הסט שתרצו לתרגל
חומר לימוד
Byte Code Jit Jvm Interpreter: הדרך של תוכנית Java מהקובץ ועד המעבד
הפרק עוקב אחרי תוכנית Java לאורך כל חייה: קובץ טקסט שכתבתם, קובץ בינארי שהמהדר מוציא, ובסוף הוראות שהמעבד מבצע בפועל. בכל תחנה נשאל מי עושה את העבודה, מתי, ומה קורה כשמשהו לא מסתדר.
- Bytecode: מה
javacכותב לקובצי ה-class, איך מציצים בו עםjavap, ולמה קובץ שהודר בגרסה חדשה נדחה בגרסה ישנה. - JVM: המכונה הווירטואלית, אזורי הזיכרון שלה, איסוף הזבל והבדיקה שהיא מריצה על כל קוד לפני שהוא רץ.
- Class Loader: מתי מחלקה נטענת ומאותחלת, איזה Loader אחראי על מה, ומה מבדיל בין שתי שגיאות הטעינה המוכרות.
- main: נקודת הכניסה ב-Java ובמקבילה שלה ב-C#, והמערך שמקבל את מילות שורת הפקודה.
- Interpreter ו-JIT: שתי דרכים לבצע Bytecode, ואיך HotSpot משלב ביניהן כדי שקוד שרץ שוב ושוב יהפוך לקוד מכונה מהיר.
- אופטימיזציות ו-AOT: Inlining, Escape Analysis ושאר הטריקים של ה-JIT, ומה משתנה כשמהדרים לקוד מכונה מראש.
רוב השאלות בנושא שואלות מי אחראי על שלב מסוים ומה הוא לא עושה, או מציגות קטע קוד ושואלות מה יודפס או איזו שגיאה תופיע. לכן כל דוגמה עם פלט הורצה בפועל, והפלט הוא מה שהתקבל, כולל הודעות השגיאה.
Bytecode: מה javac מייצר
Bytecode: שפת ביניים שאינה שייכת לאף מעבד
נניח שהידרתם תוכנית C על מחשב Linux עם מעבד x86 של Intel. מה שיצא הוא קובץ בשפה של x86 בלבד ובפורמט ש-Linux יודעת לטעון: מעבד ARM לא יבין את ההוראות, ו-Windows לא תזהה את הקובץ כתוכנית. מי שרוצה את אותה תוכנית גם שם חוזר לקוד המקור ומהדר שוב, פעם לכל צירוף של מעבד ומערכת הפעלה.
Java פותרת את זה בתחנת ביניים. javac לא מתרגם לשפה של המעבד שלכם, אלא לשפה של מחשב דמיוני שמתואר במפרט: ה-JVM. התוצר נקרא Bytecode, והוא נשמר בקובצי class.
חשבו על ספר שמתורגם פעם אחת לאספרנטו, ובכל מדינה יושב מתורגמן שקורא אספרנטו ומקריא בשפה המקומית. הספר המתורגם זהה בכל מקום; המתורגמנים שונים. ב-Java הספר הוא קובץ ה-class, והמתורגמן הוא ה-JVM שמותקנת על המחשב.
מכאן נובעת עובדה שמבלבלת רבים: דווקא ה-JVM היא החלק התלוי בפלטפורמה. יש בנייה נפרדת שלה ל-Windows על x86, ל-Linux על ARM, ל-macOS וכן הלאה, וכל אחת יודעת להפוך את אותן הוראות Bytecode לקוד מכונה של המחשב שעליו היא רצה.
זה מה שעומד מאחורי הסיסמה write once, run anywhere: הידור אחד, ואחריו הרצה על כל מחשב שמותקנת בו JVM, בלי לגעת בקוד ובלי להדר מחדש.
| הוראה | מה היא עושה |
|---|---|
iload | דוחפת ערך int ממשתנה מקומי |
iadd | מחברת שני int |
ireturn | מחזירה int מהמתודה |
new | יוצרת אובייקט |
invokevirtual | קוראת למתודה של אובייקט |
invokestatic | קוראת למתודה סטטית |
השמות בטבלה הם רק כינויים לקריאה נוחה. בקובץ עצמו כל הוראה היא מספר, קוד פעולה (opcode), שתמיד נכנס בבית אחד, ומכאן השם Byte-code; לכן אין מקום ליותר מ-256 קודים, והמפרט מגדיר בפועל כמאתיים.
ה-JVM לא יודעת ולא אכפת לה מאיזו שפה הגיע ה-Bytecode. גם המהדרים של Kotlin ושל Scala כותבים קובצי class, ולכן תוכניות בשפות האלה רצות על אותה JVM ויכולות להשתמש בספריות Java.
| מה יש בקובץ | מי מבצע אותו | קשור למעבד או למערכת הפעלה? |
|---|---|---|
| קוד מקור, קובץ java | אף אחד, עד שמהדרים אותו | לא |
| Bytecode, קובץ class | ה-JVM | לא |
| קוד מכונה (native) | המעבד עצמו | כן, לסוג מעבד ולמערכת הפעלה מסוימים |
טעויות נפוצות
- המעבד קורא את קובץ ה-class ומבצע את ההוראות שבו. למעבד אין מושג מה זה
iaddשל ה-JVM. מי שמבצעת את ההוראות, או מתרגמת אותן לקוד מכונה, היא ה-JVM. - Bytecode הוא בסך הכול קוד המקור שנשמר בפורמט אחר. קוד המקור הוא הטקסט שבקובץ java. ה-Bytecode הוא תוצר ההידור: קובץ בינארי שונה לגמרי.
- קובץ class נבנה למערכת הפעלה מסוימת, כמו exe. קובץ class אחד רץ על כל מחשב שיש בו JVM, בלי קשר למערכת ההפעלה ולסוג המעבד.
javacמייצר בתוך קובץ ה-class גרסה נפרדת לכל סוג מעבד. יש Bytecode אחד בלבד. ההתאמה למעבד נעשית מאוחר יותר, על ידי ה-JVM המקומית.- מערכת ההפעלה ממירה את ה-Bytecode להוראות מעבד ומגישה את התוצאה ל-JVM. מערכת ההפעלה כלל אינה מכירה Bytecode. ההמרה היא עבודה של ה-JVM.
- אותה JVM בדיוק מותקנת בכל המחשבים, ולכן Bytecode נייד. ההפך: לכל פלטפורמה JVM משלה. השוני בין ה-JVM-ים הוא שמאפשר ל-Bytecode להישאר אחיד.
בדקו את עצמכם
צוות בנה ספרייה על מחשב macOS עם מעבד ARM, ושלח את קובצי ה-class ללקוח שעובד על Windows עם מעבד Intel ו-JVM באותה גרסה. מה הלקוח צריך לעשות לפני שהוא מריץ?
כלום. ה-Bytecode זהה בכל פלטפורמה, וה-JVM של הלקוח, שנבנתה ל-Windows על Intel, מתרגמת אותו לקוד מכונה של המחשב שלה.
באותו מקרה, איזה חלק בשרשרת אינו זהה בין המחשב של הצוות לזה של הלקוח?
ה-JVM. היא תוכנה שנבנתה במיוחד למערכת ההפעלה ולמעבד של כל צד.
למה אי אפשר שיהיו ב-Bytecode 500 הוראות שונות?
קוד הפעולה של כל הוראה תופס בית אחד, ובבית יש רק 256 ערכים.
javac: מחלקה אחת, קובץ class אחד
מה בדיוק יוצא מ-javac, הקומפיילר שמגיע עם ה-JDK? הדרך הפשוטה לענות היא להדר ולספור קבצים.
תרחיש 1: שני קובצי מקור, חמישה קובצי class
הקובץ Fleet.java מגדיר שתי מחלקות, ולאף אחת מהן אין השם Fleet. הקובץ Garage.java מגדיר מחלקה ציבורית ובתוכה מחלקה פנימית ומחלקה אנונימית.
// Fleet.java
class Truck { }
class Van { }
// Garage.java
public class Garage {
class Door { } // inner class
Runnable alarm = new Runnable() { // anonymous class
public void run() { }
};
}מהדרים את שני הקבצים ומציגים את תוכן התיקייה:
javac Fleet.java Garage.java
ls -1Fleet.java
Garage$1.class
Garage$Door.class
Garage.class
Garage.java
Truck.class
Van.class- מ-
Fleet.javaיצאוTruck.classו-Van.class. איןFleet.class, כי אין מחלקה בשם הזה. - מ-
Garage.javaיצאו שלושה קבצים: המחלקה עצמה,Garage$Door.classשל המחלקה הפנימית, ו-Garage$1.classשל המחלקה האנונימית. - לא נוצר שום jar. אריזה לארכיון היא צעד נפרד שעושים בכלי
jar. - לא נוצר שום exe. אין כאן קוד מכונה בכלל.
הכלל שעולה מהספירה: יחידת הפלט היא המחלקה, לא קובץ המקור. מחלקה שמוגדרת בתוך אחרת מקבלת את שם החיצונית, סימן $ ואת השם שלה, כמו Garage$Door; לאנונימית אין שם, ולכן היא מקבלת מספר רץ: Garage$1, ואילו הייתה שנייה, Garage$2.
כדאי לזכור גם מה javac לא עושה. הוא לא מריץ את התוכנית, ולכן שגיאות ריצה יופיעו רק כשתפעילו java. הוא גם לא מכוון את הקוד למעבד של המחשב שעליו הידרתם: אותו Bytecode ייצא בכל מחשב, וההתאמה למעבד מחכה לזמן הריצה, בתוך ה-JVM.
טעויות נפוצות
- כל המחלקות שבקובץ מקור נכנסות לקובץ class אחד שנקרא כמו קובץ המקור. כל מחלקה מקבלת קובץ class משלה, ושם הקובץ הוא שם המחלקה.
javacמתרגם לקוד מכונה ושומר קובץ הפעלה. הוא מתרגם ל-Bytecode בלבד. קובץ הפעלה של מערכת ההפעלה אינו נוצר.- במהלך ההידור
javacמריץ את הקוד כדי למצוא שגיאות ריצה.javacרק מתרגם ובודק את התחביר והטיפוסים. הרצה קורית רק בפקודהjava. javacמכוונן את הקוד לארכיטקטורה של המחשב שמהדר. ה-Bytecode זהה בכל מקום. מי שמתאים את הקוד למעבד הוא ה-JIT, בזמן ריצה.
בדקו את עצמכם
בקובץ Library.java יש מחלקה ציבורית Library, ובתוכה מחלקה פנימית Shelf ומחלקה אנונימית אחת. אילו קובצי class יופיעו?
Library.class, Library$Shelf.class ו-Library$1.class.
מתכנת הידר בהצלחה, ובהרצה קיבל חריגה של חלוקה באפס. למה המהדר לא עצר אותו?
כי javac לא מריץ קוד. חריגה כזו מתגלה רק בזמן הריצה, בתוך ה-JVM.
להציץ בהוראות עם javap: מכונה שעובדת על מחסנית
קובץ class הוא בינארי, ועורך טקסט יציג בו רק ג'יבריש. ה-JDK מצרף כלי בשם javap שמפענח אותו, והדגל -c מבקש ממנו להדפיס גם, מתודה אחר מתודה, את ההוראות עצמן. מפעילים אותו על שם המחלקה, למשל javap -c Meter עבור Meter.class.
כדי לקרוא את הפלט צריך לדעת איך ה-JVM חושבת. היא אינה מכונת אוגרים כמו המעבד, אלא מכונת מחסנית: לכל קריאה למתודה נוצרת מסגרת (frame), ובה שני מבנים.
| מבנה במסגרת | מה יש בו |
|---|---|
| מערך המשתנים המקומיים | תא ממוספר לכל פרמטר ולכל משתנה מקומי. במתודה סטטית הפרמטר הראשון בתא 0; במתודת מופע תא 0 תפוס על ידי this, והפרמטרים מתחילים בתא 1 |
| מחסנית הפעולות (operand stack) | שטח עבודה זמני. הוראה שולפת ממנו את הערכים שהיא צריכה ודוחפת אליו את התוצאה |
המשמעות: ב-Bytecode אין הוראה שמחברת שני תאים ישירות וכותבת לתא שלישי. כל חישוב הוא שלושה מהלכים: טוענים ערכים מהמשתנים אל המחסנית, מפעילים עליהם את הפעולה, ואז מחזירים את התוצאה או שומרים אותה בחזרה במשתנה.
public class Meter {
static int combine(int start, int minus, int plus) {
return start - minus + plus;
}
int bill(int units, int rate) {
int cost = units * rate;
return cost;
}
}javac Meter.java
javap -c MeterCompiled from "Meter.java"
public class Meter {
public Meter();
Code:
0: aload_0
1: invokespecial #1 // Method java/lang/Object."<init>":()V
4: return
static int combine(int, int, int);
Code:
0: iload_0
1: iload_1
2: isub
3: iload_2
4: iadd
5: ireturn
int bill(int, int);
Code:
0: iload_1
1: iload_2
2: imul
3: istore_3
4: iload_3
5: ireturn
}האות הראשונה של הוראה אומרת על איזה טיפוס היא פועלת: i ל-int, a להפניה לאובייקט. iload_2 פירושה "דחוף את ה-int שבתא 2", isub מחסרת, imul מכפילה ו-iadd מחברת.
המספר שמשמאל לכל הוראה הוא ההיסט שלה בבתים מתחילת המתודה. כאן כל ההוראות באורך בית אחד ולכן המספרים עולים באחד, אבל bipush 100, למשל, תופסת שני בתים.
- ב-
combine, שהיא סטטית,startיושב בתא 0,minusבתא 1 ו-plusבתא 2. - ב-
bill, שהיא מתודת מופע, תא 0 שמור ל-this. לכןunitsהוא תא 1,rateתא 2, והמשתנה המקומיcostמקבל את תא 3. - גם בבנאי שהמהדר הוסיף רואים את
this:aload_0דוחפת את ההפניה מתא 0 לפני הקריאה לבנאי שלObject. istore_3שולפת את ראש המחסנית וכותבת אותו לתא 3, וכךcostמקבל את המכפלה. רוב הכתיבות למשתנים מקומיים עוברות ככה דרך המחסנית, בהוראת store שמתאימה לטיפוס (istore,lstore,astore). חריג בולט הואiinc, שמוסיפה קבוע לתא int בלי לגעת במחסנית:k += 5, כש-k הוא הפרמטר שבתא 0 של מתודה סטטית, מתורגם ל-iinc 0, 5.
תרחיש 2: מעקב אחרי המחסנית בקריאה combine(9, 4, 2)
נריץ את combine בראש, הוראה אחר הוראה. המשתנים המקומיים מתחילים כ-[9, 4, 2].
| היסט | הוראה | מחסנית הפעולות אחריה (ראש המחסנית מימין) |
|---|---|---|
| 0 | iload_0 | 9 |
| 1 | iload_1 | 9, 4 |
| 2 | isub | 5 |
| 3 | iload_2 | 5, 2 |
| 4 | iadd | 7 |
| 5 | ireturn | ריקה, והערך 7 עובר לקורא |
isubשלפה את 4 ואת 9 ודחפה במקומם את 9 פחות 4. הסדר חשוב: הערך שנדחף ראשון הוא המחוסר ממנו.- מערך המשתנים נשאר [9, 4, 2] לאורך כל הדרך. התוצאות הביניים חיו רק במחסנית הפעולות.
- שום דבר לא נכתב לערימה, וגם לא ל-constant pool של המחלקה, הטבלה שמחזיקה קבועים ושמות של מחלקות ומתודות.
- אילו השורה בקוד הייתה
start * minus + plus, הייתה מופיעהimulבמקוםisub, ושאר ההוראות היו נשארות.
טעויות נפוצות
iaddמביאה את שני המספרים מהערימה ובונה בה אובייקט שמחזיק את הסכום. int הוא ערך פרימיטיבי ולא אובייקט. החיבור קורה כולו במחסנית הפעולות של המסגרת, בלי לגעת בערימה.iaddכותבת את הסכום ישר לתוך אחד התאים במערך המשתנים המקומיים.iaddמשאירה את הסכום בראש המחסנית. כתיבה לתא מקומי היא תפקידה של הוראה אחרת,istore.- ההוראות האריתמטיות שומרות את התוצאות ב-constant pool. ה-constant pool מחזיק קבועים ושמות סימבוליים שנקבעו בהידור, וההוראות האלה רק קוראות ממנו, אם בכלל.
java -Xintהיא הדרך להציג את ה-Bytecode של מחלקה.-Xintמריץ את התוכנית כשה-JVM רק מפרשת, בלי JIT. מי שמציג הוראות הואjavap -c.jar tfמפרקת קובץ jar ומציגה את ההוראות שבו.jar tfמדפיסה רק את רשימת הקבצים שבארכיון.javadocמציג את ה-Bytecode בפורמט HTML.javadocבונה דפי תיעוד מההערות שבקוד המקור, ואין לו קשר ל-Bytecode.
בדקו את עצמכם
במתודת מופע int triple(int n) מופיעות ההוראות iload_1, iconst_3, imul, ireturn. למה הפרמטר נטען מתא 1?
כי במתודת מופע תא 0 מחזיק את this, והפרמטר הראשון יושב בתא 1. המתודה דוחפת את n ואת הקבוע 3, מכפילה ומחזירה 3n.
מתודה סטטית עם שני פרמטרים int מתחילה ב-iload_1, iload_0, isub. מה היא מחשבת?
את הפרמטר השני פחות הראשון. הערך שנדחף ראשון, זה שמתא 1, הוא זה שממנו מחסרים.
מספר הגרסה בקובץ ו-UnsupportedClassVersionError
פתחו קובץ class בכלי שמציג בתים כמספרים הקסדצימליים, וכבר בשורה הראשונה תמצאו שני נתונים שה-JVM בודקת לפני כל דבר אחר. כך נראים שמונת הבתים הפותחים של Ticket.class, תוכנית קטנה שהודרה עם --release 8:
xxd -l 8 Ticket.class00000000: cafe babe 0000 0034 .......4cafe babe הוא מספר הקסם, החתימה הקבועה שבזכותה ה-JVM יודעת שמולה קובץ class ולא סתם קובץ. אחריו שני בתים של minor version, כאן 0, ושני בתים של major version: 0x34, כלומר 52. ה-major version קובע על אילו גרסאות של Java הקובץ ירוץ.
| ה-JDK שהידר | major version בקובץ |
|---|---|
| Java 8 | 52 |
| Java 11 | 55 |
| Java 17 | 61 |
| Java 21 | 65 |
כברירת מחדל javac חותם את הקובץ במספר של הגרסה שלו עצמו. ה-JVM קוראת את המספר בזמן הטעינה ומשווה ליכולות שלה, והכלל פשוט: גרסה חדשה של Java מריצה קבצים ישנים, וגרסה ישנה לא מריצה קבצים חדשים ממנה.
במקרה השני אין שום פשרה. ה-JVM לא ממירה את הקובץ לפורמט שהיא מכירה, לא מבצעת רק את ההוראות שהיא מבינה, ולא רצה לאט יותר: היא דוחה את המחלקה כבר בשלב הטעינה, עם UnsupportedClassVersionError.
כשצריך לבנות ב-JDK חדש תוכנית שתרוץ גם על Java ישנה, מוסיפים ל-javac את הדגל --release עם הגרסה הישנה, למשל --release 8. הדגל דואג גם שהקוד לא ישתמש בספריות שלא היו קיימות בגרסה ההיא.
תרחיש 3: קובץ אחד, שלוש גרסאות של Java
המחלקה Ticket מדפיסה שורה אחת. מהדרים אותה ב-JDK 21 בלי --release, ובודקים את הגרסה שנכתבה בקובץ:
javap -v Ticket | grep version minor version: 0
major version: 65מריצים את אותו קובץ על JVM של Java 17:
java TicketError: LinkageError occurred while loading main class Ticket
java.lang.UnsupportedClassVersionError: Ticket has been compiled by a more recent version of the Java Runtime (class file version 65.0), this version of the Java Runtime only recognizes class file versions up to 61.0ב-Java 8 העטיפה אחרת: ההודעה פותחת ב-A JNI error has occurred, ואחריה אותה UnsupportedClassVersionError עם רשימה ארוכה של שורות stack trace מתוך מנגנון הטעינה, והפעם התקרה שמוזכרת בה היא 52.0. בשתי הגרסאות קוד היציאה הוא 1, ושום שורה של התוכנית לא רצה.
ב-Java 21 עצמה התוכנית מדפיסה ticket printed כרגיל. עכשיו מהדרים שוב, הפעם javac --release 8 Ticket.java: זה הקובץ שבתחילת החלק, עם major version 52, ו-Java 8 מריצה אותו ומדפיסה ticket printed.
טעויות נפוצות
- ה-JVM לא מסתכלת על מספר הגרסה, כי Bytecode אינו משתנה בין גרסאות. המספר נבדק בכל טעינה, וקובץ חדש מדי נדחה.
- ה-JIT של הגרסה הישנה מתרגם את הקובץ לגרסה שהוא מכיר. ה-JIT הופך Bytecode לקוד מכונה, ואינו ממיר בין גרסאות של Bytecode. מעבר לזה, המחלקה נדחית עוד בטעינה, כך שה-JIT אפילו לא רואה אותה.
- ה-JVM מבצעת את מה שהיא מכירה ומדלגת בשקט על ההוראות החדשות. שום הוראה לא רצה. הכישלון קורה בשלב הטעינה, לפני תחילת הביצוע.
- השגיאה שתתקבל היא
ClassNotFoundException. הקובץ נמצא בהחלט. הבעיה היא הגרסה שלו, ולכן השגיאה היאUnsupportedClassVersionError. - התוכנית עולה, ורק התכונות החדשות של השפה לא זמינות. אין דבר כזה הרצה חלקית: או שהמחלקה נטענת, או שהיא נדחית.
בדקו את עצמכם
ספרייה הודרה ב-JDK 11 ומשולבת באפליקציה שרצה על Java 21. האם תהיה בעיה?
לא. major version 55 נמוך מ-65, ו-JVM חדשה טוענת קבצים של גרסאות קודמות.
שרת הלקוח מריץ Java 11 בלבד, ואתם עובדים עם JDK 17. איך תבנו את הקוד כדי שירוץ אצלו?
מהדרים עם javac --release 11. כך נכתב בקובץ major version 55, והקוד מוגבל לממשקים שהיו קיימים ב-Java 11.
מה קובץ class חושף, ואיך מקשים על שחזור
בקובץ class אין את הטקסט שכתבתם, אבל יש בו הרבה יותר ממה שנדמה. כדי שמחלקה אחת תוכל לקרוא למתודה של מחלקה אחרת, ה-JVM מקשרת ביניהן לפי שמות. לכן שמות המחלקות, המתודות והשדות, יחד עם הטיפוסים שלהם, נשמרים בקובץ.
כדי לראות כמה מידע נשאר, הנה javap עם הדגל -p (שמציג גם חברים פרטיים) על מחלקה שקוד המקור שלה לא מוצג כאן כלל:
javap -p InvoiceCompiled from "Invoice.java"
public class Invoice {
private long totalCents;
private static int issued;
public Invoice(long);
public java.lang.String describe();
private boolean isLarge();
}מספיק להסתכל כדי לנחש מה המחלקה עושה. כלי Decompiler, כמו CFR או Fernflower, מנצלים את המידע הזה יחד עם ההוראות עצמן, ומפיקים קוד Java שקרוב מאוד למקור.
מפתחים שלא רוצים שזה יקרה מריצים על הקוד כלי טשטוש (Obfuscator), והמוכר שבהם הוא ProGuard. הוא נותן למחלקות, למתודות ולשדות שמות חסרי משמעות כמו a, b, c, ומעדכן את כל המקומות שמשתמשים בהם.
ההתנהגות של התוכנית לא משתנה בכלל. מה שמשתנה הוא מה שרואה מי שמשחזר: במקום describe() ו-isLarge() הוא יקבל a() ו-b(), ויצטרך להבין לבד מה כל אחת עושה.
טעויות נפוצות
- בתוך קובץ class שמור קוד המקור, רק בצורה דחוסה. יש בו Bytecode ומטא-דאטה: שמות, טיפוסים וקבועים. הטקסט המקורי, כולל ההערות, לא נשמר.
- השחזור קל כי לכל שורת מקור יש בדיוק הוראת Bytecode אחת. שורת מקור אחת הופכת בדרך כלל לכמה הוראות, כמו שראינו ב-
combine. השחזור קל בזכות השמות והטיפוסים. - קובץ class הוא קובץ טקסט שאפשר לפתוח בכל עורך. הפורמט בינארי. בשביל לקרוא אותו צריך כלי כמו
javap. - הידור בגרסה חדשה של
javacמצפין את הקבצים ומונע שחזור.javacלא מצפין שום דבר, בשום גרסה. - מספיק לארוז את הקבצים ב-jar כדי שכלי שחזור לא יוכלו לגשת אליהם. jar הוא ארכיון ZIP רגיל. כל תוכנת ZIP פותחת אותו, וכל Decompiler קורא ממנו.
- אפשר להעביר את הקוד דרך ה-JIT לפני המשלוח, וכך יישלח קוד מכונה במקום Bytecode. ה-JIT הוא חלק מה-JVM ופועל רק בזמן ריצה, בזיכרון. הוא לא מייצר קבצים שאפשר לשלוח.
בדקו את עצמכם
אחרי ProGuard, המחלקה PayrollEngine נקראת q, והמתודה computeBonus נקראת a. מחלקה אחרת קראה ל-computeBonus. האם הקריאה תיכשל?
לא. הכלי משנה את השם גם בצד הקורא, כך שהקוד ממשיך לפעול בדיוק כמו קודם. רק הקריאה של קוד משוחזר נעשית קשה.
קוד ביניים גם בשפות אחרות: CIL ב-.NET ו-pyc ב-Python
שפת ביניים איננה המצאה של Java בלבד. נתחיל דווקא ב-Python, בניסוי קטן שמראה שגם שם הטקסט שכתבתם לא מבוצע כמו שהוא.
תרחיש 4: מה CPython משאיר אחריו
הסקריפט run_report.py מייבא מודול קטן בשם pricing, ומריצים אותו בפעם הראשונה:
# pricing.py
def with_vat(amount):
return round(amount * 1.18, 2)
# run_report.py
import pricing
print(pricing.with_vat(50))python run_report.py
ls -1 __pycache__59.0
pricing.cpython-314.pyc- הופיעה תיקייה
__pycache__, ובה קובץ יחיד, שלpricing, המודול שיובא. הסקריפט שהופעל ישירות,run_report.py, לא קיבל קובץ. - בתוך הקובץ יש Bytecode של
pricing. CPython, ההטמעה הרגילה של Python, הופך כל קוד ל-Bytecode משלו, ורק אחר כך המפרש שלו מבצע אותו. אין בקובץ קוד מכונה, אין עותק מוצפן של המקור, ואין ערכים של משתנים מהריצה. cpython-314בשם מספר מי כתב את הקובץ: CPython בגרסה 3.14. גרסה אחרת של המפרש תכתוב לעצמה קובץ נפרד.
בהפעלה הבאה CPython משווה את ה-pyc למצב של pricing.py. אם המקור לא נגע, ה-Bytecode השמור נטען וההידור של המודול נחסך; את run_report.py הוא יהדר מחדש, כמו בכל הפעלה.
ב-.NET התמונה קרובה יותר לזו של Java. מה ש-C# מוציא, קובץ dll או exe שנקרא assembly, אינו קוד מכונה אלא CIL, שפת הביניים של .NET (נתקלים בה גם בשמות MSIL ו-IL). יחד עם הקוד שמור באותו קובץ מידע מובנה על כל הטיפוסים והמתודות, המטא-דאטה, גם הוא בפורמט בינארי.
| Java | .NET | CPython | |
|---|---|---|---|
| שפת הביניים | Bytecode של JVM | CIL (MSIL, IL) | Bytecode של CPython |
| איפה היא נשמרת | קובץ class לכל מחלקה | ב-assembly, קובץ dll או exe, לצד המטא-דאטה | בקובץ pyc בתוך __pycache__, רק למודולים מיובאים |
| מי מבצע אותה | ה-JVM, בפירוש וב-JIT | ה-CLR, שמהדר אותה לקוד מכונה בזמן ריצה בשיטת JIT | המפרש של CPython |
הפורמטים לא מתחלפים זה בזה. CIL אינו Bytecode של JVM: ה-JVM לא תדע מה לעשות ב-dll, וה-CLR לא יריץ קובץ class.
טעויות נפוצות
- קובץ dll של .NET מכיל Bytecode של JVM. הוא מכיל CIL, הפורמט של .NET.
- ה-dll שומר את קוד המקור דחוס, וה-CLR מפרש אותו שורה אחר שורה. ה-dll מכיל CIL שכבר הודר, וה-CLR מתרגם אותו לקוד מכונה ב-JIT.
- assembly הוא קובץ XML שמתאר את המחלקות. המטא-דאטה ב-assembly בינארית, והיא יושבת לצד קוד ה-CIL.
- Python מריצה את הטקסט של קובץ ה-py כמו שהוא, ואין אצלה שלב ביניים. CPython מהדר כל קוד ל-Bytecode לפני שהוא מבצע אותו. ההבדל הוא שהשלב הזה שקוף לכם.
- גם הסקריפט שמריצים בפקודה python מקבל pyc. רק מודולים שמיובאים נשמרים ב-
__pycache__. הסקריפט הראשי מהודר מחדש בכל הפעלה.
ה-JVM: המכונה הווירטואלית
מה ה-JVM עושה, ולמה זה מביא ניידות
מה קורה כשמקלידים java Ticket? מערכת ההפעלה מפעילה תוכנית רגילה, ה-JVM, ומכאן היא עושה את כל השאר: מאתרת את Ticket.class, טוענת אותו, בודקת אותו ומתחילה לבצע את ה-Bytecode שבו.
את מה שה-JVM עושה מאותו רגע ועד סוף הריצה אפשר לחלק לשתי משפחות של משימות:
| משפחה | מה נכלל בה |
|---|---|
| ביצוע הקוד | הפיכת ה-Bytecode לפעולות של המעבד המקומי, בעזרת Interpreter ובעזרת מהדר JIT. שניהם מוסברים בהמשך הפרק |
| ניהול סביבת הריצה | הבאה ובדיקה של מחלקות, הקצאת זיכרון ואיסוף זבל, ותזמון ה-threads של התוכנית |
המילה JVM משמשת בשני מובנים. יש מפרט, מסמך שמגדיר מכונה מופשטת: אילו הוראות קיימות, איך בנוי קובץ class ומה מותר לזיכרון. ויש תוכנות שמממשות את המפרט; הנפוצה שבהן נקראת HotSpot, ומקבלים אותה עם OpenJDK ועם Oracle JDK.
למה לשלם על שכבה נוספת במקום להריץ קוד מכונה שנבנה לחומרה? בשביל הניידות: Bytecode אחד רץ בכל סביבה שיש בה JVM, בלי שינוי ובלי הידור חוזר. התרגום לשפת מכונה לא נחסך, הוא רק עובר מזמן הבנייה לזמן הריצה.
| ראשי התיבות | מה מקבלים בהם |
|---|---|
| JVM | המנוע שמבצע Bytecode |
| JRE | JVM ועוד ספריית המחלקות הסטנדרטית: מה שצריך כדי להריץ |
| JDK | כל מה שיש ב-JRE, ובנוסף כלי הפיתוח: javac, javap, jar ואחרים |
טעויות נפוצות
- ה-JVM מקבלת קובצי java ומהדרת אותם ישר לקוד מכונה. ה-JVM מקבלת רק Bytecode. את קוד המקור הידר
javacעוד קודם. - ה-JVM היא מהדר מראש בלבד, וזיכרון הוא עניין של מערכת ההפעלה. ניהול הזיכרון ואיסוף הזבל הם חלק מרכזי מהעבודה של ה-JVM.
- קוד על JVM מהיר יותר כי הוא ניגש ישירות למעבד ועוקף את מערכת ההפעלה. היתרון של JVM הוא ניידות, לא גישה מיוחדת לחומרה.
- כשמריצים על JVM, הקוד לא צריך להפוך לשפת מכונה. המעבד מבין רק שפת מכונה. התרגום קורה, רק בזמן הריצה ובתוך ה-JVM.
אזורי הזיכרון: ערימה, מחסנית ו-Metaspace
ה-JVM מחזיקה כמה אזורי זיכרון, וכל אחד מהם משמש למשהו אחר. ההבחנה החשובה ביותר היא בין מה שמשותף לכל ה-threads לבין מה שכל thread מקבל לעצמו.
| אזור | של מי | מה יש בו |
|---|---|---|
| ערימה (Heap) | משותפת לכל ה-threads | כל אובייקט וכל מערך שנוצרו בתוכנית, בלי חריגים. ה-Garbage Collector אחראי עליה |
| מחסנית JVM (JVM stack) | אחת לכל thread | מסגרת לכל קריאה פעילה, ובה מערך המשתנים המקומיים ומחסנית הפעולות |
| מונה התוכנית (pc register) | אחד לכל thread | איזו הוראה ה-thread מבצע כרגע |
| אזור המתודות | משותף | מידע על כל מחלקה: שמות, מתודות, ה-Bytecode וה-constant pool. החל מ-Java 8 הוא ממומש כ-Metaspace בזיכרון native, ומחליף את PermGen |
כלל האצבע: משתנה מקומי נמצא תמיד במסגרת שבמחסנית. אם הוא מטיפוס פרימיטיבי, הערך עצמו שם; אם הוא מטיפוס הפניה (reference), במסגרת יש רק את ההפניה, והאובייקט שהיא מצביעה עליו נמצא בערימה.
תרחיש 5: מי יושב איפה בזמן קריאה למתודה
static Order checkout() {
double vat = 0.18;
int[] qty = {2, 1, 5};
Order o = new Order(qty, vat);
return o;
}vatהוא double מקומי, לכן המספר 0.18 עצמו שמור במסגרת שלcheckoutבמחסנית של ה-thread.qtyו-oהם משתנים מקומיים מטיפוס הפניה. במסגרת יש רק שתי הפניות.- המערך
{2, 1, 5}והאובייקטOrderהם אובייקטים, ולכן שניהם נבנו בערימה, אף שנוצרו בתוך מתודה. - כש-
checkoutמסיימת, המסגרת שלה נעלמת יחד עםvat,qtyו-o. האובייקטOrderממשיך לחיות, כי ההפניה אליו הוחזרה לקורא; גם המערך שורד, אםOrderשמר הפניה אליו. - אובייקט שאף אחד כבר לא מפנה אליו לא נמחק ברגע הזה, אלא מחכה שה-Garbage Collector יגיע אליו.
ומי מספק את הזיכרון עצמו? העבודה מתחלקת בין שני גורמים, וכל אחד מהם רואה תמונה אחרת:
| מערכת ההפעלה | ה-JVM | |
|---|---|---|
| מה היא רואה | תהליך אחד, כמו כל תוכנה אחרת | אובייקטים, מערכים ומסגרות |
| מתי היא מעורבת | כשה-JVM מבקשת ממנה, בקריאות מערכת, גוש זיכרון גדול לערימה: בעלייה, ושוב אם הערימה צריכה לגדול | בכל new: היא חותכת מקום מתוך הגוש שכבר ברשותה, בלי לפנות למערכת ההפעלה |
| מה מגביל | הזיכרון של המחשב | התקרה שנקבעה לה בדגל, שמעבר לה היא לא תבקש עוד |
| דגל | מה הוא קובע | דוגמה |
|---|---|---|
-Xms | גודל הערימה בעלייה | -Xms256m |
-Xmx | הגודל שהערימה לא תעבור | -Xmx2g |
-Xss | גודל המחסנית של כל thread | -Xss4m |
כל אזור נכשל בדרכו. ערימה שהתמלאה, כשאין בה אובייקטים לפנות, מובילה ל-OutOfMemoryError. מחסנית של thread שהתמלאה, בדרך כלל ברקורסיה עמוקה מדי, מובילה ל-StackOverflowError. התוכנית הבאה מפעילה את שני המצבים:
public class Limits {
static void dive(int level) {
dive(level + 1); // no base case on purpose
}
public static void main(String[] args) {
try {
dive(1);
} catch (StackOverflowError e) {
System.out.println("thread stack ran out");
}
long[] readings = new long[20_000_000]; // about 160 MB on the heap
System.out.println("allocated " + readings.length + " readings");
}
}java -Xmx64m Limitsthread stack ran out
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
at Limits.main(Limits.java:12)java -Xmx512m Limitsthread stack ran out
allocated 20000000 readingsהרקורסיה נכשלת בשתי ההרצות, כי -Xmx לא נוגע במחסנית. המערך, לעומת זאת, לא נכנס לתקרה של 64 מגה-בייט אבל נכנס בנוחות ל-512.
טעויות נפוצות
- מערך שנוצר בתוך מתודה נשמר על המחסנית, כמו המשתנים המקומיים שלה. כל מערך וכל אובייקט נמצאים בערימה, לא משנה איפה נוצרו. במחסנית נשמרת רק ההפניה אליהם.
- משתנה מקומי מטיפוס הפניה נמצא בערימה, ליד האובייקט שלו. המשתנה, כלומר ההפניה, נמצא במסגרת שבמחסנית. רק האובייקט נמצא בערימה.
- ה-JVM תופסת בעלייה כמות זיכרון קבועה, והגודל לא משתנה עד הסוף. הערימה מתחילה בגודל של
-Xmsויכולה לגדול עד-Xmx. - ה-Garbage Collector הוא הרכיב היחיד שמדבר עם מערכת ההפעלה על זיכרון. ה-JVM כולה מבקשת זיכרון ממערכת ההפעלה ומחזירה לה. ה-GC עוסק בפינוי אובייקטים בתוך הערימה.
- כשהזיכרון לוחץ, ה-JVM מעבירה אובייקטים לקבצים זמניים בדיסק. הערימה נמצאת כולה בזיכרון של התהליך. כשהיא מלאה נזרקת
OutOfMemoryError. -Xmxקובע את גודל הערימה בעלייה, או את גודל המחסנית, או כמה threads מותר לפתוח.-Xmxהוא רק התקרה של הערימה. לגודל בעלייה יש-Xms, ולמחסנית של כל thread יש-Xss.
בדקו את עצמכם
שירות נופל עם StackOverflowError בזמן מעבר רקורסיבי על עץ עמוק. איש התפעול מציע להעלות את -Xmx. למה זה לא יעזור, ובאיזה דגל כן כדאי לטפל?
המסגרות של הקריאות הרקורסיביות יושבות במחסנית של ה-thread, לא בערימה. הדגל הרלוונטי הוא -Xss, שמגדיל את המחסנית של כל thread (ועדיף, כמובן, לבדוק למה הרקורסיה עמוקה כל כך).
בתוך לולאה כותבים Point p = new Point(x, y);. איפה נמצאים p והאובייקט, ומה קורה להם בסוף כל סיבוב?
p הוא הפניה במסגרת של המתודה, והאובייקט Point בערימה. בכל סיבוב p מקבל הפניה לאובייקט חדש; האובייקט הקודם, אם אין אליו הפניות נוספות, נשאר בערימה עד שה-GC יפנה אותו.
Garbage Collector: מי מפנה את הערימה
נתחיל מקוד שנראה כאילו הוא חייב לדלוף. שני אובייקטים מחזיקים זה את זה, ואף שורה לא משחררת אותם, כי ב-Java אין בכלל פקודה כמו free או delete:
class Node {
Node partner;
}
static void pair() {
Node left = new Node();
Node right = new Node();
left.partner = right; // left -> right
right.partner = left; // right -> left: a cycle
} // after return no root reaches either nodeאחרי ש-pair חוזרת, המשתנים left ו-right נעלמים יחד עם המסגרת. לכל אחד מהאובייקטים עדיין יש הפניה, זו שמגיעה מבן הזוג, ובכל זאת שניהם יפונו.
ההסבר הוא באופן שבו ה-Garbage Collector של ה-JVM מחליט. הוא לא סופר הפניות לכל אובייקט, אלא שואל שאלה אחרת: האם אפשר להגיע אליו, אם יוצאים מכמה נקודות מוצא שנקראות שורשים?
- משתנים מקומיים בכל מסגרת שעדיין פעילה.
- שדות סטטיים של מחלקות.
- threads שעדיין רצים.
מהשורשים ה-GC הולך לאורך ההפניות, וכל מה שהוא פוגש בדרך שורד. זוג שמחזיק רק זה את זה, כמו שלנו, נשאר מחוץ להישג יד, וה-GC מחזיר את המקום שלו לערימה בלי שום שורה בקוד שלכם.
ומתי בדיוק הם יפונו? כשה-JVM תחליט. הפינוי לא מתוזמן ליציאה ממתודה או לרגע שבו נשברה ההפניה האחרונה.
הקריאה System.gc() רק מבקשת מה-JVM לשקול איסוף, וגם בלי אף קריאה כזו ה-GC רץ כשצריך.
טעויות נפוצות
- לכל אובייקט יש מונה הפניות, וכשהוא יורד לאפס האובייקט נמחק מיד. ה-GC לא סופר הפניות. הוא בודק אם אפשר להגיע לאובייקט מהשורשים, ומפנה כשהוא בוחר, לא מיד.
- כשמתודה מסתיימת, כל האובייקטים שהיא יצרה משתחררים איתה. רק המסגרת שלה נעלמת. אובייקט שהוחזר לקורא או נשמר בשדה ממשיך לחיות.
- בלי קריאה ל-
System.gc()הזיכרון לא יתפנה לעולם.System.gc()היא הצעה בלבד. ה-GC פועל מעצמו כשה-JVM צריכה מקום. javacמכניס לקוד פקודות שחרור במקומות המתאימים.javacלא מוסיף שום שחרור. כל הפינוי נעשה בזמן ריצה, על ידי ה-GC.
המאמת: בדיקת ה-Bytecode לפני שהוא רץ
דמיינו שלושה קובצי class שלא יצאו מ-javac: אחד נבנה בכלי שכותב Bytecode ידנית, אחד תוקן בעורך הקסדצימלי, ואחד נשלח ממקור שרוצה לפגוע. ה-JVM לא יודעת מאיפה הגיע כל קובץ, ולכן היא מעבירה את כולם אותו מבחן, ברכיב שנקרא bytecode verifier, המאמת.
| מה המאמת בודק | דוגמה למה שיידחה |
|---|---|
| בטיחות טיפוסים | הוראה שמצפה ל-int מקבלת הפניה, או מספר שלם שמנסים להשתמש בו ככתובת זיכרון |
| עקביות מחסנית הפעולות | הוראה ששולפת שני ערכים ממחסנית שיש בה אחד, או מחסנית שחורגת מהגודל המרבי שהוגדר למתודה |
| קפיצות חוקיות | קפיצה לאמצע של הוראה, או אל מחוץ לגבולות המתודה |
מחלקה שנכשלת באחת השורות האלה לא נטענת, ואף הוראה שלה לא מתבצעת. כך גם קובץ שנבנה כדי להזיק נשאר בלי כלים: הוא לא יכול לדרוס זיכרון שאינו שלו, ולא להתחמק מחוקי השפה, למשל להפוך מספר לכתובת ולקרוא משם.
והמחיר בזמן הריצה כמעט אפסי. המבחן נערך לכל מחלקה פעם אחת, כחלק מהטעינה שלה, ולא בכל ביצוע של הוראה.
טעויות נפוצות
- ההגנה היא הצפנה: בזמן הטעינה ה-JVM מקודדת כל קובץ class כך שאי אפשר לקרוא אותו. אין שום הצפנה. ההגנה באה מבדיקת הקוד.
- ה-JVM דורשת חתימה דיגיטלית על כל קובץ class ודוחה קבצים שלא נחתמו. קובצי class רגילים לא נחתמים בכלל. המאמת מסתכל על התוכן של הקוד, לא על חתימה.
- ה-JVM משווה את הקוד למאגר של חתימות וירוסים. זו עבודה של אנטי-וירוס. המאמת בודק חוקיות של הוראות.
- כדי שמחלקה אחת לא תפגע באחרת, ה-JVM מבודדת כל מחלקה בתהליך משלה. כל המחלקות של התוכנית רצות בתוך אותו תהליך, התהליך של ה-JVM.
- המאמת מסיר מהקוד הוראות מסוכנות ומשאיר את השאר. המאמת לא עורך קוד. מחלקה שלא עוברת את הבדיקה פשוט לא נטענת.
Class Loader: איך מחלקות נכנסות ל-JVM
טעינה כשצריך, לא מראש
הריצו את תוכנית המרפאה מהחלק הבא עם הדגל -verbose:class, וה-JVM תדפיס שורה על כל מחלקה שהיא מביאה. ב-Java 8 יצאו 415 שורות: כמעט כולן מחלקות של ספריית Java עצמה, ורק שלוש מתוך ארבע המחלקות שבקובץ. Vaccine, שהתוכנית לא באמת נזקקה לה, לא הופיעה ברשימה.
מי שעומד מאחורי כל שורה כזו הוא ה-Class Loader, הרכיב שמביא מחלקות אל ה-JVM בזמן ריצה. בשביל כל אחת הוא מאתר קובץ class, בתיקייה, בתוך jar או בין ספריות הליבה, קורא אותו והופך אותו למחלקה שה-JVM יכולה להשתמש בה.
הניסוי מראה שתי תכונות. הטעינה דינמית ועצלה: מחלקה מגיעה כשצריך אותה, בדרך כלל בשימוש הראשון, ומחלקה שלא נדרשה לא עולה כלום. ועם זאת, כל מחלקה שכן מגיעה גובה זמן, כי צריך לקרוא אותה מהדיסק, לפענח, לאמת ולהכין להרצה.
כאן נמצאת הבעיה של אפליקציות גדולות. כשכבר בעלייה נדרשות עשרות אלפי מחלקות, למשל בגלל שכבות על שכבות של ספריות, הזמן הזה מצטבר, והעלייה מתארכת.
טעויות נפוצות
- ה-Class Loader טוען את כל מחלקות האפליקציה ברגע שה-JVM עולה. מחלקה נטענת לפי הצורך, ורבות מהמחלקות לא נטענות בריצה מסוימת בכלל.
- התפקיד של ה-Class Loader הוא לאמת Bytecode, בלי לטעון אותו. התפקיד המרכזי הוא הטעינה עצמה. האימות הוא שלב אחד בהכנת המחלקה.
- ה-Class Loader מסדר את היררכיית הירושה ופותר התנגשויות בזמן ההידור. ה-Class Loader פועל בזמן ריצה. לזמן ההידור אין לו שום קשר.
- ה-Class Loader אחראי גם לנקות אובייקטים ישנים מהזיכרון. את זה עושה ה-Garbage Collector.
- ה-Class Loader יכול להפוך קובץ class בחזרה לקוד Java. שחזור קוד הוא עבודה של Decompiler, כלי חיצוני ל-JVM.
- כשיש אלפי מחלקות, העלייה איטית כי
javacנקרא שוב עבור כל אחת מהן.javacרץ בזמן הפיתוח, לא בעלייה של התוכנית. הזמן הולך על קריאה מהדיסק והכנה להרצה. - העלייה איטית כי ה-JVM פותחת thread לכל מחלקה, או כי ה-GC מנקה זיכרון עבור כל אחת. אין thread למחלקה ואין ניקוי למחלקה. העלות היא הקריאה של הקבצים והעיבוד שלהם.
שלושה שלבים: Loading, Linking, Initialization
מרגע שמחלקה נדרשת ועד שהיא מוכנה לשימוש היא עוברת שלושה שלבים, תמיד בסדר הזה.
- Loading: מאתרים את קובץ ה-class, קוראים אותו ובונים בזיכרון ייצוג של המחלקה.
- Linking: מחברים את המחלקה לשאר העולם. השלב מתחלק לשלושה: Verification, האימות שראינו בחלק הקודם; Preparation, הקצאת מקום לשדות הסטטיים וכתיבת ערכי ברירת מחדל בהם (0, false, null); ו-Resolution, החלפת הפניות סימבוליות בהפניות ממשיות.
- Initialization: הרצת ה-static initializers של המחלקה, כלומר בלוקי
staticואתחולים של שדות סטטיים, לפי הסדר שבו הם כתובים, פעם אחת בלבד.
את Resolution אפשר לראות בעיניים. אלה שתי שורות מתוך main של תוכנית המרפאה שבתרחיש בהמשך:
javap -c Clinic | grep -E "dose|Registry" 11: ldc #6 // String [c] dose 5 ml
31: invokestatic #11 // Method Registry.waiting:()Iההוראה בהיסט 31 מצביעה על רשומה 11 ב-constant pool, וברשומה יש רק טקסט: שם המחלקה Registry, שם המתודה והחתימה שלה. ב-Resolution ה-JVM מוצאת את המחלקה שנטענה בשם הזה ומחליפה את הטקסט בהפניה ישירה אליה. בשורה של [c], לעומת זאת, אין זכר ל-Vaccine: המהדר כבר הדביק את המספר 5 לתוך המחרוזת, ועל זה עוד רגע.
ההבדל בין Preparation ל-Initialization מסביר תופעה שנראית כמו באג. בתוכנית הבאה השדה הראשון קורא את השני לפני שהשני קיבל את הערך שכתוב לו בקוד:
public class Early {
static int snapshot = peek(); // runs first, before limit gets its value
static int limit = 40;
static int peek() {
return limit;
}
public static void main(String[] args) {
System.out.println("snapshot = " + snapshot);
System.out.println("limit = " + limit);
}
}snapshot = 0
limit = 40ב-Preparation קיבלו שני השדות 0. ב-Initialization האתחולים רצים מלמעלה למטה: peek() קוראת את limit כשהוא עדיין 0, ורק אחר כך limit מקבל 40.
מתי מחלקה מאותחלת? בשימוש הפעיל הראשון בה, ורק אז. שימוש פעיל הוא אחד מאלה:
- יצירת מופע ב-
new. - קריאה למתודה סטטית של המחלקה.
- קריאה של שדה סטטי, או כתיבה אליו.
- אתחול של תת-מחלקה שלה (האב מאותחל לפני הבן).
- היותה המחלקה שמפעילים בפקודה
java.
החריג המפורסם הוא קבוע: שדה static final מטיפוס פרימיטיבי או String שערכו ידוע כבר בהידור. javac מעתיק את הערך עצמו לכל מקום שמשתמש בו, כך שבזמן ריצה אין בכלל פנייה למחלקה, והיא לא מאותחלת.
תרחיש 6: מרפאה, ארבע מחלקות ושבע שורות פלט
public class Clinic {
static {
System.out.println("[a] Clinic ready");
}
public static void main(String[] args) {
System.out.println("[b] main begins");
System.out.println("[c] dose " + Vaccine.DOSE_ML + " ml");
System.out.println("[d] queue " + Registry.waiting());
new Patient();
new Patient();
System.out.println("[f] closing");
}
}
class Vaccine {
static final int DOSE_ML = 5; // compile-time constant
static {
System.out.println("Vaccine ready");
}
}
class Registry {
static {
System.out.println("[d0] Registry ready");
}
static int waiting() { return 12; }
}
class Patient {
static {
System.out.println("[e] Patient ready");
}
}[a] Clinic ready
[b] main begins
[c] dose 5 ml
[d0] Registry ready
[d] queue 12
[e] Patient ready
[f] closingClinicהיא המחלקה שהופעלה, ולכן היא מאותחלת לפני ש-mainמתחילה.[a]מודפסת ראשונה.[b]מגיעה מ-mainעצמה.Vaccine.DOSE_MLהוא קבוע של זמן הידור. המספר 5 הועתק לתוךClinic, ולכןVaccineלא מאותחלת, והשורהVaccine readyלא מופיעה בכלל.- כדי להרכיב את שורה
[d]צריך קודם לקרוא ל-Registry.waiting(). זו קריאה למתודה סטטית, כלומר שימוש פעיל, ולכן[d0]מודפסת לפני[d]עצמה. - ה-
new Patient()הראשון מאתחל אתPatientומדפיס[e]. השני לא מדפיס דבר: אתחול קורה פעם אחת למחלקה.
כשמריצים את אותה תוכנית עם הדגל -verbose:class, ה-JVM מדווחת על כל מחלקה שהיא טוענת. ברשימה מופיעות Clinic, Registry ו-Patient, ו-Vaccine לא מופיעה בכלל: היא אפילו לא נטענה, לא רק לא אותחלה.
טעויות נפוצות
- ב-Linking רצים בלוקי ה-static ונבנה המופע הראשון של המחלקה. בלוקי static רצים ב-Initialization. אף שלב בטעינה לא יוצר מופע; מופע נוצר רק ב-
new. - ב-Linking ה-Bytecode הופך לקוד מכונה. ב-Linking מאמתים, מכינים את השדות הסטטיים ומחליפים שמות בהפניות. תרגום לקוד מכונה הוא עבודה של ה-JIT, ומגיע הרבה אחר כך, ורק לקוד שרץ הרבה.
- ב-Linking נבדקת החתימה הדיגיטלית של קובץ ה-jar והמחלקה מקבלת הרשאות. שלושת תת-השלבים של Linking הם Verification, Preparation ו-Resolution, ואף אחד מהם לא עוסק בחתימות.
- עוד לפני ש-
mainמתחילה, כל מחלקה בתוכנית כבר מאותחלת. לפניmainמאותחלת רק המחלקה הראשית. כל מחלקה אחרת מאותחלת בשימוש הפעיל הראשון בה.
בדקו את עצמכם
בתרחיש המרפאה מוסיפים לפני [f] את השורה System.out.println(Registry.waiting());. כמה פעמים תודפס [d0] Registry ready?
פעם אחת. המחלקה כבר אותחלה בקריאה הקודמת, והאתחול לא חוזר.
אם DOSE_ML הייתה מוגדרת static int DOSE_ML = 5;, בלי final, מה היה משתנה בפלט?
השדה כבר לא היה קבוע של זמן הידור, ולכן קריאתו הייתה שימוש פעיל. Vaccine ready הייתה מודפסת מיד אחרי [b], לפני שורה [c].
במחלקה יש static boolean ready = true;. מה הערך של ready בין Preparation ל-Initialization?
false, ערך ברירת המחדל שנכתב ב-Preparation. הערך true נכתב רק ב-Initialization.
שרשרת ה-Loaders והכלל: קודם שואלים את ההורה
ל-JVM אין Class Loader יחיד אלא כמה, והם מסודרים בשרשרת של הורה וילד. לכל אחד מהם יש תחום אחריות.
| Loader | תחום האחריות |
|---|---|
| Bootstrap | ליבת Java: java.lang.String, java.lang.Object ושאר המחלקות הבסיסיות. הוא ממומש בתוך ה-JVM עצמה |
| Platform (עד Java 8 נקרא Extension) | מודולים נוספים של הפלטפורמה |
| Application (שם נוסף: System) | המחלקות שלכם ושל הספריות שלכם, לפי ה-classpath |
אפשר לראות את השרשרת מתוך הקוד. התוכנית הבאה שואלת מי טען אותה, מי ההורה שלו, ומי טען את String:
public class WhoLoaded {
public static void main(String[] args) {
ClassLoader app = WhoLoaded.class.getClassLoader();
System.out.println("WhoLoaded -> " + app.getClass().getName());
System.out.println("its parent -> " + app.getParent().getClass().getName());
System.out.println("parent of that -> " + app.getParent().getParent());
System.out.println("String -> " + String.class.getClassLoader());
}
}ב-Java 8:
java WhoLoadedWhoLoaded -> sun.misc.Launcher$AppClassLoader
its parent -> sun.misc.Launcher$ExtClassLoader
parent of that -> null
String -> nullוב-Java 17:
java WhoLoadedWhoLoaded -> jdk.internal.loader.ClassLoaders$AppClassLoader
its parent -> jdk.internal.loader.ClassLoaders$PlatformClassLoader
parent of that -> null
String -> nullnull מייצג כאן את ה-Bootstrap, שאינו אובייקט Java אלא חלק מה-JVM. רואים גם את השינוי בשם: ב-Java 8 ההורה הוא ExtClassLoader, ובגרסאות החדשות PlatformClassLoader.
הפלט מראה שרשרת, אבל לא איך משתמשים בה. הכלל נקרא האצלה להורה (parent delegation): בקשה לטעון מחלקה מגיעה ל-Application Loader, וזה, לפני שהוא מחפש משהו בעצמו, מעביר אותה כלפי מעלה עד ה-Bootstrap. רק כשהבקשה חוזרת בלי תשובה, כל Loader בתורו מנסה בתחום שלו, מלמעלה למטה.
שאלה ראשונה שהכלל עונה עליה: מה יקרה אם מישהו ישתול ב-classpath מחלקה מזויפת ששמה המלא java.lang.String? הבקשה ל-String מגיעה ל-Bootstrap עוד לפני שמישהו מציץ ב-classpath, וה-Bootstrap מחזיר את המחלקה האמיתית שכבר טעונה אצלו. הזיוף פשוט לא מגיע לתור.
שאלה שנייה: מה קורה כשאותה מחלקה, באותו שם מלא, נמצאת פעמיים ב-classpath? התשובה בתרחיש הבא.
תרחיש 7: שתי גרסאות של אותה ספרייה ב-classpath
בשני קובצי jar יש מחלקה בשם המלא org.shipco.Rates, ולכל גרסה מחרוזת אחרת. האפליקציה Checkout מדפיסה את המחרוזת.
// inside shipping-1.4.jar
package org.shipco;
public class Rates {
public static String edition() { return "rates 1.4"; }
}
// inside shipping-2.0.jar: same full name, different body
package org.shipco;
public class Rates {
public static String edition() { return "rates 2.0"; }
}
// app/Checkout.java
public class Checkout {
public static void main(String[] args) {
System.out.println(org.shipco.Rates.edition());
}
}java -cp "app;shipping-1.4.jar;shipping-2.0.jar" Checkout
java -cp "app;shipping-2.0.jar;shipping-1.4.jar" Checkoutrates 1.4
rates 2.0- הבקשה ל-
org.shipco.Ratesעוברת מה-Application Loader ל-Platform ומשם ל-Bootstrap. אף אחד מהם לא מכיר אותה, והיא חוזרת למטה. - ה-Application Loader סורק את ה-classpath משמאל לימין ועוצר בהתאמה הראשונה.
- החלפת סדר הרשומות היא הדבר היחיד ששינה את התוצאה. תאריך הקובץ ומספר הגרסה לא משחקים תפקיד, אין מיזוג בין שני העותקים, ואף אחד לא מתריע על הכפילות.
; ב-Windows ו-: ב-Linux וב-macOS.טעויות נפוצות
Stringהמזויף נחסם כי ה-JVM בודקת חתימה דיגיטלית לכל מחלקה. אין בדיקת חתימה. הבקשה ל-Stringמגיעה ל-Bootstrap לפני שמישהו מסתכל ב-classpath, וזו ההגנה.- המאמת מזהה את
Stringהמזויף ומחליף אותו בגרסה האמיתית. המאמת בודק אם הקוד חוקי, לא אם הוא המחלקה "הנכונה". והקובץ המזויף בכלל לא מגיע לשלב הטעינה. - מחלקות מה-classpath נטענות רק אחרי שמערכת ההפעלה מאשרת אותן. מערכת ההפעלה לא מעורבת בבחירת מחלקות. זו החלטה פנימית של ה-JVM.
- ה-Loader מתחיל בחיפוש אצלו, ומבין שתי מחלקות זהות בוחר את זו שהקובץ שלה חדש יותר. הוא מתחיל בהורה. וב-classpath, מה שקובע הוא המיקום ברשימה בלבד.
- שתי מחלקות עם אותו שם מלא ב-classpath גורמות לשגיאת טעינה. אין שום שגיאה. הראשונה נטענת והשנייה מתעלמים ממנה.
ClassNotFoundException מול NoClassDefFoundError
מערכת שטוענת תוספים לפי שם שכתוב בקובץ הגדרות לא יודעת בזמן ההידור איזו מחלקה תצטרך. היא מעבירה את השם ל-Class.forName, וזה מה שקורה כשהשם לא מוביל לשום מקום:
public class PluginHost {
public static void main(String[] args) {
String name = "org.plugins.PdfExport"; // read from a config file in real life
try {
Class<?> plugin = Class.forName(name);
System.out.println("loaded " + plugin.getName());
} catch (ClassNotFoundException e) {
System.out.println("not on the classpath: " + e.getMessage());
}
}
}not on the classpath: org.plugins.PdfExportמה שנתפס הוא ClassNotFoundException: ה-Class Loader חיפש מחלקה בשם הזה ולא מצא. כמעט תמיד הסיבה היא שהמחלקה לא נמצאת באף רשומה של ה-classpath, כי ה-jar שלה לא צורף להפעלה או כי נפלה שגיאת כתיב בשם, כולל בשם החבילה. החריג הוא מסוג checked, ולכן הקומפיילר דורש לטפל בו סביב Class.forName.
NoClassDefFoundError היא האחות שלה. כאן המחלקה כן הייתה זמינה כשהידרו, ולכן ההידור עבר, אבל בזמן הריצה היא איננה. נחזור ל-Checkout מהתרחיש הקודם, שהודר מול shipping-1.4.jar, ונריץ אותו בלי אף אחד משני ה-jar:
java -cp "app" CheckoutException in thread "main" java.lang.NoClassDefFoundError: org/shipco/Rates
at Checkout.main(Checkout.java:3)
Caused by: java.lang.ClassNotFoundException: org.shipco.Rates
at java.net.URLClassLoader.findClass(URLClassLoader.java:387)
at java.lang.ClassLoader.loadClass(ClassLoader.java:418)
at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:352)
at java.lang.ClassLoader.loadClass(ClassLoader.java:351)
... 1 moreה-JVM ניסתה לקשר את הקריאה ל-Rates.edition() שכתובה בקוד המהודר, ולא מצאה את המחלקה. ב-Java 8 רואים בשורת ה-Caused by שגם כאן, מתחת לפני השטח, החיפוש של ה-Loader נכשל באותה צורה.
| ClassNotFoundException | NoClassDefFoundError | |
|---|---|---|
| מה קרה | בקשה מפורשת לטעון מחלקה לפי שם, למשל Class.forName, לא מצאה אותה | מחלקה שהקוד המהודר תלוי בה חסרה בזמן הריצה |
| היה זמין בהידור? | לא רלוונטי: השם מגיע בזמן ריצה | כן, אחרת ההידור היה נכשל |
| סוג | חריגה (Exception), checked | שגיאה (Error) |
טעויות נפוצות
ClassNotFoundExceptionנגרמת כשהמחסנית מתמלאת בזמן הטעינה. מחסנית שהתמלאה גורמת ל-StackOverflowError. כאן הבעיה היא שהמחלקה לא נמצאה.ClassNotFoundExceptionמעידה שה-JIT עמוס מדי. ה-JIT לא משתתף בכלל בטעינת מחלקות.ClassNotFoundExceptionמופיעה כשקובץ ה-class לא מתאים לסוג המעבד. Bytecode לא קשור לסוג מעבד. ואם הבעיה היא גרסת הקובץ, השגיאה תהיהUnsupportedClassVersionError.
נקודת הכניסה: main
החתימה של main, ולמה היא חייבת להיות static
נלך אחורה מהשורה הראשונה של main. היא רצה על thread ששמו "main"; לפניה רצו בלוקי ה-static של המחלקה, כחלק מה-Initialization שלה; לפני כן המחלקה עברה Linking; ולפני הכול ה-Application Loader טען אותה, מיד אחרי שה-JVM עלתה.
ה-launcher מחפש מתודה בחתימה מדויקת אחת:
public static void main(String[] args)| חלק | למה הוא שם |
|---|---|
public | ה-launcher של Java נמצא מחוץ למחלקה, והוא צריך להיות מורשה לקרוא למתודה |
static | בתחילת התוכנית אין אף אובייקט. הקריאה ל-main חייבת להיות דרך המחלקה, בלי מופע |
void | המתודה לא מחזירה ערך. קוד יציאה אחר מ-0 קובעים ב-System.exit(n) |
String[] args | המילים שהופיעו בשורת הפקודה. הכתיב String... args שקול לגמרי |
השם לבדו לא מספיק. אפשר להוסיף למחלקה עוד מתודות main עם רשימות פרמטרים אחרות (overload); הן חוקיות לגמרי ונקראות כמו כל מתודה, אבל ה-launcher מתעלם מהן ומחפש רק את הגרסה עם מערך המחרוזות.
תרחיש 8: main שנשכח בה static
public class Greeter {
public void main(String[] args) {
String word = "shalom";
System.out.println(word);
}
}javac Greeter.java מסיים בלי שגיאה. ההפעלה, לעומת זאת:
java GreeterError: Main method is not static in class Greeter, please define the main method as:
public static void main(String[] args)shalomלא מודפס. קוד היציאה של התהליך הוא 1.- אותה הודעה בדיוק התקבלה ב-Java 8, ב-Java 17 וב-Java 21.
- ה-JVM לא מנסה לעקוף את הבעיה: היא לא בונה אובייקט של
Greeterכדי לקרוא דרכו, לא זורקתNullPointerException, ולא מדפיסה אזהרה וממשיכה.
למה ההידור עבר? כי ל-javac אין שום כלל מיוחד ל-main: מבחינתו זו מתודת מופע רגילה שבמקרה נקראת כך. מי שמכיר את החתימה הנדרשת הוא ה-launcher, והוא בודק אותה רק ברגע ההפעלה.
טעויות אחרות בחתימה מקבלות הודעות משלהן. כשחסר public, או כשהפרמטר הוא String בודד במקום מערך, ה-launcher לא מזהה בכלל נקודת כניסה:
java GreeterError: Main method not found in class Greeter, please define the main method as:
public static void main(String[] args)
or a JavaFX application class must extend javafx.application.Applicationוכשהמתודה מחזירה int, ההודעה היא Main method must return a value of type void. בכל המקרים ההידור עבר.
main של מופע ומותר main בלי פרמטרים. שאלה שמציינת גרסה בין 8 ל-24, או שמבקשת להניח את הכללים הקלאסיים, מתכוונת להתנהגות שבתרחיש.טעויות נפוצות
mainהיא static כדי שתרוץ מהר יותר. למילה static אין קשר למהירות. הסיבה היא שבתחילת התוכנית עדיין אין אובייקט לקרוא דרכו.mainהיא static כדי שתוכל לגשת לשדות של המופע בלי לבנות אובייקט. זה בדיוק מה שמתודה סטטית לא יכולה לעשות. כדי לגשת לשדה מופע צריך אובייקט.- בשלב ההידור
javacיוצר מופע שלGreeter, ודרכו מפעיל אתmain.javacלא בונה אובייקטים ולא מריץ שום קוד. mainבלי static נכשלת כבר בהידור. ההידור מצליח. ההפעלה היא שנכשלת.- ההפעלה נכשלת כי למחלקה אין בנאי ציבורי מפורש. בנאי לא רלוונטי כאן. מה שחסר הוא
mainבחתימה הנכונה.
המערך args
התוכנית הבאה מדפיסה את כל מה שקיבלה בשורת הפקודה, ונריץ אותה פעמיים: עם שלוש מילים ובלי אף אחת.
public class Route {
public static void main(String... args) { // same entry point as String[]
System.out.println("stops: " + args.length);
for (int i = 0; i < args.length; i++) {
System.out.println("args[" + i + "] = " + args[i]);
}
System.out.println(main(7)); // an overload, called like any method
if (args.length == 0) {
System.exit(3); // exit code chosen by the program
}
}
static String main(int n) {
return "overload got " + n;
}
}תרחיש 9: אותה תוכנית, עם ובלי ארגומנטים
java Route haifa acre eilat
echo $?stops: 3
args[0] = haifa
args[1] = acre
args[2] = eilat
overload got 7
0java Route
echo $?stops: 0
overload got 7
3- בהרצה הראשונה
haifaיושב באינדקס 0 ו-eilatבאינדקס 2. ניסיון לקרואargs[3]היה נגמר ב-ArrayIndexOutOfBoundsException. - בהרצה השנייה הלולאה לא מתבצעת אפילו פעם אחת, כי
args.lengthהוא 0, ואין חריגה. - החתימה
String... argsהתקבלה כנקודת כניסה, וה-mainעם הפרמטר int נקראה כמו כל מתודה רגילה. - קוד היציאה 3 הגיע מ-
System.exit(3). בלי הקריאה הזו, תוכנית שמסתיימת כרגיל יוצאת עם 0.
מה שתי ההרצות מלמדות: args מקבל רק את המילים שאחרי שם המחלקה, משמאל לימין, והראשונה ב-args[0]. בניגוד ל-argv[0] של C, שם התוכנית לא נכנס. ובלי מילים בכלל מקבלים מערך באורך 0 ולא null, כך שהבדיקה args.length לעולם לא תזרוק.
טעויות נפוצות
- ב-Java,
args[0]מכיל את שם התוכנית או את שם המחלקה.args[0]הוא הארגומנט הראשון שאחרי שם המחלקה. בזה Java שונה מ-C. args.lengthגדול באחד ממספר הארגומנטים, כי שם המחלקה נספר. שם המחלקה לא נספר. האורך שווה בדיוק למספר המילים שאחרי שם המחלקה.- כשמפעילים בלי ארגומנטים,
argsהואnull. מקבלים מערך ריק באורך 0.
בדקו את עצמכם
מריצים java Backup daily /var/data והתוכנית מדפיסה args[0] + "|" + args.length. מה מודפס?
daily|2. שם המחלקה לא נמצא במערך, ויש בו שתי מילים.
ובאותה הרצה, מה ידפיס args[args.length - 1]?
/var/data, האיבר באינדקס 1, שהוא האחרון.
Main ב-C# ומה ה-CLR עושה איתה
ב-C# נתחיל מתוכנית שעובדת ונגזור ממנה את הכללים:
using System;
class Kiosk
{
static int Main(string[] args) // private by default, still the entry point
{
Console.WriteLine("args: " + args.Length);
if (args.Length > 0)
{
Console.WriteLine("first: " + args[0]);
return 0;
}
return 4; // becomes the process exit code
}
}dotnet run -- tel-aviv jaffa
echo $?
dotnet run
echo $?args: 2
first: tel-aviv
0
args: 0
4שלושה דברים עולים מההרצות. המתודה נקראת Main עם M גדולה ומוגדרת static; היא מחזירה int, והמספר שהחזירה הפך לקוד היציאה של התהליך, 0 בהרצה הראשונה ו-4 בשנייה; ו-args קיבל רק את שתי המילים, בלי שם התוכנית.
ויש דבר אחד שלא כתוב בה: מילת הרשאה. חבר מחלקה בלי הרשאה הוא private ב-C#, כך ש-Main הזו פרטית, וזה לא מפריע לה להיות נקודת הכניסה.
int אינו האפשרות היחידה. אלה הצורות שהקומפיילר מקבל:
static void Main()
static int Main()
static async Task Main() // async forms: C# 7.1 and later
static async Task<int> Main()
// each of the four may also declare one parameter: string[] argsעכשיו הצד השני. ב-C# הקומפיילר עצמו מחפש נקודת כניסה, ולכן חתימה שגויה נעצרת כבר בהידור, בשגיאה CS5001, ולא מגיעה לשלב ההפעלה כמו ב-Java.
תרחיש 10: שלוש מחלקות Kiosk שלא מתקמפלות
// Instance.cs
class Kiosk
{
void Main(string[] args) { } // instance method: not an entry point
}
// ReturnsText.cs
class Kiosk
{
static string Main(string[] input) // string is not an allowed return type
{
return "welcome";
}
}
// JavaStyle.cs
class Kiosk
{
public static void main(string[] args) { } // lowercase m
}כל קובץ הודר לבד במהדר csc (דגלי ההפניה לספריות הושמטו מהפקודות). המהדר דחה את שלושתם באותה שגיאה, ובמקרה של string הוסיף אזהרה שמסבירה מה לא בסדר:
csc Instance.cserror CS5001: Program does not contain a static 'Main' method suitable for an entry pointcsc ReturnsText.csReturnsText.cs(3,19): warning CS0028: 'Kiosk.Main(string[])' has the wrong signature to be an entry point
error CS5001: Program does not contain a static 'Main' method suitable for an entry pointהקובץ השלישי מראה שהרגל של Java לא עובר: main באות קטנה היא סתם מתודה בשם אחר, ולכן אין נקודת כניסה.
ההידור עבר, ומה הלאה? בזמן הריצה ה-CLR טוען את ה-assembly, ומתודה מתורגמת מ-CIL לקוד מכונה רק כשמגיעה הקריאה הראשונה אליה; הפרטים בחלק על JIT.
ובגרסאות חדשות אפשר לוותר על Main לגמרי. מאז C# 9 מותר לכתוב פקודות ישירות בראש קובץ אחד (top-level statements), והקומפיילר עוטף אותן בעצמו במתודת כניסה.
טעויות נפוצות
- ב-C# מותר ש-
Mainתהיה מתודת מופע.Mainחייבת להיות static, אחרת ההידור נכשל ב-CS5001. Mainב-C# יכולה להחזיר כל טיפוס, למשל string. מותרים רק void, int, Task ו-Task<int>.- גם ב-C# שם נקודת הכניסה הוא
main, באותיות קטנות. רקMainעם M גדולה היא נקודת כניסה. Mainחייבת להיות public, אחרת ה-CLR לא יוכל לקרוא לה.Mainפרטית היא ברירת המחדל ועובדת מצוין.
Interpreter: מריצים את הקוד תוך כדי קריאה
Interpreter מול מהדר, והלולאה שבלב הפירוש
דמיינו שני מתרגמים בכנס. האחד מקבל את הנאום כתוב יום מראש ומגיש למחרת עותק מתורגם ומודפס; השני עומד ליד הנואם ומתרגם משפט אחרי משפט, בזמן אמת. הראשון עובד כמו מהדר, השני כמו Interpreter (מפרש).
מהדר (compiler) עובר על התוכנית כולה לפני שמשהו מתחיל לרוץ ומייצר ממנה תוצר: קוד מכונה, כמו אצל gcc, או Bytecode, כמו אצל javac. את התוכנית עצמה הוא לא מפעיל. מפרש, לעומתו, לא משאיר אחריו שום קובץ הרצה: הוא מתקדם בתוכנית תוך כדי הריצה ומבצע כל הוראה כשהוא מגיע אליה.
ומה המפרש קורא? לפעמים טקסט מקור גולמי: סקריפט shell, למשל, מתבצע בדרך כלל שורה אחרי שורה, וכל ביטוי בו מחושב רק כשמגיעים אליו. ולפעמים קוד ביניים: ה-Interpreter של HotSpot ולולאת הביצוע של CPython צועדים על Bytecode, הוראה אחת בכל צעד.
| סביבה | מה מהדרים | מה מפרשים |
|---|---|---|
| Java | javac מתרגם את המקור ל-Bytecode, ובזמן הריצה ה-JIT של ה-JVM הופך לקוד מכונה את מה שהתחמם | ה-JVM מפרשת את ה-Bytecode עד שהקוד מתחמם |
| CPython | המקור מתורגם ל-Bytecode של CPython עצמה | אותו Bytecode מבוצע על ידי הלולאה של CPython |
| מנועי JavaScript | קוד חם עובר JIT בהמשך הריצה | בהתחלה הקוד מפורש |
בלב כל מפרש של Bytecode יש לולאה. הדרך הקלה להבין אותה היא לכתוב אחת: הנה מכונת מחסנית זעירה בפייתון, עם שש הוראות בלבד, שאחת מהן קופצת אחורה:
# A toy stack machine: the same fetch, decode, execute cycle a bytecode interpreter runs
program = [
("push", 0), # 0: counter
("push", 1), # 1
("add", None), # 2: counter += 1
("dup", None), # 3
("jump_if_less", (3, 1)), # 4: if counter < 3 go back to index 1
("show", None), # 5
]
stack, pc, decoded = [], 0, 0
while pc < len(program):
op, arg = program[pc] # fetch
decoded += 1 # every visit pays for decoding again
if op == "push":
stack.append(arg)
elif op == "add":
b, a = stack.pop(), stack.pop()
stack.append(a + b)
elif op == "dup":
stack.append(stack[-1])
elif op == "jump_if_less":
limit, target = arg
if stack.pop() < limit:
pc = target
continue
elif op == "show":
print("counter =", stack[-1], "| instructions decoded:", decoded)
pc += 1counter = 3 | instructions decoded: 14בתוכנית יש שש הוראות, אבל הלולאה פענחה 14: ההוראה הראשונה פעם אחת, ההוראות 1 עד 4 שלוש פעמים כל אחת, והאחרונה פעם אחת. שרשרת ה-if וה-elif היא הפענוח, והיא רצה מחדש בכל ביקור בהוראה, גם אם כבר ראתה אותה קודם.
ה-Interpreter Loop של ה-JVM עושה את אותו מחזור בקנה מידה אמיתי: מביא את הוראת ה-Bytecode הבאה, מברר מה היא דורשת, ומבצע. הלולאה הזו פעילה מההוראה הראשונה של main, הרבה לפני שה-JIT הספיק להדר משהו.
ב-JVM, ברגע שקטע קוד הודר ב-JIT, הוא רץ ישירות על המעבד ואינו עובר יותר דרך הלולאה הזו. לולאת הפירוש גם אינה אחראית לטעינת קבצים או לפינוי זיכרון: את אלה עושים ה-Class Loader וה-Garbage Collector.
טעויות נפוצות
- Interpreter קודם ממיר את כל התוכנית לקוד מכונה ורק אז מתחיל להריץ. זה תיאור של הידור מראש. ה-Interpreter לא מייצר קוד מכונה בכלל; הוא מבצע תוך כדי קריאה.
- אחרי שהקוד תורגם ל-Bytecode, הוא כבר רץ בלי פירוש. ביצוע ה-Bytecode הוא בדיוק מה שה-Interpreter עושה. מישהו צריך לקרוא כל הוראת Bytecode ולבצע אותה, וזה הפירוש.
- ה-Interpreter מאתר את הפונקציות שנקראות הכי הרבה ומקמפל רק אותן. זו העבודה של JIT. ה-Interpreter רק מבצע (ב-HotSpot הוא גם סופר, אבל ההידור נעשה על ידי מהדר ה-JIT).
- תפקיד המפרש הוא לייצר קובץ בינארי אחד שמתאים לכל המחשבים, לכווץ את קובץ ההרצה או לסרוק קוד זדוני. אף אחד מאלה. התפקיד שלו הוא אחד: לבצע את הקוד.
- ה-Interpreter Loop הוא מה שמריץ את קוד המכונה שה-JIT הפיק. קוד מהודר רץ על המעבד בעצמו. הלולאה מטפלת רק בקוד שעדיין לא הודר.
- ה-Interpreter Loop גם אוסף זבל וגם טוען קובצי class מהדיסק. אלה רכיבים אחרים של ה-JVM: ה-Garbage Collector וה-Class Loader.
- המפרש של פייתון מתרגם את הקוד ל-Bytecode של Java ומעביר אותו ל-JVM. CPython מגדירה Bytecode משלה ומבצעת אותו בלולאה שלה. אין שום JVM בתמונה.
מאיפה מגיעה האיטיות: פענוח שחוזר בכל ביצוע
כשהמעבד מריץ קוד מכונה, אין שלב של בירור: ההוראה כבר כתובה בשפה שלו. ה-Interpreter, לעומת זאת, צריך לגלות מחדש מה כל הוראת Bytecode אומרת בכל פעם שהוא מגיע אליה, בדיוק כמו שרשרת ה-elif במכונה הזעירה.
בלולאה זה מצטבר. אם גוף הלולאה מכיל 12 הוראות והיא רצה 40 מיליון פעמים, ה-Interpreter מבצע 480 מיליון פענוחים, אף שהוא פוגש שוב ושוב את אותן 12 הוראות. זו התקורה של פירוש, ולכן לולאה ארוכה רצה לאט יותר לפני הידור מאשר אחריו.
כשמחפשים את הסיבה, קל לחשוד בדברים אחרים שה-JVM עושה. כדאי לדעת מתי כל אחד מהם קורה באמת:
| החשוד | מתי זה קורה בפועל | אז האם זו הסיבה? |
|---|---|---|
| קריאת קובץ ה-class מהדיסק | פעם אחת, כשהמחלקה נטענת | לא |
| אימות ה-Bytecode (Verification) | פעם אחת, בשלב Linking של הטעינה | לא |
| הידור קוד המקור | לפני הריצה, ב-javac; ה-JVM בכלל לא רואה קוד מקור | לא |
| המתנה ל-JIT | אף פעם: ב-HotSpot ההידור רץ ב-threads נפרדים ברקע, וה-Interpreter ממשיך לעבוד עד שהגרסה המהודרת מוכנה | לא |
| בניית מחסנית הקריאות, שמירת משתנים בקובץ זמני, ריצה על ליבה אחת | לא קורה בכל איטרציה, ולא קשור לפירוש | לא |
| פענוח של כל הוראה | בכל ביצוע של כל הוראה | כן |
תרחיש 11: אותה לולאה, פעם עם JIT ופעם בפירוש בלבד
המתודה checksum מסכמת את k & 7 עבור 40 מיליון ערכים של k. ה-main מריץ אותה ארבע פעמים ומודד כל מעבר:
public class Meter {
static long checksum(int count) {
long acc = 0;
for (int k = 0; k < count; k++) {
acc += k & 7; // a tiny body that runs on every iteration
}
return acc;
}
public static void main(String[] args) {
for (int pass = 1; pass <= 4; pass++) {
long t0 = System.nanoTime();
long r = checksum(40_000_000);
long ms = (System.nanoTime() - t0) / 1_000_000;
System.out.println("pass " + pass + ": " + ms + " ms, checksum " + r);
}
}
}הפעלה רגילה ב-Java 8, כלומר Interpreter ו-JIT יחד:
java Meterpass 1: 74 ms, checksum 140000000
pass 2: 60 ms, checksum 140000000
pass 3: 96 ms, checksum 140000000
pass 4: 63 ms, checksum 140000000ועכשיו עם הדגל -Xint, שמשאיר את ה-JVM במצב פירוש בלבד:
java -Xint Meterpass 1: 1641 ms, checksum 140000000
pass 2: 1409 ms, checksum 140000000
pass 3: 1488 ms, checksum 140000000
pass 4: 1641 ms, checksum 140000000התוצאה זהה בשני המצבים, אבל הזמן שונה בסדר גודל: פירוש בלבד איטי כאן בערך פי עשרים. המספרים המדויקים ישתנו אצלכם, היחס יישאר דומה.
לפי javap -c, גוף הלולאה הוא 12 הוראות, מ-iload_3 דרך iand ו-ladd ועד goto. ב--Xint כל אחת מהן מפוענחת מחדש 40 מיליון פעמים בכל מעבר.
טעויות נפוצות
- בפירוש, כל הוראה נבדקת שוב על ידי ה-Verifier לפני שהיא רצה. האימות נעשה פעם אחת לכל מחלקה, בזמן הטעינה. בזמן הביצוע נשאר רק הפענוח.
- ה-Interpreter עוצר בכל סיבוב של הלולאה ומחכה שה-JIT יסיים. ה-JIT עובד ב-threads משלו. עד שהגרסה המהודרת מוכנה, ה-Interpreter פשוט ממשיך לרוץ.
- הלולאה איטית כי ה-JVM קוראת את Meter.class מהדיסק בכל איטרציה. הקובץ נקרא פעם אחת, כשהמחלקה נטענת. משם ה-Bytecode נמצא בזיכרון.
מה מרוויחים מפירוש, ומתי JIT לא שווה את המחיר
כדי להבין מתי פירוש משתלם, השוו שתי עבודות שרצות על אותה JVM: כלי קטן ששולף שורה אחת מקובץ לוג ומסיים בתוך שנייה, ושרת הזמנות שמטפל באותו סוג בקשה מיליוני פעמים לאורך חודש.
בכלי הקטן כמעט שום קוד לא חוזר על עצמו מספיק פעמים כדי להתחמם. הידור ב-JIT היה גובה ממנו זמן מעבד וזיכרון, ולא הייתה לו שום הזדמנות להחזיר את ההוצאה, ולכן פירוש לבדו מתאים לו בדיוק.
בשרת המצב הפוך: כל דקה של הידור מתחלקת על מיליוני ביצועים. כך גם בנצ'מרק שמחפש את המהירות המרבית של פונקציה, וברקורסיה עמוקה שנכנסת לאותה פונקציה אינספור פעמים. בכל אלה ה-JIT מחזיר את ההשקעה פי כמה.
ומה נותן הפירוש עצמו, מלבד החיסכון בהידור? שלושה דברים:
- אפס המתנה: הקוד רץ ברגע שמפעילים אותו, בלי שלב הכנה.
- ניידות זולה: כדי לעבור לפלטפורמה חדשה לא נוגעים בקוד של התוכנית; העבודה היחידה היא לכתוב Interpreter לאותה פלטפורמה.
- מחזור עבודה קצר: בניפוי באגים מתקנים שורה ומריצים שוב מייד, בלי לחכות להידור. ה-REPL של פייתון, שבו כל שורה מבוצעת ברגע שנכתבה, בנוי על התכונה הזו.
למדיניות של "מבצעים רק את מה שמגיעים אליו" יש גם מחיר: גם הגילוי של חלק מהשגיאות נדחה. בשפה דינמית כמו פייתון, טעות בשורה שעוד לא רצה לא ידועה לאף אחד:
תרחיש 12: קריאה לפונקציה שלא קיימת, בענף שלא רץ
disk_free_gb = 40
if disk_free_gb < 10:
send_low_disk_alert() # this name is never defined anywhere
print("backup finished")backup finishedהפונקציה send_low_disk_alert לא מוגדרת בשום מקום, ובכל זאת התוכנית הסתיימה בשלום. התנאי שקרי, השורה השלישית לא בוצעה, ואף אחד לא בדק את השם.
שומרים עותק בשם backup_low.py שבו הערך בשורה הראשונה הוא 4, ולכן התנאי מתקיים. כדי שההודעה תהיה קצרה, מעבירים את הקובץ לפייתון דרך הקלט הרגיל, ולכן שם הקובץ בהודעה הוא <stdin>:
python - < backup_low.pyTraceback (most recent call last):
File "<stdin>", line 3, in <module>
NameError: name 'send_low_disk_alert' is not definedשימו לב שזו NameError, לא SyntaxError: הקוד תקין תחבירית בשני המקרים. CPython אמנם מהדרת את כל הקובץ ל-Bytecode לפני שהיא מתחילה, אבל ההידור הזה בודק תחביר בלבד ולא את קיומם של שמות.
ההבדל ניכר כשיש שגיאת תחביר אמיתית. בקובץ broken.py חסרות נקודתיים, ולכן ההידור נכשל עוד לפני ההוראה הראשונה, וגם starting לא מודפס:
print("starting")
if True
print("never reached")python - < broken.py File "<stdin>", line 2
if True
^
SyntaxError: expected ':'טעויות נפוצות
- מפרש תופס את כל שגיאות התוכנית עוד לפני שהיא מתחילה לרוץ. שגיאות כמו שם לא מוגדר מתגלות רק כשהשורה מבוצעת, כפי שראיתם בגיבוי שהסתיים בשלום.
- קל לנפות באגים עם מפרש כי הוא מריץ מהר יותר מקוד מהודר. הוא דווקא איטי יותר. היתרון בניפוי הוא שאפשר לתקן ולהריץ שוב מייד, בלי סבב הידור.
- המפרש שומר קובץ בינארי שאפשר לפתוח בכלי ניפוי. מפרש לא מייצר קובץ הרצה. הוא מבצע את הקוד ישירות.
- לשרת שרץ חודשים עדיף להסתפק ב-Interpreter. דווקא שם JIT משתלם יותר מכול, כי אותו קוד רץ שוב ושוב לאורך זמן רב.
בדקו את עצמכם
כלי Java קטן בודק את התקינות של קובץ הגדרות ומסיים בתוך כשלוש עשיריות השנייה, כולל עליית ה-JVM. כמה הוא ירוויח מה-JIT?
כמעט כלום. בזמן קצר כל כך כמעט אף מתודה לא חוצה את סף החום, רוב העבודה נעשית ב-Interpreter, וגם אילו משהו היה מהודר, ההידור לא היה מספיק להחזיר את הזמן שהושקע בו.
למה סקריפט פייתון יכול לעבור בהצלחה מאות הרצות ואז להיכשל ב-NameError בפעם הראשונה שמגיע קלט חריג?
כי קיום של שמות נבדק רק כשהשורה מבוצעת. הקלט החריג הוביל לענף שעוד לא רץ, ורק אז השגיאה שבו נחשפה.
JIT: קוד מכונה שנוצר בזמן הריצה
מה JIT עושה, מי מבצע אותו, והיכן הקוד המהודר חי
חזרו למדידות של Meter: בהפעלה רגילה כל מעבר לקח פחות מ-100 ms, ועם -Xint קרוב לשנייה וחצי. את ההפרש עשה JIT (Just-In-Time): כשהתוכנית כבר רצה, ה-Bytecode של checksum הפך לקוד מכונה, ברגע שהתברר שהיא נחוצה הרבה.
מי ביצע את התרגום? מהדר ה-JIT שיושב בתוך מנוע ההרצה של ה-JVM. javac סיים את חלקו עוד לפני ההפעלה, ומערכת ההפעלה והמעבד רק מריצים את התוצאה; הם לא יודעים מה זה Bytecode.
קוד המכונה החדש יושב ב-code cache, אזור בזיכרון של תהליך ה-JVM, וכל קריאה נוספת ל-checksum באותה הפעלה משתמשת בו. כשהתהליך נסגר האזור נעלם איתו: דבר לא נכתב ל-Meter.class או לשום קובץ אחר, והפעלה נוספת של Meter תהדר את checksum שוב מאפס.
למה לא להדר הכול מראש וזהו? כי ל-JIT יש מידע שאף מהדר מוקדם לא מחזיק:
- הוא יודע על איזה מעבד בדיוק הוא רץ ואילו הוראות מיוחדות יש בו, ויכול להשתמש בהן.
- הוא רואה מה התוכנית עושה בפועל: אילו מתודות חוזרות הכי הרבה ואילו סוגי אובייקטים מגיעים לכל קריאה. על התצפיות האלה בנויות האופטימיזציות של החלק הבא.
יש גם מחיר, ורואים אותו באותן מדידות: בתחילת ההרצה חלק מהעבודה עוד נעשה בפירוש, וה-JIT עסוק בהידור, ולכן ההתחלה איטית יותר. לזה קוראים חימום (warm-up). מי שמודד ביצועים ב-Java מריץ קודם כמה סבבים שלא נספרים, ורק אחריהם מתחיל למדוד.
שם נוסף שמתבלבלים בו הוא Profiler. כלי כמו VisualVM מתחבר לתוכנית רצה, אוסף זמנים ומונים, ומציג למפתח טבלאות וגרפים של המקומות שבהם הזמן הולך; התוכנית ממשיכה לרוץ בדיוק כפי שרצה קודם. ה-JIT לא מציג דבר לאף אחד, אבל הוא כן משנה את הדרך שבה הקוד מתבצע, בזמן הריצה.
טעויות נפוצות
- אחרי הריצה הראשונה, קוד המכונה כבר כתוב בתוך קובץ ה-class. קוד המכונה קיים רק ב-code cache של התהליך. קובץ ה-class נשאר Bytecode בלבד.
- ה-JDK שומר את קוד המכונה בתיקיית מטמון, וההרצה הבאה טוענת אותו מוכן. HotSpot במצבו הרגיל לא שומר קוד מכונה מהרצה להרצה. כל הרצה מתחילה מאפס.
- הקוד המהודר נזרק אחרי השימוש הראשון וההידור חוזר בכל קריאה. הוא נשאר ב-code cache ומשמש את כל הקריאות הבאות באותו תהליך.
- קוד המכונה מגיע מ-
javac.javacמפיק Bytecode ותו לא. קוד המכונה נוצר בזמן ריצה בתוך ה-JVM. - בזכות ה-JIT התוכנית מהירה כבר מהשנייה הראשונה, כי הוא מדלג על בדיקות. ההפך: ההתחלה איטית יותר, כי הקוד מפורש בזמן שה-JIT מהדר.
- ה-JIT הוא עוד שכבת תרגום שכל פקודה עוברת, ולכן התוכנית איטית לאורך כל הדרך. אחרי שקטע הודר הוא רץ כקוד מכונה רגיל, בלי תיווך.
- ה-JIT מתחיל מקוד המקור ומדלג על ה-Bytecode. הקלט שלו הוא ה-Bytecode שה-Class Loader טען. קוד המקור לא מגיע ל-JVM.
- הידור בזמן ריצה מאפשר לערוך את קובץ ה-java באמצע ההרצה, לוותר על ה-JVM או לוותר על ה-GC. היתרון האמיתי הוא התאמה למעבד המסוים ולהתנהגות שנצפתה בפועל.
- ה-JIT מציג למפתח גרפים של ביצועים, וה-Profiler משכתב את ה-Bytecode אחרי שהתוכנית נסגרת. התפקידים הפוכים: ה-Profiler מודד ומציג, ה-JIT משנה את הביצוע בזמן הריצה.
בדקו את עצמכם
שרת Java מופעל מחדש בכל לילה. למה הבקשות הראשונות בכל בוקר איטיות יותר מאלה של הצהריים, אף שבערב הקודם הכול כבר היה מהודר?
קוד המכונה של אתמול נעלם יחד עם התהליך. אחרי ההפעלה מחדש הקוד חוזר להתחיל ב-Interpreter, וה-JIT צריך לחמם ולהדר אותו שוב.
HotSpot: איך מחליטים איזה קוד חם
איך ה-JVM ידעה להדר דווקא את checksum, ולא את main או את System.nanoTime? הרמז נמצא בשם של ה-JVM עצמה: HotSpot, "הנקודה החמה".
תוכניות נוטות לבלות כמעט את כל זמנן בפינה קטנה של הקוד, ולהשקיע הידור בכל השאר היה בזבוז. לכן HotSpot מנהל לכל מתודה מונים, ושולח לקוד מכונה רק את מי שהמונים שלה מטפסים גבוה.
שני מונים קובעים:
| מונה | מה הוא סופר |
|---|---|
| מונה קריאות (invocation counter) | כמה פעמים קראו למתודה |
| מונה back-edges | כמה פעמים לולאות בתוך המתודה קפצו חזרה לתחילתן |
ב-Meter רואים למה צריך את שניהם. checksum נקראת רק ארבע פעמים בכל ההרצה, כך שמונה הקריאות שלה כמעט לא זז, אבל כבר בקריאה הראשונה הלולאה שלה קופצת אחורה 40 מיליון פעמים. מונה ה-back-edges חוצה את הסף בתוך שבריר של המעבר הראשון, והמתודה מסומנת חמה ונשלחת להידור.
טעויות נפוצות
- HotSpot הוא רכיב שעוקב אחר צריכת הזיכרון ומשבית threads רדומים. HotSpot מאתר קוד שרץ הרבה ומהדר אותו. ניהול זיכרון שייך ל-GC.
- HotSpot הוא מה שמאפשר לעצור בנקודת עצירה ולהציץ בערכי המשתנים. זה תפקיד של דיבאגר, לא של מנגנון ההידור.
- HotSpot מפנה מהזיכרון Bytecode של מחלקות שאף אחד לא משתמש בהן. זה לא חלק מתפקידו.
- ה-JIT מתחיל מהמתודות הגדולות, כי הן הכי יקרות. הקריטריון הוא כמה הקוד רץ, לא כמה הוא גדול.
Tiered Compilation: שני מהדרים, C1 ו-C2
בפלט של PrintCompilation שתראו מייד, אותה מתודה מופיעה כמה פעמים, ולידה ספרות שונות, בעיקר 3 ו-4. הסיבה: ל-HotSpot יש שני מהדרי JIT שונים, וכל אחד מהם טוב בדבר אחר:
| מהדר | קצב ההידור | עומק האופטימיזציה | למה הוא שם |
|---|---|---|---|
| C1 | מהיר | קל | להוציא מהר קוד חם מה-Interpreter לקוד מכונה, ותוך כדי לאסוף פרופיל |
| C2 | איטי | כבד | להדר שוב את הקוד הכי חם, כדי להגיע לביצועים מרביים |
השילוב שלהם עם ה-Interpreter נקרא Tiered Compilation (הידור מדורג), והוא פועל כברירת מחדל החל מ-Java 8. אפשר לחשוב עליו כעל שלוש תחנות, שמתודה ממשיכה בהן רק כל עוד היא לא מתקררת:
- תחנה ראשונה, Interpreter: אין שום המתנה, ותוך כדי הביצוע הוא גם מונה.
- תחנה שנייה, C1: מתודה שהמונים שלה עברו סף מקבלת קוד מכונה תוך זמן קצר. הקוד הזה עוד לא מלוטש, אבל הוא מתעד בפירוט מה קורה בו, וזה הפרופיל.
- תחנה שלישית, C2: למתודות שגם עכשיו לא מפסיקות לרוץ, C2 משקיע הידור ארוך ויסודי, ובונה אופטימיזציות על מה שהפרופיל לימד.
למה לא מהדר אחד? כי כל מהדר יחיד מכריח לוותר על משהו. אם הוא זריז, הקוד שלו נשאר בינוני לאורך כל חיי התוכנית; אם הוא יסודי, התוכנית מזדחלת עד שהוא מסיים.
בשלוש התחנות מקבלים קוד מכונה כבר בשלב מוקדם, וקוד מלוטש לקטעים שבאמת חשובים. התחנות עוקבות זו אחרי זו: C1 ו-C2 לא מתחרים על אותה מתודה באותו זמן, ושום גרסה לא נבחרת לפי מי שסיימה ראשונה.
שני דגלים שכדאי להכיר:
| דגל | מה הוא עושה |
|---|---|
-Xint | ה-JVM מבצעת את ה-Bytecode בפירוש בלבד, וה-JIT לא מופעל |
-XX:+PrintCompilation | בכל פעם שמתודה עוברת הידור בזמן הריצה, ה-JVM מדפיסה על כך שורה |
תרחיש 13: רואים את הסולם בעיניים עם PrintCompilation
מריצים שוב את Meter מתרחיש הלולאה, הפעם עם -XX:+PrintCompilation, ומשאירים רק את השורות של checksum ואת שורות המדידה:
java -XX:+PrintCompilation Meter | grep -E "checksum|pass" 671 23 % 3 Meter::checksum @ 4 (25 bytes)
671 24 3 Meter::checksum (25 bytes)
672 25 % 4 Meter::checksum @ 4 (25 bytes)
675 23 % 3 Meter::checksum @ -2 (25 bytes) made not entrant
763 25 % 4 Meter::checksum @ -2 (25 bytes) made not entrant
pass 1: 94 ms, checksum 140000000
764 26 % 4 Meter::checksum @ 4 (25 bytes)
768 27 4 Meter::checksum (25 bytes)
771 24 3 Meter::checksum (25 bytes) made not entrant
pass 2: 65 ms, checksum 140000000
pass 3: 50 ms, checksum 140000000
pass 4: 73 ms, checksum 140000000כך קוראים שורה: העמודה הראשונה היא מילי-שניות מאז שה-JVM עלתה, והשנייה היא מספר סידורי של משימת ההידור. הספרה שלפני שם המתודה היא הרמה: 3 היא C1 עם איסוף פרופיל, ו-4 היא C2.
הסימן % מציין הידור של לולאה שרצה כבר, באמצע הקריאה (OSR, בתת-הפרק הבא). 25 bytes הוא גודל ה-Bytecode של checksum.
made not entrant פירושו שגרסה מהודרת נפסלה: קריאה חדשה כבר לא תיכנס אליה. בשורות של רמה 3 (משימות 23 ו-24) הסיבה פשוטה: גרסת C2 הייתה מוכנה והחליפה אותן.
משימה 25, גרסת ה-OSR של C2, נפסלה ברגע שהמעבר הראשון הסתיים. יומן ההידור המפורט (-XX:+LogCompilation) מראה שהיא הניחה שתנאי היציאה מהלולאה אף פעם לא מתקיים, כי בזמן ההידור עוד לא נצפתה יציאה. ההנחה נשברה, התבצע Deoptimization, ומייד אחר כך הגיע הידור חדש, משימה 26.
מה שרואים כאן הוא הסולם המלא: Interpreter בהתחלה, אחריו C1, ובסוף C2. שימו לב גם לזמנים: המעבר הראשון, שחלקו רץ לפני ההידור, הוא האיטי ביותר.
בפלטים של החלק הבא תפגשו גם את הרמות 1 ו-2. גם הן C1: רמה 1 היא C1 בלי שום איסוף פרופיל, ומשמשת למתודות טריוויאליות כמו getter, ורמה 2 היא C1 עם איסוף פרופיל חלקי.
טעויות נפוצות
- C2 הוא המהדר הזריז, ו-C1 הוא זה שעושה את האופטימיזציות הכבדות. התפקידים הפוכים: C1 מהיר וקל, C2 איטי ויסודי.
- C1 נועד למעבד עם ליבה אחת ו-C2 למעבד מרובה ליבות, או ש-C2 מיועד לקוד שנכתב ב-C. ההבדל ביניהם הוא קצב ההידור מול עומק האופטימיזציה, ושניהם מהדרים Bytecode.
- הידור מדורג מקמפל דווקא מתודות שנקראו פעם אחת, ומשאיר בפירוש את מה שחוזר הרבה. בדיוק להפך: מה שנקרא הרבה הוא מה שמטפס בסולם.
- הרמה שמתודה מקבלת נקבעת לפי מספר השורות שלה. הרמה נקבעת לפי החום, כלומר כמה המתודה רצה.
- שני המהדרים עובדים על המתודה בבת אחת, והגרסה שמוכנה ראשונה נבחרת. השלבים רציפים: קודם C1, ואחר כך, אם המתודה עדיין חמה, C2.
- Tiered Compilation פירושו כמה JVM שרצות על כמה ליבות, כמה מעברים של
javac, המרה של כל הקוד לקובץ הרצה, השבתת GC בעומס או שדרוג גרסת השפה בזמן ריצה. זה שילוב מדורג של שלושה מנגנונים באותה JVM: Interpreter, C1 ו-C2. -Xintמציג אילו מתודות עברו הידור, קובע גודל מחסנית או מכבה את האימות.-Xintהוא פירוש בלבד. את ההדפסה עושה-XX:+PrintCompilation, ואת גודל המחסנית של thread קובע-Xss.
בדקו את עצמכם
מישהו מציע לבטל את C1 ולשלוח כל מתודה חמה ישר ל-C2, "כי בסוף ממילא מגיעים לשם". מה מפסידים?
שני דברים. C2 מהדר לאט, אז בזמן ההמתנה לו הקוד היה תקוע ב-Interpreter האיטי. ובנוסף, הפרופיל המפורט ש-C2 נשען עליו נאסף בשלב של C1.
On-Stack Replacement: החלפה באמצע הלולאה
בפלט של PrintCompilation, השורה הראשונה של checksum היא Meter::checksum @ 4, עם הסימן %. היא נרשמה ב-671 ms, באמצע הקריאה הראשונה ל-checksum ולפני שהקריאה הזו הסתיימה.
זה On-Stack Replacement (OSR). הקריאה כבר נמצאת בתוך הלולאה, במסגרת שה-Interpreter מחזיק במחסנית, וה-JVM מעבירה את מה שבמסגרת, הערכים הנוכחיים של acc ושל k, אל הגרסה המהודרת. הביצוע נכנס אליה בהוראה 4 של ה-Bytecode, שהיא תחילת הלולאה, וממשיך משם כקוד מכונה.
למה זה נחוץ? הידור רגיל משפיע רק על קריאות שמתחילות אחריו. חשבו על main שכל עבודתה היא לולאה ענקית אחת: אף אחד לא יקרא לה שוב, ובלי OSR הלולאה כולה הייתה נגמרת בפירוש.
טעויות נפוצות
- OSR דואג שאחרי חציית הסף, הקריאה הבאה למתודה תיכנס כבר לגרסה המהודרת. זה הידור רגיל. OSR מחליף את הקוד באמצע הקריאה שכבר רצה.
- OSR ממחזר את המסגרת של קריאה רקורסיבית, וכך המחסנית לא גדלה. זה מתאר אופטימיזציית רקורסיית זנב, ש-HotSpot כלל לא מבצע.
- OSR הוא המנגנון שמחליט אם מתודה תעבור ל-C1 או ל-C2. את הבחירה הזו עושה מדיניות ה-Tiered Compilation. ב-PrintCompilation רואים OSR גם ברמה 3 וגם ברמה 4.
JIT ב-.NET
ב-.NET התמונה דומה, עם שמות אחרים. מהדר C# מפיק CIL (קוד הביניים של .NET), וה-CLR מתרגם את ה-CIL לקוד מכונה ב-JIT.
כדי לראות מתי בדיוק זה קורה, הנה תוכנית קטנה עם ארבע מתודות. Refund כתובה כמו כל האחרות, אבל אף שורה לא קוראת לה:
using System;
using System.Threading;
static class Tickets
{
static int Price(int seats) => seats * 40; // called on every sale
static int Refund(int seats) => seats * 40 / 2; // never called in this run
static long SellBatch()
{
long sum = 0;
for (int i = 0; i < 1000; i++) sum += Price(i % 4);
return sum;
}
static void Main()
{
long total = 0;
for (int round = 0; round < 40; round++)
{
total += SellBatch();
Thread.Sleep(10); // give the background tiering time to act
}
Console.WriteLine("total: " + total);
}
}total: 2400000ב-.NET 7 אפשר לבקש מה-JIT שורה על כל מתודה שהוא מהדר, בעזרת משתנה הסביבה DOTNET_JitDisasmSummary. ב-PowerShell, אחרי dotnet build -c Release, ועם סינון לשורות של התוכנית שלנו:
$env:DOTNET_JitDisasmSummary = "1"
dotnet bin\Release\net7.0\Tickets.dll | Select-String "Tickets:" 19: JIT compiled Tickets:Main() [Tier0, IL size=54, code size=190]
20: JIT compiled Tickets:SellBatch() [Tier0, IL size=33, code size=133]
21: JIT compiled Tickets:Price(int) [Tier0, IL size=5, code size=18]
22: JIT compiled Tickets:SellBatch() [Tier1-OSR @0x17, IL size=33, code size=66]
23: JIT compiled Tickets:Price(int) [Tier1, IL size=5, code size=7]Refund לא מופיעה ברשימה כלל: ה-CLR לא מכין קוד מכונה למתודה לפני שמישהו מבקש אותה, ומתודה שאף אחד לא ביקש לא עולה לו דבר. כל אחת מהשלוש האחרות קיבלה קוד מכונה ברגע שבו נקראה לראשונה, ברמת Tier0.
Price מופיעה פעם שנייה, ב-Tier1: אחרי שנקראה פעמים רבות היא הודרה מחדש עם אופטימיזציה, וקוד המכונה שלה התכווץ מ-18 בתים ל-7. זה ההידור המדורג של .NET, שקיים החל מ-.NET Core 3.0: Tier0 זריז לקריאה הראשונה, ו-Tier1 שמור למתודות שנקראות הרבה. השורה Tier1-OSR מראה שגם ל-.NET 7 יש החלפה באמצע לולאה, בדומה ל-OSR של HotSpot; סדר השורות ומספרן יכולים להשתנות מהרצה להרצה.
ב-.NET Framework הוותיק לא היו שתי רמות ולא היה שום מצב פירוש. הקריאה הראשונה לכל מתודה חיכתה להידור מלא שלה, ורק אז המתודה רצה.
טעויות נפוצות
- קוד המכונה נוצר כבר כשהמהדר של C# בונה את קובץ ה-dll. המהדר של C# מפיק CIL. קוד המכונה נוצר בזמן הריצה, על ידי ה-CLR.
- ה-JIT של ה-CLR רץ בזמן התקנת התוכנית. הידור בזמן ההתקנה הוא עבודה של כלי AOT נפרדים, כמו NGen, ולא של ה-JIT.
- כשה-assembly נטען, ה-CLR מהדר את כל המתודות שבו בבת אחת. כל מתודה מהודרת בנפרד, כשקוראים לה בפעם הראשונה.
מה ה-JIT עושה לקוד: האופטימיזציות
Inlining: גוף המתודה עובר למקום הקריאה
חשבו על getSalary מהדוגמה שבהמשך: כל מה שהיא עושה הוא להחזיר שדה אחד. אבל כדי לקרוא לה, הקוד צריך להכין פרמטרים, לפתוח מסגרת חדשה, לקפוץ אליה ולחזור, וכל הטקס הזה ארוך יותר מקריאת השדה עצמה.
Inlining (הטמעה) חוסך את הטקס: ה-JIT פשוט לא מבצע קריאה, אלא שותל את הפקודות של getSalary בתוך הקוד המהודר של מי שקרא לה, כאילו נכתבו שם מלכתחילה. זו האופטימיזציה החשובה ביותר שה-JIT מבצע.
והרווח לא נגמר בקפיצה שנחסכה. כשהקוד של הקורא ושל הנקראת נמצא באותו מקום, ה-JIT יכול לייעל את שניהם יחד, למשל לגלות שחישוב בצד אחד מיותר בגלל מה שקורה בצד השני.
תרחיש 14: getter שנעלם מהקוד המהודר
המחלקה Employee נמצאת בקובץ class משלה, ו-getSalary היא מתודת מופע רגילה. sumSalaries קוראת לה אלף פעמים בכל קריאה, ו-main קורא ל-sumSalaries עשרים אלף פעמים:
class Employee {
private final int salary;
Employee(int salary) { this.salary = salary; }
int getSalary() { return salary; } // a tiny getter, a typical inlining candidate
}
public class Payroll {
static long sumSalaries(Employee[] staff) {
long total = 0;
for (Employee e : staff) {
total += e.getSalary();
}
return total;
}
public static void main(String[] args) {
Employee[] staff = new Employee[1000];
for (int i = 0; i < staff.length; i++) staff[i] = new Employee(9000 + i);
long last = 0;
for (int round = 0; round < 20000; round++) last = sumSalaries(staff);
System.out.println("total payroll: " + last);
}
}הדגל -XX:+PrintInlining (שדורש -XX:+UnlockDiagnosticVMOptions) מוסיף מתחת לכל הידור את הקריאות שבתוכו ואת מה שהוחלט לגביהן:
java -XX:+UnlockDiagnosticVMOptions -XX:+PrintInlining -XX:+PrintCompilation Payroll | grep -E "sumSalaries|getSalary|payroll" 362 26 1 Employee::getSalary (5 bytes)
367 27 % 3 Payroll::sumSalaries @ 11 (41 bytes)
@ 27 Employee::getSalary (5 bytes)
369 28 3 Payroll::sumSalaries (41 bytes)
@ 27 Employee::getSalary (5 bytes)
370 29 % 4 Payroll::sumSalaries @ 11 (41 bytes)
@ 27 Employee::getSalary (5 bytes) accessor
376 27 % 3 Payroll::sumSalaries @ -2 (41 bytes) made not entrant
415 30 4 Payroll::sumSalaries (41 bytes)
@ 27 Employee::getSalary (5 bytes) accessor
419 28 3 Payroll::sumSalaries (41 bytes) made not entrant
total payroll: 9499500בשתי הגרסאות של C2 (רמה 4) מופיעה ליד getSalary המילה accessor: C2 זיהה getter פשוט והטמיע אותו בתוך sumSalaries. המתודה בת 5 בתים בלבד, ובקוד המהודר כבר אין קריאה אליה.
בפועל, הקוד המהודר מתנהג כאילו הלולאה נכתבה כך (Java להמחשה בלבד; השדה פרטי, ואי אפשר לכתוב את זה בקוד המקור):
// What the C2 version of the loop does after inlining
for (Employee e : staff) {
total += e.salary; // the field is read directly, no call
}שלושה דברים מתגלים מהדוגמה. ראשית, קוד המקור וה-Bytecode לא השתנו בכלל: ההטמעה קיימת רק בקוד המכונה שה-JIT בונה בזיכרון. שנית, getSalary עדיין מבוצעת לכל עובד, על האובייקט של אותה איטרציה; רק מחיר הקריאה ירד.
שלישית, Employee יושבת בקובץ class נפרד, ו-getSalary איננה static, ובכל זאת היא הוטמעה. עד שמתודה מתחממת, ה-Class Loader כבר הביא את המחלקות שלה לזיכרון, וה-JIT מהדר מתוך ה-Bytecode הטעון הזה. גבולות בין קבצים או בין מחלקות לא מעניינים אותו, כי הוא לא קורא קבצים ולא קוד מקור.
טעויות נפוצות
- בזכות Inlining המתודה רצה ב-thread נפרד, והלולאה לא מחכה לה. הקוד המוטמע רץ באותו thread, כחלק מגוף הלולאה.
- ה-JIT זוכר מה המתודה החזירה בפעם הראשונה ומחזיר את אותו ערך מעכשיו. זה memoization, וזה היה שובר תוכניות שבהן הפרמטרים או האובייקט משתנים. המתודה מבוצעת בכל פעם.
- Inlining מוחק את הקריאה כקוד מת, והמתודה כבר לא מתבצעת. הקריאה נעלמת, אבל העבודה של המתודה נשארת ומתבצעת במקום הקריאה.
- Inlining מחליף משתנים גלובליים במשתנים מקומיים, מפזר מתודות על כמה ליבות או מבטל בדיקות גבולות של מערכים. Inlining הוא דבר אחד: הכנסת גוף המתודה במקום הקריאה אליה.
- אפשר להטמיע רק מתודה מאותה מחלקה. כל Bytecode שכבר נטען זמין ל-JIT, מכל מחלקה, כמו ש-Employee הראתה.
- כדי להטמיע מתודה ממחלקה אחרת, ה-JIT פותח את קובץ ה-java שלה. ה-JIT לא רואה קוד מקור בכלל. הוא עובד על Bytecode שנמצא בזיכרון.
- ממחלקה אחרת אפשר להטמיע רק מתודות static. גם מתודות מופע מוטמעות, ו-
getSalaryהיא דוגמה לכך.
קריאות וירטואליות, פרופיל טיפוסים ו-Inline Cache
הקריאה f.charge(units) ב-Billing, שבתרחיש הבא, היא קריאה וירטואלית. ב-Java זה מעמדה של כל מתודת מופע שלא סומנה private, static או final: איזו charge תרוץ, של FlatFee או של MeteredFee, מתברר רק כשרואים את האובייקט שהגיע. ב-Bytecode קריאה כזו נכתבת invokevirtual, או invokeinterface כשהיא עוברת דרך ממשק, כמו כאן.
לכאורה זה מכשול להטמעה: את הקוד של איזו מתודה שותלים, כשהתשובה משתנה מאובייקט לאובייקט? HotSpot פותר את זה בתצפית. בכל מעבר בנקודת הקריאה, ה-Interpreter ו-C1 רושמים איזה סוג הגיע, וכשמגיע תורו של C2 הוא קורא את הרישום.
תרחיש 15: נקודת קריאה אחת, ומה שמגיע אליה
ממשק Fee עם שני מימושים. bill מסכמת את העמלות של מערך שלם, וכל הקריאות ל-charge עוברות דרך נקודת קריאה אחת. בשלב 1 המערך מכיל רק FlatFee, ובשלב 2 חצי ממנו MeteredFee:
interface Fee { int charge(int units); }
class FlatFee implements Fee {
public int charge(int units) { return 5; }
}
class MeteredFee implements Fee {
public int charge(int units) { return units * 2; }
}
public class Billing {
static long bill(Fee[] fees, int units) {
long sum = 0;
for (Fee f : fees) {
sum += f.charge(units); // one call site, its profile decides the inlining
}
return sum;
}
static long run(Fee[] fees) {
long r = 0;
for (int i = 0; i < 30000; i++) r = bill(fees, 3);
return r;
}
public static void main(String[] args) {
Fee[] flat = new Fee[500];
java.util.Arrays.fill(flat, new FlatFee());
System.out.println("phase 1 result: " + run(flat));
Fee[] mixed = new Fee[500];
for (int i = 0; i < mixed.length; i++) mixed[i] = (i % 2 == 0) ? new FlatFee() : new MeteredFee();
System.out.println("phase 2 result: " + run(mixed));
}
}java -XX:+UnlockDiagnosticVMOptions -XX:+PrintInlining -XX:+PrintCompilation Billing | grep -E "Billing::bill|charge|phase" 1949 19 % 4 Billing::bill @ 13 (47 bytes)
@ 31 FlatFee::charge (2 bytes) inline (hot)
1956 20 4 Billing::bill (47 bytes)
@ 31 FlatFee::charge (2 bytes) inline (hot)
phase 1 result: 2500
2089 20 4 Billing::bill (47 bytes) made not entrant
2089 19 % 4 Billing::bill @ -2 (47 bytes) made not entrant
2089 21 4 Billing::bill (47 bytes)
@ 31 FlatFee::charge (2 bytes) inline (hot)
@ 31 MeteredFee::charge (4 bytes) inline (hot)
phase 2 result: 2750
2337 22 2 MeteredFee::charge (4 bytes)
2337 18 1 FlatFee::charge (2 bytes)בשלב 1 הנקודה monomorphic: C2 מהדר את bill ומטמיע בתוכה את FlatFee::charge בלבד (inline (hot)), עם בדיקה שהאובייקט באמת FlatFee.
בשלב 2 הגרסאות האלה נפסלות (על כך בתת-הפרק הבא), ומשימה 21 מהדרת את bill מחדש. הפעם הנקודה bimorphic, ושני המימושים מוטמעים זה לצד זה, עם בדיקת סוג שמפנה לכל אחד.
אילו היה מגיע שלב 3 עם עשרה מימושים שונים של Fee, הנקודה הייתה הופכת megamorphic. ה-JIT לא היה מטמיע שום charge, והקריאה הייתה נשארת קריאה וירטואלית רגילה.
שלושת המצבים של נקודת קריאה, בסיכום:
| מה נרשם בנקודת הקריאה | השם | ההחלטה של ה-JIT |
|---|---|---|
| סוג אחד בלבד | monomorphic | מטמיע את המימוש הזה, ומקדים לו בדיקת סוג זריזה |
| שני סוגים | bimorphic | ב-HotSpot אפשר להטמיע את שניהם, ובדיקת סוג בוחרת בכל פעם את הגוף המתאים |
| הרבה סוגים | megamorphic | אין גוף אחד שאפשר להטמיע, והקריאה נשארת וירטואלית רגילה דרך טבלת המתודות |
המסקנה החשובה: charge ניתנת לדריסה, ובכל זאת הוטמעה. מה שמכריע הוא לא מה שהשפה מרשה, אלא מה שהגיע בפועל לנקודה הזו.
גם בלי רישום יש ל-JVM רמז: היא יודעת אילו מחלקות כבר טעונות. ב-Payroll לא נטענה אף תת-מחלקה של Employee, אז ל-getSalary יש מימוש אפשרי יחיד, ומבחינה זו כבר אפשר להטמיע אותה.
עכשיו מובן גם מקרה שנראה מוזר: מתודה זעירה שה-JIT מסרב להטמיע. אם לנקודת הקריאה מגיעים עשרה מימושים שונים, אין קוד אחד לשתול, והגודל הקטן לא עוזר. ב-HotSpot ההחלטה תלויה בגודל המתודה ובמה שהפרופיל מראה; מספר הפרמטרים, try-catch או synchronized אינם מה שעוצר אותה.
במנועי ריצה רבים יש לאותה בעיה פתרון נוסף, Polymorphic Inline Cache (PIC). כל נקודת קריאה וירטואלית מקבלת טבלה קטנה: הסוגים שכבר נראו בה, ולצד כל סוג המימוש שלו. בכל קריאה משווים את סוג האובייקט לטבלה וקופצים ישר לכתובת הנכונה.
טעויות נפוצות
- מתודה שאפשר לדרוס לעולם לא מוטמעת. היא מוטמעת כשבנקודת הקריאה נצפה מימוש אחד, או כשנטענה רק מחלקה אחת שמממשת אותה.
- ה-JIT מטמיע את המימוש של הסוג שבהצהרת המשתנה, ומתעלם מתת-מחלקות. זה היה הורס את הפולימורפיזם. ההטמעה נבנית על הסוג שנצפה, ובדיקת סוג שומרת שהיא תקפה.
- ה-JIT מעדיף להטמיע מתודות גדולות, כי שם הקריאה יקרה, ומוותר על הקטנות. ההפך: מתודות קטנות הן המועמדות המובהקות, כי אצלן מחיר הקריאה הוא חלק גדול מהעבודה.
- PIC מחזיק פריט אחד, המתודה שנקראה לאחרונה, וחוסך כל בדיקת סוג. PIC מחזיק כמה סוגים, ובכל קריאה הוא בודק את סוג האובייקט מולם.
- PIC הוא שיטה לכווץ את ה-Bytecode בזיכרון. הוא מטמון של נקודת קריאה, שעובד בזמן ריצה.
- PIC הופך כבר בהידור כל קריאה וירטואלית לקריאה סטטית קבועה. אין בו שום דבר של זמן הידור: הוא חי בזמן הריצה, ומשווה את סוג האובייקט בכל קריאה.
הנחות ספקולטיביות ו-Deoptimization
ההטמעה של FlatFee::charge ב-Billing נשענה על תצפית ולא על הוכחה: עד אותו רגע הגיע רק FlatFee. אופטימיזציות כאלה נקראות ספקולטיביות, והרבה ממה שה-JIT עושה שייך לסוג הזה; Billing מראה מה קורה כשהתצפית מפסיקה להתקיים.
תרחיש 16: MeteredFee מגיע לקוד שהודר בשביל FlatFee
בפלט של Billing מהתת-פרק הקודם, בסוף שלב 1, bill הודרה ב-C2 בשתי גרסאות (משימה 20 הרגילה ומשימה 19 של OSR), ובשתיהן FlatFee::charge מוטמעת מאחורי בדיקת סוג.
שלב 2 מתחיל. נוצרים אובייקטים של MeteredFee, והראשון מהם מגיע לנקודת הקריאה בתוך הקוד המהודר. בפלט, ב-2089 ms, שתי הגרסאות מסומנות made not entrant.
היומן המפורט (-XX:+LogCompilation) מראה ששני המנגנונים פעלו. בדיקת הסוג בקוד המהודר נכשלה (הסיבה נרשמת כ-class_check), וגם ההנחה שיש ל-charge מימוש יחיד נפלה כשנטענה MeteredFee (dependency_failed).
הביצוע עבר ל-Interpreter, שקרא ל-MeteredFee::charge כמו שצריך. הפרופיל של הנקודה התעדכן, ומשימה 21 מהדרת את bill מחדש עם שני המימושים.
והתוצאה? 250 עמלות של 5 ועוד 250 עמלות של 3 כפול 2 נותנות 2750, בדיוק מה שהודפס.
התוכנית לא נעצרה ולא הופעלה מחדש, bill לא נחסמה להידור, וה-JIT המשיך לעבוד. מה שהלך לאיבוד הוא רק הזמן שהושקע בגרסאות שנפסלו.
מה שקרה ב-Billing הוא הדפוס הכללי. כל הנחה כזו מגיעה עם שמירה: בדיקה (guard) בתוך הקוד המהודר, כמו בדיקת הסוג שנכשלה שם, או הרשמה מראש לאירוע שעלול להפריך אותה, כמו טעינה של מחלקה חדשה.
עוד הנחות טיפוסיות שכבר פגשתם:
- "לנקודת הקריאה של
chargeמגיע רק FlatFee". - "ל-Employee אין תת-מחלקה טעונה, אז
getSalaryיש לה מימוש אחד". - "תנאי היציאה מהלולאה הזו לא מתקיים", כמו בגרסת ה-OSR של
checksum.
כששמירה כזו נכשלת, ה-JVM מבצעת Deoptimization, וב-Billing ראיתם את כל ארבעת השלבים שלו:
- פסילה: הגרסאות שנשענו על ההנחה קיבלו
made not entrant, ומאותו רגע אף קריאה חדשה לא נכנסה אליהן. - חזרה לפירוש: הביצוע המשיך ב-Interpreter, על ה-Bytecode המקורי, מאותה נקודה ועם אותם ערכים, כך שהסכום שנצבר לא אבד.
- למידה מחדש: בזמן שה-Interpreter רץ, הרישום של נקודת הקריאה התעדכן וכלל עכשיו גם את MeteredFee.
- הידור חדש:
billעדיין הייתה חמה, ולכן C2 בנה אותה שוב, במשימה 21, הפעם לפי התמונה המעודכנת.
שימו לב מה לא נפגע: התשובה. השמירות מבטיחות שקוד מהודר לא ממשיך לרוץ אחרי שההנחה שלו התבדתה, ולכן Deoptimization נוגע רק במהירות.
וזה גם הסיכון בספקולציה נועזת מדי. כל הנחה שנופלת שורפת את הזמן שהושקע בהידור שלה ומחזירה את הקוד לפירוש האיטי עד שההידור הבא מוכן, ונקודה שבה ההנחות נופלות שוב ושוב תבלה את רוב זמנה במעגל של פסילה והידור. זו הסיבה שבנקודות megamorphic ה-JIT מעדיף לא להמר בכלל.
טעויות נפוצות
- אחרי שההנחה נשברה, הקוד המהודר ממשיך לרוץ כמו שהוא ועלול להחזיר תשובה לא נכונה. הבדיקות בקוד המהודר נועדו בדיוק לזה: הן לא נותנות לו לרוץ על הנחה שגויה.
- הקוד המהודר נשאר בשימוש, רק עם בדיקת תקינות נוספת בכל קריאה, בלי לחזור לפירוש. כשהבדיקה נכשלת, הביצוע עובר ל-Interpreter, והגרסה המהודרת נפסלת.
- כשהנחה נשברת, התוכנית נעצרת עם שגיאת הידור, או מופעלת מחדש. כל התהליך שקוף ומתרחש באמצע הריצה. התוכנית לא מרגישה דבר מלבד האטה זמנית.
- Deoptimization פירושו טעינה מחדש של כל המחלקות. נפסל רק הקוד המהודר שנשען על ההנחה שנשברה. המחלקות לא נטענות שוב.
- אחרי Deoptimization ה-JIT מכובה, או שהמתודה נשארת בפירוש עד סוף הריצה. בדרך כלל המתודה מהודרת מחדש בהמשך, כמו
billבמשימה 21. - בזמן Deoptimization כל ה-threads מושהים עד שה-GC עובר על כל האובייקטים. Deoptimization קשור לקוד מהודר, לא לאיסוף זבל.
- הנזק של הידור אגרסיבי הוא קובץ Bytecode שתופח, או זיכרון שמתנפח עד ה-GC הבא. הקוד המהודר לא נכתב לשום קובץ. הנזק הוא זמן הידור שהתבזבז והאטה עד ההידור הבא.
בדקו את עצמכם
בתוכנית Payroll, אחרי ש-getSalary הוטמעה, נטענת בזמן הריצה תת-מחלקה Manager שדורסת את getSalary. מה קורה לגרסה המהודרת של sumSalaries?
ההטמעה נשענה על ההנחה של-Employee אין תת-מחלקה טעונה, וטעינת Manager שוברת אותה. הגרסה המהודרת עוברת Deoptimization: היא נפסלת, הביצוע ממשיך ב-Interpreter, ואם sumSalaries נשארת חמה היא תהודר מחדש לפי מה שנצפה מעכשיו.
התוצאה של Billing נכונה בשני השלבים. אם כך, מה בעצם היה המחיר של ההנחה שנשברה?
ביצועים בלבד: זמן ההידור של משימות 19 ו-20 הלך לאיבוד, ועד שמשימה 21 הייתה מוכנה הקוד רץ בפירוש.
Escape Analysis: אובייקט שלא יוצא מהמתודה
בתרחיש הבא, לולאה יוצרת 200 מיליון אובייקטים מסוג Cell, וה-Garbage Collector לא נדרש אפילו פעם אחת. כשמכבים אופטימיזציה אחת, Escape Analysis, אותה תוכנית צריכה עשרה איסופים.
תרחיש 17: כמה איסופי זבל חוסך אובייקט שלא בורח
manhattan יוצרת Cell, משתמשת בשני השדות שלו ומחזירה int. ההפניה ל-Cell לא נשמרת בשום שדה ולא יוצאת מהמתודה. ה-main קורא לה 200 מיליון פעמים ובסוף מדפיס כמה איסופי זבל התרחשו:
import java.lang.management.GarbageCollectorMXBean;
import java.lang.management.ManagementFactory;
final class Cell {
final int row, col;
Cell(int row, int col) { this.row = row; this.col = col; }
}
public class Grid {
// The Cell never leaves this method: only an int is returned
static int manhattan(int r, int c) {
Cell cell = new Cell(r, c);
return Math.abs(cell.row) + Math.abs(cell.col);
}
static long gcCount() {
long n = 0;
for (GarbageCollectorMXBean gc : ManagementFactory.getGarbageCollectorMXBeans()) n += gc.getCollectionCount();
return n;
}
public static void main(String[] args) {
long acc = 0;
for (int i = 0; i < 200_000_000; i++) acc += manhattan(i & 511, i & 63);
System.out.println("acc = " + acc + ", collections = " + gcCount());
}
}הרצה רגילה, ואחריה הרצה שבה Escape Analysis מכובה בדגל -XX:-DoEscapeAnalysis:
java Grid
java -XX:-DoEscapeAnalysis Gridacc = 57400000000, collections = 0
acc = 57400000000, collections = 10מאתיים מיליון new, ואפס איסופי זבל. אחרי Scalar Replacement הקוד המהודר של manhattan מתנהג כאילו נכתב כך:
// What the compiled manhattan does after scalar replacement
static int manhattan(int r, int c) {
int cellRow = r; // the fields live in locals (registers)
int cellCol = c;
return Math.abs(cellRow) + Math.abs(cellCol);
}בלי Escape Analysis, כל Cell באמת מוקצה בערימה, והערימה מתמלאת עד שה-GC נדרש לפנות אותה, עשר פעמים בהרצה הזו. מספר האיסופים תלוי בגודל הערימה ובמחשב; ההבדל בין אפס לבין כמה הוא העיקר.
עכשיו נותנים לאובייקט לברוח: מוסיפים למחלקה שדה static Cell lastCell, ובתוך manhattan, אחרי היצירה, שומרים בו את ההפניה (lastCell = cell;). ההרצה הרגילה, עם Escape Analysis פעיל, מדפיסה כעת:
acc = 57400000000, collections = 12ההפניה נשמרת בשדה סטטי, כל קוד אחר עלול להגיע אליה, ולכן ההקצאה בערימה חוזרת. אותו דבר היה קורה אילו manhattan הייתה מחזירה את ה-Cell.
מה ה-JIT בדק? על כל new הוא שאל אם ההפניה לאובייקט יוצאת אי פעם מגבולות המתודה. שלוש דרכים מוציאות אותה: לשמור אותה בשדה, כמו lastCell; להחזיר אותה ב-return; או למסור אותה לקוד אחר שעלול להחזיק בה.
ה-Cell של manhattan לא עשה אף אחד מאלה, ולכן ה-JIT פירק אותו: row ו-col הפכו לשני ערכים מקומיים, בדרך כלל באוגרים, ואובייקט בערימה פשוט לא נוצר. זו Scalar Replacement, והיא חוסכת גם את ההקצאה וגם את העבודה שה-GC היה עושה אחר כך.
לאותו ממצא יש תועלת נוספת. אם אף thread אחר לא יכול להגיע לאובייקט, אין ממי להגן עליו, וה-JIT רשאי למחוק נעילות synchronized שנלקחות עליו.
טעויות נפוצות
- Escape Analysis שולחת את האובייקט ישר ל-Old Generation, כדי לחסוך איסופים קטנים. אובייקט שלא בורח לא מגיע לערימה בכלל, לשום דור שלה.
- האובייקט נשמר ב-code cache ומשמש שוב בקריאות הבאות. ה-code cache מחזיק קוד מכונה, לא אובייקטים.
- בכל יצירה של האובייקט, Escape Analysis שולחת את המתודה להידור נוסף. הניתוח נעשה פעם אחת, בזמן ההידור. הידור בכל יצירה היה הורס את הביצועים.
- כשמתגלה הקצאה בזבזנית, Escape Analysis זורקת חריגה. זו אופטימיזציה שקטה. אין שום שינוי בהתנהגות התוכנית, רק בעלות שלה.
- Escape Analysis מוציאה אובייקטים לאזור משותף, כדי שגם threads אחרים ייהנו מהם. היא עושה את ההפך: מאתרת אובייקטים שאף thread אחר לא יכול לראות, ובזכות זה חוסכת הקצאה ונעילות.
אופטימיזציות של לולאות, ואיך לא לבלבל ביניהן
לולאות הן המקום שבו רוב זמן הריצה נשרף, ולכן מהדרים בכלל, וה-JIT בתוכם, מפעילים עליהן טיפול מיוחד. ארבע אופטימיזציות מוכרות עוסקות כולן בלולאות, וקל להחליף ביניהן:
| אופטימיזציה | מה משתנה בקוד המהודר | מה נחסך |
|---|---|---|
| Loop Unrolling | גוף הלולאה משוכפל כמה פעמים, וכל סיבוב מבצע עבודה של כמה איטרציות | פחות בדיקות של תנאי הלולאה ופחות קפיצות חזרה |
| Loop Invariant Code Motion | חישוב שתוצאתו זהה בכל איטרציה עובר אל לפני הלולאה | החישוב מתבצע פעם אחת במקום בכל סיבוב |
| Strength Reduction | פעולה יקרה מוחלפת בפעולה זולה שקולה, למשל כפל בחזקה של 2 בהזזת סיביות | זמן של פעולה יקרה |
| Loop Fusion | שתי לולאות צמודות עם אותו טווח מאוחדות ללולאה אחת | מעבר אחד על הטווח במקום שניים |
כך נראה שכפול פי 3 של לולאה שמעלה כל איבר במערך באחד (Java להמחשה של מה שהקוד המהודר עושה):
// Original loop: 600 condition checks
for (int j = 0; j < 600; j++) {
stock[j] += 1;
}
// The same work unrolled by 3: 200 condition checks
for (int j = 0; j < 600; j += 3) {
stock[j] += 1;
stock[j + 1] += 1;
stock[j + 2] += 1;
}הלולאה המשוכפלת בודקת את התנאי 200 פעמים במקום 600, וקופצת חזרה לראשה פחות פעמים. כל איבר עדיין מקבל את התוספת שלו.
לשם השוואה, הנה שתי האופטימיזציות האחרות על לולאה אחרת. אף אחת מהן לא משכפלת את הגוף:
// Before
for (int j = 0; j < n; j++) {
out[j] = in[j] * (rate * 4); // rate * 4 never changes inside the loop
}
// After Loop Invariant Code Motion and Strength Reduction
int factor = rate << 2; // computed once, and * 4 became a shift
for (int j = 0; j < n; j++) {
out[j] = in[j] * factor;
}טעויות נפוצות
- Loop Unrolling פירושו להוציא מהלולאה חישוב שלא משתנה בין האיטרציות. זו Loop Invariant Code Motion, כמו
rate * 4בדוגמה. - Loop Unrolling פירושו להחליף כפל בהזזת סיביות. זו Strength Reduction.
- Loop Unrolling פירושו לאחד שתי לולאות סמוכות לאחת. זו Loop Fusion.
JIT מול AOT: לתרגם מראש או תוך כדי
מה זה AOT ובמה הוא שונה מ-JIT
נניח שבניתם את Meter עם GraalVM native-image, על מחשב Linux עם מעבד x64. התוצר כבר איננו קובץ class אלא קובץ הרצה של קוד מכונה, שנבנה במלואו לפני שהתוכנית רצה אפילו פעם אחת. זה AOT (Ahead-Of-Time).
ההבדל מ-JIT הוא בשאלה מתי קורה התרגום: ה-JIT עובד תוך כדי הריצה ורק על מה שמתגלה כנחוץ, ו-AOT גומר את כל העבודה לפני שמתחילים. מלבד native-image, גם ב-.NET יש כלים כאלה: ReadyToRun, וגם Native AOT החל מ-.NET 7.
| JIT | AOT | |
|---|---|---|
| מה מתורגם ומתי | קוד חם, בזמן הריצה | כל הקוד, לפני הריצה |
| זמן העלייה | ארוך יותר: פירוש וחימום בהתחלה | קצר, אין חימום |
| על מה האופטימיזציה נשענת | המעבד המדויק וההתנהגות שנצפתה | פחות מידע מזמן ריצה |
| מה מפיצים | Bytecode שרץ על כל JVM | קוד מכונה לפלטפורמה אחת |
עכשיו העתיקו את הקובץ שבניתם ל-Linux שרץ על מעבד ARM, או למחשב Windows. באופן טבעי הוא לא ירוץ שם: ההוראות בו כתובות למעבד x64 ולמערכת Linux, ובתוכו אין שום שכבה שתתאים אותן. לכל יעד כזה צריך לבנות קובץ נפרד.
Meter.class, לעומת זאת, עובר לכל אחד מהמחשבים האלה כמו שהוא, כי שם מחכה לו JVM שנבנתה במיוחד לאותה פלטפורמה. זה המחיר שמשלמים על AOT בניידות.
טעויות נפוצות
- את JIT מפעילים כשמתקינים את התוכנית, ואת AOT כשקוראים למתודה לראשונה. שניהם לא. JIT פועל בזמן הריצה, ו-AOT לפני הריצה.
- JIT הוא בעצם מפרש שמתקדם לאורך הקוד. זה תיאור של Interpreter. JIT מהדר לקוד מכונה.
- JIT מהדר מראש, ו-AOT מהדר בזמן הריצה. זה בדיוק הפוך, כפי שמרמזים השמות: Just-In-Time מול Ahead-Of-Time.
- JIT רץ פעם אחת לפני ההפעלה, ולכן אין לו השפעה על הביצועים בזמן הריצה. JIT פועל לאורך הריצה, וזו כל המהות שלו.
- קובץ שהודר ב-AOT רץ על כל פלטפורמה. הוא קוד מכונה של פלטפורמה אחת.
- קובץ AOT ירוץ על כל מעבד, בתנאי שמערכת ההפעלה זהה. קוד מכונה תלוי גם בסוג המעבד. קובץ ל-x64 לא ירוץ באופן טבעי על ARM, גם תחת אותה מערכת הפעלה; הוא יכול לרוץ שם רק דרך שכבת אמולציה של מערכת ההפעלה, שאיננה חלק מהקובץ.
- AOT מפיק Bytecode קומפקטי יותר. AOT מפיק קוד מכונה, לא Bytecode.
AOT ו-JIT יחד
שתי הגישות לא סותרות זו את זו. עקבו אחרי מתודה אחת, נאמר Price מתוכנית הכרטיסים, באפליקציית .NET שפורסמה עם ReadyToRun:
- בזמן הבנייה (build), כלי ReadyToRun כבר מתרגם את
Priceלקוד מכונה ושומר אותו בתוך הקובץ שמופץ. - בהפעלה הקוד המוכן משמש מייד, בלי לחכות ל-JIT, ולכן האפליקציה עולה מהר.
Priceנקראת שוב ושוב. ה-CLR מזהה שהיא חמה ושולח אותה ל-JIT, שמהדר אותה מחדש עם אופטימיזציה מלאה, ב-Tier1.- מכאן הקריאות עוברות לגרסה של ה-JIT, שמותאמת למעבד ולמה שקרה בריצה.
החלוקה ברורה: ההידור המוקדם לוקח על עצמו את רגעי הפתיחה, וה-JIT את מה שרץ הכי הרבה לאורך שעות וימים. ושימו לב לשלב השלישי: קוד שהודר מראש הוא רק נקודת פתיחה, וה-JIT רשאי להחליף אותו.
טעויות נפוצות
- בזכות AOT אין יותר צורך ב-Bytecode, ומתקבל קובץ אחד שמתאים לכל המעבדים. קוד AOT קשור לפלטפורמה שאליה הודר.
- מה שהודר ב-AOT הוא סופי, וה-JIT לא יכול לשפר אותו. בשילוב, ה-JIT מהדר מחדש את הקוד החם ומחליף את הגרסה שהודרה מראש.
- AOT מאיץ את התוכנית כי הוא מבטל את בדיקות הגבולות של מערכים. בדיקות הגבולות הן חלק מהגדרת השפה, והן נשארות גם בקוד שהודר מראש.
בדקו את עצמכם
כלי שורת פקודה מופעל מתוך סקריפט אלפי פעמים ביום, וכל הפעלה נמשכת שבריר שנייה. JIT או AOT?
AOT. כשכל הפעלה קצרה כל כך, זמן העלייה הוא רוב העלות, וה-JIT לא יספיק להתחמם לפני שהתהליך נגמר.
ובשרת מסחר שרץ ברציפות חודשים ומבצע את אותם חישובים שוב ושוב?
כאן JIT מצטיין: זמן העלייה זניח ביחס לחודשי הריצה, וה-JIT מתאים את הקטעים שרצים הכי הרבה למעבד ולפרופיל האמיתיים. אפשר גם לשלב, עם קוד מוכן מראש לעלייה ו-JIT לטווח הארוך.
סיכום
הנה התמונה המלאה של חיי תוכנית Java, מקובץ המקור ועד הוראות המעבד, לפי סדר ההתרחשות:
- הידור לקוד ביניים:
javacמתרגם את קובץ ה-java ל-Bytecode, ומפיק קובץ class נפרד לכל מחלקה. כל קובץ class נפתח במספר הקסם 0xCAFEBABE ונושא מספר גרסה. - הפעלת המכונה: הפקודה
java Mainמעלה את ה-JVM, שהיא עצמה תלויה במעבד ובמערכת ההפעלה, ובזכות זה ה-Bytecode נשאר נייד. - טעינה: ה-Class Loader טוען את Main כשהיא נדרשת, ופונה קודם ל-loader ההורה. המחלקה עוברת Linking (אימות, הכנה ופתרון הפניות) ואחריו Initialization, שבו רצים בלוקי ה-static.
- נקודת הכניסה: ה-JVM קוראת ל-
public static void main(String[] args), ובמערך מגיעים הארגומנטים שנכתבו אחרי שם המחלקה. - פירוש: ה-Interpreter מבצע את ה-Bytecode הוראה אחר הוראה, מפענח כל הוראה מחדש בכל ביצוע, ובמקביל סופר קריאות וחזרות של לולאות.
- הידור בזמן ריצה: קוד שהתחמם עובר ל-C1, והחם ביותר ל-C2, שמפעיל Inlining, Escape Analysis ואופטימיזציות לולאה. לולאה ארוכה שכבר רצה עוברת לקוד המהודר באמצע, ב-OSR.
- תיקון הימורים: הנחה ספקולטיבית שנשברת מפעילה Deoptimization: חזרה ל-Interpreter, ואחר כך הידור מחדש.
- לאורך כל הדרך: ה-Garbage Collector מפנה מהערימה אובייקטים שאי אפשר עוד להגיע אליהם.
- בסוף: התהליך נגמר וקוד המכונה נעלם איתו, כך שההרצה הבאה מתחילה שוב בפירוש.
| מושג | מה לזכור | המלכודת הנפוצה |
|---|---|---|
| Bytecode | קוד ביניים של ה-JVM: אותו קובץ class לכל מחשב | לחשוב שזה קוד מכונה של המעבד |
| JVM | נבנית בנפרד לכל פלטפורמה, וכך ה-Bytecode לא צריך להשתנות; טוענת, מאמתת, מריצה ומנהלת זיכרון | לחשוב שהיא זהה בכל המחשבים |
| Class Loader | מחלקה נטענת כשמישהו צריך אותה, והבקשה עולה קודם להורה | לחשוב שכל המחלקות נטענות כבר בהפעלה |
| main | ב-Java public static void main(String[] args), ב-C# static void Main | לשכוח את static |
| Interpreter | מתחיל מייד, ומשלם על פענוח של כל הוראה בכל פעם מחדש | לחשוב שהוא קורא את הקובץ או מאמת אותו בכל איטרציה |
| JIT | קוד מכונה ב-code cache של התהליך, שנעלם בסוף ההרצה | לחשוב שהוא נכתב לקובץ ה-class |
| Tiered Compilation | Interpreter, C1 ו-C2 בזה אחר זה, לפי החום | לחשוב שהם רצים במקביל או נבחרים לפי גודל המתודה |
| Deoptimization | הנחה נפלה: פסילה, פירוש, ובהמשך הידור חדש; התוצאה נשארת נכונה | לחשוב שהתוצאה עלולה להשתבש או שהתוכנית נעצרת |
| AOT | קוד מכונה מוכן לפני הריצה: עלייה מהירה, קובץ לפלטפורמה אחת | לחשוב שהקובץ ירוץ בכל מקום |
| CIL ו-CLR | ה-CLR מתרגם CIL לקוד מכונה כשמתודה נדרשת לראשונה | לחשוב שה-dll כבר מכיל קוד מכונה |