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

പട്ടിക:

NAME

spew - I/O പ്രകടനം അളക്കുന്നു കൂടാതെ/അല്ലെങ്കിൽ I/O ലോഡ് സൃഷ്ടിക്കുന്നു

സിനോപ്സിസ്

സ്പൂ --write|--read|--read-after-write [ഓപ്ഷൻ]... TRANSFER_SIZE[kKmMgG] FILE

വിവരണം

ഒരു I/O പെർഫോമൻസ് മെഷർമെന്റും ലോഡ് ജനറേഷൻ ടൂളും. എഴുതുകയും കൂടാതെ/അല്ലെങ്കിൽ വായിക്കുകയും ചെയ്യുന്നു
ഒരു പ്രതീക ഉപകരണം, ബ്ലോക്ക് ഉപകരണം അല്ലെങ്കിൽ സാധാരണ ഫയലിൽ നിന്നുള്ള ഡാറ്റ.

-B, --max-buffer-size=BUFFER_SIZE
ഓരോ വായിക്കുക(2) /എഴുതുക(2) കോൾ BUFFER_SIZE വലുപ്പമുള്ള പരമാവധി ബഫർ ഉപയോഗിക്കുന്നു.

-b, --മിനിറ്റ്-ബഫർ-സൈസ്=BUFFER_SIZE
ഓരോ വായിക്കുക(2) /എഴുതുക(2) കോൾ BUFFER_SIZE വലുപ്പമുള്ള ഏറ്റവും കുറഞ്ഞ ബഫർ ഉപയോഗിക്കുന്നു.

-c, പിശകിന് ശേഷം --തുടരുക
ഡാറ്റ സമഗ്രത പിശകുകൾക്ക് ശേഷം തുടരുക.

-d, --നേരിട്ട്
നേരിട്ടുള്ള I/O ഉപയോഗിക്കുക. ബ്ലോക്ക് ഡിവൈസ് ഫയലുകളിൽ മാത്രമേ ഉപയോഗിക്കാവൂ. എല്ലാം പ്രവർത്തിക്കുന്നില്ല
സിസ്റ്റങ്ങൾ നേരിട്ടുള്ള I/O-യെ പിന്തുണയ്ക്കുന്നു

-g, --ജനറേറ്റ്-ലോഡ്
തുല്യമായ: -v -t -P -p ക്രമരഹിതം -i 0.

-i, --ആവർത്തനങ്ങൾ=COUNT
ഡാറ്റ COUNT തവണ എഴുതുക/വായിക്കുക. എണ്ണം 0 ആണെങ്കിൽ, എന്നെന്നേക്കുമായി ആവർത്തിക്കുന്നു.

-l, --ലോഗ് ഫയൽ=ലോഗ്ഫിൽ
LOGFILE-ലേക്ക് ലോഗ് സന്ദേശങ്ങൾ അയയ്‌ക്കുക.

-- പുരോഗതിയില്ല
പുരോഗതി കാണിക്കരുത് (സ്ഥിരസ്ഥിതി).

--no-rcfiles
സാധാരണ ആർസി ഫയലുകൾ ഉപയോഗിക്കരുത്.

-q, --നോ-സ്റ്റാറ്റിസ്റ്റിക്സ്
സ്ഥിതിവിവരക്കണക്കുകൾ ഔട്ട്‌പുട്ട് ചെയ്യരുത്.

--no-tui
TUI ഇന്റർഫേസ് ഉപയോഗിക്കരുത്.

-o, --ഓഫ്സെറ്റ്=ഓഫ്സൈറ്റ്
I/O ആരംഭിക്കുന്നതിന് മുമ്പ് OFFSET ചെയ്യാൻ ശ്രമിക്കുക.

-P, --പുരോഗതി
പുരോഗതി കാണിക്കുക.

-p, --മാതൃക=PATTERN
ഡാറ്റ വായിക്കുമ്പോഴോ എഴുതുമ്പോഴോ ഡാറ്റ പാറ്റേൺ PATTERN ഉപയോഗിക്കുക.

-r, --റാൻഡം
റാൻഡം ഓഫ്‌സെറ്റുകളിലേക്ക് ബഫറുകൾ വായിക്കുക/എഴുതുക.

