স্ট্যাক কি উপরে বা নীচের দিকে বাড়তে পারে?

Question 1

আমার কোডটিতে এই কোডটি রয়েছে:

int q = 10;
int s = 5;
int a[3];

printf("Address of a: %d\n",    (int)a);
printf("Address of a[1]: %d\n", (int)&a[1]);
printf("Address of a[2]: %d\n", (int)&a[2]);
printf("Address of q: %d\n",    (int)&q);
printf("Address of s: %d\n",    (int)&s);

আউটপুটটি হ'ল:

Address of a: 2293584
Address of a[1]: 2293588
Address of a[2]: 2293592
Address of q: 2293612
Address of s: 2293608

তাই, আমি দেখতে যে থেকে aথেকে a[2], 4 দ্বারা মেমরি অ্যাড্রেস বৃদ্ধির প্রতিটি বাইট। কিন্তু থেকে qথেকে s, মেমরি অ্যাড্রেস 4 বাইট দ্বারা হ্রাস।

আমি 2 জিনিস অবাক:

স্ট্যাক বড় হয় বা নীচে? (এক্ষেত্রে আমার কাছে উভয়েরই মতো লাগে)
কি মধ্যে ঘটতে a[2]এবং qমেমরি অ্যাড্রেস? কেন একটি বড় স্মৃতি পার্থক্য আছে? (20 বাইট)

দ্রষ্টব্য: এটি হোমওয়ার্কের প্রশ্ন নয়। স্ট্যাক কীভাবে কাজ করে তা সম্পর্কে আমি আগ্রহী। কোন সাহায্যের জন্য ধন্যবাদ।

Question 2

স্ট্যাকের আচরণ (বড় হওয়া বা বাড়তে থাকা) অ্যাপ্লিকেশন বাইনারি ইন্টারফেস (এবিআই) এবং কল স্ট্যাক (ওরফে অ্যাক্টিভেশন রেকর্ড) কীভাবে সংগঠিত হয় তার উপর নির্ভর করে।

সারা জীবন একটি প্রোগ্রাম ওএসের মতো অন্যান্য প্রোগ্রামের সাথে যোগাযোগের জন্য বাধ্য bound একটি প্রোগ্রাম অন্য প্রোগ্রামের সাথে কীভাবে যোগাযোগ করতে পারে তা এবিআই নির্ধারণ করে।

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

উদাহরণস্বরূপ, আপনি যদি এমআইপিএস এবিআই নেন, কল স্ট্যাকটি নীচে হিসাবে সংজ্ঞায়িত করা হয়েছে।

আসুন সেই ফাংশনটি 'fn1' কল করে 'fn2' consider এখন 'fn2' দ্বারা দেখা স্ট্যাক ফ্রেমটি নিম্নরূপ:

direction of     |                                 |
  growth of      +---------------------------------+ 
   stack         | Parameters passed by fn1(caller)|
from higher addr.|                                 |
to lower addr.   | Direction of growth is opposite |
      |          |   to direction of stack growth  |
      |          +---------------------------------+ <-- SP on entry to fn2
      |          | Return address from fn2(callee) | 
      V          +---------------------------------+ 
                 | Callee saved registers being    | 
                 |   used in the callee function   | 
                 +---------------------------------+
                 | Local variables of fn2          |
                 |(Direction of growth of frame is |
                 | same as direction of growth of  |
                 |            stack)               |
                 +---------------------------------+ 
                 | Arguments to functions called   |
                 | by fn2                          |
                 +---------------------------------+ <- Current SP after stack 
                                                        frame is allocated

এখন আপনি দেখতে পাবেন স্ট্যাকটি নীচের দিকে বাড়ছে। সুতরাং, যদি ভেরিয়েবলগুলি ফাংশনের স্থানীয় ফ্রেমে বরাদ্দ করা হয় তবে ভেরিয়েবলের ঠিকানাগুলি নীচের দিকে বৃদ্ধি পায়। সংকলক মেমরি বরাদ্দের জন্য ভেরিয়েবলের ক্রম সম্পর্কে সিদ্ধান্ত নিতে পারে। (আপনার ক্ষেত্রে এটি 'q' বা 's' হতে পারে যা প্রথমে স্ট্যাক মেমরি বরাদ্দ করা হয় But তবে, সাধারণত সংকলকটি ভেরিয়েবলগুলি ঘোষণার আদেশ অনুসারে স্ট্যাক মেমরি বরাদ্দ করে)।

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

