పరిచయం
నేను ఈ నివేదికను మాస్కోలో జరిగిన గోఫర్‌కాన్ రష్యా 2019 సదస్సులో ఆంగ్లంలో మరియు నిజ్నీ నొవ్‌గోరోడ్‌లో జరిగిన సమావేశంలో రష్యన్‌లో అందించాను. మేము బిట్మ్యాప్ ఇండెక్స్ గురించి మాట్లాడుతున్నాము - బి-ట్రీ కంటే తక్కువ సాధారణం, కానీ తక్కువ ఆసక్తికరంగా ఉండదు. భాగస్వామ్యం సమావేశంలో ఆంగ్లంలో ప్రసంగాలు మరియు రష్యన్ భాషలో టెక్స్ట్ ట్రాన్స్క్రిప్ట్స్.
బిట్మ్యాప్ ఇండెక్స్ ఎలా పని చేస్తుందో, అది ఎప్పుడు మెరుగ్గా ఉందో, ఇతర ఇండెక్స్‌ల కంటే అధ్వాన్నంగా ఉన్నప్పుడు మరియు ఏ సందర్భాలలో వాటి కంటే గణనీయంగా వేగంగా ఉంటుందో మేము పరిశీలిస్తాము; ఏ ప్రసిద్ధ DBMSలు ఇప్పటికే బిట్మ్యాప్ సూచికలను కలిగి ఉన్నాయో చూద్దాం; గోలో మన స్వంతంగా వ్రాయడానికి ప్రయత్నిద్దాం. మరియు "డెజర్ట్ కోసం" మేము మా స్వంత సూపర్-ఫాస్ట్ స్పెషలైజ్డ్ డేటాబేస్‌ని సృష్టించడానికి రెడీమేడ్ లైబ్రరీలను ఉపయోగిస్తాము.
నా రచనలు మీకు ఉపయోగకరంగా మరియు ఆసక్తికరంగా ఉంటాయని నేను నిజంగా ఆశిస్తున్నాను. వెళ్ళండి!
పరిచయం
అందరికి వందనాలు! సాయంత్రం ఆరు అయ్యింది, అందరం బాగా అలసిపోయాము. బోరింగ్ డేటాబేస్ ఇండెక్స్ సిద్ధాంతం గురించి మాట్లాడటానికి గొప్ప సమయం, సరియైనదా? చింతించకండి, నేను ఇక్కడ మరియు అక్కడక్కడ సోర్స్ కోడ్ యొక్క రెండు లైన్లను కలిగి ఉంటాను. 🙂
అన్ని జోకులను పక్కన పెడితే, నివేదిక పూర్తి సమాచారంతో నిండి ఉంది మరియు మాకు ఎక్కువ సమయం లేదు. కాబట్టి ప్రారంభిద్దాం.
ఈ రోజు నేను ఈ క్రింది వాటి గురించి మాట్లాడతాను:
- సూచికలు ఏమిటి;
- బిట్మ్యాప్ ఇండెక్స్ అంటే ఏమిటి;
- ఇది ఎక్కడ ఉపయోగించబడుతుంది మరియు ఎక్కడ ఉపయోగించబడదు మరియు ఎందుకు;
- గోలో సాధారణ అమలు మరియు కంపైలర్‌తో కొంచెం పోరాటం;
- గో అసెంబ్లర్‌లో కొంచెం తక్కువ సులభం, కానీ చాలా ఎక్కువ ఉత్పాదక అమలు;
- బిట్మ్యాప్ సూచికల "సమస్యలు";
- ఇప్పటికే ఉన్న అమలులు.
కాబట్టి సూచికలు ఏమిటి?
సూచిక అనేది మేము ప్రధాన డేటాతో పాటుగా నిర్వహించే మరియు అప్‌డేట్ చేసే ప్రత్యేక డేటా నిర్మాణం. శోధనను వేగవంతం చేయడానికి ఇది ఉపయోగించబడుతుంది. సూచికలు లేకుండా, శోధించడం అనేది డేటాను పూర్తిగా (పూర్తి స్కాన్ అని పిలవబడే ప్రక్రియ) ద్వారా చూడవలసి ఉంటుంది మరియు ఈ ప్రక్రియ సరళ అల్గారిథమిక్ సంక్లిష్టతను కలిగి ఉంటుంది. కానీ డేటాబేస్‌లు సాధారణంగా భారీ మొత్తంలో డేటాను కలిగి ఉంటాయి మరియు సరళ సంక్లిష్టత చాలా నెమ్మదిగా ఉంటుంది. ఆదర్శవంతంగా, మేము లాగరిథమిక్ లేదా స్థిరమైనదాన్ని పొందుతాము.
ఇది చాలా క్లిష్టమైన అంశం, ఇది సూక్ష్మబేధాలు మరియు ట్రేడ్-ఆఫ్‌లతో నిండి ఉంది, అయితే దశాబ్దాల డేటాబేస్ అభివృద్ధి మరియు పరిశోధనలను చూసిన తర్వాత, డేటాబేస్ సూచికలను రూపొందించడానికి విస్తృతంగా ఉపయోగించే కొన్ని విధానాలు మాత్రమే ఉన్నాయని నేను చెప్పడానికి సిద్ధంగా ఉన్నాను.
శోధన స్థలాన్ని క్రమానుగతంగా తగ్గించడం, శోధన స్థలాన్ని చిన్న భాగాలుగా విభజించడం మొదటి విధానం.
మేము సాధారణంగా వివిధ రకాల చెట్లను ఉపయోగించి దీన్ని చేస్తాము. ఒక ఉదాహరణ మీ గదిలోని మెటీరియల్‌ల యొక్క పెద్ద పెట్టె, ఇందులో వివిధ అంశాలలో విభజించబడిన చిన్న మెటీరియల్ బాక్స్‌లు ఉంటాయి. మీకు మెటీరియల్స్ కావాలంటే, మీరు వాటిని "కుకీలు" అని చెప్పే బాక్స్‌లో కాకుండా "మెటీరియల్స్" అని చెప్పే బాక్స్‌లో వెతకవచ్చు, సరియైనదా?
కావలసిన మూలకం లేదా మూలకాల సమూహాన్ని వెంటనే ఎంచుకోవడం రెండవ విధానం. మేము దీన్ని హాష్ మ్యాప్‌లు లేదా రివర్స్ ఇండెక్స్‌లలో చేస్తాము. హాష్ మ్యాప్‌లను ఉపయోగించడం మునుపటి ఉదాహరణకి చాలా పోలి ఉంటుంది, కానీ బాక్స్‌ల పెట్టెకి బదులుగా, మీ క్లోసెట్‌లో చివరి వస్తువులతో కూడిన చిన్న పెట్టెల సమూహాన్ని కలిగి ఉంటారు.
మూడవ విధానం శోధన అవసరాన్ని తొలగించడం. మేము బ్లూమ్ ఫిల్టర్‌లు లేదా కోకిల ఫిల్టర్‌లను ఉపయోగించి దీన్ని చేస్తాము. మొదటివి తక్షణమే సమాధానం ఇస్తాయి, శోధించకుండా మిమ్మల్ని కాపాడతాయి.
ఆధునిక హార్డ్‌వేర్ మనకు ఇచ్చే శక్తిని పూర్తిగా ఉపయోగించడం చివరి విధానం. బిట్మ్యాప్ ఇండెక్స్‌లలో మనం చేసేది ఇదే. అవును, వాటిని ఉపయోగిస్తున్నప్పుడు మేము కొన్నిసార్లు మొత్తం సూచిక ద్వారా వెళ్ళవలసి ఉంటుంది, కానీ మేము దానిని చాలా సమర్థవంతంగా చేస్తాము.
నేను చెప్పినట్లుగా, డేటాబేస్ ఇండెక్స్‌ల అంశం చాలా విస్తృతమైనది మరియు రాజీలతో నిండి ఉంది. దీని అర్థం కొన్నిసార్లు మనం ఒకే సమయంలో అనేక విధానాలను ఉపయోగించవచ్చు: మేము శోధనను మరింత వేగవంతం చేయవలసి వస్తే లేదా మేము అన్ని శోధన రకాలను కవర్ చేయవలసి వస్తే.
ఈ రోజు నేను వీటిలో అతి తక్కువగా తెలిసిన విధానం గురించి మాట్లాడతాను - బిట్మ్యాప్ సూచికలు.
ఈ అంశంపై మాట్లాడటానికి నేను ఎవరు?
నేను బడూలో టీమ్ లీడ్‌గా పని చేస్తున్నాను (బహుశా మా ఇతర ఉత్పత్తి అయిన బంబుల్‌తో మీకు బాగా తెలిసి ఉండవచ్చు). మేము ఇప్పటికే ప్రపంచవ్యాప్తంగా 400 మిలియన్ల కంటే ఎక్కువ మంది వినియోగదారులను కలిగి ఉన్నాము మరియు వారికి ఉత్తమమైన సరిపోలికను ఎంచుకునే అనేక ఫీచర్లు ఉన్నాయి. మేము బిట్మ్యాప్ సూచికలతో సహా అనుకూల సేవలను ఉపయోగించి దీన్ని చేస్తాము.
కాబట్టి బిట్మ్యాప్ ఇండెక్స్ అంటే ఏమిటి?
బిట్మ్యాప్ సూచికలు, పేరు సూచించినట్లుగా, శోధన సూచికను అమలు చేయడానికి బిట్‌మ్యాప్‌లు లేదా బిట్‌సెట్‌లను ఉపయోగిస్తాయి. పక్షి దృష్టి నుండి, ఈ సూచికలో ఏదైనా ఎంటిటీలు (వ్యక్తులు వంటివి) మరియు వాటి లక్షణాలు లేదా పారామితులు (వయస్సు, కంటి రంగు మొదలైనవి) సూచించే ఒకటి లేదా అంతకంటే ఎక్కువ బిట్‌మ్యాప్‌లు మరియు బిట్ ఆపరేషన్‌లను ఉపయోగించే అల్గారిథమ్ (AND, OR, NOT) ఉంటాయి. ) శోధన ప్రశ్నకు సమాధానం ఇవ్వడానికి.
బిట్మ్యాప్ సూచికలు చాలా తక్కువ కార్డినాలిటీ కాలమ్‌లలో ("కంటి రంగు" లేదా "వైవాహిక స్థితి" వర్సెస్ "సిటీ సెంటర్ నుండి దూరం" వంటి వాటిపై ఆలోచించండి) శోధనలు ఉన్న సందర్భాలకు బాగా సరిపోతాయని మరియు చాలా పనితీరును కలిగి ఉంటాయని మాకు చెప్పబడింది. కానీ అవి అధిక కార్డినాలిటీ కాలమ్‌లకు కూడా బాగా పనిచేస్తాయని నేను తర్వాత చూపిస్తాను.
బిట్మ్యాప్ ఇండెక్స్ యొక్క సరళమైన ఉదాహరణను చూద్దాం.
ఇలాంటి బైనరీ లక్షణాలతో మాస్కో రెస్టారెంట్‌ల జాబితాను కలిగి ఉన్నారని ఊహించండి:
- మెట్రో సమీపంలో;
- ప్రైవేట్ పార్కింగ్ ఉంది;
- వరండా ఉంది (టెర్రస్ ఉంది);
- మీరు పట్టికను రిజర్వ్ చేయవచ్చు (రిజర్వేషన్లను అంగీకరిస్తుంది);
- శాఖాహారులకు అనుకూలం (శాకాహారి స్నేహపూర్వక);
- ఖరీదైన (ఖరీదైన).
ప్రతి రెస్టారెంట్‌కు 0 నుండి ప్రారంభమయ్యే సీక్వెన్స్ నంబర్‌ని ఇద్దాం మరియు 6 బిట్‌మ్యాప్‌ల కోసం మెమరీని కేటాయించండి (ప్రతి లక్షణానికి ఒకటి). రెస్టారెంట్‌లో ఈ ఆస్తి ఉందా లేదా అనేదానిపై ఆధారపడి మేము ఈ బిట్‌మ్యాప్‌లను నింపుతాము. రెస్టారెంట్ 4లో వరండా ఉంటే, "వరండా ఉంది" బిట్‌మ్యాప్‌లోని బిట్ నంబర్ 4 1కి సెట్ చేయబడుతుంది (వరండా లేకపోతే, 0కి).
ఇప్పుడు మనకు సాధ్యమయ్యే సులభమైన బిట్మ్యాప్ ఇండెక్స్ ఉంది మరియు ఇలాంటి ప్రశ్నలకు సమాధానమివ్వడానికి మేము దానిని ఉపయోగించవచ్చు:
- "నాకు శాఖాహారానికి అనుకూలమైన రెస్టారెంట్లను చూపించు";
- "మీరు టేబుల్‌ని రిజర్వ్ చేయగల వరండాతో చవకైన రెస్టారెంట్లను నాకు చూపించు."
ఎలా? చూద్దాం. మొదటి అభ్యర్థన చాలా సులభం. మనం చేయాల్సిందల్లా “శాఖాహారం స్నేహపూర్వక” బిట్‌మ్యాప్‌ని తీసుకొని దానిని బిట్స్ బహిర్గతమయ్యే రెస్టారెంట్‌ల జాబితాగా మార్చడం.
రెండవ అభ్యర్థన కొంచెం క్లిష్టంగా ఉంటుంది. మేము చవకైన రెస్టారెంట్‌ల జాబితాను పొందడానికి "ఖరీదైన" బిట్‌మ్యాప్‌లో NOT బిట్‌మ్యాప్‌ని ఉపయోగించాలి, ఆపై "నేను టేబుల్‌ని బుక్ చేయవచ్చా" బిట్‌మ్యాప్‌తో మరియు ఫలితంగా "వెరాండా ఉంది" బిట్‌మ్యాప్‌తో. ఫలితంగా వచ్చే బిట్మ్యాప్ మా అన్ని ప్రమాణాలకు అనుగుణంగా ఉండే సంస్థల జాబితాను కలిగి ఉంటుంది. ఈ ఉదాహరణలో, ఇది యునోస్ట్ రెస్టారెంట్ మాత్రమే.
ఇందులో చాలా సిద్ధాంతం ఉంది, కానీ చింతించకండి, మేము కోడ్‌ని అతి త్వరలో చూస్తాము.
బిట్మ్యాప్ సూచికలు ఎక్కడ ఉపయోగించబడతాయి?
మీరు బిట్మ్యాప్ సూచికలను గూగుల్ చేస్తే, 90% సమాధానాలు ఒక విధంగా లేదా మరొక విధంగా Oracle DBకి సంబంధించినవిగా ఉంటాయి. కానీ ఇతర DBMSలు బహుశా అలాంటి మంచి విషయానికి మద్దతు ఇస్తాయి, సరియైనదా? నిజంగా కాదు.
ప్రధాన అనుమానితుల జాబితాను చూద్దాం.
MySQL ఇంకా బిట్మ్యాప్ సూచికలకు మద్దతు ఇవ్వదు, అయితే ఈ ఎంపికను జోడించమని సూచించే ప్రతిపాదన ఉంది ().
PostgreSQL బిట్మ్యాప్ సూచికలకు మద్దతు ఇవ్వదు, కానీ అనేక ఇతర సూచికలలో శోధన ఫలితాలను కలపడానికి సాధారణ బిట్‌మ్యాప్‌లు మరియు బిట్ ఆపరేషన్‌లను ఉపయోగిస్తుంది.
Tarantool బిట్‌సెట్ సూచికలను కలిగి ఉంది మరియు వాటిపై సాధారణ శోధనలకు మద్దతు ఇస్తుంది.
Redis సాధారణ బిట్‌ఫీల్డ్‌లను కలిగి ఉంది) వాటి కోసం శోధించే సామర్థ్యం లేకుండా.
MongoDB ఇంకా బిట్మ్యాప్ సూచికలకు మద్దతు ఇవ్వదు, అయితే ఈ ఎంపికను జోడించమని సూచించే ప్రతిపాదన కూడా ఉంది.
సాగే శోధన అంతర్గతంగా బిట్‌మ్యాప్‌లను ఉపయోగిస్తుంది).
- కానీ మా ఇంట్లో కొత్త పొరుగువాడు కనిపించాడు: పిలోసా. ఇది గోలో వ్రాయబడిన కొత్త నాన్-రిలేషనల్ డేటాబేస్. ఇది బిట్మ్యాప్ సూచికలను మాత్రమే కలిగి ఉంటుంది మరియు వాటిపై ప్రతిదానిని ఆధారపరుస్తుంది. మేము దాని గురించి కొంచెం తరువాత మాట్లాడుతాము.
గోలో అమలు
కానీ బిట్మ్యాప్ సూచికలు ఎందుకు చాలా అరుదుగా ఉపయోగించబడుతున్నాయి? ఈ ప్రశ్నకు సమాధానమిచ్చే ముందు, గోలో చాలా సులభమైన బిట్మ్యాప్ సూచికను ఎలా అమలు చేయాలో నేను మీకు చూపించాలనుకుంటున్నాను.
బిట్‌మ్యాప్‌లు తప్పనిసరిగా కేవలం డేటా ముక్కలు. గోలో, దీని కోసం బైట్ స్లైస్‌లను ఉపయోగిస్తాము.
మేము ఒక రెస్టారెంట్ లక్షణం కోసం ఒక బిట్‌మ్యాప్‌ని కలిగి ఉన్నాము మరియు బిట్‌మ్యాప్‌లోని ప్రతి బిట్ నిర్దిష్ట రెస్టారెంట్‌కు ఈ ఆస్తి ఉందా లేదా అని సూచిస్తుంది.
మాకు రెండు సహాయక విధులు అవసరం. యాదృచ్ఛిక డేటాతో మా బిట్‌మ్యాప్‌లను పూరించడానికి ఒకటి ఉపయోగించబడుతుంది. యాదృచ్ఛికంగా, కానీ ఒక నిర్దిష్ట సంభావ్యతతో రెస్టారెంట్ ప్రతి ఆస్తిని కలిగి ఉంటుంది. ఉదాహరణకు, మీరు టేబుల్‌ను రిజర్వ్ చేయలేని మాస్కోలో చాలా తక్కువ రెస్టారెంట్లు ఉన్నాయని నేను నమ్ముతున్నాను మరియు దాదాపు 20% సంస్థలు శాఖాహారులకు అనుకూలంగా ఉన్నాయని నాకు అనిపిస్తోంది.
రెండవ ఫంక్షన్ బిట్‌మ్యాప్‌ను రెస్టారెంట్‌ల జాబితాగా మారుస్తుంది.
“డాబా ఉన్న మరియు రిజర్వేషన్‌లు చేయగల చవకైన రెస్టారెంట్లను నాకు చూపించు” అనే ప్రశ్నకు సమాధానం ఇవ్వడానికి మాకు రెండు బిట్ ఆపరేషన్లు అవసరం: NOT మరియు AND.
మరింత సంక్లిష్టమైన మరియు నాట్ ఆపరేటర్‌ని ఉపయోగించడం ద్వారా మన కోడ్‌ని కొద్దిగా సరళీకృతం చేయవచ్చు.
ఈ ప్రతి ఆపరేషన్‌కు మాకు ఫంక్షన్‌లు ఉన్నాయి. రెండూ స్లైస్‌ల ద్వారా వెళ్లి, ఒక్కొక్కటి నుండి సంబంధిత మూలకాలను తీసుకొని, వాటిని ఒక బిట్ ఆపరేషన్‌తో కలపండి మరియు ఫలితాన్ని ఫలిత స్లైస్‌లో ఉంచండి.
మరియు ఇప్పుడు శోధన ప్రశ్నకు సమాధానం ఇవ్వడానికి మన బిట్‌మ్యాప్‌లు మరియు ఫంక్షన్లను ఉపయోగించవచ్చు.
ఫంక్షన్‌లు చాలా సరళంగా ఉన్నప్పటికీ, ఫంక్షన్‌కు పిలిచిన ప్రతిసారీ కొత్త స్లైస్‌ని తిరిగి ఇవ్వకుండా చాలా డబ్బు ఆదా చేసుకున్నప్పటికీ పనితీరు అంత ఎక్కువగా లేదు.
pprofతో కొంత ప్రొఫైలింగ్ చేసిన తర్వాత, గో కంపైలర్‌లో చాలా సులభమైన కానీ చాలా ముఖ్యమైన ఆప్టిమైజేషన్ లేదు: ఫంక్షన్ ఇన్‌లైనింగ్.
వాస్తవం ఏమిటంటే, గో కంపైలర్ స్లైస్‌ల గుండా వెళ్ళే లూప్‌లకు చాలా భయపడుతుంది మరియు అటువంటి లూప్‌లను కలిగి ఉన్న ఇన్‌లైన్ ఫంక్షన్లను వర్గీకరణపరంగా నిరాకరిస్తుంది.
కానీ నేను భయపడను మరియు పాత రోజుల్లో లాగా లూప్‌కు బదులుగా గోటోని ఉపయోగించడం ద్వారా కంపైలర్‌ను మోసం చేయగలను.
మరియు, మీరు చూడగలిగినట్లుగా, ఇప్పుడు కంపైలర్ మా ఫంక్షన్‌ను సంతోషంగా ఇన్‌లైన్ చేస్తుంది! ఫలితంగా, మేము దాదాపు 2 మైక్రోసెకన్లను ఆదా చేయగలుగుతాము. చెడ్డది కాదు!
మీరు అసెంబ్లీ అవుట్‌పుట్‌ని నిశితంగా పరిశీలిస్తే రెండవ అడ్డంకిని సులభంగా చూడవచ్చు. కంపైలర్ మా హాటెస్ట్ లూప్ లోపల స్లైస్ బౌండరీ చెక్‌ను జోడించింది. వాస్తవం ఏమిటంటే గో సురక్షితమైన భాష, కంపైలర్ నా మూడు వాదనలు (మూడు ముక్కలు) వేర్వేరు పరిమాణాలలో ఉన్నాయని భయపడుతున్నారు. అన్ని తరువాత, అప్పుడు ఒక అని పిలవబడే బఫర్ ఓవర్ఫ్లో సంభవించే ఒక సైద్ధాంతిక అవకాశం ఉంటుంది.
అన్ని స్లైస్‌లు ఒకే పరిమాణంలో ఉన్నాయని చూపడం ద్వారా కంపైలర్‌కు భరోసా ఇద్దాం. మేము మా ఫంక్షన్ ప్రారంభంలో ఒక సాధారణ తనిఖీని జోడించడం ద్వారా దీన్ని చేయవచ్చు.
దీన్ని చూసి, కంపైలర్ సంతోషంగా చెక్‌ను దాటవేస్తాడు మరియు మేము మరో 500 నానోసెకన్లను ఆదా చేస్తాము.
పెద్ద బుట్టలు
సరే, మేము మా సాధారణ అమలు నుండి కొంత పనితీరును తగ్గించగలిగాము, అయితే ఈ ఫలితం ప్రస్తుత హార్డ్‌వేర్‌తో సాధ్యమయ్యే దానికంటే చాలా ఘోరంగా ఉంది.
మేము చేసేదంతా ప్రాథమిక బిట్ ఆపరేషన్లు మరియు మా ప్రాసెసర్లు వాటిని చాలా సమర్థవంతంగా నిర్వహిస్తాయి. కానీ, దురదృష్టవశాత్తు, మేము మా ప్రాసెసర్‌ను చాలా చిన్న పని ముక్కలతో "ఫీడ్" చేస్తాము. మా విధులు బైట్-బైట్ ఆధారంగా కార్యకలాపాలను నిర్వహిస్తాయి. UInt8 స్లైస్‌లను ఉపయోగించి 64-బైట్ భాగాలతో పని చేయడానికి మేము చాలా సులభంగా మా కోడ్‌ను సర్దుబాటు చేయవచ్చు.
మీరు గమనిస్తే, ఈ చిన్న మార్పు బ్యాచ్ పరిమాణాన్ని ఎనిమిది రెట్లు పెంచడం ద్వారా మా ప్రోగ్రామ్‌ను ఎనిమిది రెట్లు వేగవంతం చేసింది. లాభం సరళంగా చెప్పవచ్చు.
అసెంబ్లర్‌లో అమలు
అయితే ఇది అంతం కాదు. మా ప్రాసెసర్లు 16, 32 మరియు 64 బైట్‌ల భాగాలతో పని చేయగలవు. ఇటువంటి "విస్తృత" కార్యకలాపాలను సింగిల్ ఇన్స్ట్రక్షన్ మల్టిపుల్ డేటా (SIMD; ఒక సూచన, అనేక డేటా) అని పిలుస్తారు మరియు అటువంటి కార్యకలాపాలను ఉపయోగించేలా కోడ్‌ను మార్చే ప్రక్రియను వెక్టరైజేషన్ అంటారు.
దురదృష్టవశాత్తూ, గో కంపైలర్ వెక్టరైజేషన్‌లో అద్భుతమైనది కాదు. ప్రస్తుతం, గో కోడ్‌ను వెక్టరైజ్ చేయడానికి ఏకైక మార్గం గో అసెంబ్లర్‌ని ఉపయోగించి ఈ కార్యకలాపాలను మాన్యువల్‌గా తీసుకోవడం మరియు ఉంచడం.
గో అసెంబ్లర్ ఒక వింత మృగం. అసెంబ్లీ లాంగ్వేజ్ అనేది మీరు వ్రాస్తున్న కంప్యూటర్ ఆర్కిటెక్చర్‌తో ఎక్కువగా ముడిపడి ఉందని మీకు తెలిసి ఉండవచ్చు, కానీ గోలో అలా కాదు. గో అసెంబ్లర్ అనేది IRL (ఇంటర్మీడియట్ ప్రాతినిధ్య భాష) లేదా ఇంటర్మీడియట్ భాష లాంటిది: ఇది ఆచరణాత్మకంగా ప్లాట్‌ఫారమ్ స్వతంత్రంగా ఉంటుంది. రాబ్ పైక్ అద్భుతమైన ప్రదర్శన ఇచ్చాడు చాలా సంవత్సరాల క్రితం డెన్వర్‌లోని గోఫర్‌కాన్‌లో ఈ అంశంపై.
అదనంగా, Go అసాధారణమైన ప్లాన్ 9 ఆకృతిని ఉపయోగిస్తుంది, ఇది సాధారణంగా ఆమోదించబడిన AT&T మరియు Intel ఫార్మాట్‌ల నుండి భిన్నంగా ఉంటుంది.
గో అసెంబ్లర్‌ని చేతితో రాయడం చాలా సరదాగా ఉండదని చెప్పడం సురక్షితం.
కానీ, అదృష్టవశాత్తూ, గో అసెంబ్లర్‌ని వ్రాయడంలో మాకు సహాయపడే రెండు ఉన్నత-స్థాయి సాధనాలు ఇప్పటికే ఉన్నాయి: PeachPy మరియు avo. రెండు యుటిలిటీలు వరుసగా పైథాన్ మరియు గోలో వ్రాయబడిన ఉన్నత-స్థాయి కోడ్ నుండి గో అసెంబ్లర్‌ను ఉత్పత్తి చేస్తాయి.
ఈ యుటిలిటీలు రిజిస్టర్ కేటాయింపు, లూప్‌లు రాయడం వంటి వాటిని సులభతరం చేస్తాయి మరియు సాధారణంగా గోలో అసెంబ్లీ ప్రోగ్రామింగ్ ప్రపంచంలోకి ప్రవేశించే ప్రక్రియను సులభతరం చేస్తాయి.
మేము avoని ఉపయోగిస్తాము, కాబట్టి మా ప్రోగ్రామ్‌లు దాదాపు సాధారణ Go ప్రోగ్రామ్‌లుగా ఉంటాయి.
ఏవో ప్రోగ్రామ్ యొక్క సరళమైన ఉదాహరణ ఇలా ఉంటుంది. మనకు ప్రధాన() ఫంక్షన్ ఉంది, ఇది దానిలోనే Add() ఫంక్షన్‌ని నిర్వచిస్తుంది, దీని అర్థం రెండు సంఖ్యలను జోడించడం. పేరు ద్వారా పారామితులను పొందడానికి మరియు ఉచిత మరియు తగిన ప్రాసెసర్ రిజిస్టర్‌లలో ఒకదాన్ని పొందడానికి ఇక్కడ సహాయక విధులు ఉన్నాయి. ADDQలో చూసినట్లుగా, ప్రతి ప్రాసెసర్ ఆపరేషన్ avoలో సంబంధిత ఫంక్షన్‌ను కలిగి ఉంటుంది. చివరగా, ఫలిత విలువను నిల్వ చేయడానికి మేము సహాయక ఫంక్షన్‌ని చూస్తాము.
గో జనరేట్‌కి కాల్ చేయడం ద్వారా, మేము ప్రోగ్రామ్‌ను avoలో అమలు చేస్తాము మరియు ఫలితంగా, రెండు ఫైల్‌లు రూపొందించబడతాయి:
- గో అసెంబ్లర్‌లో ఫలిత కోడ్‌తో add.s;
- రెండు ప్రపంచాలను కనెక్ట్ చేయడానికి ఫంక్షన్ హెడర్‌లతో stub.go: వెళ్ళండి మరియు అసెంబ్లర్.
ఇప్పుడు మనం ఏవో ఏం చేస్తుందో మరియు ఎలా చేస్తుందో చూసాము, మన ఫంక్షన్లను చూద్దాం. నేను ఫంక్షన్ల యొక్క స్కేలార్ మరియు వెక్టర్ (SIMD) వెర్షన్‌లను అమలు చేసాను.
ముందుగా స్కేలార్ వెర్షన్‌లను చూద్దాం.
మునుపటి ఉదాహరణలో వలె, మేము ఉచిత మరియు చెల్లుబాటు అయ్యే సాధారణ ప్రయోజన రిజిస్టర్ కోసం అడుగుతున్నాము, మేము వాదనల కోసం ఆఫ్‌సెట్‌లు మరియు పరిమాణాలను లెక్కించాల్సిన అవసరం లేదు. avo మన కోసం ఇదంతా చేస్తుంది.
మేము పనితీరును మెరుగుపరచడానికి మరియు గో కంపైలర్‌ను మోసగించడానికి లేబుల్‌లు మరియు గోటో (లేదా జంప్‌లు) ఉపయోగించాము, కానీ ఇప్పుడు మేము దీన్ని మొదటి నుండి చేస్తున్నాము. పాయింట్ ఏమిటంటే చక్రాలు ఒక ఉన్నత-స్థాయి భావన. అసెంబ్లర్‌లో, మనకు లేబుల్‌లు మరియు జంప్‌లు మాత్రమే ఉన్నాయి.
మిగిలిన కోడ్ ఇప్పటికే తెలిసిన మరియు అర్థమయ్యేలా ఉండాలి. మేము లేబుల్‌లు మరియు జంప్‌లతో కూడిన లూప్‌ను అనుకరిస్తాము, మా రెండు స్లైస్‌ల నుండి చిన్న డేటాను తీసుకొని, వాటిని ఒక బిట్ ఆపరేషన్‌తో (మరియు ఈ సందర్భంలో కాదు) మిళితం చేసి, ఆపై ఫలితాన్ని ఫలిత స్లైస్‌లో ఉంచుతాము. అన్నీ.
చివరి అసెంబ్లర్ కోడ్ ఇలా ఉంటుంది. మేము ఆఫ్‌సెట్‌లు మరియు పరిమాణాలను లెక్కించాల్సిన అవసరం లేదు (ఆకుపచ్చ రంగులో హైలైట్ చేయబడింది) లేదా ఉపయోగించిన రిజిస్టర్లను ట్రాక్ చేయాల్సిన అవసరం లేదు (ఎరుపు రంగులో హైలైట్ చేయబడింది).
అసెంబ్లీ లాంగ్వేజ్ అమలు పనితీరును గోలో అత్యుత్తమ అమలు పనితీరుతో పోల్చి చూస్తే, మనం అదే విధంగా ఉన్నట్లు చూస్తాము. మరియు ఇది ఊహించబడింది. అన్నింటికంటే, మేము ప్రత్యేకంగా ఏమీ చేయలేదు - గో కంపైలర్ ఏమి చేస్తుందో మేము పునరుత్పత్తి చేసాము.
దురదృష్టవశాత్తూ, అసెంబ్లీ భాషలో వ్రాసిన మా ఫంక్షన్లను ఇన్‌లైన్ చేయమని మేము కంపైలర్‌ను బలవంతం చేయలేము. Go కంపైలర్‌లో ప్రస్తుతం అలాంటి ఫీచర్ లేదు, అయితే దీన్ని జోడించమని చాలా కాలంగా అభ్యర్థన ఉంది.
అందుకే అసెంబ్లీ భాషలో చిన్న ఫంక్షన్ల నుండి ఎటువంటి ప్రయోజనం పొందడం అసాధ్యం. మనం పెద్ద ఫంక్షన్లను వ్రాయాలి లేదా కొత్త గణిత/బిట్స్ ప్యాకేజీని ఉపయోగించాలి లేదా అసెంబ్లర్ భాషను దాటవేయాలి.
ఇప్పుడు మన ఫంక్షన్ల వెక్టార్ వెర్షన్‌లను చూద్దాం.
ఈ ఉదాహరణ కోసం, నేను AVX2ని ఉపయోగించాలని నిర్ణయించుకున్నాను, కాబట్టి మేము 32-బైట్ భాగాలపై పనిచేసే కార్యకలాపాలను ఉపయోగిస్తాము. కోడ్ యొక్క నిర్మాణం స్కేలార్ సంస్కరణకు చాలా పోలి ఉంటుంది: పారామితులను లోడ్ చేయడం, ఉచిత భాగస్వామ్య రిజిస్టర్ కోసం అడగడం మొదలైనవి.
ఒక ఆవిష్కరణ ఏమిటంటే, విస్తృత వెక్టార్ కార్యకలాపాలు ప్రత్యేక విస్తృత రిజిస్టర్లను ఉపయోగిస్తాయి. 32-బైట్ భాగాల విషయంలో, ఇవి Y తో ప్రిఫిక్స్ చేయబడిన రిజిస్టర్‌లు. అందుకే మీరు కోడ్‌లో YMM() ఫంక్షన్‌ని చూస్తారు. నేను 512-బిట్ భాగాలతో AVX-64ని ఉపయోగిస్తుంటే, ఉపసర్గ Z అవుతుంది.
రెండవ ఆవిష్కరణ ఏమిటంటే, నేను లూప్ అన్‌రోలింగ్ అనే ఆప్టిమైజేషన్‌ని ఉపయోగించాలని నిర్ణయించుకున్నాను, అంటే లూప్ ప్రారంభానికి వెళ్లే ముందు ఎనిమిది లూప్ ఆపరేషన్‌లను మాన్యువల్‌గా చేయడం. ఈ ఆప్టిమైజేషన్ కోడ్‌లోని శాఖల సంఖ్యను తగ్గిస్తుంది మరియు అందుబాటులో ఉన్న ఉచిత రిజిస్టర్‌ల సంఖ్యతో పరిమితం చేయబడింది.
బాగా, పనితీరు గురించి ఏమిటి? ఆమె అందంగా ఉంది! ఉత్తమ Go సొల్యూషన్‌తో పోలిస్తే మేము దాదాపు ఏడు రెట్లు వేగాన్ని సాధించాము. ఆకట్టుకుంది, సరియైనదా?
అయితే ప్రశ్న షెడ్యూలర్ కోసం AVX-512, ప్రీఫెచింగ్ లేదా JIT (ఇన్-టైమ్ కంపైలర్)ని ఉపయోగించడం ద్వారా ఈ అమలును కూడా వేగవంతం చేయవచ్చు. కానీ ఇది ఖచ్చితంగా ప్రత్యేక నివేదిక కోసం ఒక అంశం.
బిట్మ్యాప్ సూచికలతో సమస్యలు
ఇప్పుడు మనం గోలో బిట్మ్యాప్ ఇండెక్స్ యొక్క సరళమైన అమలును మరియు అసెంబ్లీ భాషలో మరింత ఉత్పాదకతను ఇప్పటికే పరిశీలించాము, బిట్మ్యాప్ సూచికలు ఎందుకు చాలా అరుదుగా ఉపయోగించబడుతున్నాయి అనే దాని గురించి చివరగా మాట్లాడుదాం.
పాత పేపర్‌లు బిట్మ్యాప్ సూచికలతో మూడు సమస్యలను సూచిస్తాయి, అయితే కొత్త పేపర్‌లు మరియు అవి ఇకపై సంబంధితంగా లేవని నేను వాదిస్తున్నాను. మేము ఈ సమస్యలలో ప్రతి ఒక్కటి లోతుగా డైవ్ చేయము, కానీ వాటిని ఉపరితలంగా చూస్తాము.
అధిక కార్డినాలిటీ సమస్య
కాబట్టి, బిట్మ్యాప్ సూచికలు తక్కువ కార్డినాలిటీ ఉన్న ఫీల్డ్‌లకు మాత్రమే సరిపోతాయని మాకు చెప్పబడింది, అంటే కొన్ని విలువలు (ఉదాహరణకు, లింగం లేదా కంటి రంగు) ఉన్నవి, మరియు కారణం అటువంటి ఫీల్డ్‌ల యొక్క సాధారణ ప్రాతినిధ్యం (ఒకటి బిట్ పర్ వాల్యూ) అధిక కార్డినాలిటీ విషయంలో, ఇది చాలా స్థలాన్ని తీసుకుంటుంది మరియు అంతేకాకుండా, ఈ బిట్మ్యాప్ సూచికలు పేలవంగా (అరుదుగా) నింపబడతాయి.
కొన్నిసార్లు మనం సంఖ్యలను సూచించడానికి ఉపయోగించే ప్రామాణికం వంటి విభిన్న ప్రాతినిధ్యాన్ని ఉపయోగించవచ్చు. కానీ కుదింపు అల్గారిథమ్‌ల ఆగమనం ప్రతిదీ మార్చింది. గత దశాబ్దాలుగా, శాస్త్రవేత్తలు మరియు పరిశోధకులు బిట్‌మ్యాప్‌ల కోసం పెద్ద సంఖ్యలో కంప్రెషన్ అల్గారిథమ్‌లతో ముందుకు వచ్చారు. బిట్ ఆపరేషన్‌లను నిర్వహించడానికి బిట్‌మ్యాప్‌లను విడదీయవలసిన అవసరం లేదు - మేము బిట్ ఆపరేషన్‌లను నేరుగా కంప్రెస్డ్ బిట్‌మ్యాప్‌లపై చేయవచ్చు.
ఇటీవల, గర్జించే బిట్‌మ్యాప్‌ల వంటి హైబ్రిడ్ విధానాలు కనిపించడం ప్రారంభించాయి. వారు బిట్‌మ్యాప్‌ల కోసం ఏకకాలంలో మూడు విభిన్న ప్రాతినిధ్యాలను ఉపయోగిస్తారు - బిట్‌మ్యాప్‌లు, శ్రేణులు మరియు బిట్ రన్‌లు అని పిలవబడేవి - మరియు పనితీరును పెంచడానికి మరియు మెమరీ వినియోగాన్ని తగ్గించడానికి వాటి మధ్య సమతుల్యతను కలిగి ఉంటాయి.
మీరు అత్యంత జనాదరణ పొందిన అప్లికేషన్‌లలో రోరింగ్ బిట్‌మ్యాప్‌లను కనుగొనవచ్చు. గో కోసం మూడు కంటే ఎక్కువ ఇంప్లిమెంటేషన్‌లతో సహా అనేక రకాల ప్రోగ్రామింగ్ భాషల కోసం ఇప్పటికే భారీ సంఖ్యలో అమలులు ఉన్నాయి.
అధిక కార్డినాలిటీతో వ్యవహరించడంలో మాకు సహాయపడే మరొక విధానాన్ని బిన్నింగ్ అంటారు. ఒక వ్యక్తి యొక్క ఎత్తును సూచించే ఫీల్డ్ మీకు ఉందని ఊహించుకోండి. ఎత్తు అనేది ఫ్లోటింగ్ పాయింట్ నంబర్, కానీ మనం మనుషులం దానిని ఆ విధంగా భావించడం లేదు. మాకు ఎత్తు 185,2 సెం.మీ మరియు 185,3 సెం.మీ మధ్య తేడా లేదు.
మేము సారూప్య విలువలను 1 cm లోపల సమూహాలుగా సమూహపరచగలమని ఇది మారుతుంది.
మరియు చాలా తక్కువ మంది వ్యక్తులు 50 సెం.మీ కంటే తక్కువ మరియు 250 సెం.మీ కంటే పొడవుగా ఉన్నారని కూడా మనకు తెలిస్తే, మనం తప్పనిసరిగా అనంతమైన కార్డినాలిటీ ఉన్న ఫీల్డ్‌ను దాదాపు 200 విలువలతో కూడిన ఫీల్డ్‌గా మార్చవచ్చు.
అయితే, అవసరమైతే, మేము అదనపు వడపోత తర్వాత చేయవచ్చు.
అధిక బ్యాండ్‌విడ్త్ సమస్య
బిట్మ్యాప్ సూచికలతో తదుపరి సమస్య ఏమిటంటే వాటిని నవీకరించడం చాలా ఖరీదైనది.
వందలాది ఇతర ప్రశ్నలు డేటాను శోధిస్తున్నప్పుడు డేటాబేస్‌లు తప్పనిసరిగా డేటాను అప్‌డేట్ చేయగలగాలి. ఉమ్మడి డేటా యాక్సెస్ లేదా ఇతర షేరింగ్ సమస్యలతో సమస్యలను నివారించడానికి మాకు లాక్‌లు అవసరం. మరియు ఒక పెద్ద తాళం ఉన్న చోట, సమస్య ఉంది - లాక్ వివాదం, ఈ తాళం అడ్డంకిగా మారినప్పుడు.
ఈ సమస్యను షార్డింగ్‌ని ఉపయోగించడం లేదా వెర్షన్ చేసిన సూచికలను ఉపయోగించడం ద్వారా పరిష్కరించవచ్చు లేదా తప్పించుకోవచ్చు.
షార్డింగ్ అనేది సాధారణ మరియు బాగా తెలిసిన విషయం. మీరు ఏదైనా ఇతర డేటా వలె బిట్మ్యాప్ సూచికను పంచుకోవచ్చు. ఒక పెద్ద తాళానికి బదులుగా, మీరు చిన్న తాళాల సమూహాన్ని పొందుతారు మరియు తద్వారా లాక్ వివాదం నుండి బయటపడతారు.
సమస్యను పరిష్కరించడానికి రెండవ మార్గం సంస్కరణ సూచికలను ఉపయోగించడం. మీరు శోధించడానికి లేదా చదవడానికి ఉపయోగించే ఇండెక్స్ యొక్క ఒక కాపీని కలిగి ఉండవచ్చు మరియు మీరు వ్రాయడానికి లేదా నవీకరించడానికి ఉపయోగించే ఒక కాపీని కలిగి ఉండవచ్చు. మరియు నిర్దిష్ట వ్యవధిలో ఒకసారి (ఉదాహరణకు, ప్రతి 100 ఎంఎస్‌లు లేదా 500 ఎంఎస్‌లకు ఒకసారి) మీరు వాటిని నకిలీ చేసి, వాటిని మార్చుకుంటారు. వాస్తవానికి, మీ అప్లికేషన్ కొంచెం వెనుకబడిన శోధన సూచికను నిర్వహించగల సందర్భాలలో మాత్రమే ఈ విధానం వర్తిస్తుంది.
ఈ రెండు విధానాలు ఏకకాలంలో ఉపయోగించబడతాయి: మీరు భాగమైన సంస్కరణ సూచికను కలిగి ఉండవచ్చు.
మరింత క్లిష్టమైన ప్రశ్నలు
బిట్మ్యాప్ సూచికలతో ఉన్న చివరి సమస్య ఏమిటంటే, స్పాన్ క్వెరీల వంటి క్లిష్టమైన రకాల ప్రశ్నలకు అవి సరిగ్గా సరిపోవని మాకు చెప్పబడింది.
నిజానికి, మీరు దాని గురించి ఆలోచిస్తే, "ఒక రాత్రికి 200 నుండి 300 డాలర్ల వరకు గది ధరలు ఉన్న హోటల్‌లను నాకు చూపించు" అనే ప్రశ్నలకు AND, OR, మొదలైన బిట్ ఆపరేషన్లు సరిపోవు.
ప్రతి డాలర్ విలువకు ఫలితాలను తీసుకొని వాటిని బిట్‌వైజ్ లేదా ఆపరేషన్‌తో కలపడం అనేది అమాయక మరియు చాలా తెలివితక్కువ పరిష్కారం.
సమూహాన్ని ఉపయోగించడం కొంచెం మెరుగైన పరిష్కారం. ఉదాహరణకు, 50 డాలర్ల సమూహాలలో. ఇది మా ప్రక్రియను 50 రెట్లు వేగవంతం చేస్తుంది.
కానీ ఈ రకమైన అభ్యర్థన కోసం ప్రత్యేకంగా సృష్టించబడిన వీక్షణను ఉపయోగించడం ద్వారా సమస్య కూడా సులభంగా పరిష్కరించబడుతుంది. శాస్త్రీయ పత్రాలలో దీనిని పరిధి-ఎన్కోడెడ్ బిట్‌మ్యాప్‌లు అంటారు.
ఈ ప్రాతినిధ్యంలో, మేము కొంత విలువ కోసం ఒక బిట్‌ను సెట్ చేయము (ఉదాహరణకు, 200), కానీ ఈ విలువను మరియు ప్రతిదానిని ఎక్కువగా సెట్ చేయండి. 200 మరియు అంతకంటే ఎక్కువ. 300: 300 మరియు అంతకంటే ఎక్కువ. మరియు అందువలన న.
ఈ ప్రాతినిధ్యాన్ని ఉపయోగించి, మేము సూచికను కేవలం రెండుసార్లు దాటడం ద్వారా ఈ రకమైన శోధన ప్రశ్నకు సమాధానం ఇవ్వగలము. మొదట, మేము గది తక్కువ లేదా $300 ఖరీదు చేసే హోటల్‌ల జాబితాను పొందుతాము, ఆపై గది ధర తక్కువగా ఉన్న లేదా $199 ఉన్న వాటిని దాని నుండి తీసివేస్తాము. సిద్ధంగా ఉంది.
మీరు ఆశ్చర్యపోతారు, కానీ బిట్మ్యాప్ సూచికలను ఉపయోగించి జియోక్వెరీలు కూడా సాధ్యమే. మీ కోఆర్డినేట్‌ని రేఖాగణిత బొమ్మతో చుట్టుముట్టే జ్యామితీయ ప్రాతినిధ్యాన్ని ఉపయోగించడం ఉపాయం. ఉదాహరణకు, Google నుండి S2. సంఖ్యను సూచించే మూడు లేదా అంతకంటే ఎక్కువ ఖండన రేఖల రూపంలో సూచించడానికి ఫిగర్ సాధ్యమవుతుంది. ఈ విధంగా మనం మన జియోక్వెరీని "గ్యాప్ వెంట" (ఈ సంఖ్యా రేఖల వెంట) అనేక ప్రశ్నలుగా మార్చవచ్చు.
రెడీమేడ్ సొల్యూషన్స్
నేను మీకు కొంచెం ఆసక్తి కలిగి ఉన్నానని మరియు ఇప్పుడు మీ ఆయుధశాలలో మీకు మరొక ఉపయోగకరమైన సాధనం ఉందని నేను ఆశిస్తున్నాను. మీరు ఎప్పుడైనా ఇలాంటివి చేయవలసి వస్తే, ఏ విధంగా చూడాలో మీకు తెలుస్తుంది.
అయినప్పటికీ, బిట్మ్యాప్ సూచికలను మొదటి నుండి సృష్టించడానికి ప్రతి ఒక్కరికీ సమయం, సహనం లేదా వనరులు ఉండవు. ముఖ్యంగా మరింత అధునాతనమైనవి, ఉదాహరణకు SIMDని ఉపయోగించడం.
అదృష్టవశాత్తూ, మీకు సహాయం చేయడానికి అనేక రెడీమేడ్ పరిష్కారాలు ఉన్నాయి.
గర్జించే బిట్‌మ్యాప్‌లు
ముందుగా, నేను ఇప్పటికే మాట్లాడిన అదే రోరింగ్ బిట్‌మ్యాప్‌ల లైబ్రరీ ఉంది. మీరు పూర్తి స్థాయి బిట్మ్యాప్ సూచికను సృష్టించాల్సిన అవసరమైన అన్ని కంటైనర్‌లు మరియు బిట్ ఆపరేషన్‌లను ఇది కలిగి ఉంటుంది.
దురదృష్టవశాత్తూ, ప్రస్తుతానికి, Go ఇంప్లిమెంటేషన్‌లు ఏవీ SIMDని ఉపయోగించడం లేదు, అంటే గో అమలులు C అమలుల కంటే తక్కువ పనితీరును కలిగి ఉన్నాయి, ఉదాహరణకు.
పిలోసా
మీకు సహాయపడే మరొక ఉత్పత్తి Pilosa DBMS, వాస్తవానికి, ఇది బిట్మ్యాప్ సూచికలను మాత్రమే కలిగి ఉంటుంది. ఇది సాపేక్షంగా కొత్త పరిష్కారం, కానీ ఇది గొప్ప వేగంతో హృదయాలను గెలుచుకుంటుంది.
Pilosa అంతర్గతంగా రోరింగ్ బిట్‌మ్యాప్‌లను ఉపయోగిస్తుంది మరియు వాటిని ఉపయోగించగల సామర్థ్యాన్ని మీకు అందిస్తుంది, నేను పైన మాట్లాడిన అన్ని విషయాలను సులభతరం చేస్తుంది మరియు వివరిస్తుంది: గ్రూపింగ్, రేంజ్-ఎన్‌కోడ్ చేసిన బిట్‌మ్యాప్‌లు, ఫీల్డ్ యొక్క భావన మొదలైనవి.
మీకు ఇప్పటికే తెలిసిన ప్రశ్నకు సమాధానమివ్వడానికి Pilosaని ఉపయోగించే ఉదాహరణను శీఘ్రంగా పరిశీలిద్దాం.
ఉదాహరణ మీరు ఇంతకు ముందు చూసిన దానికి చాలా పోలి ఉంటుంది. మేము Pilosa సర్వర్‌కు క్లయింట్‌ను సృష్టిస్తాము, సూచిక మరియు అవసరమైన ఫీల్డ్‌లను సృష్టిస్తాము, ఆపై సంభావ్యతతో యాదృచ్ఛిక డేటాతో మా ఫీల్డ్‌లను పూరించండి మరియు చివరకు, తెలిసిన ప్రశ్నను అమలు చేస్తాము.
ఆ తర్వాత, మేము "ఖరీదైన" ఫీల్డ్‌లో NOTని ఉపయోగిస్తాము, ఆపై ఫలితాన్ని (లేదా మరియు అది) "టెర్రేస్" ఫీల్డ్‌తో మరియు "రిజర్వేషన్స్" ఫీల్డ్‌తో కలుస్తాము. చివరకు, మేము తుది ఫలితం పొందుతాము.
భవిష్యత్తులో ఈ కొత్త రకం ఇండెక్స్ MySQL మరియు PostgreSQL - బిట్మ్యాప్ ఇండెక్స్‌ల వంటి DBMSలలో కూడా కనిపిస్తుందని నేను నిజంగా ఆశిస్తున్నాను.
తీర్మానం
మీరు ఇంకా నిద్రపోకపోతే, ధన్యవాదాలు. పరిమిత సమయం కారణంగా నేను చాలా అంశాలపై క్లుప్తంగా స్పృశించవలసి వచ్చింది, కానీ ప్రసంగం ఉపయోగకరంగా ఉంటుందని మరియు ప్రేరణ కలిగించవచ్చని నేను ఆశిస్తున్నాను.
బిట్మ్యాప్ సూచికలు మీకు ప్రస్తుతం అవసరం లేకపోయినా వాటి గురించి తెలుసుకోవడం మంచిది. వాటిని మీ టూల్‌బాక్స్‌లో మరొక సాధనంగా ఉండనివ్వండి.
మేము Go కోసం వివిధ పనితీరు ఉపాయాలు మరియు Go కంపైలర్ ఇంకా బాగా నిర్వహించని అంశాలను పరిశీలించాము. కానీ ప్రతి గో ప్రోగ్రామర్ తెలుసుకోవడం కోసం ఇది ఖచ్చితంగా ఉపయోగపడుతుంది.
నేను మీకు చెప్పాలనుకున్నది ఒక్కటే. ధన్యవాదాలు!
మూలం: www.habr.com