audio audioduration (s) 1.58 21.7 | text stringlengths 40 415 |
|---|---|
మా office లో చాలా సార్లు కొంతమంది Java fast అంటారు. ఇంకొంతమంది Java కాదు Node.js ఇంకా fast గా ఉంటది అంటారు. కొంతమందైతే ఆ రెండూ కాదు Python సూపర్ గా ఉంటది అంటారు. ఇంకొంతమంది వేరేగా వచ్చి ఆ మూడు కాదు గాని Go, Rust అని రెండు languages ఉన్నాయి అవైతే సూపర్ గా ఉంటాయి అంటారు | |
అసలు నాకు ఎప్పుడు doubt ఏంటంటే ఎలా decide చేస్తారు ఏ language fast అని చెప్పేసని? So, ఈ decision తీసుకోవడం కోసం మనం ఏం చేద్దాం అంటే ఈరోజు ఒక చిన్న experiment చేద్దాం. ఈ experimentలో ఏం చేస్తామంటే ఒక API తీసుకుందాం | |
మనం ఎప్పుడూ వాడే ఒక authentication API. దాంట్లో username, password ఇస్తే అది మనకి correct ఆ కాదా అని చెప్పేసి అని మనకి response ఇస్తది. ఇప్పుడు API ని మనం different languages తో రాద్దాం. రాసిన తర్వాత ప్రతి language కి మనం ఒకేసారి ఒక one lakh request ని hit చేద్దాం. hit చేసిన తర్వాత... | |
అసలు ఆ language ఆ request ని ఎలా process చేస్తుంది, ఎంత time లో finish చేస్తుంది అనే దాన్ని చూద్దాం. దీన్ని బట్టి maybe మనకు కొంత idea రావచ్చు అన్న。 ఇప్పుడు ఈ video లోపలికి వెళ్ళగానే మనకి mainly ఇక్కడ observe చేస్తే ఒక front end ఉంది, ఒక back end ఉంది, అలాగే ఒక database ఉంది | |
Front end నుంచి నువ్వు user name, password పంపించగానే అవి first back end దగ్గరికి వెళ్తాయి. Back end లోకి వెళ్లగానే back end లో మనం ఏం చేస్తాం? First దాన్ని ఒక http request లాగా process చేస్తాం. దాని తర్వాత DB నుంచి user ని తెచ్చుకుంటాం. | |
దాని తర్వాత password ని match చేస్తాం. Match చేసిన తర్వాత response ఇస్తాం. Okay నా? ఇప్పుడు ఈ విధంగా నీ request అనేది process అవుతుంది. ఇప్పుడు మన experiment కోసం ఏం చేద్దాం అంటే DB నుంచి వచ్చే response ఎప్పుడూ hundred milliseconds ఉంటదని చెప్పేసి fix చేసి వెళ్దాం. At the same time ఈ backend machine కి ఒక configuration... | |
దాని తర్వాత దానికి ఒక 8GB RAM ఉందనుకుందాము. At the same time one core CPU ఉందనుకుందాం. ఓకే నా? ఇప్పుడు ఈ explanation తోని మనం different languages లో ఇది ఎలా work అవుద్ది అనేది చూద్దాం. వీటిలోకి వెళ్లే ముందు మనం main గా ఒక OS concept తెలుసుకుందాం. | |
ఆ OS concept ఏంటి అంటే, let's say మీది మీ computer లోని ఇదొక application layer ఇదొక OS layer. okay నా? ఇది మీ CPU. CPU పని ఏంటి? instructions ని execute చేయడం. CPU కి instructions ఎవరు ఇస్తారు? CPU కి ఒక thread ఉంటది అన్నమాట OS layer లో | |
ఈ thread పని ఏంటంటే, మీరు ఈ thread కి instructions ఇచ్చారనుకోండి, ఆ thread ఏం చేస్తుందంటే CPU దగ్గరికి ఆ instructions పట్టుకెళ్ళి execute చేయించుకుంటాది. ఓకేనా? ఇప్పుడు అదే మీ దగ్గర చాలా ఎక్కువ threads ఉన్నాయనుకో, అప్పుడు ఎలాగవుతది? CPU at any point of time ఒకటే thread execute చేయగలదు. | |
దానికోసం OS scheduler అని ఒకటి ఉంటాదన్నమాట. ఈ OS scheduler ఏం చేస్తది అంటే మీ దగ్గర multiple threads ఉన్నాయనుకోండి, అది CPU కి కాసేపు ఈ thread ఇస్తది, కాసేపు ఈ thread ఇస్తది, కాసేపు ఈ thread ఇస్తది, కాసేపు ఈ thread ఇస్తది. | |
అలాగా threads ని మారుస్తూ ఉంటాదన్నమాట. ఓకే నా? ఇప్పుడు ఒక thread నుంచి ఇంకో thread కి మార్చే time లో ఏమవుద్ధంటే కాస్త CPU time అనేది waste అయిపోద్ధన్నమాట. దాన్నే మనం context switching అంటాం. ఓకే నా? ఇది basic knowledge. ఇప్పుడు ఈ knowledge use చేసుకుని different different languages దీన్ని ఎలా వాడుకుంటున్నారు అనేది మనం ... | |
ముందుగా మనం Java దగ్గరికి వద్దాం. ఇక్కడ మీరు Java లో observe చేస్తే ఇది spring boot లో నేను రాసాను అనమాట. ఈ spring boot లోని ఈ method చూస్తే ఇది verify password అనేది exact గా చేస్తుంది. | |
దీంట్లో ఒక email ఉంది ఒక password అనేది. ఇది నేను arguments గా pass చేస్తే first నేను user ని database నుంచి తెచ్చుకుంటున్నాను. దాని తర్వాతేమో ఆ user ఉన్నాడా లేదా అని check చేసుకుంటున్నాను. దాని తర్వాత password ని match చేస్తున్నాను. Match చేసిన తర్వాత true or false అని చెప్పేసి return చేస్తున్నాను. | |
ఇప్పుడు ఈ code అనేది Java లో రాసింది exact గా internal గా ఎలా work అవుద్ది అంటే, ఇలాంటి architecture అనేది లోపట ఉంటదన్నమాట. ఓకే నా? ఇది application layer, ఇది OS layer | |
ఈ application layer లో మన spring boot server అయిన Tomcat ని run చేస్తున్నాం. Okay నా? ఇప్పుడు నువ్వు let's say నీకు ఒక request రాగానే authentication request రాగానే Tomcat ఏం చేస్తుందంటే నీకోసం ఒక OS thread ని create చేస్తదన్నమాట. నువ్వు ఇంకో request చేశావనుకో, నీకోసం ఇంకో, ఇంకో OS thread create చేస్తది | |
అదే time లో నువ్వు ఇంకో request చేశావనుకో, నీకోసం ఇంకో OS thread create చేస్తదన్నమాట. Okay. ప్రతి request కి ఒక కొత్త OS thread create చేస్తది | |
ఇప్పుడు ఈ OS thread అనేది దగ్గర దగ్గరగా ఒక one MB space దాకా తీసుకుంటుంది. ఇప్పుడు మనకి ఏమనిపిస్తాది? Total గా one lakh requests ఒకేసారి వస్తాయి కాబట్టి one lakh OS threads create చేస్తది అనుకుంటాం | |
Which is not completely true అనమాట. ఎందుకంటే ఒక OS thread అనేది one MB ఉంది. మన RAM ఏ eight GB. మన RAM eight GB లో ఆ OS threads అన్ని పట్టవు. అది first problem. Second problem ఏంటంటే పట్టినా కూడానూ | |
చాలా ఎక్కువ OS threads create చేస్తే ఏమవుతది? మీ CPU అనేది చాలా ఎక్కువ threads ని జంపింగ్ చేయాల్సి వస్తది అనమాట. దానివల్ల context switching అనేది చాలా ఎక్కువ ఉంటది. సో చాలా ఎక్కువ time waste అనేది context switching లోనే పోతూ ఉంటది అనమాట | |
సో, అందుకే Tomcat ఏం చేస్తుందంటే thread pool అనే concept తెచ్చిందన్నమాట. ఈ thread pool లో ఏంటంటే max నువ్వు let's say ఒక four hundred threads మాత్రమే create చేసుకోగలవు OS అని చెప్పేస్తాదన్నమాట | |
సో ఇప్పుడు నువ్వు one lakh request చేసినా కూడానూ first four hundred OS threads మాత్రమే create చేస్తాయన్నమాట. మిగిలిన requests అన్నీ కూడానూ ఇలాగ Tomcat దగ్గర ఒక queue ఉంటది. ఆ queue లో నీ ninety nine thousand six hundred requests అనేవి అక్కడ wait చేస్తూ ఉంటాయి. ఓకే నా? | |
ఇప్పుడు ఏమవుతది? Let's say ఇప్పుడు ఈ OS thread ఒక request ని తీసుకుంది. request ని తీసుకోగానే CPU దగ్గరికి వెళ్లి HTTP request ని create చేయించుకుంది. Okay నా? create చేయించుకున్న తర్వాత next ఏం చేయాలి? DB call చేయాలి. ఈ DB call చేయడం కోసం అది DB ని call చేస్తది. DB call చేసే time లో CPU పని అసలు ఏమీ ఉండదన్నమాట. So ఈ t... | |
ఎప్పుడైతే DB call నుంచి response వచ్చేస్తాదో అప్పుడు ఏమవుతది password match చేస్తాది. Password match కి మళ్ళీ CPU అవసరం ఉంటది. సో, నీ OS thread అనేది CPU దగ్గరికి వెళ్లి instructions execute చేయించుకుంటుంది | |
దాంతోటి response creation. Response creation అప్పుడు కూడానూ OS thread కి CPU అవసరం ఉంటది. ఇదంతా అయిపోయిన తర్వాత నీకు ఆ response ఇచ్చేసి ఈ OS thread ఖాళీ అయిపోద్ది అనమాట. | |
ఖాళీ అయిపోయినప్పుడు ఈ ninety nine thousand six hundred లో ఒక request అనేది ఈ OS thread ని మళ్ళీ తీసుకుంటుందన్నమాట. సో, ఈ విధంగా మీ requests అన్నీ మెల్లమెల్లగా process అవుతూ ఉంటాయన్నమాట. ఇప్పుడు ఈ one lakh request complete అవడానికి rough గా ఎంత time తీసుకుంటుందనుకుంటాం? Let's say ఒక | |
Hundred seconds తీసుకుందనుకుందాం. Hundred seconds లో ఈ one lakh requests process అవుతాయి. అసలు ఎందుకు ఈ hundred seconds తీసుకుంటుంది అని మనం observe చేస్తే, కొంత time ఏమో CPU time. అంటే ఏంటంటే, అసలు CPU లోని instructions అన్ని instructions execute చేయడానికి ఎంత time తీసుకుంటుంది? | |
Second time ఏం తీసుకుంటాది? DB call. DB call చేయడానికి ప్రతి request ఎల్సెమ్ తీసుకుంటాది. Third thing ఏంటి? Third thing ఏంటంటే context switching | |
అసలు ప్రతిసారి ఇన్ని requests ఉంటున్నప్పుడు ఎంత context switching అనేది time waste అవుతుంది అనేది third. Fourth thing ఏంటి అంటే garbage collector | |
ఇప్పుడు ఒక request రాగానే ఆ request కోసం కొన్ని objects create చేస్తున్నాం కదా. ఇప్పుడు ఆ request complete అయిపోగానే objects delete చేయాలి కదా. objects ని ఎవరు delete చేస్తారు? అది ఒక garbage collector delete చేస్తాదన్నమాట. | |
సో ఆ garbage collector కూడా మళ్ళీ CPU కొంత time అవసరం వస్తది. సో ఈ విధంగా నీ hundred seconds అనేది ఈ విధంగా distribute అయి ఉంటదన్నమాట. ఇప్పుడు మనం ఏం చేద్దాం అంటే చాలా popular thing అయిన note చేసికెళ్దాం. | |
Node JS లోని code అనేది ఈ విధంగా ఉంటాదన్నమాట. దీంట్లో మీరు observe చేస్తే verify password కి ఒక arguments ఉన్నాయి. దాని తర్వాత database query చేస్తున్నాను username check చేస్తున్నాను | |
దాని తర్వాత passwords match చేస్తాను return చేస్తాను. similar code ఏ only thing ఏంటంటే syntax మారుతూ ఉంటది. ఇప్పుడు ఈ code అనేది internal గా ఎలా work అవుతది అంటే | |
ఈ విధంగా ఒక architecture ఉంటాదన్నమాట. దీంట్లో మీరు observe చేస్తే ఒక application layer ఉంది, ఒక OS layer ఉంది. Okay నా? ఇప్పుడు దీనికి మీరు ఒక request చేశారనుకోండి... | |
Request చేయగానే ఆ request అనేది first మీ request ని ఒక queue లో పెట్టుకుంటాదన్నమాట. దాని తర్వాత మీరు ఇంకో request చేశారనుకోండి, దాన్ని కూడా ఈ queue లో పెట్టుకుంటాదన్నమాట. మీరు ఇంకో request చేస్తే దాన్ని కూడా queue లో పెట్టుకుంటాదన్నమాట. అలాగ మీరు చేసిన requests అన్నీ queue లో ఉంటాయి. దాని తర్వాత దీని దగ్గర Node.js లోని | |
Java లాగా multiple OS threads ఉండవన్నమాట. ఒకటే OS thread ఉంటది. ఓకే నా? at the same time దీంట్లోని event loop అని ఒకటి ఉంటాదన్నమాట. ఈ event loop ఏం చేస్తదంటే, event loop అంటే మళ్ళీ మీరు confuse అయిపోకండా, just ఒక while loop లాంటిది అన్నమాట. | |
ఈ event loop ఏం చేస్తుందంటే, మీ request ని తీసుకుంటది. తీసుకుని ఒక OS thread కి assign చేస్తాది. OS thread ఏం చేస్తాది? CPU దగ్గరికి వెళ్లి మీ instructions execute చేసుకుంటాదన్నమాట. ఓకేనా? మన instructions ఏంటి? First http request create చేయడం, database ని call చేయడం. | |
సో http request create చేసింది CPU తోని. దాని తర్వాత database call చేయాలి. Database call చేసే time లో CPU పని లేదని మనకు తెలుసు. ఆ time లో ఇది ఖాళీగా ఉంటాదన్నమాట | |
ఈ ఖాళీగా ఉండే time లో ఈ event loop ఏం చేస్తుందంటే ఖాళీగా నువ్వు OS thread ని ఎందుకు ఉంచుకోవడం, నువ్వు వెనక్కి వచ్చేయ్ అని చెప్పేసి అని దాన్ని RAM లో store చేస్తుందన్నమాట. దాన్ని closures అంటారు. ఈ time లో ఏం చేస్తుందంటే queue లో ఉన్న next request ని తీసుకొచ్చి OS thread కి ఇస్తుంది. | |
OS thread ఏం చేస్తది? మళ్ళీ CPU దగ్గరికి వెళ్లి instructions execute చేసుకుని ఇప్పుడు ఇది కూడా database ని call చేయాలంటే, "నువ్వు మళ్ళీ OS thread ని ఎందుకు waste చేయను" అని చెప్పేసని దాన్నే పట్టుకొచ్చేస్తుంది అన్నమాట. | |
క్యూ లో ఉన్న ఇంకో request ని OS thread కి ఇస్తుందన్నమాట. అది కూడా database call చేస్తుందనుకో, దాన్ని కూడా తీసేస్తుందన్నమాట. ఇప్పుడు మనం store చేసిన closures ఏంటి? అసలు ఆ request అనేది ఏ level వరకు execute అయ్యింది, దాంట్లో ఏ variables ఉన్నాయి, అలాగా ఆ request యొక్క state ని మనం ఇక్కడ closure లో store చేసుకుంటాం అన్నమాట... | |
ఇప్పుడు ఎప్పుడైతే database call వచ్చేస్తదో అప్పుడు వీటిని మళ్ళీ మనం queue లో పెట్టేస్తాం. ఇప్పుడు event loop ఏం చేస్తది? ఈ request ని తీసుకొచ్చి మళ్ళీ OS thread కి assign చేస్తాది | |
OS thread create చేసి దాని తర్వాత ఏమవుతది? Password matching దాని తర్వాత response creation. Password matching response creation అయిపోయిన తర్వాత మనం user కి response ఇచ్చేస్తాం. | |
దాని తర్వాత దీని response కూడా వచ్చిందనుకో database నుంచి, అది కూడా మళ్ళీ queue లోకి వెళ్తాది. దీని response కూడా database నుంచి వచ్చిందనుకోండి, ఇది కూడా queue లోకి వెళ్తాది | |
అలాగా ఇక్కడ మీరు observe చేస్తే ఒకటే OS thread ఒకటే event loop తోని మీ అన్ని requests sequential గా వెళ్తూ ఉంటాయి అన్నమాట | |
ఓకే నా, ఇక్కడ మీరు observe చేస్తే ఒకటే OS thread ని ఖాళీగా ఉంచకుండా effective గా node.js అనేది వాడుకుంటాదన్నమాట. ఇప్పుడు node.js లోని ఒకటే OS thread వల్ల problem కూడా ఉందన్నమాట. అదేంటి అంటే | |
పొరపాటున ఇప్పుడు మీరు ఒక request ఇచ్చారు. ఇప్పుడు ఈ request అనేది చాలా ఎక్కువ సేపు CP దగ్గర తీసుకుందనుకోండి | |
మీ ఒక్క OS thread ఇక్కడే stuck అయిపోయి ఉండిపోద్ది. Event loop ఇంకోదానికి assign చేయడానికి అసలు మీకు OS threads ఏ లేవన్నమాట. సో, అందుకే మరీ heavy CPU work ఉన్న దగ్గర మనం ఈ ఒక్కటే OS thread అనేది అంత effective కాదన్నమాట | |
ఇప్పుడు ఈ one lakh request ని process చేయాలంటే మనకి దగ్గర దగ్గరగా ఒక hundred seconds తీసుకుందనుకోండి | |
ఓకే నా, ఈ hundred seconds ఎక్కడ తీసుకుంటాది? first ఏమో object creation ఇదంతా, అదంతా CPU పని. next ఏమో DB calls | |
DB calls CPU పైన పని ఏం ఉండదు. దాని తర్వాత ఏమవుతది? దీంట్లో context switching అనేది లేదు. ఎందుకు? ఒకటే OS thread కాబట్టి context switching ఏ లేదు. Third thing ఏంటి అంటే garbage collector | |
దీంట్లో కూడా garbage collect ఉంటది. garbage collect ఏం చేద్దంటే, మీ request అయిపోయిన తర్వాత మీ request లో ఉన్న objects అన్నిటినీ కూడా delete చేస్తాదన్నమాట. దానికి కూడా CPU అవసరం ఉంటది. | |
సో ఈ విధంగా Node.js అనేది మీ request ని handle చేస్తుంది. ఇప్పుడు అందరికీ favourite అయిన Python దగ్గరికి వెళదాం | |
Python లో మీరు observe చేస్తే code అనేది ఇలా ఉంటాదన్నమాట | |
దీంట్లో కూడాను email password ఇదంతా వస్తది database call చేస్తాను user లేకపోతే false return చేస్తాను passwords match చేస్తాను return చేస్తాను. so similar code ఏ only thing ఏంటంటే syntax మారుతది. | |
ఇప్పుడు Python యొక్క internal architecture మనం observe చేస్తే, అది కూడా somewhat similar Node.js లాగే ఉందన్నమాట. దాంట్లో కూడా ఒక event loop ఉంది, ఒక queue ఉంది, ఒక OS thread ఉంది, CPU ఉంది. | |
సో ఇప్పుడు మీరు request ఇచ్చారనుకోండి ఆ request ని మనం note jass లాగానే first ఒక queue లో పెట్టుకుంటాం | |
ఇంకో request వస్తే దాన్ని కూడా queue లో పెట్టుకుంటాం. ఓకే నా? ఇప్పుడు event loop ఏం చేస్తుందంటే, మీ request ని OS thread కి assign చేస్తది. OS thread ఏం చేస్తది? CPU దగ్గర పట్టుకెళ్ళి మీ request ని process చేస్తది. | |
ఇప్పుడు నీ request పొరపాటున database call చేయాలనుకో అప్పుడు అది ఏం చేద్దంటే, "నువ్వు OS thread దగ్గర ఎందుకున్నావ్, నువ్వు వెనక్కి వచ్చేయమ్మా" అని చెప్పేసని దాన్ని RAM లో store చేసుకుంటది. | |
Python దీన్ని ఏమంటది అంటే coroutines అంటది అనమాట. మీరు observe చేస్తే ఇదే దాన్ని Node.js ఏమో closures అంటుంది Python అనేది coroutine అంటది | |
Coroutine కూడా same అంతే. ఒక request ఎంత వరకు అయ్యింది అని దాని state ని ఇక్కడ store చేసుకుంటాం అనమాట. ఇది మరీ ఎక్కువ size తీసుకోదు. OS thread అనుకోండి, OS thread one MB size తీసుకుంటది. కానీ ఈ coroutines అంత size తీసుకోవు అనమాట. | |
సో ఇప్పుడు దాని తర్వాత ఏం చేస్తది event loop ఈ request తీసుకుని దాన్ని process చేస్తది. ఇప్పుడు ఈ request response వచ్చింది అనుకోండి, మళ్ళీ అది అలాగ నీ loop లోకి వెళ్తది. సో ఈ విధంగా same Node.js లాగ ఇది కూడా work అవుద్ది అనమాట. | |
సో ఇక్కడ కూడాను మీ one lakh request ని process చేయడానికి మీకు దగ్గిర్ దగ్గిర్ గా ఆ ఒక three hundred seconds తీసుకుంటది అనుకుందాం | |
మీకు doubt రావచ్చు three hundred seconds ఏంటి node.js లాగే అంటున్నారు కదా node.js కన్నా ఎక్కువ సేపు ఎందుకు తీసుకుంటుంది అని చెప్పేసి అని. ఈ three hundred seconds మనం ఎందుకు తీసుకుంటున్నాం? first ఏమో object creation | |
అంతేనా object creation దగ్గర ఎక్కువ CPU work ఉంటది. దాని తర్వాత ఏమవుతది DB calls DB calls అన్నిటికి fix అని దాని తర్వాత garbage collector garbage collector దీంట్లో కూడా ఉంది. | |
ఓకే నా కాకపోతే ఇక్కడ ఎక్కువ time ఎక్కడ తీసుకుంటది అంటే object creation దగ్గర తీసుకుంటది అనమాట | |
ఎందుకు అంటే Node JS గాని Python గాని ఇవన్నీ ఏంటి అంటే, ఇవన్నీ static languages కాదు. Static languages కాదంటే అర్థం ఏంటంటే, for example ఇప్పుడు Java లో నేను int I equals to four అన్నాననుకో, దానికి ముందే చెప్పేస్తాను ఇది ఒక integer అని చెప్పేస్తాను. | |
దీని వల్ల ఏంటి అంటే అది RAM లోని అంతే స్టో-- స్పేస్ తీసుకుంటది. అదే ఇప్పుడు నేను మామూలుగా జా-JavaScript లో వీటిలో ఏం చేస్తాను var i equal to four అంటాను | |
ఓకే నా, అది అసలు integer అని చెప్పేసని run time లో తెలుస్తాది. అంతే తప్ప ముందే తెలీదు అనమాట అది ఒక integer అని చెప్పేసని | |
సేమ్ Python లో కూడా ఇలాగే ఉంటాదట. Python లో కూడా ముందే అది integer ఆ లేకపోతే string ఆ ఏంటా అని చెప్పేసి అని run time లో తెలుస్తాది. సో, దీనివల్ల Java లో ఇది four bytes ఇస్తుందనుకోండి Node JS లో గాని Python లో గాని దగ్గర దగ్గర twenty కన్నా ఎక్కువ bytes తీసుకుంటాదన్నమాట. | |
సో మీ object creation కి ఎక్కువ time తీసుకుంటాది. ఎందుకంటే object లో ఏ data types ఉన్నాయని మనం ముందే తెలియకపోవడం వల్ల ఎక్కువ time తీసుకుంటాది. | |
మరి మీకు అనిపించొచ్చు నోడ్ JS పైథాన్ ఒకే time తీసుకోవాలి కదా రెండు static languages కాదు కదా అని చెప్పేసి అని | |
కాకపోతే Node.js recent versions లో వాడు కొన్ని optimizations చేయడం వల్ల Node.js అనేది Python కంటేనూ better గా object ని handle చేస్తదన్నమాట. So, ఈ విధంగా Python అనేది మీ request ని handle చేస్తుంది. | |
ఇప్పుడు మనం చాలా famous అయినా Go language కి వద్దాం. Go language లో మీరు observe చేస్తే దీంట్లోనేమో email, password ఉంటది. దాని తర్వాత మనం database query చేస్తాం. Database query చేసిన తర్వాత same code ఏ ఉంటది. పెద్ద తేడా ఏం ఉండదు. | |
Only thing అంటే syntax మారుతూ ఉంటది. ఇప్పుడు Go దీన్ని internal గా ఎలా చేస్తుంది అని observe చేస్తే, దీంట్లో ఇలాంటి architecture ఉంటదన్నమాట | |
ఇదొక OS layer ఇది application layer. ఓకేనా? ఇప్పుడు మీకు ఒక request రాగానే Go మీ కోసం ఏం చేస్తది? | |
ఒక coroutine create చేస్తదనమాట. దాన్ని coroutine అంటారు. మీ request ని first ఇక్కడ దాస్తది. దాని తర్వాత మీరు ఇంకో request చేశారనుకోండి, దానికోసం ఇంకో coroutine చేస్తదనమాట. మీరు ఇంకో request చేశారనుకోండి, మీకోసం ఇంకో coroutine create చేస్తది. | |
అలాగే మీరు ఎన్ని request చేస్తే అన్ని coroutines create చేస్తాది. ఈ coroutines అన్నిటికి పెద్ద space ఏం తీసుకోదు అనమాట few KBస్ లోనే ఉంటాది. | |
ఇప్పుడు ఇక్కడ మీరు observe చేస్తే OS threads ఉన్నాయి. Golang యొక్క philosophy ఏంటి అంటే, see Node.js ఏమో ఒకటే OS thread ఉంది. ఒకటే OS thread ఉండటం వల్ల | |
Request fast గా handle చేస్తుంది కానీ CPU heavy work వస్తే కొంచెం దెబ్బ అయిపోతుంది. అదే ఇప్పుడు మీరు Java లో observe చేస్తే Java లో ఎక్కువ OS threads ఉన్నాయి. ఓకే నా! ఎక్కువ OS thread ఉండడం వల్ల context switching అనేది ఎక్కువ అయిపోతుంది. | |
సో Golang ఏం చేస్తుంది అంటే, నేను మరీ ఎక్కువ OS threads create చేసుకోను. నేను Java నుంచి కొంత తీసుకుంటాను, Node.js నుంచి కొంత inspiration తీసుకుని, నేను మరీ ఎక్కువ OS threads handle చేయను. కొన్ని OS threads ఏ పెట్టుకుంటుందన్నమాట | |
దగ్గర దగ్గర let's say ఇదొక four to five OS threads అనేది create చేసుకుంది | |
ఓకే నా, ఇక్కడ మీరు observe చేస్తే OS scheduler తో పాటు ఇక్కడొక scheduler ఉందన్నమాట application layer లో, ఓకే నా. దాన్నే Go scheduler అంటారన్నమాట. ఈ Go scheduler interesting గా ఏం చేస్తుందంటే, మీ request ఉంది కదా, మీ request ఒక coroutine ఉంది. దీన్ని coroutine అంటాం. ఇక్కడ మీరు observe చేస్తే ఒక Go scheduler ఉందన్నమాట. | |
Go schedule కి మంచి interesting పని ఉంటుందన్నమాట. అదేం చేస్తదంటే, మీ request ని తీసుకుంటది. మీ request ని తీసుకుని మీకంటూ ఒక OS thread ని assign చేస్తది | |
అలాగ మీ request ని తీసుకుంటది. తీసుకుని ఇంకో voice thread ని మీకు assign చేస్తాది. దాని తర్వాత ఇంకో request ని తీసుకుని ఇంకో voice thread ki assign చేస్తాది. | |
అసైన్ చేసిన తర్వాత పొరపాటున let's say మీరు ఒక database కాల్ చేస్తున్నారనుకోండి, database కాల్ చేసినప్పుడు ఇదనుకుంటది database కాల్ చేసినప్పుడు ఎందుకు దీనికి OS thread waste అని చెప్పేసి అని మీ కోడ్ ఇదంతా తెచ్చుకొని మళ్ళీ store చేసుకుంటదన్నమాట. ఈ timeలో ఇంకో request వచ్చిందనుకోండి | |
దానికోసం కూడా ఒక coroutine create చేస్తాం కదా. ఆ coroutine కి assign చేస్తాం కదా OS thread ని. so ఇక్కడ మీరు observe చేస్తే scheduler పని ఏంటి అంటే మీ దగ్గర కొన్ని coroutines ఉంటాయి, మీ దగ్గర at the same time | |
OS threads ఉంటాయి. ఇప్పుడు ఏ OS thread కి ఏ coroutine వెళ్ళాలా అని చెప్పేసి అది figure out చేస్తది అనమాట. Coroutine అంటే మళ్ళీ ఏది అనుకోవద్దు అది just object లాంటిది అది. ఆ object లో ఏంటి అంటే, మీ request యొక్క state ని మనం store చేసుకుంటూ ఉంటాం. ఏ లెవెల్ వరకు execute అయ్యింది, దాంట్లో ఏ variables ఉన్నాయి, అవన్నీ store... | |
సో ఇప్పుడు మీరు observe చేస్తే మీ Go లోని మీరు one lakh request చేసినా కూడానూ ఆ one lakh request ని అది handle చేయగలదు అనమాట. ఎందుకంటే మనం చాలా one lakh coroutines create చేసుకుంటాం | |
Coroutine యొక్క size అనేది ఎక్కువ KB ఏం ఉండదు. కొన్ని KBస్ లో ఉంటది. ఆ KBస్ లో ఉండటం వల్ల అన్ని coroutines దీంట్లో fit అయిపోతాయన్నమాట. fit అయిపోయిన తర్వాత మీ go scheduler ఏం చేస్తుందంటే, మీ coroutines ని మీ OS threads కి map చేస్తూ ఉంటది. | |
ఓకే నా? ఈ విధంగా Go అనేది మీ request ని handle చేస్తది. ఇప్పుడు one lakh request మీరు చేస్తే | |
ఆ one lakh request కి దగ్గర దగ్గర let's say మనం ఒక hundred seconds తీసుకుంటాది అనుకుందాం. ఈ hundred seconds ఎక్కడ పోతది? మీరు observe చేస్తే first object creation లో పోతది | |
అంతేనా? Object creation లో కొన్ని పోతది. Next ఏమవుద్ది? Database calls లో పోతది. Next ఏమవుతది? Next ఏమవుతది? Garbage collector లో కొంచెం పోతది. | |
ఓకే నా, ఈ hundred seconds overall గా దీంట్లో పోతది. ఇప్పుడు మీరు observe చేస్తే object creation అనేది Node.js కన్నా Python కన్నా ఇది fast గా ఉంటది. ఎందుకు అంటే Go అనేది static language. | |
Dynamic language కాదు static language Java లాగన్నమాట. So మనం ముందే data type ని ముందే fix చేస్తాం. ఇంకా, ఇంకా ఇక్కడ depth కి వెళ్ళచ్చు but మీకు కొంచెం simplify చేసి చెప్పేస్తున్నాను. ఈ విధంగా Golang అనేది మీ request ని process చేస్తదన్నమాట. Golang లో multiple OS threads ఉండడం వల్ల CPU heavy works కూడా అవి బాగానే handle... | |
ఇప్పుడు మీకు అనిపించవచ్చు ఇంకెన్ని languages రా బాబు అని చెప్పేసి అని కాకపోతే ఇంకొక్క language ఉంది అదేంటి Rust | |
మనం ఈ మధ్యన popular గా వింటున్న language ఇది. మనం ఒకసారి Rust లోకి వెళ్లి observe చేస్తే Rust లో మీ code అనేది ఈ విధంగా ఉంటది | |
దీంట్లో మీరు observe చేస్తే verify password ఉంటది email password వస్తది SQL query చేస్తాము query చేసిన తర్వాత response వస్తది verify చేస్తాం. ఇదంతా regular thing ఏ | |
ఓకే దీంట్లోని syntax మారడం తప్ప మొత్తం అంతా regular thing ఏ. ఇప్పుడు rust యొక్క internal architecture observe చేస్తే some అది కూడా కొంచెం golang లాగే ఉంటాది అనమాట. ఓకే నా? మీకు ఒక request వచ్చింది అనుకోండి | |
అంటే Rust యొక్క basic thing Rust యొక్క default thing కాదు Rust లోని ఆ Tokyo something ఏదో ఒక library ఉంటాదంట. ఆ library వాడితే దీనికి async capabilities వస్తాయన్నమాట Rust కి | |
ఐసి క్యాబిన్స్ లాగా అనేది ఏం చేస్తదంటే మీరు ఒక request చేశారనుకోండి మీ కోసం co-routine లాగా ఇలాగ ఒక object create చేసుకుంటాదన్నమాట. అలా మీరు ఎన్ని request చేస్తే అన్నిటికీ ఒక co-routine లాగా ఒక object create చేస్తుంది |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.