रिवर्स डिबगिंग कैसे काम करता है?

Question 1

GDB का एक नया संस्करण है जो रिवर्स डिबग का समर्थन करता है (देखें http://www.gnu.org/software/gdb/news/reversible.html )। मुझे आश्चर्य हुआ कि यह कैसे काम करता है।

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

Question 2

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

हां, यह महंगा है, लेकिन आधुनिक सीपीयू इतनी तेज है कि जब आप किसी भी तरह से इंटरैक्टिव होते हैं (कदम या ब्रेकपॉइंट कर रहे हैं), तो आप वास्तव में इसे इतना नोटिस नहीं करते हैं।

Question 3

ध्यान दें कि रिवर्स निष्पादन को लागू करने के लिए आपको सिमुलेटर, वर्चुअल मशीन और हार्डवेयर रिकॉर्डर का उपयोग नहीं भूलना चाहिए।

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

दूसरा तरीका चेकपॉइंट + री-एक्ज़ीक्यूशन मेथड का उपयोग करना है, जिसका उपयोग VmWare Workstation 6.5 और Virtutech Simics 3.0 (और बाद में) द्वारा किया जाता है, और जो Visual Studio 2010 के साथ आ रहा है। यहाँ, आप एक वर्चुअल मशीन या एक सिम्युलेटर का उपयोग करते हैं। एक प्रणाली के निष्पादन पर अप्रत्यक्ष स्तर प्राप्त करना। आप नियमित रूप से पूरे राज्य को डिस्क या मेमोरी में डंप करते हैं, और फिर सिम्युलेटर पर भरोसा करते हैं जो सटीक रूप से सटीक प्रोग्राम प्रोग्राम को फिर से निष्पादित करता है।

सरलीकृत, यह इस तरह से काम करता है: कहते हैं कि आप सिस्टम के निष्पादन में समय टी पर हैं। टी -1 के समय पर जाने के लिए, आप पॉइंट टी <टी से कुछ चेकपॉइंट उठाते हैं, और फिर एक (जहाँ आप थे) से पहले एक चक्र को समाप्त करने के लिए (टीटी -1) चक्र को निष्पादित करते हैं। यह बहुत अच्छी तरह से काम करने के लिए बनाया जा सकता है, और यहां तक कि ऐसे वर्कलोड के लिए भी लागू होता है जो डिस्क IO करते हैं, जिसमें कर्नेल-स्तर कोड होता है, और डिवाइस ड्राइवर काम करता है। कुंजी में एक सिम्युलेटर होना चाहिए जिसमें पूरे लक्ष्य प्रणाली शामिल है, इसके सभी प्रोसेसर, डिवाइस, यादें और IOs। देखें gdb मेलिंग सूची और चर्चा निम्नलिखित है कि अधिक जानकारी के लिए gdb मेलिंग सूची पर। मैं विशेष रूप से डिवाइस ड्राइवरों और शुरुआती ओएस बूटों में ट्रिकी कोड को डीबग करने के लिए इस दृष्टिकोण का उपयोग खुद को काफी नियमित रूप से करता हूं।

सूचना का एक अन्य स्रोत चेकपॉइंटिंग (जो मैंने लिखा था, पूरे प्रकटीकरण में) पर एक वाइट्यूटेक व्हाइट पेपर है ।

Question 4

EclipseCon सत्र के दौरान हमने यह भी पूछा कि वे Java के लिए Chronon Debugger के साथ ऐसा कैसे करते हैं । यह आपको वास्तव में वापस कदम रखने की अनुमति नहीं देता है , लेकिन एक रिकॉर्ड किए गए प्रोग्राम निष्पादन को इस तरह से वापस खेल सकता है कि यह रिवर्स डिबगिंग की तरह लगता है । (मुख्य अंतर यह है कि आप क्रोनन डिबगर में चल रहे प्रोग्राम को बदल नहीं सकते, जबकि आप ऐसा कर सकते हैं अन्य अधिकांश डीबगर्स में।)

अगर मैंने इसे सही ढंग से समझा, तो यह रनिंग प्रोग्राम के बाइट कोड में फेरबदल करता है, जैसे कि प्रोग्राम की आंतरिक स्थिति के हर बदलाव को रिकॉर्ड किया जाता है। बाहरी राज्यों को अतिरिक्त रूप से रिकॉर्ड करने की आवश्यकता नहीं है। यदि वे किसी तरह से आपके कार्यक्रम को प्रभावित करते हैं, तो आपके पास उस बाहरी राज्य से मेल खाने वाला एक आंतरिक चर होना चाहिए (और इसलिए कि आंतरिक चर पर्याप्त है)।

प्लेबैक समय के दौरान वे मूल रूप से रिकॉर्ड किए गए राज्य परिवर्तनों से चल रहे कार्यक्रम के प्रत्येक राज्य को फिर से बना सकते हैं।

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

Question 5

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

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

सॉफ्टवेयर आधारित सर्वव्यापी डिबगिंग 1969 EXDAMS प्रणाली के साथ शुरू हुई, जहां इसे "डिबग-टाइम हिस्ट्री-प्लेबैक" कहा गया। जीएनयू डिबगर, जीडीबी ने 2009 से सर्वव्यापी डिबगिंग का समर्थन किया है, इसकी 'प्रक्रिया रिकॉर्ड और रिप्ले' सुविधा के साथ। TotalView, UndoDB और Chronon वर्तमान में उपलब्ध सर्वोत्तम सर्वव्यापी डिबगर हैं, लेकिन वाणिज्यिक सिस्टम हैं। TOD, जावा के लिए, सबसे अच्छा ओपन-सोर्स विकल्प प्रतीत होता है, जो आंशिक नियतात्मक रिप्ले का उपयोग करता है, साथ ही आंशिक ट्रेस कैप्चरिंग और एक वितरित डेटाबेस को शामिल करता है ताकि सूचना के बड़े संस्करणों की रिकॉर्डिंग को सक्षम किया जा सके।

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

इस तरह की पहली प्रणाली 1981 COPE प्रोटोटाइप थी ...

Question 6

मोज़िला rrजीडीबी रिवर्स डिबगिंग का अधिक मजबूत विकल्प है

https://github.com/mozilla/rr

GDB के अंतर्निहित रिकॉर्ड और रिप्ले में गंभीर सीमाएँ हैं, उदाहरण के लिए AVX निर्देशों का कोई समर्थन नहीं: gdb रिवर्स डिबगिंग "प्रक्रिया रिकॉर्ड पते पर निर्देश 0xf0d का समर्थन नहीं करता है" के साथ विफल रहता है

Rr के अपसाइड:

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

rr इसे पहली बार प्रोग्राम को इस तरह से चलाकर प्राप्त करता है जो रिकॉर्ड करता है कि थ्रेड स्विच जैसे हर एक गैर-निर्धारक घटना पर क्या हुआ।

फिर दूसरे रिप्ले रन के दौरान, यह उस ट्रेस फ़ाइल का उपयोग करता है, जो आश्चर्यजनक रूप से छोटा है, मूल गैर-नियतात्मक रन पर वास्तव में क्या हुआ, यह निर्धारित करने के लिए, लेकिन नियतात्मक तरीके से, आगे या पीछे।

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

निम्न उदाहरण इसकी कुछ विशेषताओं को दर्शाता है, विशेष रूप से reverse-next, reverse-stepऔर reverse-continueआदेश।

Ubuntu 18.04 पर स्थापित करें:

sudo apt-get install rr linux-tools-common linux-tools-generic linux-cloud-tools-generic
sudo cpupower frequency-set -g performance
# Overcome "rr needs /proc/sys/kernel/perf_event_paranoid <= 1, but it is 3."
echo 'kernel.perf_event_paranoid=1' | sudo tee -a /etc/sysctl.conf
sudo sysctl -p

परीक्षण कार्यक्रम:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int f() {
    int i;
    i = 0;
    i = 1;
    i = 2;
    return i;
}

int main(void) {
    int i;

    i = 0;
    i = 1;
    i = 2;

    /* Local call. */
    f();

    printf("i = %d\n", i);

    /* Is randomness completely removed?
     * Recently fixed: https://github.com/mozilla/rr/issues/2088 */
    i = time(NULL);
    printf("time(NULL) = %d\n", i);

    return EXIT_SUCCESS;
}

संकलित करें और चलाएं:

gcc -O0 -ggdb3 -o reverse.out -std=c89 -Wextra reverse.c
rr record ./reverse.out
rr replay

अब आपको GDB सत्र के अंदर छोड़ दिया गया है, और आप डीबग को ठीक से उलट सकते हैं:

(rr) break main
Breakpoint 1 at 0x55da250e96b0: file a.c, line 16.
(rr) continue
Continuing.

Breakpoint 1, main () at a.c:16
16          i = 0;
(rr) next
17          i = 1;
(rr) print i
$1 = 0
(rr) next
18          i = 2;
(rr) print i
$2 = 1
(rr) reverse-next
17          i = 1;
(rr) print i
$3 = 0
(rr) next
18          i = 2;
(rr) print i
$4 = 1
(rr) next
21          f();
(rr) step
f () at a.c:7
7           i = 0;
(rr) reverse-step
main () at a.c:21
21          f();
(rr) next
23          printf("i = %d\n", i);
(rr) next
i = 2
27          i = time(NULL);
(rr) reverse-next
23          printf("i = %d\n", i);
(rr) next
i = 2
27          i = time(NULL);
(rr) next
28          printf("time(NULL) = %d\n", i);
(rr) print i
$5 = 1509245372
(rr) reverse-next
27          i = time(NULL);
(rr) next
28          printf("time(NULL) = %d\n", i);
(rr) print i
$6 = 1509245372
(rr) reverse-continue
Continuing.

Breakpoint 1, main () at a.c:16
16          i = 0;

जब जटिल सॉफ़्टवेयर को डीबग करना होता है, तो आप संभवतः एक क्रैश पॉइंट तक चलेंगे, और फिर एक गहरे फ्रेम के अंदर गिरेंगे। उस स्थिति में, reverse-nextउच्च फ्रेम पर मत भूलना , आपको पहले होना चाहिए:

reverse-finish

उस फ्रेम तक, बस सामान्य रूप upसे करना पर्याप्त नहीं है।

मेरी राय में rr की सबसे गंभीर सीमाएँ हैं:

https://github.com/mozilla/rr/issues/2089 आपको स्क्रैच से दूसरा रीप्ले करना होगा, जो कि अगर आप जिस क्रैश को डिबग करने की कोशिश कर रहे हैं वह महंगा हो सकता है, तो कहो, निष्पादन में घंटे
https://github.com/mozilla/rr/issues/1373 x86 केवल

UndoDB rr का एक व्यावसायिक विकल्प है: https://undo.io दोनों ट्रेस / रीप्ले आधारित हैं, लेकिन मुझे यकीन नहीं है कि वे सुविधाओं और प्रदर्शन के मामले में कैसे तुलना करते हैं।

Question 7

नाथन फेलमैन ने लिखा:

लेकिन क्या रिवर्स डिबगिंग केवल आपको अगले रोल को वापस करने की अनुमति देता है और आपके द्वारा टाइप किए गए आदेशों को चरणबद्ध करता है, या क्या यह आपको किसी भी निर्देश को पूर्ववत करने की अनुमति देता है?

आप किसी भी निर्देश को पूर्ववत कर सकते हैं। उदाहरण के लिए, आप उन बिंदुओं तक ही सीमित नहीं हैं, केवल उन बिंदुओं पर रुकना, जहाँ आप आगे बढ़ रहे थे। आप एक नया ब्रेकपॉइंट सेट कर सकते हैं और इसे पीछे की ओर चला सकते हैं।

उदाहरण के लिए, यदि मैं एक निर्देश पर एक ब्रेकपॉइंट सेट करता हूं और इसे तब तक चलने देता हूं, तो क्या मैं फिर से पिछले निर्देश पर वापस आ सकता हूं, भले ही मैं इस पर छोड़ दिया हो?

हाँ। जब तक आप ब्रेकपॉइंट पर जाने से पहले रिकॉर्डिंग मोड ऑन करते हैं।

Question 8

यहां बताया गया है कि ODB नामक एक अन्य रिवर्स-डिबगर कैसे काम करता है। निकालें:

सर्वज्ञ डिबगिंग एक "रुचि के बिंदु" पर "समय टिकटों" को इकट्ठा करने का एक विचार है (एक मान सेट करना, एक विधि कॉल करना, एक कार्यक्रम में एक अपवाद को पकड़ना / पकड़ना) और फिर प्रोग्रामर को उन समय टिकटों का उपयोग करने की अनुमति देता है ताकि वे तलाश कर सकें उस कार्यक्रम का इतिहास चलता है।

ODB ... प्रोग्राम की कक्षाओं में कोड सम्मिलित करता है क्योंकि वे लोड किए जाते हैं और जब प्रोग्राम चलता है, तो घटनाओं को रिकॉर्ड किया जाता है।

मैं अनुमान लगा रहा हूँ कि gdb एक ही तरह से काम करता है।

Question 9

रिवर्स डिबगिंग का अर्थ है कि आप प्रोग्राम को पीछे की ओर चला सकते हैं, जो किसी समस्या के कारण को ट्रैक करने के लिए बहुत उपयोगी है।

आपको प्रत्येक चरण के लिए पूर्ण परिवर्तन की स्थिति में, केवल परिवर्तनों को संग्रहीत करने की आवश्यकता नहीं है। यह शायद अभी भी काफी महंगा है।