--റോ ഒരു അപരനാമം --വായിച്ചതിനുശേഷം-എഴുതുക.

--rcfile=RCFILE
RCFILE-ൽ നിന്നുള്ള കമാൻഡ്-ലൈൻ ഓപ്ഷനുകൾ വായിക്കുക.

--വായിക്കുക ഫയലിൽ നിന്ന് വായിച്ച തീയതി.

--വായിച്ചതിനുശേഷം-എഴുതുക
FILE-ലേക്ക് എഴുതിയതിന് ശേഷം ഡാറ്റ തിരികെ വായിക്കുക.

-S, --വിത്ത്=വിത്ത്
റാൻഡം നമ്പർ സീഡിനായി SEED ഉപയോഗിക്കുക.

-s, --സമന്വയിപ്പിക്കുക
സിൻക്രണസ് I/O ഉപയോഗിക്കുക.

--സ്ഥിതിവിവരക്കണക്കുകൾ
ഔട്ട്പുട്ട് സ്ഥിതിവിവരക്കണക്കുകൾ (സ്ഥിരസ്ഥിതി).

-t, --tui
ശാപങ്ങളെ അടിസ്ഥാനമാക്കിയുള്ള, ടെർമിനൽ യൂസർ ഇന്റർഫേസ് ഉപയോഗിക്കുക.

-u, --യൂണിറ്റുകൾ=UNITS
UNITS യൂണിറ്റുകളിൽ ട്രാൻസ്ഫർ നിരക്ക് കാണിക്കുക.

--ഉപയോഗം
ഹ്രസ്വ ഉപയോഗ സന്ദേശം കാണിച്ച് പുറത്തുകടക്കുക.

-V, --പതിപ്പ്
ഔട്ട്പുട്ട് പതിപ്പ് വിവരങ്ങളും പുറത്തുകടക്കുക.

-v, --വിശദമായ സ്ഥിതിവിവരക്കണക്കുകൾ
വിശദമായ സ്ഥിതിവിവരക്കണക്കുകൾ ഔട്ട്പുട്ട് ചെയ്യുക.

--എഴുതുക
FILE-ലേക്ക് ഡാറ്റ എഴുതുക.

-?, --സഹായിക്കൂ
ഈ സഹായം കാണിച്ച് പുറത്തുകടക്കുക.

ഡാറ്റ എഴുതാനുള്ള ഫയൽ റെഗുലർ അല്ലെങ്കിൽ ഉപകരണ ഫയൽ.

ലോഗ്ഫിൽ
ലോഗിംഗിനായി ഉപയോഗിക്കുന്ന ഒരു ഫയലിലേക്കുള്ള പാത.

MAX_BUFFER_SIZE
ഓരോന്നിലും ഉപയോഗിക്കുന്ന ഏറ്റവും കുറഞ്ഞ ബഫർ വലുപ്പം വായിക്കുക(2) /എഴുതുക(2) കോൾ (ഡിഫോൾട്ട് MIN_BUFFER_SIZE ആണ്
ബൈറ്റുകൾ). MAX_BUFFER_SIZE. 512 ബൈറ്റുകളുടെ ഇരട്ട ഗുണിതമായിരിക്കണം കൂടാതെ ആകാം
ബൈറ്റുകൾ, കിബിബൈറ്റുകൾ(കെ), കിലോബൈറ്റുകൾ(കെ) എന്നിവയിൽ വ്യക്തമാക്കിയിട്ടുണ്ട് മെബിബൈറ്റുകൾ(എം), മെഗാബൈറ്റ്(എം),
ജിബിബൈറ്റ്സ്(ജി), ജിഗാബൈറ്റ്(ജി). ടെബിബൈറ്റുകൾ (ടി), അല്ലെങ്കിൽ ടെറാബൈറ്റുകൾ (ടി). MAX_BUFFER_SIZE
MIN_BUFFER_SIZE ലേക്ക് സ്ഥിരസ്ഥിതികൾ. MAX_BUFFER_SIZE > MIN_BUFFER_SIZE ആണെങ്കിൽ, ക്രമരഹിതമായ ബഫറുകൾ
രണ്ട് പരിധികൾക്കിടയിലുള്ള വലുപ്പങ്ങൾ ഉപയോഗിക്കുന്നു. MAX_BUFFER_SIZE എന്നത് ഇതിന്റെ ഇരട്ടിയായിരിക്കണം
MIN_BUFFER_SIZE.

