1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [Valgrind]

2
00:00:02,000 --> 00:00:05,000
[నేట్ Hardison, హార్వర్డ్ విశ్వవిద్యాలయం]

3
00:00:05,000 --> 00:00:07,000
ఈ CS50.TV, CS50 ఉంది]

4
00:00:07,000 --> 00:00:10,000
సి కార్యక్రమాలు అత్యంత క్లిష్టమైన దోషాలు కొన్ని

5
00:00:10,000 --> 00:00:13,000
మెమరీ నిర్వహణలో నుండి వస్తాయి.

6
00:00:13,000 --> 00:00:15,000
సంగతులకు మేకు మార్గాలు భారీ సంఖ్యలో ఉన్నాయి

7
00:00:15,000 --> 00:00:17,000
మెమరీ తప్పు మొత్తం కేటాయించడం సహా,

8
00:00:17,000 --> 00:00:20,000
వేరియబుల్స్ ప్రారంభించడం మర్చిపోకుండా,

9
00:00:20,000 --> 00:00:23,000
ఒక బఫర్ యొక్క ముగింపు ముందు లేదా తర్వాత రాయడం,

10
00:00:23,000 --> 00:00:25,000
మరియు మెమరీ అనేక సార్లు ఉంచేందుకు ఉండండి.

11
00:00:25,000 --> 00:00:28,000
లక్షణాలు అడపాదడపా క్రాష్ మొదలుకుని

12
00:00:28,000 --> 00:00:30,000
రహస్యంగా భర్తీ విలువలకు,

13
00:00:30,000 --> 00:00:34,000
తరచుగా చాలా లోపం యొక్క అసలు నుండి తొలగించబడింది ప్రదేశాలు మరియు సమయాల్లో.

14
00:00:34,000 --> 00:00:37,000
అంతర్లీన మూల కారణంగా తిరిగి పరిశీలించిన సమస్య వెతకటం

15
00:00:37,000 --> 00:00:39,000
సవాలు చేయవచ్చు,

16
00:00:39,000 --> 00:00:42,000
కానీ అదృష్టవశాత్తూ Valgrind అనే ఉపయోగపడిందా కార్యక్రమం ఉంది

17
00:00:42,000 --> 00:00:44,000
ఆ సహాయం చాలా చేయవచ్చు.

18
00:00:44,000 --> 00:00:47,000
>> మీరు ప్రారంభించడానికి Valgrind ఒక కార్యక్రమాన్ని అమలు

19
00:00:47,000 --> 00:00:50,000
కుప్ప మెమోరీ కేటాయింపులు మరియు ప్రాప్తిని యొక్క విస్తృతమైన చేస్తోంది.

20
00:00:50,000 --> 00:00:53,000
Valgrind ఒక సమస్య గుర్తించినప్పుడు అది, మీరు వెంటనే ఇస్తుంది

21
00:00:53,000 --> 00:00:56,000
మీరు అనుమతించే ప్రత్యక్ష సమాచారం

22
00:00:56,000 --> 00:00:58,000
మరింత సులభంగా కనుగొని పరిష్కరించడానికి.

23
00:00:58,000 --> 00:01:01,000
, కూడా తక్కువ ఘోరమైన మెమరీ సమస్యలపై నివేదికలు Valgrind

24
00:01:01,000 --> 00:01:04,000
మెమరీ లీకేజ్, కుప్ప మెమరీ కేటాయించడం

25
00:01:04,000 --> 00:01:07,000
మరియు ఇది ఉచితం కు మర్చిపోకుండా.

26
00:01:07,000 --> 00:01:10,000
మా డీబగ్గర్ లో మా కంపైలర్, గణగణమని ద్వని చేయు, GDB, ఇష్టం

27
00:01:10,000 --> 00:01:14,000
Valgrind ఉచిత సాఫ్ట్వేర్, మరియు అది ఉపకరణం వ్యవస్థాపించబడిన.

28
00:01:14,000 --> 00:01:16,000
Valgrind, మీ బైనరీ ఎక్సిక్యూటబుల్ అమలు

29
00:01:16,000 --> 00:01:20,000
మీ. సి లేదా. h సోర్స్ కోడ్ ఫైళ్ళను,

30
00:01:20,000 --> 00:01:23,000
కాబట్టి మీరు మీ ప్రోగ్రామ్ యొక్క ఒక నవీనమైన కాపీ సంగ్రహం ఖచ్చితంగా

31
00:01:23,000 --> 00:01:25,000
గణగణమని ద్వని చేయు ఉపయోగించి లేదా చేయండి.

32
00:01:25,000 --> 00:01:28,000
అప్పుడు, Valgrind కింద ప్రోగ్రామ్ను అమలు ఉంటుంది

33
00:01:28,000 --> 00:01:32,000
కేవలం పదం Valgrind ప్రామాణిక కార్యక్రమం ఆదేశం ముందు వంటి సాధారణ,

