জাভাতে, ডাবলির পরিবর্তে ইনট এবং ফ্লোটের পরিবর্তে বাইট বা সংক্ষিপ্ত ব্যবহার করা আরও দক্ষ?

Question 1

আমি লক্ষ করেছি যে আমি সর্বদা ইনট ব্যবহার করেছি এবং সংখ্যাটি যত ছোট বা বড় হওয়া উচিত তা দ্বিগুণ। সুতরাং জাভাতে, এটি ব্যবহার করা আরও দক্ষ byteবা shortপরিবর্তে intএবং floatপরিবর্তে double?

সুতরাং ধরুন আমার কাছে প্রচুর পরিমাণে ইনট এবং ডাবলস রয়েছে। যদি আমি জানতাম যে নম্বরটি মাপসই হবে তবে কি আমার প্রবেশপথটি বাইট বা শর্টসগুলিতে পরিবর্তন করা উচিত?

আমি জানি যে জাভাতে স্বাক্ষরবিহীন প্রকার নেই তবে আমি কী জানি সংখ্যাটি ইতিবাচক হবে যদি আমি অতিরিক্ত কিছু করতে পারি?

দক্ষতার দ্বারা আমি বেশিরভাগই প্রক্রিয়াজাতকরণ মানে। আমি ধরে নিয়েছি আবর্জনা সংগ্রহকারী অনেক দ্রুত হবে যদি সমস্ত ভেরিয়েবলগুলি অর্ধেক আকারের হয় এবং সেই গণনাগুলি সম্ভবত কিছুটা দ্রুতও হত। (আমি অনুমান করি যেহেতু আমি অ্যান্ড্রয়েডে কাজ করছি তখনই আমাকে র‌্যাম সম্পর্কে কিছুটা চিন্তা করতে হবে)

(আমি ধরে নিলাম আবর্জনা সংগ্রহকারী কেবলমাত্র অবজেক্টের সাথে ডিল করি এবং আদিম নয় তবে তবুও পরিত্যক্ত বস্তুগুলিতে সমস্ত আদিমকে মুছে ফেলেছি?)

আমি এটি একটি ছোট অ্যান্ড্রয়েড অ্যাপ্লিকেশন দিয়ে চেষ্টা করেছি কিন্তু আসলেই কোনও পার্থক্য লক্ষ্য করিনি। (যদিও আমি "বৈজ্ঞানিকভাবে" কিছুই পরিমাপ করি নি))

আমি কী ধরে নিচ্ছি যে এটি দ্রুত এবং আরও দক্ষ হওয়া উচিত? আমি আমার সময় নষ্ট করছি তা খুঁজে পেতে আমি একটি বিশাল প্রোগ্রামের মধ্যে দিয়ে যেতে এবং সমস্ত কিছু পরিবর্তন করতে ঘৃণা করব।

আমি যখন নতুন প্রকল্প শুরু করি তখন কি এটি শুরু থেকেই করা উচিত? (আমি বোঝাতে চাইছি প্রতিটি সামান্য কিছু সাহায্য করবে তবে আবার যদি তা হয় তবে কেন কেউ মনে করে না কেন))

Question 2

আমি কী ধরে নিচ্ছি যে এটি দ্রুত এবং আরও দক্ষ হওয়া উচিত? আমি আমার সময় নষ্ট করছি তা খুঁজে পেতে আমি একটি বিশাল প্রোগ্রামের মধ্যে দিয়ে যেতে এবং সমস্ত কিছু পরিবর্তন করতে ঘৃণা করব।

সংক্ষিপ্ত উত্তর

হ্যাঁ, আপনি ভুল বলেছেন। বেশিরভাগ ক্ষেত্রে, এটি ব্যবহৃত স্থানের ক্ষেত্রে সামান্য পার্থক্য করে।

এটি অপ্টিমাইজ করার চেষ্টা করা উপযুক্ত নয় ... যদি না আপনার কাছে প্রমাণ থাকে যে অপটিমাইজেশন প্রয়োজন। এবং যদি আপনি না প্রয়োজন বিশেষ করে বস্তুর ক্ষেত্র অপ্টিমাইজ মেমোরি ব্যবহার করার জন্য, সম্ভবত অন্যান্য (আরো কার্যকর) ব্যবস্থা গ্রহণ করতে হবে।

দীর্ঘ উত্তর

জাভা ভার্চুয়াল মেশিন মডেলগুলি 32 বিট আদিম ঘরের আকারের গুণমান (কার্যকরভাবে) অফসেট ব্যবহার করে স্ট্যাক এবং অবজেক্ট ফিল্ডগুলি। সুতরাং আপনি যখন স্থানীয় ভেরিয়েবল বা অবজেক্ট ফিল্ডকে (বলুন) হিসাবে ঘোষণা করেন byte, ভেরিয়েবল / ক্ষেত্রটি 32 বিটের একটি ঘরে যেমন সংরক্ষণ করা হবে int।

এর দুটি ব্যতিক্রম আছে:

longএবং doubleমানগুলির জন্য 2 আদিম 32-বিট কোষ প্রয়োজন
আদিম ধরণের অ্যারেগুলি প্যাকড আকারে উপস্থাপন করা হয়, যাতে (উদাহরণস্বরূপ) বাইটগুলির একটি অ্যারে 32 বিট শব্দ প্রতি 4 বাইট ধারণ করে hold

সুতরাং এটি আদিমতার এবং ... এবং বৃহত অ্যারেগুলির ব্যবহারের অনুকূলকরণের উপযুক্ত হতে পারে । তবে সাধারণভাবে না।longdouble

^{তত্ত্ব, একটি জে আই টি JIT পারে এই নিখুত পাবে, কিন্তু বাস্তবে আমি জে আই টি JIT যে আছে কথা শুনিনি করেছি। একটি প্রতিবন্ধকতা হ'ল জেআইটি সাধারণত ক্লাস সংকলনের উদাহরণ তৈরি না হওয়া পর্যন্ত চালানো যায় না। জেআইটি যদি মেমোরি লেআউটটিকে অনুকূলিত করে তোলে তবে আপনার একই শ্রেণীর বস্তুর দুটি (বা আরও বেশি) "স্বাদ" থাকতে পারে ... এবং এতে প্রচুর অসুবিধা হবে।}

পুনর্বিবেচনা

@ মেরিটনের উত্তরের মানদণ্ডের ফলাফলগুলি দেখে, এটি প্রদর্শিত হয় যে ব্যবহার shortএবং byteতার পরিবর্তে intগুণনের জন্য পারফরম্যান্স পেনাল্টি লাগাচ্ছে । প্রকৃতপক্ষে, যদি আপনি বিচ্ছিন্নভাবে অপারেশনগুলি বিবেচনা করেন, তবে শাস্তিটি উল্লেখযোগ্য। (আপনি এগুলিকে বিচ্ছিন্নভাবে বিবেচনা করবেন না ... তবে এটি অন্য একটি বিষয়))

আমি মনে করি ব্যাখ্যাটি হ'ল জেআইটি সম্ভবত প্রতিটি ক্ষেত্রে 32 বিট গুণিত নির্দেশাবলী ব্যবহার করে গুণগুলি করছে। কিন্তু এ byteএবং shortমামলা, এটা executes অতিরিক্ত নির্দেশাবলীর জন্য অন্তর্বর্তী 32 বিট মান রূপান্তর করতে byteবা shortপ্রতিটি লুপ পুনরাবৃত্তির। (তত্ত্ব অনুসারে, সেই রূপান্তরটি একবার লুপের শেষে করা যেতে পারে ... তবে আমি সন্দেহ করি যে অপ্টিমাইজারটি এটি নির্ধারণ করতে সক্ষম হবে))

যাইহোক, এটি অপটিমাইজেশন হিসাবে স্যুইচ করতে shortএবং অন্য সমস্যার দিকে ইঙ্গিত করে byte। এটি পারফরম্যান্সকে আরও খারাপ করতে পারে ... একটি অ্যালগরিদমে যা পাটিগণিত এবং গণনা নিবিড়।

Question 3

এটি জেভিএম বাস্তবায়নের পাশাপাশি অন্তর্নিহিত হার্ডওয়্যার নির্ভর করে। বেশিরভাগ আধুনিক হার্ডওয়্যার মেমরি থেকে একক বাইট আনবে না (বা এমনকি প্রথম স্তরের ক্যাশে থেকেও), যেমন ছোট আদিম ধরণের ব্যবহার সাধারণত মেমরির ব্যান্ডউইথ খরচ হ্রাস করে না। তেমনি, আধুনিক সিপিইউতে একটি শব্দ আকার রয়েছে b৪ বিট। তারা কম বিটগুলিতে অপারেশন করতে পারে, তবে এটি অতিরিক্ত বিটগুলি ফেলে দিয়ে কাজ করে যা দ্রুত হয় না।

একমাত্র সুবিধাটি হ'ল ছোট আদিম ধরণের ফলে আরও কমপ্যাক্ট মেমরি লেআউট হতে পারে, বিশেষত অ্যারে ব্যবহার করার সময় when এটি স্মৃতি সংরক্ষণ করে, যা রেফারেন্সের লোকালটিকে উন্নত করতে পারে (এভাবে ক্যাশে মিসের সংখ্যা হ্রাস করতে পারে) এবং আবর্জনা সংগ্রহের ওভারহেড হ্রাস করতে পারে।

তবে সাধারণত বললে, ছোট আদিম ধরণের ব্যবহারগুলি দ্রুত হয় না।

এটি প্রদর্শনের জন্য, নীচের মানদণ্ডটি দেখুন:

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 টি পরীক্ষা রয়েছে।

টেস্টক্লাস এখানে:

 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)

আমি বিশ্বাস করি যে এই পরীক্ষাটি দেখায় যে আপনি যদি প্রচুর পরিমাণে ভেরিয়েবল ইনস্ট্যান্স করে থাকেন তবে int এর পরিবর্তে বাইট ব্যবহার করা দক্ষতা বাড়াতে পারে

Question 5

বাইট সাধারণত 8 বিট হিসাবে বিবেচিত হয়। সংক্ষিপ্ত সাধারণত 16 বিট হিসাবে বিবেচিত হয়।

একটি "খাঁটি" পরিবেশে যা জাভা নয় যা বাইটস এবং লংগগুলি এবং শর্টসগুলি এবং অন্যান্য মজাদার জিনিসগুলি সাধারণত আপনার কাছ থেকে লুকানো থাকে, বাইট স্থানটির আরও ভাল ব্যবহার করে।

তবে আপনার কম্পিউটারটি সম্ভবত 8 বিট নয় এবং সম্ভবত এটি 16 বিট নয়। এর অর্থ হ'ল বিশেষত 16 বা 8 টি বিট পেতে, "কৌশল" অবলম্বন করা দরকার যা প্রয়োজনের সময় এই ধরণের অ্যাক্সেস করার ক্ষমতা রাখে এমন ভান করার জন্য সময় নষ্ট করে।

এই মুহুর্তে, এটি হার্ডওয়্যার কীভাবে প্রয়োগ করা হয় তার উপর নির্ভর করে। তবে আমার কাছ থেকে চেষ্টা করা হয়েছে, আপনার সিপিইউ ব্যবহারের জন্য স্বাচ্ছন্দ্যযুক্ত জিনিসগুলিতে জিনিসগুলি সংরক্ষণ করে সেরা গতি অর্জন করা হয়। একটি bit৪ বিট প্রসেসর bit৪ বিট উপাদানগুলির সাথে ডিল করতে পছন্দ করে এবং এর চেয়ে কম যে কোনও কিছুতে প্রায়ই "ইঞ্জিনিয়ারিং ম্যাজিক" প্রয়োজন হয় যে এটি তাদের সাথে ডিল করা পছন্দ করে।

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

যেমন আপনি পর্যবেক্ষণ করতে পারেন, সংক্ষিপ্ত তথ্য প্রকারের হস্তক্ষেপের জন্য, এটি এখনও ইন ডাটা টাইপ নির্দেশনা সংস্করণ ব্যবহার করছে এবং যখন প্রয়োজন হয় তখন স্পষ্টতই সংক্ষিপ্ত রূপান্তর করে। এখন, এই কারণে, কর্মক্ষমতা হ্রাস পায়।

এখন, সরাসরি সমর্থন না দেওয়ার কারণ হিসাবে নিম্নে উল্লেখ করা হয়েছে:

জাভা ভার্চুয়াল মেশিন ইন টাইপের ডেটার জন্য সর্বাধিক সরাসরি সমর্থন সরবরাহ করে। এটি আংশিকভাবে জাভা ভার্চুয়াল মেশিনের অপারেন্ড স্ট্যাক এবং স্থানীয় ভেরিয়েবল অ্যারেগুলির কার্যকর প্রয়োগের প্রত্যাশায় in এটি সাধারণ প্রোগ্রামগুলিতে ইনটার ডেটা ফ্রিকোয়েন্সি দ্বারা অনুপ্রাণিত হয়। অন্যান্য অবিচ্ছেদ্য ধরণের প্রত্যক্ষ সমর্থন কম থাকে। স্টোরের কোনও বাইট, চর বা সংক্ষিপ্ত সংস্করণ নেই, উদাহরণস্বরূপ লোড করুন বা নির্দেশাবলী যুক্ত করুন।

এখানে উপস্থিত জেভিএম নির্দিষ্টকরণ থেকে উদ্ধৃত (পৃষ্ঠা 58)।

Question 7

পার্থক্যটি খুব কমই লক্ষণীয়! এটি নকশা, যথাযথতা, অভিন্নতা, অভ্যাস ইত্যাদির আরও প্রশ্ন ... কখনও কখনও এটি কেবল স্বাদের বিষয়। যখন সমস্ত আপনি যত্নশীল যে আপনার প্রোগ্রাম এবং চলমান এবং বদলে একটি উঠে হয় floatএকটি জন্য intশুদ্ধি ক্ষতি করতে পারবে না, আমি এক যাচ্ছেন কোন সুবিধা দেখতে বা অন্য, যদি না আপনি দেখাতে পারি যে হয় টাইপ গন্ধে পরিবর্তন কর্মক্ষমতা ব্যবহার করে। 2 বা 3 বাইটের মধ্যে বিভিন্ন ধরণের ভিত্তিতে পারফরম্যান্স টিউন করা আপনার পক্ষে যত্ন নেওয়া উচিত এমন শেষ জিনিস; ডোনাল্ড নুথ একবার বলেছিলেন: "অকালীন অপটিমাইজেশন হ'ল সমস্ত অশুভের মূল" (নিশ্চিত নয় যে এটি তিনিই ছিলেন, আপনার উত্তর থাকলে সম্পাদনা করুন)।