మొదటి C++ (m) కేటాయింపు ఎల్లప్పుడూ 72 KBగా ఎందుకు ఉంటుంది?

మీ మొదటి C++ కేటాయింపు వెనుక రహస్యం

మీరు సాధారణ C++ ప్రోగ్రామ్‌ని వ్రాస్తారు. ఒకే కొత్త పూర్ణం. నాలుగు బైట్లు. మీరు straceని లేదా మీకు ఇష్టమైన మెమరీ ప్రొఫైలర్‌ని కాల్చారు మరియు అది ఉంది — మీ ప్రక్రియ కేవలం ఆపరేటింగ్ సిస్టమ్ నుండి దాదాపు 72 KBని అభ్యర్థించింది. 4 బైట్లు కాదు. 64 బైట్లు కాదు. పూర్తి 72 KB. మీరు ఎప్పుడైనా ఆ నంబర్ వైపు చూస్తూ, మీ సాధనం మీకు అబద్ధం చెబుతోందా అని ఆలోచిస్తే, మీరు ఒంటరిగా లేరు. C++ డెవలపర్‌లు మెమొరీ ఇంటర్నల్‌లను మొదటిసారిగా త్రవ్వడం చాలా తరచుగా అడిగే ప్రశ్నలలో ఈ వింత ప్రవర్తన ఒకటి, మరియు సమాధానం మీ కోడ్ మరియు వాస్తవ హార్డ్‌వేర్ మధ్య ఉండే లేయర్‌ల ద్వారా మనోహరమైన ప్రయాణంలో మమ్మల్ని తీసుకువెళుతుంది.

మీరు క్రొత్త

72 KB ఫిగర్‌ని అర్థం చేసుకోవడానికి, మీరు పూర్తి కేటాయింపు గొలుసును ట్రేస్ చేయాలి. మీ C++ కోడ్ new intని అమలు చేసినప్పుడు, కంపైలర్ దానిని ఆపరేటర్ కొత్తకి కాల్‌గా అనువదిస్తుంది, ఇది చాలా Linux సిస్టమ్‌లలో glibc నుండి mallocకి ప్రాతినిధ్యం వహిస్తుంది. కానీ malloc నేరుగా కెర్నల్‌ని 4 బైట్‌ల మెమరీని అడగదు. కెర్నల్ పేజీలలో పనిచేస్తుంది — సాధారణంగా x86_64లో 4 KB — మరియు సాధారణ మెమరీ యాక్సెస్‌కి సంబంధించి సిస్టమ్ కాల్ ఖర్చు అపారమైనది. ప్రతి వ్యక్తిగత కేటాయింపు కోసం brk() లేదా mmap()కి కాల్ చేయడం వలన ఏదైనా చిన్నవిషయం కాని ప్రోగ్రామ్ ఆగిపోతుంది.

బదులుగా, glibc యొక్క మెమరీ అలోకేటర్ — ptmalloc2 అని పిలువబడే ఒక అమలు, డౌగ్ లీ యొక్క క్లాసిక్ dlmalloc నుండి వచ్చింది — ఇది మధ్యవర్తిగా పనిచేస్తుంది. ఇది కెర్నల్ ముందు నుండి పెద్ద మెమరీ బ్లాక్‌లను అభ్యర్థిస్తుంది, ఆపై మీ ప్రోగ్రామ్‌కు అవసరమైన విధంగా వాటిని చిన్న ముక్కలుగా చెక్కుతుంది. మీ మొదటి 4-బైట్ కేటాయింపు ఆపరేటింగ్ సిస్టమ్‌కు చాలా పెద్ద అభ్యర్థనను ప్రేరేపించడానికి ఇది ప్రాథమిక కారణం. కేటాయించేవాడు వృధా కాదు. ఇది వ్యూహాత్మకంగా ఉంది.

72 KBని విడదీయడం: బైట్‌లు ఎక్కడికి వెళ్తాయి

ప్రారంభ కేటాయింపు ఓవర్‌హెడ్ అనేక విభిన్న భాగాల నుండి వస్తుంది, రన్‌టైమ్ మీకు ఉపయోగపడే మెమరీలో ఒక్క బైట్‌ను కూడా అందజేయడానికి ముందు తప్పనిసరిగా ప్రారంభించాలి. ప్రతి అంశాన్ని అర్థం చేసుకోవడం వల్ల ఆ సంఖ్య ఎందుకు ల్యాండ్ అవుతుందో వివరిస్తుంది.

