समकक्ष स्थिर और गैर स्थिर तरीकों की गति में बड़ा अंतर

Question 1

इस कोड में जब मैं mainविधि में एक ऑब्जेक्ट बनाता हूं और फिर उस ऑब्जेक्ट विधि को कॉल करता ff.twentyDivCount(i)हूं : (16010 एमएस में चलता है), यह एनोटेशन का उपयोग करके इसे कॉल करने की तुलना में बहुत तेज चलता है: twentyDivCount(i)(59516 एमएस में चलता है)। बेशक, जब मैं इसे एक ऑब्जेक्ट बनाए बिना चलाता हूं, तो मैं विधि को स्थिर बनाता हूं, इसलिए इसे मुख्य में कहा जा सकता है।

public class ProblemFive {

    // Counts the number of numbers that the entry is evenly divisible by, as max is 20
    int twentyDivCount(int a) {    // Change to static int.... when using it directly
        int count = 0;
        for (int i = 1; i<21; i++) {

            if (a % i == 0) {
                count++;
            }
        }
        return count;
    }

    public static void main(String[] args) {
        long startT = System.currentTimeMillis();;
        int start = 500000000;
        int result = start;

        ProblemFive ff = new ProblemFive();

        for (int i = start; i > 0; i--) {

            int temp = ff.twentyDivCount(i); // Faster way
                       // twentyDivCount(i) - slower

            if (temp == 20) {
                result = i;
                System.out.println(result);
            }
        }

        System.out.println(result);

        long end = System.currentTimeMillis();;
        System.out.println((end - startT) + " ms");
    }
}

EDIT: अब तक ऐसा लगता है कि विभिन्न मशीनें अलग-अलग परिणाम देती हैं, लेकिन JRE 1.8 का उपयोग करते हुए। जहां मूल परिणाम लगातार पुन: उत्पन्न होता है।

Question 2

JRE 1.8.0_45 के उपयोग से मुझे समान परिणाम मिलते हैं।

जाँच पड़ताल:

साथ जावा चल रहा है -XX:+UnlockDiagnosticVMOptions -XX:+PrintCompilation -XX:+PrintInliningVM विकल्पों के पता चलता है कि दोनों विधियां संकलित और अंतर्निर्मित हैं
तरीकों के लिए उत्पन्न विधानसभा को देखते हुए स्वयं कोई महत्वपूर्ण अंतर नहीं दिखाता है
एक बार जब वे अंतर्निर्मित हो जाते हैं, हालांकि, भीतर उत्पन्न विधानसभा mainबहुत अलग होती है, उदाहरण के तरीके को अधिक आक्रामक रूप से अनुकूलित किया जाता है, विशेष रूप से लूप ट्रोलिंग के संदर्भ में

मैंने फिर आपके परीक्षण को फिर से चलाया लेकिन ऊपर दिए गए संदेह की पुष्टि करने के लिए अलग-अलग लूप की सेटिंग के साथ। मैंने आपका कोड इसके साथ चलाया:

-XX:LoopUnrollLimit=0 और दोनों विधियां धीरे-धीरे चलती हैं (डिफ़ॉल्ट विकल्पों के साथ स्थिर विधि के समान)।
-XX:LoopUnrollLimit=100 और दोनों विधियाँ तेजी से चलती हैं (डिफ़ॉल्ट विकल्पों के साथ उदाहरण विधि के समान)।

निष्कर्ष के रूप में ऐसा लगता है कि, डिफ़ॉल्ट सेटिंग्स के साथ, हॉटस्पॉट 1.8.0_45 का JIT विधि स्थिर होने पर लूप को अनियंत्रित करने में सक्षम नहीं है (हालांकि मुझे यकीन नहीं है कि यह उस तरह से व्यवहार क्यों करता है)। अन्य JVM अलग परिणाम दे सकते हैं।

Question 3

बस एक अप्रमाणित अनुमान एक एसिलियास के उत्तर पर आधारित है।

JVM लूप अनरोलिंग के लिए थ्रेशोल्ड का उपयोग करता है, जो कि 70 जैसा कुछ है। जो भी कारण से, स्थिर कॉल थोड़ा बड़ा है और अनियंत्रित नहीं होता है।

अद्यतन परिणाम

उसके साथ LoopUnrollLimit 52 नीचे में, दोनों संस्करणों धीमी गति से कर रहे हैं।
52 और 71 के बीच, केवल स्थिर संस्करण धीमा है।
71 से ऊपर, दोनों संस्करण तेज हैं।

यह अजीब है क्योंकि मेरा अनुमान था कि स्टेटिक कॉल आंतरिक प्रतिनिधित्व में थोड़ा बड़ा है और ओपी ने एक अजीब मामला मारा। लेकिन अंतर लगभग 20 का लगता है, जिसका कोई मतलब नहीं है।

