একটি ভাল সি চলক দৈর্ঘ্যের অ্যারে উদাহরণ [বন্ধ]

Question

এই প্রশ্নটির পরিবর্তে এসও-তে একটি হিমশীতল অভ্যর্থনা পেল তাই আমি এটি এখানে মুছে ফেলার সিদ্ধান্ত নিয়েছি এবং পরিবর্তে এখানে চেষ্টা করব। আপনি যদি মনে করেন এটি এটি এখানেও খাপ খায় না তবে দয়া করে কমপক্ষে একটি পরামর্শ দিন যাতে আমি পরে কীভাবে একটি উদাহরণ খুঁজে পাব ...

আপনি কি উদাহরণ দিতে পারেন , যেখানে সি 99 ভিএলএএস ব্যবহার করে বর্তমান স্ট্যান্ডার্ড হিপ-সি ব্যবহার করে সি ++ আরআইআই প্রক্রিয়াগুলির মতো কোনও কিছুর উপরে প্রকৃত সুবিধা পাওয়া যায়?

আমি যে উদাহরণটি পরে যাচ্ছি তা হ'ল:

1. গাদা ব্যবহার করে সহজেই পরিমাপযোগ্য (10% হতে পারে) পারফরম্যান্স সুবিধা অর্জন করুন।
2. ভাল workaround না, যা মোটেও পুরো অ্যারের প্রয়োজন হবে না।
3. স্থির সর্বাধিক আকারের পরিবর্তে গতিশীল আকার ব্যবহার করে উপকার পাবেন।
4. সাধারণ ব্যবহারের দৃশ্যে স্ট্যাক ওভারফ্লো হওয়ার সম্ভাবনা নেই।
5. কোনও সি ++ প্রকল্পে একটি সি 99 উত্স ফাইল অন্তর্ভুক্ত করার জন্য পারফরম্যান্সের প্রয়োজন এমন একজন বিকাশকারীকে প্রলুব্ধ করতে যথেষ্ট শক্ত হন।

---

প্রসঙ্গে কিছু স্পেসিফিকেশন যুক্ত করা হচ্ছে: আমি সিএল দ্বারা বোঝানো ভিএলএর অর্থ এবং স্ট্যান্ডার্ড সি ++ এ অন্তর্ভুক্ত নয়: int array[n]যেখানে nএকটি পরিবর্তনশীল। এবং আমি ব্যবহারের ক্ষেত্রে উদাহরণের পরে আছি যেখানে এটি অন্যান্য মান (সি 90, সি ++ 11) দ্বারা সরবরাহিত বিকল্পগুলি ট্রাম্প করে:

int array[MAXSIZE]; // C stack array with compile time constant size
int *array = calloc(n, sizeof int); // C heap array with manual free
int *array = new int[n]; // C++ heap array with manual delete
std::unique_ptr<int[]> array(new int[n]); // C++ heap array with RAII
std::vector<int> array(n); // STL container with preallocated size

---

কিছু ধারণা:

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

উইকিপিডিয়ায় একটি উদাহরণ রয়েছে যা আমার মানদণ্ড পূরণ করে না , কারণ গাদা ব্যবহারের ব্যবহারিক পার্থক্য কমপক্ষে প্রসঙ্গ ছাড়াই অপ্রাসঙ্গিক বলে মনে হয়। এটিও অ-আদর্শ, কারণ আরও প্রসঙ্গ না থাকলে মনে হয় আইটেমের গণনা খুব ভাল স্ট্যাকের ওভারফ্লো করতে পারে cause

দ্রষ্টব্য: আমি বিশেষত একটি উদাহরণ কোড, বা একটি অ্যালগরিদমের পরামর্শের পরে যা এতে উপকৃত হবে, আমার নিজের জন্য উদাহরণটি বাস্তবায়নের জন্য।

Comments

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

— খ্রিস্টিয়াকক

