[മൈക്കൽ ലിഞ്ച്] ഒരു വിചിത്രമായ സാഹചര്യം നേരിട്ടു. എന്തുകൊണ്ടാണ് കംപൈലിംഗ് പിന്നീട് അദ്ദേഹത്തിൻ്റെ പ്രോഗ്രാം ഏകദേശം 10 മടങ്ങ് പ്രവർത്തിക്കുന്നത് വേഗത്തിൽ പ്രോഗ്രാം സ്വയം പ്രവർത്തിപ്പിക്കുന്നതിനേക്കാൾ? [മൈക്കൽ] ഒരു പ്രോഗ്രാമിംഗ് പ്രോജക്റ്റ് ബെഞ്ച്മാർക്ക് ചെയ്യുന്നതിനിടയിൽ ഈ പ്രശ്നത്തിൽ ഇടപെട്ടു, ആവർത്തനത്തിനും വിശകലനത്തിനുമുള്ള അതിൻ്റെ അത്യന്താപേക്ഷിതമായ കാര്യങ്ങളിലേക്ക് അതിനെ നിരത്തി, ബാഷ് പൈപ്പ്ലൈനുകൾ എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നതിൻ്റെ തെറ്റായ മാനസിക മാതൃക ഉയർത്തിക്കാട്ടുന്നതായി കണ്ടെത്തി.
സാഹചര്യം ഇതാ. [മൈക്കൽ] ൻ്റെ പാരെഡ്-ഡൗൺ പ്രോഗ്രാം ആദ്യം ചെയ്യുന്നത് ഒരു ടൈമർ ആരംഭിക്കുക എന്നതാണ്. തുടർന്ന് അത് കുറച്ച് ബൈറ്റുകൾ വായിക്കുകയും എണ്ണുകയും ചെയ്യുന്നു stdin, അത് സംഭവിക്കാൻ എത്ര സമയമെടുത്തു എന്ന് പ്രിൻ്റ് ചെയ്യുന്നു. ഇനിപ്പറയുന്ന രീതിയിൽ ടെസ്റ്റ് പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുമ്പോൾ, ഏകദേശം 13 മൈക്രോസെക്കൻഡ് എടുക്കും.
$ echo '00010203040506070809' | xxd -r -p | zig build run -Doptimize=ReleaseFast bytes: 10 execution time: 13.549µs
(ഇതിനകം സമാഹരിച്ച) പ്രോഗ്രാം നേരിട്ട് പ്രവർത്തിപ്പിക്കുമ്പോൾ, നിർവ്വഹണ സമയം 162 മൈക്രോസെക്കൻഡായി വർദ്ധിക്കുന്നു.
$ echo '00010203040506070809' | xxd -r -p | ./zig-out/bin/count-bytes bytes: 10 execution time: 162.195µs
വീണ്ടും, തമ്മിലുള്ള വ്യത്യാസം മാത്രം zig build run ഒപ്പം ./zig-out/bin/count-bytes ആദ്യത്തേത് കോഡ് കംപൈൽ ചെയ്യുന്നു, തുടർന്ന് അത് ഉടൻ പ്രവർത്തിപ്പിക്കുന്നു. രണ്ടാമത്തേത് കംപൈൽ ചെയ്ത പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുന്നു.
ഒരു അധിക കംപൈൽ ഘട്ടം എങ്ങനെ ചേർക്കാം കുറയുന്നു നിർവ്വഹണ സമയം? ബാഷ് പൈപ്പ്ലൈനുകൾ എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നതിൻ്റെ [മൈക്കിൾ] മാനസിക മാതൃക തെറ്റായിരുന്നു, കൂടാതെ അദ്ദേഹം ഒരു മികച്ച ജോലി ചെയ്യുന്നു അവ യഥാർത്ഥത്തിൽ എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്നും അത് വിചിത്രമായ പെരുമാറ്റത്തിന് കാരണമായത് എന്തുകൊണ്ടാണെന്നും വിശദീകരിക്കുന്നു അവൻ കാണുകയായിരുന്നു.
ചുരുക്കത്തിൽ, ഒരു ബാഷ് പൈപ്പ്ലൈനിലെ കമാൻഡുകൾ തുടർച്ചയായി ലോഞ്ച് ചെയ്യപ്പെടുന്നില്ല. അവയെല്ലാം ഒരേ സമയം വിക്ഷേപിക്കുകയും സമാന്തരമായി നടപ്പിലാക്കുകയും ചെയ്യുന്നു. അതിനർത്ഥം നേരിട്ട് പ്രവർത്തിപ്പിക്കുമ്പോൾ, [മൈക്കൽ] ൻ്റെ ബൈറ്റ്-കൗണ്ടർ പ്രോഗ്രാം ഉടൻ സമാരംഭിച്ചു. പിന്നീട് 150 മൈക്രോസെക്കൻഡുകളോളം കാര്യമായി ഒന്നും ചെയ്യാതെ കാത്തിരുന്നു echo '00010203040506070809' | xxd -r -p പൈപ്പ്ലൈനിൻ്റെ ഒരു ഭാഗം പ്രോഗ്രാമിന് വായിക്കാനായി അതിൻ്റെ ഡാറ്റ ഡെലിവറി ചെയ്തു. ഇതിനകം കംപൈൽ ചെയ്ത പതിപ്പ് പ്രവർത്തിപ്പിക്കുമ്പോൾ അധിക എക്സിക്യൂഷൻ സമയം ലഭിക്കുന്നത് ഇവിടെ നിന്നാണ്.
എന്തുകൊണ്ടാണ് ഇത് ആദ്യം കംപൈൽ ചെയ്യുന്നത് വേഗത്തിൽ പ്രവർത്തിക്കുന്നത്? അതേ അടിസ്ഥാന കാരണം: എപ്പോൾ zig build run കമാൻഡ് ആരംഭിക്കുന്നു, ഇത് ആദ്യം പ്രോഗ്രാം കംപൈൽ ചെയ്യുന്നതിന് കുറച്ച് സമയം ചെലവഴിക്കുന്നു. കംപൈൽ ചെയ്ത പ്രോഗ്രാം യഥാർത്ഥത്തിൽ സമാരംഭിക്കുമ്പോൾ (അതിൻ്റെ എക്സിക്യൂഷൻ ടൈമർ ആരംഭിക്കുന്നു), ബാഷ് പൈപ്പ്ലൈനിൽ നിന്നുള്ള ഇൻപുട്ട് ഡാറ്റ ഇതിനകം തയ്യാറാണ്. അതിനാൽ, പുതിയതായി സമാഹരിച്ച പ്രോഗ്രാം കുറഞ്ഞ സമയത്തിനുള്ളിൽ എക്സിക്യൂട്ട് ചെയ്യുന്നു, കാരണം പൈപ്പ്ലൈനിൽ മുമ്പത്തെ ഡാറ്റ ലഭ്യമാകുന്നതിനായി അത് കാത്തിരിക്കുന്നില്ല.
ബാഷ് പൈപ്പ്ലൈനുകൾ യഥാർത്ഥത്തിൽ എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നതിൻ്റെ രസകരമായ ഒരു കാഴ്ചയാണിത്, മുഴുവൻ യാത്രയിലും വിശദീകരണത്തിലും [മൈക്കൽ] നൽകുന്ന വിശദാംശങ്ങളിൽ ഞങ്ങൾ സന്തുഷ്ടരാണ്. താമസിയാതെ അല്ലെങ്കിൽ പിന്നീട്, ഇതുപോലുള്ള വിശദാംശങ്ങൾ ക്രോപ്പ് ചെയ്യപ്പെടുകയും കണ്ടെത്തിയ ഉപയോക്താവിനെപ്പോലെ ചില പുരികങ്ങൾ ഉയരുകയും ചെയ്യും ssh കമാൻഡുകളിലെ സ്‌പെയ്‌സുകളെ സംബന്ധിച്ച പ്രശ്‌നകരമായ എഡ്ജ് കേസുകൾ.
- SEO പവർ ചെയ്ത ഉള്ളടക്കവും PR വിതരണവും. ഇന്ന് ആംപ്ലിഫൈഡ് നേടുക.
- PlatoData.Network ലംബ ജനറേറ്റീവ് Ai. സ്വയം ശാക്തീകരിക്കുക. ഇവിടെ പ്രവേശിക്കുക.
- PlatoAiStream. Web3 ഇന്റലിജൻസ്. വിജ്ഞാനം വർധിപ്പിച്ചു. ഇവിടെ പ്രവേശിക്കുക.
- പ്ലേറ്റോഇഎസ്ജി. കാർബൺ, ക്ലീൻ ടെക്, ഊർജ്ജം, പരിസ്ഥിതി, സോളാർ, മാലിന്യ സംസ്കരണം. ഇവിടെ പ്രവേശിക്കുക.
- പ്ലേറ്റോ ഹെൽത്ത്. ബയോടെക് ആൻഡ് ക്ലിനിക്കൽ ട്രയൽസ് ഇന്റലിജൻസ്. ഇവിടെ പ്രവേശിക്കുക.
- അവലംബം: https://hackaday.com/2024/03/28/is-your-mental-model-of-bash-pipelines-wrong/