మొదట, glibc యొక్క malloc ప్రధాన రంగాన్ని ప్రారంభిస్తుంది — ప్రధాన థ్రెడ్‌లో అన్ని కేటాయింపులను ట్రాక్ చేసే ప్రాథమిక బుక్ కీపింగ్ నిర్మాణం. ఈ అరేనా హీప్ కోసం మెటాడేటా, ఫ్రీ-లిస్ట్ పాయింటర్‌లు మరియు విభిన్న కేటాయింపు పరిమాణాల కోసం బిన్ నిర్మాణాలను కలిగి ఉంటుంది. కేటాయింపుదారు ప్రోగ్రామ్ విరామాన్ని sbrk() ద్వారా విస్తరింపజేస్తుంది మరియు ప్రారంభ పొడిగింపు M_TOP_PAD అనే అంతర్గత పరామితి ద్వారా నిర్వహించబడుతుంది, ఇది డిఫాల్ట్‌గా 128 KB ప్యాడింగ్‌కు వస్తుంది. అయితే, అసలు ప్రారంభ అభ్యర్థన పేజీ సమలేఖనం మరియు ఇప్పటికే ఉన్న విరామ స్థానం కోసం సర్దుబాటు చేయబడుతుంది, దీని ఫలితంగా తరచుగా చిన్న మొదటి అభ్యర్థన వస్తుంది — సాధారణంగా తాజాగా ప్రారంభించిన ప్రక్రియలో 72 KB ఫిగర్‌కి సమీపంలో ల్యాండ్ అవుతుంది.

రెండవది, glibc 2.26 నుండి, కేటాయింపుదారు మొదటి ఉపయోగంలో థ్రెడ్-లోకల్ కాష్ (tcache)ని ప్రారంభిస్తుంది. tcache 64 డబ్బాలను కలిగి ఉంటుంది (ఒక చిన్న-కేటాయింపు పరిమాణం తరగతికి ఒకటి), ప్రతి ఒక్కటి 7 కాష్ చేయబడిన భాగాలను కలిగి ఉంటుంది. tcache_perthread_struct దానికదే దాదాపు 1 KB వినియోగిస్తుంది, అయితే దీన్ని ప్రారంభించే చర్య విస్తృత అరేనా సెటప్‌ను ప్రేరేపిస్తుంది. మూడవది, C++ రన్‌టైమ్ ఇప్పటికే మీ ప్రధాన()ని అమలు చేయడానికి ముందే కేటాయింపులను నిర్వహించింది — స్టాటిక్ కన్‌స్ట్రక్టర్‌లు, std::cout మరియు స్నేహితుల కోసం iostream బఫర్ ప్రారంభీకరణ మరియు లొకేల్ సెటప్ అన్నీ ఆ ప్రారంభ హీప్ ఫుట్‌ప్రింట్‌కు దోహదం చేస్తాయి.

అరేనా సిస్టమ్ మరియు ముందస్తు కేటాయింపు ఎందుకు తెలివైనది

మెమొరీ యొక్క గణనీయమైన భాగాన్ని ముక్కలుగా అభ్యర్థించడం కంటే ముందుగా కేటాయించాలనే నిర్ణయం అమలులో ప్రమాదం కాదు. ఇది దశాబ్దాల సిస్టమ్స్ ప్రోగ్రామింగ్ అనుభవంలో పాతుకుపోయిన ఉద్దేశపూర్వక ఇంజనీరింగ్ ట్రేడ్‌ఆఫ్. brk() లేదా mmap()కి చేసే ప్రతి కాల్‌లో వినియోగదారు స్థలం నుండి కెర్నల్ స్పేస్‌కి సందర్భం మారడం, ప్రాసెస్ యొక్క వర్చువల్ మెమరీ మ్యాపింగ్‌ల సవరణ మరియు సంభావ్య పేజీ పట్టిక నవీకరణలు ఉంటాయి. ఆధునిక హార్డ్‌వేర్‌లో, ఒకే సిస్టమ్ కాల్‌కు దాదాపు 100-200 నానోసెకన్‌లు ఖర్చవుతాయి — ఇది చిన్నవిషయం, స్కేల్ వద్ద విపత్తు.