-XX:LoopUnrollLimit=51
5400 ms NON_STATIC
5310 ms STATIC
-XX:LoopUnrollLimit=52
1456 ms NON_STATIC
5305 ms STATIC
-XX:LoopUnrollLimit=71
1459 ms NON_STATIC
5309 ms STATIC
-XX:LoopUnrollLimit=72
1457 ms NON_STATIC
1488 ms STATIC

प्रयोग करने के इच्छुक लोगों के लिए, मेरा संस्करण उपयोगी हो सकता है।

Question 4

जब इसे डीबग मोड में निष्पादित किया जाता है, तो संख्या उदाहरण और स्थिर मामलों के लिए समान होती है। इसका मतलब यह है कि जेआईटी स्टेटिक कोड को स्टैटिक केस में उसी तरह संकलित करने में हिचकिचाता है, जिस तरह से यह इंस्टीट्यूशन केस में करता है।

ऐसा क्यों करता है? यह कहना कठिन है; अगर यह एक बड़ा अनुप्रयोग होता तो शायद यह सही काम करता ...

Question 5

मैंने परीक्षण को थोड़ा मोड़ दिया और मुझे निम्नलिखित परिणाम मिले:

आउटपुट:

Dynamic Test:
465585120
232792560
232792560
51350 ms
Static Test:
465585120
232792560
232792560
52062 ms

ध्यान दें

जब मैं उन्हें अलग से परीक्षण कर रहा था तो मुझे गतिशील के लिए ~ 52 सेकंड और स्थैतिक के लिए ~ 200 सेकंड मिला।

यह कार्यक्रम है:

public class ProblemFive {

    // Counts the number of numbers that the entry is evenly divisible by, as max is 20
    int twentyDivCount(int a) {  // Change to static int.... when using it directly
        int count = 0;
        for (int i = 1; i<21; i++) {

            if (a % i == 0) {
                count++;
            }
        }
        return count;
    }

    static int twentyDivCount2(int a) {
         int count = 0;
         for (int i = 1; i<21; i++) {

             if (a % i == 0) {
                 count++;
             }
         }
         return count;
    }

    public static void main(String[] args) {
        System.out.println("Dynamic Test: " );
        dynamicTest();
        System.out.println("Static Test: " );
        staticTest();
    }

    private static void staticTest() {
        long startT = System.currentTimeMillis();;
        int start = 500000000;
        int result = start;

        for (int i = start; i > 0; i--) {

            int temp = twentyDivCount2(i);

            if (temp == 20) {
                result = i;
                System.out.println(result);
            }
        }

        System.out.println(result);

        long end = System.currentTimeMillis();;
        System.out.println((end - startT) + " ms");
    }

    private static void dynamicTest() {
        long startT = System.currentTimeMillis();;
        int start = 500000000;
        int result = start;

        ProblemFive ff = new ProblemFive();

        for (int i = start; i > 0; i--) {

            int temp = ff.twentyDivCount(i); // Faster way

            if (temp == 20) {
                result = i;
                System.out.println(result);
            }
        }

        System.out.println(result);

        long end = System.currentTimeMillis();;
        System.out.println((end - startT) + " ms");
    }
}

मैंने परीक्षण का क्रम भी बदल दिया है:

public static void main(String[] args) {
    System.out.println("Static Test: " );
    staticTest();
    System.out.println("Dynamic Test: " );
    dynamicTest();
}

और मुझे यह मिल गया:

Static Test:
465585120
232792560
232792560
188945 ms
Dynamic Test:
465585120
232792560
232792560
50106 ms

जैसा कि आप देखते हैं, यदि गतिशील को स्थिर से पहले कहा जाता है, तो स्थिर के लिए गति नाटकीय रूप से कम हो जाती है।

इस बेंचमार्क पर आधारित:

मैं परिकल्पना करता हूं कि यह सब जेवीएम अनुकूलन पर निर्भर करता है। इस प्रकार मैं आपको केवल स्थैतिक और गतिशील तरीकों के उपयोग के लिए अंगूठे के नियम के साथ जाने की सलाह देता हूं।

अंगूठे का नियम:

जावा: जब स्थिर विधियों का उपयोग करना है

Question 6

प्रयास करें:

public class ProblemFive {
    public static ProblemFive PROBLEM_FIVE = new ProblemFive();

    public static void main(String[] args) {
        long startT = System.currentTimeMillis();
        int start = 500000000;
        int result = start;


        for (int i = start; i > 0; i--) {
            int temp = PROBLEM_FIVE.twentyDivCount(i); // faster way
            // twentyDivCount(i) - slower

            if (temp == 20) {
                result = i;
                System.out.println(result);
                System.out.println((System.currentTimeMillis() - startT) + " ms");
            }
        }

        System.out.println(result);

        long end = System.currentTimeMillis();
        System.out.println((end - startT) + " ms");
    }

    int twentyDivCount(int a) {  // change to static int.... when using it directly
        int count = 0;
        for (int i = 1; i < 21; i++) {

            if (a % i == 0) {
                count++;
            }
        }
        return count;
    }
}