MIN_BUFFER_SIZE
ഓരോന്നിലും ഉപയോഗിക്കുന്ന ഏറ്റവും കുറഞ്ഞ ബഫർ വലുപ്പം വായിക്കുക(2) /എഴുതുക(2) കോൾ (ഡിഫോൾട്ട് 512 ബൈറ്റുകൾ ആണ്).
MIN_BUFFER_SIZE. 512 ബൈറ്റുകളുടെ ഇരട്ട ഗുണിതമായിരിക്കണം കൂടാതെ അതിൽ വ്യക്തമാക്കാനും കഴിയും
ബൈറ്റുകൾ, കിബിബൈറ്റുകൾ(കെ), കിലോബൈറ്റുകൾ(കെ), മെബിബൈറ്റുകൾ(എം), മെഗാബൈറ്റ്(എം), ജിബിബൈറ്റുകൾ(ജി),
ജിഗാബൈറ്റ്(ജി). ടെബിബൈറ്റുകൾ (ടി), അല്ലെങ്കിൽ ടെറാബൈറ്റുകൾ (ടി).

I/O ആരംഭിക്കുന്നതിന് മുമ്പ് ഫയലിൽ അന്വേഷിക്കേണ്ട OFFSET സ്ഥാനം (സ്ഥിരസ്ഥിതി 0 ആണ്). OFFSET ആയിരിക്കണം
512 ബൈറ്റുകളുടെ ഇരട്ടി ഗുണിതം, ബൈറ്റുകൾ, കിബിബൈറ്റുകൾ (k), എന്നിവയിൽ വ്യക്തമാക്കാം
കിലോബൈറ്റുകൾ(കെ), മെബിബൈറ്റുകൾ(m), മെഗാബൈറ്റ്(M), gibibytes(g), gigabytes(G).
ടെബിബൈറ്റുകൾ (ടി), അല്ലെങ്കിൽ ടെറാബൈറ്റുകൾ (ടി).

PATTERN
ഡാറ്റ എഴുതുമ്പോൾ / വായിക്കുമ്പോൾ ഉപയോഗിക്കുന്ന ഡാറ്റ പാറ്റേൺ. ലഭ്യമായ പാറ്റേണുകൾ ഇവയാണ്: ഒന്നുമില്ല, പൂജ്യങ്ങൾ,
വൺസ്, ആൾട്ട്, റാൻഡം, നമ്പറുകൾ, കൂടാതെ "#" (ഇവിടെ "#" എന്നത് 0-255 ന് ഇടയിലുള്ള ഒരു സംഖ്യയാണ്). ദി
സ്ഥിരസ്ഥിതി പാറ്റേൺ "ഒന്നുമില്ല" ആണ്.

RCFILE RCFILE-ൽ നിന്നുള്ള അധിക കമാൻഡ്-ലൈൻ ഓപ്ഷനുകൾ വായിക്കുക. ഇതിലെ മറ്റ് ഓപ്ഷനുകൾ
കമാൻഡ്-ലൈൻ RCFILE-ലെ ഓപ്ഷനുകൾ അസാധുവാക്കും.

റാൻഡം നമ്പർ ജനറേറ്റർ വിത്ത് വിതയ്ക്കാൻ ഉപയോഗിക്കുന്ന വിത്ത് >= 1 ഉം <= 2^32 ഉം ആയിരിക്കണം.

TRANSFER_SIZE
കൈമാറാനുള്ള മൊത്തം ബൈറ്റുകളുടെ എണ്ണം (രണ്ടിന്റെയും MIN_BUFFER_SIZE രണ്ടിന്റെയും ഇരട്ടി ഗുണിതമായിരിക്കണം
കൂടാതെ MAX_BUFFER)SIZE). TRANSFER_SIZE എന്നത് ബൈറ്റുകൾ, കിലോബൈറ്റുകൾ, എന്നിവയിൽ വ്യക്തമാക്കാം.
മെഗാബൈറ്റ്, അല്ലെങ്കിൽ ജിഗാബൈറ്റ്.