ప్రారంభ సమయంలో 10,000 చిన్న కేటాయింపులు చేసే ప్రోగ్రామ్‌ను పరిగణించండి. ముందస్తు కేటాయింపు లేకుండా, అంటే 10,000 సిస్టమ్ కాల్‌లు, దాదాపు 1-2 మిల్లీసెకన్ల స్వచ్ఛమైన ఓవర్‌హెడ్ ఖర్చవుతుంది. అరేనా-ఆధారిత కేటాయింపుతో, మొదటి కేటాయింపు ఒకే సిస్టమ్ కాల్‌ను ప్రేరేపిస్తుంది మరియు తదుపరి 9,999 కేటాయింపులు పాయింటర్ అంకగణితం మరియు లింక్డ్-లిస్ట్ ఆపరేషన్‌ల ద్వారా వినియోగదారు స్థలంలో పూర్తిగా సేవలు అందించబడతాయి - ఒక్కొక్కటి సుమారు 10-50 నానోసెకన్లు పడుతుంది. గణితం నిస్సందేహంగా ఉంది: ప్రీ-అలొకేషన్ మాగ్నిట్యూడ్ ఆర్డర్‌ల ద్వారా గెలుస్తుంది.

మీ మొదటి కేటాయింపులో మీరు చూసే 72 KB మెమరీని వృథా చేయలేదు — ఇది పనితీరు పెట్టుబడి. మీ ప్రోగ్రామ్ త్వరలో మరిన్ని కేటాయింపులు చేస్తుందని మరియు వాస్తవంగా ప్రతి వాస్తవిక దృష్టాంతంలో, ఆ పందెం చాలా చక్కగా చెల్లిస్తుందని కేటాయింపుదారుడు పందెం వేస్తున్నారు. ఆధునిక 64-బిట్ సిస్టమ్‌లలో ఉపయోగించని వర్చువల్ అడ్రస్ స్పేస్ ధర తప్పనిసరిగా సున్నా.

వర్చువల్ మెమరీ వర్సెస్ ఫిజికల్ మెమరీ: ఇది ఎందుకు పట్టింపు లేదు

ఈ ప్రవర్తనను మొదటిసారిగా ఎదుర్కొన్న డెవలపర్‌లలో ఒక సాధారణ ఆందోళన వనరు వ్యర్థం. నాకు 4 బైట్‌లు మాత్రమే అవసరమైతే, నా ప్రోగ్రామ్ 72 KBని ఎందుకు వినియోగిస్తోంది? క్లిష్టమైన అంతర్దృష్టి ఏమిటంటే వర్చువల్ మెమరీ అనేది భౌతిక మెమరీ కాదు. glibc ప్రోగ్రామ్ బ్రేక్‌ను 72 KB పొడిగించినప్పుడు, కెర్నల్ ప్రాసెస్ యొక్క వర్చువల్ మెమరీ మ్యాపింగ్‌లను అప్‌డేట్ చేస్తుంది, కానీ అది వెంటనే ఫిజికల్ RAMతో ఆ పేజీలను బ్యాక్ చేయదు. అసలు భౌతిక పేజీలు పేజీ లోపాలు ద్వారా డిమాండ్‌పై కేటాయించబడతాయి - మీ ప్రోగ్రామ్ నిర్దిష్ట చిరునామాకు వ్రాసినప్పుడు మాత్రమే కెర్నల్ దానికి మెమరీ యొక్క నిజమైన పేజీని కేటాయిస్తుంది.

దీని అర్థం మీ ప్రాసెస్ యొక్క వర్చువల్ పరిమాణం 72 KB పెరిగినప్పటికీ, దాని నివాసి సెట్ పరిమాణం (RSS) — నిజానికి వినియోగించిన ఫిజికల్ RAM మొత్తం — మీరు నిజంగా తాకిన పేజీల ద్వారా మాత్రమే పెరుగుతుంది. ఒకే క్రొత్త పూర్ణాంకానికి, అది సాధారణంగా ఒక 4 KB పేజీ, అలాగే అరేనా మెటాడేటా ఆక్రమించిన పేజీలు. మిగిలిన వర్చువల్ స్పేస్ అక్కడే ఉంది, ఉపయోగం కోసం సిద్ధంగా ఉంది, అడ్రస్ స్పేస్ తప్ప మరేమీ ఖర్చవదు — వీటిలో మీకు 64-బిట్ Linux సిస్టమ్‌లో 128 TB ఉంది.