34
00:01:32,000 --> 00:01:35,000
ఇది Valgrind అప్ మొదలవుతుంది మరియు దాని లోపల కార్యక్రమం నడుపుతుంది.

35
00:01:35,000 --> 00:01:38,000
ప్రారంభించేటప్పుడు, Valgrind కొన్ని క్లిష్టమైన చేస్తుంది

36
00:01:38,000 --> 00:01:41,000
మెమరీ తనిఖీలను కోసం executable ఆకృతీకరించుటకు jiggering,

37
00:01:41,000 --> 00:01:44,000
కాబట్టి పొందడానికి మరియు అమలు చెయ్యడానికి ఒక బిట్ పడుతుంది.

38
00:01:44,000 --> 00:01:48,000
కార్యక్రమం తర్వాత, చాలా చాలా నెమ్మదిగా, సాధారణంగా అమలు ఇది ఉంటుంది

39
00:01:48,000 --> 00:01:52,000
మరియు అది ముగుస్తుండగా, Valgrind దాని మెమరీ వాడుక యొక్క సారాంశం ముద్రిస్తుంది.

40
00:01:52,000 --> 00:01:58,000
అన్ని బాగా పోతే, అది ఈ వంటి ఏదో కనిపిస్తుంది:

41
00:01:58,000 --> 00:02:01,000
ఈ సందర్భంలో,. / Clean_program

42
00:02:01,000 --> 00:02:04,000
నేను అమలు చేయండి కార్యక్రమానికి మార్గం.

43
00:02:04,000 --> 00:02:06,000
మరియు ఈ కథలో వాదనలు తీసుకోదు అయితే,

44
00:02:06,000 --> 00:02:09,000
అది చేస్తే నేను మామూలుగానే ఆదేశం చివర కేవలం టాక్ వారిని చూసాను.

45
00:02:09,000 --> 00:02:12,000
క్లీన్ కార్యక్రమం నేను సృష్టించిన కేవలం ఒక వెర్రి చిన్న కార్యక్రమం

46
00:02:12,000 --> 00:02:15,000
ఆ, కుప్ప మీద ints ఒక బ్లాక్ స్థలాన్ని కేటాయించుకునే

47
00:02:15,000 --> 00:02:19,000
కొన్ని విలువలు వాటిలో లోపల పెట్టి, మరియు మొత్తం బ్లాక్ కాపాడి.

48
00:02:19,000 --> 00:02:23,000
ఈ మీరు లోపాలు మరియు లీకేజ్ లేదు, చిత్రీకరణ ఏమి ఉంది.

49
00:02:23,000 --> 00:02:27,000
>> మరో ముఖ్యమైన మెట్రిక్ కేటాయించింది బైట్లు మొత్తం సంఖ్య.

50
00:02:27,000 --> 00:02:32,000
మీ కేటాయింపులు మెగాబైట్ల లేదా ఎక్కువ లో ఉంటే ప్రోగ్రామ్ ఆధారంగా

51
00:02:32,000 --> 00:02:34,000
మీరు బహుశా ఏదో చేయుచున్నారు.

52
00:02:34,000 --> 00:02:37,000
మీరు అనవసరంగా నకిలీలను నిల్వ ఉంటాయి?

53
00:02:37,000 --> 00:02:40,000
ఇది స్టాక్ ఉపయోగించడానికి మంచిదని మీరు, నిల్వ కోసం కుప్ప ఉపయోగిస్తున్నారు?

54
00:02:40,000 --> 00:02:43,000
కాబట్టి, మెమరీ లోపాలు నిజంగా దుష్ట ఉంటుంది.

55
00:02:43,000 --> 00:02:46,000
ఎక్కువగా కనిపిస్తాయి వాటిని, అద్భుతమైన క్రాష్ కారణం

56
00:02:46,000 --> 00:02:49,000
కానీ అప్పటికీ కూడా ఇప్పటికీ ఏర్పడుతాయి కష్టంగా ఉంటుంది

57
00:02:49,000 --> 00:02:51,000
ఏ సరిగ్గా క్రాష్ దారితీసింది.

58
00:02:51,000 --> 00:02:54,000
ఒక మెమరీ లోపం మరింత insidiously, ఒక ప్రోగ్రామ్

59
00:02:54,000 --> 00:02:56,000
ఇప్పటికీ వారు కంపైల్ చేయవచ్చు

60
00:02:56,000 --> 00:02:58,000
మరియు ఇంకా సరిగ్గా పని ఉన్నాయి

61
00:02:58,000 --> 00:03:01,000
మీరు ఎక్కువ సమయం లక్కీ సాధించింది ఎందుకంటే.

62
00:03:01,000 --> 00:03:04,000
అనేక తర్వాత "విజయవంతమైన ఫలితాలను,"

