😈 👩🏽‍🚀 🏷️ उदाहरणों के साथ लिनक्स कोड प्रदर्शन परीक्षण 🍽️ 🎼 ⚰️

जब मैंने जावा सीखना शुरू किया, तो मैंने जिन पहले कार्यों को हल करने का प्रयास किया, उनमें से एक भी / विषम संख्या निर्धारित करना था। मैं ऐसा करने के कई तरीके जानता था, लेकिन इंटरनेट पर "सही" तरीके से देखने का फैसला किया। सभी लिंक पर मिली जानकारी ने मुझे विभाजन के शेष भाग को प्राप्त करने के लिए फॉर्म x% 2 के एकमात्र सही समाधान के बारे में बताया। यदि शेष 0 है, तो संख्या समान है, यदि शेष 1 है, तो यह विषम है।

ZX स्पेक्ट्रम के समय से, मुझे एक और तरीका याद आया और यह बाइनरी सिस्टम में संख्याओं के प्रतिनिधित्व से जुड़ा है। दशमलव प्रणाली में किसी भी संख्या को दो की शक्तियों के योग के रूप में लिखा जा सकता है। उदाहरण के लिए, एक बाइट के लिए, और यह 8 बिट्स है, दशमलव प्रणाली में किसी भी संख्या को 128 + 64 + 32 + 16 + 8 + 4 + 2 + 1 की संख्या के रूप में दर्शाया जा सकता है।

यह सिर्फ दो की शक्तियों का एक क्रम है। किसी संख्या को बाइनरी सिस्टम में अनुवाद करते समय, यदि हमें संख्या को ध्यान में रखना है, तो बाइनरी प्रतिनिधित्व में यह एक होगा, यदि आवश्यक नहीं है, तो यह 0. होगा।

उदाहरण के लिए:

10 = 1010 (8 + 0 + 2 + 0)
13 = 1101 (8 + 4) + 0 + 1)
200 = 11001000 (128 + 64 + 0 + 0 + 8 + 0 + 0 + 0)

आप तुरंत इस तथ्य पर ध्यान दे सकते हैं कि एक विषम संख्या केवल 1 के मूल्य के साथ दो की शून्य शक्ति दे सकती है, दो की अन्य सभी शक्तियां परिभाषा के अनुसार भी होंगी। इसका स्वचालित रूप से अर्थ है कि बाइनरी नंबर सिस्टम के दृष्टिकोण से, यदि हम समता के लिए किसी भी संख्या की जांच करना चाहते हैं, तो हमें पूरी संख्या की जांच करने की आवश्यकता नहीं है, चाहे वह कितनी भी बड़ी हो। हमें केवल पहले बिट (सबसे सही) की जांच करने की आवश्यकता है। यदि यह 0 है, तो संख्या समान है, क्योंकि अन्य सभी बिट्स एक समान संख्या देते हैं, और इसके विपरीत, यदि यह सबसे सही बिट में से एक है, तो संख्या विषम होने की गारंटी है, क्योंकि अन्य सभी बिट्स केवल एक समान मूल्य देते हैं।
किसी संख्या में केवल सही बिट की जांच करने के लिए, आप कई विधियों का उपयोग कर सकते हैं। उनमें से एक द्विआधारी और है।

तथा

द्विआधारी और (AND) निम्नलिखित नियम द्वारा काम करता है। यदि आप किसी भी नंबर पर आवेदन करते हैं, तो इसे मूल, तार्किक और नंबर 0 के साथ कहते हैं, तो इस तरह के ऑपरेशन का परिणाम हमेशा 0. होता है। इस तरह से आप उन बिट्स को शून्य कर सकते हैं जिनकी आपको आवश्यकता नहीं है। यदि आप मूल 1 पर लागू होते हैं, तो आपको मूल मिलता है।

बाइनरी सिस्टम में, यह लिखना आसान है:

0 और 0 = 0 (शून्य मूल)
1 और 0 = 0 (शून्य मूल)
0 और 1 = 0 (मूल नहीं बदलें)
1 और 1 = 1 (मूल नहीं बदलें)

यहां से कुछ सरल है। नियम।

यदि हम सभी इकाइयों के लिए और सभी संख्याओं के संचालन को लागू करते हैं (सभी बिट्स चालू हैं), तो हमें एक ही प्रारंभिक संख्या मिलती है।

यदि हम किसी भी संख्या में (सभी बिट्स बंद हैं) सभी शून्य लागू करते हैं, तो हमें 0. मिलता है।

उदाहरण के लिए:

यदि हम AND 0 को बाइट 13 पर लागू करते हैं, तो हमें 0. मिलता है। दशमलव में यह 13 और 0 = 0 जैसा दिखता है।

यदि हम लागू करते हैं और 200 बाइट करते हैं, तो हम 0 प्राप्त करते हैं, या 200 और 0 = 0 को संक्षेप में लिखते हैं।
वही इसके विपरीत है। 13 सभी सम्मिलित बिट्स पर लागू करें, बाइट के लिए यह आठ इकाइयाँ होंगी, और हम मूल प्राप्त करते हैं। बाइनरी सिस्टम में 00001101 और 11111111 = 00001101 या दशमलव प्रणाली में 13 और 255 = 13

200 के लिए क्रमशः 11001000 और 11111111 = 11001000 या दशमलव प्रणाली में 200 और 255/200 होंगे।

बाइनरी सत्यापन

समता के लिए संख्या की जांच करने के लिए, हमें केवल सबसे सही बिट की जांच करनी होगी। यदि यह 0 है, तो संख्या सम है, यदि 1 है, तो यह भी नहीं है। यह जानते हुए कि और हम कुछ बिट्स को मूल छोड़ सकते हैं और कुछ हम रीसेट कर सकते हैं, हम सिर्फ सबसे सही को छोड़कर सभी बिट्स को रीसेट कर सकते हैं। उदाहरण के लिए:

बाइनरी सिस्टम में 13 1101 है। आइए इसे लागू करें और इसे 0001 करें (हम सभी बिट्स को रीसेट करते हैं, अंतिम को मूल एक छोड़ दिया जाता है)। 1101 में, हम पिछले एक को छोड़कर सभी बिट्स को 0 में बदलते हैं और 0001 प्राप्त करते हैं। हमें अपने मूल नंबर से केवल अंतिम बिट मिला है। दशमलव प्रणाली में, यह 13 और 1 = 1 जैसा दिखेगा।

200 नंबर के साथ एक ही बात, बाइनरी फॉर्म 11001000 में। हम इसे लागू करने के लिए AND 00000001, उसी योजना के अनुसार, सभी बिट्स को शून्य करते हैं, अंतिम एक को छोड़ दें जैसा कि हम हैं, हमें 00000000 मिलता है, और हम बाएं 7 शून्य को रीसेट करते हैं और हमें अंतिम 0 मिलता है। मूल संख्या से। दशमलव प्रणाली में, यह 200 और 1 = 0 जैसा दिखता है।