യൂണിറ്റുകൾ കിബിബൈറ്റുകൾ(കെ), കിലോബൈറ്റുകൾ(കെ), മെബിബൈറ്റുകൾ(m), മെഗാബൈറ്റ്(M), gibibytes(g), gigabytes(G).
ടെബിബൈറ്റുകൾ (ടി), അല്ലെങ്കിൽ ടെറാബൈറ്റുകൾ (ടി).

ഉദാഹരണങ്ങൾ

സ്പൂ --എഴുതുക -b 16k 1m /tmp/bigfile

or

സ്പൂ -b 16k 1m /tmp/bigfile

1 കിബിബൈറ്റ് (1 കിബിബൈറ്റ് = 1024) ഉപയോഗിച്ച് 1024 മെബിബൈറ്റ് (16 മെബിബൈറ്റ് = 1*1024 ബൈറ്റുകൾ) എഴുതുന്നു
ബൈറ്റുകൾ) ഫയലിലേക്കുള്ള അഭ്യർത്ഥനകൾ /tmp/bigfile സ്ഥിരസ്ഥിതി പാറ്റേൺ ഉപയോഗിക്കുന്നു (റാൻഡം). പ്രദർശിപ്പിക്കുന്നു
കൈമാറ്റ നിരക്ക് സെക്കൻഡിൽ കിബിബൈറ്റിലും റൈറ്റ് ട്രാൻസ്ഫർ സമയം സെക്കൻഡിലും.

സ്പൂ --എഴുതുക -u m -i 10 -b 1k 256k / dev / sda1

or

സ്പൂ -u m -i 10 -b 1k 256k / dev / sda1

ബ്ലോക്ക് ഡിവൈസ് ഫയലിലേക്ക് 256 കിബിബൈറ്റ് അഭ്യർത്ഥനകൾ ഉപയോഗിച്ച് 1 കിബിബൈറ്റുകൾ എഴുതുന്നു / dev / sda1 10 തവണ
സ്ഥിരസ്ഥിതി പാറ്റേൺ ഉപയോഗിക്കുന്നു (റാൻഡം). ആവർത്തനവും ക്യുമുലേറ്റീവ് റൈറ്റ് ട്രാൻസ്ഫർ നിരക്കുകളും
ഒരു സെക്കൻഡിൽ മെബിബൈറ്റിൽ പ്രദർശിപ്പിക്കുകയും ആവർത്തനവും ക്യുമുലേറ്റീവ് റൈറ്റ് ട്രാൻസ്ഫർ സമയവും
സെക്കന്റുകൾക്കുള്ളിൽ പ്രദർശിപ്പിക്കും.

സ്പൂ --റോ -d -o 1m -b 16m 1g /tmp/bigfile

or

സമൃദ്ധമാണ് -s -o 1m -b 16m 1g /tmp/bigfile

1 ജിബിബൈറ്റ് (1 ജിബിബൈറ്റ് = 1024*1024*1024 ബൈറ്റുകൾ) 1 മെബിബൈറ്റിന്റെ ഓഫ്‌സെറ്റിൽ ആരംഭിക്കുക
ഫയലിലേക്ക് 16 മെബിബൈറ്റ് അഭ്യർത്ഥനകൾ ഉപയോഗിക്കുന്നു /tmp/bigfile സ്ഥിരസ്ഥിതി പാറ്റേൺ ഉപയോഗിക്കുന്നു (റാൻഡം).
ഡാറ്റ സമന്വയത്തോടെ എഴുതുകയും ഫയൽ അടയ്ക്കുമ്പോൾ ഫ്ലഷ് ചെയ്യുകയും ചെയ്യുന്നു. തുടർന്ന് അതേ ഡാറ്റയിൽ വായിക്കുക
ഒരേ അഭ്യർത്ഥന വലുപ്പവും ഓഫ്‌സെറ്റും ഉപയോഗിക്കുന്നു. ഡാറ്റ വായിക്കുന്നുണ്ടെന്ന് ഉറപ്പാക്കാൻ ഡാറ്റ പരിശോധിക്കുന്നു
വായിച്ച ഡാറ്റയുമായി പൊരുത്തപ്പെടുന്നു. എഴുത്തും വായനയും ട്രാൻസ്ഫർ നിരക്കുകൾ പ്രദർശിപ്പിക്കും
കിബിബൈറ്റുകൾ/സെക്കൻഡ്. വായനയും എഴുത്തും ട്രാൻസ്ഫർ സമയങ്ങൾ സെക്കൻഡിൽ പ്രദർശിപ്പിക്കും.