63
00:03:04,000 --> 00:03:07,000
మీరు, క్రాష్ కంప్యూటర్ యొక్క ఒక అదృష్టమని ఉంటుంది ఉండవచ్చు

64
00:03:07,000 --> 00:03:10,000
కానీ కంప్యూటర్ తప్పు కాదు.

65
00:03:10,000 --> 00:03:13,000
>> Valgrind రన్నింగ్ మీరు కనిపించే మెమరీ లోపాల కారణం జాడ సహాయపడుతుంది

66
00:03:13,000 --> 00:03:18,000
అలాగే తప్పులు ప్రచ్ఛన్న కనుగొనడానికి మీరు కూడా ఇంకా గురించి తెలియదు.

67
00:03:18,000 --> 00:03:22,000
Valgrind ఒక సమస్య గుర్తించి ప్రతిసారి, అది గమనించిన గురించి సమాచారం అందిస్తుంది.

68
00:03:22,000 --> 00:03:24,000
ప్రతి అంశం చాలా సంక్షిప్తమైన ఉంది -

69
00:03:24,000 --> 00:03:27,000
ఆక్షేపణీయ బోధనా మూల లైన్, సమస్య ఏమిటి,

70
00:03:27,000 --> 00:03:30,000
పాల్గొన్న మెమరీ గురించి మరియు ఒక చిన్న సమాచారం -

71
00:03:30,000 --> 00:03:34,000
కానీ తరచుగా సరైన స్థలం మీ దృష్టిని దర్శకత్వం తగినంత సమాచారం.

72
00:03:34,000 --> 00:03:37,000
ఇక్కడ ఒక బగ్గీ కార్యక్రమం అమలు Valgrind యొక్క ఒక ఉదాహరణ

73
00:03:37,000 --> 00:03:40,000
ఆ కుప్ప మెమరీ చెల్లని రీడ్ చేస్తుంది.

74
00:03:40,000 --> 00:03:49,000
మేము సంకలనంలో లోపాలు లేదా హెచ్చరికలు చూడండి.

75
00:03:49,000 --> 00:03:53,000
UH-OH, లోపం సారాంశం రెండు లోపాలు లేవని తెలుస్తుంది -

76
00:03:53,000 --> 00:03:56,000
పరిమాణం 4 రెండు చెల్లని పుస్తకాలు - బైట్లు, ఆ ఉంటుంది.

77
00:03:56,000 --> 00:04:01,000
రెండు చెడు, invalid_read.c యొక్క ప్రధాన విధి జరిగింది చదువుతుంది

78
00:04:01,000 --> 00:04:04,000
లైన్ 16 మరియు 19 లైన్ లో రెండవ మొదటి.

79
00:04:04,000 --> 00:04:06,000
యొక్క కోడ్ చూద్దాం.

80
00:04:06,000 --> 00:04:11,000
Printf మా మెమరీ బ్లాక్ ముగింపులో గత ఒక Int చదవటానికి ప్రయత్నిస్తుంది మొదటి కాల్ కనిపిస్తోంది.

81
00:04:11,000 --> 00:04:13,000
మేము Valgrind యొక్క అవుట్పుట్ తిరిగి చూడాలని, ఉంటే

82
00:04:13,000 --> 00:04:16,000
మేము Valgrind సరిగ్గా మాకు చెప్పారు చూసాము.

83
00:04:16,000 --> 00:04:19,000
మేము చదవడానికి ప్రయత్నిస్తున్న చిరునామా 0 చి ప్రారంభమవుతుంది

84
00:04:19,000 --> 00:04:22,000
- పరిమాణం 16 బైట్లు యొక్క బ్లాక్ ముగింపులో గత

85
00:04:22,000 --> 00:04:25,000
మేము కేటాయించింది నాలుగు 32-bit ints.

86
00:04:25,000 --> 00:04:29,000
అంటే, మేము చదవడానికి ప్రయత్నిస్తున్న చిరునామా, కుడి మా బ్లాక్ చివరిలో ప్రారంభమవుతుంది

87
00:04:29,000 --> 00:04:32,000
మేము మా చెడ్డ printf కాల్ చూడండి కేవలం.

88
00:04:32,000 --> 00:04:36,000
ఇప్పుడు, చెల్లని పుస్తకాలు, ఒక ఒప్పందం యొక్క పెద్ద వంటి కనిపించడం ఉండవచ్చు

89
00:04:36,000 --> 00:04:39,000
కానీ మీరు మీ ప్రోగ్రామ్ యొక్క ప్రవాహ నియంత్రణ డేటా ను ఉపయోగిస్తున్నట్లయితే -

90
00:04:39,000 --> 00:04:42,000
ఉదాహరణకు, ఒక భాగంగా ఉంటే ప్రకటన లేదా లూప్ -