Question 3

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

দুটিই সি স্ট্যান্ডার্ড দ্বারা নির্দিষ্ট করা হয়নি তবে উত্তরগুলি কিছুটা আলাদা different

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

Question 4

যে স্ট্যাকগুলি বড় হয় সেই দিকটি আর্কিটেকচার নির্দিষ্ট। এই বলেছিল, আমার বোঝা হল যে খুব কম কয়েকটি হার্ডওয়্যার আর্কিটেকচারে বড় হয়ে থাকা স্ট্যাক রয়েছে।

যে স্ট্যাকটি বড় হয় সে দিকটি কোনও পৃথক বস্তুর বিন্যাসের চেয়ে আলাদা। সুতরাং যখন স্ট্যাকটি বড় হতে পারে তখন অ্যারেগুলি (যেমন & অ্যারে [এন] সর্বদা <& অ্যারে [n + 1]) থাকবে না;

Question 5

স্ট্যান্ডে জিনিসগুলি কীভাবে সংগঠিত হয় তা নির্দেশ করে এমন কোনও মানের নেই। প্রকৃতপক্ষে, আপনি এমন একটি সংমিশ্রণকারী সংকলক তৈরি করতে পারেন যা স্ট্যাকের সাথে সামঞ্জস্যপূর্ণ উপাদানগুলিতে অ্যারে উপাদানগুলি সংরক্ষণ করে না, যদি এটি স্মার্টসকে এখনও অ্যারে উপাদানগুলি গাণিতিকভাবে সঠিকভাবে করতে না পারে (যাতে এটি জানত, উদাহরণস্বরূপ, যে 1 টি ছিল একটি [0] থেকে 1K দূরে এবং এটির জন্য সামঞ্জস্য করতে পারে)।

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

অপ্টিমাইজেশন।
প্রান্তিককরণ
ব্যক্তির কৌতুকগুলি সংকলকের স্ট্যাক পরিচালনার অংশ।

স্ট্যাকের দিকনির্দেশে আমার দুর্দান্ত গ্রন্থের জন্য এখানে দেখুন :-)

আপনার নির্দিষ্ট প্রশ্নের উত্তরে:

স্ট্যাক বড় হয় বা নীচে?
এটি (স্ট্যান্ডার্ডের দিক দিয়ে) মোটেই গুরুত্বপূর্ণ নয় তবে আপনি যেহেতু জিজ্ঞাসা করেছেন, বাস্তবায়নের উপর নির্ভর করে এটি স্মৃতিতে বড় বা নীচে নেমে যেতে পারে ।
একটি [2] এবং কিউ মেমরি ঠিকানাগুলির মধ্যে কী ঘটে? কেন একটি বড় স্মৃতি পার্থক্য আছে? (20 বাইট)?
এটি মোটেই কিছু যায় আসে না (স্ট্যান্ডার্ডের দিক দিয়ে)। সম্ভাব্য কারণে উপরে দেখুন।

Question 6

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

অ্যারের চারপাশের ব্যবধানটি একধরণের প্যাডিং হতে পারে তবে এটি আমার কাছে রহস্যজনক।

Question 7