സ്പൂ --വായിക്കുക -i 0 -u M -p പൂജ്യങ്ങൾ -b 512 1m /dev/പൂജ്യം

or

കണ്ഠം -i 0 -u M -p പൂജ്യങ്ങൾ -b 512 1m /dev/പൂജ്യം

ഫയലിൽ നിന്നുള്ള 1 ബൈറ്റ് അഭ്യർത്ഥനകൾ ഉപയോഗിച്ച് 512 മെബിബൈറ്റ് ഡാറ്റ വായിക്കുക /dev/പൂജ്യം ഒരു അനന്തമായ സംഖ്യ
പൂജ്യം പാറ്റേൺ ഉപയോഗിക്കുന്ന തവണ (ഡാറ്റ പരിശോധിക്കരുത്). ആവർത്തനവും സഞ്ചിതവും
റീഡ് ട്രാൻസ്ഫർ നിരക്കുകൾ സെക്കൻഡിൽ മെഗാബൈറ്റിൽ (1 മെഗാബൈറ്റ് = 1,000,000 ബൈറ്റുകൾ) പ്രദർശിപ്പിക്കും
കൂടാതെ ആവർത്തനവും ക്യുമുലേറ്റീവ് റീഡ് ട്രാൻസ്ഫർ സമയവും സെക്കൻഡിൽ പ്രദർശിപ്പിക്കും.

സ്പൂ --റോ -g -r -b 1k -B 256K 1t /dev/md1

or

സമൃദ്ധമാണ് -g -r -b 1k -B 256K 1t /dev/md1

1-1 കിബിബൈറ്റ് അഭ്യർത്ഥനകൾ ഉപയോഗിച്ച് 1024 ടെബിബൈറ്റ് (1024 ടെബിബൈറ്റ് = 1024*1024*1*256 ബൈറ്റുകൾ) എഴുതുക
ബ്ലോക്ക് ഉപകരണം /dev/md1 ക്രമരഹിതമായ പാറ്റേൺ ഉപയോഗിച്ച്. റാൻഡം തിരയലുകൾ മുമ്പ് നടത്തപ്പെടുന്നു
ഓരോ കൈമാറ്റവും, എന്നാൽ ഡാറ്റയുടെ ആരംഭത്തിനും അവസാനത്തിനും ഇടയിലുള്ള ഓരോ ബ്ലോക്കും കൃത്യമായി എഴുതിയിരിക്കുന്നു
ഒരിക്കല്. അഭ്യർത്ഥന വലുപ്പങ്ങൾ ക്രമരഹിതമായി തിരഞ്ഞെടുത്തു. തുടർന്ന് അതേ ഡാറ്റ ഉപയോഗിച്ച് അതേ ഡാറ്റയിൽ വായിക്കുക
ഒരേ ക്രമത്തിൽ വലുപ്പങ്ങളും തിരയലുകളും അഭ്യർത്ഥിക്കുക. മുകളിലുള്ള ക്രമം അനന്തമായി ആവർത്തിക്കുക
പുറത്തുകടക്കാൻ പറയുന്നതുവരെ എത്ര തവണ (സിഗ്നൽ അല്ലെങ്കിൽ TUI കമാൻഡ് വഴി).