91
00:04:42,000 --> 00:04:45,000
అప్పుడు విషయాలు నిశ్శబ్దంగా చెడు వెళ్ళవచ్చు.

92
00:04:45,000 --> 00:04:47,000
నేను invalid_read అమలు ఎలా చూడండి

93
00:04:47,000 --> 00:04:50,000
మరియు సాధారణ యొక్క ఏమీ అవుట్ జరుగుతుంది.

94
00:04:50,000 --> 00:04:52,000
స్కేరీ, హుహ్?

95
00:04:52,000 --> 00:04:56,000
>> ఇప్పుడు, యొక్క మీ కోడ్ లో ఎదుర్కొనే కొన్ని లోపాలు కొన్ని రకాల చూద్దాం

96
00:04:56,000 --> 00:04:59,000
మరియు మేము వాటిని గుర్తించి ఎలా Valgrind చూస్తారు.

97
00:04:59,000 --> 00:05:01,000
మేము, ఒక invalid_read ఒక ఉదాహరణ చూసిన

98
00:05:01,000 --> 00:05:04,000
కాబట్టి ఇప్పుడు యొక్క ఒక invalid_write తనిఖీ అనుమతిస్తుంది.

99
00:05:04,000 --> 00:05:09,000
మళ్లీ, సంకలనంలో లోపాలు లేదా హెచ్చరికలు.

100
00:05:09,000 --> 00:05:12,000
సరే, Valgrind ఈ కార్యక్రమంలో రెండు లోపాలు లేవని తెలుస్తుంది -

101
00:05:12,000 --> 00:05:15,000
మరియు invalid_write మరియు ఒక invalid_read.

102
00:05:15,000 --> 00:05:18,000
యొక్క ఈ కోడ్ తనిఖీ లెట్.

103
00:05:18,000 --> 00:05:21,000
మేము strlen ప్లస్ ఒక బగ్ యొక్క ఒక ఉదాహరణ వచ్చింది అనిపిస్తున్నది.

104
00:05:21,000 --> 00:05:24,000
కోడ్ malloc స్థలం అదనపు బైట్ కాదు

105
00:05:24,000 --> 00:05:26,000
/ 0 పాత్ర కోసం,

106
00:05:26,000 --> 00:05:30,000
కాబట్టి STR కాపీ ssubstrlen వద్ద వ్రాయటానికి వెళ్ళినప్పుడు అతను "cs50 రాళ్ళు!"

107
00:05:30,000 --> 00:05:33,000
అది మా బ్లాక్ ముగింపులో గత 1 బైట్ రాశారు.

108
00:05:33,000 --> 00:05:36,000
మేము printf మా కాల్ చేసినపుడు invalid_read వస్తుంది.

109
00:05:36,000 --> 00:05:40,000
అది / 0 పాత్ర చదువునప్పుడు Printf చెల్లని మెమరీ reading ముగుస్తుంది

110
00:05:40,000 --> 00:05:43,000
ఈ E స్ట్రింగ్ చివరిలో ఉంది గా ముద్రణ ఉంది.

111
00:05:43,000 --> 00:05:45,000
కానీ ఈ ఎవరూ Valgrind తప్పించుకున్నారు.

112
00:05:45,000 --> 00:05:48,000
మేము STR కాపీ భాగంగా ఇది invalid_write క్యాచ్ ఆ చూడండి

113
00:05:48,000 --> 00:05:51,000
ప్రధాన రేఖ 11 న, మరియు invalid_read printf భాగం.

114
00:05:51,000 --> 00:05:54,000
Valgrind, రాక్ ఆన్.

115
00:05:54,000 --> 00:05:57,000
మళ్ళీ, ఈ పెద్ద ఒప్పందంలో వంటి కనిపించడం ఉండవచ్చు.

116
00:05:57,000 --> 00:06:00,000
మేము Valgrind వెలుపల మీద మరియు ఈ కార్యక్రమం అమలు చెయ్యవచ్చు

117
00:06:00,000 --> 00:06:03,000
మరియు ఏ లోపం లక్షణాలు చూడండి లేదు.

118
00:06:03,000 --> 00:06:06,000
>> అయితే, చూడటానికి ఈ స్వల్ప వ్యత్యాసం చూడండి యొక్క తెలపండి

119
00:06:06,000 --> 00:06:09,000
ఎలా వస్తువులు నిజంగా చెడు పొందవచ్చు.

120
00:06:09,000 --> 00:06:14,000
కాబట్టి, మంజూరు, మేము ఈ కోడ్ లో ఒక బిట్ కంటే ఎక్కువ విషయాలు దుర్భాషలాడటం ఉంటాయి.

121
00:06:14,000 --> 00:06:17,000
మేము రెండు రెమ్మలు కోసం కుప్ప మీద స్థలాన్ని కేటాయించడం చేస్తున్నారు