ప్రొఫైలింగ్ మరియు ప్రొడక్షన్ అప్లికేషన్‌లను పర్యవేక్షించేటప్పుడు ఈ వ్యత్యాసం కీలకం. మీరు నిజమైన వనరుల వినియోగాన్ని ట్రాక్ చేయాల్సిన సాఫ్ట్‌వేర్‌ను రూపొందిస్తున్నట్లయితే — అది SaaS బ్యాకెండ్ అయినా, మైక్రోసర్వీస్ అయినా లేదా వ్యాపార కార్యకలాపాల కోసం Mewayz వంటి ప్లాట్‌ఫారమ్‌లపై నడిచే విశ్లేషణల పైప్‌లైన్ అయినా — మీరు ఎల్లప్పుడూ వర్చువల్ సైజు కంటే RSSని పర్యవేక్షించాలి. /proc/[pid]/smaps, valgrind --tool=massif, మరియు pmap వంటి సాధనాలు వర్చువల్ మెమరీ ఫిగర్‌లను తప్పుదారి పట్టించే బదులు మీకు ఖచ్చితమైన భౌతిక మెమరీ పాదముద్రలను అందించగలవు.

వేర్వేరు కేటాయింపుదారులు మొదటి కేటాయింపును ఎలా నిర్వహిస్తారు

72 KB ఫిగర్ glibc యొక్క ptmalloc2కి ప్రత్యేకంగా ఉంటుంది. ఇతర కేటాయింపుదారులు వేర్వేరు ట్రేడ్‌ఆఫ్‌లను చేస్తారు మరియు ప్రారంభ కేటాయింపు ఓవర్‌హెడ్ తదనుగుణంగా మారుతుంది. పనితీరు-సెన్సిటివ్ అప్లికేషన్‌ల కోసం కేటాయింపుదారుని ఎంచుకున్నప్పుడు ఈ తేడాలను అర్థం చేసుకోవడం విలువైనది.

• jemalloc (Facebook, FreeBSD ద్వారా ఉపయోగించబడుతుంది) — థ్రెడ్-లోకల్ కాష్‌లతో మరింత గ్రాన్యులర్ అరేనా నిర్మాణాన్ని ఉపయోగిస్తుంది. ప్రారంభ ఓవర్‌హెడ్ ఎక్కువగా ఉంటుంది (తరచుగా 200+ KB) కానీ తగ్గిన లాక్ వివాదం కారణంగా మెరుగైన బహుళ-థ్రెడ్ పనితీరును అందిస్తుంది.
• tcmalloc (Google యొక్క థ్రెడ్-కాషింగ్ Malloc) — దూకుడు ముందస్తు కేటాయింపుతో డిఫాల్ట్‌గా దాదాపు 2 MB ప్రతి-థ్రెడ్ కాష్‌ని కేటాయిస్తుంది. ప్రారంభ ఓవర్‌హెడ్ ఎక్కువగా ఉంటుంది, కానీ తదుపరి చిన్న కేటాయింపులు చాలా వేగంగా ఉంటాయి.
• musl libc's malloc — అన్ని కేటాయింపుల కోసం mmap ఆధారంగా చాలా సరళమైన డిజైన్‌ని ఉపయోగిస్తుంది. ప్రారంభ ఓవర్‌హెడ్ కనిష్టంగా ఉంటుంది (తరచుగా ఒక్కో కేటాయింపుకు 4 KB), కానీ తరచుగా సిస్టమ్ కాల్‌ల కారణంగా ఒక్కో కేటాయింపు ఖర్చు ఎక్కువగా ఉంటుంది.
• mimalloc (Microsoft) — 64 MB విభాగాలతో సెగ్మెంట్-ఆధారిత కేటాయింపును ఉపయోగిస్తుంది. మొదటి కేటాయింపు 64 MB వర్చువల్ రిజర్వేషన్‌ను (కనీస భౌతిక నిబద్ధతతో) ట్రిగ్గర్ చేస్తుంది, అసాధారణమైన స్థానికత మరియు నిర్గమాంశ కోసం ట్రేడింగ్ అడ్రస్ స్పేస్.

ఈ కేటాయింపుదారుల మధ్య ఎంపిక పూర్తిగా మీ పనిభారంపై ఆధారపడి ఉంటుంది. భారీ బహుళ-థ్రెడ్ కేటాయింపుతో ఎక్కువ కాలం నడుస్తున్న సర్వర్ అప్లికేషన్‌ల కోసం, jemalloc లేదా tcmalloc సాధారణంగా glibc యొక్క డిఫాల్ట్‌ను అధిగమిస్తుంది. మెమరీ-నియంత్రిత ఎంబెడెడ్ సిస్టమ్‌ల కోసం, తక్కువ త్రూపుట్ ఉన్నప్పటికీ musl యొక్క సరళమైన విధానం ఉత్తమం. చాలా సాధారణ-ప్రయోజన డెస్క్‌టాప్ మరియు సర్వర్ అప్లికేషన్‌ల కోసం, ptmalloc2 యొక్క 72 KB ప్రారంభ ఓవర్‌హెడ్ ట్యూనింగ్ లేకుండా బాగా పనిచేసే సహేతుకమైన డిఫాల్ట్‌ను సూచిస్తుంది.

ప్రారంభ కేటాయింపు ప్రవర్తనను ట్యూన్ చేయడం

డిఫాల్ట్ 72 KB ప్రారంభ ఓవర్‌హెడ్ మీ వినియోగ విషయంలో నిజంగా సమస్యాత్మకంగా ఉంటే - బహుశా మీరు వేలకొద్దీ స్వల్పకాలిక ప్రక్రియలను సృష్టిస్తూ ఉండవచ్చు, ప్రతి ఒక్కటి కొన్ని కేటాయింపులను మాత్రమే చేస్తుంది - glibc mallopt() మరియు MALLOC_ పర్యావరణం ద్వారా అనేక ట్యూనబుల్‌లను అందిస్తుంది.

M_TOP_PAD పరామితి కేటాయింపుదారు తక్షణం అవసరమైన దాని కంటే ఎంత అదనపు మెమరీని అభ్యర్థిస్తుందో నియంత్రిస్తుంది. mallopt(M_TOP_PAD, 0)తో దీన్ని 0కి సెట్ చేయడం వలన ప్రారంభ ఓవర్‌హెడ్ గణనీయంగా తగ్గి, అవసరమైన వాటిని మాత్రమే అభ్యర్థించమని కేటాయింపుదారుని చెబుతుంది. M_MMAP_THRESHOLD పరామితి అరేనాకు బదులుగా mmapని ఉపయోగించే కేటాయింపుల పరిమాణాన్ని నియంత్రిస్తుంది. OSకి ఫ్రీడ్ మెమరీ తిరిగి వచ్చినప్పుడు M_TRIM_THRESHOLD నియంత్రిస్తుంది. మరియు glibc 2.26 నుండి, glibc.malloc.tcache_count మరియు glibc.malloc.tcache_max ట్యూనబుల్‌లు థ్రెడ్ కాష్ ప్రవర్తనను నియంత్రించడానికి మిమ్మల్ని అనుమతిస్తాయి.

అయితే, ఒక జాగ్రత్త పదం: జాగ్రత్తగా బెంచ్‌మార్కింగ్ లేకుండా ఈ పారామితులను ట్యూన్ చేయడం దాదాపు ఎల్లప్పుడూ విషయాలను మరింత దిగజార్చుతుంది. విస్తృతమైన వాస్తవ-ప్రపంచ ప్రొఫైలింగ్ ఆధారంగా డిఫాల్ట్‌లు ఎంపిక చేయబడ్డాయి మరియు అవి ఎక్కువ భాగం పనిభారానికి మంచి ప్రదేశాన్ని సూచిస్తాయి. malloc ఓవర్‌హెడ్ అడ్డంకి అని ప్రొడక్షన్ ప్రొఫైలింగ్ నుండి మీకు బలమైన సాక్ష్యం లేకపోతే - మరియు మీరు మీ మార్పుల ప్రభావాన్ని కొలిచినట్లయితే - డిఫాల్ట్‌లను వదిలివేయండి. అలోకేటర్ యొక్క అకాల ఆప్టిమైజేషన్ అనేది యాక్ షేవింగ్ యొక్క ప్రత్యేకించి కృత్రిమమైన రూపం, ఇది అతితక్కువ ప్రయోజనం కోసం లెక్కలేనన్ని ఇంజనీరింగ్ గంటలను వినియోగించింది.

సిస్టమ్స్ ప్రోగ్రామింగ్ గురించి ఇది మనకు ఏమి బోధిస్తుంది

72 KB మొదటి-కేటాయింపు రహస్యం, దాని ప్రధానాంశం, అబ్‌స్ట్రాక్షన్ లేయర్‌ల గురించిన పాఠం. C++ మీకు కొత్త int 4 బైట్‌లను కేటాయిస్తుందనే భ్రమను అందిస్తుంది. భాషా ప్రమాణం అలా చెబుతుంది. మీ మానసిక నమూనా అలా చెప్పింది. కానీ మీ కోడ్ మరియు హార్డ్‌వేర్ మధ్య అధునాతన సిస్టమ్‌ల స్టాక్ ఉంటుంది — C++ రన్‌టైమ్, C లైబ్రరీ కేటాయింపుదారు, కెర్నల్ యొక్క వర్చువల్ మెమరీ సబ్‌సిస్టమ్ మరియు హార్డ్‌వేర్ యొక్క MMU మరియు TLB — ప్రతి దాని స్వంత ప్రవర్తనలు, ఆప్టిమైజేషన్‌లు మరియు ఓవర్‌హెడ్‌లను జోడిస్తుంది.

ఇది లోపం కాదు. ఇది సిస్టమ్స్ సాఫ్ట్‌వేర్ యొక్క మొత్తం పాయింట్. నిజమైన సమస్యను పరిష్కరించడానికి ప్రతి లేయర్ ఉంది: కేటాయింపుదారు ఉంది కాబట్టి మీరు ప్రతి కేటాయింపు కోసం సిస్టమ్ కాల్‌లు చేయవలసిన అవసరం లేదు. వర్చువల్ మెమరీ సిస్టమ్ ఉంది కాబట్టి మీరు ఫిజికల్ మెమరీని నేరుగా నిర్వహించాల్సిన అవసరం లేదు. పేజీ తప్పు హ్యాండ్లర్ ఉంది కాబట్టి మెమరీ సోమరితనం మరియు సమర్ధవంతంగా కట్టుబడి ఉంటుంది. ప్రతి లేయర్ పెద్ద మొత్తంలో పనితీరు మరియు సౌలభ్యం కోసం చిన్న మొత్తంలో పారదర్శకతను ట్రేడ్ చేస్తుంది.

అత్యంత విశ్వసనీయమైన, అత్యధిక పనితీరు గల సిస్టమ్‌లను రూపొందించే డెవలపర్‌లు ఈ లేయర్‌లను అర్థం చేసుకున్నవారు — వారు వాటి గురించి నిరంతరం ఆలోచించాల్సిన అవసరం ఉన్నందున కాదు, కానీ ఏదైనా ఊహించనిది జరిగినప్పుడు (నిగూఢమైన 72 KB కేటాయింపు వంటివి) ఎందుకు అర్థం చేసుకునే మానసిక నమూనాను కలిగి ఉంటారు. మీరు రియల్-టైమ్ ట్రేడింగ్ సిస్టమ్, గేమ్ ఇంజిన్ లేదా వేలాది మంది వినియోగదారులకు సేవలందించే వ్యాపార ప్లాట్‌ఫారమ్‌ను రూపొందిస్తున్నా, సిస్టమ్ స్థాయిలో మీ కోడ్ వాస్తవంగా ఏమి చేస్తుందనే దాని గురించి తర్కించే సామర్థ్యం సమర్థులైన డెవలపర్‌లను అసాధారణమైన వాటి నుండి వేరు చేస్తుంది. 72 KB ఒక బగ్ కాదు. ఇది మీ కేటాయింపుదారు తన పనిని అద్భుతంగా చేస్తున్నాడు.