जावा में, इंट की बजाय बाइट या शॉर्ट का उपयोग करना अधिक कुशल है और डबल के बजाय फ्लोट?

Question 1

मैंने देखा है कि मैंने हमेशा int का उपयोग किया है और कोई फर्क नहीं पड़ता कि संख्या कितनी छोटी या बड़ी होनी चाहिए। जावा में तो, इसे और अधिक उपयोग करने के लिए सक्षम है byteया shortके बजाय intऔर floatके बजाय double?

तो मान लीजिए कि मेरे पास बहुत सारे चीटियों और युगल के साथ एक कार्यक्रम है। अगर मैं जानता था कि संख्या फिट होगी, तो क्या यह मेरी बाइट्स को शॉर्ट्स या बाइट्स में बदलने और बदलने के लायक होगा?

मुझे पता है कि जावा में अहस्ताक्षरित प्रकार नहीं हैं, लेकिन क्या कुछ अतिरिक्त है अगर मैं जानता था कि संख्या केवल सकारात्मक होगी?

कुशल से मेरा मतलब ज्यादातर प्रोसेसिंग से है। मुझे लगता है कि कचरा संग्रहकर्ता बहुत तेज होगा यदि सभी चर आधे आकार के होंगे और गणना कुछ हद तक तेज होगी। (मुझे लगता है कि जब से मैं Android पर काम कर रहा हूँ मुझे कुछ हद तक राम के बारे में भी चिंता करने की ज़रूरत है)

(मुझे लगता है कि कचरा कलेक्टर केवल वस्तुओं के साथ व्यवहार करता है और आदिम नहीं है, लेकिन अभी भी परित्यक्त वस्तुओं में सभी प्राथमिकताओं को हटा देता है?)

मैंने इसे एक छोटे से एंड्रॉइड ऐप के साथ आज़माया, लेकिन वास्तव में मुझे बिल्कुल भी फर्क नहीं पड़ा। (हालांकि मैं "वैज्ञानिक रूप से" कुछ भी मापता नहीं था।)

क्या मैं यह मानने में गलत हूं कि यह तेज और अधिक कुशल होना चाहिए? मैं अपना समय बर्बाद करने के लिए एक बड़े पैमाने पर कार्यक्रम के माध्यम से जाने और सब कुछ बदलने से नफरत करता हूं।

जब मैं एक नई परियोजना शुरू करूंगा तो क्या यह शुरू से ही करने योग्य होगा? (मेरा मतलब है कि मुझे लगता है कि हर छोटी मदद करेगा, लेकिन फिर अगर ऐसा है, तो ऐसा क्यों नहीं लगता कि कोई भी ऐसा करता है।)

Question 2

क्या मैं यह मानने में गलत हूं कि यह तेज और अधिक कुशल होना चाहिए? मैं अपना समय बर्बाद करने के लिए एक बड़े पैमाने पर कार्यक्रम के माध्यम से जाने और सब कुछ बदलने से नफरत करता हूं।

संक्षिप्त जवाब

हां, आप गलत हैं। ज्यादातर मामलों में, उपयोग की जाने वाली जगह के संदर्भ में यह बहुत कम फर्क पड़ता है।

यह इसे ऑप्टिमाइज़ करने की कोशिश करने लायक नहीं है ... जब तक आपके पास स्पष्ट सबूत न हों कि ऑप्टिमाइज़ेशन की आवश्यकता है। और यदि आपको विशेष रूप से ऑब्जेक्ट फ़ील्ड के मेमोरी उपयोग को अनुकूलित करने की आवश्यकता है, तो आपको संभवतः अन्य (अधिक प्रभावी) उपाय करने की आवश्यकता होगी।

लंबा उत्तर