122
00:06:17,000 --> 00:06:19,000
cs50 రాళ్ళు పొడవు,

123
00:06:19,000 --> 00:06:22,000
ఈ సమయంలో, / 0 పాత్ర గుర్తు.

124
00:06:22,000 --> 00:06:25,000
కానీ మేము మెమరీ బ్లాక్ లోకి సూపర్ దీర్ఘ స్ట్రింగ్ విసరాలి

125
00:06:25,000 --> 00:06:27,000
ఆ S కు సూచిస్తుంది.

126
00:06:27,000 --> 00:06:30,000
ఏ ప్రభావం మెమరీ బ్లాక్ లో కలిగి కు T పాయింట్లు?

127
00:06:30,000 --> 00:06:34,000
Well, ఉంటే S కేవలం ప్రక్కన ఉండే స్మృతికి T పాయింట్లు,

128
00:06:34,000 --> 00:06:37,000
దీనిని తరువాత వచ్చే,

129
00:06:37,000 --> 00:06:39,000
అప్పుడు మేము T. భాగంగా రాసి ఉండవచ్చు

130
00:06:39,000 --> 00:06:41,000
యొక్క ఈ కోడ్ అమలు అయ్యేలా అనుమతించండి.

131
00:06:41,000 --> 00:06:43,000
ఏమి వద్ద చూడండి.

132
00:06:43,000 --> 00:06:47,000
మేము మా కుప్ప బ్లాక్స్ రెండు నిల్వ తీగలను సరిగ్గా ముద్రించిన కనిపించింది.

133
00:06:47,000 --> 00:06:49,000
నథింగ్ అన్ని తప్పు ఉంది.

134
00:06:49,000 --> 00:06:52,000
అయితే, యొక్క మా కోడ్ తిరిగి వీడలేదు మరియు

135
00:06:52,000 --> 00:06:55,000
మేము cs50 రాళ్ళు కాపీ పేరు లైన్ అవ్ట్ వ్యాఖ్య

136
00:06:55,000 --> 00:06:59,000
రెండవ మెమరీ బ్లాక్ లోకి, t ద్వారా చూపారు.

137
00:06:59,000 --> 00:07:02,000
ఇప్పుడు మేము ఈ కోడ్ అమలు మేము చేయాలి

138
00:07:02,000 --> 00:07:06,000
మొదటి మెమరీ బ్లాక్ విషయాలు ముద్రించాలా చూడండి.

139
00:07:06,000 --> 00:07:09,000
అయ్యో, మేము STR కాపీ కాదు అయినప్పటికీ

140
00:07:09,000 --> 00:07:12,000
రెండవ కుప్ప బ్లాక్ లోకి ఏ అక్షరాలు, ఒక, T ద్వారా చూపారు

141
00:07:12,000 --> 00:07:15,000
మేము ఒక ప్రింట్ అవుట్.

142
00:07:15,000 --> 00:07:18,000
నిజానికి, స్ట్రింగ్ మేము మా మొదటి బ్లాక్ నింపుతారు

143
00:07:18,000 --> 00:07:21,000
మొదటి బ్లాక్ మరియు రెండవ బ్లాక్ లోకి, దండయాత్ర

144
00:07:21,000 --> 00:07:23,000
ప్రతిదీ సాధారణ కనిపిస్తుంది అయింది.

145
00:07:23,000 --> 00:07:26,000
Valgrind, అయితే, మాకు నిజమైన కథ చెబుతుంది.

146
00:07:26,000 --> 00:07:28,000
అక్కడ మేము వెళ్ళి.

147
00:07:28,000 --> 00:07:32,000
ఆ చెల్లని అన్ని చదివి మరియు వ్రాస్తాడు.

148
00:07:32,000 --> 00:07:36,000
>> యొక్క లోపం మరొక రకమైన ఉదాహరణగా చూద్దాం.

149
00:07:36,000 --> 00:07:39,000
ఇక్కడ మేము కాకుండా దురదృష్టకరమైన ఏదో ఒకటి.

150
00:07:39,000 --> 00:07:41,000
మేము, కుప్ప మీద ఒక పూర్ణాంకానికి స్థలాన్ని పట్టుకొను

151
00:07:41,000 --> 00:07:45,000
p - - ఆ స్థలం సూచించడానికి మరియు మేము ఒక పూర్ణాంకానికి పాయింటర్ ప్రారంభించడం.

152
00:07:45,000 --> 00:07:48,000
అయితే, మా పాయింటర్ initialized ఉన్నప్పుడు,

153
00:07:48,000 --> 00:07:52,000
అది సూచించే చేసే డేటా కేవలం కుప్ప ఆ భాగంలో ఏ వ్యర్థ ఉంది.

154
00:07:52,000 --> 00:07:55,000
కాబట్టి మేము Int నేను ఆ డేటాను లోడ్ చేసినప్పుడు,

