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
உங்கள். கேட்ச் அல்லது. ம மூல குறியீடு கோப்புகள்,

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 கூடிய நிலையான திட்டம் கட்டளை prefixing போன்ற எளிய,

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
நினைவக காசோலைகளுக்கு இயங்கக்கூடிய கட்டமைக்க 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
ஒரு நினைவக பிழை இன்னும் மெல்ல, ஒரு திட்டம்

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
பத்திதான் ஓ, பிழை சுருக்கம் இரண்டு பிழைகள் உள்ளன என்று -

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 நம் நினைவகம் தொகுதி முடிவு கடந்த ஒரு எண்ணாக வாசிக்க முயற்சிக்கும் முதல் அழைப்பு தெரிகிறது.

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 பிட் 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 தவறான நினைவக படித்து நிறைவடைகிறது

110
00:05:40,000 --> 00:05:43,000
இந்த மின் சரம் முடிவில் தெரிகிறது அதை அச்சிடும் தான்.

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
என்று எஸ் சுட்டி காட்டியது.

126
00:06:27,000 --> 00:06:30,000
என்ன விளைவு நினைவக தொகுதி மீது வேண்டும் என்று அந்த டி புள்ளிகள்?

127
00:06:30,000 --> 00:06:34,000
நன்றாக, S வெறும் அருகில் என்று நினைவக டி புள்ளிகள்,

128
00:06:34,000 --> 00:06:37,000
அதை பிறகு வரும்,

129
00:06:37,000 --> 00:06:39,000
நாம் டி பகுதியாக மீது எழுதப்பட்ட

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
இரண்டாவது குவியல் தொகுதி எந்த கதாபாத்திரங்கள், ஒரு, டீ சுட்டிக்காட்டினார்

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
முதல் தொகுதி மற்றும் இரண்டாவது தொகுதி வந்து, overran

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
ப - - அந்த இடத்தில் சுட்டிக்காட்ட நாம் ஒரு முழு எண்ணாக சுட்டிக்காட்டி துவக்க.

152
00:07:45,000 --> 00:07:48,000
எனினும், எங்கள் சுட்டிக்காட்டி துவக்கப்படும் போது,

153
00:07:48,000 --> 00:07:52,000
அதை சுட்டி காட்டும் என்று தரவு தான் குவியல் என்று பகுதியில் என்ன குப்பை உள்ளது.

154
00:07:52,000 --> 00:07:55,000
நாம் எண்ணாக நான் அந்த தரவு ஏற்ற போது,

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
குவியல் இடைவெளி இருந்தது என்பதை பொறுத்து,, ப சுட்டிக்காட்டினார்

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
சி தேவைப்படுகிறது

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
Pretty நாகரீகமான.

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
நாம் மோசமான நினைவக ஒதுக்கீடு விடுத்தல் ஒரு உதாரணம் பார்க்கலாம்.

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
அதற்கு பதிலாக ஒவ்வொரு எண்ணாக அளவிலான பகுதியை விடுவிக்க முயற்சி மாறிவிட்டது

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]