जावा वर्चुअल मशीन मॉडल ऑफ़सेट्स का उपयोग करके स्टैक और ऑब्जेक्ट फ़ील्ड्स जो (प्रभाव में) एक 32 बिट आदिम सेल आकार के गुणक हैं। इसलिए जब आप स्थानीय वेरिएबल या ऑब्जेक्ट फील्ड को (जैसे) ए घोषित करते हैं byte, तो वेरिएबल / फील्ड को 32 बिट सेल में स्टोर किया जाएगा, जैसे ए int।

इसके दो अपवाद हैं:

longऔर doubleमानों के लिए 2 आदिम 32-बिट कोशिकाओं की आवश्यकता होती है
आदिम प्रकार के सरणियों को पैक रूप में दर्शाया जाता है, ताकि (उदाहरण के लिए) बाइट्स की एक सरणी प्रति 32 बिट शब्द में 4 बाइट्स रखती है।

तो यह और ... और आदिम के बड़े सरणियों के उपयोग को अनुकूलित करने के लायक हो सकता है । लेकिन सामान्य तौर पर नहीं।longdouble

^{सिद्धांत रूप में, एक JIT इसे अनुकूलित करने में सक्षम हो सकता है, लेकिन व्यवहार में मैंने कभी ऐसा JIT के बारे में नहीं सुना जो ऐसा करता हो। एक बाधा यह है कि आमतौर पर JIT तब तक नहीं चल सकती है जब तक कि संकलित किए जाने वाले वर्ग के उदाहरण नहीं बने हैं। यदि JIT मेमोरी लेआउट को अनुकूलित करता है, तो आप एक ही कक्षा के ऑब्जेक्ट के दो (या अधिक) "फ्लेवर" रख सकते हैं ... और यह बहुत बड़ी मुश्किल पेश करेगा।}

Revisitation

@ मेरिटॉन के उत्तर में बेंचमार्क परिणामों को देखते हुए, यह प्रतीत होता है कि उपयोग करने के बजाय shortऔर गुणन के लिए एक प्रदर्शन जुर्माना लगाता है। वास्तव में, यदि आप अलगाव में संचालन पर विचार करते हैं, तो जुर्माना महत्वपूर्ण है। (आप उन्हें अलगाव में विचार नहीं करना चाहिए ... लेकिन यह एक और विषय है।)byteint

मुझे लगता है कि स्पष्टीकरण यह है कि जेआईटी संभवत: प्रत्येक मामले में 32 बिट का गुणा निर्देश का उपयोग कर गुणा कर रही है। लेकिन byteऔर shortमामले में, यह मध्यवर्ती निर्देश 32 बिट मान को या प्रत्येक लूप पुनरावृत्ति में परिवर्तित करने के लिए अतिरिक्त निर्देशों को निष्पादित करता है । (सिद्धांत रूप में, यह रूपांतरण एक बार लूप के अंत में किया जा सकता है ... लेकिन मुझे संदेह है कि ऑप्टिमाइज़र यह पता लगाने में सक्षम होगा।)byteshort

वैसे भी, यह एक और समस्या के लिए स्विचन के साथ shortऔर byteएक अनुकूलन के रूप में इंगित करता है । यह प्रदर्शन को बदतर बना सकता है ... एक एल्गोरिथ्म में जो अंकगणित है और गहन गणना करता है।

Question 3

यह जेवीएम के कार्यान्वयन पर निर्भर करता है, साथ ही साथ अंतर्निहित हार्डवेयर भी। अधिकांश आधुनिक हार्डवेयर मेमोरी से सिंगल बाइट नहीं लाएंगे (या पहले स्तर के कैश से भी), यानी छोटे आदिम प्रकारों का उपयोग करने से आमतौर पर मेमोरी बैंडविड्थ की खपत कम नहीं होती है। इसी तरह, आधुनिक सीपीयू का शब्द आकार 64 बिट्स है। वे कम बिट्स पर ऑपरेशन कर सकते हैं, लेकिन यह अतिरिक्त बिट्स को त्यागकर काम करता है, जो या तो तेज नहीं है।