155
00:07:55,000 --> 00:07:57,000
మేము సాంకేతికంగా, నేను ప్రారంభించడం

156
00:07:57,000 --> 00:08:00,000
కానీ మేము వ్యర్థ డేటా తో అలా.

157
00:08:00,000 --> 00:08:03,000
కాల్ చక్కని డీబగ్గింగ్ స్థూల ఇది బలపరచటానికి

158
00:08:03,000 --> 00:08:06,000
సముచితంగా అనే నొక్కి లైబ్రరీ లో నిర్వచించిన,

159
00:08:06,000 --> 00:08:09,000
గర్భస్రావము దాని పరీక్ష పరిస్థితి విఫలమైతే కార్యక్రమాన్ని రెడీ.

160
00:08:09,000 --> 00:08:11,000
నేను 0 లేదు అని చెప్పాడు ఉంది.

161
00:08:11,000 --> 00:08:14,000
కుప్ప స్పేస్ లో ఏం ఆధారపడి,, p చూపారు

162
00:08:14,000 --> 00:08:18,000
ఈ కార్యక్రమం కొన్నిసార్లు పని మరియు ఇతర సమయాల్లో వైఫల్యం చెందవచ్చు.

163
00:08:18,000 --> 00:08:20,000
ఇది పనిచేస్తుంది ఉంటే, మేము లక్కీ చేస్తున్నారు.

164
00:08:20,000 --> 00:08:24,000
కంపైలర్ ఈ లోపం క్యాచ్, కానీ ఖచ్చితంగా విల్ Valgrind లేదు.

165
00:08:24,000 --> 00:08:28,000
అక్కడ మేము ఆ వ్యర్థ డేటా మా ఉపయోగం ద్వారా సంక్రమించిన లోపం చూడండి.

166
00:08:28,000 --> 00:08:32,000
>> మీరు కుప్ప మెమరీని కేటాయించాల్సిన కానీ deallocate లేదా ఇది ఉచితం వాడవద్దు,

167
00:08:32,000 --> 00:08:34,000
ఒక లీక్ అంటారు.

168
00:08:34,000 --> 00:08:37,000
నిష్క్రమిస్తుంది నడుస్తుంది మరియు వెంటనే ఒక చిన్న, తక్కువ కాలం కార్యక్రమం కోసం,

169
00:08:37,000 --> 00:08:39,000
లీకేజ్ బాగా హానిచేయని ఉంటాయి,

170
00:08:39,000 --> 00:08:42,000
కానీ పెద్ద పరిమాణం మరియు / లేదా దీర్ఘాయువు ఒక ప్రాజెక్ట్ కోసం,

171
00:08:42,000 --> 00:08:46,000
ఒక చిన్న లీక్ ప్రధాన దానిని సమ్మేళనం చేయవచ్చు.

172
00:08:46,000 --> 00:08:49,000
CS50, మీరు నువ్వు అనుకుంటున్నావా

173
00:08:49,000 --> 00:08:51,000
మీరు కేటాయించాలని ఆ కుప్ప మెమరీ అన్ని ఉండండి యొక్క శ్రద్ధ వహించడానికి,

174
00:08:51,000 --> 00:08:54,000
మేము మీరు మాన్యువల్ ప్రాసెస్ సరిగా నిర్వహించడానికి నైపుణ్యాలు నిర్మించడానికి కావలసిన నుండి

175
00:08:54,000 --> 00:08:56,000
C. అవసరమైన

176
00:08:56,000 --> 00:08:59,000
అలా చెయ్యడానికి, మీ ప్రోగ్రామ్ ఒక ఖచ్చితమైన ఉండాలి

177
00:08:59,000 --> 00:09:03,000
malloc మరియు ఉచిత కాల్స్ మధ్య ఒక దానితో ఒకటిని.

178
00:09:03,000 --> 00:09:06,000
అదృష్టవశాత్తూ, Valgrind చాలా మెమరీ లీకేజ్ మీకు సహాయం చేస్తుంది.

179
00:09:06,000 --> 00:09:09,000
ఇక్కడ leak.c అనే కారుతున్న కార్యక్రమం అని కేటాయించుకునే

180
00:09:09,000 --> 00:09:13,000
కుప్ప మీద స్పేస్, అది వ్రాస్తాడు, కానీ ఇది ఉచితం లేదు.

181
00:09:13,000 --> 00:09:16,000
మేము, చేయండి మరియు Valgrind కింద అమలు తో కంపైల్

182
00:09:16,000 --> 00:09:18,000
మరియు మేము చూడండి, మేము మెమరీ లోపాలు లేవు, ఆ

183
00:09:18,000 --> 00:09:20,000
మేము ఒక లీక్ ఉన్నాయి.

