कोड इंप्रूविंग ट्रांसफॉर्मेशन (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 के लाभ

लाभ	विवरण
Execution Speed बढ़ाता है	अनावश्यक गणनाओं को हटाकर कोड तेज़ बनाता है।
Code Size कम करता है	अनावश्यक इंस्ट्रक्शंस को हटाकर कोड छोटा किया जाता है।
CPU Utilization सुधारता है	बेहतर ऑप्टिमाइज़ कोड से CPU संसाधनों का सही उपयोग होता है।

निष्कर्ष

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