एकमात्र लाभ यह है कि छोटे आदिम प्रकार एक अधिक कॉम्पैक्ट मेमोरी लेआउट में परिणाम कर सकते हैं, सबसे विशेष रूप से सरणियों का उपयोग करते समय। यह मेमोरी को बचाता है, जो संदर्भ के स्थानीयता में सुधार कर सकता है (इस प्रकार कैश मिस की संख्या को कम करता है) और कचरा संग्रह को कम कर देता है।

आम तौर पर हालांकि, छोटे आदिम प्रकारों का उपयोग करना तेज नहीं है।

यह प्रदर्शित करने के लिए, निम्नलिखित बेंचमार्क निहारें:

package tools.bench;

import java.math.BigDecimal;

public abstract class Benchmark {

    final String name;

    public Benchmark(String name) {
        this.name = name;
    }

    abstract int run(int iterations) throws Throwable;

    private BigDecimal time() {
        try {
            int nextI = 1;
            int i;
            long duration;
            do {
                i = nextI;
                long start = System.nanoTime();
                run(i);
                duration = System.nanoTime() - start;
                nextI = (i << 1) | 1; 
            } while (duration < 100000000 && nextI > 0);
            return new BigDecimal((duration) * 1000 / i).movePointLeft(3);
        } catch (Throwable e) {
            throw new RuntimeException(e);
        }
    }   

    @Override
    public String toString() {
        return name + "\t" + time() + " ns";
    }

    public static void main(String[] args) throws Exception {
        Benchmark[] benchmarks = {
            new Benchmark("int multiplication") {
                @Override int run(int iterations) throws Throwable {
                    int x = 1;
                    for (int i = 0; i < iterations; i++) {
                        x *= 3;
                    }
                    return x;
                }
            },
            new Benchmark("short multiplication") {                   
                @Override int run(int iterations) throws Throwable {
                    short x = 0;
                    for (int i = 0; i < iterations; i++) {
                        x *= 3;
                    }
                    return x;
                }
            },
            new Benchmark("byte multiplication") {                   
                @Override int run(int iterations) throws Throwable {
                    byte x = 0;
                    for (int i = 0; i < iterations; i++) {
                        x *= 3;
                    }
                    return x;
                }
            },
            new Benchmark("int[] traversal") {                   
                @Override int run(int iterations) throws Throwable {
                    int[] x = new int[iterations];
                    for (int i = 0; i < iterations; i++) {
                        x[i] = i;
                    }
                    return x[x[0]];
                }
            },
            new Benchmark("short[] traversal") {                   
                @Override int run(int iterations) throws Throwable {
                    short[] x = new short[iterations];
                    for (int i = 0; i < iterations; i++) {
                        x[i] = (short) i;
                    }
                    return x[x[0]];
                }
            },
            new Benchmark("byte[] traversal") {                   
                @Override int run(int iterations) throws Throwable {
                    byte[] x = new byte[iterations];
                    for (int i = 0; i < iterations; i++) {
                        x[i] = (byte) i;
                    }
                    return x[x[0]];
                }
            },
        };
        for (Benchmark bm : benchmarks) {
            System.out.println(bm);
        }
    }
}

जो मेरी कुछ पुरानी नोटबुक पर प्रिंट करता है (कॉलम समायोजित करने के लिए रिक्त स्थान जोड़ रहा है):

int       multiplication    1.530 ns
short     multiplication    2.105 ns
byte      multiplication    2.483 ns
int[]     traversal         5.347 ns
short[]   traversal         4.760 ns
byte[]    traversal         2.064 ns

जैसा कि आप देख सकते हैं, प्रदर्शन अंतर काफी मामूली हैं। एल्गोरिदम का अनुकूलन आदिम प्रकार की पसंद से कहीं अधिक महत्वपूर्ण है।

Question 4

का उपयोग byteकरने के बजाय intअगर आप उन्हें एक बड़ी राशि में उपयोग कर रहे हैं प्रदर्शन बढ़ा सकते हैं। यहाँ एक प्रयोग है:

import java.lang.management.*;

public class SpeedTest {

/** Get CPU time in nanoseconds. */
public static long getCpuTime() {
    ThreadMXBean bean = ManagementFactory.getThreadMXBean();
    return bean.isCurrentThreadCpuTimeSupported() ? bean
            .getCurrentThreadCpuTime() : 0L;
}

public static void main(String[] args) {
    long durationTotal = 0;
    int numberOfTests=0;

    for (int j = 1; j < 51; j++) {
        long beforeTask = getCpuTime();
        // MEASURES THIS AREA------------------------------------------
        long x = 20000000;// 20 millions
        for (long i = 0; i < x; i++) {
                           TestClass s = new TestClass(); 

        }
        // MEASURES THIS AREA------------------------------------------
        long duration = getCpuTime() - beforeTask;
        System.out.println("TEST " + j + ": duration = " + duration + "ns = "
                + (int) duration / 1000000);
        durationTotal += duration;
        numberOfTests++;
    }
    double average = durationTotal/numberOfTests;
    System.out.println("-----------------------------------");
    System.out.println("Average Duration = " + average + " ns = "
            + (int)average / 1000000 +" ms (Approximately)");


}

}

यह वर्ग एक नया बनाने की गति का परीक्षण करता है TestClass। प्रत्येक परीक्षण इसे 20 मिलियन बार करता है और 50 परीक्षण होते हैं।

यहाँ TestClass है:

 public class TestClass {
     int a1= 5;
     int a2= 5; 
     int a3= 5;
     int a4= 5; 
     int a5= 5;
     int a6= 5; 
     int a7= 5;
     int a8= 5; 
     int a9= 5;
     int a10= 5; 
     int a11= 5;
     int a12=5; 
     int a13= 5;
     int a14= 5; 
 }

मैंने SpeedTestकक्षा चलाई है और अंत में इसे मिला है:

 Average Duration = 8.9625E8 ns = 896 ms (Approximately)

अब मैं टेस्टक्लास में बट्स को बाइट्स में बदल रहा हूं और इसे फिर से चला रहा हूं। यहाँ परिणाम है:

 Average Duration = 6.94375E8 ns = 694 ms (Approximately)

मेरा मानना है कि इस प्रयोग से पता चलता है कि यदि आप बड़ी मात्रा में वेरिएबल का उपयोग कर रहे हैं, तो इंट के बजाय बाइट का उपयोग करने से दक्षता बढ़ सकती है

Question 5

बाइट को आम तौर पर 8 बिट माना जाता है। शॉर्ट को आमतौर पर 16 बिट्स माना जाता है।

"शुद्ध" वातावरण में, जो बाइट्स और लॉन्ग के सभी कार्यान्वयन के रूप में जावा नहीं है, और शॉर्ट्स, और अन्य मजेदार चीजें आम तौर पर आपसे छिपी होती हैं, बाइट अंतरिक्ष का बेहतर उपयोग करती है।

हालाँकि, आपका कंप्यूटर शायद 8 बिट नहीं है, और यह शायद 16 बिट नहीं है। इसका मतलब यह है कि विशेष रूप से 16 या 8 बिट्स प्राप्त करने के लिए, "ट्रिकरी" का सहारा लेना होगा, जो समय को बर्बाद करने का दिखावा करता है ताकि जरूरत पड़ने पर उन प्रकारों को एक्सेस करने की क्षमता हो।

इस बिंदु पर, यह निर्भर करता है कि हार्डवेयर कैसे लागू किया जाता है। हालाँकि, जब से मुझे खरीदा गया है, सबसे अच्छी गति उन चीज़ों को संग्रहीत करने से प्राप्त हुई है जो आपके CPU के उपयोग के लिए आरामदायक हैं। 64 बिट प्रोसेसर 64 बिट तत्वों के साथ काम करना पसंद करता है, और इससे कम कुछ भी अक्सर "इंजीनियरिंग जादू" की आवश्यकता होती है यह दिखावा करने के लिए कि यह उनके साथ काम करना पसंद करता है।