184
00:09:20,000 --> 00:09:23,000
ఖచ్చితంగా కోల్పోయింది 16 బైట్లు ఉన్నాయి

185
00:09:23,000 --> 00:09:27,000
కార్యక్రమం ముగిసింది ఆ స్మృతికి పాయింటర్ పరిధిని కాదని అర్థం.

186
00:09:27,000 --> 00:09:30,000
ఇప్పుడు, Valgrind, మాకు లీక్ గురించి ఒక టన్ను ఇవ్వదు

187
00:09:30,000 --> 00:09:35,000
కానీ మేము దాని నివేదిక దిగువ దిశగా డౌన్ ఇచ్చే ఈ చిన్న నోట్ అనుసరించండి ఉంటే

188
00:09:35,000 --> 00:09:38,000
తో తిరిగి కు - లీక్ తనిఖీ = పూర్తి

189
00:09:38,000 --> 00:09:41,000
వెల్లడైంది మెమరీ పూర్తి వివరాలను చూడడానికి,

190
00:09:41,000 --> 00:09:44,000
మేము మరింత సమాచారం పొందుతారు.

191
00:09:44,000 --> 00:09:46,000
ఇప్పుడు, కుప్ప సారాంశంలో,

192
00:09:46,000 --> 00:09:50,000
ఓడిపోయిన మెమరీ ప్రారంభంలో కేటాయించారు పేరు Valgrind మాకు చెబుతుంది.

193
00:09:50,000 --> 00:09:52,000
మేము సోర్స్ కోడ్ చూస్తూ తెలిసిన వలె,

194
00:09:52,000 --> 00:09:55,000
Valgrind మేము మెమరీ వెల్లడైంది మాకు సమాచారం

195
00:09:55,000 --> 00:09:58,000
leak.c యొక్క పంక్తి 8 న malloc ఒక కాల్ తో కేటాయించింది

196
00:09:58,000 --> 00:10:00,000
ప్రధాన ఫంక్షన్.

197
00:10:00,000 --> 00:10:02,000
ప్రెట్టీ నిఫ్టీ.

198
00:10:02,000 --> 00:10:04,000
>> Valgrind ఈ పదాలను ఉపయోగించి స్రావాలు వర్గీకరిస్తుంది:

199
00:10:04,000 --> 00:10:07,000
ఖచ్చితంగా కోల్పోయింది - ఈ కుప్ప కేటాయించిన మెమొరీ ఉంటుంది

200
00:10:07,000 --> 00:10:10,000
కార్యక్రమం ఇకపై ఒక పాయింటర్ కలిగి.

201
00:10:10,000 --> 00:10:14,000
Valgrind మీరు ఒకసారి పాయింటర్ కానీ నుండీ యొక్క ట్రాక్ కోల్పోయారు తెలుసు.

202
00:10:14,000 --> 00:10:17,000
ఈ మెమరీ ఖచ్చితంగా వెల్లడైంది ఉంది.

203
00:10:17,000 --> 00:10:20,000
పరోక్షంగా కోల్పోయింది - ఈ కుప్ప కేటాయించిన మెమొరీ ఉంటుంది

204
00:10:20,000 --> 00:10:24,000
అది మాత్రమే గమనికలు కూడా పోతాయి కు.

205
00:10:24,000 --> 00:10:27,000
ఉదాహరణకు, మీరు ఒక లింక్ జాబితా యొక్క మొదటి నోడ్ మీ పాయింటర్ కోల్పోతే,

206
00:10:27,000 --> 00:10:30,000
అప్పుడు మొదటి నోడ్ కూడా ఖచ్చితంగా, కోల్పోయిన ఉంటుంది

207
00:10:30,000 --> 00:10:34,000
ఏ తదుపరి నోడ్స్ పరోక్షంగా కోల్పోయింది అయితే.

208
00:10:34,000 --> 00:10:37,000
బహుశా కోల్పోయిన - ఈ కుప్ప కేటాయించిన మెమొరీ ఉంటుంది

209
00:10:37,000 --> 00:10:41,000
ఇది వరకు Valgrind ఒక పాయింటర్ లేదా అక్కడ అనే ఖచ్చితంగా కాదు.

210
00:10:41,000 --> 00:10:44,000
ఇప్పటికీ అందుబాటులో కుప్ప కేటాయించిన మెమొరీ ఉంటుంది

211
00:10:44,000 --> 00:10:47,000
కార్యక్రమం ఇప్పటికీ నిష్క్రమించండి ఒక పాయింటర్ కలిగి కు,

212
00:10:47,000 --> 00:10:50,000
ఇది సాధారణంగా అంటే అది ఒక ప్రపంచ వేరియబుల్ పాయింట్లు.

213
00:10:50,000 --> 00:10:53,000
ఈ స్రావాలు తనిఖీ, మీరు కూడా ఎంపిక ఉన్నాయి ఉంటుంది