@ ক্রাইসাইকক হ্যাঁ, খুব পেরেক পেরেকের সন্ধান করছে, তবে একটি হাতুড়ি যা আসলে বিদ্যমান (এটি C99 ভিএলএ হোক বা আসলে-কোনও-মানক নয় alloca , যা আমি মনে করি মূলত একই জিনিস)। তবে এই বহুবিবাহিত জিনিসটি ভাল, এটিকে অন্তর্ভুক্ত করার জন্য প্রশ্ন সম্পাদনা করুন!

— হাইড

ভিএলএসের একটি অসুবিধা হ'ল বরাদ্দ ব্যর্থতা সনাক্ত করার জন্য কোনও ব্যবস্থা নেই; পর্যাপ্ত মেমরি না থাকলে, আচরণটি সংজ্ঞায়িত। (স্থির আকারের অ্যারেগুলির জন্য একই - এবং বরাদ্দ () এর ক্ষেত্রেও একই -)

— কিথ থম্পসন

@ কিথথম্পসন ওয়েল, ম্যালোক / নতুন বরাদ্দ ব্যর্থতা সনাক্ত করার কোনও নিশ্চয়তা নেই, উদাহরণস্বরূপ লিনাক্স ম্যালোক ম্যান পৃষ্ঠা ( linux.die.net/man/3/malloc ) এর জন্য নোট দেখুন ।

— হাইড

@ হাইড: লিনাক্সের mallocআচরণ সি স্ট্যান্ডার্ডের সাথে খাপ খায় কিনা তা বিতর্কযোগ্য ।

— কিথ থম্পসন

Answer 1

আমি ঠিক একটি সামান্য প্রোগ্রাম হ্যাক করেছি যা এটি "ন্যায্য" এবং "তুলনীয়" তা নিশ্চিত করার জন্য প্রতিবার একই বীজে পুনরায় চালু হওয়া এলোমেলো সংখ্যার একটি সেট তৈরি করে। এটি যেহেতু এগিয়ে যায়, এটি এই মানগুলির সর্বনিম্ন এবং সর্বাধিক চিত্রিত করে। আর যখন সংখ্যার সেট তৈরি করেছে, এটা বড়, মোট ছাত্র কত গড় উপরে হয় minএবং max।

খুব ছোট অ্যারেগুলির জন্য, এটি ভিএলএর সমাপ্তির সাথে একটি সুস্পষ্ট উপকার দেখায় std::vector<>।

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

প্রাসঙ্গিক ফাংশনগুলিতে "এলোমেলো সংখ্যার সংখ্যা" (এক্স) এর খুব ছোট মানগুলির জন্য, vlaসমাধানটি বিশাল ব্যবধানে জয়ী হয়। আকারটি বড় হওয়ার সাথে সাথে "জয়" আরও ছোট হয় এবং পর্যাপ্ত আকার দেওয়া হয়, ভেক্টর সমাধানটি আরও দক্ষ বলে মনে হয় - সেই রূপটি খুব বেশি অধ্যয়ন করে না, যখন আমরা যখন ভিএলএতে কয়েক হাজার উপাদান থাকা শুরু করি, তখন তা হয় না তারা কি বোঝাতে চেয়েছিল ...

এবং আমি নিশ্চিত যে কেউ আমাকে বলবে যে এই সমস্ত কোডের একগুচ্ছ টেমপ্লেট সহ এই কোডটি লেখার কোনও উপায় আছে এবং আরডিটিএসসি এবং coutরানটাইমের সময় বিটের চেয়ে বেশি চালানো ছাড়াই এটি করা সম্ভব ... তবে আমি মনে করি না এটি সত্যিই আছে বিন্দু.

এই বিশেষ বৈকল্পিকটি চালানোর সময়, আমি এর মধ্যে প্রায় 10% পার্থক্য পাই func1 (ভিএলএ) এবং func2(স্টাড :: ভেক্টর) ।

