ಲೇಖನದ ವಸ್ತುವನ್ನು ನನ್ನಿಂದ ತೆಗೆದುಕೊಳ್ಳಲಾಗಿದೆ .
ಕೊನೆಯಲ್ಲಿ , ಟಿಕ್ಕರ್ ಲೋಡ್ ಅಂದಾಜಿನ ಸಮಸ್ಯೆಯನ್ನು ಮತ್ತು ಮೀಡಿಯಾ ಸ್ಟ್ರೀಮರ್‌ನಲ್ಲಿ ಅತಿಯಾದ ಕಂಪ್ಯೂಟಿಂಗ್ ಲೋಡ್ ಅನ್ನು ಎದುರಿಸುವ ಮಾರ್ಗಗಳನ್ನು ಪರಿಗಣಿಸುವುದಾಗಿ ನಾನು ಭರವಸೆ ನೀಡಿದ್ದೇನೆ. ಆದರೆ ಡೇಟಾ ಚಲನೆಗೆ ಸಂಬಂಧಿಸಿದ ಡೀಬಗ್ ಮಾಡುವ ಕ್ರಾಫ್ಟ್ ಫಿಲ್ಟರ್‌ಗಳ ಸಮಸ್ಯೆಗಳನ್ನು ಒಳಗೊಳ್ಳಲು ಇದು ಹೆಚ್ಚು ತಾರ್ಕಿಕವಾಗಿದೆ ಎಂದು ನಾನು ನಿರ್ಧರಿಸಿದೆ ಮತ್ತು ನಂತರ ಮಾತ್ರ ಕಾರ್ಯಕ್ಷಮತೆ ಆಪ್ಟಿಮೈಸೇಶನ್ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಗಣಿಸಿ.
ಕ್ರಾಫ್ಟ್ ಫಿಲ್ಟರ್‌ಗಳನ್ನು ಡೀಬಗ್ ಮಾಡಲಾಗುತ್ತಿದೆ
ಹಿಂದಿನ ಲೇಖನದಲ್ಲಿ ಮೀಡಿಯಾ ಸ್ಟ್ರೀಮರ್‌ನಲ್ಲಿ ಡೇಟಾ ಚಲನೆಯ ಕಾರ್ಯವಿಧಾನವನ್ನು ನಾವು ಪರಿಶೀಲಿಸಿದ ನಂತರ, ಅದರಲ್ಲಿ ಅಡಗಿರುವ ಅಪಾಯಗಳ ಬಗ್ಗೆ ಮಾತನಾಡುವುದು ತಾರ್ಕಿಕವಾಗಿರುತ್ತದೆ. "ಡೇಟಾ ಫ್ಲೋ" ತತ್ವದ ಒಂದು ವೈಶಿಷ್ಟ್ಯವೆಂದರೆ ರಾಶಿಯಿಂದ ಮೆಮೊರಿಯ ಹಂಚಿಕೆಯು ಡೇಟಾ ಹರಿವಿನ ಮೂಲಗಳಲ್ಲಿರುವ ಫಿಲ್ಟರ್‌ಗಳಲ್ಲಿ ಸಂಭವಿಸುತ್ತದೆ ಮತ್ತು ಹರಿವಿನ ಹಾದಿಯ ಕೊನೆಯಲ್ಲಿ ಇರುವ ಫಿಲ್ಟರ್‌ಗಳು ಈಗಾಗಲೇ ರಿಟರ್ನ್‌ನೊಂದಿಗೆ ಮೆಮೊರಿಯನ್ನು ನಿಯೋಜಿಸುತ್ತವೆ. ರಾಶಿಗೆ. ಇದರ ಜೊತೆಗೆ, ಹೊಸ ಡೇಟಾದ ಸೃಷ್ಟಿ ಮತ್ತು ಅವುಗಳ ವಿನಾಶವು ಮಧ್ಯಂತರ ಬಿಂದುಗಳಲ್ಲಿ ಎಲ್ಲೋ ಸಂಭವಿಸಬಹುದು. ಸಾಮಾನ್ಯವಾಗಿ, ಡೇಟಾ ಬ್ಲಾಕ್ ಅನ್ನು ರಚಿಸಿದ ಫಿಲ್ಟರ್ ಹೊರತುಪಡಿಸಿ ಮೆಮೊರಿಯ ಬಿಡುಗಡೆಯನ್ನು ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ.
ಮೆಮೊರಿಯ ಪಾರದರ್ಶಕ ಮೇಲ್ವಿಚಾರಣೆಯ ದೃಷ್ಟಿಕೋನದಿಂದ, ಫಿಲ್ಟರ್, ಇನ್‌ಪುಟ್ ಬ್ಲಾಕ್ ಅನ್ನು ಸ್ವೀಕರಿಸುವಾಗ, ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಿದ ನಂತರ, ಮೆಮೊರಿಯನ್ನು ಮುಕ್ತಗೊಳಿಸಿದ ನಂತರ ಅದನ್ನು ತಕ್ಷಣವೇ ನಾಶಮಾಡಲು ಮತ್ತು ಔಟ್ಪುಟ್ನಲ್ಲಿ ಔಟ್‌ಪುಟ್ ಡೇಟಾದೊಂದಿಗೆ ಹೊಸದಾಗಿ ರಚಿಸಲಾದ ಬ್ಲಾಕ್ ಅನ್ನು ಹಾಕಲು ಇದು ಸಮಂಜಸವಾಗಿದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಫಿಲ್ಟರ್‌ನಲ್ಲಿನ ಮೆಮೊರಿ ಸೋರಿಕೆಯನ್ನು ಸುಲಭವಾಗಿ ಪತ್ತೆಹಚ್ಚಬಹುದು - ವಿಶ್ಲೇಷಕವು ಫಿಲ್ಟರ್‌ನಲ್ಲಿ ಸೋರಿಕೆಯನ್ನು ಪತ್ತೆಮಾಡಿದರೆ, ನಂತರ ಅದನ್ನು ಅನುಸರಿಸುವ ಫಿಲ್ಟರ್ ಒಳಬರುವ ಬ್ಲಾಕ್‌ಗಳನ್ನು ಸರಿಯಾಗಿ ನಾಶಪಡಿಸುವುದಿಲ್ಲ ಮತ್ತು ಅದರಲ್ಲಿ ದೋಷವಿದೆ. ಆದರೆ ಹೆಚ್ಚಿನ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ನಿರ್ವಹಿಸುವ ದೃಷ್ಟಿಕೋನದಿಂದ, ಡೇಟಾ ಬ್ಲಾಕ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ಈ ವಿಧಾನವು ಉತ್ಪಾದಕವಲ್ಲ - ಇದು ಯಾವುದೇ ಉಪಯುಕ್ತ ನಿಷ್ಕಾಸವಿಲ್ಲದೆ ಡೇಟಾ ಬ್ಲಾಕ್‌ಗಳಿಗೆ / ಉಚಿತ ಮೆಮೊರಿಯನ್ನು ನಿಯೋಜಿಸಲು ಹೆಚ್ಚಿನ ಸಂಖ್ಯೆಯ ಕಾರ್ಯಾಚರಣೆಗಳಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ.
ಈ ಕಾರಣಕ್ಕಾಗಿ, ಮಾಧ್ಯಮ ಸ್ಟ್ರೀಮರ್ ಫಿಲ್ಟರ್‌ಗಳು, ಡೇಟಾ ಸಂಸ್ಕರಣೆಯನ್ನು ನಿಧಾನಗೊಳಿಸದಿರಲು, ಸಂದೇಶಗಳನ್ನು ನಕಲಿಸುವಾಗ ಬೆಳಕಿನ ಪ್ರತಿಗಳನ್ನು ರಚಿಸುವ ಕಾರ್ಯಗಳನ್ನು ಬಳಸುತ್ತವೆ (ನಾವು ಹಿಂದಿನ ಲೇಖನದಲ್ಲಿ ಅವುಗಳ ಬಗ್ಗೆ ಮಾತನಾಡಿದ್ದೇವೆ). ಈ ಕಾರ್ಯಗಳು ನಕಲು ಮಾಡಿದ "ಹಳೆಯ" ಸಂದೇಶದಿಂದ ಡೇಟಾ ಬ್ಲಾಕ್ ಅನ್ನು "ಲಗತ್ತಿಸುವ" ಮೂಲಕ ಸಂದೇಶದ ಹೆಡರ್‌ನ ಹೊಸ ನಕಲನ್ನು ಮಾತ್ರ ರಚಿಸುತ್ತವೆ. ಪರಿಣಾಮವಾಗಿ, ಒಂದು ಡೇಟಾ ಬ್ಲಾಕ್‌ಗೆ ಎರಡು ಹೆಡರ್‌ಗಳನ್ನು ಲಗತ್ತಿಸಲಾಗಿದೆ ಮತ್ತು ಡೇಟಾ ಬ್ಲಾಕ್‌ನಲ್ಲಿನ ಉಲ್ಲೇಖ ಕೌಂಟರ್ ಅನ್ನು ಹೆಚ್ಚಿಸಲಾಗಿದೆ. ಆದರೆ ಇದು ಎರಡು ಸಂದೇಶಗಳಂತೆ ಕಾಣಿಸುತ್ತದೆ. ಅಂತಹ "ಸಾರ್ವಜನಿಕ" ಡೇಟಾ ಬ್ಲಾಕ್ನೊಂದಿಗೆ ಹೆಚ್ಚಿನ ಸಂದೇಶಗಳು ಇರಬಹುದು, ಉದಾಹರಣೆಗೆ, MS_TEE ಫಿಲ್ಟರ್ ಹತ್ತು ಅಂತಹ ಬೆಳಕಿನ ಪ್ರತಿಗಳನ್ನು ಏಕಕಾಲದಲ್ಲಿ ಉತ್ಪಾದಿಸುತ್ತದೆ, ಅದರ ಔಟ್ಪುಟ್ಗಳ ನಡುವೆ ಅವುಗಳನ್ನು ವಿತರಿಸುತ್ತದೆ. ಸರಪಳಿಯಲ್ಲಿನ ಎಲ್ಲಾ ಫಿಲ್ಟರ್‌ಗಳು ಸರಿಯಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸಿದರೆ, ಪೈಪ್‌ಲೈನ್‌ನ ಅಂತ್ಯದ ವೇಳೆಗೆ ಈ ಉಲ್ಲೇಖದ ಎಣಿಕೆ ಶೂನ್ಯವನ್ನು ತಲುಪಬೇಕು ಮತ್ತು ಮೆಮೊರಿ ಡಿಲೊಕೇಶನ್ ಕಾರ್ಯವನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ: ms_free(). ಕರೆ ಸಂಭವಿಸದಿದ್ದರೆ, ಈ ಮೆಮೊರಿಯ ತುಣುಕು ಇನ್ನು ಮುಂದೆ ರಾಶಿಗೆ ಹಿಂತಿರುಗುವುದಿಲ್ಲ, ಅಂದರೆ. ಅವನು "ಸೋರುತ್ತಾನೆ". ಬೆಳಕಿನ ಪ್ರತಿಗಳನ್ನು ಬಳಸುವ ವೆಚ್ಚವು ಸುಲಭವಾಗಿ ನಿರ್ಧರಿಸುವ ಸಾಮರ್ಥ್ಯದ ನಷ್ಟವಾಗಿದೆ (ಸಾಮಾನ್ಯ ನಕಲುಗಳನ್ನು ಬಳಸುವ ಸಂದರ್ಭದಲ್ಲಿ ಅದು ಇರುತ್ತದೆ) ಇದರಲ್ಲಿ ಗ್ರಾಫ್ ಫಿಲ್ಟರ್ ಮೆಮೊರಿ ಸೋರಿಕೆಯಾಗುತ್ತದೆ.
"ಸ್ಥಳೀಯ" ಫಿಲ್ಟರ್‌ಗಳಲ್ಲಿ ಮೆಮೊರಿ ಸೋರಿಕೆಯನ್ನು ಕಂಡುಹಿಡಿಯುವ ಜವಾಬ್ದಾರಿಯು ಮೀಡಿಯಾ ಸ್ಟ್ರೀಮರ್‌ನ ಡೆವಲಪರ್‌ಗಳ ಮೇಲಿರುವುದರಿಂದ, ಹೆಚ್ಚಾಗಿ ನೀವು ಅವುಗಳನ್ನು ಡೀಬಗ್ ಮಾಡಬೇಕಾಗಿಲ್ಲ. ಆದರೆ ನಿಮ್ಮ ಕ್ರಾಫ್ಟಿಂಗ್ ಫಿಲ್ಟರ್‌ನೊಂದಿಗೆ, ನೀವೇ ನಿಮ್ಮ ಸ್ವಂತ ಸಂತೋಷದ ಮಿಡತೆ, ಮತ್ತು ನಿಮ್ಮ ಕೋಡ್‌ನಲ್ಲಿ ಸೋರಿಕೆಯನ್ನು ಹುಡುಕಲು ನೀವು ಕಳೆಯುವ ಸಮಯವು ನಿಮ್ಮ ನಿಖರತೆಯನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ. ನಿಮ್ಮ ಡೀಬಗ್ ಮಾಡುವ ಸಮಯವನ್ನು ಕಡಿಮೆ ಮಾಡಲು, ಫಿಲ್ಟರ್‌ಗಳನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸುವಾಗ ನಾವು ಸೋರಿಕೆ ಸ್ಥಳೀಕರಣ ತಂತ್ರಗಳನ್ನು ನೋಡಬೇಕಾಗಿದೆ. ಹೆಚ್ಚುವರಿಯಾಗಿ, ನಿಜವಾದ ವ್ಯವಸ್ಥೆಯಲ್ಲಿ ಫಿಲ್ಟರ್ ಅನ್ನು ಅನ್ವಯಿಸುವಾಗ ಮಾತ್ರ ಸೋರಿಕೆಯು ಸ್ವತಃ ಪ್ರಕಟವಾಗುತ್ತದೆ, ಅಲ್ಲಿ "ಶಂಕಿತರ" ಸಂಖ್ಯೆಯು ದೊಡ್ಡದಾಗಿರಬಹುದು ಮತ್ತು ಡೀಬಗ್ ಮಾಡುವ ಸಮಯ ಸೀಮಿತವಾಗಿರುತ್ತದೆ.
ಮೆಮೊರಿ ಸೋರಿಕೆ ಹೇಗೆ ಪ್ರಕಟವಾಗುತ್ತದೆ?
ಪ್ರೋಗ್ರಾಂನ ಔಟ್ಪುಟ್ನಲ್ಲಿ ಎಂದು ಊಹಿಸಲು ಇದು ತಾರ್ಕಿಕವಾಗಿದೆ ಟಾಪ್ ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನಿಂದ ಹೆಚ್ಚುತ್ತಿರುವ ಶೇಕಡಾವಾರು ಮೆಮೊರಿಯನ್ನು ತೋರಿಸುತ್ತದೆ.
ಬಾಹ್ಯ ಅಭಿವ್ಯಕ್ತಿಯು ಕೆಲವು ಹಂತದಲ್ಲಿ ಸಿಸ್ಟಮ್ ಮೌಸ್ನ ಚಲನೆಗೆ ನಿಧಾನವಾಗಿ ಪ್ರತಿಕ್ರಿಯಿಸುತ್ತದೆ, ನಿಧಾನವಾಗಿ ಪರದೆಯನ್ನು ಪುನಃ ಚಿತ್ರಿಸುತ್ತದೆ. ಸಿಸ್ಟಮ್ ಲಾಗ್ ಬೆಳೆಯುವ ಸಾಧ್ಯತೆಯಿದೆ, ಹಾರ್ಡ್ ಡ್ರೈವಿನಲ್ಲಿ ಜಾಗವನ್ನು ತಿನ್ನುತ್ತದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ವಿಚಿತ್ರವಾಗಿ ವರ್ತಿಸಲು ಪ್ರಾರಂಭವಾಗುತ್ತದೆ, ಆಜ್ಞೆಗಳಿಗೆ ಪ್ರತಿಕ್ರಿಯಿಸುವುದಿಲ್ಲ, ಫೈಲ್ ತೆರೆಯಲು ಸಾಧ್ಯವಿಲ್ಲ, ಇತ್ಯಾದಿ.
ಸೋರಿಕೆಯ ಸತ್ಯವನ್ನು ಗುರುತಿಸಲು, ನಾವು ಮೆಮೊರಿ ವಿಶ್ಲೇಷಕವನ್ನು ಬಳಸುತ್ತೇವೆ (ಇನ್ನು ಮುಂದೆ ವಿಶ್ಲೇಷಕ ಎಂದು ಉಲ್ಲೇಖಿಸಲಾಗುತ್ತದೆ). ಇದು ಆಗಿರಬಹುದು ವಾಲ್ಗ್ರಿಂಡ್ (ಒಳ್ಳೆಯದು ಅದರ ಬಗ್ಗೆ) ಅಥವಾ ಕಂಪೈಲರ್‌ನಲ್ಲಿ ನಿರ್ಮಿಸಲಾಗಿದೆ gcc ಅಥವ ಇನ್ನೇನಾದರು. ಗ್ರಾಫ್ ಫಿಲ್ಟರ್‌ಗಳಲ್ಲಿ ಒಂದರಲ್ಲಿ ಸೋರಿಕೆ ಸಂಭವಿಸುತ್ತದೆ ಎಂದು ವಿಶ್ಲೇಷಕವು ತೋರಿಸಿದರೆ, ಕೆಳಗೆ ವಿವರಿಸಿದ ವಿಧಾನಗಳಲ್ಲಿ ಒಂದನ್ನು ಅನ್ವಯಿಸಲು ಇದು ಸಮಯ ಎಂದು ಅರ್ಥ.
ಮೂರು ಪೈನ್ಸ್ ವಿಧಾನ
ಮೇಲೆ ತಿಳಿಸಿದಂತೆ, ಮೆಮೊರಿ ಸೋರಿಕೆಯ ಸಂದರ್ಭದಲ್ಲಿ, ವಿಶ್ಲೇಷಕವು ರಾಶಿಯಿಂದ ಮೆಮೊರಿ ಹಂಚಿಕೆಯನ್ನು ವಿನಂತಿಸಿದ ಫಿಲ್ಟರ್‌ಗೆ ಸೂಚಿಸುತ್ತದೆ. ಆದರೆ ಅದನ್ನು ಹಿಂದಿರುಗಿಸಲು "ಮರೆತಿದೆ" ಎಂದು ಫಿಲ್ಟರ್ ಅನ್ನು ಸೂಚಿಸುವುದಿಲ್ಲ, ಇದು ವಾಸ್ತವವಾಗಿ ದೂರುವುದು. ಹೀಗಾಗಿ, ವಿಶ್ಲೇಷಕವು ನಮ್ಮ ಭಯವನ್ನು ಮಾತ್ರ ದೃಢೀಕರಿಸಬಹುದು, ಆದರೆ ಅವರ ಮೂಲವನ್ನು ಸೂಚಿಸುವುದಿಲ್ಲ.
ಗ್ರಾಫ್‌ನಲ್ಲಿನ "ಕೆಟ್ಟ" ಫಿಲ್ಟರ್‌ನ ಸ್ಥಳವನ್ನು ಕಂಡುಹಿಡಿಯಲು, ವಿಶ್ಲೇಷಕವು ಇನ್ನೂ ಸೋರಿಕೆಯನ್ನು ಪತ್ತೆಹಚ್ಚುವ ಕನಿಷ್ಠ ಸಂಖ್ಯೆಯ ನೋಡ್‌ಗಳಿಗೆ ಗ್ರಾಫ್ ಅನ್ನು ಕಡಿಮೆ ಮಾಡುವ ಮೂಲಕ ನೀವು ಹೋಗಬಹುದು ಮತ್ತು ಉಳಿದ ಮೂರು ಪೈನ್‌ಗಳಲ್ಲಿ ಸಮಸ್ಯಾತ್ಮಕ ಫಿಲ್ಟರ್ ಅನ್ನು ಪತ್ತೆ ಮಾಡಬಹುದು.
ಆದರೆ ಕಾಲಮ್‌ನಲ್ಲಿ ಫಿಲ್ಟರ್‌ಗಳ ಸಂಖ್ಯೆಯನ್ನು ಕಡಿಮೆ ಮಾಡುವ ಮೂಲಕ ನೀವು ಫಿಲ್ಟರ್‌ಗಳು ಮತ್ತು ನಿಮ್ಮ ಸಿಸ್ಟಮ್‌ನ ಇತರ ಅಂಶಗಳ ನಡುವಿನ ಪರಸ್ಪರ ಕ್ರಿಯೆಯ ಸಾಮಾನ್ಯ ಕೋರ್ಸ್ ಅನ್ನು ಅಡ್ಡಿಪಡಿಸುತ್ತೀರಿ ಮತ್ತು ಸೋರಿಕೆ ಇನ್ನು ಮುಂದೆ ಕಾಣಿಸುವುದಿಲ್ಲ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನೀವು ಪೂರ್ಣ ಗಾತ್ರದ ಗ್ರಾಫ್ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಬೇಕಾಗುತ್ತದೆ ಮತ್ತು ಕೆಳಗೆ ವಿವರಿಸಿದ ವಿಧಾನವನ್ನು ಬಳಸಿ.
ಸ್ಲೈಡಿಂಗ್ ಇನ್ಸುಲೇಟರ್ ವಿಧಾನ
ಪ್ರಸ್ತುತಿಯ ಸರಳತೆಗಾಗಿ, ನಾವು ಫಿಲ್ಟರ್‌ಗಳ ಒಂದೇ ಸರಣಿಯನ್ನು ಒಳಗೊಂಡಿರುವ ಗ್ರಾಫ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ. ಅವಳನ್ನು ಚಿತ್ರದಲ್ಲಿ ತೋರಿಸಲಾಗಿದೆ.
ಒಂದು ಸಾಮಾನ್ಯ ಗ್ರಾಫ್, ಇದರಲ್ಲಿ, ರೆಡಿಮೇಡ್ ಮೀಡಿಯಾ ಸ್ಟ್ರೀಮರ್ ಫಿಲ್ಟರ್‌ಗಳ ಜೊತೆಗೆ, ನಾಲ್ಕು ಕ್ರಾಫ್ಟ್ ಫಿಲ್ಟರ್‌ಗಳು F1...F4 ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ, ನೀವು ಬಹಳ ಹಿಂದೆಯೇ ಮಾಡಿದ ನಾಲ್ಕು ವಿಭಿನ್ನ ಪ್ರಕಾರಗಳು ಮತ್ತು ಅವುಗಳ ನಿಖರತೆಯ ಬಗ್ಗೆ ಯಾವುದೇ ಸಂದೇಹವಿಲ್ಲ. ಆದಾಗ್ಯೂ, ಅವುಗಳಲ್ಲಿ ಹಲವಾರು ಮೆಮೊರಿ ಸೋರಿಕೆಯನ್ನು ಹೊಂದಿವೆ ಎಂದು ಭಾವಿಸೋಣ. ನಮ್ಮ ವಿಶ್ಲೇಷಕ ಮೇಲ್ವಿಚಾರಣಾ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಚಾಲನೆ ಮಾಡುವಾಗ, ನಿರ್ದಿಷ್ಟ ಫಿಲ್ಟರ್ ಒಂದು ನಿರ್ದಿಷ್ಟ ಪ್ರಮಾಣದ ಮೆಮೊರಿಯನ್ನು ವಿನಂತಿಸಿದೆ ಮತ್ತು ರಾಶಿ N ಬಾರಿ ಅದನ್ನು ಹಿಂತಿರುಗಿಸಲಿಲ್ಲ ಎಂದು ನಾವು ಅದರ ವರದಿಯಿಂದ ಕಲಿಯುತ್ತೇವೆ. MS_VOID_SOURCE ಪ್ರಕಾರದ ಆಂತರಿಕ ಫಿಲ್ಟರ್ ಕಾರ್ಯಗಳಿಗೆ ಉಲ್ಲೇಖವಿದೆ ಎಂದು ಊಹಿಸುವುದು ಸುಲಭ. ರಾಶಿಯಿಂದ ಸ್ಮರಣೆಯನ್ನು ತೆಗೆದುಕೊಳ್ಳುವುದು ಅವನ ಕಾರ್ಯ. ಇತರ ಫಿಲ್ಟರ್‌ಗಳು ಅದನ್ನು ಅಲ್ಲಿಗೆ ಹಿಂತಿರುಗಿಸಬೇಕು. ಆ. ನಾವು ಸೋರಿಕೆಯನ್ನು ಕಂಡುಕೊಳ್ಳುತ್ತೇವೆ.
ಮೆಮೊರಿ ಸೋರಿಕೆಗೆ ಕಾರಣವಾದ ಪೈಪ್‌ಲೈನ್ ನಿಷ್ಕ್ರಿಯತೆಯ ಯಾವ ವಿಭಾಗದಲ್ಲಿ ಸಂಭವಿಸಿದೆ ಎಂಬುದನ್ನು ನಿರ್ಧರಿಸಲು, ಇನ್‌ಪುಟ್‌ನಿಂದ ಔಟ್‌ಪುಟ್‌ಗೆ ಸಂದೇಶಗಳನ್ನು ಸರಳವಾಗಿ ಬದಲಾಯಿಸುವ ಹೆಚ್ಚುವರಿ ಫಿಲ್ಟರ್ ಅನ್ನು ಪರಿಚಯಿಸಲು ಪ್ರಸ್ತಾಪಿಸಲಾಗಿದೆ, ಆದರೆ ಅದೇ ಸಮಯದಲ್ಲಿ ಇನ್‌ಪುಟ್‌ನ ನಾನ್-ಲೈಟ್ ನಕಲನ್ನು ರಚಿಸುತ್ತದೆ. ಸಾಮಾನ್ಯ "ಭಾರೀ" ನಕಲುಗೆ ಸಂದೇಶವನ್ನು ಕಳುಹಿಸಿ, ನಂತರ ಪ್ರವೇಶದ್ವಾರದಲ್ಲಿ ಬಂದ ಸಂದೇಶವನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಅಳಿಸಿಹಾಕುತ್ತದೆ. ಅಂತಹ ಫಿಲ್ಟರ್ ಅನ್ನು ನಾವು ಇನ್ಸುಲೇಟರ್ ಎಂದು ಕರೆಯುತ್ತೇವೆ. ಫಿಲ್ಟರ್ ಸರಳವಾಗಿರುವುದರಿಂದ, ಅದರಲ್ಲಿ ಸೋರಿಕೆಯನ್ನು ಹೊರತುಪಡಿಸಲಾಗಿದೆ ಎಂದು ನಾವು ನಂಬುತ್ತೇವೆ. ಮತ್ತು ಇನ್ನೊಂದು ಸಕಾರಾತ್ಮಕ ಆಸ್ತಿ - ನಾವು ಅದನ್ನು ನಮ್ಮ ಗ್ರಾಫ್‌ನಲ್ಲಿ ಯಾವುದೇ ಸ್ಥಳಕ್ಕೆ ಸೇರಿಸಿದರೆ, ಇದು ಸರ್ಕ್ಯೂಟ್‌ನ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಯಾವುದೇ ರೀತಿಯಲ್ಲಿ ಪರಿಣಾಮ ಬೀರುವುದಿಲ್ಲ. ನಾವು ಇನ್ಸುಲೇಟರ್ ಫಿಲ್ಟರ್ ಅನ್ನು ಎರಡು ಬಾಹ್ಯರೇಖೆಯೊಂದಿಗೆ ವೃತ್ತದಂತೆ ಚಿತ್ರಿಸುತ್ತೇವೆ.
voidsourse ಫಿಲ್ಟರ್ ನಂತರ ಐಸೊಲೇಟರ್ ಅನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಿ:
ನಾವು ಮತ್ತೊಮ್ಮೆ ವಿಶ್ಲೇಷಕದೊಂದಿಗೆ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ರನ್ ಮಾಡುತ್ತೇವೆ ಮತ್ತು ಈ ಸಮಯದಲ್ಲಿ, ವಿಶ್ಲೇಷಕವು ಐಸೊಲೇಟರ್ ಮೇಲೆ ಆರೋಪವನ್ನು ಹಾಕುತ್ತದೆ ಎಂದು ನಾವು ನೋಡುತ್ತೇವೆ. ಎಲ್ಲಾ ನಂತರ, ಅವನು ಈಗ ಡೇಟಾದ ಬ್ಲಾಕ್‌ಗಳನ್ನು ರಚಿಸುತ್ತಾನೆ, ಅದು ನಂತರ ಅಜ್ಞಾತ ನಿರ್ಲಕ್ಷ್ಯ ಫಿಲ್ಟರ್‌ನಿಂದ (ಅಥವಾ ಫಿಲ್ಟರ್‌ಗಳು) ಕಳೆದುಹೋಗುತ್ತದೆ. ಮುಂದಿನ ಹಂತವು ಸರಪಳಿಯ ಉದ್ದಕ್ಕೂ ಅವಾಹಕವನ್ನು ಒಂದು ಫಿಲ್ಟರ್ ಮೂಲಕ ಬಲಕ್ಕೆ ವರ್ಗಾಯಿಸುವುದು ಮತ್ತು ವಿಶ್ಲೇಷಣೆಯನ್ನು ಮತ್ತೆ ಪ್ರಾರಂಭಿಸುವುದು. ಆದ್ದರಿಂದ, ಹಂತ ಹಂತವಾಗಿ, ಐಸೊಲೇಟರ್ ಅನ್ನು ಬಲಕ್ಕೆ ಸರಿಸಿ, ಮುಂದಿನ ವಿಶ್ಲೇಷಕ ವರದಿಯಲ್ಲಿ "ಸೋರಿಕೆಯಾದ" ಮೆಮೊರಿ ಬ್ಲಾಕ್‌ಗಳ ಸಂಖ್ಯೆ ಕಡಿಮೆಯಾದಾಗ ನಾವು ಪರಿಸ್ಥಿತಿಯನ್ನು ಪಡೆಯುತ್ತೇವೆ. ಇದರರ್ಥ ಈ ಹಂತದಲ್ಲಿ ಅವಾಹಕವು ಸಮಸ್ಯಾತ್ಮಕ ಫಿಲ್ಟರ್ ನಂತರ ತಕ್ಷಣವೇ ಸರಪಳಿಯಲ್ಲಿ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ. ಕೇವಲ ಒಂದು "ಕೆಟ್ಟ" ಫಿಲ್ಟರ್ ಇದ್ದರೆ, ಸೋರಿಕೆಯು ಸಂಪೂರ್ಣವಾಗಿ ಕಣ್ಮರೆಯಾಗುತ್ತದೆ. ಹೀಗಾಗಿ, ನಾವು ಸಮಸ್ಯಾತ್ಮಕ ಫಿಲ್ಟರ್ ಅನ್ನು ಸ್ಥಳೀಕರಿಸಿದ್ದೇವೆ (ಅಥವಾ ಹಲವಾರುವುಗಳಲ್ಲಿ ಒಂದು). ಫಿಲ್ಟರ್ ಅನ್ನು "ಸ್ಥಿರಗೊಳಿಸಿದ" ನಂತರ, ಮೆಮೊರಿ ಸೋರಿಕೆಯನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ತೆಗೆದುಹಾಕುವವರೆಗೆ ನಾವು ಐಸೊಲೇಟರ್ ಅನ್ನು ಸರಪಳಿಯ ಉದ್ದಕ್ಕೂ ಬಲಕ್ಕೆ ಸರಿಸುವುದನ್ನು ಮುಂದುವರಿಸಬಹುದು.
ಐಸೊಲೇಟರ್ ಫಿಲ್ಟರ್ ಅನ್ನು ಅಳವಡಿಸಲಾಗುತ್ತಿದೆ
ಐಸೊಲೇಟರ್ ಅನುಷ್ಠಾನವು ಸಾಮಾನ್ಯ ಫಿಲ್ಟರ್‌ನಂತೆ ಕಾಣುತ್ತದೆ. ಹೆಡರ್ ಫೈಲ್:
/* Файл iso_filter.h Описание изолирующего фильтра. */
#ifndef iso_filter_h
#define iso_filter_h
/* Задаем идентификатор фильтра. */
#include <mediastreamer2/msfilter.h>
#define MY_ISO_FILTER_ID 1024
extern MSFilterDesc iso_filter_desc;
#endif
ಫಿಲ್ಟರ್ ಸ್ವತಃ:
/* Файл iso_filter.c Описание изолирующего фильтра. */
#include "iso_filter.h"
static void
iso_init (MSFilter * f)
{
}
static void
iso_uninit (MSFilter * f)
{
}
static void
iso_process (MSFilter * f)
{
mblk_t *im;
while ((im = ms_queue_get (f->inputs[0])) != NULL)
{
ms_queue_put (f->outputs[0], copymsg (im));
freemsg (im);
}
}
static MSFilterMethod iso_methods[] = {
{0, NULL}
};
MSFilterDesc iso_filter_desc = {
MY_ISO_FILTER_ID,
"iso_filter",
"A filter that reads from input and copy to its output.",
MS_FILTER_OTHER,
NULL,
1,
1,
iso_init,
NULL,
iso_process,
NULL,
iso_uninit,
iso_methods
};
MS_FILTER_DESC_EXPORT (iso_desc)
ಮೆಮೊರಿ ನಿರ್ವಹಣೆ ಕಾರ್ಯಗಳನ್ನು ಬದಲಿಸುವ ವಿಧಾನ
ಹೆಚ್ಚು ಸೂಕ್ಷ್ಮ ಸಂಶೋಧನೆಗಾಗಿ, ಮೀಡಿಯಾ ಸ್ಟ್ರೀಮರ್ ನಿಮ್ಮದೇ ಆದ ಮೆಮೊರಿ ಪ್ರವೇಶ ಕಾರ್ಯಗಳನ್ನು ಬದಲಿಸುವ ಸಾಮರ್ಥ್ಯವನ್ನು ಒದಗಿಸುತ್ತದೆ, ಇದು ಮುಖ್ಯ ಕೆಲಸದ ಜೊತೆಗೆ, "ಯಾರು, ಎಲ್ಲಿ ಮತ್ತು ಏಕೆ" ಎಂದು ರೆಕಾರ್ಡ್ ಮಾಡುತ್ತದೆ. ಮೂರು ಕಾರ್ಯಗಳನ್ನು ಬದಲಾಯಿಸಲಾಗುತ್ತಿದೆ. ಇದನ್ನು ಈ ಕೆಳಗಿನ ರೀತಿಯಲ್ಲಿ ಮಾಡಲಾಗುತ್ತದೆ:
OrtpMemoryFunctions reserv;
OrtpMemoryFunctions my;
reserv.malloc_fun = ortp_malloc;
reserv.realloc_fun = ortp_realloc;
reserv.free_fun = ortp_free;
my.malloc_fun = &my_malloc;
my.realloc_fun = &my_realloc;
my.free_fun = &my_free;
ortp_set_memory_functions(&my);ವಿಶ್ಲೇಷಕವು ಫಿಲ್ಟರ್‌ಗಳನ್ನು ತುಂಬಾ ನಿಧಾನಗೊಳಿಸಿದಾಗ ನಮ್ಮ ಸರ್ಕ್ಯೂಟ್ ನಿರ್ಮಿಸಲಾದ ಸಿಸ್ಟಮ್‌ನ ಕಾರ್ಯಾಚರಣೆಯು ಅಡ್ಡಿಪಡಿಸಿದಾಗ ಈ ವೈಶಿಷ್ಟ್ಯವು ಪಾರುಗಾಣಿಕಾಕ್ಕೆ ಬರುತ್ತದೆ. ಅಂತಹ ಪರಿಸ್ಥಿತಿಯಲ್ಲಿ, ನೀವು ವಿಶ್ಲೇಷಕವನ್ನು ತ್ಯಜಿಸಬೇಕು ಮತ್ತು ಮೆಮೊರಿ ಕಾರ್ಯಗಳ ಪರ್ಯಾಯವನ್ನು ಬಳಸಬೇಕು.
ಶಾಖೆಗಳನ್ನು ಹೊಂದಿರದ ಸರಳ ಗ್ರಾಫ್ಗಾಗಿ ನಾವು ಕ್ರಮಗಳ ಅಲ್ಗಾರಿದಮ್ ಅನ್ನು ಪರಿಗಣಿಸಿದ್ದೇವೆ. ಆದರೆ ಈ ವಿಧಾನವನ್ನು ಇತರ ಸಂದರ್ಭಗಳಲ್ಲಿ ಅನ್ವಯಿಸಬಹುದು, ಸಹಜವಾಗಿ ತೊಡಕುಗಳೊಂದಿಗೆ, ಆದರೆ ಕಲ್ಪನೆಯು ಒಂದೇ ಆಗಿರುತ್ತದೆ.
ಮುಂದಿನ ಲೇಖನದಲ್ಲಿ, ಟಿಕ್ಕರ್ ಲೋಡ್ ಅಂದಾಜಿನ ಸಮಸ್ಯೆಯನ್ನು ನಾವು ನೋಡುತ್ತೇವೆ ಮತ್ತು ಮೀಡಿಯಾ ಸ್ಟ್ರೀಮರ್‌ನಲ್ಲಿ ಅತಿಯಾದ ಕಂಪ್ಯೂಟಿಂಗ್ ಲೋಡ್ ಅನ್ನು ಹೇಗೆ ಎದುರಿಸುವುದು.
ಮೂಲ: www.habr.com