214
00:10:53,000 --> 00:10:55,000
- ఇంకా అందుబాటులో = అవును

215
00:10:55,000 --> 00:10:58,000
Valgrind మీ ఆవాహన లో.

216
00:10:58,000 --> 00:11:01,000
>> ఈ వివిధ సందర్భాలలో, వాటిని శుభ్రపరిచే వివిధ వ్యూహాలు అవసరపడవచ్చు

217
00:11:01,000 --> 00:11:05,000
కానీ స్రావాలు తొలగించాలి.

218
00:11:05,000 --> 00:11:08,000
దురదృష్టవశాత్తు, స్రావాలు ఫిక్సింగ్, చేయడానికి కష్టం

219
00:11:08,000 --> 00:11:11,000
ఉచిత సరికాదు కాల్స్ మీ ప్రోగ్రామ్ పేల్చివేయడానికి ఎందుకంటే.

220
00:11:11,000 --> 00:11:14,000
ఉదాహరణకు, invalid_free.c విషయంలో చూస్తే,

221
00:11:14,000 --> 00:11:18,000
మేము చెడ్డ జ్ఞాపకం deallocation ఒక ఉదాహరణ చూడండి.

222
00:11:18,000 --> 00:11:21,000
మొత్తం బ్లాక్ విముక్తికై ఒక కాల్ ఉండాలి

223
00:11:21,000 --> 00:11:24,000
మెమరీ, int_block ద్వారా చూపారు

224
00:11:24,000 --> 00:11:27,000
బదులుగా ప్రతి Int పరిమాణం విభాగం విడిపించేందుకు ప్రయత్నంలో మారింది

225
00:11:27,000 --> 00:11:29,000
వ్యక్తిగతంగా మెమరీ.

226
00:11:29,000 --> 00:11:32,000
ఈ విపత్తుల విఫలమౌతుంది.

227
00:11:32,000 --> 00:11:34,000
బూమ్! ఏ లోపం.

228
00:11:34,000 --> 00:11:36,000
ఈ ఖచ్చితంగా మంచి కాదు.

229
00:11:36,000 --> 00:11:39,000
మీరు ఈ రకమైన ఇరుక్కుపోయి ఉన్నాం, అయితే, మరియు మీరు, ఇక్కడ చూడవలసిన తెలియకపోతే

230
00:11:39,000 --> 00:11:41,000
మీ కొత్త స్నేహితుడి తిరిగి వస్తాయి.

231
00:11:41,000 --> 00:11:44,000
మీరు ఊహించిన - Valgrind.

232
00:11:44,000 --> 00:11:47,000
Valgrind, వంటి ఎల్లప్పుడూ అప్, వేటి తెలుసు.

233
00:11:47,000 --> 00:11:50,000
alloc మరియు ఉచిత గణనలు మ్యాచ్ కాకపోవడం.

234
00:11:50,000 --> 00:11:52,000
మేము 1 alloc మరియు 4 ఫ్రీస్ పొందారు.

235
00:11:52,000 --> 00:11:55,000
మరియు Valgrind కూడా మొదటి చెడు ఉచిత కాల్ మాకు చెబుతుంది -

236
00:11:55,000 --> 00:11:58,000
blowup కారణమైన ఒక - నుండి వచ్చినది -

237
00:11:58,000 --> 00:12:00,000
లైన్ 16.

238
00:12:00,000 --> 00:12:03,000
మీరు చూడండి వంటి, ఉచిత ప్రతికూల కాల్స్, నిజంగా తప్పుగా ఉన్నాయి

239
00:12:03,000 --> 00:12:05,000
కాబట్టి మేము మీ ప్రోగ్రామ్ లీక్ తెలియజేసినందుకు సిఫార్సు

240
00:12:05,000 --> 00:12:08,000
మీరు కార్యాచరణ సరైన పొందడానికి పని చేస్తున్న సమయంలో.

241
00:12:08,000 --> 00:12:12,000
మీ ప్రోగ్రామ్ సరిగా పని మాత్రమే తర్వాత దోషాలను వెతుకుతున్న ప్రారంభం,

242
00:12:12,000 --> 00:12:14,000
ఇతర లోపాలు లేకుండా.

243
00:12:14,000 --> 00:12:16,000
>> మరియు మేము ఈ వీడియో కోసం మేం అంతే.

244
00:12:16,000 --> 00:12:18,000
ఇప్పుడు మీరు కోసం వేచి ఉన్నాయో?

245
00:12:18,000 --> 00:12:21,000
ప్రస్తుతం మీ కార్యక్రమాల మీద Valgrind అమలు వెళ్ళండి.

246
00:12:21,000 --> 00:12:25,000
నా పేరు నేట్ Hardison ఉంది. ఈ CS50 ఉంది. [CS50.TV]