count = 9884
func1 time in clocks per iteration 7048685
count = 9884
func2 time in clocks per iteration 7661067
count = 9884
func3 time in clocks per iteration 8971878

এটি এর সাথে সংকলিত: g++ -O3 -Wall -Wextra -std=gnu++0x -o vla vla.cpp

কোডটি এখানে:

#include <iostream>
#include <vector>
#include <cstdint>
#include <cstdlib>

using namespace std;

const int SIZE = 1000000;

uint64_t g_val[SIZE];


static __inline__ unsigned long long rdtsc(void)
{
    unsigned hi, lo;
    __asm__ __volatile__ ("rdtsc" : "=a"(lo), "=d"(hi));
    return ( (unsigned long long)lo)|( ((unsigned long long)hi)<<32 );
}


int func1(int x)
{
    int v[x];

    int vmax = 0;
    int vmin = x;
    for(int i = 0; i < x; i++)
    {
        v[i] = rand() % x;
        if (v[i] > vmax) 
            vmax = v[i];
        if (v[i] < vmin) 
            vmin = v[i];
    }
    int avg = (vmax + vmin) / 2;
    int count = 0;
    for(int i = 0; i < x; i++)
    {
        if (v[i] > avg)
        {
            count++;
        }
    }
    return count;
}

int func2(int x)
{
    vector<int> v;
    v.resize(x); 

    int vmax = 0;
    int vmin = x;
    for(int i = 0; i < x; i++)
    {
        v[i] = rand() % x;
        if (v[i] > vmax) 
            vmax = v[i];
        if (v[i] < vmin) 
            vmin = v[i];
    }
    int avg = (vmax + vmin) / 2;
    int count = 0;
    for(int i = 0; i < x; i++)
    {
        if (v[i] > avg)
        {
            count++;
        }
    }
    return count;
}    

int func3(int x)
{
    vector<int> v;

    int vmax = 0;
    int vmin = x;
    for(int i = 0; i < x; i++)
    {
        v.push_back(rand() % x);
        if (v[i] > vmax) 
            vmax = v[i];
        if (v[i] < vmin) 
            vmin = v[i];
    }
    int avg = (vmax + vmin) / 2;
    int count = 0;
    for(int i = 0; i < x; i++)
    {
        if (v[i] > avg)
        {
            count++;
        }
    }
    return count;
}    

void runbench(int (*f)(int), const char *name)
{
    srand(41711211);
    uint64_t long t = rdtsc();
    int count = 0;
    for(int i = 20; i < 200; i++)
    {
        count += f(i);
    }
    t = rdtsc() - t;
    cout << "count = " << count << endl;
    cout << name << " time in clocks per iteration " << dec << t << endl;
}

struct function
{
    int (*func)(int);
    const char *name;
};


#define FUNC(f) { f, #f }

function funcs[] = 
{
    FUNC(func1),
    FUNC(func2),
    FUNC(func3),
}; 


int main()
{
    for(size_t i = 0; i < sizeof(funcs)/sizeof(funcs[0]); i++)
    {
        runbench(funcs[i].func, funcs[i].name);
    }
}

Comments

বাহ, আমার সিস্টেম ভিএলএর সংস্করণে 30% উন্নতি দেখায় std::vector।

— খ্রিস্টাইকॉक

ঠিক আছে, 20-200 এর পরিবর্তে প্রায় 5-15 আকারের পরিসীমা দিয়ে চেষ্টা করুন এবং আপনার সম্ভবত 1000% বা আরও উন্নতি হবে। [এছাড়াও সংকলক বিকল্পগুলির উপর নির্ভর করে - আমি জিসিসিতে আমার সংকলক বিকল্পগুলি দেখানোর জন্য উপরের কোডটি সম্পাদনা করব]

— ম্যাটস পিটারসন