വായിച്ച ഡാറ്റ, വായിച്ച ഡാറ്റയുമായി പൊരുത്തപ്പെടുന്നുണ്ടെന്ന് ഉറപ്പാക്കാൻ ഡാറ്റ പരിശോധിക്കുന്നു. ഒരു ശാപം-
ആവർത്തനവും ക്യുമുലേറ്റീവ് ട്രാൻസ്ഫർ നിരക്കുകളും, ട്രാൻസ്ഫർ സമയങ്ങളും, കൂടാതെ പ്രദർശിപ്പിക്കുന്നതിന് അടിസ്ഥാനമാക്കിയുള്ള TUI ഉപയോഗിക്കുന്നു
ബൈറ്റുകൾ കൈമാറി. ഉപേക്ഷിച്ചതിന് ശേഷം വാചാലമായ സ്ഥിതിവിവരക്കണക്കുകൾ പ്രദർശിപ്പിക്കുക.

അൽഗോരിതങ്ങൾ

MAX_BUFFER_SIZE > ആകുമ്പോൾ ബ്ലോക്കിന്റെ വലുപ്പം നിർണ്ണയിക്കാൻ ഇനിപ്പറയുന്ന അൽഗോരിതം ഉപയോഗിക്കുന്നു
MIN_BUFFER_SIZE:

2 ന്റെ ശക്തിയും >= MAX_BUFFER_SIZE ഉം ഉള്ള ഏറ്റവും വലിയ ബ്ലോക്ക്സൈസ് കണ്ടെത്തുക. ഇതിനെ വിളിക്കൂ
maxbuffersize. 2 ന്റെ ശക്തിയും >= ആയതുമായ ഏറ്റവും ചെറിയ ബഫർസൈസ് കണ്ടെത്തുക
MIN_BUFFER_SIZE. ഇതിനെ minbuffersize എന്ന് വിളിക്കുക. ചങ്ക്‌സൈസ് = മാക്സ്ബഫർസൈസ് * (വ്യത്യാസം
മിനിറ്റിനും മാക്സ്ബഫർസൈസിനും ഇടയിലുള്ള ബിറ്റുകളുടെ എണ്ണം + 1). കഷണങ്ങളുടെ എണ്ണം ആണ്
TRANSFER_SIZE/ചങ്ക്‌സൈസ്. ഇതിനെ നംചങ്ക്സ് എന്ന് വിളിക്കുക. നംചങ്കുകളുടെ എണ്ണം ഉണ്ടാകും
maxbuffersize വലുപ്പമുള്ള വായന/എഴുതുകൾ, 2 * നംചങ്കുകൾ വായിക്കുന്ന/എഴുതുന്നു
വലിപ്പം maxbuffersize/2, 4 * numchunks വലിപ്പമുള്ള വായന/എഴുതുകളുടെ എണ്ണം
maxbuffersize/4, അങ്ങനെ minbuffersize എത്തുന്നതുവരെ. MIN_BUFFER_SIZE ഇതിനായി ഉപയോഗിക്കുന്നു
TRANSFER_SIZE എന്നത് ഭാഗങ്ങളുടെ വലുപ്പം കൊണ്ട് തുല്യമായി വിഭജിക്കപ്പെടുന്നില്ലെങ്കിൽ ബാക്കിയുള്ള കൈമാറ്റങ്ങൾ.

ഉദാഹരണം: 1k-ന്റെ MIN_BLOCK_SIZE, 8k-ന്റെ MAX_BLOCK_SIZE, 264k-ന്റെ TRANSFER_SIZE എന്നിവ ഉപയോഗിക്കുന്നു
8 8k വായന/എഴുതുകൾ, 16 4k വായന/എഴുതുകൾ, 32 2k വായന/എഴുതുകൾ, 64 + 8 1k എന്നിങ്ങനെയുള്ള ഫലങ്ങൾ
വായിക്കുന്നു/എഴുതുന്നു.

പാറ്റേണുകൾ

ഇനിപ്പറയുന്നവ ഉപയോഗിക്കുക od(1) ഡാറ്റാ സമഗ്രതയുള്ള സ്പ്യൂ ജനറേറ്റഡ് ഫയലുകൾ പരിശോധിക്കാനുള്ള കമാൻഡ്
പ്രശ്നം സംഭവിച്ചു:

od -A d --format=d8 --width=32

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