Introduction to MapReduce-XWNEhv-b2PM

  హలో, క్లౌడ్ కంప్యూటింగ్(cloud computing) పై మన చర్చను కొనసాగిస్తాము.
  మా పూర్వ ఉపన్యాసంలో మనము డేటా స్టోర్(data store) లేదా సమాచారాల గురించి అవలోకనం కలిగి ఉన్న క్లౌడ్(cloud) లో డేటా (data)ను ఎలా నిర్వహించాలో గురించి చర్చించాము.
  ఇప్పుడు మనము MapReduce అనే మరొక ప్రోగ్రామింగ్(programming) పారాడిం(paradigm)ని చూడబోతున్నాం. ఇది చాలా ప్రజాదరణ పొందిన ప్రోగ్రామింగ్(programming) నమూన, ఇది ప్రధానంగా గూగుల్(google) చేత నిర్మించబడింది, కానీ ఇప్పుడు వేర్వేరు శాస్త్రీయ ప్రయోజనాల కోసం ఉపయోగించబడుతోంది.
  ప్రధమంగా గూగుల్(google) దీనిని లార్జ్ స్కేలు సర్చ్ ఇంజిన్(large scale search engines)ల కోసం అభివృద్ది చేయబడింది. ఇది ప్రధానంగా వారి Google శోధన ఇంజిన్లలో భారీ మొత్తాల వాల్యూమ్ల(volumes)ను శోధించడానికి, కానీ ఈ శాస్త్రీయ ప్రపంచం కోసం ఈ తత్వశాస్త్రంను ఎక్స్ప్లోయిట్(exploit) చేయడానికి ఇది ఒక ప్రధాన నమూనా ప్రోగ్రామింగ్ ఉదాహరణగా మారుతుంది.
  వివిధ రకాలైన శాస్త్రీయ సమస్యలకు సమర్ధవంతంగా పనిచేస్తాయి.
  మ్యాప్ రెడ్యూస్(MapReduce): గూగుల్(google) లో అభివృద్ధి చేయబడిన ఒక ప్రోగ్రామింగ్ మోడల్ (programming model). ప్రధానంగా లక్ష్యం పెద్ద ఎత్తున సర్చ్(search)ను ఇంప్లెమెంట్(implement) చేయడం, బిగ్ టేబల్(big table) లేదా GFS డిస్ట్రిబ్యూటెడ్ ఫైల్ సిస్టమ్(distributed file system)ని ఉపయోగించి నిల్వ చేయబడిన భారీగా స్కేలబుల్(scalable) వెబ్ డేటా(web data)పై టెక్స్ట్ ప్రాసెసింగ్(text processing) చేయడం.
  మనము ఈ డాటా(data) ను బిగ్ డేటా(big data) మరియు GFS డిస్ట్రిబ్యూటెడ్ ఫైల్ సిస్టమ్ల(distributed file systems)ల నుంచి పొందుతాము.
  భారీ వాల్యూమ్ డాటా(volume data) ఉన్న భారీగా స్కేలబుల్ వెబ్ డేటా(scalable web data) ని ఎలా ప్రాసెస్(process) చెయ్యాలి.
  ఒకే సమయంలో వేలాది ప్రాసెసర్ల(processors)ను ఉపయోగగించే భారీగా సమాంతర కంప్యుటేషన్(computation) ద్వారా డేటా యొక్క భారీ పరిమాణాలను ప్రాసెస్(process) చేయడానికి మరియు రూపొందించడానికి రూపకల్పన.
  లార్జ్ పూల్ ఆఫ్ రిసోర్సస్(large pool of resources) ని కలిగి ఉంటుంది. పెద్ద మొత్తం లో డాటా(data) ని కలిగి ఉంటుంది మరియు దాని నుండి కొంత విశ్లేషణ చేయాలనుకుంటున్నాను.
  ఎలా చేయగలను? ఇక్కడ మనము చూస్తే చాలా ప్రముఖమైన సమస్య ఏమిటంటే, నా దగ్గర ఎక్కువ వాల్యూమ్ డేటా(volume data) మరియు ఎక్కువ ప్రాసెసర్ల(processors) కలిగి ఉంటే, అప్పుడు ఏదో ఒక విధమైన పద గణన లేదా గణన డేటా యొక్క భారీ పరిమాణంలో పదాల యొక్క ఫ్రీక్వెన్సీ(frequency)ని లెక్కించాలనుకుంటాను.
  ఐటీ ఖరగ్పూర్ అనే పదం ఈ డేటా(data)లో ఎన్నిసార్లు కనిపిస్తుందో తెలుసుకోవాలనుకుంటాము. ఇవి ప్రధానంగా HDFS లేదా GFS లేదా బిగ్ టేబల్(big table) నిర్మాణంలో నిల్వ చేయబడతాయి.
  ఇది ఫాల్ట్ టోలరెంట్(fault tolerant) గా ఉంటుంది. ప్రాసెసర్ విఫలమైనా మరియు నెట్వర్క్(network) విఫలమైనా కంప్యుటేషన్(computation) యొక్క పురోగతిని నిర్ధారిస్తుంది.
  ఎందుకంటే భారీ వాల్యూమ్ డాటా(volume data), ఎక్కువ ప్రాసెసర్ల(processors) మరియు అంథీర్లన నెట్వర్క్లు(networks) ఉండటం వలన, నేను ఫాల్ట్ టోలరెంట్(fault tolerant)కి హామీ ఇస్తుంది.
  దీనికి ఒక ఉదాహరణకు hadoop, టైమ్(time) పరిమాణంలో అభివృద్ధి చేసిన MapReduce యొక్క హడూప్ ఓపెన్ సోర్స్(hadoop open source) అమలు అనేది ప్రారంభంలో యాహూ(yahoo)లో జరిగింది మరియు తరువాత ఓపెన్ సోర్స్(open source)గా మారింది.
  అమెజాన్(amazon) EC2 ప్లాట్ఫాం(platform)లో ప్రీ ప్యాక్డ్ (pre packed)AMI లు అందుబాటులో ఉంది.
  మనం చూస్తున్నది ఏమిటంటే ప్రోగ్రామింగ్ ప్లాట్ఫామ్(programming platform) లేదా ప్రోగ్రామింగ్(programming) పథకం అందించే ప్రయత్నం చేయడం, ఇది డేటా బేస్(data base) తో సంకర్షణ చెందుతుంది, ఈ రకమైన క్లౌడ్ డేటా(cloud data) స్టోర్ల(stores)లో ఇది నిల్వ చేయబడుతుంది, అది HDFS, GFS రకం కావచ్చు.  
  బిగ్ టేబల్(big table) చేత నిర్వహించబడుతుంది.
  మనము మునుపటి ఉపన్యాసాలలో చూసిన పారలెల్ కంప్యూటింగ్(parallel computing) ను మరలా చూస్తే, సమాంతర కంప్యూటింగ్ యొక్క వేర్వేరు నమూనాలు ప్రాసెసర్(processor) యొక్క స్వభావం మరియు పరిణామం, మల్టీప్రాసెసర్ కంప్యూటర్(multiprocessor computer) నిర్మాణంపై ఆధారపడతాయి.
  ఇది షేర్డ్ మెమరీ మోడల్(shared memory model),డిస్ట్రిబ్యూటెడ్ మెమరీ మోడల్(distributed memory model), ఇవి 2 ప్రముఖ విషయాలు.
  కంప్యూటింగ్(computing) కోసం అభివృద్ధి చేసిన సమాంతర కంప్యూటింగ్ (computing), మనకు తెలిసినంతవరకూ ఇంటెన్సివ్ సైంటిఫిక్(intensive scientific) పనులు; తరువాత డేటా బేస్ అరేనా లేదా డేటా బేస్ పారాడిగ్మ్(data base paradigm) లో కూడా అప్లికేషన్(applications) లకు పారలెల్ కంప్యూటింగ్ (parallel computing) ని ఉపయోగిస్తారు.
  సో, ఇది ప్రారంభంలో ఎక్కువగా సైంటిఫిక్ టాస్క్(scientific tasks) లలో తరువాత చాలా డేటాబేస్ డొమైన్(database domains) లోని చాలా అప్లికేషన్(applications) లలో చూస్తాము.
  మనము ముందు ఉపన్యాసంలో చూసిన మూడు రకాల దృష్టాంతాలు ఒకటి షేర్డ్ మెమరీ(shared memory), షేర్డ్ డిస్క్(shared disk) మరియు షేర్డ్ నథింగ్(shared nothing).
  ఎప్పుడైనా ఒక ప్రోగ్రామింగ్ నమూనా చేయాలనుకున్నప్పుడు లేదా పారలెల్ ప్రోగ్రామ్మింగ్(parallel programming) లాంటి దాని పై పని చేస్తున్నప్పుడు డాటా(data) అనేది క్లౌడ్(cloud) లో స్టోర్(store) అయి ఉంటుంది. అందువల్ల మేము ఏ విధమైన మెకానిసంను(mechanism)  జాగ్రత్తగా చూసుకోవాలి. 
  అనేదానిని కన్సిడర్(consider) చేస్తాం.
  ఎలాగంటే, ఇది షేర్డ్ మెమరీ(shared memory), షేర్డ్ డిస్క్(shared disk) లేదా షేర్డ్ నథింగ్(shared nothing) రకానికి చెందినడ అని.
  ఇంతకు మునుపు మనము పూర్వ ఉపన్యాసాలలో చూసిన చిత్రం, కాబట్టి పునరావృతం చేయవలసిన అవసరం లేదు.
  సో, అది ఒక షేర్డ్ మెమరీ(shared memory) నిర్మాణం, షేర్డ్ డిస్క్(shared disk) మరియు షేర్డ్ నథింగ్(shared nothing), కానీ ఇప్పుడు మనము చూస్తున్నడి కొద్దిగా భిన్నంగా ఉంటుంది.
  మునుపు చూసిన దానిలో స్టోరేజ్ (storage) ఎక్కువ ఉంది.
  ఇప్పుడు మనము చూస్తున్నది, ప్రోగ్రామింగ్ ఈ విధమైన నిర్మాణాన్ని ఎలా ఎక్స్ప్లోయిట్(exploit) చేయగలదని.
  ఇది ఇప్పటికే మనము చర్చించాము; అందువల్ల, బహుళ CPU లతో సర్వర్ల(servers) కోసం షేర్డ్ మెమరీ (shared memory) అనుకూలం.
  షేర్డ్ నథింగ్(shared nothing) ఆనేది, దాని సొంత హార్డ్ డిస్క్(hard disk) తో ఉండే స్వతంత్ర సర్వర్(servers) ల క్లస్టర్(cluster), కాబట్టి ఇది అధిక వేగం కలిగిన నెట్వర్క్(network) ద్వారా కనెక్ట్(connect) చేయబడింది.
  మరియు షేర్డ్ డిస్క్(shared disk), ఇది ఒక హైబ్రిడ్ ఆర్కిటెక్చర్ (hybrid architecture), స్వతంత్ర సర్వర్(server) క్లస్టర్(clusters) షేర్లు NAS లేదా SAN వంటి అధిక వేగ నెట్వర్క్ స్టోరేజ్ (network storage) ద్వారా నిల్వ చేస్తుంది.
  ప్రామాణిక ఈథర్నెట్(Ethernet), ఫాస్ట్ ఫైబర్ ఛానల్ (fast fiber channel), ఇన్ఫిని-బ్యాండ్(infini-band) మొదలైనవాటి ద్వారా క్లస్టర్ (clusters) లు స్టోరేజ్ (storage) కి అనుసంధానించబడి ఉంటాయి.
  మనము ఏదైనా సమాంతర లేదా సమాంతర కంప్యూటింగ్ (computing) లేదా సమాంతర స్టోరేజ్(storage) చెయ్యాలనుకున్నపుడు, మనము గుర్తించే విషయం ఎఫిషియెన్సీ(efficiency).
  పారాలిజ్మ్(parallelism) చెయ్యలి అనుకున్నప్పుడు ఎఫిషియెన్సీ (efficiency) అనేది ఒక ప్రధాన అంశం.
  మరొక ముఖ్యమైన అంశం ఫాల్ట్ టాలరెన్స్ (fault tolerance) మరియు పూర్తి రుజువు మరియు ఫైల్యూర్ రిజిస్టర్(failure register), కానీ ప్రధానమైనది ఎఫిషియెన్సీ (efficiency).
  ఇప్పుడు, మనము పని చేస్తున్న అన్ని రకములలో మొదటిది దానిలో స్వాభావిక పారేలిజం (parallelism) అయి ఉండాలి.
  ఏ స్వాభావిక పారేలిజం(parallelism) లేనట్లయితే, అది ఎల్లప్పుడూ సమాంతర నిర్మాణాన్ని ఉపయోగించడం సులభతరం కాదు.
  కాబట్టి, మొదట అవి అంతర్గత సమాంతరంగా ఉండాలి, ఇది ఆపరేషన్(operations) లు క్రమంలో ఉండకూడదు మరియు అప్పుడు మీరు సమాంతరంగా చేయటానికి ప్రయత్నిస్తారు.
  జాబ్ 1, జాబ్ 2, జాబ్ 3, జాబ్ 4 లు ఒక సీక్వెన్స్లో ఉండచ్చు లేదా వీటి మధ్య పారేలిజం(parallelism) ఉండవచ్చు, కానీ మనము పారలెల్ ఆపరేషన్(parallel operation) చేయాలనుకుంటే, అక్కడ జరగక పోవచ్చు.
  ఒక టాస్క్(task) UNI ప్రాసెసర్(processor)లో T టైమ్ (time) తీసుకుంటే, దానిని p ప్రాసెసర్(processors) లలో అమలు చేసినప్పుడు అది T/P టైమ్ తీసుకుంటుంది. పారేలిజం(parallelism) ఉన్నట్లయితే, టాస్క్(tasks) లను విభజించి డిస్ట్రిబ్యూట్(distribute) చేయడానికి కాస్ట్ (cost) ఏమి ఉండదు.
  T/p ఆనేది ఐడియల్ (ideal) ఉండే స్థితి.
  ప్రోసెసర్ల(processors) మధ్య సింక్రొనైజేషన్(synchronization) అవసరం కారణంగా డిస్ట్రిబ్యూటెడ్ కంప్యూటింగ్(distributed computing) లో  అసమర్థతలు ప్రవేశపెట్టబడ్డాయి. 
  సో, నేను ప్రాసెసర్(processors) ల మధ్య సింక్రొనైజేషన్(synchronization) చేయవలసిన అవసరం ఉంది, ఇది అన్ని ప్రాసెసర్(processor) కి దాని సొంత క్లాక్(clock) కలిగి ఉండటం మరియు వాటిని సింక్రొనైజేషన్ (synchronization) చేయవలసిన అవసరం లేదు.
  లేకపోతే జాబ్(job) 2 గా విభజించి , అందులో ఒక దానిని ఇప్పుడు అమలు పరచి మరియు కొన్ని గంటల తర్వాత రెండవ దానిని అమలు చెయ్యవచ్చు.
  సో, ప్రాసెసర్ మధ్య సింక్రొనైజేషన్(synchronization) చేయడం అనేది ముఖ్యమైన అంశాలలో ఒకటి.
  కాబట్టి, సింక్రొనైజేషన్(synchronization) అవసరం ఉంది.
  ప్రాసెసర్ల(processors) మధ్య మరొక విషయం మెసేజ్ కమ్యూనికేషన్(message communication) యొక్క సమస్యలు; ప్రాసెసర్ల(processors)కు వర్క్(work) పంపిణీలో అసమతుల్యత, అంటే సమానంగా విభజించబడటం లాంటిది కాదు.
  దీనిని పరోక్షంగా ప్రభావితం చేసే లేదా ఈ సమాంతర అమలులో అసమర్థతను తీసుకురావడానికి వేర్వేరు అంశాలు.
  ఒక అల్గోరిథం యొక్క సమాంతర సామర్థ్యాన్ని P/T గా నిర్వచించవచ్చు.
  ఇది స్కేలబుల్(scalable) అయినట్లయితే, ఇది స్కేలబుల్(scalable) లేదా స్కేలబుల్(scalable) సమాంతర సామర్థ్యతతో డేటా యొక్క పరిమాణాన్ని పెంచుతుంది.  
  ప్రాసెసర్(processor). 
  మరింత డేటా వచ్చినప్పుడు ఏమి జరుగుతుందో, కాబట్టి మీరు మరింత ప్రాసెసర్(processor)ని అమలు చేయడానికి వెళ్తారు లేదా మీరు క్లౌడ్ నుండి మరింత ప్రాసెసర్ నుండి అభ్యర్థిస్తూ, మీ సామర్థ్యాన్ని స్థిరంగా ఉంచుతారు, సామర్థ్య విలువలు మారవు? అది కొలవలేనిది.
  నేను రెండింటిని పెంచుతున్నాను, ఉదాహరణకు చెప్పాలంటే, సరళంగా అది స్థిరంగా ఉన్నది.
  ఒక స్థిర సంఖ్య ప్రాసెసర్(processor) కోసం డేటా పరిమాణాన్ని సమాంతర సామర్థ్యం పెంచుతుంది, ఇది డేటా పరిమాణంతో పెరుగుతుంది; మరియు ఇది ఒక స్థిర సంఖ్యలో ప్రాసెసర్(processor) అయితే మరింత సామర్థ్యం కలిగి ఉంటుంది.
  ఇప్పుడు, ఈ పుస్తకంలో ఉన్న ఉదాహరణ మనము రిఫర్(refer) చేస్తాం, వివిధ లిటరేచర్(literatures)లలో కూడా ఈ ఉదాహరణలను చూడవచ్చు.
  అతి భారీ వెబ్ డాక్యుమెంట్(web documents) లను పరిగణిస్తే ఈ వెబ్ డాక్యుమెంట్(web document) అనేది ఇంటర్నెట్(internet) ద్వారా క్రాల్(crawl) చెయ్యబడింది.
  సో, ఇది పెద్దగా ప్రతి రోజు పెరుగుతోంది.
  ఈ సేకరణలో ప్రతి పదానికి సంబంధించిన మొత్తం సంఘటనల సంఖ్యను లేదా ఫ్రీక్వెన్సీ (frequency)ని గుర్తించడం ఒక సమస్య.
  కాబట్టి, నేను ఈ డాక్యుమెంట్(document) లోని ప్రతి పదం యొక్క అక్కరెన్సెస్(occurrences)ని లేదా ఫ్రీక్వెన్సీ(frequency) మొత్తం సంఖ్యను గుర్తించాలనుకుంటాము.
  అక్కడ n డాక్యుమెంట్(documents) లు మరియు m విభిన్న పదాలు ఉన్నట్లయితే, ప్రతి పదానికి m ఫ్రీక్వెన్సీ(frequency)ని కనుగొనడానికి ఉపయోగిస్తాము.
  ఇది ఒక సాధారణ సమస్య లేదా సర్చ్ ఇంజిన్ల(search engines)లకు మరియు రకానికి చెందిన విషయాల కోసం మరింత సందర్భోచితంగా ఉండవచ్చు.
  ఇక్కడ మనకు రెండు పద్ధతులు ఉన్నాయి, ప్రతి ప్రాసెసర్(processor) ఫ్రీక్వెన్సీ(frequency) ని m/p వర్డ్(words) లుగా లెక్కిస్తుంది.
  ఇక్కడ p ప్రాసెసర్ల(processors)లను, m ఫ్రీక్వెన్సీ(frequency) లను కలిగి ఉంటే, m/p ని కనుక్కోవాలి, ఉదాహరణకు, పది ప్రాసెసర్ల(processors)ను ఉన్నాయి అనుకోండి మరియు 90 పదాలు, అంటే m=90.
  ప్రతి ప్రాసెసర్(processor) దానిని పది భాగాలుగా చేస్తుంది, ఒకవేళ అది డివిసబుల్(divisible) కాకపోతే మనము ఆసిమిట్రిక్ డివిజన్(asymmetric division) చెయ్యాలి. మీరు కొన్ని అసమాన విభాగాన్ని తయారు చేయాలి.
  ఇది విషయాలను చేస్తుంది మరియు అంతిమంగా వారు మళ్ళీ కొన్ని విషయాలను కలిసి లేదా కొన్ని విషయాలను నివేదిస్తారు.
  కాబట్టి, మరొక విధంగా ప్రతి ప్రాసెసర్ N పత్రంలో పౌన frequency పున్యాన్ని P పత్రాల ద్వారా లెక్కించనివ్వండి.
  మొత్తం డాక్యుమెంట్(documents) లు 10,000 ఉన్నాయి అనుకుందాం.
  మనము చూడాలనుకుంటున్న పదాల సంఖ్య 90, ప్రాసెసర్(processors) ల సంఖ్య 10,000 కలిగి ఉన్నాను.
  10. కాబట్టి, ప్రతి ప్రాసెసర్‌కు సగటున 9 పదాలు 10, అంటే 9. 
  ప్రతి ప్రాసెసర్(processor) మొత్తం 90 పదాల ఫ్రీక్వెన్సీ(frequency)ని గణన చేస్తుంది, కాని n/p లో 10,000 పదాలు మరియు 10 ప్రాసెసర్లు ఉంటే; 1000 డాక్యుమెంట్(documents) లు మరియు ప్రతి ఒక్కటి 100 డాక్యుమెంట్(documents)లను తీసుకుని ప్రాసెసింగ్(processing) చేస్తాయి. మరియు ఈ ఇండివిజువల్(individual) ప్రాసెసర్ల(processors)చే ఈ m పదాల ఫ్రీక్వెన్సీ(frequency) బయటకి వచ్చినప్పుడు, మనము దీని మొత్తాన్ని సం(sum) చేసి అగ్రిగేట్(aggregate) చేస్తాము. అన్ని ప్రాసెసర్లు(processors) వారి ఫలితాలను సంక్షిప్తం చేస్తాయి.
  సమాంతర కంప్యూటింగ్, ఇప్పుడు ఈ సమాంతర కంప్యూటింగ్ నమూనా ఆధారంగా ఇది సమర్థవంతంగా పని చేస్తుంది.
  సమాంతర కంప్యూటింగ్ ఒక డిస్ట్రిబ్యూటెడ్ మెమొరీ మోడల్(distributed memory model) గా, షేర్డ్ డిస్క్(shared disk) తో అమలు చేయబడుతుంది, తద్వారా ప్రతి ప్రాసెసర్(processor) ఏ వివాదం లేకుండా ఏ డాక్యుమెంట్(document) ని అయినా డిస్క్(disk) నుండి యాక్సెస్(access) చేయగలదు.
  సో, ఇది అమలు విధానాలలో ఒకటిగా ఉంటుంది.
  ఇప్పుడు, డాక్యుమెంట్(document) నుండి ప్రతి పదాన్ని రీడ్(read) చేసే టైమ్(time) చెప్పాలంటే, ఇంటర్ ప్రాసెసర్ కమ్యూనికేషన్(inter processor communication) ద్వారా మరొక ప్రాసెసర్(processor) కి ఒక వర్డ్(word)ను పంపించడానికి పట్టే సమయం.
  అది c కి సమానం.
  దీనిని సులభం చేస్తే అది ఉత్తమమైన సందర్భంలో లేదా నిజ జీవిత సందర్భంలో భిన్నంగా ఉంటుంది, కానీ మనము ఈ సందర్భాలలో, మొదటి పద్దతి రన్(run) అవుతున్న ఫ్రీక్వెన్సీ(frequency) లన్నింటిని యాడ్(add) చేయడానికి తీసుకునే టైమ్(time) అతితక్కువగా ఉంటుంది.
  ఒకసారి నేను ఈ m పదాల యొక్క ఫ్రీక్వెన్సీ(frequency)లను కనుగొన్టే దాని సంక్షిప్తం చాలా తక్కువగా ఉంటుంది.
  ప్రతి పదం డాక్యుమెంట్(document)లో సగటున f సార్లు ఉంటుంది.
  నేను మా గణన కోసం ఉంటే ప్రతి పదం సగటున, కొంత సమయం f.
  ఒకే ప్రాసెసర్(processor) తో m ఫ్రీక్వెన్సీ(frequency)లను లెక్కించడానికి పట్టే సమయము n x m x f x c కి సమానం.
  సో, ఈ ఒక ప్రాసెసర్ తో m పౌనఃపున్యాలను గణించడానికి సమయం, నేను ఒకే ప్రక్రియ కలిగి ఉంటే ఈ విషయం కావచ్చు.
  మనము మొట్టమొదటి విధానం చేస్తే, ఇది మొదటి విధానం, ప్రతి ప్రాసెసర్(processor) m/p పదాల యొక్క ఫ్రీక్వెన్సీ(frequency)ని గణించడం వీలు కల్పిస్తుంది, కాబట్టి ఇది మొదటి విధానం.
  ప్రతి ప్రాసెసర్(processor) చాలా సార్లు n x m/p x f టైమ్స్(times) రీడ్(read) చేస్తుంది.
  సమాంతర సామర్థ్యం nffc/pnmfc గా లెక్కించబడుతుంది, కాబట్టి 1/p చాలా వనిల్లా రకం పరిశీలన ద్వారా.
  మనమందరం అన్నింటినీ నైతికంగా ఒకే పౌనఃపున్యాలు చేస్తున్నాం, అన్నీ అగ్రిగేషన్కు అన్ని సమయం తక్కువగా ఉంటాయి, అప్పుడు అన్ని సమయాలను చదివి, వ్రాయడం కోసం మరొక సమయాన్ని రాయడానికి మేము c ను పరిగణలోకి తీసుకోవాలి.
  పెరుగుతున్న పురోగతితో సంభావ్యత వస్తుంది.
  కాబట్టి, మనము p ను పెంచుకుంటే, అప్పుడు సామర్ధ్యం తగ్గుతుంది.
  కాబట్టి, ఇది స్థిరంగా లేదు.
  కాబట్టి, ఇది కొలవదగినది కాదు, ఇది ప్రధాన సమస్యగా ఉంది, అయితే ఇది చాలా సందర్భోచితమైనదిగా చెప్పాలంటే మేము చెప్పేది, అయితే విషయాల యొక్క కొలతలో సమస్య ఉంది.
  ప్రతి ప్రాసెసర్(processor) m/n వర్డ్(words)లకు ఫ్రీక్వెన్సీ(frequencies) లను కొలవగలదు.
  అయితే, రెండో పద్ధతిలో, ఆ పదాలు వేర్వేరు ప్రక్రియలకు లోబడి మనం ఆ డాక్యుమెంట్(document) d ను డివైడ్(divide) చేస్తాము, ప్రతి ప్రాసెసర్(processor) దీన్ని మొత్తం m పదాల కోసం లెక్కించి, మొత్తం కలుపుతుంది.
  స్పష్టంగా ఇధి మరింత ఖరీదైనది .
  ఇది ఒక సంకలనం విషయం మీరు ఆ ప్రోసెసర్ క్లబ్బింగ్ (processor clubbing) చేస్తున్నప్పుడు, క్లబ్(club) అంటే విభిన్నమైన ఈ మొత్తం డాక్యుమెంట్ల(documents)కు విభజన చేయడం మరియు కలపడం, ఇది మొదటిదాని కంటే సమర్థవంతంగా ఉంటుంది.
  కానీ అక్కడ ఏమి ఉందో చూద్దాం.
  ప్రతి ప్రాసెసర్(processor) రీడ్(read) చేసే సంఖ్య n/pxmxf గా ఉంటుంది, రీడ్(read) చెయ్యడానికి పట్టే సమయం n/pxmxfxc గా ఉంటుంది.
  ఎందుకంటే మీరు డేటా యొక్క మొత్తం p పరిమాణంతో n కలిగి ఉన్నాము మరియు తరువాత c లోకి f లోకి m కు లెక్కించాలనుకుంటున్నారా, అందువల్ల ఈ చదివే లెక్కించేందుకు తీసుకునే సమయం.
  సమయం tడిస్కుకి సమాంతరంగా m పదాలపై పాక్షిక పౌనఃపున్యం వ్రాయడానికి గుర్తుగా m లోకి c లోకి m అవుతుంది.
  ఒకసారి మీరు డిస్కుకి సమాంతరంగా రాయడం అవసరం మరియు ఇది p మైనస్ 1 ప్రాసెసర్లకు పాక్షిక పౌనఃపున్యాన్ని సరిగ్గా కమ్యూనికేట్ చేయడానికి తీసుకున్న సమయాన్ని c తీసుకుంటుంది.
  ఆపై స్థానికంగా సబ్ పి సబ్ వెక్టార్లను జతచేస్తుంది తుది m వెక్టార్ పౌనఃపున్యాల p ద్వారా ఒకదానిని తయారు చేద్దాం అప్పుడు మనం p లోకి c లోకి p చేస్తాము.
  మీరు మొత్తం పౌనఃపున్యాలను కలిగి లేనందున పాక్షిక పౌనఃపున్యాలు సంభాషించడానికి మేము తీసుకోవలసిన సమయం ఆసన్నమైంది.
  వేర్వేరు ప్రాసెసర్ మరియు p మైనస్ 1 ప్రాసెసర్ ద్వారా పాక్షిక పౌనఃపున్యం మరియు స్థానికంగా p సబ్ వెక్టార్లను జోడించడం ద్వారా తుది m వెక్టార్ పౌనఃపున్యాలు ఇక్కడ p ద్వారా ఉత్పత్తి చేయబడతాయి.
  వ్యక్తిగతంగా చేయవలసిన అవసరం ఉంది.
  ఈ రెండో విధానానికి సంబంధించిన అన్ని విషయాలను మేము అనుసరిస్తే, మనము ఈ నిర్మాణంతో ఈ సమాంతర పౌనఃపున్యాన్ని కలిగి ఉంటాము, కాబట్టి 1 ప్లస్ 1 ప్లస్ 2 p ద్వారా nf చేస్తే, 
  అందువల్ల మీరు దాన్ని కొద్దిగా సూక్ష్మంగా చూస్తే పుస్తకం, ఇది చాలా కష్టం సమస్య రాబట్టు కాదు.
  ఇది స్టెప్ బై స్టెప్ ద్వారా వెళ్ళడానికి అందంగా సులభం.
  ఇప్పుడు, ఈ ఆసక్తికరమైన విషయం.
  కాబట్టి, మనము ఇక్కడ ఉన్న పదం n ప్లస్ 1 ప్లస్ 2 p.
  కాబట్టి, ఈ సందర్భంలో ఒక p అనేక, అనేక సార్లు nf కంటే తక్కువ.
  రెండవ పద్ధతి యొక్క సమర్థత, ఇక్కడ మొదటి కుడివైపు కంటే ఎక్కువగా ఉంటుంది, ఇది p అనేది చాలామంది ఉంటే, చాలా సార్లు nf కంటే తక్కువగా ఉంటుంది, అప్పుడు ఈ పదాన్ని ఒక దాని వైపు మళ్ళిస్తుంది.
  మరియు చాలా సామర్థ్యం చాలా ఎక్కువ ఉందని అనిపించవచ్చు.
  మొదటి పద్ధతిలో(approach), ఇది ఒక రకమైన ఉండాలి, మొదటి ప్రాసెసర్లో (processor) ప్రతి ప్రాసెసర్ చదివేది కంటే ఎక్కువ సమయం చదివేటప్పుడు చదివిన సమయం కంటే ఎక్కువ సమయం వుధావుతుంధి.
  మనం మొదటి పద్ధతిలో చేసిన ఈ అనేక ప్రాసెసర్ మేము ఈ m విభిన్న విభాగంగా విభజించాము.
  కాబట్టి, ప్రాసెసర్ మనకు ఉదాహరణగా తీసుకున్నట్లుగా, నా ధగరా m విలువ 90 మరియు ప్రాసెసర్ సంఖ్యను p అని పిలుస్తాను, కాబట్టి 90 by p is10 అవుతుంది.
  ప్రతి ఒక్కరికి 10 పూర్తయింది, కానీ మొత్తం పత్రాన్ని శోధిస్తున్నప్పుడు , అందువల్ల హిట్ (hint) లేని చోట పత్రాల సంఖ్య చదివేది, ఇది విజయం కాదు.
  సమర్థత, రెండో విధానం ఉపయోగకరమైనది.
  ఫలితంగా గణన ఫలితంగా మరియు తుది ఫలితాలకు పంపిణీ చేస్తుంది.
  రెండవ విధానం కోసం, ప్రతి రీడ్(read) ఈ ఫలితానికి దోహదం చేస్తున్నప్పుడు ఉపయోగకరంగా ఉంటుంది.
  ఇది కూడా కొలవదగినది.
  N మరియు p రెండూ సమర్థవంతంగా (potentially) పెరుగుతాయి, ఇవి నిష్పత్తిలో ఉంటాయి.
  మనం ఏమి చేసామో చూద్దాం, నా డేటా లోడ్ పెరుగుతు ఉంటే నేను ప్రాసెసర్ పెంచుతాను.
  కాబట్టి, నేను డేటా ప్రాసెసర్(processor) కు అనుగుణంగా పెరుగుతుంటే, రెండవ కేసులో నా సామర్థ్యం స్థిరంగా ఉంటుంది.
  సమర్థత (potentially)p యొక్క స్థిరత్వం మరియు క్రమంగా పెరుగుతుంది. 
  కాబట్టి, సామర్థ్యం 1 వరకు పెరుగుతుంది, ప్రాసెసర్ల సంఖ్య స్థిరంగా ఉంటే మరియు క్రమంగా పెరిగితే మనం n ను పెంచుతున్నాము.అంటే మనం డేటా లోడ్‌ను పెంచుతున్నాం, ప్రాసెసర్ల సంఖ్య పరిష్కరించబడింది మరియు ఇది ప్రాథమికంగా ఒకదానికి వెళ్తుంది. 
  సొ, ఈ సందర్భంతో లేదా ఈ నేపథ్యంతో(background), ఈ పనుల ద్వారా వ్యక్తిగతంగా సమీకరించడం అనేది మరింత సమర్థవంతంగా మారుతోంది,మేము మీ మాప్ రెడ్యూస్ మాడెల్ (map reduce model) చూస్తాము.
  వేర్వేరు సమాంతర అనువర్తనాల(parallel programing) ద్వారా ఉపయోగించే ఒక సమాంతర ప్రోగ్రామింగ్ సంగ్రహణం, ఇది వేలాది ప్రాసెసర్ల(processors)ను కలిగి ఉన్న భారీ స్థాయి గణనలు నిర్వహిస్తుంది; ఒక సాధారణ అంతర్లీన తప్పు సహనం అమలు అమలుచేస్తుంది.
  మ్యాప్ యొక్క రెండు దశలు మ్యాప్ ఆపరేషన్ను తగ్గిస్తాయి మరియు ఆపరేషన్ను తగ్గించాయి.
  సమస్యపై పనిచేయడానికి M మ్యాపర్-మ్యాపర్ ప్రాసెసర్ మరియు R రీడర్ ప్రాసెసర్ల కన్ఫిగర్ (configure)చేయదగిన సంఖ్య కేటాయించబడతాయి.
  గణన (computation)ఒకే మాస్టర్ ప్రాసెస్ ద్వారా సమన్వయించబడుతుంది.
  కాబట్టి, మనం ఇప్పుడు ఏమి కలిగి ఉన్నాము? వేర్వేరు mapper ప్రాసెసర్లు ఉన్నాయి మరియు వివిధ రీడ్యూసర్ ప్రాసెసర్(reducer processor) ఉంది.
  సొ మొత్తం ప్రక్రియ, నేను రెండు విషయాలు విభజించబడింది.
  నేను ఒక మాపర్ (mapper)కలిగి, కాబట్టి వివిధ mapper ప్రాసెసర్. 
  సొ మనకి M ప్రాసెసర్ మరియు రీడ్యూసర్ ప్రాసెసర్ ఉన్నాయి.
  ఇక్కడ ఏమి జరుగుతుందో అక్కడ డేటా ఏమి చేస్తుందో అది ప్రాధమికంగా కొన్ని అమలును చేస్తాయి మరియు ఈ తగ్గింపుదారు సమస్య యొక్క రకంపై ఆధారపడి ఉండవచ్చు, ఇది వేర్వేరు తగ్గింపు విషయాలపై కొనసాగుతుంది మరియు అమలు చేయబడుతుంది.
  ఉత్పాదకత సంకలనం చేయబడిన ఫలితాలను (result)మరింతగా ఉత్పత్తి (produce)చేస్తుంది.
  సో, అది ఏమి ప్రయత్నిస్తుంది అది ప్రోసెసర్ (processor) వేల పాల్గొన్న పెద్ద ఎత్తున గణన కొనసాగిస్తున్న ఖనిజ సమాంతర అప్లికేషన్లు ఉపయోగించే ఒక సమాంతర ప్రోగ్రామింగ్ సారాంశం ఉంది.
  సో, ఇక్కడ అప్లికేషన్ ఆట వస్తాయి(come into play).
  ఇది రెండు దశల ప్రక్రియ, ఒకటి మ్యాప్ ఆపరేషన్, మరోది తగ్గింపు (reduce)ఆపరేషన్.
  కాబట్టి, M MAPPER ప్రాసెసర్, R తగ్గించే (reducer)ప్రాసెసర్ల కన్ఫిగర్ చేయదగిన సంఖ్య, కాబట్టి అది కాన్ఫిగర్ చేయదగినది; అనగా, మీరు మరింత ఎక్కువ బరువు కలిగివుండే మ్యాపర్ (mapper)మరియు తగ్గింపుదారుని కలిగి ఉండవచ్చు.
  మాప్ దశను తగ్గించండి.
  మేము మాప్ దశలో చూస్తే ప్రతి మ్యాపర్ (mapper) ప్రపంచ ఫైలు నుండి ఇన్పుట(ఇన్పుట్)యొక్క m ద్వారా సుమారు ఒకటి చదువుతుంది.
  ఇది మొత్తం డేటా d కాదు, కానీ డేటా యొక్క భాగం చదివేది.
  మ్యాప్ ఆపరేషన్ (operation)కీ విలువ జత యొక్క ఒక సెట్ విలువ కీ విలువ జత సెట్ పరివర్తించడం కలిగి.
  ఏ మ్యాప్ (map)చేస్తుంది, ఇది కీ విలువ జత యొక్క ఒక సెట్ కీ విలువ జత మరొక సెట్.
  ఈకాడ k 1 v1 కు k 2 v2 ని మ్యాప్ చేయండి.
  ప్రతి మాపెర్ గణన ఫలితాలను ప్రతి ఒక ప్రతి ఫైల్లో (file)వ్రాస్తాడు.
  ఇది ఏమి చేస్తుంది, ఇది ప్రాథమికంగా ప్రతి తగ్గింపుకు ఇది ఒక ఫైల్ను(file) ఉత్పత్తి చేస్తుంది.
  తగ్గింపుదారులు R 1, R 2, R 3 ఒక mapper m ఉంటే, నేను తగ్గింపుకు సంబంధించిన మూడు ఫైళ్లను సృష్టించాను.
  ఫైళ్లు ఒక కీ ద్వారా క్రమబద్ధీకరించబడతాయి మరియు ఒక స్థానిక ఫైల్ సిస్టమ్స్ లో (system) నిల్వ చేయబడతాయి.
  మాస్టర్ ఈ ఫైళ్ళ స్థానాన్ని ట్రాక్ (track)చేస్తుంది.
  ఇక్కడ మాస్టర్ మాప్ను మాస్టర్ను తగ్గించవచ్చు, దీని వలన ఫైల్ యొక్క ఈ ప్రదేశం యొక్క శ్రద్ధ వహించబడుతుంది, ప్రతి మ్యాపెర్ (mapper)ప్రతి రిడ్యూసర్స్ కోసం ఒక ఫైల్ను ఉత్పత్తి చేస్తుంది మరియు ఫైల్లు స్థానిక డిస్క్ (disk)ద్విపార్టీలో నిల్వ చేయబడిన సంరక్షణను తీసుకుంటాయి.
  తగ్గింపు దశలో, పాక్షిక గణన సంబంధిత మాపెర్స్ యొక్క స్థానిక ఫైల్ సిస్టమ్స్లో నిల్వ చేయబడిన రీడ్యూసర్లు యజమానికి తెలియచేస్తుంది; దీని అర్థం, తగ్గింపు దశలో తగ్గింపుదారు ఈ మాస్టర్ను సంప్రదించి దాని సంబంధిత ఫైల్స్ ప్రతి మాపెర్ (mapper)ఫంక్షన్లకు అనుగుణంగా ఎక్కడ నిల్వ చేయబడతాయో తెలియజేస్తుంది.
  Reducer ఫైళ్ళను పొందటానికి మాపర్స్కు రిమోట్ ప్రక్రియ కాల్ చేస్తుంది.
  రీపెర్టర్ మాపెర్ కోసం రిమోట్ విధానం కాల్ చేస్తుంది.
  కాబట్టి, మ్యాపర్ (mapper)అది డిస్క్లోఎక్కడా ఉంటుంది మరియు వివిధ రకాల VMs etcetera తో విభిన్న నిర్మాణంలో ఉండవచ్చు, అంతేకాకుండా ఇది భౌగోళికంగా పంపిణీ చేయబడదు, ఆ విషయాలు పనిచేయవు.
  అయితే, అయినప్పటికీ ఇది మ్యాపర్ చేత ఉత్పత్తి చేయబడిన నిర్దిష్ట డేటాపై పని చేస్తుంది.
  అందువల్ల, ప్రతి తగ్గింపు సమూహం యొక్క దశలు కీ ఫంక్షన్ f మొదలైనవాటిని ఉపయోగించి ఒకే కీ విలువకు కారణమవుతాయి, కాబట్టి k 2 v 2 k 2 f 2 v 2. కాబట్టి, సేకరించిన ఫంక్షన్ ఇక్కడ అమలులోకి వస్తుంది.
  ఇతర అర్థంలో, మేము మా సమస్య గుర్తుంచుకోవాలి ఉంటే.
  ప్రతి డిఓసి, ప్రతి కీ లేదా ప్రతి పదం మేము ఫ్రీక్వెన్సీని లెక్కించాలనుకుంటున్నాము, కాబట్టి ఫంక్షనల్ మోడల్ విషయాలు యొక్క ఫ్రీక్వెన్సీలను సంక్షిప్తం చేస్తుంది, ఇది విభిన్న రకాలైన విషయాల కోసం భిన్నంగా ఉంటుంది.
  అది ఆక్సెస్ 2 లో v etcetera లో k 2 చేస్తుంది. 
  ఇక్కడ మరొక కీ విలువ కోసం ఇది వెళ్తుంది.
  అంతిమ ఫలితాలు తిరిగి GFS ఫైల్ సిస్టమ్కు గూగుల్ ఫైల్ సిస్టమ్కు తిరిగి వస్తాయి.
  మాప్ రెడ్యూసర్(map reducer).
  ఇక్కడ చూస్తే 3 మ్యాపర్(mappers)లు , 2 రీడ్యూసర్ (reducers)లు ఉన్నాయి.
  మా విషయంలో ఈ మాప్ ఫంక్షన్(map function) డేటా D W1, W2, Wn నే సమితి, మరియు అది ప్రతి కన్నా లెక్కింపు కోసం లెక్కించబడుతుంది, ఇది మ్యాపర్ (mapper)యొక్క భాగాన్ని ఎంతవరకు కలిగి ఉంటుంది.
  ప్రతి y కి, ఇది లెక్కింపబడుతుంది.
  మీరు d1 చూసినట్లైతే, అది w1, w2, w4 కలిగి ఉంటే; d2 ఈ విషయాలు మరియు ఇది ఈ గణనలు.
  ప్రతి మ్యాపర్ (mapper)అది చేస్తుంది, మరియు అది ప్రధానంగా రీడ్యూసర్(reducer)read ఇంటర్మీడియట్ ప్రదేశంలో నిల్వ చేస్తుంది.
  ఈ ప్రతి విషయాల కోసం ప్రతి ఫైల్(file) ను సృష్టిస్తుంది, ఇది ఒక నిర్ధిష్ట ఫైల్(file) ను ఉత్పత్తి చేస్తుంది.
  రెండు రెడ్యూసర్(reducers) లు ఉన్నాయి.
  రెండు మాడ్యూల్(module) కోసం ప్రతి మ్యాపర్(mapper) ఫైల్ను(file) ఉత్పత్తి చేస్తుంది.
  ఇది w1, w2, w1, w1 గా 7 గా ఉంటుంది. W2 ఏదో 15 గా ఉంటుంది.
  ఈ సందర్భంలో, w3, w4 ఇతర రెండు.
  రెడ్యూసర్(reducers) లు మ్యాపర్స్ అవుట్పుట్ (output)నుండి ఇన్పుట్ను (input) పొందడానికి మ్యాపర్ (mapper)యొక్క ఫలితాల నుండి లేదా ఇన్పుట్ల (input)నుండి విషయం తగ్గిస్తుంది.
  మాప్ రెడ్యూస్ (map reducer)అనేధి ఒక ఫాల్ట్ తొలరెన్స్ (fault tolarence); అది చూడడానికి వేరొక మార్గం ఉంది,ఇధి హేయర్త్బ్ బీట్ సందేశం.
  కాబట్టి, ప్రతి ప్రత్యేక సమయ వ్యవధిలో, ఇది ప్రత్యక్ష మరియు రకాలైన విషయాలను సూచిస్తుంది.
  కమ్యూనికేషన్(communication) ఉనికిలో ఉంది, అయితే కమ్యూనికేషన్ ఉన్నట్లయితే పురోగతి నిపుణులు లేరు, కానీ ఎటువంటి పురోగతి యజమాని ఆ పనులను నకిలీ చేయలేదు మరియు ఇప్పటికే పూర్తయిన ప్రాసెసర్ (processor)లేదా కొన్ని ఉచిత ప్రాసెసర్లను (processor)కేటాయించారు.
  Mapper విఫలమైతే, తిరిగి అమలులో ఉన్న మరొక పని నోడ్కు (node) దాని యొక్క ముఖ్య విలువను MAPPER నియమిస్తుంది.
  కాబట్టి, అది వైఫల్యం అయితే, దాన్ని తిరిగి అమలు చేయండి.
  రీడ్యూసర్ (reducer)విఫలమైతే మిగిలిన విధిని మరొక నోడ్కు(node)తిరిగి అప్పగించాల్సిన అవసరం ఉంది.
  పూర్తయిన పనులు అప్పటికే Google ఫైల్ సిస్టమ్కు తిరిగి వ్రాయబడ్డాయి.
  కాబట్టి, పూర్తిఐన పనులు ఉన్నట్లయితే, వారు ఇప్పటికే Google ఫైల్ సిస్టమ్స్లో మాత్రమే మిగిలివుండే మిగిలిన కార్యాలను తిరిగి కేటాయించాల్సిన అవసరం ఉంది.
  Map Reduce యొక్క సామర్థ్యాన్ని మీరు లెక్కించాలనుకుంటే, డేటా D పరిమాణంపై సాధారణ గణన పని. 
  కాబట్టి, డేటాను చదవడానికి యూని-ప్రాసెసర్ (uni-processor) చదవవలసిన సమయానికి D సమయం పడుతుంది. డిక్లరేషన్ చేస్తున్న డిస్క్ (disk)తిరిగి డిస్క్కి వ్రాస్తుంది.
  చదవటానికి సమయం ఒక పదం నుండి డిస్క్కు c ఉంది.
  మీ వంటి దశలను తగ్గిస్తుంది, D డేటా ఉత్పత్తి మరియు అవుట్పుట్ (output)rho d లో, దశను తగ్గించేందుకు సమయం Cr rho D ను తగ్గిస్తుంది మరియు అవుట్పుట్ వద్ద ఉత్పత్తి చేయబడిన డేటా సిగ్మా mu D.
  కు తగ్గించబడింది. 
  కష్టం. 
  ప్రతి మ్యాపర్ (mapper)పని చేస్తున్న సమయం ఎంత మేపుతుందో మ్యాపింగ్ (mapping)చేస్తున్నది, ఇది ప్రతి మ్యానుగుణంగా ఉంటుంది, ఇది ప్రతి క్షేత్రంతో లెక్కించినప్పుడు తగ్గించే సమయం తగ్గించటానికి ఎంత సమయం పడుతుంది మరియు చివరికి మనకు తగ్గింపు ఉత్పాదన ఉంటుంది.
  పనులను మాప్ (map)లోకి డీకొంపోసింగ్(decomposing)మరియు దశలను తగ్గించడానికి ఎలాంటి ఓవర్ హెడ్స్ని పరిగణనలోకి తీసుకోకపోతే, మేము ఈ క్రింది సంబంధాన్ని కలిగి ఉండవచ్చు.
  మనస్తీకరణను మ్యాపింగ్(mapping) మరియు తగ్గించడం మనం మరచిపోయినట్లయితే, మనము ఈ విషయాల సమ్మషన్ను కలిగి ఉండవచ్చు.
  ఇపుడు, P సమస్యలను పరిష్కరించుటకు దశల మధ్య సంబంధం లేకుండా మాపుర్ (mapper)మరియు తగ్గింపుదారుడిగా పనిచేసే P ప్రాసెసర్లను (processor)కలిగి ఉన్నట్లయితే.
  మేము P ప్రాసెసర్ను (processor)ఉపయోగిస్తుంటే కొన్నిసార్లు ఇది ఒక మ్యాపర్గా(mapper) పనిచేస్తుంది, కొన్నిసార్లు ఒక తగ్గించే వ్యక్తిగా పని చేస్తుంది.
  అప్పుడు మనం అదనపు భారాన్ని కలిగివుంటాయి, మనకు స్థానికంగా కొన్ని అదనపు భారాలు ఉన్నాయి, తరువాత స్థానిక డిస్కుకి(disk) వ్రాస్తుంది, తరువాత ప్రతి రిస్క్యూర్ డిస్కుకు రిమోట్ గా చదవబడుతుంది.
  స్థానికంగా లేదా సుదూరంగా ఒక పదం చదవడానికి విశ్లేషణ ప్రయోజనం సమయం కోసం, మాకు అదే పరిగణలోకి తెలపండి.
  డిస్క్ నుండి ఒక డేటాను చదివే సమయం ప్రతి మ్యాపర్‌కు, ప్రాసెసర్ల సంఖ్య P తో w సంఖ్య అయితే, P డేటా D నుండి P వరకు ఉంటుంది. 
  నిర్మాత మాపర్, R అనేది D నుండి R.
  డిస్క్ (disk)తిరిగి వ్రాయడానికి సమయం అవసరం ఎందుకంటే మీరు చదివిన తర్వాత మీరు గణన తర్వాత కలిగి, మీరు ఆ తిరిగి వ్రాయడానికి కలిగి చాలా ఉంది.
  ప్రతి విభజన నుండి ప్రతి రిపోర్జర్ ప్రతి మాపర్స్ ద్వారా చదివిన డేటా పి మ్యాపర్ లు D ద్వారా Pద్వారా ఉంటాయి P.
  P స్క్వేర్ (p square)ద్వారా ro D.
  మనం లెక్కించినట్లయితే, మాప్ యొక్క సమాంతర సామర్థ్యం అమలును తగ్గించడం వల్ల, ఇది 1, 1 నుండి 2 ప్లస్ 2 సిలను W లోకి W లోకి తెస్తుంది. 
  ఇప్పుడు,ఈ మేము ఇక్కడ parallel efficiency పొందండి ఏమిటి.
  ఇప్పుడు, ఇండెక్సింగ్ మ్యాప్ (indexing map) తగ్గించబడితే, అనేక రకాలైన దరఖాస్తులు ఉన్నట్లయితే, ఒక డాక్యుమెంట్ల(documents) యొక్క పెద్ద సేకరణను ఇండెక్స్(index) చేస్తుంది, తద్వారా ఇది ప్రాథమికంగా గూగుల్ (Google) యొక్క ప్రధాన ప్రేరణలో ఒకటి.
  వెబ్ సర్చ్(web search) కోసం అలాగే handling structured data నిర్వహణ కోసం ముఖ్యమైన అంశం.
  మ్యాప్ టాస్క్(map task) ఒక పదం డాక్యుమెంట్ను(document), రికార్డు ఐడి(record id) జతని ప్రతి పదం కొరకు ఉంచుతుంది, ప్రతి పదం D కిలోనికి w 1 ను మ్యాప్లోకి w 1 లోకి w d k లోకి చూశాము.
  నేను కొన్ని విధమైన సూచికలను కలిగి ఉంటుంది, అవి దశల సమూహాలను పదాల జతను తగ్గించగలవు మరియు అంశంలోకి ప్రవేశించగలవు.
  మ్యాప్ను తగ్గించడం ద్వారా సంబంధిత కార్యకలాపాలలో అప్లికేషన్లు(applications) ఉన్నాయి.
  SQL స్టేట్మెంట్స్ రిలేషనల్ చేరడానికి, పెద్ద సమూహం డేటా ద్వారా సమూహం అమలు.
  సమాంతర దత్తాంశ బేస్ యొక్క ప్రయోజనాలు పెద్ద ఎత్తున తప్పు సహనం మేము దోపిడీ చేయాలనుకుంటున్నాము మరియు మేము ఇది వంటి ఫంక్షన్ ఆ రకమైన కలిగి ఉంటుంది మేము అది మేము చేయగల వంటి నిబంధన మరియు రకం ద్వారా ఒక సమూహం అని చూసిన, తద్వారా రిలేషనల్ కార్యకలాపాలు విధమైన మేము అమలు.
  వీటితో మేము నేటి చర్చకు ఈ ముగింపు వరకు వచ్చాము.
  మీరు Map Reduce paradigm యొక్క అవలోకనాన్ని అందించడానికి ఇక్కడ చేయడానికి ప్రయత్నించేది ఏమిటంటే ఒక సమస్య సమాంతర మరణశిక్షల సమితిగా విభజించబడగలదు,ఇది ఇంటర్మీడియట్ ఫలితాలను సృష్టించే మ్యాప్పర్ నోడ్(mapper node).
  మరియు ఈ డేటాను తీసుకుని, తుది ఫలితాలను సరిగ్గా సృష్టించే రీడ్యూసర్ నోడ్(reducer nodes)ల సమితి ఉంది.
  మరియు మనం కొన్ని ఉత్పాదక విషయాలకు డేటా ఫైల్(file) ను సృష్టించే ఆసక్తికరంగా ఉన్న కొన్ని విషయాలు ఇక్కడ ఉన్నాయి.
  డేటా తగ్గింపుకు సృష్టించబడుతుంది.
  అక్కడ ఉన్న డేటాను అక్కడ తగ్గించేవాడు తెలుసు.
  ఓవర్ మరియు పైన ఒక మాస్టర్ నియంత్రిక లేదా మ్యాప్ రీడ్యూసర్(map reducer) మాస్టర్(master) విషయాలు ఉన్నాయి ఇది ఎక్కడ డేటా మ్యాపర్(mapper) ద్వారా నిల్వ ఇక్కడ విషయాలు మరియు రీడ్యూసర్(reducer) ఎలా చదువుతాడో తెలుసు.
  మ్యాపర్(mapper) ని నోడ్(node) పునఃప్రారంభించాలనేది విఫలమైతే; రీడ్యూసర్ నోడ్(reducer node) విఫలమైతే, పునఃప్రారంభించాలంటే ఎలా జరుగుతుంది లేదా అమలు చేయని డేటాను అమలు చేయని చర్యలు ఇంకా అమలు చేయబడని చర్యలు ఇంకా అమలు చేయబడవు.
  ఈ రోజు మేము మా ఉపన్యాసంను ఆపివేస్తము.
  ధన్యవాదాలు.