আমি স্রেফ একটি যুক্ত করেছি func3যা v.push_back(rand())পরিবর্তে ব্যবহার করে v[i] = rand();এবং প্রয়োজনীয়তা সরিয়ে দেয় resize()। এটি ব্যবহারের তুলনায় এটি প্রায় 10% বেশি সময় নেয় resize()। [অবশ্যই, প্রক্রিয়াটিতে, আমি দেখেছি যে v[i]ফাংশনটি সময় লাগে তার ব্যবহারের ক্ষেত্রে প্রধান অবদান থাকে - আমি সে সম্পর্কে কিছুটা অবাক হয়েছি]]

— ম্যাটস পিটারসন

@ মাইকব্রাউন আপনি কি এমন বাস্তব std::vectorবাস্তবায়ন সম্পর্কে জানেন যা ভিএলএ / ব্যবহার করবে alloca, বা কেবল অনুমান?

— হাইড

ভেক্টর প্রকৃতপক্ষে অভ্যন্তরীণভাবে একটি অ্যারে ব্যবহার করে না, তবে যতদূর আমি বুঝতে পারি, এটি কোনও ভিএলএ ব্যবহার করার উপায় নেই। আমি বিশ্বাস করি যে আমার উদাহরণটি দেখায় যে ভিএলএ এর কয়েকটি (সম্ভবত এমনকি অনেকগুলি) ক্ষেত্রে দরকারী যেখানে ডেটার পরিমাণ কম is এমনকি ভেক্টর যদি ভিএলএর হয় তবে এটি vectorবাস্তবায়নের অভ্যন্তরে অতিরিক্ত পরিশ্রমের পরে হবে ।

— ম্যাটস পিটারসন

Answer 2

ভিএলএলএস বনাম কোনও ভেক্টর সম্পর্কিত

আপনি কি ভেবেছিলেন যে কোনও ভেক্টর নিজেই ভিএলএসের সুবিধা নিতে পারে। ভিএলএস ব্যতীত ভেক্টরকে স্টোরের জন্য অ্যারেগুলির কয়েকটি "স্কেল" উদাহরণস্বরূপ 10, 100, 10000 নির্দিষ্ট করতে হবে যাতে আপনি 101 টি আইটেম ধরে রাখতে 10000 আইটেম অ্যারে বরাদ্দ করেন। ভিএলএএস সহ, আপনি যদি 200 এর আকার পরিবর্তন করেন তবে অ্যালগরিদম ধরে নিতে পারে আপনার কেবল 200 প্রয়োজন হবে এবং 200 আইটেম অ্যারে বরাদ্দ করতে পারবেন। অথবা এটি n * 1.5 বলে একটি বাফার বরাদ্দ করতে পারে।

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

ভেক্টর থেকে তার অভ্যন্তরীণ অ্যারেতে অতিরিক্ত পয়েন্টার জাম্প যুক্ত হয়।

মূল প্রশ্নের উত্তর

আপনি যখন লিংকডলিস্টের মতো গতিশীল বরাদ্দকৃত কাঠামোটি ব্যবহার করার বিষয়ে কথা বলছেন তখন কোনও তুলনা হয় না। একটি অ্যারে তার উপাদানগুলিতে পয়েন্টার গাণিতিক ব্যবহার করে সরাসরি অ্যাক্সেস সরবরাহ করে। একটি লিঙ্কযুক্ত তালিকা ব্যবহার করে আপনাকে কোনও নির্দিষ্ট উপাদানটিতে যেতে নোডগুলি হাঁটা করতে হবে। সুতরাং ভিএলএ এই পরিস্থিতিতে হাতছাড়া করে।

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

Comments

আমি নিশ্চিত নই যে আমি লিঙ্কযুক্ত তালিকার জন্য আপনার রেফারেন্সটি বুঝতে পেরেছি, তাই আমি প্রাসঙ্গিক কিছুটা ব্যাখ্যা করে এবং আমি যে বিকল্পগুলির কথা ভাবছি তার উদাহরণ যুক্ত করে, আমি প্রশ্নের একটি বিভাগ যুক্ত করেছি।

— হাইড

একটি std::vectorঅ্যারে এর স্কেল কেন প্রয়োজন হবে ? যখন এটি কেবল 101 প্রয়োজন তখন কেন এটি 10 ​​কে উপাদানগুলির জন্য স্থানের প্রয়োজন হবে? এছাড়াও, প্রশ্নটি কখনই লিঙ্কযুক্ত তালিকাগুলির উল্লেখ করে না, সুতরাং আমি নিশ্চিত নই যে আপনি এটি কোথা থেকে পেয়েছেন। শেষ অবধি, সি 99 এর ভিএলএগুলি স্ট্যাক-বরাদ্দ করা হয়; তারা একটি মান ফর্ম alloca()। হিপ স্টোরেজ প্রয়োজন এমন যে কোনও কিছু (এটি ফাংশন ফিরে আসার পরে প্রায় থাকে) বা একটি realloc()(অ্যারে নিজেই আকার পরিবর্তন করে) যাইহোক ভিএলএস নিষিদ্ধ করবে।

— খ্রিস্টিয়াকক

@ chrisaycock সি ++ এর কোনও কারণে রিলোক () ফাংশন নেই, ধরে নেওয়া মেমরি নতুন [] দিয়ে বরাদ্দ করা হয়েছে। স্ট্যান্ড :: ভেক্টরকে অবশ্যই স্কেল ব্যবহার করা উচিত বলেই মূল কারণ নয়?

@ লন্ডিন কি দশটি শক্তি দ্বারা ভেক্টরকে স্কেল করে? আমি কেবল এই ধারণাটি পেয়েছি যে লিঙ্কযুক্ত তালিকার রেফারেন্সটি দিয়ে মাইক ব্রাউন প্রশ্নটি দ্বারা সত্যিই বিভ্রান্ত হয়েছিল। (তিনি এর আগে জোর দিয়েছিলেন যে C99 ভিএলএর স্তূপে সরাসরি জারি করে))

— ক্রিসাইককক

@ হায়ড আমি বুঝতে পারিনি যে আপনি কী বিষয়ে কথা বলছিলেন। আমি ভেবেছিলাম আপনি অন্যান্য হিপ ভিত্তিক ডেটা স্ট্রাকচার বোঝাতে চাইছেন। আপনি এই স্পষ্টতা যোগ করেছেন এখন আকর্ষণীয়। সেগুলির মধ্যে পার্থক্য আপনাকে জানাতে আমি যথেষ্ট পরিমাণে সি ++ গিগ নেই।

— মাইকেল ব্রাউন

Answer 3

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

আসলে, বেশিরভাগ জায়গায় যেখানে ভিএলএগুলি এই পদ্ধতিতে ব্যবহৃত হয়, তারা হিপ কলগুলি প্রতিস্থাপন করে না বরং পরিবর্তে এমন কিছু প্রতিস্থাপন করে:

float vals[256]; /* I hope we never get more! */

যে কোনও স্থানীয় ঘোষণার বিষয়টি হ'ল এটি অত্যন্ত দ্রুত। লাইনটিতে float vals[n]সাধারণত বেশ কয়েকটি প্রসেসরের নির্দেশাবলী প্রয়োজন (সম্ভবত কেবলমাত্র একটি)) এটি কেবলমাত্র মানটি যুক্ত করেn স্ট্যাক পয়েন্টারটিতে ।

অন্যদিকে, একটি গাদা বরাদ্দের একটি মুক্ত অঞ্চল খুঁজতে ডেটা কাঠামো হাঁটা দরকার। ভাগ্যবান ক্ষেত্রে এমনকি সময়টি আরও দীর্ঘতার অর্ডার হতে পারে। (অর্থাৎ কেবল nস্ট্যাকের উপরে রাখার এবং কল করার mallocকাজটি সম্ভবত 5-10 নির্দেশাবলী)) স্তূপে কোনও যুক্তিসঙ্গত পরিমাণের ডেটা থাকলে সম্ভবত আরও খারাপ। mallocসত্যিকারের প্রোগ্রামে 100x থেকে 1000x পর্যন্ত ধীর গতির একটি মামলা দেখে আমার অবাক করে দেওয়ার কিছু নেই ।