इस प्रकार, और 1 कमांड को किसी भी संख्या पर लागू करने पर, हम या तो 0 या 1. प्राप्त करते हैं और यदि परिणाम 0 है, तो संख्या भी है। जब 1, संख्या विषम है।

जावा में, बाइनरी और के रूप में लिखा जाता है। तदनुसार, 200 और 1 = 0 (भी) और 13 और 1 = 1 (विषम)।

इसका मतलब है कि संख्याओं के निर्धारण के लिए कम से कम दो तरीके।

X% 2 - विभाजन के शेष भाग के माध्यम से दो
X & 1 - बाइनरी और के माध्यम से

बाइनरी ऑपरेशंस जैसे OR, AND, XOR को प्रोसेसर द्वारा न्यूनतम समय में प्रोसेस किया जाता है। लेकिन विभाजन ऑपरेशन एक गैर-तुच्छ कार्य है, और इसे निष्पादित करने के लिए, प्रोसेसर को बहुत सारे निर्देशों को संसाधित करने की आवश्यकता होती है, अनिवार्य रूप से पूरे कार्यक्रम को निष्पादित करता है। हालांकि, बाइनरी बाएं और दाएं शिफ्ट ऑपरेशन हैं जो उदाहरण के लिए, जल्दी से एक संख्या को 2 से विभाजित करने की अनुमति देते हैं। सवाल यह है कि क्या कंपाइलर इस अनुकूलन का उपयोग करते हैं और क्या इन दो तुलनाओं के बीच अंतर है, जो वास्तव में ऐसा ही करते हैं।

कोडिंग

हम एक प्रोग्राम लिखेंगे जो क्रम में 9,000,000,000 नंबरों को एक चक्र में संसाधित करेगा, और विभाजन के शेष को निर्धारित करके उनके सम सम / विषम को निर्धारित करेगा।

public class OddEvenViaMod {
        public static void main (String[] args) {
                long i=0;
                long odds=0;
                long evens=0;
                do {
                if ((i % 2) == 0) {
                        evens++;
                        }
                else {
                        odds++;
                        }
                i++;
                } while (i<9000000000L);
                System.out.println("Odd " + odds);
                System.out.println("Even " + evens);
        }
}

और हम वास्तव में एक ही लिखेंगे, लेकिन शाब्दिक रूप से द्विआधारी और के माध्यम से एक ही चीज़ की जाँच करते हुए, दो वर्णों को बदलते हैं।

