[Powered by Google Translate] [Valgrind]
[నేట్ Hardison, హార్వర్డ్ విశ్వవిద్యాలయం]
ఈ CS50.TV, CS50 ఉంది]
సి కార్యక్రమాలు అత్యంత క్లిష్టమైన దోషాలు కొన్ని
మెమరీ నిర్వహణలో నుండి వస్తాయి.
సంగతులకు మేకు మార్గాలు భారీ సంఖ్యలో ఉన్నాయి
మెమరీ తప్పు మొత్తం కేటాయించడం సహా,
వేరియబుల్స్ ప్రారంభించడం మర్చిపోకుండా,
ఒక బఫర్ యొక్క ముగింపు ముందు లేదా తర్వాత రాయడం,
మరియు మెమరీ అనేక సార్లు ఉంచేందుకు ఉండండి.
లక్షణాలు అడపాదడపా క్రాష్ మొదలుకుని
రహస్యంగా భర్తీ విలువలకు,
తరచుగా చాలా లోపం యొక్క అసలు నుండి తొలగించబడింది ప్రదేశాలు మరియు సమయాల్లో.
అంతర్లీన మూల కారణంగా తిరిగి పరిశీలించిన సమస్య వెతకటం
సవాలు చేయవచ్చు,
కానీ అదృష్టవశాత్తూ Valgrind అనే ఉపయోగపడిందా కార్యక్రమం ఉంది
ఆ సహాయం చాలా చేయవచ్చు.
>> మీరు ప్రారంభించడానికి Valgrind ఒక కార్యక్రమాన్ని అమలు
కుప్ప మెమోరీ కేటాయింపులు మరియు ప్రాప్తిని యొక్క విస్తృతమైన చేస్తోంది.
Valgrind ఒక సమస్య గుర్తించినప్పుడు అది, మీరు వెంటనే ఇస్తుంది
మీరు అనుమతించే ప్రత్యక్ష సమాచారం
మరింత సులభంగా కనుగొని పరిష్కరించడానికి.
, కూడా తక్కువ ఘోరమైన మెమరీ సమస్యలపై నివేదికలు Valgrind
మెమరీ లీకేజ్, కుప్ప మెమరీ కేటాయించడం
మరియు ఇది ఉచితం కు మర్చిపోకుండా.
మా డీబగ్గర్ లో మా కంపైలర్, గణగణమని ద్వని చేయు, GDB, ఇష్టం
Valgrind ఉచిత సాఫ్ట్వేర్, మరియు అది ఉపకరణం వ్యవస్థాపించబడిన.
Valgrind, మీ బైనరీ ఎక్సిక్యూటబుల్ అమలు
మీ. సి లేదా. h సోర్స్ కోడ్ ఫైళ్ళను,
కాబట్టి మీరు మీ ప్రోగ్రామ్ యొక్క ఒక నవీనమైన కాపీ సంగ్రహం ఖచ్చితంగా
గణగణమని ద్వని చేయు ఉపయోగించి లేదా చేయండి.
అప్పుడు, Valgrind కింద ప్రోగ్రామ్ను అమలు ఉంటుంది
కేవలం పదం Valgrind ప్రామాణిక కార్యక్రమం ఆదేశం ముందు వంటి సాధారణ,
ఇది Valgrind అప్ మొదలవుతుంది మరియు దాని లోపల కార్యక్రమం నడుపుతుంది.
ప్రారంభించేటప్పుడు, Valgrind కొన్ని క్లిష్టమైన చేస్తుంది
మెమరీ తనిఖీలను కోసం executable ఆకృతీకరించుటకు jiggering,
కాబట్టి పొందడానికి మరియు అమలు చెయ్యడానికి ఒక బిట్ పడుతుంది.
కార్యక్రమం తర్వాత, చాలా చాలా నెమ్మదిగా, సాధారణంగా అమలు ఇది ఉంటుంది
మరియు అది ముగుస్తుండగా, Valgrind దాని మెమరీ వాడుక యొక్క సారాంశం ముద్రిస్తుంది.
అన్ని బాగా పోతే, అది ఈ వంటి ఏదో కనిపిస్తుంది:
ఈ సందర్భంలో,. / Clean_program
నేను అమలు చేయండి కార్యక్రమానికి మార్గం.
మరియు ఈ కథలో వాదనలు తీసుకోదు అయితే,
అది చేస్తే నేను మామూలుగానే ఆదేశం చివర కేవలం టాక్ వారిని చూసాను.
క్లీన్ కార్యక్రమం నేను సృష్టించిన కేవలం ఒక వెర్రి చిన్న కార్యక్రమం
ఆ, కుప్ప మీద ints ఒక బ్లాక్ స్థలాన్ని కేటాయించుకునే
కొన్ని విలువలు వాటిలో లోపల పెట్టి, మరియు మొత్తం బ్లాక్ కాపాడి.
ఈ మీరు లోపాలు మరియు లీకేజ్ లేదు, చిత్రీకరణ ఏమి ఉంది.
>> మరో ముఖ్యమైన మెట్రిక్ కేటాయించింది బైట్లు మొత్తం సంఖ్య.
మీ కేటాయింపులు మెగాబైట్ల లేదా ఎక్కువ లో ఉంటే ప్రోగ్రామ్ ఆధారంగా
మీరు బహుశా ఏదో చేయుచున్నారు.
మీరు అనవసరంగా నకిలీలను నిల్వ ఉంటాయి?
ఇది స్టాక్ ఉపయోగించడానికి మంచిదని మీరు, నిల్వ కోసం కుప్ప ఉపయోగిస్తున్నారు?
కాబట్టి, మెమరీ లోపాలు నిజంగా దుష్ట ఉంటుంది.
ఎక్కువగా కనిపిస్తాయి వాటిని, అద్భుతమైన క్రాష్ కారణం
కానీ అప్పటికీ కూడా ఇప్పటికీ ఏర్పడుతాయి కష్టంగా ఉంటుంది
ఏ సరిగ్గా క్రాష్ దారితీసింది.
ఒక మెమరీ లోపం మరింత insidiously, ఒక ప్రోగ్రామ్
ఇప్పటికీ వారు కంపైల్ చేయవచ్చు
మరియు ఇంకా సరిగ్గా పని ఉన్నాయి
మీరు ఎక్కువ సమయం లక్కీ సాధించింది ఎందుకంటే.
అనేక తర్వాత "విజయవంతమైన ఫలితాలను,"
మీరు, క్రాష్ కంప్యూటర్ యొక్క ఒక అదృష్టమని ఉంటుంది ఉండవచ్చు
కానీ కంప్యూటర్ తప్పు కాదు.
>> Valgrind రన్నింగ్ మీరు కనిపించే మెమరీ లోపాల కారణం జాడ సహాయపడుతుంది
అలాగే తప్పులు ప్రచ్ఛన్న కనుగొనడానికి మీరు కూడా ఇంకా గురించి తెలియదు.
Valgrind ఒక సమస్య గుర్తించి ప్రతిసారి, అది గమనించిన గురించి సమాచారం అందిస్తుంది.
ప్రతి అంశం చాలా సంక్షిప్తమైన ఉంది -
ఆక్షేపణీయ బోధనా మూల లైన్, సమస్య ఏమిటి,
పాల్గొన్న మెమరీ గురించి మరియు ఒక చిన్న సమాచారం -
కానీ తరచుగా సరైన స్థలం మీ దృష్టిని దర్శకత్వం తగినంత సమాచారం.
ఇక్కడ ఒక బగ్గీ కార్యక్రమం అమలు Valgrind యొక్క ఒక ఉదాహరణ
ఆ కుప్ప మెమరీ చెల్లని రీడ్ చేస్తుంది.
మేము సంకలనంలో లోపాలు లేదా హెచ్చరికలు చూడండి.
UH-OH, లోపం సారాంశం రెండు లోపాలు లేవని తెలుస్తుంది -
పరిమాణం 4 రెండు చెల్లని పుస్తకాలు - బైట్లు, ఆ ఉంటుంది.
రెండు చెడు, invalid_read.c యొక్క ప్రధాన విధి జరిగింది చదువుతుంది
లైన్ 16 మరియు 19 లైన్ లో రెండవ మొదటి.
యొక్క కోడ్ చూద్దాం.
Printf మా మెమరీ బ్లాక్ ముగింపులో గత ఒక Int చదవటానికి ప్రయత్నిస్తుంది మొదటి కాల్ కనిపిస్తోంది.
మేము Valgrind యొక్క అవుట్పుట్ తిరిగి చూడాలని, ఉంటే
మేము Valgrind సరిగ్గా మాకు చెప్పారు చూసాము.
మేము చదవడానికి ప్రయత్నిస్తున్న చిరునామా 0 చి ప్రారంభమవుతుంది
- పరిమాణం 16 బైట్లు యొక్క బ్లాక్ ముగింపులో గత
మేము కేటాయించింది నాలుగు 32-bit ints.
అంటే, మేము చదవడానికి ప్రయత్నిస్తున్న చిరునామా, కుడి మా బ్లాక్ చివరిలో ప్రారంభమవుతుంది
మేము మా చెడ్డ printf కాల్ చూడండి కేవలం.
ఇప్పుడు, చెల్లని పుస్తకాలు, ఒక ఒప్పందం యొక్క పెద్ద వంటి కనిపించడం ఉండవచ్చు
కానీ మీరు మీ ప్రోగ్రామ్ యొక్క ప్రవాహ నియంత్రణ డేటా ను ఉపయోగిస్తున్నట్లయితే -
ఉదాహరణకు, ఒక భాగంగా ఉంటే ప్రకటన లేదా లూప్ -
అప్పుడు విషయాలు నిశ్శబ్దంగా చెడు వెళ్ళవచ్చు.
నేను invalid_read అమలు ఎలా చూడండి
మరియు సాధారణ యొక్క ఏమీ అవుట్ జరుగుతుంది.
స్కేరీ, హుహ్?
>> ఇప్పుడు, యొక్క మీ కోడ్ లో ఎదుర్కొనే కొన్ని లోపాలు కొన్ని రకాల చూద్దాం
మరియు మేము వాటిని గుర్తించి ఎలా Valgrind చూస్తారు.
మేము, ఒక invalid_read ఒక ఉదాహరణ చూసిన
కాబట్టి ఇప్పుడు యొక్క ఒక invalid_write తనిఖీ అనుమతిస్తుంది.
మళ్లీ, సంకలనంలో లోపాలు లేదా హెచ్చరికలు.
సరే, Valgrind ఈ కార్యక్రమంలో రెండు లోపాలు లేవని తెలుస్తుంది -
మరియు invalid_write మరియు ఒక invalid_read.
యొక్క ఈ కోడ్ తనిఖీ లెట్.
మేము strlen ప్లస్ ఒక బగ్ యొక్క ఒక ఉదాహరణ వచ్చింది అనిపిస్తున్నది.
కోడ్ malloc స్థలం అదనపు బైట్ కాదు
/ 0 పాత్ర కోసం,
కాబట్టి STR కాపీ ssubstrlen వద్ద వ్రాయటానికి వెళ్ళినప్పుడు అతను "cs50 రాళ్ళు!"
అది మా బ్లాక్ ముగింపులో గత 1 బైట్ రాశారు.
మేము printf మా కాల్ చేసినపుడు invalid_read వస్తుంది.
అది / 0 పాత్ర చదువునప్పుడు Printf చెల్లని మెమరీ reading ముగుస్తుంది
ఈ E స్ట్రింగ్ చివరిలో ఉంది గా ముద్రణ ఉంది.
కానీ ఈ ఎవరూ Valgrind తప్పించుకున్నారు.
మేము STR కాపీ భాగంగా ఇది invalid_write క్యాచ్ ఆ చూడండి
ప్రధాన రేఖ 11 న, మరియు invalid_read printf భాగం.
Valgrind, రాక్ ఆన్.
మళ్ళీ, ఈ పెద్ద ఒప్పందంలో వంటి కనిపించడం ఉండవచ్చు.
మేము Valgrind వెలుపల మీద మరియు ఈ కార్యక్రమం అమలు చెయ్యవచ్చు
మరియు ఏ లోపం లక్షణాలు చూడండి లేదు.
>> అయితే, చూడటానికి ఈ స్వల్ప వ్యత్యాసం చూడండి యొక్క తెలపండి
ఎలా వస్తువులు నిజంగా చెడు పొందవచ్చు.
కాబట్టి, మంజూరు, మేము ఈ కోడ్ లో ఒక బిట్ కంటే ఎక్కువ విషయాలు దుర్భాషలాడటం ఉంటాయి.
మేము రెండు రెమ్మలు కోసం కుప్ప మీద స్థలాన్ని కేటాయించడం చేస్తున్నారు
cs50 రాళ్ళు పొడవు,
ఈ సమయంలో, / 0 పాత్ర గుర్తు.
కానీ మేము మెమరీ బ్లాక్ లోకి సూపర్ దీర్ఘ స్ట్రింగ్ విసరాలి
ఆ S కు సూచిస్తుంది.
ఏ ప్రభావం మెమరీ బ్లాక్ లో కలిగి కు T పాయింట్లు?
Well, ఉంటే S కేవలం ప్రక్కన ఉండే స్మృతికి T పాయింట్లు,
దీనిని తరువాత వచ్చే,
అప్పుడు మేము T. భాగంగా రాసి ఉండవచ్చు
యొక్క ఈ కోడ్ అమలు అయ్యేలా అనుమతించండి.
ఏమి వద్ద చూడండి.
మేము మా కుప్ప బ్లాక్స్ రెండు నిల్వ తీగలను సరిగ్గా ముద్రించిన కనిపించింది.
నథింగ్ అన్ని తప్పు ఉంది.
అయితే, యొక్క మా కోడ్ తిరిగి వీడలేదు మరియు
మేము cs50 రాళ్ళు కాపీ పేరు లైన్ అవ్ట్ వ్యాఖ్య
రెండవ మెమరీ బ్లాక్ లోకి, t ద్వారా చూపారు.
ఇప్పుడు మేము ఈ కోడ్ అమలు మేము చేయాలి
మొదటి మెమరీ బ్లాక్ విషయాలు ముద్రించాలా చూడండి.
అయ్యో, మేము STR కాపీ కాదు అయినప్పటికీ
రెండవ కుప్ప బ్లాక్ లోకి ఏ అక్షరాలు, ఒక, T ద్వారా చూపారు
మేము ఒక ప్రింట్ అవుట్.
నిజానికి, స్ట్రింగ్ మేము మా మొదటి బ్లాక్ నింపుతారు
మొదటి బ్లాక్ మరియు రెండవ బ్లాక్ లోకి, దండయాత్ర
ప్రతిదీ సాధారణ కనిపిస్తుంది అయింది.
Valgrind, అయితే, మాకు నిజమైన కథ చెబుతుంది.
అక్కడ మేము వెళ్ళి.
ఆ చెల్లని అన్ని చదివి మరియు వ్రాస్తాడు.
>> యొక్క లోపం మరొక రకమైన ఉదాహరణగా చూద్దాం.
ఇక్కడ మేము కాకుండా దురదృష్టకరమైన ఏదో ఒకటి.
మేము, కుప్ప మీద ఒక పూర్ణాంకానికి స్థలాన్ని పట్టుకొను
p - - ఆ స్థలం సూచించడానికి మరియు మేము ఒక పూర్ణాంకానికి పాయింటర్ ప్రారంభించడం.
అయితే, మా పాయింటర్ initialized ఉన్నప్పుడు,
అది సూచించే చేసే డేటా కేవలం కుప్ప ఆ భాగంలో ఏ వ్యర్థ ఉంది.
కాబట్టి మేము Int నేను ఆ డేటాను లోడ్ చేసినప్పుడు,
మేము సాంకేతికంగా, నేను ప్రారంభించడం
కానీ మేము వ్యర్థ డేటా తో అలా.
కాల్ చక్కని డీబగ్గింగ్ స్థూల ఇది బలపరచటానికి
సముచితంగా అనే నొక్కి లైబ్రరీ లో నిర్వచించిన,
గర్భస్రావము దాని పరీక్ష పరిస్థితి విఫలమైతే కార్యక్రమాన్ని రెడీ.
నేను 0 లేదు అని చెప్పాడు ఉంది.
కుప్ప స్పేస్ లో ఏం ఆధారపడి,, p చూపారు
ఈ కార్యక్రమం కొన్నిసార్లు పని మరియు ఇతర సమయాల్లో వైఫల్యం చెందవచ్చు.
ఇది పనిచేస్తుంది ఉంటే, మేము లక్కీ చేస్తున్నారు.
కంపైలర్ ఈ లోపం క్యాచ్, కానీ ఖచ్చితంగా విల్ Valgrind లేదు.
అక్కడ మేము ఆ వ్యర్థ డేటా మా ఉపయోగం ద్వారా సంక్రమించిన లోపం చూడండి.
>> మీరు కుప్ప మెమరీని కేటాయించాల్సిన కానీ deallocate లేదా ఇది ఉచితం వాడవద్దు,
ఒక లీక్ అంటారు.
నిష్క్రమిస్తుంది నడుస్తుంది మరియు వెంటనే ఒక చిన్న, తక్కువ కాలం కార్యక్రమం కోసం,
లీకేజ్ బాగా హానిచేయని ఉంటాయి,
కానీ పెద్ద పరిమాణం మరియు / లేదా దీర్ఘాయువు ఒక ప్రాజెక్ట్ కోసం,
ఒక చిన్న లీక్ ప్రధాన దానిని సమ్మేళనం చేయవచ్చు.
CS50, మీరు నువ్వు అనుకుంటున్నావా
మీరు కేటాయించాలని ఆ కుప్ప మెమరీ అన్ని ఉండండి యొక్క శ్రద్ధ వహించడానికి,
మేము మీరు మాన్యువల్ ప్రాసెస్ సరిగా నిర్వహించడానికి నైపుణ్యాలు నిర్మించడానికి కావలసిన నుండి
C. అవసరమైన
అలా చెయ్యడానికి, మీ ప్రోగ్రామ్ ఒక ఖచ్చితమైన ఉండాలి
malloc మరియు ఉచిత కాల్స్ మధ్య ఒక దానితో ఒకటిని.
అదృష్టవశాత్తూ, Valgrind చాలా మెమరీ లీకేజ్ మీకు సహాయం చేస్తుంది.
ఇక్కడ leak.c అనే కారుతున్న కార్యక్రమం అని కేటాయించుకునే
కుప్ప మీద స్పేస్, అది వ్రాస్తాడు, కానీ ఇది ఉచితం లేదు.
మేము, చేయండి మరియు Valgrind కింద అమలు తో కంపైల్
మరియు మేము చూడండి, మేము మెమరీ లోపాలు లేవు, ఆ
మేము ఒక లీక్ ఉన్నాయి.
ఖచ్చితంగా కోల్పోయింది 16 బైట్లు ఉన్నాయి
కార్యక్రమం ముగిసింది ఆ స్మృతికి పాయింటర్ పరిధిని కాదని అర్థం.
ఇప్పుడు, Valgrind, మాకు లీక్ గురించి ఒక టన్ను ఇవ్వదు
కానీ మేము దాని నివేదిక దిగువ దిశగా డౌన్ ఇచ్చే ఈ చిన్న నోట్ అనుసరించండి ఉంటే
తో తిరిగి కు - లీక్ తనిఖీ = పూర్తి
వెల్లడైంది మెమరీ పూర్తి వివరాలను చూడడానికి,
మేము మరింత సమాచారం పొందుతారు.
ఇప్పుడు, కుప్ప సారాంశంలో,
ఓడిపోయిన మెమరీ ప్రారంభంలో కేటాయించారు పేరు Valgrind మాకు చెబుతుంది.
మేము సోర్స్ కోడ్ చూస్తూ తెలిసిన వలె,
Valgrind మేము మెమరీ వెల్లడైంది మాకు సమాచారం
leak.c యొక్క పంక్తి 8 న malloc ఒక కాల్ తో కేటాయించింది
ప్రధాన ఫంక్షన్.
ప్రెట్టీ నిఫ్టీ.
>> Valgrind ఈ పదాలను ఉపయోగించి స్రావాలు వర్గీకరిస్తుంది:
ఖచ్చితంగా కోల్పోయింది - ఈ కుప్ప కేటాయించిన మెమొరీ ఉంటుంది
కార్యక్రమం ఇకపై ఒక పాయింటర్ కలిగి.
Valgrind మీరు ఒకసారి పాయింటర్ కానీ నుండీ యొక్క ట్రాక్ కోల్పోయారు తెలుసు.
ఈ మెమరీ ఖచ్చితంగా వెల్లడైంది ఉంది.
పరోక్షంగా కోల్పోయింది - ఈ కుప్ప కేటాయించిన మెమొరీ ఉంటుంది
అది మాత్రమే గమనికలు కూడా పోతాయి కు.
ఉదాహరణకు, మీరు ఒక లింక్ జాబితా యొక్క మొదటి నోడ్ మీ పాయింటర్ కోల్పోతే,
అప్పుడు మొదటి నోడ్ కూడా ఖచ్చితంగా, కోల్పోయిన ఉంటుంది
ఏ తదుపరి నోడ్స్ పరోక్షంగా కోల్పోయింది అయితే.
బహుశా కోల్పోయిన - ఈ కుప్ప కేటాయించిన మెమొరీ ఉంటుంది
ఇది వరకు Valgrind ఒక పాయింటర్ లేదా అక్కడ అనే ఖచ్చితంగా కాదు.
ఇప్పటికీ అందుబాటులో కుప్ప కేటాయించిన మెమొరీ ఉంటుంది
కార్యక్రమం ఇప్పటికీ నిష్క్రమించండి ఒక పాయింటర్ కలిగి కు,
ఇది సాధారణంగా అంటే అది ఒక ప్రపంచ వేరియబుల్ పాయింట్లు.
ఈ స్రావాలు తనిఖీ, మీరు కూడా ఎంపిక ఉన్నాయి ఉంటుంది
- ఇంకా అందుబాటులో = అవును
Valgrind మీ ఆవాహన లో.
>> ఈ వివిధ సందర్భాలలో, వాటిని శుభ్రపరిచే వివిధ వ్యూహాలు అవసరపడవచ్చు
కానీ స్రావాలు తొలగించాలి.
దురదృష్టవశాత్తు, స్రావాలు ఫిక్సింగ్, చేయడానికి కష్టం
ఉచిత సరికాదు కాల్స్ మీ ప్రోగ్రామ్ పేల్చివేయడానికి ఎందుకంటే.
ఉదాహరణకు, invalid_free.c విషయంలో చూస్తే,
మేము చెడ్డ జ్ఞాపకం deallocation ఒక ఉదాహరణ చూడండి.
మొత్తం బ్లాక్ విముక్తికై ఒక కాల్ ఉండాలి
మెమరీ, int_block ద్వారా చూపారు
బదులుగా ప్రతి Int పరిమాణం విభాగం విడిపించేందుకు ప్రయత్నంలో మారింది
వ్యక్తిగతంగా మెమరీ.
ఈ విపత్తుల విఫలమౌతుంది.
బూమ్! ఏ లోపం.
ఈ ఖచ్చితంగా మంచి కాదు.
మీరు ఈ రకమైన ఇరుక్కుపోయి ఉన్నాం, అయితే, మరియు మీరు, ఇక్కడ చూడవలసిన తెలియకపోతే
మీ కొత్త స్నేహితుడి తిరిగి వస్తాయి.
మీరు ఊహించిన - Valgrind.
Valgrind, వంటి ఎల్లప్పుడూ అప్, వేటి తెలుసు.
alloc మరియు ఉచిత గణనలు మ్యాచ్ కాకపోవడం.
మేము 1 alloc మరియు 4 ఫ్రీస్ పొందారు.
మరియు Valgrind కూడా మొదటి చెడు ఉచిత కాల్ మాకు చెబుతుంది -
blowup కారణమైన ఒక - నుండి వచ్చినది -
లైన్ 16.
మీరు చూడండి వంటి, ఉచిత ప్రతికూల కాల్స్, నిజంగా తప్పుగా ఉన్నాయి
కాబట్టి మేము మీ ప్రోగ్రామ్ లీక్ తెలియజేసినందుకు సిఫార్సు
మీరు కార్యాచరణ సరైన పొందడానికి పని చేస్తున్న సమయంలో.
మీ ప్రోగ్రామ్ సరిగా పని మాత్రమే తర్వాత దోషాలను వెతుకుతున్న ప్రారంభం,
ఇతర లోపాలు లేకుండా.
>> మరియు మేము ఈ వీడియో కోసం మేం అంతే.
ఇప్పుడు మీరు కోసం వేచి ఉన్నాయో?
ప్రస్తుతం మీ కార్యక్రమాల మీద Valgrind అమలు వెళ్ళండి.
నా పేరు నేట్ Hardison ఉంది. ఈ CS50 ఉంది. [CS50.TV]