स्प्रोफ़ - क्लाउड में ऑनलाइन

कार्यक्रम:

नाम

स्प्रोफ - साझा ऑब्जेक्ट प्रोफाइलिंग डेटा को पढ़ें और प्रदर्शित करें

SYNOPSIS

sprof [विकल्प] ... साझा-वस्तु-पथ [प्रोफ़ाइल-डेटा-पथ]

वर्णन

RSI sprof कमांड साझा ऑब्जेक्ट (साझा लाइब्रेरी) के लिए एक प्रोफाइलिंग सारांश प्रदर्शित करता है
इसे इसके पहले कमांड-लाइन तर्क के रूप में निर्दिष्ट किया गया है। प्रोफ़ाइलिंग सारांश का उपयोग करके बनाया गया है
(वैकल्पिक) दूसरे कमांड-लाइन तर्क में पहले से तैयार किया गया प्रोफाइलिंग डेटा। अगर
प्रोफ़ाइलिंग डेटा पथनाम छोड़ दिया गया है sprof का उपयोग करके इसका अनुमान लगाने का प्रयास किया जाएगा
साझा ऑब्जेक्ट का सोनम नाम, नाम वाली फ़ाइल की तलाश में ।प्रोफ़ाइल में
वर्तमान निर्देशिका।

विकल्प

निम्नलिखित कमांड-लाइन विकल्प उत्पादित किए जाने वाले प्रोफ़ाइल आउटपुट को निर्दिष्ट करते हैं:

-c, --कॉल-जोड़े
साझा द्वारा निर्यात किए गए इंटरफ़ेस के लिए कॉल पथों के जोड़े की एक सूची प्रिंट करें
ऑब्जेक्ट, साथ ही प्रत्येक पथ का कितनी बार उपयोग किया जाता है।

-p, --फ्लैट-प्रोफ़ाइल
मॉनिटर किए गए ऑब्जेक्ट में सभी कार्यों का एक सपाट प्रोफ़ाइल तैयार करें
गिनता है और टिक करता है।

-q, --ग्राफ
एक कॉल ग्राफ़ बनाएं.

यदि उपरोक्त विकल्पों में से कोई भी निर्दिष्ट नहीं है, तो डिफ़ॉल्ट व्यवहार एक फ्लैट प्रदर्शित करना है
प्रोफ़ाइल और एक कॉल ग्राफ़।

निम्नलिखित अतिरिक्त कमांड-लाइन विकल्प उपलब्ध हैं:

-?, --मदद
कमांड-लाइन विकल्पों और तर्कों का सारांश प्रदर्शित करें और बाहर निकलें।

--उपयोग
एक संक्षिप्त उपयोग संदेश प्रदर्शित करें और बाहर निकलें।

-V, --संस्करण
प्रोग्राम संस्करण प्रदर्शित करें और बाहर निकलें।

अनुरूप सेवा मेरे

RSI sprof कमांड एक GNU एक्सटेंशन है, जो POSIX.1 में मौजूद नहीं है।

उदाहरण

निम्नलिखित उदाहरण इसके उपयोग को दर्शाता है sprof. उदाहरण में एक मुख्य शामिल है
प्रोग्राम जो एक साझा ऑब्जेक्ट में दो फ़ंक्शन को कॉल करता है। सबसे पहले, मुख्य कार्यक्रम का कोड:

$ बिल्ली प्रोग.सी
#शामिल

शून्य x1(शून्य);
शून्य x2(शून्य);

int
मुख्य(int argc, char *argv[])
{
x1();
x2();
बाहर निकलें(EXIT_SUCCESS);
}

कार्य करता है x1() और x2() निम्नलिखित स्रोत फ़ाइल में परिभाषित किया गया है जिसका उपयोग किया जाता है
साझा वस्तु का निर्माण करें:

$ बिल्ली libdemo.c
#शामिल करना

शून्य
उपभोगCpu1(int lim)
{
इंट जे;

(j = 0; j < lim; j++) के लिए
getppid();
}

शून्य
x1(शून्य) {
इंट जे;

(j = 0; j < 100; j++) के लिए
उपभोगसीपीयू1; (200000)
}

शून्य
उपभोगCpu2(int lim)
{
इंट जे;

(j = 0; j < lim; j++) के लिए
getppid();
}

शून्य
x2(शून्य)
{
इंट जे;

(j = 0; j < 1000; j++) के लिए
उपभोगसीपीयू2; (10000)
}

अब हम वास्तविक नाम के साथ साझा वस्तु का निर्माण करते हैं libdemo.so.1.0.1, और सोनम
libdemo.so.1:

$ cc -g -एफपीआईसी कमरा साझा -Wl,-soname,libdemo.so.1 \
-o libdemo.so.1.0.1 libdemo.c

फिर हम लाइब्रेरी सोनैम और लाइब्रेरी लिंकर नाम के लिए प्रतीकात्मक लिंक बनाते हैं:

$ ln -एसएफ libdemo.so.1.0.1 libdemo.so.1
$ ln -एसएफ libdemo.so.1 libdemo.so

इसके बाद, हम मुख्य प्रोग्राम को संकलित करते हैं, इसे साझा ऑब्जेक्ट से जोड़ते हैं, और फिर सूचीबद्ध करते हैं
कार्यक्रम की गतिशील निर्भरताएँ:

$ cc -g -o ठेला प्रोग.सी एल। -एलडेमो
$ ldd ठेला
linux-vdso.so.1 => (0x00007fff86d66000)
libdemo.so.1 => नहीं मिला
libc.so.6 => /lib64/libc.so.6 (0x00007fd4dc138000)
/lib64/ld-linux-x86-64.so.2 (0x00007fd4dc51f000)

साझा ऑब्जेक्ट के लिए प्रोफ़ाइलिंग जानकारी प्राप्त करने के लिए, हम पर्यावरण को परिभाषित करते हैं
परिवर्तनशील एलडी_प्रोफ़ाइल लाइब्रेरी के सोनम नाम के साथ:

$ निर्यात LD_PROFILE=libdemo.so.1

फिर हम पर्यावरण चर को परिभाषित करते हैं LD_PROFILE_OUTPUT के पथनाम के साथ
निर्देशिका जहां प्रोफ़ाइल आउटपुट लिखा जाना चाहिए, और यदि ऐसा नहीं है तो वह निर्देशिका बनाएं
पहले से मौजूद है:

$ निर्यात LD_PROFILE_OUTPUT=$(pwd)/prof_data
$ mkdir -p $LD_PROFILE_OUTPUT

एलडी_प्रोफ़ाइल प्रोफ़ाइलिंग आउटपुट का कारण बनता है संलग्न आउटपुट फ़ाइल में यदि यह पहले से मौजूद है,
इसलिए हम सुनिश्चित करते हैं कि पहले से मौजूद कोई प्रोफ़ाइलिंग डेटा न हो:

$ rm -f $LD_PROFILE_OUTPUT/$LD_PROFILE.profile

फिर हम प्रोफाइलिंग आउटपुट तैयार करने के लिए प्रोग्राम चलाते हैं, जो कि एक फ़ाइल में लिखा जाता है
निर्देशिका में निर्दिष्ट LD_PROFILE_OUTPUT:

$ एलडी_LIBRARY_PATH=. ./प्रोग
$ ls prof_data
libdemo.so.1.profile

हम तब का उपयोग करते हैं sprof -p गिनती और टिक के साथ एक फ्लैट प्रोफ़ाइल तैयार करने का विकल्प:

$ sprof -p libdemo.so.1 $LD_PROFILE_OUTPUT/libdemo.so.1.profile
समतल प्रोफ़ाइल:

प्रत्येक नमूना 0.01 सेकंड के रूप में गिना जाता है।
% संचयी स्वयं का कुल
समय सेकंड सेकंड हमें कॉल करता है/हमें कॉल करता है/नाम कॉल करता है
60.00 0.06 0.06 100 600.00 उपभोगसीपीयू1
40.00 0.10 0.04 1000 40.00 उपभोगसीपीयू2
0.00 0.10 0.00 1 0.00 X1
0.00 0.10 0.00 1 0.00 X2

RSI sprof -q विकल्प एक कॉल ग्राफ़ उत्पन्न करता है:

$ sprof -q libdemo.so.1 $LD_PROFILE_OUTPUT/libdemo.so.1.profile

अनुक्रमणिका % समय स्वंय बच्चों ने नाम पुकारा

0.00 0.00 100/100 x1 [1]
[0] 100.0 0.00 0.00 100 उपभोगसीपीयू1 [0]
-----------------------------------------------
0.00 0.00 1/1
[1] 0.0 0.00 0.00 1 एक्स1 [1]
0.00 0.00 100/100 उपभोगसीपीयू1 [0]
-----------------------------------------------
0.00 0.00 1000/1000 x2 [3]
[2] 0.0 0.00 0.00 1000 उपभोगसीपीयू2 [2]
-----------------------------------------------
0.00 0.00 1/1
[3] 0.0 0.00 0.00 1 एक्स2 [3]
0.00 0.00 1000/1000 उपभोगसीपीयू2 [2]
-----------------------------------------------

ऊपर और नीचे, " "स्ट्रिंग्स उन पहचानकर्ताओं का प्रतिनिधित्व करते हैं जो इसके बाहर हैं
प्रोफाइल ऑब्जेक्ट (इस उदाहरण में, ये उदाहरण हैं मुख्य()).

RSI sprof -c विकल्प कॉल जोड़े की एक सूची और उनकी घटनाओं की संख्या उत्पन्न करता है:

$ sprof -c libdemo.so.1 $LD_PROFILE_OUTPUT/libdemo.so.1.profile
x1 1
X1 उपभोगCpu1 100
x2 1
X2 उपभोगCpu2 1000

onworks.net सेवाओं का उपयोग करके ऑनलाइन sprof का उपयोग करें