cpipe - ക്ലൗഡിൽ ഓൺലൈനിൽ

പട്ടിക:

NAME

cpipe - ബൈറ്റുകൾ എണ്ണുകയും പുരോഗതി റിപ്പോർട്ടുചെയ്യുകയും ചെയ്യുമ്പോൾ stdin stdout-ലേക്ക് പകർത്തുക

സിനോപ്സിസ്

cpipe [-b bsize] [-vt] [-vr] [-vw] [-ngr] [-s വേഗത]

ഓപ്ഷനുകൾ

-b ബഫർ വലുപ്പം കെബിയിൽ,
1-നും oo-നും ഇടയിലുള്ള 1 Int മൂല്യം.
സ്ഥിരസ്ഥിതി: `128'

-vt ഷോ ത്രോപുട്ട്.

-vr ഷോ റീഡ്-ടൈംസ്.

-vw എഴുത്ത് സമയങ്ങൾ കാണിക്കുക.

-ngr അത്യാഗ്രഹമില്ലാത്ത വായന. എഴുതാൻ തുടങ്ങുന്നതിന് മുമ്പ് വായനയിൽ പൂർണ്ണ ബഫർ നിർബന്ധമാക്കരുത്.

-s ത്രൂപുട്ട് വേഗത പരിധി kB/s ൽ,
1 1 നും oo നും ഇടയിലുള്ള ഇരട്ട മൂല്യം.

വിവരണം

സിപൈപ്പ് എടുക്കുന്ന സമയം അളക്കുമ്പോൾ അതിന്റെ സ്റ്റാൻഡേർഡ് ഇൻപുട്ട് അതിന്റെ സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ടിലേക്ക് പകർത്തുന്നു
ഒരു ഇൻപുട്ട് ബഫർ വായിക്കാനും ഔട്ട്പുട്ട് ബഫർ എഴുതാനും. ഒന്നോ അതിലധികമോ ആണെങ്കിൽ -vx ഓപ്ഷനുകൾ ആണ്
നൽകിയിരിക്കുന്നത്, ശരാശരി ത്രൂപുട്ടിന്റെ സ്ഥിതിവിവരക്കണക്കുകളും പകർത്തിയ ബൈറ്റുകളുടെ ആകെ തുകയും പ്രിന്റ് ചെയ്യുന്നു
സാധാരണ പിശക് ഔട്ട്പുട്ടിലേക്ക്.

നോൺ അത്യാഗ്രഹം വായിക്കുക
സാധാരണയായി, cpipe അതിന്റെ ബഫർ പൂർണ്ണമായും പൂരിപ്പിക്കുന്നതിന് പരമാവധി ശ്രമിക്കുന്നു (ഓപ്ഷൻ -b) ആരംഭിക്കുന്നതിന് മുമ്പ്
എഴുത്തു. എന്നിരുന്നാലും ചില സാഹചര്യങ്ങളിൽ, ഉദാ നിങ്ങൾ cpipe വഴി ഒരു സംവേദനാത്മക പ്രോഗ്രാമുമായി സംസാരിക്കുകയാണെങ്കിൽ,
ഇത് ആശയവിനിമയത്തെ തടസ്സപ്പെടുത്തുന്നു: പ്രോഗ്രാം ഒരിക്കലും കാണാത്ത ഇൻപുട്ടിനായി കാത്തിരിക്കുന്നു,
കാരണം ഇൻപുട്ട് cpipe-ന്റെ ബഫറിൽ കുടുങ്ങിയിരിക്കുന്നു. എന്നാൽ cpipe തന്നെ കൂടുതൽ ഇൻപുട്ട് കാണില്ല
പ്രോഗ്രാം പ്രതികരിക്കാത്തതിന് മുമ്പ്.

ഇത് മറികടക്കാൻ, ഉപയോഗിച്ച് ശ്രമിക്കുക -എൻജിആർ. ഒരു റീഡ് കോൾ ഇഷ്യൂ ചെയ്യുമ്പോൾ, cpipe തുടർന്ന് തൃപ്തിപ്പെടും
ഒരു ബൈറ്റെങ്കിലും കിട്ടിയാൽ ഉടൻ. ബഫർ പൂരിപ്പിക്കുന്നതിന് പകരം, അത് വായന നിർത്തുന്നു
ഔട്ട്പുട്ടിൽ കിട്ടുന്നതെന്തും എഴുതുന്നു. എന്നിരുന്നാലും, ത്രൂപുട്ട് അളവുകൾ ചെയ്യുമെന്നത് ശ്രദ്ധിക്കുക
ഒരു റീഡ്/റൈറ്റ് ജോഡിയിൽ കൈമാറ്റം ചെയ്യപ്പെടുന്ന ബൈറ്റുകളുടെ എണ്ണം ചെറുതാണെങ്കിൽ കൃത്യമായി പറയുക,
കാരണം cpipe എല്ലാ ബൈറ്റിലും പ്രവർത്തിക്കാൻ താരതമ്യേന കൂടുതൽ സമയം ചെലവഴിക്കും.

പരിമിതപ്പെടുത്തുന്നു ട്രേഡ്
ഒരു ത്രൂപുട്ട് പരിധി ഓപ്‌ഷനോടൊപ്പം വ്യക്തമാക്കിയിട്ടുണ്ടെങ്കിൽ -s, cpipe കോളുകൾ ഉറങ്ങുക(3) ഇടയിൽ
ബഫറുകൾ പകർത്തുന്നു, അതുവഴി കൃത്രിമമായി വായന/എഴുത്ത്-ചക്രത്തിന്റെ ദൈർഘ്യം വർദ്ധിപ്പിക്കുന്നു. മുതലുള്ള
മിക്ക സിസ്റ്റങ്ങളിലും ഒരു നിശ്ചിത മിനിമം സമയം ഉസ്ലീപ്() ഉറങ്ങുന്നു, ഉദാ 0.01സെ, ഇത്
ഒരു ചെറിയ ബഫർ വലിപ്പം കൊണ്ട് ഉയർന്ന പരിധിയിലെത്തുക അസാധ്യമാണ്. ഈ സാഹചര്യത്തിൽ, വർദ്ധിക്കുന്നു
ബഫർ വലുപ്പം (ഓപ്ഷൻ -b) സഹായിച്ചേക്കാം. എന്നിരുന്നാലും, ഇത് ത്രോപുട്ടിനെ പരിമിതപ്പെടുത്തുന്നുവെന്ന് ഓർമ്മിക്കുക
ശരാശരിയിൽ മാത്രം. ഓരോ ബഫറും കഴിയുന്നത്ര വേഗത്തിൽ പകർത്തുന്നു.

ഉദാഹരണം

കമാൻഡ്
ടാർ cCf / - usr | cpipe -vr -vw -vt > /dev/null
ഒരു ഔട്ട്പുട്ട് പോലെ ഫലം
...
ഇൻ: 19.541ms at 6.4MB/s (4.7MB/s ശരാശരി) 2.0MB
പുറത്ത്: 0.004GB/s-ൽ 30.5ms (27.1GB/s ശരാശരി) 2.0MB
വഴി: 19.865MB/s-ൽ 6.3ms (4.6MB/s ശരാശരി) 2.0MB
...
ദി ആദ്യം നിര ഒരു ബഫർ ഡാറ്റ കൈകാര്യം ചെയ്യാൻ എടുക്കുന്ന സമയം കാണിക്കുന്നു (ഡിഫോൾട്ടായി 128kB).
റീഡ്-കോൾ 19.541ms എടുത്തു, /dev/null എന്നതിലേക്കുള്ള റൈറ്റ്-കോൾ വെറും 0.004ms എടുത്തു.
വായനയുടെ തുടക്കം മുതൽ എഴുത്തിന്റെ അവസാനം വരെ 19.865 മി.

ദി സെക്കന്റ് നിര ബഫർ വലുപ്പം (ഡിഫോൾട്ടായി 128kB) കൊണ്ട് ഹരിക്കുന്നതിന്റെ ഫലം കാണിക്കുന്നു
ആദ്യ നിരയിലെ തവണ.

ദി മൂന്നാമത്തെ നിര ന്റെ തുടക്കം മുതൽ അളന്ന എല്ലാ മൂല്യങ്ങളുടെയും ശരാശരി അടങ്ങിയിരിക്കുന്നു
പ്രോഗ്രാം.

അവസാനം, ആ അവസാനത്തെ നിര ട്രാൻസ്ഫർ ചെയ്ത മൊത്തം ബൈറ്റുകളുടെ എണ്ണം കാണിക്കുന്നു, അത് തീർച്ചയായും
വായനയ്ക്കും എഴുത്തിനും ഒരുപോലെ.

onworks.net സേവനങ്ങൾ ഉപയോഗിച്ച് cpipe ഓൺലൈനായി ഉപയോഗിക്കുക