public class OddEvenViaAnd {
        public static void main (String[] args) {
                long i=0;
                long odds=0;
                long evens=0;
                do {
                if ((i & 1) == 0) {
                        evens++;
                        }
                else {
                        odds++;
                        }
                i++;
                } while (i<9000000000L);
                System.out.println("Odd " + odds);
                System.out.println("Even " + evens);

अब हमें किसी तरह इन दोनों कार्यक्रमों की तुलना करने की आवश्यकता है।

लिनक्स पर संसाधन। सी पी यू

किसी भी ऑपरेटिंग सिस्टम को बनाने में विशेष रूप से कार्यक्रमों के बीच संसाधनों के उचित वितरण पर घंटों की एक बड़ी राशि खर्च की गई है। एक तरफ, यह अच्छा है, दो कार्यक्रमों को चलाने के बाद, आप यह सुनिश्चित कर सकते हैं कि वे समानांतर में काम करेंगे, लेकिन दूसरी तरफ, जब आपको किसी कार्यक्रम के प्रदर्शन की जांच करने की आवश्यकता होती है, तो प्रोग्राम को बाहरी प्रभाव को सीमित करने या कम करने के लिए दूसरों से कम करना बेहद आवश्यक है। कार्यक्रम और ऑपरेटिंग सिस्टम।

पहली बात यह है कि प्रोसेसर है। प्रत्येक प्रक्रिया के लिए लिनक्स ओएस एक बिटमास्क स्टोर करता है, जो इंगित करता है कि कौन सी गुठली का उपयोग एप्लिकेशन द्वारा किया जा सकता है और कौन से नहीं। आप इस मास्क को टास्किट कमांड के साथ देख और बदल सकते हैं।

उदाहरण के लिए, मेरे प्रोसेसर में कोर की संख्या देखते हैं:

[user@localhost]# grep -c processor /proc/cpuinfo
4

मेरे कंप्यूटर में 4 कोर वाला एक प्रोसेसर है। यह अच्छा है, क्योंकि मैं उनमें से एक को अपनी जरूरतों के लिए आवंटित करने जा रहा हूं।

आइए देखें कि क्या वर्तमान में वे सभी शीर्ष कमांड के उपयोग में हैं:

[user@localhost]# top

प्रत्येक कोर पर अलग से जानकारी देखने के लिए "1" दबाएं:

top - 13:44:11 up 1 day, 23:26,  7 users,  load average: 1.48, 2.21, 2.02
Tasks: 321 total,   1 running, 320 sleeping,   0 stopped,   0 zombie
%Cpu0  :  7.7 us,  6.8 sy,  0.0 ni, 85.5 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu1  :  9.2 us,  4.2 sy,  0.0 ni, 86.6 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu2  :  7.6 us,  3.4 sy,  0.0 ni, 89.1 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu3  :  8.4 us,  4.2 sy,  0.0 ni, 87.4 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
KiB Mem : 16210820 total,   296972 free, 10072092 used,  5841756 buff/cache
KiB Swap: 16777212 total, 16777212 free,        0 used.  5480568 avail Mem
....

यहां हम देखते हैं कि सभी कोर लगभग समान हैं। (हम और एसई और आईडी संकेतक प्रत्येक कोर के लिए लगभग बराबर हैं)।

अब इसे टास्किट कमांड के साथ देखने का प्रयास करें।

[user@localhost]# taskset -p 1
pid 1's current affinity mask: f

हेक्साडेसिमल प्रणाली में बिटमास्क "एफ" का मतलब दशमलव में 15 या बाइनरी में 811 (8 + 4 + 2 + 1) है। सभी बिट्स सक्षम हैं, जिसका अर्थ है कि सभी कोर PID 1 के साथ एक प्रक्रिया द्वारा उपयोग किए जाते हैं
। लिनक्स पर, जब एक प्रक्रिया एक क्लोन सिस्टम कॉल के साथ दूसरे को जन्म देती है, तो बिटमास्क को क्लोनिंग के समय माता-पिता से कॉपी किया जाता है। इसका मतलब है कि अगर हम इस मास्क को अपनी इनइट प्रक्रिया के लिए बदलते हैं (मेरे मामले में यह सिस्टमड है), तो सिस्टमड के माध्यम से कोई भी नई प्रक्रिया शुरू करते समय यह नई प्रक्रिया पहले से ही एक नए मास्क के साथ लॉन्च की जाएगी।

आप एक ही कमांड का उपयोग करके प्रक्रिया के लिए मुखौटा बदल सकते हैं, सीपीयू कोर की संख्या को सूचीबद्ध करते हुए जिसे हम प्रक्रिया के लिए उपयोग करना चाहते हैं। मान लीजिए कि हम अपनी प्रक्रिया के लिए कर्नेल को 0.2.3 पर छोड़ना चाहते हैं, और हम अपने सिस्टमड प्रोसेस के लिए कर्नेल 1 को निष्क्रिय करना चाहते हैं। ऐसा करने के लिए, हमें कमांड चलाने की आवश्यकता है:

[user@localhost]#  taskset -pc 0,2,3 1
pid 1's current affinity list: 0-3
pid 1's new affinity list: 0,2,3

हम जाँच:

[user@localhost]# taskset -p 1
pid 1's current affinity mask: d

हेक्साडेसिमल नोटेशन में मुखौटा "डी" में बदल गया, जो दशमलव में 13 और बाइनरी में 801 (8 + 4 + 0 + 1) है।

इस क्षण से, किसी भी प्रक्रिया को सिस्टमड प्रक्रिया द्वारा क्लोन किया जाएगा जो सीपीयू का उपयोग करने के लिए स्वचालित रूप से एक मुखौटा 1101 होगा, जिसका अर्थ है कि कर्नेल नंबर 1 का उपयोग नहीं किया जाएगा।

हम सभी प्रक्रियाओं के लिए कर्नेल के उपयोग पर रोक लगाते हैं

एक ही कर्नेल का उपयोग करने से मुख्य लिनक्स प्रक्रिया को रोकना केवल इस प्रक्रिया द्वारा बनाई गई नई प्रक्रियाओं को प्रभावित करेगा। लेकिन मेरे सिस्टम में पहले से ही एक प्रक्रिया नहीं है, लेकिन एक पूरी भीड़, जैसे कि क्रोन, एसशीडी, बैश और अन्य। यदि मुझे एक कोर का उपयोग करने से सभी प्रक्रियाओं को प्रतिबंधित करने की आवश्यकता है, तो मुझे प्रत्येक चलने वाली प्रक्रिया के लिए कार्यशील कमांड को चलाना होगा।

सभी प्रक्रियाओं की सूची प्राप्त करने के लिए, हम एपीआई का उपयोग करेंगे जो कर्नेल हमें देता है, अर्थात् / proc फ़ाइल सिस्टम।

लूप में आगे, हम प्रत्येक चलने की प्रक्रिया के पीआईडी को देखते हैं और इसके लिए मास्क और सभी धागे बदलते हैं:

[user@localhost]# cd /proc; for i in `ls -d [0-9]*`; do taskset -a -pc 0,2,3 $i; done
pid 1's current affinity list: 0,2,3
pid 1's new affinity list: 0,2,3
...

चूंकि कार्यक्रम के निष्पादन के दौरान, कुछ प्रक्रियाओं में अन्य प्रक्रियाओं को स्पॉन करने का समय हो सकता है, इसलिए इस कमांड को कई बार चलाना बेहतर होता है।

शीर्ष कमांड के साथ हमारे काम के परिणाम की जाँच करें:

[user@localhost]# top
top - 14:20:46 up 2 days, 3 min,  7 users,  load average: 0.19, 0.27, 0.57
Tasks: 324 total,   4 running, 320 sleeping,   0 stopped,   0 zombie
%Cpu0  :  8.9 us,  7.7 sy,  0.0 ni, 83.4 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu1  :  0.0 us,  0.0 sy,  0.0 ni,100.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu2  :  9.5 us,  6.0 sy,  0.0 ni, 84.5 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu3  :  8.4 us,  6.6 sy,  0.0 ni, 85.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
KiB Mem : 16210820 total,   285724 free, 10142548 used,  5782548 buff/cache
KiB Swap: 16777212 total, 16777212 free,        0 used.  5399648 avail Mem

जैसा कि आप देख सकते हैं, अब चित्र थोड़ा बदल गया है, अब कर्नेल के लिए 0.2.3 औसत पैरामीटर हमें, sy, id हमारे लिए समान हैं, और कर्नेल 1 के लिए हमारे उपयोगकर्ता और साइज़ में कोर की खपत 0 है, और कर्नेल 100% पर निष्क्रिय है (निष्क्रिय 100) ) कर्नेल 1 अब हमारे अनुप्रयोगों द्वारा उपयोग नहीं किया जाता है और वर्तमान में कर्नेल द्वारा बहुत कम प्रतिशत का उपयोग किया जाता है।

अब एक निशुल्क कोर पर हमारी प्रक्रिया शुरू करने के लिए प्रदर्शन के परीक्षण का कार्य कम हो गया है।

याद

किसी प्रक्रिया को आवंटित भौतिक मेमोरी को आसानी से किसी भी प्रक्रिया से लिया जा सकता है। इस तंत्र को स्वैप कहा जाता है। यदि लिनक्स में स्वैप के लिए जगह है, तो वह इसे वैसे भी करेगा। ओएस को हमारी प्रक्रिया से मेमोरी लेने से रोकने का एकमात्र तरीका, किसी भी अन्य प्रक्रिया की तरह, स्वैप अनुभाग को पूरी तरह से अक्षम करना है, जो हम करेंगे:

[user@localhost]$ sudo swapoff -a
[user@localhost]$ free -m
              total        used        free      shared  buff/cache   available
Mem:          15830        7294        1894         360        6641        7746
Swap:             0           0           0

हमने 1 प्रोसेसर कोर आवंटित किया, जिसका उपयोग नहीं किया गया है, और लिनक्स कर्नेल से मेमोरी स्वैप करने की क्षमता को भी हटा दिया है।

डिस्क

हमारी प्रक्रिया के लॉन्च पर डिस्क के प्रभाव को कम करने के लिए, मेमोरी में एक डिस्क बनाएं और इस डिस्क पर सभी आवश्यक फ़ाइलों को कॉपी करें।

एक निर्देशिका बनाएँ और फ़ाइल सिस्टम को माउंट करें:

[user@localhost]$ sudo mkdir /mnt/ramdisk;
[user@localhost]$ mount -t tmpfs -o size=512m tmpfs /mnt/ramdisk
[user@localhost]$ chown user: /mnt/ramdisk

अब हमें यह पता लगाने की आवश्यकता है कि हम इसे लॉन्च करने के लिए क्या और कैसे योजना बनाते हैं। अपना कार्यक्रम चलाने के लिए, हमें सबसे पहले अपना कोड संकलित करना होगा:

[user@localhost]$ javac OddEvenViaMod.java

फिर आपको इसे चलाने की आवश्यकता है:

[user@localhost]$ java OddEvenViaMod

लेकिन हमारे मामले में, हम प्रोसेसर कोर पर प्रक्रिया को चलाना चाहते हैं जो किसी अन्य प्रक्रिया द्वारा उपयोग नहीं की जाती है। इसलिए, इसे कार्यस्थल के माध्यम से चलाएं:

[user@localhost]# taskset -c 1 time java OddEvenViaMod

हमारे परीक्षणों में, हमें समय को मापने की आवश्यकता है, इसलिए हमारी लॉन्च लाइन बदल जाती है

taskset -c 1 time java OddEvenViaMod

लिनक्स ओएस निष्पादन योग्य फ़ाइलों के कई स्वरूपों का समर्थन करता है, और उनमें से सबसे आम ईएलएफ प्रारूप है। यह फ़ाइल प्रारूप आपको OS को आपकी फ़ाइल चलाने के लिए नहीं, बल्कि दूसरी फ़ाइल चलाने की अनुमति देता है। पहली नज़र में, यह बहुत तार्किक और समझ में नहीं आता है। कल्पना कीजिए कि मैं माइनस्वीपर गेम लॉन्च करता हूं, और मेरे लिए मारियो गेम शुरू होता है - यह वायरस की तरह दिखता है। लेकिन यह तर्क है। अगर मेरे प्रोग्राम को किसी भी डायनेमिक लाइब्रेरी की आवश्यकता है, उदाहरण के लिए libc, या कोई अन्य, इसका मतलब है कि OS को पहले इस लाइब्रेरी को मेमोरी में लोड करना होगा, और उसके बाद लोड और मेरा प्रोग्राम चलाना होगा। और इस तरह की कार्यक्षमता को ऑपरेटिंग सिस्टम में रखना तर्कसंगत लगता है, लेकिन ऑपरेटिंग सिस्टम मेमोरी के संरक्षित क्षेत्र में काम करता है और इसमें यथासंभव कम कार्यक्षमता होनी चाहिए।इसलिए, ईएलएफ प्रारूप ओएस को यह बताने का अवसर प्रदान करता है कि हम कुछ अन्य कार्यक्रम डाउनलोड करना चाहते हैं, और यह "अन्य" कार्यक्रम सभी आवश्यक पुस्तकालयों और हमारे कार्यक्रम को डाउनलोड करेगा और पूरी बात शुरू करेगा।

तो, हमें 3 फाइलें चलाने की आवश्यकता है, यह कार्यस्थल, समय, जावा है।

उनमें से पहले की जाँच करें:

[user@localhost]$ whereis taskset
taskset: /usr/bin/taskset /usr/share/man/man1/taskset.1.gz

बैश फ़ाइल / usr / bin / कार्यपत्रक चलाएगा, जांचें कि अंदर क्या है:

[user@localhost]$ file /usr/bin/taskset
/usr/bin/taskset: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.6.32, BuildID[sha1]=7a2fd0779f64aa9047faa00f498042f0f0c5dc60, stripped

यह ईएलएफ फ़ाइल है जिसके बारे में मैंने ऊपर लिखा है। ईएलएफ फ़ाइल में, कार्यक्रम के अलावा, विभिन्न हेडर हैं। इस फ़ाइल को लॉन्च करने से, ओएस अपने हेडर की जांच करता है, और यदि हेडर "रिक्वेस्ट प्रोग्राम इंटरप्रेटर" फाइल में मौजूद है, तो ओएस इस हेडर से फाइल लॉन्च करेगा, और यह शुरू में लॉजिक के रूप में फाइल को पास करेगा।

जांचें कि क्या यह हैडर हमारी ईएलएफ फाइल में मौजूद है:

[user@localhost]$ readelf -a /usr/bin/taskset  | grep -i interpreter
      [Requesting program interpreter: /lib64/ld-linux-x86-64.so.2]

हेडर मौजूद है, जिसका अर्थ है कि / usr / bin / कार्यपत्रक फ़ाइल को लॉन्च करके हम वास्तव में /lib64/ld-linux-x86-64.so.2 चलाते हैं।

जाँचें कि यह फ़ाइल क्या है:

[user@localhost]$ ls -lah /lib64/ld-linux-x86-64.so.2
lrwxrwxrwx 1 root root 10 May 21  2019 /lib64/ld-linux-x86-64.so.2 -> ld-2.17.so

यह फ़ाइल /lib64/ld-2.17.so के लिए एक सिम लिंक है। इसकी जांच - पड़ताल करें:

[user@localhost]$ file /lib64/ld-2.17.so
/lib64/ld-2.17.so: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked, BuildID[sha1]=a527fe72908703c5972ae384e78d1850d1881ee7, not stripped

जैसा कि आप देख सकते हैं, यह एक और ईएलएफ फ़ाइल है जो ओएस चलेगा। हम हेडर देखते हैं:

[user@localhost]$ readelf -a /lib64/ld-2.17.so  | grep -i interpreter
[user@localhost]$

हम देखते हैं कि इस ELF फ़ाइल में ऐसा कोई हेडर नहीं है, इसलिए OS इस फ़ाइल को चलाएगा और इस पर नियंत्रण स्थानांतरित करेगा। और पहले से ही यह फ़ाइल हमारी फ़ाइल / usr / bin / कार्यपत्रक को खोल देगी, वहां से सभी आवश्यक पुस्तकालयों की जानकारी पढ़ें। आवश्यक पुस्तकालयों की सूची भी ईएलएफ फ़ाइल के हेडर में है। हम इस सूची को ldd या readelf कमांड के साथ देख सकते हैं, जो एक ही बात है:

[user@localhost]$ ldd /usr/bin/taskset
	linux-vdso.so.1 =>  (0x00007ffc4c1df000)
	libc.so.6 => /lib64/libc.so.6 (0x00007f4a24c4e000)
	/lib64/ld-linux-x86-64.so.2 (0x00007f4a2501b000)

[user@localhost]$ readelf -a /usr/bin/taskset  | grep NEEDED
 0x0000000000000001 (NEEDED)             Shared library: [libc.so.6]

VDSO मेमोरी का एक जुड़ा हुआ टुकड़ा है जो पुस्तकालयों से संबंधित नहीं है, इसलिए यह आवश्यक लाइब्रेरी के रूप में ELF फ़ाइल से गायब है।

इससे यह स्पष्ट हो जाता है कि यह प्रोग्राम /lib64/ld-2.17.so उन सभी कार्यक्रमों को चलाने के लिए जिम्मेदार है जिनकी आवश्यकता है, और ये सभी गतिशील रूप से जुड़े पुस्तकालयों के साथ प्रोग्राम हैं।

यदि हम / usr / bin / कार्यपत्रक चलाते हैं, तो यह ठीक उसी प्रकार है जैसे हम / usr / bin / कार्यपत्रक तर्क के साथ /lib64/ld-2.17.so चलाते हैं।

हम अपने परीक्षणों पर डिस्क के प्रभाव की समस्या पर लौटते हैं। अब हम जानते हैं कि यदि हम अपने प्रोग्राम को मेमोरी से लोड करना चाहते हैं, तो हमें एक फाइल की कॉपी करने की आवश्यकता नहीं है, लेकिन कई:

[user@localhost]$ cp /lib64/libc-2.17.so /mnt/ramdisk/
[user@localhost]$ cp /lib64/ld-2.17.so /mnt/ramdisk/
[user@localhost]$ cp /usr/bin/taskset /mnt/ramdisk/

हम समय के लिए ऐसा ही करते हैं, पुस्तकालय की आवश्यकताएं जिनके लिए बिल्कुल समान हैं (हमने पहले से ही ld और libc की प्रतिलिपि बनाई है)।

[user@localhost]$ cp /usr/bin/time /mnt/ramdisk/

जावा के लिए, चीजें थोड़ी अधिक जटिल हैं, क्योंकि जावा को कई अलग-अलग पुस्तकालयों की आवश्यकता होती है जिन्हें लंबे समय तक कॉपी किया जा सकता है। अपने जीवन को थोड़ा सरल बनाने के लिए, मैं अपने java openjdk से पूरी निर्देशिका को मेमोरी में एक डिस्क पर कॉपी करूँगा और एक सिम लिंक बनाऊंगा। बेशक, डिस्क एक्सेस इस मामले में रहेगा, लेकिन कम होगा।

[user@localhost]$ cp -R /usr/lib/jvm/java-1.8.0-openjdk-1.8.0.222.b10-0.el7_6.x86_64 /mnt/ramdisk/

पुरानी निर्देशिका का नाम बदलकर, .default को जोड़कर

[user@localhost]$ sudo mv /usr/lib/jvm/java-1.8.0-openjdk-1.8.0.222.b10-0.el7_6.x86_64{,.default}

और एक सिमलिंक बनाएँ:

[user@localhost]$ sudo ln -s /mnt/ramdisk/java-1.8.0-openjdk-1.8.0.222.b10-0.el7_6.x86_64 /usr/lib/jvm/

हम पहले से ही द्विआधारी फ़ाइल को /lib64/ld-2.17.so फ़ाइल के तर्क के माध्यम से चलाना जानते हैं, जो वास्तव में शुरू होती है। लेकिन हमने जो निर्देशिका निर्दिष्ट की है, उससे लोड / लाइब्ररी के प्रोग्राम /lib64/ld-2.17.so को कैसे बनाया जाए? आदमी हमारी मदद करने के लिए ld, जिससे हम सीखते हैं कि यदि आप पर्यावरण चर LD_LIBRARY_PATH की घोषणा करते हैं, तो ld प्रोग्राम हमारे द्वारा निर्दिष्ट निर्देशिकाओं से पुस्तकालयों को लोड करेगा। अब हमारे पास जावा एप्लिकेशन की लॉन्च लाइन तैयार करने के लिए सभी डेटा हैं।

हम कई बार एक पंक्ति में शुरू करते हैं और जाँचते हैं:

[user@localhost ramdisk]$ export LD_LIBRARY_PATH=/mnt/ramdisk ; /mnt/ramdisk/ld-2.17.so /mnt/ramdisk/taskset -c 1 /mnt/ramdisk/ld-2.17.so /mnt/ramdisk/time /mnt/ramdisk/ld-2.17.so java OddEvenViaMod
Odd 4500000000
Even 4500000000
10.66user 0.01system 0:10.67elapsed 99%CPU (0avgtext+0avgdata 20344maxresident)k
0inputs+64outputs (0major+5229minor)pagefaults 0swaps
[user@localhost ramdisk]$
[user@localhost ramdisk]$ export LD_LIBRARY_PATH=/mnt/ramdisk ; /mnt/ramdisk/ld-2.17.so /mnt/ramdisk/taskset -c 1 /mnt/ramdisk/ld-2.17.so /mnt/ramdisk/time /mnt/ramdisk/ld-2.17.so java OddEvenViaMod
Odd 4500000000
Even 4500000000
10.65user 0.01system 0:10.67elapsed 99%CPU (0avgtext+0avgdata 20348maxresident)k
0inputs+64outputs (0major+5229minor)pagefaults 0swaps
[user@localhost ramdisk]$
[user@localhost ramdisk]$ export LD_LIBRARY_PATH=/mnt/ramdisk ; /mnt/ramdisk/ld-2.17.so /mnt/ramdisk/taskset -c 1 /mnt/ramdisk/ld-2.17.so /mnt/ramdisk/time /mnt/ramdisk/ld-2.17.so java OddEvenViaMod
Odd 4500000000
Even 4500000000
10.66user 0.01system 0:10.68elapsed 99%CPU (0avgtext+0avgdata 20348maxresident)k
0inputs+64outputs (0major+5229minor)pagefaults 0swaps
[user@localhost ramdisk]$
[user@localhost ramdisk]$ export LD_LIBRARY_PATH=/mnt/ramdisk ; /mnt/ramdisk/ld-2.17.so /mnt/ramdisk/taskset -c 1 /mnt/ramdisk/ld-2.17.so /mnt/ramdisk/time /mnt/ramdisk/ld-2.17.so java OddEvenViaMod
Odd 4500000000
Even 4500000000
10.65user 0.01system 0:10.67elapsed 99%CPU (0avgtext+0avgdata 20348maxresident)k
0inputs+96outputs (0major+5234minor)pagefaults 0swaps
[user@localhost ramdisk]$

कार्यक्रम के निष्पादन के दौरान, हम शीर्ष चला सकते हैं और सुनिश्चित कर सकते हैं कि प्रोग्राम सही सीपीयू कोर पर चलता है।

[user@localhost ramdisk]$ top
...
%Cpu0  : 19.7 us, 11.7 sy,  0.0 ni, 68.6 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu1  :100.0 us,  0.0 sy,  0.0 ni,  0.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu2  :  9.8 us,  9.1 sy,  0.0 ni, 81.1 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu3  : 14.0 us,  9.0 sy,  0.0 ni, 77.1 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 s
...

जैसा कि आप देख सकते हैं, ज्यादातर मामलों में परिणाम समान हैं। दुर्भाग्य से, हम सीपीयू कोर पर ओएस के प्रभाव को पूरी तरह से हटा नहीं सकते हैं, इसलिए परिणाम अभी भी लॉन्च के समय लिनक्स कर्नेल के अंदर विशिष्ट कार्यों पर निर्भर करता है। इसलिए, कई शुरू के मूल्यों के मध्यिका का उपयोग करना बेहतर है।

हमारे मामले में, हम देखते हैं कि जावा प्रोग्राम सीपीयू के एक कोर पर 10.65 सेकंड में विभाजन के शेष के माध्यम से 9,000,000,000 प्रक्रियाओं को समानता के साथ संसाधित करता है।

चलो हमारे दूसरे कार्यक्रम के साथ एक ही परीक्षण करते हैं, जो बाइनरी और के माध्यम से एक ही काम करता है।

[user@localhost ramdisk]$ export LD_LIBRARY_PATH=/mnt/ramdisk ; /mnt/ramdisk/ld-2.17.so /mnt/ramdisk/taskset -c 1 /mnt/ramdisk/ld-2.17.so /mnt/ramdisk/time /mnt/ramdisk/ld-2.17.so java OddEvenViaAnd
Odd 4500000000
Even 4500000000
4.02user 0.00system 0:04.03elapsed 99%CPU (0avgtext+0avgdata 20224maxresident)k
0inputs+64outputs (0major+5197minor)pagefaults 0swaps
[user@localhost ramdisk]$
[user@localhost ramdisk]$ export LD_LIBRARY_PATH=/mnt/ramdisk ; /mnt/ramdisk/ld-2.17.so /mnt/ramdisk/taskset -c 1 /mnt/ramdisk/ld-2.17.so /mnt/ramdisk/time /mnt/ramdisk/ld-2.17.so java OddEvenViaAnd
Odd 4500000000
Even 4500000000
4.01user 0.00system 0:04.03elapsed 99%CPU (0avgtext+0avgdata 20228maxresident)k
0inputs+64outputs (0major+5199minor)pagefaults 0swaps
[user@localhost ramdisk]$
[user@localhost ramdisk]$ export LD_LIBRARY_PATH=/mnt/ramdisk ; /mnt/ramdisk/ld-2.17.so /mnt/ramdisk/taskset -c 1 /mnt/ramdisk/ld-2.17.so /mnt/ramdisk/time /mnt/ramdisk/ld-2.17.so java OddEvenViaAnd
Odd 4500000000
Even 4500000000
4.01user 0.01system 0:04.03elapsed 99%CPU (0avgtext+0avgdata 20224maxresident)k
0inputs+64outputs (0major+5198minor)pagefaults 0swaps
[user@localhost ramdisk]$
[user@localhost ramdisk]$ export LD_LIBRARY_PATH=/mnt/ramdisk ; /mnt/ramdisk/ld-2.17.so /mnt/ramdisk/taskset -c 1 /mnt/ramdisk/ld-2.17.so /mnt/ramdisk/time /mnt/ramdisk/ld-2.17.so java OddEvenViaAnd
Odd 4500000000
Even 4500000000
4.02user 0.00system 0:04.03elapsed 99%CPU (0avgtext+0avgdata 20224maxresident)k
0inputs+64outputs (0major+5198minor)pagefaults 0swaps

अब हम विश्वास के साथ कह सकते हैं कि बाइनरी के माध्यम से समानता के लिए तुलना और 4.02 सेकंड लगते हैं, जिसका अर्थ है कि विभाजन के शेष के माध्यम से जांच करने की तुलना में, यह 2.6 गुना तेजी से काम करता है, कम से कम ओपनजेडक संस्करण 1.8.0 पर।

ओरेकल Java vs Openjdk

मैं डाउनलोड और /mnt/ramdisk/jdk-13.0.2 निर्देशिका के लिए ओरेकल वेबसाइट से पैक जावा JDK।

संकलित:

[user@localhost ramdisk]$ /mnt/ramdisk/jdk-13.0.2/bin/javac OddEvenViaAnd.java

हम लॉन्च करते हैं:

[user@localhost ramdisk]$ export LD_LIBRARY_PATH=/mnt/ramdisk ; /mnt/ramdisk/ld-2.17.so /mnt/ramdisk/taskset -c 1 /mnt/ramdisk/ld-2.17.so /mnt/ramdisk/time /mnt/ramdisk/ld-2.17.so /mnt/ramdisk/jdk-13.0.2/bin/java OddEvenViaAnd
Odd 4500000000
Even 4500000000
10.39user 0.01system 0:10.41elapsed 99%CPU (0avgtext+0avgdata 24260maxresident)k
0inputs+64outputs (0major+6979minor)pagefaults 0swaps
[user@localhost ramdisk]$
[user@localhost ramdisk]$ export LD_LIBRARY_PATH=/mnt/ramdisk ; /mnt/ramdisk/ld-2.17.so /mnt/ramdisk/taskset -c 1 /mnt/ramdisk/ld-2.17.so /mnt/ramdisk/time /mnt/ramdisk/ld-2.17.so /mnt/ramdisk/jdk-13.0.2/bin/java OddEvenViaAnd
Odd 4500000000
Even 4500000000
10.40user 0.01system 0:10.42elapsed 99%CPU (0avgtext+0avgdata 24268maxresident)k
0inputs+64outputs (0major+6985minor)pagefaults 0swaps

हम दूसरा कार्यक्रम संकलित करते हैं:

[user@localhost ramdisk]$ /mnt/ramdisk/jdk-13.0.2/bin/javac OddEvenViaMod.java

हम लॉन्च करते हैं:

[user@localhost ramdisk]$ export LD_LIBRARY_PATH=/mnt/ramdisk ; /mnt/ramdisk/ld-2.17.so /mnt/ramdisk/taskset -c 1 /mnt/ramdisk/ld-2.17.so /mnt/ramdisk/time /mnt/ramdisk/ld-2.17.so /mnt/ramdisk/jdk-13.0.2/bin/java OddEvenViaMod
Odd 4500000000
Even 4500000000
10.39user 0.01system 0:10.40elapsed 99%CPU (0avgtext+0avgdata 24324maxresident)k
0inputs+96outputs (0major+7003minor)pagefaults 0swaps
[user@localhost ramdisk]$
[user@localhost ramdisk]$ export LD_LIBRARY_PATH=/mnt/ramdisk ; /mnt/ramdisk/ld-2.17.so /mnt/ramdisk/taskset -c 1 /mnt/ramdisk/ld-2.17.so /mnt/ramdisk/time /mnt/ramdisk/ld-2.17.so /mnt/ramdisk/jdk-13.0.2/bin/java OddEvenViaMod
Odd 4500000000
Even 4500000000
10.40user 0.00system 0:10.41elapsed 99%CPU (0avgtext+0avgdata 24316maxresident)k
0inputs+64outputs (0major+6992minor)pagefaults 0swaps

ऑर्कल jdk में समान स्रोतों का निष्पादन समय शेष डिवीजन और बाइनरी AND के लिए समान है, जो सामान्य दिखता है, लेकिन यह समय भी उतना ही खराब है, जो शेष डिवीजन पर ओपनजेडक में दिखाया गया था।

अजगर

आइए पायथन में उसी की तुलना करने की कोशिश करते हैं। सबसे पहले, 2 के बंटवारे के शेष के साथ विकल्प:

odd=0
even=0
for i in xrange(100000000):
	if i % 2 == 0:
		even += 1
	else:
		odd += 1
print "even", even
print "odd", odd

हम लॉन्च करते हैं:

[user@localhost ramdisk]$ export LD_LIBRARY_PATH=/mnt/ramdisk ; /mnt/ramdisk/ld-2.17.so /mnt/ramdisk/taskset -c 1 /mnt/ramdisk/ld-2.17.so /mnt/ramdisk/time /mnt/ramdisk/ld-2.17.so /mnt/ramdisk/python2.7 odd_mod.py
even 50000000
odd 50000000
11.69user 0.00system 0:11.69elapsed 99%CPU (0avgtext+0avgdata 4584maxresident)k
0inputs+0outputs (0major+1220minor)pagefaults 0swaps
[user@localhost ramdisk]$
[user@localhost ramdisk]$ export LD_LIBRARY_PATH=/mnt/ramdisk ; /mnt/ramdisk/ld-2.17.so /mnt/ramdisk/taskset -c 1 /mnt/ramdisk/ld-2.17.so /mnt/ramdisk/time /mnt/ramdisk/ld-2.17.so /mnt/ramdisk/python2.7 odd_mod.py
even 50000000
odd 50000000
11.67user 0.00system 0:11.67elapsed 99%CPU (0avgtext+0avgdata 4584maxresident)k
0inputs+0outputs (0major+1220minor)pagefaults 0swaps
[user@localhost ramdisk]$
[user@localhost ramdisk]$ export LD_LIBRARY_PATH=/mnt/ramdisk ; /mnt/ramdisk/ld-2.17.so /mnt/ramdisk/taskset -c 1 /mnt/ramdisk/ld-2.17.so /mnt/ramdisk/time /mnt/ramdisk/ld-2.17.so /mnt/ramdisk/python2.7 odd_mod.py
even 50000000
odd 50000000
11.66user 0.00system 0:11.66elapsed 99%CPU (0avgtext+0avgdata 4584maxresident)k
0inputs+0outputs (0major+1220minor)pagefaults 0swaps

अब बाइनरी और: के साथ एक ही बात

odd=0
even=0
for i in xrange(100000000):
	if i & 1 == 0:
		even += 1
	else:
		odd += 1
print "even", even
print "odd", odd

हम लॉन्च करते हैं:

[user@localhost ramdisk]$ export LD_LIBRARY_PATH=/mnt/ramdisk ; /mnt/ramdisk/ld-2.17.so /mnt/ramdisk/taskset -c 1 /mnt/ramdisk/ld-2.17.so /mnt/ramdisk/time /mnt/ramdisk/ld-2.17.so /mnt/ramdisk/python2.7 odd_and.py
even 50000000
odd 50000000
10.41user 0.00system 0:10.41elapsed 99%CPU (0avgtext+0avgdata 4588maxresident)k
0inputs+0outputs (0major+1221minor)pagefaults 0swaps
[user@localhost ramdisk]$
[user@localhost ramdisk]$ export LD_LIBRARY_PATH=/mnt/ramdisk ; /mnt/ramdisk/ld-2.17.so /mnt/ramdisk/taskset -c 1 /mnt/ramdisk/ld-2.17.so /mnt/ramdisk/time /mnt/ramdisk/ld-2.17.so /mnt/ramdisk/python2.7 odd_and.py
even 50000000
odd 50000000
10.43user 0.00system 0:10.43elapsed 99%CPU (0avgtext+0avgdata 4588maxresident)k
0inputs+0outputs (0major+1222minor)pagefaults 0swaps
[user@localhost ramdisk]$
[user@localhost ramdisk]$ export LD_LIBRARY_PATH=/mnt/ramdisk ; /mnt/ramdisk/ld-2.17.so /mnt/ramdisk/taskset -c 1 /mnt/ramdisk/ld-2.17.so /mnt/ramdisk/time /mnt/ramdisk/ld-2.17.so /mnt/ramdisk/python2.7 odd_and.py
even 50000000
odd 50000000
10.43user 0.00system 0:10.43elapsed 99%CPU (0avgtext+0avgdata 4584maxresident)k
0inputs+0outputs (0major+1222minor)pagefaults 0swaps

परिणाम बताते हैं कि और तेज है।

इंटरनेट पर, यह कई बार लिखा गया है कि पायथन में वैश्विक चर धीमी हैं। मैंने अंतिम कार्यक्रम के निष्पादन समय की तुलना AND और ठीक उसी के साथ करने का निर्णय लिया, लेकिन एक फ़ंक्शन में लिपटे:

def main():
	odd=0
	even=0
	for i in xrange(100000000):
		if i & 1 == 0:
			even += 1
		else:
			odd += 1
	print "even", even
	print "odd", odd

main()

फ़ंक्शन में चलाएं:

[user@localhost ramdisk]$ export LD_LIBRARY_PATH=/mnt/ramdisk ; /mnt/ramdisk/ld-2.17.so /mnt/ramdisk/taskset -c 1 /mnt/ramdisk/ld-2.17.so /mnt/ramdisk/time /mnt/ramdisk/ld-2.17.so /mnt/ramdisk/python2.7 odd_and_func.py
even 50000000
odd 50000000
5.08user 0.00system 0:05.08elapsed 99%CPU (0avgtext+0avgdata 4592maxresident)k
0inputs+0outputs (0major+1222minor)pagefaults 0swaps
[user@localhost ramdisk]$
[user@localhost ramdisk]$ export LD_LIBRARY_PATH=/mnt/ramdisk ; /mnt/ramdisk/ld-2.17.so /mnt/ramdisk/taskset -c 1 /mnt/ramdisk/ld-2.17.so /mnt/ramdisk/time /mnt/ramdisk/ld-2.17.so /mnt/ramdisk/python2.7 odd_and_func.py
even 50000000
odd 50000000
5.08user 0.00system 0:05.09elapsed 99%CPU (0avgtext+0avgdata 4592maxresident)k
0inputs+0outputs (0major+1223minor)pagefaults 0swaps

जैसा कि आप देख सकते हैं, बाइनरी के माध्यम से पायथन में एक ही समता की तुलना और फ़ंक्शन में ~ 5 सेकंड में एक एकल सीपीयू कोर पर 100000000 नंबर की प्रक्रिया होती है, और फ़ंक्शन के बिना और बिना फ़ंक्शन के एक ही तुलना में ~ 10 सेकंड लगते हैं, और विभाजन के शेष भाग के माध्यम से एक फ़ंक्शन के बिना तुलना ~ होती है 11 सेकंड

क्यों एक समारोह में एक पायथन कार्यक्रम तेजी से काम करता है बिना इसके पहले ही एक से अधिक बार वर्णित किया गया है और यह चर के दायरे से संबंधित है।

पायथन में एक कार्यक्रम को आंतरिक कार्यों में अलग करने की क्षमता होती है जो एक कार्यक्रम की व्याख्या करते समय पायथन का उपयोग करता है। आइए देखें कि विषम के लिए वेरिएंट के लिए पायथन किन कार्यों का उपयोग करता है_and_func.py फ़ंक्शन:

[user@localhost ramdisk]# python
Python 2.7.5 (default, Jun 20 2019, 20:27:34)
[GCC 4.8.5 20150623 (Red Hat 4.8.5-36)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> def main():
...     odd=0
...     even=0
...     for i in xrange(100000000):
...             if i & 1 == 0:
...                     even += 1
...             else:
...                     odd += 1
...     print "even", even
...     print "odd", odd
...
>>> import dis
>>> dis.dis(main)
  2           0 LOAD_CONST               1 (0)
              3 STORE_FAST               0 (odd)

  3           6 LOAD_CONST               1 (0)
              9 STORE_FAST               1 (even)

  4          12 SETUP_LOOP              59 (to 74)
             15 LOAD_GLOBAL              0 (xrange)
             18 LOAD_CONST               2 (100000000)
             21 CALL_FUNCTION            1
             24 GET_ITER
        >>   25 FOR_ITER                45 (to 73)
             28 STORE_FAST               2 (i)

  5          31 LOAD_FAST                2 (i)
             34 LOAD_CONST               3 (1)
             37 BINARY_AND
             38 LOAD_CONST               1 (0)
             41 COMPARE_OP               2 (==)
             44 POP_JUMP_IF_FALSE       60

  6          47 LOAD_FAST                1 (even)
             50 LOAD_CONST               3 (1)
             53 INPLACE_ADD
             54 STORE_FAST               1 (even)
             57 JUMP_ABSOLUTE           25

  8     >>   60 LOAD_FAST                0 (odd)
             63 LOAD_CONST               3 (1)
             66 INPLACE_ADD
             67 STORE_FAST               0 (odd)
             70 JUMP_ABSOLUTE           25
        >>   73 POP_BLOCK

  9     >>   74 LOAD_CONST               4 ('even')
             77 PRINT_ITEM
             78 LOAD_FAST                1 (even)
             81 PRINT_ITEM
             82 PRINT_NEWLINE

 10          83 LOAD_CONST               5 ('odd')
             86 PRINT_ITEM
             87 LOAD_FAST                0 (odd)
             90 PRINT_ITEM
             91 PRINT_NEWLINE
             92 LOAD_CONST               0 (None)
             95 RETURN_VALUE

और हमारे कोड में फ़ंक्शन का उपयोग किए बिना समान जांचें:

>>> f=open("odd_and.py","r")
>>> l=f.read()
>>>
>>> l
'odd=0\neven=0\nfor i in xrange(100000000):\n\tif i & 1 == 0:\n\t\teven += 1\n\telse:\n\t\todd += 1\nprint "even", even\nprint "odd", odd\n'
>>> k=compile(l,'l','exec')
>>> k
<code object <module> at 0x7f2bdf39ecb0, file "l", line 1>
>>> dis.dis(k)
  1           0 LOAD_CONST               0 (0)
              3 STORE_NAME               0 (odd)

  2           6 LOAD_CONST               0 (0)
              9 STORE_NAME               1 (even)

  3          12 SETUP_LOOP              59 (to 74)
             15 LOAD_NAME                2 (xrange)
             18 LOAD_CONST               1 (100000000)
             21 CALL_FUNCTION            1
             24 GET_ITER
        >>   25 FOR_ITER                45 (to 73)
             28 STORE_NAME               3 (i)

  4          31 LOAD_NAME                3 (i)
             34 LOAD_CONST               2 (1)
             37 BINARY_AND
             38 LOAD_CONST               0 (0)
             41 COMPARE_OP               2 (==)
             44 POP_JUMP_IF_FALSE       60

  5          47 LOAD_NAME                1 (even)
             50 LOAD_CONST               2 (1)
             53 INPLACE_ADD
             54 STORE_NAME               1 (even)
             57 JUMP_ABSOLUTE           25

  7     >>   60 LOAD_NAME                0 (odd)
             63 LOAD_CONST               2 (1)
             66 INPLACE_ADD
             67 STORE_NAME               0 (odd)
             70 JUMP_ABSOLUTE           25
        >>   73 POP_BLOCK

  8     >>   74 LOAD_CONST               3 ('even')
             77 PRINT_ITEM
             78 LOAD_NAME                1 (even)
             81 PRINT_ITEM
             82 PRINT_NEWLINE

  9          83 LOAD_CONST               4 ('odd')
             86 PRINT_ITEM
             87 LOAD_NAME                0 (odd)
             90 PRINT_ITEM
             91 PRINT_NEWLINE
             92 LOAD_CONST               5 (None)
             95 RETURN_VALUE

जैसा कि आप देख सकते हैं, घोषित फ़ंक्शन के साथ वेरिएंट में, पायथन FAST पोस्टफिक्स के साथ आंतरिक कार्यों का उपयोग करता है, उदाहरण के लिए, STORE_FAST, LOAD_FAST, और फ़ंक्शन की घोषणा के बिना संस्करण में, Python आंतरिक फ़ंक्शन STORE_NAME और LOAD_NAME का उपयोग करता है।

इस लेख का थोड़ा व्यावहारिक अर्थ है और यह लिनक्स, और संकलक की कुछ विशेषताओं को समझने के उद्देश्य से अधिक है।

सभी को अच्छा!

उदाहरणों के साथ लिनक्स कोड प्रदर्शन परीक्षण

तथा

बाइनरी सत्यापन

कोडिंग

लिनक्स पर संसाधन। सी पी यू

हम सभी प्रक्रियाओं के लिए कर्नेल के उपयोग पर रोक लगाते हैं

याद

डिस्क

ओरेकल Java vs Openjdk

अजगर

More articles: