আমি ভাবছিলাম যে কেউ আমাকে #pragma packপ্রিপ্রোসেসর স্টেটমেন্টটি কী করে তা ব্যাখ্যা করতে পারে এবং আরও গুরুত্বপূর্ণ, কেন কেউ এটি ব্যবহার করতে চান।
আমি এমএসডিএন পৃষ্ঠাটি যাচাই করেছিলাম , যা কিছু অন্তর্দৃষ্টি দিয়েছিল, তবে আমি অভিজ্ঞ ব্যক্তিদের কাছ থেকে আরও কিছু শুনার আশা করছিলাম। আমি এটি আগে কোডে দেখেছি, যদিও আমি আর কোথাও খুঁজে পাচ্ছি না।
A mod s = 0যেখানে A হল ঠিকানা এবং সেগুলি ডেটাটাইপের আকার; কোনও ডেটা ভ্রান্তাক্ষরিত না হলে এটি পরীক্ষা করে।
উত্তর:
#pragma packসংকলককে নির্দিষ্ট প্রান্তিককরণের সাথে কাঠামোর সদস্যদের প্যাক করার নির্দেশ দেয়। বেশিরভাগ সংকলক, যখন আপনি কোনও স্ট্রাক্ট ঘোষণা করেন, সদস্যদের মধ্যে প্যাডিং সন্নিবেশ করানো হবে তা নিশ্চিত করার জন্য যে তারা মেমরির উপযুক্ত ঠিকানার (সাধারণত টাইপের আকারের একাধিক) সাথে সংযুক্ত রয়েছে। এটি ভেরিয়েবলগুলি অ্যাক্সেসের সাথে যুক্ত কিছু আর্কিটেকচারের পারফরম্যান্স পেনাল্টি (বা সরাসরি ত্রুটি) এড়িয়ে চলে যা সঠিকভাবে প্রান্তিক না হয়। উদাহরণস্বরূপ, প্রদত্ত 4-বাইট পূর্ণসংখ্যা এবং নিম্নলিখিত কাঠামো:
struct Test
{
char AA;
int BB;
char CC;
};সংকলক স্ট্রাক্টটিকে মেমোরিতে রেখে দিতে পছন্দ করতে পারে:
| 1 | 2 | 3 | 4 |
| AA(1) | pad.................. |
| BB(1) | BB(2) | BB(3) | BB(4) |
| CC(1) | pad.................. |এবং sizeof(Test)4 × 3 = 12 হবে, যদিও এটি শুধুমাত্র তথ্য 6 বাইট ধারণ করে। #pragma(আমার জ্ঞানের কাছে) সর্বাধিক সাধারণ ব্যবহারের ক্ষেত্রে হ'ল হার্ডওয়্যার ডিভাইসগুলির সাথে কাজ করার সময় যেখানে আপনাকে নিশ্চিত করতে হবে যে কম্পাইলার ডেটাতে প্যাডিং প্রবেশ করায় না এবং প্রতিটি সদস্য পূর্ববর্তীটিকে অনুসরণ করে। এর সাথে #pragma pack(1)উপরের স্ট্রাক্টটি এভাবে ছড়িয়ে দেওয়া হবে:
| 1 |
| AA(1) |
| BB(1) |
| BB(2) |
| BB(3) |
| BB(4) |
| CC(1) |এবং sizeof(Test)1 × 6 = 6 হবে।
এর সাথে #pragma pack(2)উপরের স্ট্রাক্টটি এভাবে ছড়িয়ে দেওয়া হবে:
| 1 | 2 |
| AA(1) | pad.. |
| BB(1) | BB(2) |
| BB(3) | BB(4) |
| CC(1) | pad.. |এবং sizeof(Test)2 × 4 = 8 হবে।
কাঠামোতে ভেরিয়েবলের ক্রমও গুরুত্বপূর্ণ। ভেরিয়েবলগুলি নীচের মতো অর্ডার করা হয়েছে:
struct Test
{
char AA;
char CC;
int BB;
};এবং এর সাথে #pragma pack(2)স্ট্রাক্টটি এভাবে ছড়িয়ে দেওয়া হবে:
| 1 | 2 |
| AA(1) | CC(1) |
| BB(1) | BB(2) |
| BB(3) | BB(4) |এবং sizeOf(Test)3 × 2 = 6 হবে।
#pragmaসংকলকটিতে অ-বহনযোগ্য (কেবলমাত্র এই সংকলক হিসাবে) বার্তা প্রেরণে ব্যবহৃত হয়। কিছু নির্দিষ্ট সতর্কতা এবং প্যাকিং স্ট্রাকগুলি অক্ষম করার মতো জিনিসগুলি সাধারণ কারণ। নির্দিষ্ট সতর্কতাগুলি অক্ষম করা বিশেষত কার্যকর যদি আপনি ত্রুটিযুক্ত পতাকাটি চালু হওয়ার সাথে সাথে সতর্কতাগুলি সংকলন করেন।
#pragma packবিশেষত এটি নির্দেশ করতে ব্যবহৃত হয় যে স্ট্রাকটি প্যাক করা হচ্ছে তার সদস্যদের সারিবদ্ধ করা উচিত নয়। আপনি যখন হার্ডওয়ারের কোনও অংশে মেমরি ম্যাপ করা ইন্টারফেস রাখেন এবং বিভিন্ন স্ট্রাক্ট সদস্যরা ঠিক কোথায় নির্দেশ করেন সেখানে নিয়ন্ত্রণ করতে সক্ষম হবেন এটি কার্যকর। এটি উল্লেখযোগ্যভাবে একটি ভাল গতি অপ্টিমাইজেশন নয়, যেহেতু বেশিরভাগ মেশিনগুলি সারিবদ্ধ ডেটা নিয়ে কাজ করার ক্ষেত্রে অনেক দ্রুত faster
এটি কম্পাইলারকে একটি কাঠামোয় অবজেক্টগুলিকে সারিবদ্ধ করার জন্য সীমানা বলছে। উদাহরণস্বরূপ, আমার যদি এমন কিছু থাকে:
struct foo {
char a;
int b;
};একটি সাধারণ 32-বিট মেশিনের সাহায্যে আপনি সাধারণত 3 বাইটের প্যাডিং করতে চান " aএবং bতাই bএটির অ্যাক্সেসের গতি বাড়ানোর জন্য 4-বাইটের সীমানায় অবতরণ করবে (এবং এটি সাধারণত ডিফল্টরূপে ঘটবে)।
তবে, আপনাকে যদি কোনও বাহ্যিক সংজ্ঞায়িত কাঠামোর সাথে মিল করতে হয় তবে আপনি নিশ্চিত করতে চান যে সংকলকটি আপনার বাহ্যিক সংজ্ঞা অনুসারে আপনার কাঠামোটি ঠিক রেখে দিয়েছে। এই ক্ষেত্রে, আপনি সংকলককে #pragma pack(1)এটি বলতে সদস্যদের মধ্যে কোনও প্যাডিং not োকাতে না দেওয়ার জন্য বলতে পারেন - যদি কাঠামোর সংজ্ঞাটিতে সদস্যদের মধ্যে প্যাডিং অন্তর্ভুক্ত থাকে তবে আপনি এটি স্পষ্টভাবে সন্নিবেশ করান (উদাহরণস্বরূপ, নামযুক্ত সদস্যদের সাথে unusedNবা এটির ignoreNকিছু) অর্ডার)।
b4-বাইট সীমানায় স্থাপন করার অর্থ প্রসেসর এটি একটি একক 4-বাইট লোড জারি করে লোড করতে পারে। যদিও এটি কিছুটা প্রসেসরের উপর নির্ভর করে, যদি এটি কোনও অদ্ভুত সীমানায় থাকে তবে এটি লোড করার জন্য প্রসেসরের দুটি পৃথক লোড নির্দেশনা জারি করা প্রয়োজন, তারপরে এই টুকরাগুলি একসাথে রাখার জন্য একটি শিফটার ব্যবহার করুন। সাধারণ পেনাল্টিটি সেই আইটেমটির 3x ধীর লোডের ক্রম হয়।
অ্যাক্সেসের সময়কালের উন্নতি করার জন্য ডেটা উপাদানগুলি (যেমন ক্লাস এবং স্ট্রাক্টের সদস্য) সাধারণত বর্তমান প্রজন্মের প্রসেসরের জন্য ডাব্লুআরড বা ডিডাবর্ডার সীমানায় সংযুক্ত থাকে। 4 টি দ্বারা বিভাজ্য নয় এমন ঠিকানায় DWORD পুনরুদ্ধার করতে 32 বিট প্রসেসরের কমপক্ষে একটি অতিরিক্ত সিপিইউ চক্রের প্রয়োজন। সুতরাং, যদি আপনার উদাহরণস্বরূপ তিনটি চর সদস্য থাকে তবে char a, b, c;তারা প্রকৃতপক্ষে 6 বা 12 বাইট স্টোরেজ নেবে।
#pragmaঅ্যাক্সেস গতির ব্যয়ে, বা বিভিন্ন সংকলক লক্ষ্যমাত্রার মধ্যে সঞ্চিত ডেটা ধারাবাহিকতার জন্য আপনাকে আরও দক্ষ স্থানের ব্যবহার অর্জন করতে এটিকে ওভাররাইড করতে দেয়। আমি 16 বিট থেকে 32 বিট কোডে রূপান্তর করে খুব মজা পেয়েছি; আমি আশা করি 64৪ বিট কোডে পোর্টিং কিছু কোডের জন্য একই ধরণের মাথাব্যাথা ঘটাবে।
char a,b,c;সাধারণত 3 বা 4 বাইট স্টোরেজ লাগবে (কমপক্ষে x86 এ) - কারণ তাদের প্রান্তিককরণের প্রয়োজন 1 বাইট। যদি তা না হয়, তবে আপনি কীভাবে মোকাবেলা করবেন char str[] = "foo";? একটিতে অ্যাক্সেস charসর্বদা একটি সহজ আনয়ন-শিফট-মাস্ক, অন্যদিকে অ্যাক্সেস intআনতে-আনতে-মার্জ করতে বা কেবল আনতে পারে, এটি প্রান্তিক করা হয়েছে কি না তার উপর নির্ভর করে। int(এক্স 86 দিকে) একটি 32 বিট (4 বাইট) প্রান্তিককরণ কারণ অন্যথায় আপনি পেতে চাই (বলুন) একটি অর্ধেক হয়েছে intএক DWORDএবং অন্যান্য অর্ধেক, এবং যে দুই লুক-গ্রহণ করা হবে।
সংকলক নির্দিষ্ট প্ল্যাটফর্মে সর্বাধিক কর্মক্ষমতা অর্জনের জন্য সদস্যগুলিকে কাঠামোতে সারিবদ্ধ করতে পারে। #pragma packনির্দেশিকা আপনাকে সেই প্রান্তিককরণ নিয়ন্ত্রণ করতে দেয়। সর্বোত্তম পারফরম্যান্সের জন্য সাধারণত আপনার এটি ডিফল্ট হিসাবে ছেড়ে দেওয়া উচিত। আপনার যদি কোনও কাঠামো দূরবর্তী মেশিনে পাস করার প্রয়োজন হয় তবে আপনি সাধারণত #pragma pack 1কোনও অযাচিত প্রান্তিককরণ বাদ দিতে ব্যবহার করবেন।
একটি সংকলক হতে পারে নির্দিষ্ট আর্কিটেকচারের পারফরম্যান্সের কারণে কাঠামোর সদস্যদের নির্দিষ্ট বাইট সীমানায় স্থাপন । এটি সদস্যদের মধ্যে অব্যবহৃত প্যাডিং ছেড়ে দিতে পারে। স্ট্রাকচার প্যাকিং সদস্যদের সম্মোহিত হতে বাধ্য করে।
এটি উদাহরণস্বরূপ গুরুত্বপূর্ণ হতে পারে যদি আপনার কোনও নির্দিষ্ট ফাইল বা যোগাযোগের ফর্ম্যাট অনুসারে কোনও কাঠামোর প্রয়োজন হয় যেখানে আপনার প্রয়োজনীয় ডেটাটি একটি ক্রমের মধ্যে নির্দিষ্ট অবস্থানে থাকতে হবে। তবে এ জাতীয় ব্যবহার এন্ডিয়ান-নেস সম্পর্কিত সমস্যাগুলির সাথে ডিল করে না, সুতরাং যদিও এটি ব্যবহৃত হয় তবে এটি পোর্টেবল হতে পারে না।
এটি কোনও I / O ডিভাইসের অভ্যন্তরীণ রেজিস্ট্রার কাঠামোর ঠিক যেমন একটি ইউআরটি বা ইউএসবি কন্ট্রোলারের উপরেও আবৃত হতে পারে, যাতে সরাসরি ঠিকানাগুলির চেয়ে রেজিস্টার অ্যাক্সেস কোনও কাঠামোর মাধ্যমে থাকে।
আপনি সম্ভবত তখনই এটি ব্যবহার করতে চাইবেন যদি আপনি কিছু হার্ডওয়্যার (যেমন একটি মেমরি ম্যাপযুক্ত ডিভাইস) কোডিং করে যা রেজিস্টার ক্রম এবং সারিবদ্ধকরণের জন্য কঠোর প্রয়োজনীয়তা ছিল।
যাইহোক, এটিকে অর্জনের জন্য এটি দেখতে বেশ ধোঁয়াটে সরঞ্জামের মতো দেখাচ্ছে। একটি সংক্ষিপ্ত আকারে একটি মিনি-ড্রাইভারকে কোড করা এবং এই প্রগমার সাথে ঘুরাঘুরি করার পরিবর্তে এটিকে একটি সি কলিং ইন্টারফেস দেওয়া আরও ভাল উপায় approach
আমি কোডটি আগে এটি ব্যবহার করেছি, যদিও কেবলমাত্র উত্তরাধিকার কোডের সাথে ইন্টারফেস করতে। এটি একটি ম্যাক ওএস এক্স কোকো অ্যাপ্লিকেশন ছিল যা পূর্ববর্তী, কার্বন সংস্করণ (যা নিজে নিজেই মূল M68k সিস্টেম 6.5 সংস্করণের সাথে পিছনের দিকে সামঞ্জস্যপূর্ণ ছিল ... আপনার ধারণাটি পেয়েছিল) থেকে পছন্দের ফাইলগুলি লোড করা দরকার। মূল সংস্করণে অগ্রাধিকার ফাইলগুলি হ'ল একটি কনফিগারেশন কাঠামোর বাইনারি ডাম্প ছিল যা এটি ব্যবহার করে#pragma pack(1) অতিরিক্ত স্থান গ্রহণ এবং জাঙ্ক সংরক্ষণ (যেমন প্যাডিং বাইট যা অন্যথায় কাঠামোর মধ্যে থাকবে) সংরক্ষণ এড়ানোর জন্য হত।
কোডের মূল লেখকরা এমন #pragma pack(1)স্ট্রাকচারগুলি সঞ্চয় করতেও ব্যবহার করেছিলেন যা আন্ত-প্রক্রিয়া যোগাযোগে বার্তা হিসাবে ব্যবহৃত হত। আমি মনে করি যে এখানে কারণটি অজানা বা পরিবর্তিত প্যাডিং মাপগুলির সম্ভাবনা এড়ানো ছিল, কারণ কোডটি মাঝে মাঝে বার্তাটির কাঠামোর একটি নির্দিষ্ট অংশের দিকে শুরু থেকে বেশ কয়েকটি বাইট গণনা করে দেখেছিল (ewww)।
বহু লোকের প্রেক্ষাপটে মিথ্যা ভাগাভাগি রোধ করতে কোনও কাঠামো পুরো ক্যাশে লাইন গ্রহণ করে তা নিশ্চিত করতে আমি এটি ব্যবহার করে দেখেছি। আপনার যদি প্রচুর পরিমাণে অবজেক্ট থাকে যা ডিফল্টরূপে আলগাভাবে প্যাক করা হয় এটি মেমরিটি বাঁচাতে এবং তাদের আরও শক্ত করে তুলতে ক্যাশে কার্যকারিতা উন্নত করতে পারে, যদিও স্বাক্ষরবিহীন মেমরির অ্যাক্সেস সাধারণত জিনিসগুলিকে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে নামিয়ে ফেলতে পারে।
মনে রাখবেন যে ডেটা ধারাবাহিকতা অর্জনের অন্যান্য উপায় রয়েছে যা # প্রগমা প্যাক অফার করে (উদাহরণস্বরূপ কিছু লোকেরা নেটওয়ার্ক জুড়ে প্রেরণ করা উচিত এমন কাঠামোর জন্য # প্রগমা প্যাক (1) ব্যবহার করেন)। উদাহরণস্বরূপ, নিম্নলিখিত কোড এবং এর পরবর্তী ফলাফল দেখুন:
#include <stdio.h>
struct a {
char one;
char two[2];
char eight[8];
char four[4];
};
struct b {
char one;
short two;
long int eight;
int four;
};
int main(int argc, char** argv) {
struct a twoa[2] = {};
struct b twob[2] = {};
printf("sizeof(struct a): %i, sizeof(struct b): %i\n", sizeof(struct a), sizeof(struct b));
printf("sizeof(twoa): %i, sizeof(twob): %i\n", sizeof(twoa), sizeof(twob));
}আউটপুটটি নিম্নরূপ: সাইজফ (স্ট্রাক্ট এ): 15, সাইজফ (স্ট্রাক্ট বি): 24 সাইজফ (টুআনা): 30, সাইজফ (টু বি): 48
লক্ষ্য করুন কিভাবে struct একটি মাপ ঠিক কি বাইট গণনা, কিন্তু struct বি প্যাডিং যোগ করেনি (দেখুন এই প্যাডিং বিস্তারিত জন্য)। # প্রাগমা প্যাকটির বিপরীতে এটি করার মাধ্যমে আপনার কাছে "তারের ফর্ম্যাট "টিকে উপযুক্ত ধরণের রূপান্তর করার নিয়ন্ত্রণ থাকতে পারে। উদাহরণস্বরূপ, "চর দুটি [2]" কে "শর্ট ইনট" এবং সেটারে পরিণত করুন।
sizeofএকটি ফেরৎ size_tযা ব্যবহার করে প্রিন্ট করা উচিত নয়%zu । ভুল ফর্ম্যাট স্পেসিফায়ার ব্যবহার অনির্ধারিত আচরণের ডাক দেয়
কেন এটি ব্যবহার করতে চান?
কাঠামোর স্মৃতি হ্রাস করতে
কেন এটি ব্যবহার করা উচিত নয়?
#pragmaনির্দেশাবলীর মতো তারা বাস্তবায়িত হয় সংজ্ঞায়িত।