অবশ্যই, তারপরে আপনার মিলের সাথে কিছু পারফরম্যান্স প্রভাবও রয়েছে free, সম্ভবত mallocকলটির মতো পরিমাণে similar

তদাতিরিক্ত, মেমরি খণ্ডনের বিষয়টি রয়েছে। প্রচুর অল্প বরাদ্দ হিড়কে খণ্ডিত করে। খণ্ডিত স্তূপ উভয় বর্জ্য মেমরি এবং মেমরি বরাদ্দ করার জন্য প্রয়োজনীয় সময় বাড়ায়।

Comments

উইকিপিডিয়া উদাহরণ সম্পর্কে: এটি একটি ভাল উদাহরণের একটি অংশ হতে পারে , তবে এর চারপাশে আরও কোড না থাকলে এটি আমার প্রশ্নে অঙ্কিত 5 টির মধ্যে সত্যিই কোনওটি প্রদর্শন করে না । অন্যথায় হ্যাঁ, আমি আপনার ব্যাখ্যার সাথে একমত। যদিও একটি জিনিস মনে রাখতে হবে: ভিএলএলগুলি ব্যবহার করে স্থানীয় ভেরিয়েবলগুলি অ্যাক্সেস করতে ব্যয় করতে পারে, সেগুলি সহ সমস্ত স্থানীয় ভেরিয়েবলের অফসেটগুলি সংকলনের সময় অগত্যা জানা যায় না, তাই কোনও এক-সময় গাদা ব্যয়টি প্রতিস্থাপন না করার জন্য যত্ন নেওয়া উচিত must প্রতিটি পুনরাবৃত্তির জন্য অভ্যন্তরীণ লুপ জরিমানা।

— হাইড

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

— রোবট

কংক্রিট উদাহরণ:: int vla[n]; if(test()) { struct LargeStruct s; int i; }স্ট্যাক অফসেট sসংকলনের সময় জানা যাবে না, এবং এটিও সন্দেহজনক যে সংকলক iঅভ্যন্তরীণ ক্ষেত্রের বাইরে থেকে স্টোরেজটিকে স্থির স্ট্যাক অফসেটে সরিয়ে ফেলবে কিনা তা সন্দেহজনক । সুতরাং অতিরিক্ত মেশিন কোডের প্রয়োজন কারণ ইন্ডিरेশন এবং এটি পিসি হার্ডওয়্যারগুলির জন্য গুরুত্বপূর্ণ রেজিস্টারগুলিও খাওয়া যায়। আপনি যদি সংকলক সমাবেশ আউটপুট সহ উদাহরণ কোড চান তবে দয়া করে একটি পৃথক প্রশ্ন জিজ্ঞাসা করুন;)

— হায়ড

এই সংকলকটি কোডটিতে সম্মুখীন ক্রমের জন্য বরাদ্দ করতে হবে না এবং স্থান বরাদ্দ করা হয়েছে এবং ব্যবহৃত হচ্ছে না তা বিবেচ্য নয়। একটি স্মার্ট অপটিমাইজার স্থান বরাদ্দ জন্য হবে sএবং iযখন ফাংশন প্রবেশ করানো হয়, আগে testবলা হয় বা vla, বরাদ্দ করা হয় বরাদ্দ হিসাবে sএবং iকোন পার্শ্বপ্রতিক্রিয়া আছে। (এবং প্রকৃতপক্ষে, iএমনকি কোনও রেজিস্টারেও স্থাপন করা যেতে পারে, যার অর্থ কোনও "বরাদ্দ" নেই)

— রোবট

(একটি নির্বোধ ভুলের কারণে একটি মন্তব্য মুছে ফেলা হয়েছে)

— হাইড