Java Academy · पाठ

Dead-Code Elimination से बचना

Blackhole और state

पाठ 4, कुल 4 में से13 चरण

Dead-Code Elimination से बचना, CoddyKit पर Java Academy का एक निःशुल्क पाठ है। यह 4 में से 4वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह Java Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Java Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

मृत-कोड उन्मूलन से बचना

सूक्ष्म-बेंचमार्क की सबसे बड़ी समस्या मृत-कोड उन्मूलन (DCE) है: यदि JIT यह सिद्ध कर दे कि किसी परिणाम का उपयोग नहीं हो रहा, तो वह गणना हटा देता है। तब आपका बेंचमार्क कुछ भी नहीं मापता। JMH इससे बचने के लिए दो उपकरण देता है—मान लौटाना और Blackhole।

DCE की समस्या

यह लूप दस लाख बार वर्गमूल की गणना करता है, लेकिन परिणाम का कभी उपयोग नहीं करता। एक बुद्धिमान संकलक पूरे लूप को हटा सकता है।

public class Main {
    public static void main(String[] args) {
        long t = System.nanoTime();
        for (int i = 0; i < 1_000_000; i++) {
            double ignored = Math.sqrt(i); // result thrown away
        }
        System.out.println("ns: " + (System.nanoTime() - t));
    }
}

समाधान 1: परिणाम लौटाएँ

सबसे आसान बचाव है कि @Benchmark method से गणना किया गया मान लौटाएँ। JMH लौटाए गए प्रत्येक मान का उपभोग करता है, इसलिए JVM यह सिद्ध नहीं कर सकती कि वह अप्रयुक्त है।

import org.openjdk.jmh.annotations.Benchmark;

public class Bench {
    @Benchmark
    public double sqrt() {
        return Math.sqrt(42.0); // returned -> consumed by JMH
    }
}

समाधान 2: Blackhole

जब कोई बेंचमार्क कई मान उत्पन्न करता हो या आप कोई मान लौटा न सकते हों, तो Blackhole डालें और consume(...) चलाएँ। Blackhole JIT को विश्वास दिलाता है कि प्रत्येक मान का उपयोग हो रहा है, जबकि वास्तविक कार्य की लागत नहीं आती।

import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.infra.Blackhole;

public class Bench {
    @Benchmark
    public void manyValues(Blackhole bh) {
        for (int i = 0; i < 100; i++) {
            bh.consume(Math.sqrt(i));
        }
    }
}

@State ऑब्जेक्ट

@State class ऐसे इनपुट रखती है, जो अनुकूलक के लिए अपारदर्शी होते हैं और स्थिरांक फोल्डिंग को रोकते हैं। JMH इसका उदाहरण बनाकर इसे आपके बेंचमार्क में भेजता है। दायरा Thread, Benchmark (साझा) या Group हो सकता है।

import org.openjdk.jmh.annotations.*;

public class Bench {
    @State(Scope.Thread)
    public static class Data {
        public int x = 21;
    }

    @Benchmark
    public int multiply(Data d) {
        return d.x * 2; // d.x is not a compile-time constant
    }
}

@Setup और @TearDown

@State class के अंदर @Setup से चिह्नित विधियाँ मापन से पहले और @TearDown से चिह्नित विधियाँ बाद में चलती हैं। Level आवृत्ति नियंत्रित करता है: Trial (एक बार), Iteration या Invocation।

import org.openjdk.jmh.annotations.*;

@State(Scope.Thread)
public class Data {
    int[] arr;
    @Setup(Level.Trial)
    public void init() {
        arr = new int[1000];
        for (int i = 0; i < arr.length; i++) arr[i] = i;
    }
}

स्थिर इनपुट से बचें

परीक्षणाधीन विधि को कभी भी शाब्दिक स्थिरांक न दें। Math.sqrt(2.0) को स्थिरांक में बदला जा सकता है, लेकिन Math.sqrt(state.value) को नहीं। इनपुट हमेशा किसी @State फ़ील्ड से लें।

एकाधिक मान लौटाना

यदि आपका बेंचमार्क स्वाभाविक रूप से दो परिणाम उत्पन्न करता है, तो आप एक परिणाम लौटा सकते हैं और दूसरे को ब्लैकहोल के माध्यम से consume कर सकते हैं, या दोनों को मिला सकते हैं। किसी एक परिणाम को consume किए बिना छोड़ने पर DCE की समस्या फिर पैदा हो जाती है।

import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.infra.Blackhole;

public class Bench {
    @Benchmark
    public int twoResults(Blackhole bh) {
        int a = 3 * 7;
        int b = 5 + 9;
        bh.consume(b);
        return a;
    }
}

ब्लैकहोल की अतिरिक्त लागत

ब्लैकहोल को अत्यंत कम लागत वाला और स्वयं भी अनुकूलन के प्रति प्रतिरोधी बनाया गया है, लेकिन यह पूरी तरह निःशुल्क नहीं है। बहुत तेज़ संचालन के लिए एक ही मान लौटाना पसंद करें; लूप और एकाधिक मानों के लिए Blackhole का उपयोग सुरक्षित रखें।

अपने आँकड़ों की युक्तिसंगतता जाँचें

यदि कोई बेंचमार्क असंभव रूप से कम समय बताता है (वास्तविक कार्य के लिए नैनोसेकंड से भी कम), तो DCE या स्थिरांक फोल्डिंग की आशंका करें। फिर जाँचें कि परिणाम लौटाए या consume किए जा रहे हैं और इनपुट @State से आ रहे हैं।

सब कुछ एक साथ

एक विश्वसनीय बेंचमार्क में इनपुट किसी @State ऑब्जेक्ट से पढ़े जाते हैं, कार्य किया जाता है, और परिणाम या तो return किया जाता है या Blackhole.consume किया जाता है। इन तीन आदतों के साथ DCE और स्थिरांक फोल्डिंग आपके मापों को बिगाड़ नहीं सकते।

त्वरित जाँच

मृत-कोड निष्कासन को रोकने की अपनी समझ का परीक्षण करें।

इंटरैक्टिव पाठ में इसका उत्तर दें

पुनरावलोकन

आपने बेंचमार्क को विश्वसनीय बनाए रखना सीखा:

मृत-कोड निष्कासन उपयोग में न आने वाली गणनाओं को हटा देता है।
एक परिणाम लौटाएँ, ताकि JMH उसे consume कर सके।
लूप और एकाधिक मानों के लिए Blackhole.consume का उपयोग करें।
@State ऑब्जेक्ट इनपुट को अपारदर्शी रखते हैं और स्थिरांक फोल्डिंग को रोकते हैं।
@Setup / @TearDown चुने गए स्तर पर स्थिति तैयार और साफ़ करते हैं।

शुरुआत निःशुल्क

एआई शिक्षक के साथ Java सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 104
पाठ: 374

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “Dead-Code Elimination से बचना” पाठ निःशुल्क है?

हाँ—“Dead-Code Elimination से बचना” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और Java Academy पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। Java Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“Dead-Code Elimination से बचना” में मैं क्या सीखूँगा?

Blackhole और state आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Java Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या Java Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Java Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 4वाँ पाठ है।

“Dead-Code Elimination से बचना” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस Java Academy पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर Java Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

← Java Academy पर वापस जाएँ