প্রথমত, এটির 8 টি বাইট অব্যক্ত স্থান স্মৃতিতে (এটি 12 নয়, মনে রাখবেন স্ট্যাকটি নীচের দিকে বৃদ্ধি পায়, সুতরাং যে স্থানটি বরাদ্দ করা হয়নি তা 604 থেকে 597 অবধি)। এবং কেন?. কারণ প্রতিটি ডেটা টাইপ ঠিকানার আকার থেকে বিভাজ্য ঠিকানা থেকে শুরু করে মেমরিতে স্থান নেয়। আমাদের ক্ষেত্রে 3 পূর্ণসংখ্যার অ্যারে 12 বাইট মেমরি স্পেস নেয় এবং 604 টি 12 দ্বারা বিভাজ্য নয় তাই এটি খালি স্থান ছেড়ে দেয় যতক্ষণ না এটি 12 টি দ্বারা বিভাজ্য একটি মেমরির ঠিকানার মুখোমুখি হয়, এটি 596 হয় 6

সুতরাং অ্যারে বরাদ্দ মেমরি স্পেস 596 থেকে 584. কিন্তু অ্যারে বরাদ্দ অবিরত হিসাবে, তাই অ্যারের প্রথম উপাদান 596 ঠিকানা থেকে নয় 584 ঠিকানা থেকে শুরু হয়।

Question 8

সংকলক স্থানীয় স্ট্যাক ফ্রেমের যে কোনও স্থানে স্থানীয় (অটো) ভেরিয়েবলগুলি বরাদ্দ করতে বিনামূল্যে, আপনি নির্ভরযোগ্যভাবে সেখান থেকে স্ট্যাকের বৃদ্ধির দিক নির্ধারণ করতে পারবেন না। নেস্টেড স্ট্যাক ফ্রেমের ঠিকানাগুলির তুলনা করে আপনি স্ট্যাকের বৃদ্ধির দিকটি নির্ধারণ করতে পারেন, যেমন কোনও কলকারীর তুলনায় কোনও ফাংশনের স্ট্যাক ফ্রেমের ভিতরে স্থানীয় ভেরিয়েবলের ঠিকানাটির তুলনা করে:

#include <stdio.h>
int f(int *x)
{
  int a;
  return x == NULL ? f(&a) : &a - x;
}

int main(void)
{
  printf("stack grows %s!\n", f(NULL) < 0 ? "down" : "up");
  return 0;
}

Question 9

আমি মনে করি না যে এটি নির্বিচারবাদী। অ্যারেটি "বৃদ্ধি" বলে মনে হচ্ছে কারণ সেই স্মৃতিটি স্বচ্ছলভাবে বরাদ্দ করা উচিত। তবে, যেহেতু q এবং s একে অপরের সাথে সম্পর্কিত নয়, কম্পাইলার কেবল তাদের প্রতিটিকে স্ট্যাকের মধ্যে একটি নির্বিচারে ফ্রি মেমরির স্থানে আটকে দেয়, সম্ভবত এটি একটি পূর্ণসংখ্যার আকারের সাথে সবচেয়ে ভাল ফিট করে।

[2] এবং q এর মধ্যে যা ঘটেছিল তা হ'ল q এর অবস্থানের চারপাশের স্থানটি 3 টি সংখ্যার অ্যারে বরাদ্দ করার জন্য যথেষ্ট পরিমাণে বড় ছিল না (যেমন, 12 বাইটের চেয়ে বড় নয়)।

Question 10

আমার স্ট্যাকটি কম নম্বরযুক্ত ঠিকানার দিকে প্রসারিত হবে।

এটি অন্য কম্পিউটারে, এমনকি আমার নিজের কম্পিউটারেও আলাদা হতে পারে যদি আমি একটি আলাদা সংকলক অনুরোধ ব্যবহার করি। ... বা সংকলক মুগত কোনও স্ট্যাক ব্যবহার না করা বেছে নিন (সবকিছুকে ইনলাইন করুন (ফাংশন এবং ভেরিয়েবলগুলি যদি আমি তাদের ঠিকানা না নিই))।

$ cat stack.c
#include <stdio.h>

int stack(int x) {
  printf("level %d: x is at %p\n", x, (void*)&x);
  if (x == 0) return 0;
  return stack(x - 1);
}

int main(void) {
  stack(4);
  return 0;
}

us / usr / bin / gcc -Wall -Wextra -std = c89 -pedantic stack.c

$ ./a.out
স্তর 4: x 0x7fff7781190c এ রয়েছে
স্তর 3: x 0x7fff778118ec এ রয়েছে
স্তর 2: x 0x7fff778118cc এ রয়েছে
স্তর 1: x 0x7fff778118ac এ রয়েছে
স্তর 0: x 0x7fff7781188c এ রয়েছে

Question 11

স্ট্যাকটি বাড়ছে (x86 এ)। যাইহোক, ফাংশনটি লোড হয়ে গেলে স্ট্যাকটি একটি ব্লকে বরাদ্দ করা হয়, এবং স্ট্যাকগুলিতে আইটেমগুলি কী অর্ডার করবে তা আপনার কোনও গ্যারান্টি নেই।

এই ক্ষেত্রে, এটি দুটি কালি এবং স্ট্যাকের উপর একটি তিন-ইনট অ্যারের জন্য স্থান বরাদ্দ করে। এটি অ্যারের পরে অতিরিক্ত 12 বাইটও বরাদ্দ করেছে, সুতরাং এটি এর মতো দেখাচ্ছে:

একটি [12 বাইট]
প্যাডিং (?) [12 বাইট]
এর [4 বাইট]
কিউ [4 বাইট]

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

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

Question 12

এটি আপনার অপারেটিং সিস্টেম এবং আপনার সংকলকের উপর নির্ভর করে।

Question 13

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

http://c0x.coding-guidlines.com/6.5.8.html

1206 যদি নির্দেশিত বস্তুগুলি একই সমষ্টিগত বস্তুর সদস্য হয় তবে কাঠামোর সদস্যদের পয়েন্টারগুলি পরে ঘোষণা করা কাঠামোর পূর্বে ঘোষিত সদস্যদের তুলনায় পয়েন্টারগুলির চেয়ে বড় তুলনা করুন, এবং বৃহত্তর সাবস্ক্রিপ্ট মানগুলির সাথে অ্যারের উপাদানগুলিতে পয়েন্টারগুলি একই উপাদানের সাথে পয়েন্টারের চেয়ে বেশি তুলনা করে নিম্ন সাবস্ক্রিপ্ট মান সহ অ্যারে।

& a [0] <এবং a [1], 'a' কীভাবে বরাদ্দ করা হয় তা নির্বিশেষে সর্বদা সত্য হতে হবে

Question 14

নীচের দিকে বৃদ্ধি পায় এবং এটি মেমরিতে ডেটা সেট করার সময় ছোট এন্ডিয়ান বাইট অর্ডার মানের কারণে হয়।

আপনি যে দিকটি দেখতে পারেন তার একটি উপায় হ'ল আপনি উপরে থেকে 0 এবং নীচে থেকে সর্বাধিক মেমরির দিকে তাকান যদি স্ট্যাকটি উপরের দিকে বৃদ্ধি পায়।

স্ট্যাকটি নিম্নগতির দিকে বাড়ার কারণ হ'ল স্ট্যাক বা বেস পয়েন্টারের দৃষ্টিকোণ থেকে অবনতি অর্জন করতে সক্ষম হওয়া।

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

এ কারণেই এতগুলি প্রোগ্রামিং এবং স্ক্রিপ্টিং ভাষা নিবন্ধভিত্তিক না হয়ে স্ট্যাক-ভিত্তিক ভার্চুয়াল মেশিন ব্যবহার করে।

Question 15

এটি নির্ভর করে আর্কিটেকচারের উপর। আপনার নিজের সিস্টেমটি পরীক্ষা করতে, গিক্সফোর্ডজিক্স থেকে এই কোডটি ব্যবহার করুন :

// C program to check whether stack grows 
// downward or upward. 
#include<stdio.h> 

void fun(int *main_local_addr) 
{ 
    int fun_local; 
    if (main_local_addr < &fun_local) 
        printf("Stack grows upward\n"); 
    else
        printf("Stack grows downward\n"); 
} 

int main() 
{ 
    // fun's local variable 
    int main_local; 

    fun(&main_local); 
    return 0; 
}