Question 6

शॉर्ट / बाइट / चार के कम प्रदर्शन का एक कारण इन डेटा प्रकारों के लिए सीधे समर्थन की कमी है। प्रत्यक्ष समर्थन से, इसका मतलब है, जेवीएम विनिर्देशों में इन डेटा प्रकारों के लिए कोई निर्देश निर्धारित नहीं है। स्टोर, लोड, ऐड आदि जैसे निर्देशों में इंट डेटा टाइप के लिए संस्करण हैं। लेकिन उनके पास लघु / बाइट / चार के लिए संस्करण नहीं हैं। उदा नीचे जावा कोड पर विचार करें:

void spin() {
 int i;
 for (i = 0; i < 100; i++) {
 ; // Loop body is empty
 }
}

समान नीचे दिए गए मशीन कोड में परिवर्तित हो जाता है।

0 iconst_0 // Push int constant 0
1 istore_1 // Store into local variable 1 (i=0)
2 goto 8 // First time through don't increment
5 iinc 1 1 // Increment local variable 1 by 1 (i++)
8 iload_1 // Push local variable 1 (i)
9 bipush 100 // Push int constant 100
11 if_icmplt 5 // Compare and loop if less than (i < 100)
14 return // Return void when done

अब, नीचे के रूप में संक्षिप्त को बदलने पर विचार करें।

void sspin() {
 short i;
 for (i = 0; i < 100; i++) {
 ; // Loop body is empty
 }
}

संबंधित मशीन कोड निम्नानुसार बदल जाएगा:

0 iconst_0
1 istore_1
2 goto 10
5 iload_1 // The short is treated as though an int
6 iconst_1
7 iadd
8 i2s // Truncate int to short
9 istore_1
10 iload_1
11 bipush 100
13 if_icmplt 5
16 return

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

अब, इस प्रकार प्रत्यक्ष समर्थन न देने का कारण बताया गया है:

जावा वर्चुअल मशीन टाइप इंट के डेटा के लिए सबसे सीधा समर्थन प्रदान करता है। यह आंशिक रूप से जावा वर्चुअल मशीन के ऑपरेंड स्टैक और स्थानीय चर सरणियों के कुशल कार्यान्वयन की प्रत्याशा में है। यह विशिष्ट कार्यक्रमों में इंट डेटा की आवृत्ति से भी प्रेरित है। अन्य अभिन्न प्रकारों का प्रत्यक्ष समर्थन कम है। उदाहरण के लिए, स्टोर का कोई बाइट, चार या लघु संस्करण नहीं हैं, लोड या निर्देश जोड़ें।

यहाँ मौजूद JVM विनिर्देशन से उद्धृत (पृष्ठ 58)।

Question 7

अंतर शायद ही ध्यान देने योग्य है! यह डिजाइन, औचित्य, एकरूपता, आदत, आदि का सवाल है ... कभी-कभी यह सिर्फ स्वाद की बात है। जब तुम सब के बारे में परवाह है कि अपने कार्यक्रम और चल रहा है और प्रतिस्थापन एक उठ जाता है है floatएक के लिए intशुद्धता को नुकसान नहीं होगा, मैं एक के लिए जा रहा में कोई फायदा नहीं दिखता है या किसी अन्य जब तक आप प्रदर्शन कर सकते हैं कि किसी भी प्रकार बदलती जाए प्रदर्शन का उपयोग कर। 2 या 3 बाइट्स में भिन्न प्रकार के आधार पर ट्यूनिंग प्रदर्शन वास्तव में आखिरी चीज है जिसे आपको ध्यान देना चाहिए; डोनाल्ड नुथ ने एक बार कहा था: "समयपूर्व अनुकूलन सभी बुराई की जड़ है" (यह सुनिश्चित नहीं था कि यह उसका था, यदि आपके पास उत्तर है तो संपादित करें)।