Code Improving Transformations in Compiler Design in Hindi | कोड इंप्रूविंग ट्रांसफॉर्मेशन

कोड इंप्रूविंग ट्रांसफॉर्मेशन (Code Improving Transformations) क्या है?

Compiler Design में Code Improving Transformations का उपयोग प्रोग्राम के निष्पादन को बेहतर बनाने और **कोड ऑप्टिमाइजेशन** करने के लिए किया जाता है। इस प्रक्रिया में **अनावश्यक इंस्ट्रक्शंस हटाई जाती हैं, गणनाओं को सरल बनाया जाता है, और कोड के निष्पादन समय को कम किया जाता है**।

Code Improving Transformations की आवश्यकताएँ

• **Execution Speed** बढ़ाने के लिए।
• **Redundant Computations** को हटाने के लिए।
• **Memory और CPU Utilization** को बेहतर बनाने के लिए।

Code Improving Transformations के प्रकार

1. Common Subexpression Elimination (CSE)

यदि एक ही गणना बार-बार हो रही है, तो उसे **एक बार कैलकुलेट करके** पुनः उपयोग किया जाता है।

// Before Optimization
t1 = a + b
t2 = t1 * c
t3 = a + b
t4 = t3 * d

// After Optimization
t1 = a + b
t2 = t1 * c
t4 = t1 * d

2. Copy Propagation (कॉपी प्रोपेगेशन)

यदि एक वेरिएबल दूसरे वेरिएबल के बराबर है, तो उसे सीधे रिप्लेस किया जा सकता है।

// Before Optimization
x = y
z = x + 5

// After Optimization
z = y + 5

3. Dead Code Elimination (डेड कोड एलिमिनेशन)

ऐसा कोड जो कभी निष्पादित नहीं होता या जिसका उपयोग नहीं किया जाता, उसे हटा दिया जाता है।

// Before Optimization
int x = 10;
x = 20;  // x = 10 is never used

// After Optimization
int x = 20;

4. Constant Folding (स्थिर गणना को सरल बनाना)

Compile Time पर स्थिर गणनाओं को पहले ही हल कर दिया जाता है।

// Before Optimization
x = 10 * 20

// After Optimization
x = 200

5. Strength Reduction (स्ट्रेंथ रिडक्शन)

महंगे ऑपरेशंस (Multiplication, Division) को सस्ते ऑपरेशंस (Addition, Bit Shift) में बदला जाता है।

// Before Optimization
y = x * 8

// After Optimization
y = x << 3   // Left shift by 3 is equivalent to multiplication by 8

6. Loop Unrolling (लूप अनरोलिंग)

लूप की पुनरावृत्तियों को कम करने के लिए लूप बॉडी को कई बार दोहराया जाता है।

// Before Optimization
for (int i = 0; i < 4; i++) {
    arr[i] = i * 2;
}

// After Optimization (Loop Unrolling)
arr[0] = 0;
arr[1] = 2;
arr[2] = 4;
arr[3] = 6;

7. Loop Invariant Code Motion (लूप इनवेरिएंट कोड मूवमेंट)

इस तकनीक में **लूप के अंदर मौजूद स्थिर गणनाओं** को लूप के बाहर ले जाया जाता है ताकि वे बार-बार न चलें।

// Before Optimization
for (int i = 0; i < n; i++) {
    int x = 10;  // Unnecessary repetition
    arr[i] = x * i;
}

// After Optimization
int x = 10;  // Moved outside loop
for (int i = 0; i < n; i++) {
    arr[i] = x * i;
}

Code Improving Transformations के लाभ

निष्कर्ष

Code Improving Transformations कंपाइलर डिजाइन का एक महत्वपूर्ण भाग है, जो **Common Subexpression Elimination, Dead Code Elimination, Strength Reduction, और Loop Optimization** जैसी तकनीकों का उपयोग करके कोड को अधिक कुशल बनाता है।