వ్యాసం యొక్క పదార్థం నా నుండి తీసుకోబడింది .
గతం లో , టిక్కర్‌పై లోడ్‌ను అంచనా వేసే సమస్యను మరియు మీడియా స్ట్రీమర్‌లో అధిక కంప్యూటింగ్ లోడ్‌ను ఎదుర్కోవడానికి మార్గాలను పరిగణలోకి తీసుకుంటానని వాగ్దానం చేసాను. కానీ డేటా కదలికకు సంబంధించిన డీబగ్గింగ్ క్రాఫ్ట్ ఫిల్టర్‌ల సమస్యలను కవర్ చేయడం మరింత తార్కికంగా ఉంటుందని నేను నిర్ణయించుకున్నాను మరియు తర్వాత మాత్రమే పనితీరు ఆప్టిమైజేషన్ సమస్యలను పరిగణలోకి తీసుకున్నాను.
క్రాఫ్ట్ ఫిల్టర్‌లను డీబగ్గింగ్ చేస్తోంది
మునుపటి కథనంలో మీడియా స్ట్రీమర్‌లో డేటాను తరలించే విధానాన్ని మేము చూసిన తర్వాత, దానిలో దాగి ఉన్న ప్రమాదాల గురించి మాట్లాడటం తార్కికంగా ఉంటుంది. డేటా ప్రవాహం యొక్క మూలం వద్ద ఉన్న ఫిల్టర్‌లలోని కుప్ప నుండి మెమరీ కేటాయించబడుతుంది మరియు ప్రవాహం చివరిలో ఉన్న ఫిల్టర్‌ల ద్వారా మెమరీ విడుదల చేయబడుతుంది మరియు కుప్పకు తిరిగి వస్తుంది అనేది “డేటా ఫ్లో” సూత్రం యొక్క లక్షణాలలో ఒకటి. మార్గం. అదనంగా, కొత్త డేటా యొక్క సృష్టి మరియు దాని విధ్వంసం మధ్యలో ఎక్కడో సంభవించవచ్చు. సాధారణంగా, మెమరీ విడుదల డేటా బ్లాక్‌ను సృష్టించిన దాని కంటే వేరొక ఫిల్టర్ ద్వారా నిర్వహించబడుతుంది.
పారదర్శక మెమరీ మానిటరింగ్ దృక్కోణం నుండి, ఫిల్టర్ ఇన్‌పుట్ బ్లాక్‌ను స్వీకరించిన తర్వాత, ప్రాసెస్ చేసిన తర్వాత వెంటనే దానిని నాశనం చేయడం, మెమరీని ఖాళీ చేయడం మరియు అవుట్‌పుట్ డేటాతో కొత్తగా సృష్టించిన బ్లాక్‌ను అవుట్‌పుట్ చేయడం సహేతుకంగా ఉంటుంది. ఈ సందర్భంలో, ఫిల్టర్‌లోని మెమరీ లీక్ సులభంగా గుర్తించబడుతుంది - ఎనలైజర్ ఫిల్టర్‌లో లీక్‌ను గుర్తించినట్లయితే, తదుపరి ఫిల్టర్ ఇన్‌కమింగ్ బ్లాక్‌లను సరిగ్గా నాశనం చేయదు మరియు దానిలో లోపం ఉంది. కానీ అధిక పనితీరును కొనసాగించే దృక్కోణం నుండి, డేటా బ్లాక్‌లతో పని చేసే ఈ విధానం ఉత్పాదకమైనది కాదు - ఇది ఎటువంటి ఉపయోగకరమైన అవుట్‌పుట్ లేకుండా డేటా బ్లాక్‌ల కోసం పెద్ద సంఖ్యలో కార్యకలాపాలకు/ఉచిత మెమరీని కేటాయించడానికి దారితీస్తుంది.
ఈ కారణంగా, మీడియా స్ట్రీమర్ ఫిల్టర్‌లు, డేటా ప్రాసెసింగ్‌ను మందగించకుండా ఉండటానికి, సందేశాలను కాపీ చేసేటప్పుడు సులభమైన కాపీలను సృష్టించే ఫంక్షన్‌లను ఉపయోగిస్తాయి (మేము మునుపటి కథనంలో వాటి గురించి మాట్లాడాము). ఈ ఫంక్షన్‌లు కాపీ చేయబడిన “పాత” సందేశం నుండి డేటా యొక్క బ్లాక్‌ను దానికి “అటాచ్ చేయడం” ద్వారా సందేశ హెడర్‌కి కొత్త ఉదాహరణను మాత్రమే సృష్టిస్తాయి. ఫలితంగా, ఒక డేటా బ్లాక్‌కి రెండు హెడర్‌లు జోడించబడతాయి మరియు డేటా బ్లాక్‌లోని రిఫరెన్స్ కౌంటర్ పెరుగుతుంది. అయితే ఇది రెండు సందేశాల లాగా ఉంటుంది. అటువంటి "సోషలైజ్డ్" డేటా బ్లాక్‌తో మరిన్ని సందేశాలు ఉండవచ్చు, ఉదాహరణకు, MS_TEE ఫిల్టర్ అటువంటి లైట్ కాపీల డజను ఒకేసారి ఉత్పత్తి చేస్తుంది, వాటిని దాని అవుట్‌పుట్‌లలో పంపిణీ చేస్తుంది. గొలుసులోని అన్ని ఫిల్టర్‌లు సరిగ్గా పనిచేస్తే, పైప్‌లైన్ ముగిసే సమయానికి ఈ రిఫరెన్స్ కౌంటర్ సున్నాకి చేరుకోవాలి మరియు మెమరీ విడుదల ఫంక్షన్ అంటారు: ms_free(). కాల్ జరగకపోతే, ఈ మెమరీ భాగం ఇకపై కుప్పకు తిరిగి ఇవ్వబడదు, అనగా. అది "లీక్" అవుతుంది. లైట్ కాపీలను ఉపయోగించడం యొక్క ధర ఏమిటంటే, ఏ గ్రాఫ్ ఫిల్టర్ మెమరీని లీక్ చేస్తుందో సులభంగా గుర్తించే సామర్థ్యాన్ని కోల్పోవడం (సాధారణ కాపీల విషయంలో ఉంటుంది).
స్థానిక ఫిల్టర్‌లలో మెమరీ లీక్‌లను కనుగొనడానికి మీడియా స్ట్రీమర్ డెవలపర్‌లు బాధ్యత వహిస్తారు కాబట్టి, మీరు వాటిని డీబగ్ చేయాల్సిన అవసరం ఉండదు. కానీ మీ క్రాఫ్ట్ ఫిల్టర్‌తో, మీరు మీ స్వంత ఆనందానికి గొల్లభామగా ఉంటారు మరియు మీ కోడ్‌లో లీక్‌ల కోసం వెతకడానికి మీరు వెచ్చించే సమయం మీ ఖచ్చితత్వంపై ఆధారపడి ఉంటుంది. మీ డీబగ్గింగ్ సమయాన్ని తగ్గించడానికి, ఫిల్టర్‌లను అభివృద్ధి చేస్తున్నప్పుడు మేము లీక్ డిటెక్షన్ టెక్నిక్‌లను చూడాలి. అదనంగా, ఫిల్టర్‌ను నిజమైన సిస్టమ్‌లో వర్తింపజేసినప్పుడు మాత్రమే లీక్ వ్యక్తమవుతుంది, ఇక్కడ "అనుమానితుల" సంఖ్య భారీగా ఉండవచ్చు మరియు డీబగ్గింగ్ సమయం పరిమితం కావచ్చు.
మెమరీ లీక్ ఎలా వ్యక్తమవుతుంది?
ప్రోగ్రామ్ అవుట్‌పుట్‌లో అని భావించడం తార్కికం టాప్ మీ అప్లికేషన్ ఆక్రమించిన మెమరీలో పెరుగుతున్న శాతాన్ని చూపుతుంది.
బాహ్య అభివ్యక్తి ఏమిటంటే, ఏదో ఒక సమయంలో సిస్టమ్ మౌస్ కదలికకు నెమ్మదిగా స్పందించడం మరియు నెమ్మదిగా స్క్రీన్‌ను మళ్లీ గీయడం ప్రారంభమవుతుంది. మీ హార్డు డ్రైవులో ఖాళీని తిని, సిస్టమ్ లాగ్ పెరిగే అవకాశం కూడా ఉంది. ఈ సందర్భంలో, మీ అప్లికేషన్ వింతగా ప్రవర్తించడం ప్రారంభమవుతుంది, ఆదేశాలకు ప్రతిస్పందించదు, ఫైల్‌ను తెరవదు, మొదలైనవి.
లీక్ సంభవించడాన్ని గుర్తించడానికి, మేము మెమరీ ఎనలైజర్‌ని ఉపయోగిస్తాము (ఇకపై ఎనలైజర్‌గా సూచిస్తారు). అది కావచ్చు వాల్‌గ్రైండ్ (మంచిది దాని గురించి) లేదా కంపైలర్‌లో నిర్మించబడింది gcc లేదా మరేదైనా. గ్రాఫ్ ఫిల్టర్‌లలో ఒకదానిలో లీక్ సంభవిస్తుందని ఎనలైజర్ చూపిస్తే, దిగువ వివరించిన పద్ధతుల్లో ఒకదాన్ని వర్తింపజేయడానికి ఇది సమయం అని అర్థం.
మూడు పైన్స్ పద్ధతి
పైన పేర్కొన్నట్లుగా, మెమరీ లీక్ ఉన్నట్లయితే, ఎనలైజర్ హీప్ నుండి మెమరీ కేటాయింపును అభ్యర్థించిన ఫిల్టర్‌ను సూచిస్తుంది. కానీ దానిని తిరిగి ఇవ్వడానికి “మర్చిపోయిన” ఫిల్టర్‌ను అది ఎత్తి చూపదు, వాస్తవానికి ఇది అపరాధి. అందువల్ల, ఎనలైజర్ మన భయాలను మాత్రమే నిర్ధారించగలదు, కానీ వాటి మూలాన్ని సూచించదు.
గ్రాఫ్‌లోని “చెడు” ఫిల్టర్ యొక్క స్థానాన్ని తెలుసుకోవడానికి, మీరు గ్రాఫ్‌ను కనీస నోడ్‌ల సంఖ్యకు తగ్గించడం ద్వారా వెళ్లవచ్చు, దీనిలో ఎనలైజర్ ఇప్పటికీ లీక్‌ను గుర్తించి, మిగిలిన మూడు పైన్‌లలో సమస్యాత్మక ఫిల్టర్‌ను స్థానికీకరించవచ్చు.
కానీ గ్రాఫ్‌లోని ఫిల్టర్‌ల సంఖ్యను తగ్గించడం ద్వారా, మీరు ఫిల్టర్‌లు మరియు మీ సిస్టమ్‌లోని ఇతర అంశాల మధ్య పరస్పర చర్య యొక్క సాధారణ కోర్సుకు అంతరాయం కలిగించవచ్చు మరియు లీక్ ఇకపై కనిపించదు. ఈ సందర్భంలో, మీరు పూర్తి-పరిమాణ గ్రాఫ్‌తో పని చేయాలి మరియు దిగువ వివరించిన విధానాన్ని ఉపయోగించాలి.
స్లైడింగ్ ఇన్సులేటర్ పద్ధతి
ప్రెజెంటేషన్ యొక్క సరళత కోసం, మేము ఒక గొలుసు ఫిల్టర్‌లను కలిగి ఉన్న గ్రాఫ్‌ని ఉపయోగిస్తాము. ఆమె చిత్రంలో చూపబడింది.
ఒక సాధారణ గ్రాఫ్‌లో, రెడీమేడ్ మీడియా స్ట్రీమర్ ఫిల్టర్‌లతో పాటు, నాలుగు క్రాఫ్ట్ ఫిల్టర్‌లు F1...F4 ఉపయోగించబడతాయి, నాలుగు వేర్వేరు రకాలు, వీటిని మీరు చాలా కాలం క్రితం తయారు చేసారు మరియు వాటి ఖచ్చితత్వం గురించి ఎటువంటి సందేహం లేదు. అయితే, వాటిలో చాలా మెమరీ లీక్‌లు ఉన్నాయని అనుకుందాం. ఎనలైజర్‌ను పర్యవేక్షించడానికి మేము మా ప్రోగ్రామ్‌ను అమలు చేసినప్పుడు, నిర్దిష్ట ఫిల్టర్ కొంత మెమరీని అభ్యర్థించిందని మరియు దానిని హీప్ Nకి ఎన్నిసార్లు తిరిగి ఇవ్వలేదని దాని నివేదిక నుండి మేము తెలుసుకున్నాము. MS_VOID_SOURCE రకం అంతర్గత ఫిల్టర్ ఫంక్షన్‌లకు లింక్ ఉంటుందని మీరు సులభంగా ఊహించవచ్చు. అతని పని కుప్ప నుండి జ్ఞాపకశక్తిని తీసుకోవడం. ఇతర ఫిల్టర్‌లు దానిని అక్కడ తిరిగి ఇవ్వాలి. ఆ. మేము లీక్ యొక్క వాస్తవాన్ని కనుగొంటాము.
మెమరీ లీక్‌కు దారితీసే పైప్‌లైన్‌లోని ఏ విభాగంలో నిష్క్రియాత్మకత ఉందో గుర్తించడానికి, సందేశాలను ఇన్‌పుట్ నుండి అవుట్‌పుట్‌కు మార్చే అదనపు ఫిల్టర్‌ను ప్రవేశపెట్టాలని ప్రతిపాదించబడింది, అయితే అదే సమయంలో తేలికగా లేని ఇన్‌పుట్ సందేశం కాపీని సృష్టిస్తుంది. , కానీ సాధారణ "భారీ" ఒకటి, ప్రవేశద్వారం వద్ద అందుకున్న సందేశాన్ని పూర్తిగా తొలగిస్తుంది. అటువంటి ఫిల్టర్‌ను మేము ఇన్సులేటర్ అని పిలుస్తాము. ఫిల్టర్ సరళమైనది కాబట్టి, దానిలో లీకేజీ లేదని మేము నమ్ముతున్నాము. మరియు మరొక సానుకూల ఆస్తి - మేము దానిని మా గ్రాఫ్‌లో ఎక్కడైనా జోడిస్తే, ఇది సర్క్యూట్ యొక్క ఆపరేషన్‌ను ఏ విధంగానూ ప్రభావితం చేయదు. మేము ఫిల్టర్-ఐసోలేటర్‌ను డబుల్ సర్క్యూట్‌తో సర్కిల్ రూపంలో చిత్రీకరిస్తాము.
వాయిడ్‌సోర్స్ ఫిల్టర్ తర్వాత మేము వెంటనే ఐసోలేటర్‌ను ఆన్ చేస్తాము:
మేము ఎనలైజర్‌తో ప్రోగ్రామ్‌ను మళ్లీ అమలు చేస్తాము మరియు ఈసారి ఎనలైజర్ ఇన్సులేటర్‌ను నిందిస్తుందని మేము చూస్తాము. అన్నింటికంటే, అతను ఇప్పుడు డేటా బ్లాక్‌లను సృష్టిస్తాడు, అవి తెలియని అజాగ్రత్త ఫిల్టర్ (లేదా ఫిల్టర్‌లు) ద్వారా పోతాయి. తదుపరి దశ గొలుసుతో పాటు ఇన్సులేటర్‌ను ఒక ఫిల్టర్ ద్వారా కుడి వైపుకు తరలించి, విశ్లేషణను మళ్లీ ప్రారంభించడం. కాబట్టి, స్టెప్ బై స్టెప్ బై స్టెప్ ఐసోలేటర్‌ను కుడి వైపుకు తరలించడం, తదుపరి ఎనలైజర్ రిపోర్ట్‌లో “లీక్” మెమరీ బ్లాక్‌ల సంఖ్య తగ్గే పరిస్థితిని మేము పొందుతాము. ఈ దశలో సమస్య వడపోత తర్వాత వెంటనే ఇన్సులేటర్ గొలుసులో ఉందని దీని అర్థం. ఒక "చెడు" ఫిల్టర్ మాత్రమే ఉంటే, అప్పుడు లీక్ పూర్తిగా అదృశ్యమవుతుంది. అందువలన, మేము సమస్యాత్మక ఫిల్టర్‌ను (లేదా అనేక వాటిలో ఒకటి) స్థానికీకరించాము. ఫిల్టర్‌ను “ఫిక్స్” చేసిన తర్వాత, మెమరీ లీక్‌లను పూర్తిగా ఓడించే వరకు ఐసోలేటర్‌ను గొలుసుతో పాటు కుడివైపుకి తరలించడం కొనసాగించవచ్చు.
ఐసోలేటర్ ఫిల్టర్ అమలు
ఐసోలేటర్ అమలు సాధారణ ఫిల్టర్ లాగా కనిపిస్తుంది. హెడర్ ఫైల్:
/* Файл 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