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

പട്ടിക:

NAME

fio - flexible I/O tester

സിനോപ്സിസ്

fio [ഓപ്ഷനുകൾ] [ജോലി ഫയൽ]...

വിവരണം

fio ഒരു പ്രത്യേക തരം ചെയ്യുന്ന നിരവധി ത്രെഡുകളോ പ്രക്രിയകളോ സൃഷ്ടിക്കുന്ന ഒരു ഉപകരണമാണ്
ഉപയോക്താവ് വ്യക്തമാക്കിയ I/O പ്രവർത്തനം. ഫിയോയുടെ സാധാരണ ഉപയോഗം ഒരു ജോബ് ഫയൽ എഴുതുക എന്നതാണ്
ഒരാൾ അനുകരിക്കാൻ ആഗ്രഹിക്കുന്ന I/O ലോഡുമായി പൊരുത്തപ്പെടുന്നു.

ഓപ്ഷനുകൾ

--ഡീബഗ്=ടൈപ്പ് ചെയ്യുക
വിവിധ ഫിയോ പ്രവർത്തനങ്ങളുടെ വെർബോസ് ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കുക. എല്ലാ തരത്തിനും 'എല്ലാം' ആയിരിക്കാം അല്ലെങ്കിൽ
ഒരു കോമ കൊണ്ട് വേർതിരിച്ച വ്യക്തിഗത തരങ്ങൾ (ഉദാ --debug=io,file). `സഹായം' എല്ലാം ലിസ്റ്റ് ചെയ്യും
ലഭ്യമായ ട്രേസിംഗ് ഓപ്ഷനുകൾ.

--ഔട്ട്പുട്ട്=ഫയലിന്റെ പേര്
ഔട്ട്പുട്ട് എഴുതുക ഫയലിന്റെ പേര്.

--ഔട്ട്പുട്ട്-ഫോർമാറ്റ്=ഫോർമാറ്റ്
റിപ്പോർട്ടിംഗ് ഫോർമാറ്റ് സജ്ജമാക്കുക സാധാരണ, കഠിനമായ, അഥവാ json.

--റൺടൈം=റൺടൈം
പ്രവർത്തന സമയം പരിമിതപ്പെടുത്തുക റൺടൈം സെക്കൻഡ്.

--ബാൻഡ്‌വിഡ്ത്ത്-ലോഗ്
ഓരോ ജോലിക്കും ബാൻഡ്‌വിഡ്ത്ത് ലോഗുകൾ സൃഷ്ടിക്കുക.

--കുറഞ്ഞത്
സ്ഥിതിവിവരക്കണക്കുകൾ ഒരു ചെറിയ, അർദ്ധവിരാമ-ഡിലിമിറ്റഡ് ഫോർമാറ്റിൽ അച്ചടിക്കുക.

--append-terse
തിരഞ്ഞെടുത്ത മോഡിൽ സ്ഥിതിവിവരക്കണക്കുകൾ അച്ചടിക്കുക.

--പതിപ്പ്
പതിപ്പ് വിവരങ്ങൾ പ്രദർശിപ്പിക്കുകയും പുറത്തുകടക്കുകയും ചെയ്യുക.

--ടെർസ്-പതിപ്പ്=പതിപ്പ്
ടെഴ്‌സ് പതിപ്പ് ഔട്ട്‌പുട്ട് ഫോർമാറ്റ് സജ്ജമാക്കുക (നിലവിലെ പതിപ്പ് 3 അല്ലെങ്കിൽ പഴയ പതിപ്പ് 2).

--സഹായിക്കൂ ഉപയോഗ വിവരങ്ങൾ പ്രദർശിപ്പിക്കുകയും പുറത്തുകടക്കുകയും ചെയ്യുക.

--cpuclock-ടെസ്റ്റ്
ആന്തരിക സിപിയു ക്ലോക്കിന്റെ പരിശോധനയും മൂല്യനിർണ്ണയവും നടത്തുക

--crctest[=ടെസ്റ്റ്]
ബിൽറ്റ്ഇൻ ചെക്ക്സമ്മിംഗ് ഫംഗ്ഷനുകളുടെ വേഗത പരിശോധിക്കുക. ഒരു വാദവും നൽകിയിട്ടില്ലെങ്കിൽ, എല്ലാം
അവയിൽ പരീക്ഷിക്കപ്പെടുന്നു. അല്ലെങ്കിൽ ഒരു കോമ വേർതിരിക്കപ്പെട്ട ലിസ്റ്റ് പാസാക്കാം, ഈ സാഹചര്യത്തിൽ
നൽകിയിരിക്കുന്നവ പരിശോധിക്കപ്പെടുന്നു.

--cmdhelp=കമാൻഡ്
ഇതിനായി സഹായ വിവരങ്ങൾ അച്ചടിക്കുക കമാൻഡ്. എല്ലാ കമാൻഡുകൾക്കും `എല്ലാം' ആയിരിക്കാം.

--സഹായിക്കുക=അയോഎൻജിൻ[,കമാൻഡ്]
നിർവചിച്ചിരിക്കുന്ന എല്ലാ കമാൻഡുകളും ലിസ്റ്റ് ചെയ്യുക അയോഎൻജിൻ, അല്ലെങ്കിൽ പ്രിന്റ് സഹായം കമാൻഡ് നിർവചിച്ചിരിക്കുന്നത്
അയോഎൻജിൻ.

--showcmd=ജോലി ഫയൽ
മാറ്റുക ജോലി ഫയൽ ഒരു കൂട്ടം കമാൻഡ്-ലൈൻ ഓപ്ഷനുകളിലേക്ക്.

--എടാ=എപ്പോൾ
എപ്പോഴാണ് തത്സമയ ETA എസ്റ്റിമേറ്റ് പ്രിന്റ് ചെയ്യേണ്ടതെന്ന് വ്യക്തമാക്കുന്നു. എപ്പോൾ ഒന്നായിരിക്കാം
`എപ്പോഴും', `ഒരിക്കലും' അല്ലെങ്കിൽ `ഓട്ടോ'.

--eta-newline=കാലം
കടന്നുപോകുന്ന ഓരോ `സമയ` കാലയളവിനും ഒരു ETA ന്യൂലൈൻ നിർബന്ധമാക്കുക.

--സ്റ്റാറ്റസ്-ഇന്റർവെൽ=കാലം
ഓരോ `സമയ` കാലയളവും കടന്നുപോകുമ്പോൾ മുഴുവൻ ഔട്ട്‌പുട്ട് നിലയും റിപ്പോർട്ട് ചെയ്യുക.

--വായിക്കാൻ മാത്രം
എഴുതാൻ ശ്രമിക്കുന്നത് തടയുന്ന സുരക്ഷാ വായന-മാത്രം പരിശോധനകൾ ഓണാക്കുക.

--വിഭാഗം=സെക്കന്റ്
വിഭാഗം മാത്രം പ്രവർത്തിപ്പിക്കുക സെക്കന്റ് ജോലി ഫയലിൽ നിന്ന്. ചേർക്കാൻ ഈ ഓപ്ഷൻ ഒന്നിലധികം തവണ ഉപയോഗിക്കാം
കൂടുതൽ വിഭാഗങ്ങൾ പ്രവർത്തിപ്പിക്കാൻ.

--alloc-size=kb
ആന്തരിക സ്മോലോക്ക് പൂൾ വലുപ്പം സജ്ജമാക്കുക kb കിലോബൈറ്റുകൾ.

--മുന്നറിയിപ്പുകൾ-മാരകമായ
എല്ലാ ഫിയോ പാർസർ മുന്നറിയിപ്പുകളും മാരകമാണ്, ഇത് ഒരു പിശകോടെ ഫിയോ പുറത്തുകടക്കാൻ കാരണമാകുന്നു.

--പരമാവധി-ജോലികൾ=nr
പിന്തുണയ്ക്കാൻ അനുവദനീയമായ പരമാവധി ജോലികൾ (ത്രെഡുകൾ/പ്രക്രിയകൾ) സജ്ജമാക്കുക.

--സെർവർ=വാദിക്കുന്നു
ഉപയോഗിച്ച് ഒരു ബാക്കെൻഡ് സെർവർ ആരംഭിക്കുക വാദിക്കുന്നു എന്താണ് കേൾക്കേണ്ടതെന്ന് വ്യക്തമാക്കുന്നത്. ക്ലയന്റ്/സെർവർ കാണുക
വിഭാഗം.

--ഡെമോണൈസ്=പിഡ്ഫിൽ
ഒരു ഫിയോ സെർവറിന്റെ പശ്ചാത്തലം, നൽകിയിരിക്കുന്ന pid ഫയലിലേക്ക് pid എഴുതുക.

--കക്ഷി=ഹോസ്റ്റ്
ജോലികൾ പ്രാദേശികമായി പ്രവർത്തിപ്പിക്കുന്നതിനുപകരം, നൽകിയിരിക്കുന്ന ഹോസ്റ്റിലേക്കോ സെറ്റിലേക്കോ അയച്ച് പ്രവർത്തിപ്പിക്കുക
ഹോസ്റ്റുകൾ. ക്ലയന്റ്/സെർവർ വിഭാഗം കാണുക.

--നിഷ്‌ക്രിയ-പ്രൊഫ=ഓപ്ഷൻ
ഒരു സിസ്റ്റം അല്ലെങ്കിൽ പെർസിപിയു അടിസ്ഥാനത്തിൽ സിപിയു നിഷ്‌ക്രിയത്വം റിപ്പോർട്ട് ചെയ്യുക (ഓപ്ഷൻ= സിസ്റ്റം, percpu) അല്ലെങ്കിൽ റൺ യൂണിറ്റ്
വർക്ക് കാലിബ്രേഷൻ മാത്രം (ഓപ്ഷൻ= കാലിബ്രേറ്റ് ചെയ്യുക).

ജോബ് FILE ഫോർമാറ്റ്

ജോബ് ഫയലുകൾ `ഇനി' ഫോർമാറ്റിലാണ്. അവ ആരംഭിക്കുന്ന ഒന്നോ അതിലധികമോ തൊഴിൽ നിർവചനങ്ങൾ ഉൾക്കൊള്ളുന്നു
സ്ക്വയർ ബ്രാക്കറ്റുകളിൽ ജോലിയുടെ പേര്, അടുത്ത ജോലിയുടെ പേരിലേക്ക് നീട്ടുക. ജോലിയുടെ പേര് ആകാം
ഒരു പ്രത്യേക അർത്ഥമുള്ള `ഗ്ലോബൽ' ഒഴികെയുള്ള ഏതെങ്കിലും ASCII സ്ട്രിംഗ്. ജോലിയുടെ പേര് പിന്തുടരുന്നു
ജോലിയുടെ സ്വഭാവം നിർവചിക്കുന്ന പൂജ്യമോ അതിലധികമോ പാരാമീറ്ററുകളുടെ ഒരു ശ്രേണി, ഓരോ വരിയിലും ഒന്ന്.
`;' എന്നതിൽ തുടങ്ങുന്ന ഏതൊരു വരിയും അല്ലെങ്കിൽ `#' പ്രതീകം ഒരു കമന്റായി കണക്കാക്കുകയും അവഗണിക്കുകയും ചെയ്യുന്നു.

If ജോലി ഫയൽ `-' എന്ന് വ്യക്തമാക്കിയിരിക്കുന്നു, സ്റ്റാൻഡേർഡ് ഇൻപുട്ടിൽ നിന്ന് ജോബ് ഫയൽ റീഡ് ചെയ്യും.

ആഗോള വിഭാഗം
ആഗോള വിഭാഗത്തിൽ ജോബ് ഫയലിൽ വ്യക്തമാക്കിയ ജോലികൾക്കായുള്ള ഡിഫോൾട്ട് പാരാമീറ്ററുകൾ അടങ്ങിയിരിക്കുന്നു. ഒരു ജോലി
അതിന് മുകളിൽ വസിക്കുന്ന ആഗോള വിഭാഗങ്ങളെ മാത്രമേ ബാധിക്കുകയുള്ളൂ, കൂടാതെ എത്ര വേണമെങ്കിലും ഉണ്ടാകാം
ആഗോള വിഭാഗങ്ങൾ. പ്രത്യേക തൊഴിൽ നിർവചനങ്ങൾ ആഗോളതലത്തിൽ സജ്ജീകരിച്ചിരിക്കുന്ന ഏത് പാരാമീറ്ററും അസാധുവാക്കാം
വിഭാഗങ്ങൾ.

ജോബ് പാരാമീറ്ററുകൾ

തരത്തിലുള്ളവ
ചില പരാമീറ്ററുകൾ ഒരു പ്രത്യേക തരത്തിലുള്ള ആർഗ്യുമെന്റുകൾ എടുത്തേക്കാം. എവിടെയും ഒരു സംഖ്യാ മൂല്യം
ആവശ്യമായ, ഒരു ഗണിത പദപ്രയോഗം ഉപയോഗിക്കാം, അത് പരാൻതീസിസുകളാൽ ചുറ്റപ്പെട്ടിട്ടുണ്ടെങ്കിൽ.
പിന്തുണയ്ക്കുന്ന ഓപ്പറേറ്റർമാർ:

പുറമേ (+)

ഉപവിഭാഗം (-)

ഗുണനം (*)

ഡിവിഷൻ (/)

മോഡുലസ് (%)

വിസ്താരം (^)

എക്സ്പ്രഷനുകളിലെ സമയ മൂല്യങ്ങൾക്ക്, യൂണിറ്റുകൾ ഡിഫോൾട്ടായി മൈക്രോസെക്കൻഡുകളാണ്. ഇത് വ്യത്യസ്തമാണ്
എക്‌സ്‌പ്രഷനുകളിലല്ലാത്ത സമയ മൂല്യങ്ങൾക്ക് (പരാന്തീസിസിൽ ഉൾപ്പെടുത്തിയിട്ടില്ല). ഉപയോഗിക്കുന്ന തരങ്ങൾ ഇവയാണ്:

str സ്ട്രിംഗ്: ആൽഫാന്യൂമെറിക് പ്രതീകങ്ങളുടെ ഒരു ശ്രേണി.

int SI പൂർണ്ണസംഖ്യ: ഒരു പൂർണ്ണ സംഖ്യ, ഒരുപക്ഷേ അടിസ്ഥാന യൂണിറ്റിനെ സൂചിപ്പിക്കുന്ന ഒരു പ്രത്യയം അടങ്ങിയിരിക്കുന്നു
മൂല്യം. കിലോയെ സൂചിപ്പിക്കുന്ന `k', 'M', 'G', 'T', 'P' എന്നിവയാണ് അംഗീകൃത പ്രത്യയങ്ങൾ
(1024), മെഗാ (1024^2), ഗിഗാ (1024^3), ടെറ (1024^4), പെറ്റ (1024^5)
യഥാക്രമം. '0x' എന്ന പ്രിഫിക്‌സ് ആണെങ്കിൽ, മൂല്യം അടിസ്ഥാന 16 ആണെന്ന് അനുമാനിക്കപ്പെടുന്നു
(ഹെക്സാഡെസിമൽ). ഒരു സഫിക്സിൽ 'b' എന്ന പിൻഗാമി ഉൾപ്പെടാം, ഉദാഹരണത്തിന് 'kb' സമാനമാണ്
'k' ലേക്ക്. 'KiB', 'MiB', 'GiB' മുതലായവ ഉപയോഗിച്ച് നിങ്ങൾക്ക് അടിസ്ഥാന 10 മൂല്യം വ്യക്തമാക്കാം. ഇത്
അടിസ്ഥാന 10 മൂല്യങ്ങളിൽ പലപ്പോഴും മൂല്യങ്ങൾ നൽകിയിരിക്കുന്ന ഡിസ്ക് ഡ്രൈവുകൾക്ക് ഉപയോഗപ്രദമാണ്. വ്യക്തമാക്കുന്നത്
'30GiB' നിങ്ങൾക്ക് 30*1000^3 ബൈറ്റുകൾ ലഭിക്കും. സമയങ്ങൾ വ്യക്തമാക്കുമ്പോൾ ഡിഫോൾട്ട് സഫിക്സ്
അർത്ഥം മാറ്റങ്ങൾ, ഇപ്പോഴും മൂല്യത്തിന്റെ അടിസ്ഥാന യൂണിറ്റിനെ സൂചിപ്പിക്കുന്നു, എന്നാൽ സ്വീകരിച്ച പ്രത്യയങ്ങൾ
'D' (ദിവസങ്ങൾ), 'H' (മണിക്കൂറുകൾ), 'M' (മിനിറ്റുകൾ), 'S' സെക്കൻഡ്, 'ms' (അല്ലെങ്കിൽ msec) മില്ലി
സെക്കൻഡുകൾ, 'ഞങ്ങൾ' (അല്ലെങ്കിൽ 'ഉപയോഗം') മൈക്രോ സെക്കന്റുകൾ. ഒരു യൂണിറ്റ് ഇല്ലാത്ത സമയ മൂല്യങ്ങൾ വ്യക്തമാക്കുന്നു
സെക്കന്റുകൾ. പ്രത്യയങ്ങൾ കേസ് സെൻസിറ്റീവ് അല്ല.

bool ബൂളിയൻ: ശരി അല്ലെങ്കിൽ തെറ്റായ മൂല്യം. `0' എന്നത് തെറ്റിനെ സൂചിപ്പിക്കുന്നു, `1' എന്നത് സത്യത്തെ സൂചിപ്പിക്കുന്നു.

ഇറഞ്ച് പൂർണ്ണസംഖ്യ ശ്രേണി: ഫോർമാറ്റിൽ വ്യക്തമാക്കിയ പൂർണ്ണസംഖ്യകളുടെ ഒരു ശ്രേണി താഴത്തെ:മുകളിലെ or
താഴത്തെ-മുകളിലെ. താഴത്തെ ഒപ്പം മുകളിലെ മുകളിൽ വിവരിച്ചതുപോലെ ഒരു പ്രത്യയം അടങ്ങിയിരിക്കാം. ഒരു ഓപ്ഷൻ ആണെങ്കിൽ
രണ്ട് സെറ്റ് ശ്രേണികൾ അനുവദിക്കുന്നു, അവ ഒരു `,' അല്ലെങ്കിൽ `/' പ്രതീകം ഉപയോഗിച്ച് വേർതിരിച്ചിരിക്കുന്നു. വേണ്ടി
ഉദാഹരണം: `8-8k/8M-4G'.

ഫ്ലോട്ട്_ലിസ്റ്റ്
ഫ്ലോട്ടിംഗ് നമ്പറുകളുടെ ലിസ്റ്റ്: ഫ്ലോട്ടിംഗ് നമ്പറുകളുടെ ഒരു ലിസ്റ്റ്, ഒരു ':' പ്രതീകം കൊണ്ട് വേർതിരിച്ചിരിക്കുന്നു.

പാരാമീറ്റർ പട്ടിക
പേര്=str
ജോലിയുടെ പേര് അസാധുവാക്കാൻ ഉപയോഗിച്ചേക്കാം. കമാൻഡ് ലൈനിൽ, ഈ പരാമീറ്റർ ഉണ്ട്
ഒരു പുതിയ ജോലിയുടെ ആരംഭം സൂചിപ്പിക്കുന്നതിന്റെ പ്രത്യേക ഉദ്ദേശ്യം.

വിവരണം=str
ജോലിയുടെ മനുഷ്യർക്ക് വായിക്കാവുന്ന വിവരണം. ജോലി പ്രവർത്തിപ്പിക്കുമ്പോൾ ഇത് അച്ചടിക്കുന്നു, പക്ഷേ
അല്ലാത്തപക്ഷം പ്രത്യേക ലക്ഷ്യമില്ല.

ഡയറക്ടറി=str
ഈ ഡയറക്‌ടറിയിൽ ഫയലിന്റെ പേരുകൾ പ്രിഫിക്‌സ് ചെയ്യുക. അല്ലാതെ മറ്റൊരു സ്ഥലത്ത് ഫയലുകൾ സ്ഥാപിക്കാൻ ഉപയോഗിക്കുന്നു
`./'. പേരുകൾ ':' ഉപയോഗിച്ച് വേർതിരിക്കുന്നതിലൂടെ നിങ്ങൾക്ക് നിരവധി ഡയറക്‌ടറികൾ വ്യക്തമാക്കാൻ കഴിയും.
സ്വഭാവം. ഈ ഡയറക്‌ടറികൾ ജോബ് ക്ലോണുകൾക്ക് തുല്യമായി വിതരണം ചെയ്യപ്പെടും
ഉപയോഗിച്ച് സൃഷ്ടിക്കുന്നു numjobs അവർ സൃഷ്ടിച്ച ഫയൽനാമങ്ങൾ ഉപയോഗിക്കുന്നിടത്തോളം. നിർദ്ദിഷ്ടമാണെങ്കിൽ
ഫയൽനാമം(കൾ) ആദ്യം ലിസ്‌റ്റ് ചെയ്‌ത ഡയറക്‌ടറി fio ഉപയോഗിക്കുകയും അതുവഴി പൊരുത്തപ്പെടുത്തുകയും ചെയ്യും
The ഫയലിന്റെ പേര് സെമാന്റിക്, അത് വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ ഓരോ ക്ലോണിലും ഒരു ഫയൽ സൃഷ്ടിക്കുന്നു, പക്ഷേ അനുവദിക്കുക
സജ്ജീകരിച്ചാൽ എല്ലാ ക്ലോണുകളും ഒരേപോലെ ഉപയോഗിക്കുന്നു. കാണുക ഫയലിന്റെ പേര് രക്ഷപ്പെടുന്നത് സംബന്ധിച്ച പരിഗണനകൾക്കായി
ചില പ്ലാറ്റ്‌ഫോമുകളിൽ ചില പ്രതീകങ്ങൾ.

ഫയലിന്റെ പേര്=str
fio ജോലിയുടെ പേര്, ത്രെഡ് നമ്പർ, ഫയൽ എന്നിവയെ അടിസ്ഥാനമാക്കി സാധാരണയായി ഒരു ഫയൽ നാമം ഉണ്ടാക്കുന്നു
നമ്പർ. ഒരു ജോലിയിലോ നിരവധി ജോലികളിലോ ഉള്ള ത്രെഡുകൾക്കിടയിൽ നിങ്ങൾക്ക് ഫയലുകൾ പങ്കിടണമെങ്കിൽ,
എ വ്യക്തമാക്കുക ഫയലിന്റെ പേര് അവയിൽ ഓരോന്നിനും സ്ഥിരസ്ഥിതിയെ മറികടക്കാൻ. I/O എഞ്ചിൻ ആണെങ്കിൽ
ഫയൽ അടിസ്ഥാനമാക്കി, പേരുകൾ ഒരു `:' ഉപയോഗിച്ച് വേർതിരിച്ചുകൊണ്ട് നിങ്ങൾക്ക് നിരവധി ഫയലുകൾ വ്യക്തമാക്കാൻ കഴിയും
സ്വഭാവം. `-' എന്നത് ഒരു റിസർവ്ഡ് നാമമാണ്, ഇതിനെ ആശ്രയിച്ച് stdin അല്ലെങ്കിൽ stdout എന്നാണ് അർത്ഥമാക്കുന്നത്
വായിക്കുക/എഴുതാനുള്ള ദിശാ സെറ്റ്. വിൻഡോസിൽ, ഡിസ്ക് ഉപകരണങ്ങൾ \.PhysicalDrive0 ആയി ആക്സസ് ചെയ്യപ്പെടുന്നു
ആദ്യ ഉപകരണത്തിന്, \.PhysicalDrive1 രണ്ടാമത്തേതിന്. ശ്രദ്ധിക്കുക: വിൻഡോസ് ഒപ്പം
ഉപയോഗത്തിലുള്ള ഡാറ്റ അടങ്ങിയ ഡിസ്കിന്റെ ഏരിയകളിലേക്കുള്ള റൈറ്റ് ആക്സസ് ഫ്രീബിഎസ്ഡി തടയുന്നു (ഉദാ
ഫയൽസിസ്റ്റംസ്). ആവശ്യമുള്ള ഫയൽ നാമത്തിൽ കോളൻ ഉൾപ്പെടുത്തേണ്ടതുണ്ടെങ്കിൽ, അത് ഒഴിവാക്കുക
ഒരു '\' പ്രതീകം. ഉദാഹരണത്തിന്, ഫയലിന്റെ പേര് "/dev/dsk/foo@3,0:c" ആണെങ്കിൽ, പിന്നെ
നിങ്ങൾ ഫയൽനാമം="/dev/dsk/foo@3,0\:c" ഉപയോഗിക്കും.

ഫയൽനാമം_ഫോർമാറ്റ്=str
ജോലികൾക്കിടയിൽ ഒന്നിലധികം ഫയലുകൾ പങ്കിടുകയാണെങ്കിൽ, സാധാരണയായി ഫിയോ ഉണ്ടായിരിക്കേണ്ടത് ആവശ്യമാണ്
നിങ്ങൾക്ക് ആവശ്യമുള്ള കൃത്യമായ പേരുകൾ സൃഷ്ടിക്കുക. സ്ഥിരസ്ഥിതിയായി, ഫിയോ അടിസ്ഥാനമാക്കി ഒരു ഫയലിന് പേര് നൽകും
യുടെ ഡിഫോൾട്ട് ഫയൽ ഫോർമാറ്റ് സ്പെസിഫിക്കേഷൻ jobname.jobnumber.filenumber. ഇതിനോടൊപ്പം
ഓപ്ഷൻ, അത് ഇഷ്ടാനുസൃതമാക്കാം. ഫിയോ ഇനിപ്പറയുന്നവ തിരിച്ചറിയുകയും മാറ്റിസ്ഥാപിക്കുകയും ചെയ്യും
ഈ സ്ട്രിംഗിലെ കീവേഡുകൾ:

$ജോലിയുടെ പേര്
തൊഴിലാളി ത്രെഡിന്റെ അല്ലെങ്കിൽ പ്രക്രിയയുടെ പേര്.

$ജോലി
വർക്കർ ത്രെഡിന്റെ അല്ലെങ്കിൽ പ്രോസസിന്റെ ഇൻക്രിമെന്റൽ നമ്പർ.

$filenum
ആ വർക്കർ ത്രെഡ് അല്ലെങ്കിൽ പ്രോസസ്സിനായുള്ള ഫയലിന്റെ ഇൻക്രിമെന്റൽ നമ്പർ.

ആശ്രിത ജോലികൾ ഒരു കൂട്ടം ഫയലുകൾ പങ്കിടുന്നതിന്, ഈ ഓപ്‌ഷൻ ഫിയോ ഉള്ളതായി സജ്ജീകരിക്കാം
രണ്ടും തമ്മിൽ പങ്കിടുന്ന ഫയൽനാമങ്ങൾ സൃഷ്ടിക്കുക. ഉദാഹരണത്തിന്, എങ്കിൽ
testfiles.$filenum വ്യക്തമാക്കിയിരിക്കുന്നു, ഏത് ജോലിക്കും ഫയൽ നമ്പർ 4 പേരിടും
ടെസ്റ്റ് ഫയലുകൾ.4. യുടെ സ്ഥിരസ്ഥിതി $ജോബ്നാമം.$ജോബ്നം.$ഫിലെനം മറ്റൊന്നില്ലെങ്കിൽ ഉപയോഗിക്കും
ഫോർമാറ്റ് സ്പെസിഫയർ നൽകിയിരിക്കുന്നു.

ലോക്ക് ഫയൽ=str
ഫയലുകളൊന്നും IO ചെയ്യുന്നതിനുമുമ്പ് ലോക്ക് ചെയ്യാതിരിക്കാൻ ഫിയോ ഡിഫോൾട്ട് ചെയ്യുന്നു. ഒരു ഫയലോ ഫയലോ ആണെങ്കിൽ
descriptor പങ്കിട്ടു, അന്തിമഫലം ഉണ്ടാക്കാൻ fio-ന് ആ ഫയലിലേക്ക് IO സീരിയലൈസ് ചെയ്യാൻ കഴിയും
സ്ഥിരതയുള്ള. ഫയലുകൾ പങ്കിടുന്ന യഥാർത്ഥ ജോലിഭാരങ്ങൾ അനുകരിക്കുന്നതിന് ഇത് സാധാരണമാണ്. പൂട്ട്
മോഡുകൾ ഇവയാണ്:

ആരും ലോക്കിംഗ് ഇല്ല. ഇതാണ് സ്ഥിരസ്ഥിതി.

എക്സ്ക്ലൂസീവ്
മറ്റെല്ലാം ഒഴികെ ഒരു സമയം ഒരു ത്രെഡ് അല്ലെങ്കിൽ പ്രോസസ്സ് മാത്രമേ IO ചെയ്യാൻ കഴിയൂ.

റീഡ്‌റൈറ്റ്
ഫയലിൽ റീഡ്-റൈറ്റ് ലോക്കിംഗ്. പല വായനക്കാർക്കും ഫയൽ ആക്സസ് ചെയ്യാം
അതേ സമയം, എന്നാൽ എഴുത്തുകൾക്ക് എക്സ്ക്ലൂസീവ് ആക്സസ് ലഭിക്കും.

ഓപ്പൺഡിർ=str ഡയറക്‌ടറിക്ക് താഴെയുള്ള ഏതെങ്കിലും ഫയലുകൾ ആവർത്തിച്ച് തുറക്കുക str.

റീഡ്‌റൈറ്റ്=str, rw=str
I/O പാറ്റേണിന്റെ തരം. സ്വീകാര്യമായ മൂല്യങ്ങൾ ഇവയാണ്:

വായിക്കുക തുടർച്ചയായ വായനകൾ.

എഴുതുക തുടർച്ചയായി എഴുതുന്നു.

ട്രിം ചെയ്യുക സീക്വൻഷ്യൽ ട്രിം (ലിനക്സ് ബ്ലോക്ക് ഉപകരണങ്ങൾ മാത്രം).

റാൻഡ്രെഡ്
ക്രമരഹിതമായി വായിക്കുന്നു.

റാൻഡ്റൈറ്റ്
ക്രമരഹിതമായി എഴുതുന്നു.

റാൻഡ്ട്രിം
ക്രമരഹിതമായ ട്രിം (ലിനക്സ് ബ്ലോക്ക് ഉപകരണങ്ങൾ മാത്രം).

rw, റീഡ്‌റൈറ്റ്
സമ്മിശ്രമായ വായനയും എഴുത്തും.

randrw ക്രമരഹിതമായ വായനയും എഴുത്തും.

trimwrite
മിക്സഡ് വർക്ക് ലോഡ് ട്രിം ചെയ്ത് എഴുതുക. ബ്ലോക്കുകൾ ആദ്യം ട്രിം ചെയ്യും, തുടർന്ന്
ഇതേ ബ്ലോക്കുകൾ എഴുതപ്പെടും.

മിക്സഡ് ഐ/ഒയ്ക്ക്, ഡിഫോൾട്ട് സ്പ്ലിറ്റ് 50/50 ആണ്. ചില തരത്തിലുള്ള ഐഒകൾക്ക് ഫലം ഉണ്ടായേക്കാം
വേഗത വ്യത്യസ്‌തമായിരിക്കാമെന്നതിനാൽ ഇപ്പോഴും അൽപ്പം വളച്ചൊടിക്കുക. വ്യക്തമാക്കാൻ സാധിക്കും
ഒരു പുതിയ ഓഫ്‌സെറ്റ് ലഭിക്കുന്നതിന് മുമ്പ് ചെയ്യേണ്ട നിരവധി IO-കൾ, ഇത് a ചേർത്താണ് ചെയ്യുന്നത്
`: നൽകിയിരിക്കുന്ന ചരടിന്റെ അവസാനം വരെ. ക്രമരഹിതമായി വായിക്കാൻ, അത് ഇതുപോലെ കാണപ്പെടും
rw=randread:8 8 മൂല്യമുള്ള ഒരു ഓഫ്‌സെറ്റ് മോഡിഫയറിൽ കടന്നുപോകുന്നതിന്. പോസ്റ്റ്ഫിക്സ് ആണെങ്കിൽ
ഒരു സീക്വൻഷ്യൽ IO പാറ്റേൺ ഉപയോഗിച്ചാണ് ഉപയോഗിക്കുന്നത്, തുടർന്ന് വ്യക്തമാക്കിയ മൂല്യം എന്നതിലേക്ക് ചേർക്കും
ഓരോ IO-നും ഓഫ്‌സെറ്റ് സൃഷ്ടിച്ചു. ഉദാഹരണത്തിന്, ഉപയോഗിക്കുന്നത് rw=എഴുതുക:4k 4k ഒഴിവാക്കും
ഓരോ എഴുത്തും. ഇത് സീക്വൻഷ്യൽ ഐഒയെ ദ്വാരങ്ങളുള്ള സീക്വൻഷ്യൽ ഐഒ ആക്കി മാറ്റുന്നു. കാണുക
rw_sequencer ഓപ്ഷൻ.

rw_sequencer=str
എന്നതിലേക്ക് ഒരു നമ്പർ ചേർത്തുകൊണ്ട് ഒരു ഓഫ്‌സെറ്റ് മോഡിഫയർ നൽകിയിട്ടുണ്ടെങ്കിൽ rw= ലൈൻ, പിന്നെ
ജനറേറ്റുചെയ്യുന്ന IO ഓഫ്‌സെറ്റിനെ ആ നമ്പർ എങ്ങനെ പരിഷ്‌ക്കരിക്കുന്നു എന്നത് ഈ ഓപ്ഷൻ നിയന്ത്രിക്കുന്നു.
സ്വീകാര്യമായ മൂല്യങ്ങൾ ഇവയാണ്:

തുടർച്ചയായ
തുടർച്ചയായ ഓഫ്‌സെറ്റ് സൃഷ്ടിക്കുക

സമാനമായ
ഒരേ ഓഫ്സെറ്റ് സൃഷ്ടിക്കുക

തുടർച്ചയായ റാൻഡം ഐഒയ്ക്ക് മാത്രമേ ഇത് ഉപയോഗപ്രദമാകൂ, അവിടെ ഫിയോ സാധാരണയായി പുതിയത് സൃഷ്ടിക്കും
ഓരോ IO-യ്‌ക്കും ക്രമരഹിതമായ ഓഫ്‌സെറ്റ്. നിങ്ങൾ റാൻഡ്‌റെഡിലേക്ക് ഉദാ 8 ചേർത്താൽ, നിങ്ങൾക്ക് പുതിയത് ലഭിക്കും
ഓരോ 8 IO-കൾക്കും ക്രമരഹിതമായ ഓഫ്‌സെറ്റ്. ഫലം ഓരോ 8 IO-കൾക്കും വേണ്ടിയുള്ള അന്വേഷണം മാത്രമായിരിക്കും,
ഓരോ IO യ്ക്കും പകരം. ഉപയോഗിക്കുക rw=randread:8 അത് വ്യക്തമാക്കാൻ. സീക്വൻഷ്യൽ IO പോലെ
ഇതിനകം തുടർച്ചയായി, ക്രമീകരണം തുടർച്ചയായ അതൊന്നും ഫലം ചെയ്യില്ലല്ലോ
വ്യത്യാസങ്ങൾ. സമാനമായ സമാനമായ രീതിയിൽ പെരുമാറുന്നു, അത് അയയ്‌ക്കുന്നതൊഴിച്ചാൽ
ഒരു പുതിയ ഓഫ്‌സെറ്റ് സൃഷ്ടിക്കുന്നതിന് മുമ്പ് 8 തവണ ഓഫ്‌സെറ്റ് ചെയ്യുക.

kb_base=int
ഒരു കിലോബൈറ്റിനുള്ള അടിസ്ഥാന യൂണിറ്റ്. ഡിഫാക്റ്റോ ബേസ് 2^10 ആണ്, 1024. സംഭരണം
നിർമ്മാതാക്കൾ 10^3 അല്ലെങ്കിൽ 1000 അടിസ്ഥാന പത്ത് യൂണിറ്റായി ഉപയോഗിക്കാൻ ഇഷ്ടപ്പെടുന്നു, വ്യക്തമായും
കാരണങ്ങൾ. അനുവദനീയമായ മൂല്യങ്ങൾ 1024 അല്ലെങ്കിൽ 1000 ആണ്, 1024 ഡിഫോൾട്ടാണ്.

unified_rw_reporting=bool
ഫിയോ സാധാരണയായി സ്ഥിതിവിവരക്കണക്കുകൾ ഓരോ ഡാറ്റ ദിശാടിസ്ഥാനത്തിലും റിപ്പോർട്ട് ചെയ്യുന്നു, അതായത് വായിക്കുന്നത്,
എഴുതുക, ട്രിം ചെയ്യുക എന്നിവ പ്രത്യേകം കണക്കാക്കുകയും റിപ്പോർട്ടുചെയ്യുകയും ചെയ്യുന്നു. ഈ ഓപ്ഷൻ ഫിയോ ആണെങ്കിൽ
ഫലങ്ങൾ സംഗ്രഹിക്കുകയും പകരം "മിക്സഡ്" എന്ന് റിപ്പോർട്ട് ചെയ്യുകയും ചെയ്യുന്നു.

വീണ്ടും ആവർത്തിക്കുക=bool
ക്രമരഹിതമായ I/O പാറ്റേണുകൾക്കായി ഉപയോഗിക്കുന്ന റാൻഡം നമ്പർ ജനറേറ്റർ പ്രവചിക്കാവുന്ന രീതിയിൽ സീഡ് ചെയ്യുക
അതിനാൽ റണ്ണുകളിലുടനീളം പാറ്റേൺ ആവർത്തിക്കാവുന്നതാണ്. സ്ഥിരസ്ഥിതി: ശരി.

എല്ലാം ആവർത്തിക്കുക=bool
എല്ലാ റാൻഡം നമ്പർ ജനറേറ്ററുകളും പ്രവചിക്കാവുന്ന രീതിയിൽ വിത്ത് ചെയ്യുക, അങ്ങനെ ഫലങ്ങൾ ആവർത്തിക്കാവുന്നതാണ്
റണ്ണുകളിലുടനീളം. സ്ഥിരസ്ഥിതി: തെറ്റ്.

റാൻഡ്സീഡ്=int
നിയന്ത്രിക്കാൻ ഈ വിത്ത് മൂല്യത്തെ അടിസ്ഥാനമാക്കി റാൻഡം നമ്പർ ജനറേറ്ററുകൾ വിത്ത് ചെയ്യുക
ഔട്ട്പുട്ടിന്റെ ഏത് ശ്രേണിയാണ് സൃഷ്ടിക്കുന്നത്. സജ്ജീകരിച്ചിട്ടില്ലെങ്കിൽ, ക്രമരഹിതമായ ക്രമം ആശ്രയിച്ചിരിക്കുന്നു
ന് വീണ്ടും ആവർത്തിക്കുക ക്രമീകരണം.

വീഴുക=str
ഫയലുകൾ വയ്ക്കുമ്പോൾ പ്രീ-അലോക്കേഷൻ നടത്തുന്നുണ്ടോ. സ്വീകാര്യമായ മൂല്യങ്ങൾ ഇവയാണ്:

ആരും സ്ഥലം മുൻകൂട്ടി അനുവദിക്കരുത്.

പോസിക്സ് വഴി മുൻകൂട്ടി അനുവദിക്കുക posix_fallocate(3).

സൂക്ഷിക്കുക വഴി മുൻകൂട്ടി അനുവദിക്കുക വീഴുക(2) FALLOC_FL_KEEP_SIZE സെറ്റിനൊപ്പം.

0 'ഒന്നുമില്ല' എന്നതിന് പിന്നിലേക്ക്-അനുയോജ്യമായ അപരനാമം.

1 'പോസിക്‌സ്' എന്നതിന് പിന്നിലേക്ക്-അനുയോജ്യമായ അപരനാമം.

പിന്തുണയ്‌ക്കുന്ന എല്ലാ പ്ലാറ്റ്‌ഫോമുകളിലും ലഭ്യമായേക്കില്ല. 'keep' ലിനക്സിൽ മാത്രമേ ലഭ്യമാകൂ.
സോളാരിസിൽ ZFS ഉപയോഗിക്കുകയാണെങ്കിൽ, ZFS പിന്തുണയ്ക്കാത്തതിനാൽ ഇത് 'ഒന്നുമില്ല' എന്ന് സജ്ജീകരിക്കണം.
സ്ഥിരസ്ഥിതി: 'posix'.

fadvise_hint=bool
ഉപയോഗം posix_fadvise(2) I/O പാറ്റേണുകൾ എന്തായിരിക്കാൻ സാധ്യതയുണ്ടെന്ന് കേർണലിനെ ഉപദേശിക്കാൻ
ഇഷ്യൂചെയ്തു. സ്ഥിരസ്ഥിതി: ശരി.

fadvise_stream=int
ഉപയോഗം posix_fadvise(2) പുറപ്പെടുവിച്ച റൈറ്റുകൾ ഏത് സ്ട്രീം ഐഡിയിൽ പെട്ടതാണെന്ന് കേർണലിനെ ഉപദേശിക്കാൻ
വരെ. Linux-ൽ മാത്രം പിന്തുണയ്ക്കുന്നു. ശ്രദ്ധിക്കുക, ഈ ഓപ്‌ഷൻ ഭാവിയിൽ മാറിയേക്കാം.

വലുപ്പം=int
ഈ ജോലിയുടെ ആകെ വലുപ്പം I/O. fio ഇത്രയും ബൈറ്റുകൾ ഉണ്ടാകുന്നതുവരെ പ്രവർത്തിക്കും
മറ്റ് ഓപ്‌ഷനുകളാൽ പരിമിതപ്പെടുത്തിയില്ലെങ്കിൽ കൈമാറ്റം ചെയ്‌തു (റൺടൈം, ഉദാഹരണത്തിന്, അല്ലെങ്കിൽ
വർദ്ധിച്ചു/കുറച്ചു io_size). അല്ലാതെ nrfiles ഒപ്പം ഫയലിന്റെ വലിപ്പം ഓപ്ഷനുകൾ നൽകിയിരിക്കുന്നു,
ഈ തുക ജോലിക്കായി ലഭ്യമായ ഫയലുകൾക്കിടയിൽ വിഭജിക്കപ്പെടും. സജ്ജമാക്കിയില്ലെങ്കിൽ,
തന്നിരിക്കുന്ന ഫയലുകളുടെയോ ഉപകരണങ്ങളുടെയോ പൂർണ്ണ വലുപ്പം fio ഉപയോഗിക്കും. ഫയലുകൾ ഇല്ലെങ്കിൽ
നിലവിലുണ്ട്, വലിപ്പം നൽകണം. ഇടയ്ക്ക് ഒരു ശതമാനമായി വലിപ്പം നൽകാനും സാധിക്കും
1 ഉം 100 ഉം. സൈസ്=20% നൽകിയാൽ, ഫിയോ നൽകിയിട്ടുള്ള പൂർണ്ണ വലുപ്പത്തിന്റെ 20% ഉപയോഗിക്കും
ഫയലുകൾ അല്ലെങ്കിൽ ഉപകരണങ്ങൾ.

io_size=int, io_limit =int
സാധാരണയായി ഫിയോ സജ്ജീകരിച്ച പ്രദേശത്തിനുള്ളിൽ പ്രവർത്തിക്കുന്നു വലുപ്പം, അതിനർത്ഥം വലുപ്പം
ഐ‌ഒയുടെ മേഖലയും വലുപ്പവും നിർവ്വഹിക്കുന്നതിന് ഓപ്ഷൻ സജ്ജമാക്കുന്നു. ചിലപ്പോൾ അങ്ങനെയല്ല
നിങ്ങൾക്കെന്താണ് വേണ്ടത്. ഈ ഓപ്ഷൻ ഉപയോഗിച്ച്, IO യുടെ അളവ് മാത്രം നിർവചിക്കാൻ കഴിയും
ഫിയോ ചെയ്യണം. ഉദാഹരണത്തിന്, എങ്കിൽ വലുപ്പം 20G ആയി സജ്ജീകരിച്ചിരിക്കുന്നു ഒപ്പം io_limit 5G ആയി സജ്ജീകരിച്ചിരിക്കുന്നു,
fio ആദ്യത്തെ 20G-യിൽ IO നിർവഹിക്കും, എന്നാൽ 5G ചെയ്തുകഴിഞ്ഞാൽ പുറത്തുകടക്കും. ദി
വിപരീതവും സാധ്യമാണ് - എങ്കിൽ വലുപ്പം 20G ആയി സജ്ജീകരിച്ചിരിക്കുന്നു, ഒപ്പം io_size 40G ആയി സജ്ജീകരിച്ചിരിക്കുന്നു, തുടർന്ന്
40..0G മേഖലയ്ക്കുള്ളിൽ fio 20G IO ചെയ്യും.

ഫിൽ_ഡിവൈസ്=bool, fill_fs=bool
വലുപ്പം വളരെ വലുതായി സജ്ജീകരിക്കുകയും ENOSPC-യ്‌ക്കായി കാത്തിരിക്കുകയും ചെയ്യുന്നു (ഉപകരണത്തിൽ ഇടമില്ല)
അവസാനിപ്പിക്കുന്ന അവസ്ഥയായി. തുടർച്ചയായി എഴുതുമ്പോൾ മാത്രമേ അർത്ഥമുള്ളൂ. ഒരു വായനയ്ക്കായി
ജോലിഭാരം, മൗണ്ട് പോയിന്റ് ആദ്യം പൂരിപ്പിക്കും, തുടർന്ന് ഫലത്തിൽ IO ആരംഭിക്കും. ഈ
ഒരു അസംസ്‌കൃത ഉപകരണ നോഡിൽ പ്രവർത്തിക്കുകയാണെങ്കിൽ ഓപ്ഷൻ അർത്ഥമാക്കുന്നില്ല, കാരണം അതിന്റെ വലുപ്പം
ഫയൽ സിസ്റ്റം ഇതിനകം അറിയപ്പെടുന്നു. കൂടാതെ, ഉപകരണത്തിന്റെ അവസാനത്തിനപ്പുറം എഴുതുന്നു
അവിടെ ENOSPC തിരികെ നൽകില്ല.

ഫയലിന്റെ വലിപ്പം=ഇറഞ്ച്
വ്യക്തിഗത ഫയൽ വലുപ്പങ്ങൾ. ഒരു ശ്രേണി ആയിരിക്കാം, ഈ സാഹചര്യത്തിൽ fio എന്നതിനായുള്ള വലുപ്പങ്ങൾ തിരഞ്ഞെടുക്കും
നൽകിയിരിക്കുന്ന പരിധിക്കുള്ളിൽ ക്രമരഹിതമായ ഫയലുകൾ, പരിമിതപ്പെടുത്തിയിരിക്കുന്നു വലുപ്പം മൊത്തത്തിൽ (അങ്ങനെയാണെങ്കിൽ
നൽകിയത്). എങ്കിൽ ഫയലിന്റെ വലിപ്പം എന്നത് വ്യക്തമാക്കിയിട്ടില്ല, സൃഷ്ടിച്ച ഓരോ ഫയലിനും ഒരേ വലിപ്പമുണ്ട്.

file_append=bool
ഫയൽ അവസാനിച്ചതിന് ശേഷം IO നടത്തുക. സാധാരണയായി ഫിയോയുടെ വലിപ്പത്തിൽ പ്രവർത്തിക്കും
ഒരു ഫയല്. ഈ ഓപ്‌ഷൻ സജ്ജമാക്കിയാൽ, പകരം ഫിയോ ഫയലിൽ ചേർക്കും. ഇതിനുണ്ട്
ഒരു ഫയലിന്റെ വലുപ്പത്തിലേക്ക് ഓഫ്‌സെറ്റ് ക്രമീകരിക്കുന്നതിന് സമാനമായ സ്വഭാവം. ഈ ഓപ്ഷൻ അവഗണിക്കപ്പെട്ടു
നോൺ-റെഗുലർ ഫയലുകളിൽ.

ബ്ലോക്കുകളുടെ വലിപ്പം=int[,int], bs=int[,int]
I/O യൂണിറ്റുകൾക്കുള്ള ബ്ലോക്ക് വലുപ്പം. സ്ഥിരസ്ഥിതി: 4k. വായിക്കുന്നതിനും എഴുതുന്നതിനും ട്രിം ചെയ്യുന്നതിനുമുള്ള മൂല്യങ്ങൾ ആകാം
ഫോർമാറ്റിൽ പ്രത്യേകം വ്യക്തമാക്കിയിട്ടുണ്ട് വായിക്കുക,എഴുതുക,ട്രിം ചെയ്യുക അവയിലേതെങ്കിലും ശൂന്യമായിരിക്കാം
ആ മൂല്യം അതിന്റെ സ്ഥിരസ്ഥിതിയായി വിടുക. ഒരു ട്രെയിലിംഗ് കോമ നൽകിയില്ലെങ്കിൽ, ബാക്കിയുള്ളത്
അവസാന മൂല്യം സെറ്റ് അവകാശമാക്കും.

blocksize_range=ഇറഞ്ച്[,ഇറഞ്ച്], അസംബന്ധം=ഇറഞ്ച്[,ഇറഞ്ച്]
I/O ബ്ലോക്ക് വലുപ്പങ്ങളുടെ ഒരു ശ്രേണി വ്യക്തമാക്കുക. ഇഷ്യൂ ചെയ്ത I/O യൂണിറ്റ് എപ്പോഴും ഒന്നിലധികം ആയിരിക്കും
കുറഞ്ഞ വലിപ്പം, ഒഴികെ blocksize_unaligned സജ്ജീകരിച്ചിരിക്കുന്നു. രണ്ടും വായിക്കുന്നതിനും ബാധകമാണ്
ഒരു ശ്രേണി മാത്രം നൽകിയാൽ എഴുതുന്നു, എന്നാൽ ഒരു കോമ ഉപയോഗിച്ച് പ്രത്യേകം വ്യക്തമാക്കാം
മൂല്യങ്ങൾ വേർതിരിക്കുന്നു. ഉദാഹരണം: bsrange=1k-4k,2k-8k. കൂടാതെ (കാണുക ബ്ലോക്കുകളുടെ വലിപ്പം).

bsplit=str
ഈ ഓപ്‌ഷൻ ഇഷ്യൂ ചെയ്ത ബ്ലോക്ക് വലുപ്പങ്ങളുടെ സൂക്ഷ്മമായ നിയന്ത്രണം അനുവദിക്കുന്നു, മാത്രമല്ല
അവർക്കിടയിൽ പിളരുന്നു പോലും. ഈ ഓപ്ഷൻ ഉപയോഗിച്ച്, നിങ്ങൾക്ക് വിവിധ ബ്ലോക്കുകളുടെ വലുപ്പം തൂക്കാം
മിക്സഡ് ബ്ലോക്ക് സൈസുകളുള്ള ഒരു ജോലിക്ക് ഇഷ്യൂ ചെയ്ത IO യുടെ കൃത്യമായ നിയന്ത്രണം. എന്ന ഫോർമാറ്റ്
ഓപ്‌ഷൻ bssplit=blocksize/percentage ആണ്, ഓപ്‌ഷണലായി നിരവധി നിർവചനങ്ങൾ ചേർക്കുന്നു
ആവശ്യാനുസരണം ഒരു കോളൻ കൊണ്ട് വേർതിരിച്ചിരിക്കുന്നു. ഉദാഹരണം: bssplit=4k/10:64k/50:32k/40 പുറപ്പെടുവിക്കും
50% 64k ബ്ലോക്കുകളും 10% 4k ബ്ലോക്കുകളും 40% 32k ബ്ലോക്കുകളും. bsplit കൊടുക്കുന്നതും പിന്തുണയ്ക്കുന്നു
വായിക്കാനും എഴുതാനും വേർതിരിക്കുക. ഫോർമാറ്റ് എന്താണെന്നതിന് സമാനമാണ് bs ഓപ്ഷൻ
സ്വീകരിക്കുന്നു, വായിക്കുകയും എഴുതുകയും ചെയ്യുന്ന ഭാഗങ്ങൾ കോമ ഉപയോഗിച്ച് വേർതിരിക്കുന്നു.

blocksize_unaligned, bs_unaligned
സജ്ജമാക്കിയാൽ, ഏത് വലുപ്പത്തിലും blocksize_range ഉപയോഗിച്ചേക്കാം. ഇത് സാധാരണയായി പ്രവർത്തിക്കില്ല
നേരിട്ടുള്ള I/O, അതിന് സാധാരണയായി സെക്ടർ വിന്യാസം ആവശ്യമാണ്.

തടയൽ=int[,int], ba=int[,int]
ക്രമരഹിതമായ IO ഓഫ്‌സെറ്റുകൾ വിന്യസിക്കേണ്ടത് ഏത് അതിർത്തിയിലാണ്. 'ബ്ലോക്ക്‌സൈസ്' എന്നതിന് സമാനമാണ് ഡിഫോൾട്ടുകൾ
നൽകിയിരിക്കുന്ന ഏറ്റവും കുറഞ്ഞ ബ്ലോക്കിന്റെ വലിപ്പം. നേരിട്ട് ഉപയോഗിക്കുന്നതിനുള്ള ഏറ്റവും കുറഞ്ഞ വിന്യാസം സാധാരണയായി 512b ആണ്
IO, ഇത് സാധാരണയായി ഹാർഡ്‌വെയർ ബ്ലോക്ക് വലുപ്പത്തെ ആശ്രയിച്ചിരിക്കുന്നു. ഈ ഓപ്ഷൻ പരസ്പരമാണ്
ഫയലുകൾക്കായി ഒരു റാൻഡം മാപ്പ് ഉപയോഗിച്ച് പ്രത്യേകം, അതിനാൽ അത് ആ ഓപ്ഷൻ ഓഫാക്കും.

bs_is_seq_rand=bool
ഈ ഓപ്‌ഷൻ സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിൽ, ഫിയോ സാധാരണ റീഡ്, റൈറ്റ് ബ്ലോക്ക്‌സൈസ് ക്രമീകരണങ്ങൾ ഉപയോഗിക്കും
ക്രമം, പകരം ക്രമരഹിതം. ക്രമരഹിതമായി വായിക്കുകയോ എഴുതുകയോ ചെയ്യുന്നത് WRITE ബ്ലോക്കിന്റെ വലുപ്പം ഉപയോഗിക്കും
ക്രമീകരണങ്ങൾ, കൂടാതെ ഏതെങ്കിലും തുടർച്ചയായ വായന അല്ലെങ്കിൽ എഴുത്ത് റീഡ് ബ്ലോക്ക്സൈസ് ക്രമീകരണം ഉപയോഗിക്കും.

പൂജ്യം_ബഫറുകൾ
എല്ലാ പൂജ്യങ്ങളും ഉപയോഗിച്ച് ബഫറുകൾ ആരംഭിക്കുക. ഡിഫോൾട്ട്: റാൻഡം ഡാറ്റ ഉപയോഗിച്ച് ബഫറുകൾ പൂരിപ്പിക്കുക.

റീഫിൽ_ബഫറുകൾ
ഈ ഓപ്‌ഷൻ നൽകിയാൽ, ഓരോ സമർപ്പിക്കുമ്പോഴും ഫിയോ ഐഒ ബഫറുകൾ വീണ്ടും നിറയ്ക്കും. ദി
ഇത് init സമയത്ത് മാത്രം പൂരിപ്പിക്കുകയും ആ ഡാറ്റ വീണ്ടും ഉപയോഗിക്കുകയും ചെയ്യുക എന്നതാണ് ഡിഫോൾട്ട്. എങ്കിൽ മാത്രമേ അർത്ഥമുള്ളൂ
സ്വാഭാവികമായും zero_buffers വ്യക്തമാക്കിയിട്ടില്ല. ഡാറ്റ പരിശോധന പ്രവർത്തനക്ഷമമാക്കിയിട്ടുണ്ടെങ്കിൽ,
refill_buffers സ്വയമേവ പ്രവർത്തനക്ഷമമാക്കുന്നു.

സ്ക്രാംബിൾ_ബഫറുകൾ=bool
If റീഫിൽ_ബഫറുകൾ ഇത് വളരെ ചെലവേറിയതാണ്, ടാർഗെറ്റ് ഡാറ്റ ഡ്യൂപ്ലിക്കേഷൻ ഉപയോഗിക്കുന്നു, തുടർന്ന്
ഈ ഓപ്‌ഷൻ ക്രമീകരിക്കുന്നത് സാധാരണ തോൽപ്പിക്കാൻ IO ബഫർ ഉള്ളടക്കത്തെ ചെറുതായി പരിഷ്‌ക്കരിക്കും
ഡ്യൂപ്പ് ശ്രമങ്ങൾ. കൂടുതൽ സമർത്ഥമായ ബ്ലോക്ക് കംപ്രഷനെ പരാജയപ്പെടുത്താൻ ഇത് പര്യാപ്തമല്ല
ശ്രമങ്ങൾ, പക്ഷേ അത് ബ്ലോക്കുകളുടെ നിഷ്കളങ്കതയെ തടയും. സ്ഥിരസ്ഥിതി: ശരി.

ബഫർ_കംപ്രസ്_ശതമാനം=int
ഇത് സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിൽ, ഫിയോ IO ബഫർ ഉള്ളടക്കം (എഴുതുകളിൽ) നൽകാൻ ശ്രമിക്കും
നിർദ്ദിഷ്ട തലത്തിലേക്ക് കംപ്രസ് ചെയ്യുക. റാൻഡം ഡാറ്റയുടെ മിശ്രിതം നൽകിയാണ് ഫിയോ ഇത് ചെയ്യുന്നത്
ഒരു നിശ്ചിത മാതൃകയും. നിശ്ചിത പാറ്റേൺ ഒന്നുകിൽ പൂജ്യങ്ങളാണ്, അല്ലെങ്കിൽ വ്യക്തമാക്കിയ പാറ്റേൺ
by ബഫർ_പാറ്റേൺ. പാറ്റേൺ ഓപ്ഷൻ ഉപയോഗിക്കുകയാണെങ്കിൽ, അത് കംപ്രഷൻ വളച്ചൊടിച്ചേക്കാം
അനുപാതം ചെറുതായി. ഇത് ഓരോ ബ്ലോക്ക് സൈസ് യൂണിറ്റിനും, ഫയൽ/ഡിസ്‌ക് വീതിയിലാണെന്ന് ശ്രദ്ധിക്കുക
ഈ ക്രമീകരണവുമായി പൊരുത്തപ്പെടുന്ന കംപ്രഷൻ ലെവൽ. ഇത് ഓരോ ബ്ലോക്ക് സൈസ് യൂണിറ്റിനും ആണെന്നത് ശ്രദ്ധിക്കുക,
ഈ ക്രമീകരണവുമായി പൊരുത്തപ്പെടുന്ന ഫയൽ/ഡിസ്ക് വൈഡ് കംപ്രഷൻ ലെവലിനായി, നിങ്ങൾക്കും ഇത് ആവശ്യമാണ്
refill_buffers സജ്ജമാക്കുക.

ബഫർ_കംപ്രസ്_ചങ്ക്=int
കാണുക ബഫർ_കംപ്രസ്_ശതമാനം. ഈ ക്രമീകരണം ഫിയോയെ എത്ര വലുതാണെന്ന് നിയന്ത്രിക്കാൻ അനുവദിക്കുന്നു
ക്രമരഹിതമായ ഡാറ്റയുടെ ശ്രേണികളും പൂജ്യമായ ഡാറ്റയുമാണ്. ഈ സെറ്റ് ഇല്ലാതെ, ഫിയോ നൽകും
ബഫർ_കംപ്രസ്_ശതമാനം ബ്ലോക്ക്‌സൈസ് റാൻഡം ഡാറ്റ, തുടർന്ന് ബാക്കിയുള്ളത്
പൂജ്യം. ബ്ലോക്ക് വലുപ്പത്തേക്കാൾ ചെറുതായ ചില ചങ്ക് വലുപ്പത്തിലേക്ക് ഈ സെറ്റ് ഉപയോഗിച്ച്, ഫിയോയ്ക്ക് കഴിയും
IO ബഫറിലുടനീളം ഇതര ക്രമരഹിതവും പൂജ്യവുമായ ഡാറ്റ.

ബഫർ_പാറ്റേൺ=str
സജ്ജമാക്കിയാൽ, ഈ പാറ്റേൺ ഉപയോഗിച്ച് ഫിയോ ഐഒ ബഫറുകൾ നിറയ്ക്കും. സജ്ജീകരിച്ചിട്ടില്ലെങ്കിൽ, ഉള്ളടക്കം
ബഫർ ഉള്ളടക്കങ്ങളുമായി ബന്ധപ്പെട്ട മറ്റ് ഓപ്ഷനുകളാൽ IO ബഫറുകൾ നിർവചിക്കപ്പെടുന്നു. ക്രമീകരണം
ബൈറ്റുകളുടെ ഏതെങ്കിലും പാറ്റേൺ ആകാം, കൂടാതെ ഹെക്‌സ് മൂല്യങ്ങൾക്കായി 0x ഉപയോഗിച്ച് പ്രിഫിക്‌സ് ചെയ്യാം. അത് ഒരുപക്ഷെ
ഒരു സ്ട്രിംഗും ആകുക, അവിടെ സ്ട്രിംഗ് "" കൊണ്ട് പൊതിയണം, ഉദാ:
ബഫർ_പാറ്റേൺ= "abcd"
or
ബഫർ_പാറ്റേൺ=-12
or
ബഫർ_പാറ്റേൺ=0x ഡെഡ്‌ഫേസ്

കൂടാതെ, നിങ്ങൾക്ക് ഏത് ക്രമത്തിലും എല്ലാം സംയോജിപ്പിക്കാൻ കഴിയും:

ബഫർ_പാറ്റേൺ=0xdeadface"abcd"-12

dedupe_percentage=int
സജ്ജീകരിച്ചാൽ, എഴുതുമ്പോൾ സമാനമായ ബഫറുകളുടെ ഈ ശതമാനം ഫിയോ സൃഷ്ടിക്കും. ഇവ
ബഫറുകൾ സ്വാഭാവികമായും ഒഴിവാക്കാവുന്നതായിരിക്കും. ബഫറുകളുടെ ഉള്ളടക്കം എന്തിനെ ആശ്രയിച്ചിരിക്കുന്നു
മറ്റ് ബഫർ കംപ്രഷൻ ക്രമീകരണങ്ങൾ സജ്ജമാക്കി. ഉണ്ടാകാൻ സാധ്യതയുണ്ട്
വ്യക്തിഗത ബഫറുകൾ ഒന്നുകിൽ പൂർണ്ണമായി കംപ്രസ് ചെയ്യാവുന്നതോ അല്ലാത്തതോ ആണ്. ഈ ഓപ്ഷൻ മാത്രം
അദ്വിതീയ ബഫറുകളുടെ വിതരണം നിയന്ത്രിക്കുന്നു.

nrfiles=int
ഈ ജോലിക്കായി ഉപയോഗിക്കേണ്ട ഫയലുകളുടെ എണ്ണം. സ്ഥിരസ്ഥിതി: 1.

ഓപ്പൺ ഫയലുകൾ=int
ഒരേ സമയം തുറന്ന് സൂക്ഷിക്കേണ്ട ഫയലുകളുടെ എണ്ണം. ഡിഫോൾട്ട്: nrfiles.

file_service_type=str
സേവനത്തിലേക്കുള്ള ഫയലുകൾ എങ്ങനെയാണ് തിരഞ്ഞെടുക്കുന്നതെന്ന് നിർവചിക്കുന്നു. ഇനിപ്പറയുന്ന തരങ്ങൾ നിർവചിച്ചിരിക്കുന്നു:

ക്രമരഹിതം ക്രമരഹിതമായി ഒരു ഫയൽ തിരഞ്ഞെടുക്കുക.

റൗണ്ട്റോബിൻ
തുറന്ന ഫയലുകളിൽ റൗണ്ട് റോബിൻ (സ്ഥിരസ്ഥിതി).

തുടർച്ചയായ
സെറ്റിലെ ഓരോ ഫയലും തുടർച്ചയായി ചെയ്യുക.

ഒരു പുതിയ ഫയലിലേക്ക് മാറുന്നതിന് മുമ്പ് നൽകേണ്ട I/O-കളുടെ എണ്ണം വ്യക്തമാക്കാം
കൂട്ടിച്ചേർക്കുന്നു `:int' സേവന തരത്തിലേക്ക്.

അയോഎൻജിൻ=str
ജോലി പ്രശ്നങ്ങൾ I/O എങ്ങനെയെന്ന് നിർവചിക്കുന്നു. ഇനിപ്പറയുന്ന തരങ്ങൾ നിർവചിച്ചിരിക്കുന്നു:

സമന്വയം അടിസ്ഥാനപരമായ വായിക്കുക(2) അല്ലെങ്കിൽ എഴുതുക(2) I/O. fseek(2) I/O സ്ഥാപിക്കാൻ ഉപയോഗിക്കുന്നു
സ്ഥലം.

psync അടിസ്ഥാനപരമായ പ്രബോധനം(2) അല്ലെങ്കിൽ എഴുതുക(2) I/O.

vsync അടിസ്ഥാനപരമായ വായിക്കുക(2) അല്ലെങ്കിൽ എഴുതുന്നു(2) I/O. കോൾസിംഗ് വഴി ക്യൂയിംഗ് അനുകരിക്കും
തൊട്ടടുത്തുള്ള ഐഒകൾ ഒറ്റ സമർപ്പണത്തിലേക്ക്.

pvsync അടിസ്ഥാനപരമായ preadv(2) അല്ലെങ്കിൽ pwritev(2) I/O.

ലിബായോ Linux നേറ്റീവ് അസിൻക്രണസ് I/O. ഈ അയോഎൻജിൻ എഞ്ചിൻ പ്രത്യേകം നിർവചിക്കുന്നു
ഓപ്ഷനുകൾ.

പോസിക്സായോ
POSIX അസിൻക്രണസ് I/O ഉപയോഗിക്കുന്നു aio_read(3) ഉം aio_write(3).

സോളാരിസയോ
സോളാരിസ് നേറ്റീവ് അസിൻക്രണസ് I/O.

വിൻഡോസയോ
വിൻഡോസ് നേറ്റീവ് അസിൻക്രണസ് ഐ/ഒ.

mmap ഫയൽ മെമ്മറി മാപ്പ് ചെയ്തതാണ് mmap(2) ഉപയോഗിച്ച് പകർത്തിയ ഡാറ്റയും എംഎംപിപി(3).

Splice Splice(2) ഡാറ്റ കൈമാറ്റം ചെയ്യാനും ഉപയോഗിക്കുന്നു vmsplice(2) കൈമാറാൻ
യൂസർ-സ്‌പെയ്‌സിൽ നിന്ന് കേർണലിലേക്കുള്ള ഡാറ്റ.

syslet-rw
പതിവ് വായന/എഴുത്ത് അസമന്വിതമാക്കാൻ syslet സിസ്റ്റം കോളുകൾ ഉപയോഗിക്കുക.

sg SCSI ജനറിക് sg v3 I/O. SG_IO ഉപയോഗിച്ച് ഒന്നുകിൽ സിൻക്രണസ് ആയിരിക്കാം
ioctl, അല്ലെങ്കിൽ ലക്ഷ്യം ഒരു sg പ്രതീക ഉപകരണമാണെങ്കിൽ, ഞങ്ങൾ ഉപയോഗിക്കുന്നു വായിക്കുക(2) ഉം
എഴുതുക(2) അസിൻക്രണസ് ഐ/ഒയ്ക്ക്.

ശൂന്യം ഡാറ്റയൊന്നും കൈമാറുന്നില്ല, വെറുതെ നടിക്കുന്നു. പ്രധാനമായും വ്യായാമം ചെയ്യാൻ ഉപയോഗിക്കുന്നു
fio സ്വയം ഡീബഗ്ഗിംഗ്, ടെസ്റ്റിംഗ് ആവശ്യങ്ങൾക്ക്.

വല നെറ്റ്‌വർക്കിലൂടെ കൈമാറുക. ഉപയോഗിക്കേണ്ട പ്രോട്ടോക്കോൾ നിർവചിക്കാം
കൂടെ പ്രോട്ടോകോൾ പരാമീറ്റർ. പ്രോട്ടോക്കോൾ അനുസരിച്ച്, ഫയലിന്റെ പേര്,
ഹോസ്റ്റ്നാമം, തുറമുഖം, അഥവാ കേൾക്കാൻ വ്യക്തമാക്കണം. ഈ അയോഎൻജിൻ നിർവചിക്കുന്നു
എഞ്ചിൻ നിർദ്ദിഷ്ട ഓപ്ഷനുകൾ.

നെറ്റ്സ്പ്ലൈസ്
പോലെ വല, എന്നാൽ ഉപയോഗിക്കുന്നു Splice(2) ഉം vmsplice(2) ഡാറ്റ മാപ്പ് ചെയ്യുന്നതിനും
അയയ്ക്കുക/സ്വീകരിക്കുക. ഈ അയോഎൻജിൻ എഞ്ചിൻ നിർദ്ദിഷ്ട ഓപ്ഷനുകൾ നിർവചിക്കുന്നു.

cpuio ഡാറ്റയൊന്നും കൈമാറില്ല, എന്നാൽ അതിനനുസരിച്ച് CPU സൈക്കിളുകൾ ബേൺ ചെയ്യുന്നു cpuload
ഒപ്പം cpucycles പാരാമീറ്ററുകൾ.

ഗ്വാസി GUASI I/O എഞ്ചിൻ ജനറിക് യൂസർസ്‌പേസ് അസിൻക്രണസ് സൈസ്‌കാൾ ആണ്
അസിൻക്രണസ് I/O-യിലേക്കുള്ള ഇന്റർഫേസ് സമീപനം.
കാണുകhttp://www.xmailserver.org/guasi-lib.html>.

rdma RDMA I/O എഞ്ചിൻ RDMA മെമ്മറി സെമാന്റിക്‌സിനെ പിന്തുണയ്ക്കുന്നു
(RDMA_WRITE/RDMA_READ) കൂടാതെ ചാനൽ സെമാന്റിക്‌സും (അയയ്‌ക്കുക/Recv)
InfiniBand, RoCE, iWARP പ്രോട്ടോക്കോളുകൾ.

പുറമേയുള്ള
ഒരു ബാഹ്യ I/O എഞ്ചിൻ ഒബ്‌ജക്റ്റ് ഫയൽ ലോഡ് ചെയ്യുന്നു. എഞ്ചിൻ ഫയലിന്റെ പേര് ചേർക്കുക
ഇങ്ങനെ `:എഞ്ചിൻപാത്ത്'.

ഫാലോക്ക്
സാധാരണ ലിനക്സ് നേറ്റീവ് ഫാലോക്കേറ്റ് കോൾ ചെയ്യുന്ന IO എഞ്ചിൻ
ഡാറ്റ കൈമാറ്റം ഫിയോ എഞ്ചിൻ ആയി അനുകരിക്കുക
DDIR_READ ഫാലോക്കേറ്റ് ചെയ്യുന്നു(,മോഡ് = FALLOC_FL_KEEP_SIZE,)
DIR_WRITE ഫാലോക്കേറ്റ് ചെയ്യുന്നു(,മോഡ് = 0)
DDIR_TRIM ഫാലോക്കേറ്റ് ചെയ്യുന്നു(,മോഡ് =
FALLOC_FL_KEEP_SIZE|FALLOC_FL_PUNCH_HOLE)

e4defrag
അനുകരിക്കാൻ സാധാരണ EXT4_IOC_MOVE_EXT ioctls ചെയ്യുന്ന IO എഞ്ചിൻ
DDIR_WRITE ഇവന്റിലേക്കുള്ള defragment പ്രവർത്തന അഭ്യർത്ഥന

rbd Ceph Rados ബ്ലോക്ക് ഉപകരണങ്ങളിലേക്ക് (RBD) നേരിട്ടുള്ള പ്രവേശനത്തെ പിന്തുണയ്ക്കുന്ന IO എഞ്ചിൻ
കേർണൽ rbd ഡ്രൈവർ ഉപയോഗിക്കാതെ librbd വഴി. ഈ
ioengine എഞ്ചിൻ നിർദ്ദിഷ്ട ഓപ്ഷനുകൾ നിർവചിക്കുന്നു.

gfapi Glusterfs-ലേക്ക് നേരിട്ട് ആക്‌സസ് ചെയ്യുന്നതിന് Glusterfs libgfapi സമന്വയ ഇന്റർഫേസ് ഉപയോഗിക്കുന്നു
FUSE വഴി പോകാതെ തന്നെ വോള്യങ്ങൾ. ഈ അയോഎൻജിൻ നിർവചിക്കുന്നു
എഞ്ചിൻ നിർദ്ദിഷ്ട ഓപ്ഷനുകൾ.

gfapi_async
നേരിട്ട് ആക്സസ് ചെയ്യുന്നതിന് Glusterfs libgfapi async ഇന്റർഫേസ് ഉപയോഗിക്കുന്നു
FUSE വഴി പോകാതെ തന്നെ Glusterfs വോള്യങ്ങൾ. ഈ അയോഎൻജിൻ
എഞ്ചിൻ നിർദ്ദിഷ്ട ഓപ്ഷനുകൾ നിർവചിക്കുന്നു.

libhdfs
Hadoop (HDFS) വഴി വായിക്കുകയും എഴുതുകയും ചെയ്യുക. ദി ഫയലിന്റെ പേര് ഓപ്ഷൻ ഉപയോഗിക്കുന്നു
കണക്ട് ചെയ്യുന്നതിനായി hdfs നെയിം-നോഡിന്റെ ഹോസ്റ്റ്, പോർട്ട് വ്യക്തമാക്കുക. ഈ എഞ്ചിൻ
ഓഫ്സെറ്റുകളെ അല്പം വ്യത്യസ്തമായി വ്യാഖ്യാനിക്കുന്നു. HDFS-ൽ, ഒരിക്കൽ സൃഷ്ടിച്ച ഫയലുകൾ
പരിഷ്കരിക്കാൻ കഴിയില്ല. അതിനാൽ ക്രമരഹിതമായ എഴുത്തുകൾ സാധ്യമല്ല. അനുകരിക്കാൻ
ഇത്, libhdfs എഞ്ചിൻ ഒരു കൂട്ടം ചെറിയ ഫയലുകൾ സൃഷ്ടിക്കപ്പെടുമെന്ന് പ്രതീക്ഷിക്കുന്നു
HDFS, എഞ്ചിൻ എന്നിവ ആ ഫയലുകളിൽ നിന്ന് ക്രമരഹിതമായി ഒരു ഫയൽ തിരഞ്ഞെടുക്കും
ഫിയോ ബാക്കെൻഡ് സൃഷ്ടിച്ച ഓഫ്സെറ്റിൽ. (ഉദാഹരണ ജോബ് ഫയൽ കാണുക
അത്തരം ഫയലുകൾ സൃഷ്ടിക്കുക, rw=write ഓപ്ഷൻ ഉപയോഗിക്കുക). ദയവായി ശ്രദ്ധിക്കുക, നിങ്ങൾ ആഗ്രഹിച്ചേക്കാം
hdfs/libhdfs-ൽ പ്രവർത്തിക്കാൻ ആവശ്യമായ എൻവയോൺമെന്റ് വേരിയബിളുകൾ സജ്ജമാക്കാൻ
ശരിയായി.

എംടിഡി ഒരു MTD പ്രതീക ഉപകരണം വായിക്കുക, എഴുതുക, മായ്‌ക്കുക (ഉദാ. /dev/mtd0).
നിരസിക്കുന്നവ മായ്ക്കലുകളായി കണക്കാക്കുന്നു. അടിസ്ഥാന ഉപകരണത്തെ ആശ്രയിച്ചിരിക്കുന്നു
ടൈപ്പ് ചെയ്യുക, I/O ഒരു നിശ്ചിത പാറ്റേണിൽ പോകേണ്ടി വന്നേക്കാം, ഉദാ, NAND-ൽ,
ബ്ലോക്കുകൾ മായ്‌ക്കുന്നതിന് തുടർച്ചയായി എഴുതുകയും മുമ്പ് ഉപേക്ഷിക്കുകയും ചെയ്യുന്നു
തിരുത്തിയെഴുതുന്നു. ഈ നിയന്ത്രണത്തിന് റൈറ്റ്ട്രിം മോഡ് നന്നായി പ്രവർത്തിക്കുന്നു.

അയോഡെപ്ത്ത്=int
ഫയലിനെതിരെ ഫ്ലൈറ്റിൽ സൂക്ഷിക്കേണ്ട I/O യൂണിറ്റുകളുടെ എണ്ണം. വർദ്ധിക്കുന്നത് ശ്രദ്ധിക്കുക
1-ന് അപ്പുറം അയോഡെപ്ത് സിൻക്രണസ് അയോ എഞ്ചിനുകളെ ബാധിക്കില്ല (ചെറിയ ഡിഗ്രെസ് ഒഴികെ
verify_async ഉപയോഗിക്കുമ്പോൾ). അസിൻക് എഞ്ചിനുകൾ പോലും OS നിയന്ത്രണങ്ങൾ ഏർപ്പെടുത്തിയേക്കാം
ആഗ്രഹിച്ച ആഴം കൈവരിക്കാൻ കഴിയില്ല. libaio ഉപയോഗിക്കുമ്പോൾ Linux-ൽ ഇത് സംഭവിക്കാം
ക്രമീകരണമല്ല നേരായ=1, ബഫർ ചെയ്‌ത IO ആ OS-ൽ അസിൻക് ചെയ്യാത്തതിനാൽ. ഒരു ശ്രദ്ധ വേണം
ഫിയോ ഔട്ട്‌പുട്ടിലെ IO ഡെപ്‌ത് ഡിസ്‌ട്രിബ്യൂഷൻ, നേടിയ ഡെപ്‌ത് ഇപ്രകാരമാണോ എന്ന് പരിശോധിക്കാൻ
പ്രതീക്ഷിച്ചത്. സ്ഥിരസ്ഥിതി: 1.

iodepth_batch=int
ഒരേസമയം സമർപ്പിക്കേണ്ട I/Oകളുടെ എണ്ണം. ഡിഫോൾട്ട്: അയോഡെപ്ത്ത്.

iodepth_batch_complete=int
ഒരേസമയം എത്ര ഐഒയുടെ കഷണങ്ങൾ വീണ്ടെടുക്കണമെന്ന് ഇത് നിർവചിക്കുന്നു. ഇത് 1 ലേക്ക് ഡിഫോൾട്ട് ചെയ്യുന്നു
എന്നതിൽ നിന്ന് വീണ്ടെടുക്കൽ പ്രക്രിയയിൽ ഞങ്ങൾ കുറഞ്ഞത് 1 IO ആവശ്യപ്പെടും എന്നാണ്
കേർണൽ. ഞങ്ങൾ നിശ്ചയിച്ച പരിധിയിൽ എത്തുന്നതുവരെ IO വീണ്ടെടുക്കൽ തുടരും iodepth_low. എങ്കിൽ
ഈ വേരിയബിൾ 0 ആയി സജ്ജീകരിച്ചിരിക്കുന്നു, തുടർന്ന് ഫിയോ എല്ലായ്‌പ്പോഴും മുമ്പ് പൂർത്തിയാക്കിയ ഇവന്റുകൾക്കായി പരിശോധിക്കും
ക്യൂവിൽ കൂടുതൽ IO. കൂടുതൽ വീണ്ടെടുക്കൽ സംവിധാനത്തിന്റെ ചെലവിൽ ഇത് IO ലേറ്റൻസി കുറയ്ക്കാൻ സഹായിക്കുന്നു
കോളുകൾ.

iodepth_low=int
ക്യൂ വീണ്ടും നിറയ്ക്കുന്നത് എപ്പോൾ തുടങ്ങണമെന്ന് സൂചിപ്പിക്കുന്ന താഴ്ന്ന വാട്ടർമാർക്ക്. ഡിഫോൾട്ട്: അയോഡെപ്ത്ത്.

io_submit_mode=str
ഐഒ എഞ്ചിനിലേക്ക് ഫിയോ എങ്ങനെയാണ് ഐഒ സമർപ്പിക്കുന്നതെന്ന് ഈ ഓപ്ഷൻ നിയന്ത്രിക്കുന്നു. സ്ഥിരസ്ഥിതിയാണ്
ഇൻലൈൻ, അതായത് ഫിയോ ജോബ് ത്രെഡുകൾ നേരിട്ട് IO സമർപ്പിക്കുകയും കൊയ്യുകയും ചെയ്യുന്നു എന്നാണ്. സജ്ജമാക്കിയാൽ
ലേക്ക് ഓഫ്‌ലോഡ്, ജോബ് ത്രെഡുകൾ IO യുടെ സമർപ്പിത പൂളിലേക്ക് IO സമർപ്പിക്കൽ ഓഫ്‌ലോഡ് ചെയ്യും
ത്രെഡുകൾ. ഇതിന് കുറച്ച് ഏകോപനം ആവശ്യമാണ്, അതിനാൽ കുറച്ച് അധിക ഓവർഹെഡ് ഉണ്ട്,
പ്രത്യേകിച്ച് ലോവർ ക്യൂ ഡെപ്ത് IO യ്ക്ക് ഇത് ലേറ്റൻസി വർദ്ധിപ്പിക്കാൻ കഴിയും. പ്രയോജനം ആണ്
ഉപകരണ പൂർത്തീകരണ നിരക്കിൽ നിന്ന് സ്വതന്ത്രമായി സമർപ്പിക്കൽ നിരക്കുകൾ നിയന്ത്രിക്കാൻ fio-ന് കഴിയും.
ഉപകരണത്തിന്റെ വശത്ത് IO ബാക്ക് അപ്പ് ചെയ്‌താൽ ഇത് വക്രതയുള്ള ലേറ്റൻസി റിപ്പോർട്ടിംഗ് ഒഴിവാക്കുന്നു (ദി
ഏകോപിത ഒഴിവാക്കൽ പ്രശ്നം).

നേരായ=bool
ശരിയാണെങ്കിൽ, ബഫർ ചെയ്യാത്ത I/O ഉപയോഗിക്കുക (സാധാരണയായി O_DIRECT). സ്ഥിരസ്ഥിതി: തെറ്റ്.

ആറ്റോമിക=bool
മൂല്യം ശരിയാണെങ്കിൽ, ആറ്റോമിക് ഡയറക്റ്റ് IO ഉപയോഗിക്കാൻ ശ്രമിക്കുക. ആറ്റോമിക് എഴുത്തുകൾ ഉറപ്പുനൽകുന്നു
ഓപ്പറേറ്റിംഗ് സിസ്റ്റം അംഗീകരിച്ചുകഴിഞ്ഞാൽ സ്ഥിരതയുള്ളതായിരിക്കുക. Linux മാത്രമേ O_ATOMIC പിന്തുണയ്ക്കുന്നുള്ളൂ
ഇപ്പോൾ.

ബഫർ ചെയ്തു=bool
ശരിയാണെങ്കിൽ, ബഫർ ചെയ്ത I/O ഉപയോഗിക്കുക. ഇത് വിപരീതമാണ് നേരായ പരാമീറ്റർ. ഡിഫോൾട്ട്:
ശരി.

ഓഫ്സെറ്റ്=int
I/O ആരംഭിക്കാൻ ഫയലിൽ ഓഫ്‌സെറ്റ് ചെയ്യുക. ഓഫ്‌സെറ്റിന് മുമ്പുള്ള ഡാറ്റ സ്പർശിക്കില്ല.

ഓഫ്സെറ്റ്_ഇൻക്രിമെന്റ്=int
ഇത് നൽകിയിട്ടുണ്ടെങ്കിൽ, യഥാർത്ഥ ഓഫ്സെറ്റ് ഓഫ്സെറ്റ് + ഓഫ്സെറ്റ്_ഇൻക്രിമെന്റ് * ആയി മാറുന്നു
thread_number, ഇവിടെ ത്രെഡ് നമ്പർ 0-ൽ ആരംഭിക്കുന്ന ഒരു കൗണ്ടറാണ്
ഓരോ ഉപജോലിക്കും (അതായത് numjobs ഓപ്ഷൻ വ്യക്തമാക്കുമ്പോൾ) വർദ്ധിപ്പിച്ചു. ഈ ഓപ്ഷൻ
ഒരു ഫയലിൽ പ്രവർത്തിക്കാൻ ഉദ്ദേശിച്ചിട്ടുള്ള നിരവധി ജോലികൾ ഉണ്ടെങ്കിൽ അത് ഉപയോഗപ്രദമാണ്
സമാന്തര വിഭജന സെഗ്‌മെന്റുകൾ, ആരംഭ പോയിന്റുകൾക്കിടയിൽ ഇരട്ട അകലമുണ്ട്.

നമ്പർ_ഐഒഎസ്=int
നിശ്ചയിച്ചിട്ടുള്ള പ്രദേശത്തിന്റെ വലിപ്പം തീരുന്നത് വരെ ഫിയോ സാധാരണയായി IOകൾ നിർവഹിക്കും
വലുപ്പം, അല്ലെങ്കിൽ അത് അനുവദിച്ച സമയം തീർന്നാൽ (അല്ലെങ്കിൽ ഒരു പിശക് അവസ്ഥയിൽ). ഇതിനോടൊപ്പം
ക്രമീകരണം, നിർവ്വഹിക്കേണ്ട IO-കളുടെ എണ്ണത്തിൽ നിന്ന് സ്വതന്ത്രമായി ശ്രേണി/വലിപ്പം സജ്ജമാക്കാൻ കഴിയും.
ഫിയോ ഈ നമ്പറിൽ എത്തുമ്പോൾ, അത് സാധാരണ നിലയിൽ പുറത്തുകടന്ന് സ്റ്റാറ്റസ് റിപ്പോർട്ട് ചെയ്യും. അതല്ല
ഇത് ചെയ്യപ്പെടുന്ന IO യുടെ അളവ് നീട്ടുന്നില്ല, എങ്കിൽ മാത്രമേ ഇത് ഫിയോ നിർത്തുകയുള്ളൂ
മറ്റ് തൊഴിൽ അവസാന മാനദണ്ഡങ്ങൾക്ക് മുമ്പാണ് ഈ വ്യവസ്ഥ പാലിക്കുന്നത്.

fsync=int
ഒരു ഇഷ്യൂ ചെയ്യുന്നതിന് മുമ്പ് എത്ര ഐ/ഒകൾ നിർവഹിക്കണം fsync(2) വൃത്തികെട്ട ഡാറ്റയുടെ. 0 ആണെങ്കിൽ, ചെയ്യരുത്
സമന്വയിപ്പിക്കുക. സ്ഥിരസ്ഥിതി: 0.

fdatasync=int
പോലെ fsync, എന്നാൽ ഉപയോഗിക്കുന്നു fdatasync(2) ഫയലിന്റെ ഡാറ്റ ഭാഗങ്ങൾ മാത്രം സമന്വയിപ്പിക്കുന്നതിന് പകരം.
സ്ഥിരസ്ഥിതി: 0.

എഴുത്ത്_തടസ്സം=int
ഓരോ Nth എഴുതാനും ഒരു തടസ്സം എഴുതുക.

sync_file_range=str:int
ഉപയോഗം sync_file_range(2) എഴുത്ത് പ്രവർത്തനങ്ങളുടെ ഓരോ വാൽ നമ്പറിനും. ഫിയോ ട്രാക്ക് ചെയ്യും
അവസാനം മുതൽ നടന്ന എഴുത്തുകളുടെ ശ്രേണി sync_file_range(2) വിളിക്കുക. str കഴിയും
നിലവിൽ ഇവയിൽ ഒന്നോ അതിലധികമോ ആയിരിക്കും:

കാത്തിരിക്കുക
SYNC_FILE_RANGE_WAIT_BEFORE

എഴുതുക SYNC_FILE_RANGE_WRITE

കാത്തിരിക്കുക
SYNC_FILE_RANGE_WRITE

നിങ്ങൾ sync_file_range=wait_before,write:8 ചെയ്യുകയാണെങ്കിൽ, fio ഉപയോഗിക്കും
SYNC_FILE_RANGE_WAIT_BEFORE | SYNC_FILE_RANGE_WRITE ഓരോ 8 എഴുത്തുകൾക്കും. ഇതും കാണുക
The sync_file_range(2) മാൻ പേജ്. ഈ ഓപ്ഷൻ Linux സ്പെസിഫിക് ആണ്.

തിരുത്തിയെഴുതുക=bool
എഴുതുകയാണെങ്കിൽ, ആദ്യം ഫയൽ സജ്ജീകരിച്ച് ഓവർറൈറ്റുകൾ ചെയ്യുക. സ്ഥിരസ്ഥിതി: തെറ്റ്.

end_fsync=bool
ഒരു റൈറ്റ് ഘട്ടം പൂർത്തിയാകുമ്പോൾ ഫയൽ ഉള്ളടക്കങ്ങൾ സമന്വയിപ്പിക്കുക. സ്ഥിരസ്ഥിതി: തെറ്റ്.

fsync_on_close=bool
ശരിയാണെങ്കിൽ, ഫയൽ ഉള്ളടക്കങ്ങൾ സമന്വയിപ്പിക്കുക. ഇതിൽ നിന്ന് വ്യത്യസ്തമാണ് end_fsync അതിൽ അത് ചെയ്യും
ജോലിയുടെ അവസാനത്തിൽ മാത്രമല്ല, എല്ലാ ക്ലോസിലും സംഭവിക്കുന്നു. സ്ഥിരസ്ഥിതി: തെറ്റ്.

rwmixread=int
വായിക്കേണ്ട ഒരു സമ്മിശ്ര ജോലിഭാരത്തിന്റെ ശതമാനം. സ്ഥിരസ്ഥിതി: 50.

rwmixwrite=int
എഴുതേണ്ട ഒരു സമ്മിശ്ര ജോലിഭാരത്തിന്റെ ശതമാനം. എങ്കിൽ rwmixread ഒപ്പം rwmixwrite
നൽകിയിരിക്കുന്നു, 100% ആയി കണക്കാക്കരുത്, രണ്ടിൽ രണ്ടാമത്തേത് ആദ്യത്തേതിനെ മറികടക്കുന്നു. ഈ
വായിക്കുന്നതിനോ എഴുതുന്നതിനോ പരിമിതപ്പെടുത്താൻ ഫിയോയോട് ആവശ്യപ്പെട്ടാൽ നൽകിയിരിക്കുന്ന നിരക്ക് ക്രമീകരണത്തിൽ ഇടപെടാം
ഒരു നിശ്ചിത നിരക്കിലേക്ക്. അങ്ങനെയാണെങ്കിൽ, വിതരണം വളച്ചൊടിച്ചേക്കാം.
സ്ഥിരസ്ഥിതി: 50.

ക്രമരഹിതമായ_വിതരണം=str:ഫ്ലോട്ട്
ഡിഫോൾട്ടായി, ആവശ്യപ്പെടുമ്പോൾ ഫിയോ പൂർണ്ണമായും ഏകീകൃത റാൻഡം ഡിസ്ട്രിബ്യൂഷൻ ഉപയോഗിക്കും
ക്രമരഹിതമായ IO നടത്തുക. വിതരണത്തെ പ്രത്യേകമായി വളച്ചൊടിക്കുന്നത് ചിലപ്പോൾ ഉപയോഗപ്രദമാണ്
ഡാറ്റയുടെ ചില ഭാഗങ്ങൾ മറ്റുള്ളവയേക്കാൾ കൂടുതൽ ചൂടുള്ളതാണെന്ന് ഉറപ്പാക്കുന്ന വഴികൾ. ഫിയോ ഉൾപ്പെടുന്നു
ഇനിപ്പറയുന്ന വിതരണ മോഡലുകൾ:

ക്രമരഹിതം ഏകീകൃത ക്രമരഹിതമായ വിതരണം

zipf Zipf വിതരണം

പാരേറ്റോ പാരെറ്റോ വിതരണം

ഒരു zipf അല്ലെങ്കിൽ pareto ഡിസ്ട്രിബ്യൂഷൻ ഉപയോഗിക്കുമ്പോൾ, ഒരു ഇൻപുട്ട് മൂല്യവും ആവശ്യമാണ്
ആക്സസ് പാറ്റേൺ നിർവ്വചിക്കുക. zipf-ന്, ഇതാണ് zipf തീറ്റ. പാരെറ്റോയെ സംബന്ധിച്ചിടത്തോളം, ഇതാണ്
പാരെറ്റോ പവർ. ഫിയോയിൽ ഒരു ടെസ്റ്റ് പ്രോഗ്രാം ഉൾപ്പെടുന്നു, genzipf, അത് എന്താണെന്ന് ദൃശ്യവൽക്കരിക്കാൻ ഉപയോഗിക്കാം
നൽകിയിരിക്കുന്ന ഇൻപുട്ട് മൂല്യങ്ങൾ ഹിറ്റ് നിരക്കുകളുടെ അടിസ്ഥാനത്തിൽ നൽകും. നിങ്ങൾക്ക് zipf ഉപയോഗിക്കണമെങ്കിൽ
1.2 തീറ്റയിൽ, നിങ്ങൾ random_distribution=zipf:1.2 ഓപ്ഷനായി ഉപയോഗിക്കും. അത് അങ്ങിനെയെങ്കിൽ
നോൺ-യൂണിഫോം മോഡൽ ഉപയോഗിക്കുന്നു, ഫിയോ റാൻഡം മാപ്പിന്റെ ഉപയോഗം പ്രവർത്തനരഹിതമാക്കും.

ശതമാനം_റാൻഡം=int
ക്രമരഹിതമായ ജോലിഭാരത്തിന്, എത്ര വലിയ ശതമാനം ക്രമരഹിതമായിരിക്കണമെന്ന് സജ്ജീകരിക്കുക. ഇത് സ്ഥിരസ്ഥിതിയാക്കുന്നു
100%, ഈ സാഹചര്യത്തിൽ ജോലിഭാരം പൂർണ്ണമായും ക്രമരഹിതമാണ്. ഇത് എവിടെ നിന്നും സെറ്റ് ചെയ്യാം
0 മുതൽ 100 ​​വരെ. ഇത് 0 ആയി സജ്ജീകരിക്കുന്നത് ജോലിഭാരം പൂർണ്ണമായി ക്രമപ്പെടുത്തും. അതു സാധ്യമാണ്
വായിക്കുന്നതിനും എഴുതുന്നതിനും ട്രിം ചെയ്യുന്നതിനും വ്യത്യസ്ത മൂല്യങ്ങൾ സജ്ജമാക്കാൻ. അങ്ങനെ ചെയ്യുന്നതിന്, ഒരു കോമ ഉപയോഗിക്കുക
വേർതിരിച്ച പട്ടിക. കാണുക ബ്ലോക്കുകളുടെ വലിപ്പം.

norandommap
സാധാരണയായി fio ക്രമരഹിതമായ I/O ചെയ്യുമ്പോൾ ഫയലിന്റെ എല്ലാ ബ്ലോക്കുകളും കവർ ചെയ്യും. ഇത് എങ്കിൽ
പാരാമീറ്റർ നൽകിയിരിക്കുന്നു, കഴിഞ്ഞ I/O നോക്കാതെ ഒരു പുതിയ ഓഫ്‌സെറ്റ് തിരഞ്ഞെടുക്കും
ചരിത്രം. ഈ പരാമീറ്റർ പരസ്പര വിരുദ്ധമാണ് പരിശോധിക്കുക.

softrandommap=bool
കാണുക norandommap. റാൻഡം ബ്ലോക്ക് മാപ്പ് പ്രവർത്തനക്ഷമമാക്കി ഫിയോ പ്രവർത്തിക്കുകയും അത് പരാജയപ്പെടുകയും ചെയ്താൽ
മാപ്പ് അനുവദിക്കുക, ഈ ഓപ്‌ഷൻ സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിൽ, അത് ക്രമരഹിതമായ ബ്ലോക്ക് ഇല്ലാതെ തുടരും
ഭൂപടം. റാൻഡം മാപ്പുകൾ പോലെ കവറേജ് പൂർണ്ണമാകാത്തതിനാൽ, ഈ ഓപ്ഷൻ ഇതാണ്
സ്ഥിരസ്ഥിതിയായി പ്രവർത്തനരഹിതമാക്കി.

ക്രമരഹിത_ജനറേറ്റർ=str
ക്രമരഹിതമായ IO-യ്‌ക്കായി IO ഓഫ്‌സെറ്റുകൾ സൃഷ്ടിക്കുന്നതിന് ഇനിപ്പറയുന്ന എഞ്ചിനുകളെ ഫിയോ പിന്തുണയ്ക്കുന്നു:

തൌസ്വർത്ത്
ശക്തമായ 2^88 സൈക്കിൾ റാൻഡം നമ്പർ ജനറേറ്റർ

lfsr ലീനിയർ ഫീഡ്ബാക്ക് ഷിഫ്റ്റ് രജിസ്റ്റർ ജനറേറ്റർ

tausworthe64
ശക്തമായ 64-ബിറ്റ് 2^258 സൈക്കിൾ റാൻഡം നമ്പർ ജനറേറ്റർ

Tausworthe ഒരു ശക്തമായ റാൻഡം നമ്പർ ജനറേറ്ററാണ്, എന്നാൽ ഇതിന് ട്രാക്കിംഗ് ആവശ്യമാണ്
The
ബ്ലോക്കുകൾ ഒരിക്കൽ മാത്രം വായിക്കുകയോ എഴുതുകയോ ചെയ്യുന്നുവെന്ന് ഉറപ്പാക്കണമെങ്കിൽ. എൽഎഫ്എസ്ആർ
ഒരേ ഓഫ്‌സെറ്റ് ഞങ്ങൾ രണ്ടുതവണ സൃഷ്ടിക്കുന്നില്ലെന്ന് ഉറപ്പ് നൽകുന്നു, മാത്രമല്ല ഇത് കുറവാണ്
കണക്കുകൂട്ടൽ ചെലവേറിയത്. എന്നിരുന്നാലും, IO യ്ക്ക് വേണ്ടിയാണെങ്കിലും ഇത് ഒരു യഥാർത്ഥ റാൻഡം ജനറേറ്റർ അല്ല
ഉദ്ദേശ്യങ്ങൾ അത് സാധാരണ മതിയാകും. എൽഎഫ്എസ്ആർ ഒറ്റ ബ്ലോക്ക് വലുപ്പത്തിൽ മാത്രമേ പ്രവർത്തിക്കൂ, അല്ല
ഒന്നിലധികം ബ്ലോക്ക് വലുപ്പങ്ങൾ ഉപയോഗിക്കുന്ന ജോലിഭാരത്തോടൊപ്പം. അത്തരം ഒരു ജോലിഭാരത്തോടെ ഉപയോഗിക്കുകയാണെങ്കിൽ, ഫിയോ മെയ്
ചില ബ്ലോക്കുകൾ ഒന്നിലധികം തവണ വായിക്കുകയോ എഴുതുകയോ ചെയ്യുക.

നൈസ്=int
നല്ല മൂല്യം നൽകി ജോലി പ്രവർത്തിപ്പിക്കുക. കാണുക നൈസ്(2).

പ്രിയോ=int
ഈ ജോലിയുടെ I/O മുൻഗണനാ മൂല്യം 0 (ഏറ്റവും ഉയർന്നത്) 7 (ഏറ്റവും താഴ്ന്നത്) എന്നിവയ്ക്കിടയിൽ സജ്ജമാക്കുക. കാണുക
അയണിസ്(1).

പ്രിയക്ലാസ്=int
I/O മുൻഗണനാ ക്ലാസ് സജ്ജമാക്കുക. കാണുക അയണിസ്(1).

ചിന്താസമയം=int
I/O-കൾ നൽകുന്നതിന് ഇടയിൽ നൽകിയിരിക്കുന്ന മൈക്രോസെക്കൻഡുകളുടെ സ്റ്റാൾ ജോലി.

ചിന്ത സമയം_സ്പിൻ=int
തന്നിരിക്കുന്ന മൈക്രോസെക്കൻഡുകളുടെ സിപിയു സമയം ചെലവഴിക്കുന്നതായി നടിക്കുക, ബാക്കിയുള്ളത് ഉറങ്ങുക
വ്യക്തമാക്കിയ സമയം ചിന്താസമയം. എങ്കിൽ മാത്രമേ സാധുതയുള്ളൂ ചിന്താസമയം സജ്ജീകരിച്ചിരിക്കുന്നു.

തിങ്ക്ടൈം_ബ്ലോക്കുകൾ=int
തിങ്ക്ടൈം സജ്ജീകരിച്ചാൽ മാത്രമേ സാധുതയുള്ളൂ - കാത്തിരിക്കുന്നതിന് മുമ്പ് എത്ര ബ്ലോക്കുകൾ നൽകണമെന്ന് നിയന്ത്രിക്കുക
ചിന്താസമയം മൈക്രോസെക്കൻഡ്. സജ്ജീകരിച്ചിട്ടില്ലെങ്കിൽ, സ്ഥിരസ്ഥിതി 1 ലേക്ക്, അത് ഫിയോയെ കാത്തിരിക്കാൻ ഇടയാക്കും
ചിന്താസമയം ഓരോ ബ്ലോക്കിനും ശേഷം മൈക്രോസെക്കൻഡ്. ഇത് ഫലപ്രദമായി ഏതെങ്കിലും ക്യൂ ഡെപ്ത് ഉണ്ടാക്കുന്നു
അനാവശ്യമായി സജ്ജീകരിക്കുന്നു, കാരണം 1 IO-യിൽ കൂടുതൽ ക്യൂവിൽ നിൽക്കില്ല
അത് പൂർത്തിയാക്കി ഞങ്ങളുടെ ചിന്താസമയം പ്രവർത്തിക്കുക. മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, ഈ ക്രമീകരണം ഫലപ്രദമായി ക്യാപ് ചെയ്യുന്നു
രണ്ടാമത്തേത് വലുതാണെങ്കിൽ ക്യൂ ഡെപ്ത്. സ്ഥിരസ്ഥിതി: 1.

നിരക്ക്=int
ഈ ജോലി ഉപയോഗിക്കുന്ന ക്യാപ് ബാൻഡ്‌വിഡ്ത്ത്. നമ്പർ ബൈറ്റുകൾ/സെക്കൻഡിലാണ്, സാധാരണ പോസ്റ്റ്ഫിക്സ്
നിയമങ്ങൾ ബാധകമാണ്. നിങ്ങൾക്ക് ഉപയോഗിക്കാം നിരക്ക്=500k വായനയും എഴുത്തും 500k ആയി പരിമിതപ്പെടുത്താൻ, അല്ലെങ്കിൽ നിങ്ങൾ
വായനയും എഴുത്തും വെവ്വേറെ വ്യക്തമാക്കാം. ഉപയോഗിക്കുന്നത് നിരക്ക്=1m,500k വായനകൾ പരിമിതപ്പെടുത്തും
1MB/സെക്കൻഡ്, 500KB/സെക്കൻഡ് വരെ എഴുതുന്നു. വായിക്കുന്നതിനോ എഴുതുന്നതിനോ മാത്രമേ ക്യാപ്പിംഗ് ചെയ്യാൻ കഴിയൂ
നിരക്ക്=,500k അല്ലെങ്കിൽ നിരക്ക്=500k,. ആദ്യത്തേത് റൈറ്റുകളെ മാത്രം പരിമിതപ്പെടുത്തും (500KB/sec), the
പിന്നീടുള്ള വായനകൾ പരിമിതപ്പെടുത്തും.

റേറ്റ്മിൻ=int
പറയുക fio തന്നിരിക്കുന്ന ബാൻഡ്‌വിഡ്ത്ത് എങ്കിലും നിലനിർത്താൻ കഴിയുന്നതെല്ലാം ചെയ്യുക. പരാജയപ്പെടുകയാണ്
ഈ ആവശ്യകത നിറവേറ്റുന്നത് ജോലിയിൽ നിന്ന് പുറത്തുപോകാൻ ഇടയാക്കും. അതേ ഫോർമാറ്റ് നിരക്ക് is
വായിക്കുന്നതിനും എഴുതുന്നതിനും വേർതിരിക്കാൻ ഉപയോഗിക്കുന്നു.

നിരക്ക്_ഐഒപ്സ്=int
ഈ ഐ‌ഒ‌പി‌എസിന്റെ ബാൻഡ്‌വിഡ്ത്ത് പരിമിതപ്പെടുത്തുക. അടിസ്ഥാനപരമായി നിരക്കിന് തുല്യമാണ്, വെറും
ബാൻഡ്‌വിഡ്‌ത്തിൽ നിന്ന് സ്വതന്ത്രമായി വ്യക്തമാക്കിയിരിക്കുന്നു. അതേ ഫോർമാറ്റ് നിരക്ക് vs വായിക്കാൻ ഉപയോഗിക്കുന്നു
വേർപിരിയൽ എഴുതുക. എങ്കിൽ ബ്ലോക്കുകളുടെ വലിപ്പം ഒരു ശ്രേണിയാണ്, ഏറ്റവും ചെറിയ ബ്ലോക്ക് വലുപ്പം ഉപയോഗിക്കുന്നു
മെട്രിക്.

നിരക്ക്_iops_min=int
ഈ I/O നിരക്ക് പാലിച്ചില്ലെങ്കിൽ, ജോലി പുറത്തുപോകും. അതേ ഫോർമാറ്റ് നിരക്ക് ഉപയോഗിക്കുന്നു
വായിക്കുന്നതിനും എഴുതുന്നതിനും വേർതിരിക്കാൻ.

നിരക്ക്ചക്രം=int
ഇതിനായി ശരാശരി ബാൻഡ്‌വിഡ്ത്ത് നിരക്ക് ഒപ്പം റേറ്റ്മിൻ ഈ മില്ലിസെക്കൻഡിൽ കൂടുതൽ. ഡിഫോൾട്ട്:
1000മി.സി.

latency_target=int
സജ്ജമാക്കിയാൽ, തന്നിരിക്കുന്ന ജോലിഭാരത്തിന്റെ പരമാവധി പ്രകടന പോയിന്റ് കണ്ടെത്താൻ ഫിയോ ശ്രമിക്കും
ഈ ലക്ഷ്യത്തിന് താഴെയുള്ള ഒരു ലേറ്റൻസി നിലനിർത്തുമ്പോൾ പ്രവർത്തിക്കും. മൂല്യങ്ങൾ നൽകിയിരിക്കുന്നു
മൈക്രോസെക്കൻഡ്. കാണുക ലേറ്റൻസി_വിൻഡോ ഒപ്പം ലേറ്റൻസി_ശതമാനം.

ലേറ്റൻസി_വിൻഡോ=int
ഉപയോഗിച്ചു latency_target ജോലി പ്രവർത്തിക്കുന്ന സാമ്പിൾ വിൻഡോ വ്യക്തമാക്കാൻ
പ്രകടനം പരിശോധിക്കാൻ വ്യത്യസ്ത ക്യൂ ഡെപ്‌റ്റുകൾ. മൈക്രോസെക്കൻഡിലാണ് മൂല്യം നൽകിയിരിക്കുന്നത്.

ലേറ്റൻസി_ശതമാനം=ഫ്ലോട്ട്
വ്യക്തമാക്കിയിട്ടുള്ള മാനദണ്ഡങ്ങളിൽ ഉൾപ്പെടേണ്ട IO-കളുടെ ശതമാനം
latency_target ഒപ്പം ലേറ്റൻസി_വിൻഡോ. സജ്ജീകരിച്ചിട്ടില്ലെങ്കിൽ, ഇത് 100.0 ലേക്ക് ഡിഫോൾട്ട് ചെയ്യുന്നു, അതായത്
എല്ലാ IO-കളും സജ്ജീകരിച്ച മൂല്യത്തിന് തുല്യമോ താഴെയോ ആയിരിക്കണം latency_target.

പരമാവധി_ലേറ്റൻസി=int
സജ്ജീകരിച്ചാൽ, ഈ പരമാവധി ലേറ്റൻസി കവിഞ്ഞാൽ ഫിയോ ജോലിയിൽ നിന്ന് പുറത്തുപോകും. കൂടെ പുറത്തുകടക്കും
ഒരു ETIME പിശക്.

cpumask=int
ഈ ജോലിക്കായി CPU അഫിനിറ്റി സജ്ജമാക്കുക. int ജോലി പ്രവർത്തിപ്പിക്കാനിടയുള്ള അനുവദനീയമായ CPU-കളുടെ ബിറ്റ്മാസ്ക് ആണ്.
കാണുക ഷെഡ്_സെറ്റഫിനിറ്റി(2).

cpus_Allowed=str
അതുപോലെ തന്നെ cpumask, എന്നാൽ CPU നമ്പറുകളുടെ കോമ-ഡിലിമിറ്റഡ് ലിസ്റ്റ് അനുവദിക്കുന്നു.

cpus_allowed_policy=str
വ്യക്തമാക്കിയ CPU-കൾ ഫിയോ എങ്ങനെ വിതരണം ചെയ്യുന്നു എന്നതിന്റെ നയം സജ്ജമാക്കുക cpus_Allowed or
cpumask. രണ്ട് നയങ്ങൾ പിന്തുണയ്ക്കുന്നു:

പങ്കിട്ടു എല്ലാ ജോലികളും വ്യക്തമാക്കിയ CPU സെറ്റ് പങ്കിടും.

രണ്ടായി പിരിയുക ഓരോ ജോലിക്കും സിപിയു സെറ്റിൽ നിന്ന് ഒരു അദ്വിതീയ സിപിയു ലഭിക്കും.

പങ്കിട്ടു ഓപ്ഷൻ വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ, ഡിഫോൾട്ട് പെരുമാറ്റമാണ്. എങ്കിൽ രണ്ടായി പിരിയുക is
വ്യക്തമാക്കിയാൽ, ഫിയോ ഓരോ ജോലിക്കും ഒരു സിപിയു നൽകും. മതിയായ CPU-കൾ നൽകിയിട്ടില്ലെങ്കിൽ
ലിസ്‌റ്റ് ചെയ്‌ത ജോലികൾ, തുടർന്ന് സെറ്റിലെ സിപിയുകളെ ഫിയോ റൗണ്ട്‌റോബിൻ ചെയ്യും.

numa_cpu_nodes=str
നിർദ്ദിഷ്ട NUMA നോഡുകളുടെ CPU-കളിൽ പ്രവർത്തിക്കുന്ന ഈ ജോലി സജ്ജമാക്കുക. വാദങ്ങൾ കോമ അനുവദിക്കുന്നു
സിപിയു നമ്പറുകൾ, എബി ശ്രേണികൾ അല്ലെങ്കിൽ 'എല്ലാം' എന്നിവയുടെ ഡിലിമിറ്റഡ് ലിസ്റ്റ്.

numa_mem_policy=str
ഈ ജോലിയുടെ മെമ്മറി നയവും അനുബന്ധ NUMA നോഡുകളും സജ്ജമാക്കുക. വാദങ്ങളുടെ ഫോർമാറ്റ്:

[: ]

മോഡ് ഇനിപ്പറയുന്ന മെമ്മറി നയങ്ങളിൽ ഒന്നാണ്:

സ്ഥിരസ്ഥിതി, തിരഞ്ഞെടുക്കുക, ബന്ധിക്കുക, ഇടവേള, പ്രാദേശിക

വേണ്ടി സ്ഥിരസ്ഥിതി ഒപ്പം പ്രാദേശിക മെമ്മറി പോളിസി, ഇല്ല നോഡലിസ്റ്റ് is
വ്യക്തമാക്കേണ്ടതുണ്ട്. വേണ്ടി ഇഷ്ടപ്പെടുന്നു, ഒരു നോഡ് മാത്രമേ അനുവദിക്കൂ. വേണ്ടി ബന്ധിക്കുക ഒപ്പം
ഇടവേള, നോഡലിസ്റ്റ് സംഖ്യകളുടെ, AB ശ്രേണികൾ, അല്ലെങ്കിൽ 'എല്ലാം' എന്നിവയുടെ കോമ ഡിലിമിറ്റഡ് ലിസ്റ്റ് അനുവദിക്കുന്നു.

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

റൺടൈം=int
നിർദ്ദിഷ്ട സെക്കൻഡുകൾക്ക് ശേഷം പ്രോസസ്സിംഗ് അവസാനിപ്പിക്കുക.

സമയ_അടിസ്ഥാനം
നൽകിയിട്ടുണ്ടെങ്കിൽ, വ്യക്തമാക്കിയവയ്ക്കായി പ്രവർത്തിപ്പിക്കുക റൺടൈം ഫയലുകൾ പൂർണ്ണമായും ആണെങ്കിൽ പോലും ദൈർഘ്യം
വായിക്കുകയോ എഴുതുകയോ ചെയ്യുക. ഒരേ ജോലിഭാരം എത്ര പ്രാവശ്യം ആവർത്തിക്കും റൺടൈം
അനുവദിക്കുന്നു.

റാംപ്_ടൈം=int
സജ്ജീകരിച്ചാൽ, ലോഗിംഗ് ചെയ്യുന്നതിന് മുമ്പായി ഇത്രയും സമയത്തേക്ക് ഫിയോ നിർദ്ദിഷ്ട വർക്ക്ലോഡ് പ്രവർത്തിപ്പിക്കും
ഏതെങ്കിലും പ്രകടന സംഖ്യകൾ. ലോഗിംഗ് ചെയ്യുന്നതിന് മുമ്പ് പ്രകടനം സ്ഥിരീകരിക്കാൻ അനുവദിക്കുന്നതിന് ഉപയോഗപ്രദമാണ്
ഫലങ്ങൾ, അങ്ങനെ സ്ഥിരമായ ഫലങ്ങൾക്ക് ആവശ്യമായ റൺടൈം കുറയ്ക്കുന്നു. എന്നത് ശ്രദ്ധിക്കുക
റാംപ്_ടൈം ഒരു ജോലിയുടെ സമയത്ത് ലീഡ് ആയി കണക്കാക്കപ്പെടുന്നു, അങ്ങനെ അത് മൊത്തം വർദ്ധിപ്പിക്കും
ഒരു പ്രത്യേക ടൈംഔട്ട് അല്ലെങ്കിൽ റൺടൈം വ്യക്തമാക്കിയിട്ടുണ്ടെങ്കിൽ റൺടൈം.

അസാധുവാക്കുക=bool
I/O ആരംഭിക്കുന്നതിന് മുമ്പ് ഫയലിനായുള്ള ബഫർ-കാഷെ അസാധുവാക്കുക. സ്ഥിരസ്ഥിതി: ശരി.

സമന്വയം=bool
ബഫർ ചെയ്ത എഴുത്തുകൾക്കായി സിൻക്രണസ് I/O ഉപയോഗിക്കുക. ഭൂരിഭാഗം I/O എഞ്ചിനുകൾക്കും ഇത്
O_SYNC ഉപയോഗിക്കുന്നു എന്നാണ് അർത്ഥമാക്കുന്നത്. സ്ഥിരസ്ഥിതി: തെറ്റ്.

ഐയോം=str, നിഗര്=str
I/O യൂണിറ്റ് ബഫറിനായുള്ള അലോക്കേഷൻ രീതി. അനുവദനീയമായ മൂല്യങ്ങൾ ഇവയാണ്:

malloc ഉപയോഗിച്ച് മെമ്മറി അനുവദിക്കുക malloc(3).

shm പങ്കിട്ട മെമ്മറി ബഫറുകൾ ഉപയോഗിക്കുക shmget(2).

shmhuge
അതുപോലെ തന്നെ shm, എന്നാൽ വലിയ പേജുകൾ പിന്തുണയായി ഉപയോഗിക്കുക.

mmap ഉപയോഗം mmap(2) വിഹിതത്തിനായി. ഒരു ഫയൽ നാമം ഒഴികെ അജ്ഞാത മെമ്മറി ഉപയോഗിക്കുന്നു
ഫോർമാറ്റിലെ ഓപ്‌ഷനുശേഷം നൽകിയിരിക്കുന്നു `:ഫയല്'.

mmaphuge
അതുപോലെ തന്നെ mmap, എന്നാൽ ബാക്കിംഗായി വലിയ ഫയലുകൾ ഉപയോഗിക്കുക.

അനുവദിച്ച മെമ്മറിയുടെ അളവ് അനുവദനീയമായ പരമാവധി ആണ് ബ്ലോക്കുകളുടെ വലിപ്പം ജോലിക്ക് വേണ്ടി
കൊണ്ട് ഗുണിച്ചു അയോഡെപ്ത്ത്. വേണ്ടി shmhuge or mmaphuge പ്രവർത്തിക്കാൻ, സിസ്റ്റത്തിന് സൗജന്യമായിരിക്കണം
വലിയ പേജുകൾ അനുവദിച്ചു. mmaphuge ബിഗ്‌ടിഎൽബിഎഫ്‌സ് മൗണ്ട് ചെയ്യേണ്ടതുണ്ട്, കൂടാതെ ഫയല് ആവശമാകുന്നു
അവിടെ ചൂണ്ടിക്കാണിക്കുക. കുറഞ്ഞത് ലിനക്സിൽ, വലിയ പേജുകൾ സ്വമേധയാ അനുവദിക്കണം. കാണുക
/proc/sys/vm/nr_hugehages അതിനുള്ള ഡോക്യുമെന്റേഷനും. സാധാരണയായി നിങ്ങൾ ചെയ്യേണ്ടത്
ഉചിതമായ ഒരു നമ്പർ പ്രതിധ്വനിപ്പിക്കുക, ഉദാ: 8 പ്രതിധ്വനിക്കുന്നത് OS-ന് 8 വലിയ പേജുകൾ ഉണ്ടെന്ന് ഉറപ്പാക്കും
ഉപയോഗത്തിന് തയ്യാറാണ്.

iomem_align=int, mem_align=int
ഇത് IO മെമ്മറി ബഫറുകളുടെ മെമ്മറി വിന്യാസത്തെ സൂചിപ്പിക്കുന്നു. നൽകിയത് ശ്രദ്ധിക്കുക
ഉപയോഗിക്കുകയാണെങ്കിൽ, ആദ്യ IO യൂണിറ്റ് ബഫറിലേക്ക് വിന്യാസം പ്രയോഗിക്കുന്നു അയോഡെപ്ത്ത് യുടെ വിന്യാസം
ഇനിപ്പറയുന്ന ബഫറുകൾ നൽകിയിരിക്കുന്നു bs ഉപയോഗിച്ചു. മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, a ഉപയോഗിക്കുകയാണെങ്കിൽ bs ആ
സിസ്റ്റത്തിൽ വലിപ്പമുള്ള പേജിന്റെ ഗുണിതമാണ്, എല്ലാ ബഫറുകളും ഇതിലേക്ക് വിന്യസിക്കും
മൂല്യം. എ ഉപയോഗിക്കുകയാണെങ്കിൽ bs അത് പേജ് വിന്യസിച്ചിട്ടില്ല, തുടർന്നുള്ള IO യുടെ വിന്യാസം
മെമ്മറി ബഫറുകൾ എന്നത് ഇതിന്റെ ആകെത്തുകയാണ് iomem_align ഒപ്പം bs ഉപയോഗിച്ചു.

വലിയ പേജ് വലിപ്പം=int
ഒരു വലിയ പേജിന്റെ വലുപ്പം നിർവചിക്കുന്നു. സിസ്റ്റം ക്രമീകരണത്തിന് കുറഞ്ഞത് തുല്യമായിരിക്കണം.
1MB യുടെ ഗുണിതമായിരിക്കണം. സ്ഥിരസ്ഥിതി: 4MB.

പുറത്തുകടക്കുക
ഒന്ന് പൂർത്തിയാകുമ്പോൾ എല്ലാ ജോലികളും അവസാനിപ്പിക്കുക. ഡിഫോൾട്ട്: ഓരോ ജോലിയും പൂർത്തിയാകുന്നതുവരെ കാത്തിരിക്കുക.

bwavgtime=int
നൽകിയിരിക്കുന്ന സമയത്തെ ശരാശരി ബാൻഡ്‌വിഡ്ത്ത് കണക്കുകൂട്ടലുകൾ മില്ലിസെക്കൻഡിൽ. ഡിഫോൾട്ട്:
500മി.സി.

iopsavgtime=int
നൽകിയിരിക്കുന്ന സമയത്തെ ശരാശരി IOPS കണക്കുകൂട്ടലുകൾ മില്ലിസെക്കൻഡിൽ. സ്ഥിരസ്ഥിതി: 500മി.എസ്.

സൃഷ്ടിക്കുക_സീരിയലൈസ് ചെയ്യുക=bool
ശരിയാണെങ്കിൽ, ജോലികൾക്കായി ഫയൽ സൃഷ്‌ടിക്കൽ സീരിയലൈസ് ചെയ്യുക. സ്ഥിരസ്ഥിതി: ശരി.

create_fsync=bool
fsync(2) സൃഷ്ടിച്ചതിന് ശേഷമുള്ള ഡാറ്റ ഫയൽ. സ്ഥിരസ്ഥിതി: ശരി.

സൃഷ്‌ടിക്കുക_ഓൺ_ഓപ്പൺ=bool
ശരിയാണെങ്കിൽ, ജോലി പ്രകാരം IO-യ്‌ക്കായി തുറക്കുന്നതുവരെ ഫയലുകൾ സൃഷ്‌ടിക്കപ്പെടില്ല.

സൃഷ്ടിക്കുക_മാത്രം=bool
ശരിയാണെങ്കിൽ, ജോലിയുടെ സജ്ജീകരണ ഘട്ടം മാത്രമേ ഫിയോ പ്രവർത്തിപ്പിക്കുകയുള്ളൂ. ഫയലുകൾ നിരത്തേണ്ടതുണ്ടെങ്കിൽ
അല്ലെങ്കിൽ ഡിസ്കിൽ അപ്ഡേറ്റ് ചെയ്താൽ, അത് മാത്രമേ ചെയ്യൂ. യഥാർത്ഥ ജോലി ഉള്ളടക്കം അല്ല
നടപ്പിലാക്കി.

അനുവദിക്കുക_file_create=bool
ശരിയാണെങ്കിൽ, അതിന്റെ ജോലിഭാരത്തിന്റെ ഭാഗമായി ഫയലുകൾ സൃഷ്‌ടിക്കാൻ fio-ന് അനുമതിയുണ്ട്. ഇതാണ്
സ്ഥിര സ്വഭാവം. ഈ ഓപ്‌ഷൻ തെറ്റാണെങ്കിൽ, ഫിയോ അത് ഫയൽ ചെയ്‌താൽ പിശക് സംഭവിക്കും
ഉപയോഗിക്കേണ്ട ആവശ്യകതകൾ ഇതിനകം നിലവിലില്ല. സ്ഥിരസ്ഥിതി: ശരി.

അനുവദനീയമായ_മൌണ്ടഡ്_റൈറ്റ്=bool
ഇത് സജ്ജീകരിച്ചില്ലെങ്കിൽ, വിനാശകരമായ ജോലികൾ ഫിയോ നിർത്തലാക്കും (ഉദാ. എഴുതുക)
ഒരു മൌണ്ട് ചെയ്ത ഉപകരണമോ പാർട്ടീഷനോ ആണെന്ന് തോന്നുന്നു. ഇത് സൃഷ്ടിക്കാൻ സഹായിക്കണം
അശ്രദ്ധമായി നശിപ്പിക്കുന്ന ടെസ്റ്റുകൾ, ടെസ്റ്റ് ഡാറ്റ നശിപ്പിക്കുമെന്ന് തിരിച്ചറിയുന്നില്ല
മൌണ്ട് ചെയ്ത ഫയൽ സിസ്റ്റം. സ്ഥിരസ്ഥിതി: തെറ്റ്.

മുൻകൂട്ടി_വായിക്കുക=bool
ഇത് നൽകിയാൽ, നൽകിയിരിക്കുന്ന IO ആരംഭിക്കുന്നതിന് മുമ്പ് ഫയലുകൾ മെമ്മറിയിലേക്ക് മുൻകൂട്ടി വായിക്കും
ഓപ്പറേഷൻ. ഇതും ക്ലിയർ ചെയ്യും അസാധുവാക്കുക പതാക, കാരണം അത് മുൻകൂട്ടി പറയുന്നതിൽ അർത്ഥമില്ല
വായിച്ചതിനുശേഷം കാഷെ ഡ്രോപ്പ് ചെയ്യുക. ഇത് തേടാവുന്ന IO എഞ്ചിനുകൾക്ക് മാത്രമേ പ്രവർത്തിക്കൂ,
ഒരേ ഡാറ്റ ഒന്നിലധികം തവണ വായിക്കാൻ അവ നിങ്ങളെ അനുവദിക്കുന്നതിനാൽ. അതിനാൽ ഇത് പ്രവർത്തിക്കില്ല
ഉദാ നെറ്റ്‌വർക്ക് അല്ലെങ്കിൽ സ്‌പ്ലൈസ് IO.

അൺലിങ്ക് ചെയ്യുക=bool
പൂർത്തിയാകുമ്പോൾ ജോലി ഫയലുകൾ അൺലിങ്ക് ചെയ്യുക. സ്ഥിരസ്ഥിതി: തെറ്റ്.

ലൂപ്പുകൾ=int
ഈ ജോലിയുടെ ആവർത്തനങ്ങളുടെ എണ്ണം (ഒരേ ജോലിഭാരത്തിന്റെ റൺ) വ്യക്തമാക്കുന്നു.
സ്ഥിരസ്ഥിതി: 1.

വെരിഫൈ_മാത്രം=bool
നിർദ്ദിഷ്‌ട ജോലിഭാരം നിർവ്വഹിക്കരുത്, മുമ്പത്തെ ഡാറ്റയുമായി പൊരുത്തപ്പെടുന്ന ഡാറ്റ മാത്രം പരിശോധിച്ചുറപ്പിക്കുക
ഈ ജോലിഭാരത്തിന്റെ അഭ്യർത്ഥന. ഡാറ്റ ഒന്നിലധികം തവണ പരിശോധിക്കാൻ ഈ ഓപ്ഷൻ ഒരാളെ അനുവദിക്കുന്നു
തിരുത്തിയെഴുതാതെ പിന്നീടുള്ള തീയതി. ഈ ഓപ്ഷൻ ജോലിഭാരത്തിന് മാത്രം അർത്ഥമാക്കുന്നു
അത് ഡാറ്റ എഴുതുന്നു, ഒപ്പം ജോലിഭാരങ്ങളെ പിന്തുണയ്ക്കുന്നില്ല സമയ_അടിസ്ഥാനം ഓപ്ഷൻ സെറ്റ്.

സ്ഥിരീകരിക്കുക=bool
ഒരു എഴുത്ത് ഘട്ടത്തിന് ശേഷം പരിശോധിച്ചുറപ്പിക്കൽ ഘട്ടം പ്രവർത്തിപ്പിക്കുക. എങ്കിൽ മാത്രമേ സാധുതയുള്ളൂ പരിശോധിക്കുക സജ്ജീകരിച്ചിരിക്കുന്നു. ഡിഫോൾട്ട്:
ശരി.

പരിശോധിക്കുക=str
ജോലിയുടെ ഓരോ ആവർത്തനത്തിനു ശേഷവും ഫയൽ ഉള്ളടക്കങ്ങൾ പരിശോധിക്കുന്ന രീതി. ഓരോന്നും
സ്ഥിരീകരണ രീതി പ്രത്യേക തലക്കെട്ടിന്റെ സ്ഥിരീകരണത്തെയും സൂചിപ്പിക്കുന്നു, അത് എഴുതിയിരിക്കുന്നു
ഓരോ ബ്ലോക്കിന്റെയും ആരംഭം വരെ. ഈ തലക്കെട്ടിൽ മെറ്റാ വിവരങ്ങളും ഉൾപ്പെടുന്നു
ബ്ലോക്കിന്റെ ഓഫ്സെറ്റ്, ബ്ലോക്ക് നമ്പർ, ബ്ലോക്ക് എഴുതിയ സമയ സ്റ്റാമ്പ് തുടങ്ങിയവ.
പരിശോധിക്കുക=str എന്നതുമായി സംയോജിപ്പിക്കാം verify_pattern=str ഓപ്ഷൻ. അനുവദനീയമായ മൂല്യങ്ങൾ ഇവയാണ്:

md5 crc16 crc32 crc32c crc32c-intel crc64 crc7 sha256 sha512 sha1 xxhash
ഓരോ ബ്ലോക്കിന്റെയും തലക്കെട്ടിൽ ഉചിതമായ ചെക്ക്സം സംഭരിക്കുക. crc32c-intel
ഹാർഡ്‌വെയർ ത്വരിതപ്പെടുത്തിയ SSE4.2 ആണ്, സാധാരണ crc32c ലേക്ക് തിരികെ വരുന്നു
സിസ്റ്റം പിന്തുണയ്ക്കുന്നില്ലെങ്കിൽ.

മെറ്റാ ഇപ്പോൾ മെറ്റാ വിവരങ്ങൾ ഉൾപ്പെടുത്തിയിരിക്കുന്നതിനാൽ ഈ ഓപ്ഷൻ ഒഴിവാക്കിയിരിക്കുന്നു
ജനറിക് വെരിഫിക്കേഷൻ ഹെഡറും മെറ്റാ വെരിഫിക്കേഷനും ഡിഫോൾട്ടായി സംഭവിക്കുന്നു.
വിശദമായ വിവരങ്ങൾക്ക് എന്നതിന്റെ വിവരണം കാണുക പരിശോധിക്കുക=str
ക്രമീകരണം. പഴയതുമായുള്ള അനുയോജ്യത കാരണം ഈ ഓപ്ഷൻ സൂക്ഷിച്ചിരിക്കുന്നു
കോൺഫിഗറേഷനുകൾ. അത് ഉപയോഗിക്കരുത്.

പാറ്റേൺ
കർശനമായ പാറ്റേൺ പരിശോധിക്കുക. സാധാരണയായി ഫിയോയിൽ ചിലത് ഉള്ള ഒരു തലക്കെട്ട് ഉൾപ്പെടുന്നു
അടിസ്ഥാന വിവരങ്ങളും ചെക്ക്‌സമ്മിംഗും, എന്നാൽ ഈ ഓപ്ഷൻ സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിൽ, മാത്രം
പ്രത്യേക പാറ്റേൺ സജ്ജീകരിച്ചിരിക്കുന്നു verify_pattern പരിശോധിച്ചുറപ്പിച്ചിരിക്കുന്നു.

ശൂന്യം സ്ഥിരീകരിക്കുന്നതായി നടിക്കുക. ഇന്റേണലുകൾ പരിശോധിക്കാൻ ഉപയോഗിക്കുന്നു.

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

സ്ഥിരീകരിക്കുക=bool
ശരിയാണെങ്കിൽ, എഴുതിയ പരിശോധിച്ചുറപ്പിക്കൽ ബ്ലോക്കുകൾ അടുക്കും fio അവ വായിക്കുന്നത് വേഗമേറിയതാണെന്ന് കരുതുന്നു
ക്രമീകരിച്ച രീതിയിൽ തിരികെ. സ്ഥിരസ്ഥിതി: ശരി.

verifysort_nr=int
റീഡ് വർക്ക് ലോഡിനായി ബ്ലോക്കുകൾ മുൻകൂട്ടി ലോഡുചെയ്‌ത് അടുക്കുക.

verify_offset=int
എഴുതുന്നതിന് മുമ്പ് ബ്ലോക്കിലെ മറ്റെവിടെയെങ്കിലും ഡാറ്റ ഉപയോഗിച്ച് സ്ഥിരീകരണ തലക്കെട്ട് മാറ്റുക.
പരിശോധിച്ചുറപ്പിക്കുന്നതിന് മുമ്പ് ഇത് തിരികെ മാറ്റി.

verify_interval=int
ഈ എണ്ണം ബൈറ്റുകളുടെ സ്ഥിരീകരണ തലക്കെട്ട് എഴുതുക, അത് വിഭജിക്കണം
ബ്ലോക്കുകളുടെ വലിപ്പം. ഡിഫോൾട്ട്: ബ്ലോക്കുകളുടെ വലിപ്പം.

verify_pattern=str
സജ്ജീകരിച്ചാൽ, ഈ പാറ്റേൺ ഉപയോഗിച്ച് io ബഫറുകൾ ഫിയോ പൂരിപ്പിക്കും. ഫിയോ ഡിഫോൾട്ടായി പൂരിപ്പിക്കുന്നു
തികച്ചും ക്രമരഹിതമായ ബൈറ്റുകൾക്കൊപ്പം, എന്നാൽ ചിലപ്പോൾ അറിയപ്പെടുന്നവ ഉപയോഗിച്ച് പൂരിപ്പിക്കുന്നത് രസകരമാണ്
io സ്ഥിരീകരണ ആവശ്യങ്ങൾക്കുള്ള പാറ്റേൺ. പാറ്റേണിന്റെ വീതിയെ ആശ്രയിച്ച്, ഫിയോ
ആ സമയത്ത് ബഫറിന്റെ 1/2/3/4 ബൈറ്റുകൾ പൂരിപ്പിക്കും (ഇത് ഒന്നുകിൽ ഒരു ദശാംശമോ ഒരു ആകാം
ഹെക്സ് നമ്പർ). 32-ബിറ്റ് അളവിനേക്കാൾ വലുതാണെങ്കിൽ വെരിഫൈ_പാറ്റേൺ ഒരു ഹെക്‌സ് ആയിരിക്കണം
"0x" അല്ലെങ്കിൽ "0X" എന്നിവയിൽ ആരംഭിക്കുന്ന നമ്പർ. കൂടെ ഉപയോഗിക്കുക പരിശോധിക്കുക=str. കൂടാതെ,
verify_pattern %o ഫോർമാറ്റിനെ പിന്തുണയ്ക്കുന്നു, അതായത് ഓരോ ബ്ലോക്കിനും ഓഫ്സെറ്റ് ആയിരിക്കും
എഴുതുകയും പിന്നീട് വീണ്ടും പരിശോധിക്കുകയും ചെയ്യുന്നു, ഉദാ:
verify_pattern=%o
അല്ലെങ്കിൽ എല്ലാം സംയോജിപ്പിക്കുക:

verify_pattern=0xff%o"abcd"-21

verify_fatal=bool
ശരിയാണെങ്കിൽ, ആദ്യം നിരീക്ഷിച്ച സ്ഥിരീകരണ പരാജയത്തിൽ ജോലിയിൽ നിന്ന് പുറത്തുകടക്കുക. സ്ഥിരസ്ഥിതി: തെറ്റ്.

verify_dump=bool
സജ്ജമാക്കിയാൽ, ഒറിജിനൽ ഡാറ്റ ബ്ലോക്കിന്റെയും ഡാറ്റ ബ്ലോക്കിന്റെയും ഉള്ളടക്കങ്ങൾ ഡംപ് ചെയ്യുക
ഫയലുകളിലേക്ക് ഡിസ്ക് വായിക്കുക. ഏത് തരത്തിലുള്ളതാണെന്ന് പരിശോധിക്കാൻ ഇത് പിന്നീട് വിശകലനത്തെ അനുവദിക്കുന്നു
ഡാറ്റ അഴിമതി സംഭവിച്ചു. ഡിഫോൾട്ടായി ഓഫ്.

verify_async=int
Fio സാധാരണയായി സമർപ്പിക്കുന്ന ത്രെഡിൽ നിന്ന് IO ഇൻലൈൻ പരിശോധിക്കും. ഈ ഓപ്ഷൻ ഒരു എടുക്കും
IO സ്ഥിരീകരണത്തിനായി എത്ര അസിൻക് ഓഫ്‌ലോഡ് ത്രെഡുകൾ സൃഷ്ടിക്കണമെന്ന് വിവരിക്കുന്ന പൂർണ്ണസംഖ്യ
പകരം, ഒന്നോ അതിലധികമോ ഐ‌ഒ ഉള്ളടക്കങ്ങൾ പരിശോധിക്കുന്നതിനുള്ള ചുമതല ഫിയോ ഓഫ്‌ലോഡ് ചെയ്യാൻ കാരണമാകുന്നു
പ്രത്യേക ത്രെഡുകൾ. ഈ ഓഫ്‌ലോഡ് ഓപ്ഷൻ ഉപയോഗിക്കുകയാണെങ്കിൽ, സമന്വയ ഐഒ എഞ്ചിനുകൾക്ക് പോലും പ്രയോജനം ലഭിക്കും
ഒരു ഉപയോഗിക്കുന്നതിൽ നിന്ന് അയോഡെപ്ത്ത് ഫ്ലൈറ്റിൽ IO ഉണ്ടായിരിക്കാൻ ഇത് അവരെ അനുവദിക്കുന്നതിനാൽ 1-നേക്കാൾ ഉയർന്നത് ക്രമീകരിക്കുന്നു
പരിശോധിച്ചുറപ്പിക്കൽ പ്രവർത്തിക്കുമ്പോൾ.

verify_async_cpus=str
Async IO വെരിഫിക്കേഷൻ ത്രെഡുകളിൽ നൽകിയിരിക്കുന്ന സിപിയു അഫിനിറ്റി സജ്ജീകരിക്കാൻ ഫിയോയോട് പറയുക. കാണുക
cpus_Allowed ഉപയോഗിച്ച ഫോർമാറ്റിനായി.

verify_backlog=int
ഫിയോ സാധാരണയായി ഒരു ജോലിയുടെ രേഖാമൂലമുള്ള ഉള്ളടക്കം സ്ഥിരീകരിക്കും, അത് ഒരിക്കൽ പരിശോധിച്ചുറപ്പിക്കും
ആ ജോലി പൂർത്തിയായി. മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, എല്ലാം എഴുതിയിരിക്കുന്നു, പിന്നെ എല്ലാം
തിരികെ വായിച്ച് പരിശോധിച്ചുറപ്പിച്ചു. വ്യത്യസ്തമായവയ്‌ക്ക് പകരം തുടർച്ചയായി സ്ഥിരീകരിക്കാൻ നിങ്ങൾ ആഗ്രഹിച്ചേക്കാം
കാരണങ്ങൾ. ഫിയോ മെമ്മറിയിൽ ഒരു IO ബ്ലോക്കുമായി ബന്ധപ്പെട്ട മെറ്റാ ഡാറ്റ സംഭരിക്കുന്നു
വലിയ വെരിഫൈ വർക്ക്ലോഡുകൾ, ഈ മെറ്റാ കൈവശം വയ്ക്കുമ്പോൾ കുറച്ച് മെമ്മറി ഉപയോഗിക്കപ്പെടും
ഡാറ്റ. ഈ ഓപ്‌ഷൻ പ്രവർത്തനക്ഷമമാക്കിയാൽ, സ്ഥിരീകരിക്കുന്നതിന് മുമ്പ് ഫിയോ N ബ്ലോക്കുകൾ മാത്രമേ എഴുതൂ
ഈ ബ്ലോക്കുകൾ.

verify_backlog_batch=int
verify_backlog സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിൽ ഫിയോ എത്ര ബ്ലോക്കുകൾ പരിശോധിക്കുമെന്ന് നിയന്ത്രിക്കുക. സജ്ജമാക്കിയില്ലെങ്കിൽ, ചെയ്യും
മൂല്യത്തിലേക്ക് സ്ഥിരസ്ഥിതി verify_backlog (അർത്ഥം മുഴുവൻ ക്യൂവും തിരികെ വായിച്ചു
സ്ഥിരീകരിച്ചു). എങ്കിൽ verify_backlog_batch കുറവാണ് verify_backlog അപ്പോൾ എല്ലാ ബ്ലോക്കുകളും അല്ല
എങ്കിൽ പരിശോധിക്കും verify_backlog_batch എന്നതിനേക്കാൾ വലുതാണ് verify_backlogചില
ബ്ലോക്കുകൾ ഒന്നിലധികം തവണ പരിശോധിക്കും.

ട്രിം_ശതമാനം=int
നിരസിക്കാനുള്ള/ട്രിം ചെയ്യാനുള്ള വെരിഫൈ ബ്ലോക്കുകളുടെ എണ്ണം.

trim_verify_zero=bool
ട്രിം/ഉപേക്ഷിച്ച ബ്ളോക്കുകൾ പൂജ്യമായി നൽകിയിട്ടുണ്ടോയെന്ന് പരിശോധിക്കുക.

ട്രിം_ബാക്ക്ലോഗ്=int
ഈ എണ്ണം ബ്ലോക്കുകൾ എഴുതിയതിന് ശേഷം ട്രിം ചെയ്യുക.

trim_backlog_batch=int
IO ബ്ലോക്കുകളുടെ ഈ എണ്ണം ട്രിം ചെയ്യുക.

പരീക്ഷണ_പരിശോധന=bool
പരീക്ഷണാത്മക സ്ഥിരീകരണം പ്രവർത്തനക്ഷമമാക്കുക.

verify_state_save=bool
വെരിഫൈ വർക്ക് ലോഡിന്റെ റൈറ്റ് ഘട്ടത്തിൽ ഒരു ജോലി പുറത്തുകടക്കുമ്പോൾ, അതിന്റെ കറന്റ് സംരക്ഷിക്കുക
സംസ്ഥാനം. വെരിഫൈ സ്റ്റേറ്റ് ലോഡ് ചെയ്താൽ, അത് വരെ ഫിയോയെ റീപ്ലേ ചെയ്യാൻ ഇത് അനുവദിക്കുന്നു
പരിശോധിച്ചുറപ്പിക്കൽ വായന ഘട്ടത്തിനായി.

verify_state_load=bool
ഒരു സ്ഥിരീകരണ ടെർമിനേഷൻ ട്രിഗർ ഉപയോഗിച്ചിട്ടുണ്ടെങ്കിൽ, ഫിയോ നിലവിലെ റൈറ്റ് അവസ്ഥ സംഭരിക്കുന്നു
ഓരോ ത്രെഡ്. സ്ഥിരീകരണ സമയത്ത് ഇത് ഉപയോഗിക്കാനാകുമെന്നതിനാൽ ഫിയോയ്ക്ക് ഇത് എത്രത്തോളം ദൂരമുണ്ടെന്ന് അറിയാനാകും
സ്ഥിരീകരിക്കണം. ഈ വിവരങ്ങളില്ലാതെ, ഫിയോ ഒരു പൂർണ്ണ സ്ഥിരീകരണ പാസ് പ്രവർത്തിപ്പിക്കും,
ഉപയോഗിച്ച ജോലി ഫയലിലെ ക്രമീകരണങ്ങൾ അനുസരിച്ച്.

കല്ലുമതില് , മുമ്പത്തേതിനായി_കാത്തിരിക്കുക
ഇത് ആരംഭിക്കുന്നതിന് മുമ്പ് ജോബ് ഫയലിലെ മുൻ ജോലികൾ പുറത്തുവരാൻ കാത്തിരിക്കുക.
കല്ലുമതില് ധ്വനിപ്പിക്കുന്നു പുതിയ_ഗ്രൂപ്പ്.

പുതിയ_ഗ്രൂപ്പ്
ഒരു പുതിയ റിപ്പോർട്ടിംഗ് ഗ്രൂപ്പ് ആരംഭിക്കുക. നൽകിയില്ലെങ്കിൽ, ഫയലിലെ എല്ലാ ജോലികളും ഇതിന്റെ ഭാഗമാകും
ഒരേ റിപ്പോർട്ടിംഗ് ഗ്രൂപ്പ്, ഒരു കല്ലുകൊണ്ട് വേർപെടുത്തിയില്ലെങ്കിൽ.

numjobs=int
ഈ ജോലിയുടെ ക്ലോണുകളുടെ എണ്ണം (ഒരേ ജോലിഭാരം നിർവഹിക്കുന്ന പ്രക്രിയകൾ/ത്രെഡുകൾ).
സ്ഥിരസ്ഥിതി: 1.

ഗ്രൂപ്പ്_റിപ്പോർട്ടിംഗ്
സജ്ജീകരിച്ചാൽ, ഓരോ ജോലിക്കും പകരം ഓരോ ഗ്രൂപ്പിനും റിപ്പോർട്ടുകൾ പ്രദർശിപ്പിക്കുക numjobs വ്യക്തമാക്കിയിട്ടുണ്ട്.

ഇഴ ഉപയോഗിച്ച് സൃഷ്ടിച്ച ത്രെഡുകൾ ഉപയോഗിക്കുക pthread_create(3) ഉപയോഗിച്ച് സൃഷ്ടിച്ച പ്രക്രിയകൾക്ക് പകരം
ഫോർക്ക്(2).

സോൺസൈസ്=int
ബൈറ്റുകളിൽ നിർദ്ദിഷ്ട വലുപ്പത്തിലുള്ള സോണുകളായി ഫയലിനെ വിഭജിക്കുക. കാണുക zoneskip.

സോൺറേഞ്ച്=int
ഒരു IO സോണിന്റെ വലിപ്പം നൽകുക. കാണുക zoneskip.

zoneskip=int
എപ്പോൾ ബൈറ്റുകളുടെ നിർദ്ദിഷ്ട എണ്ണം ഒഴിവാക്കുക സോൺസൈസ് ഡാറ്റയുടെ ബൈറ്റുകൾ വായിച്ചു.

എഴുതുക_അയോളജി=str
നൽകിയ I/O പാറ്റേണുകൾ നിർദ്ദിഷ്ട ഫയലിലേക്ക് എഴുതുക. ഇതിനായി ഒരു പ്രത്യേക ഫയൽ വ്യക്തമാക്കുക
ഓരോ ജോലിയും, അല്ലെങ്കിൽ iologs ഇടകലർന്ന് ഫയൽ കേടായേക്കാം.

വായിക്കുക_അയോളജി=str
സൃഷ്ടിച്ച നിർദ്ദിഷ്ട ഫയലിൽ അടങ്ങിയിരിക്കുന്ന I/O പാറ്റേണുകൾ വീണ്ടും പ്ലേ ചെയ്യുക എഴുതുക_അയോളജി,
അല്ലെങ്കിൽ ഒരു ആകാം blktrace ബൈനറി ഫയൽ.

replay_no_stall=int
ഉപയോഗിച്ച് I/O പാറ്റേണുകൾ വീണ്ടും പ്ലേ ചെയ്യുമ്പോൾ വായിക്കുക_അയോളജി സ്വതവേയുള്ള പെരുമാറ്റം ശ്രമിക്കുന്നു
I/Os തമ്മിലുള്ള സമയ വിവരങ്ങൾ മാനിക്കുക. പ്രവർത്തനക്ഷമമാക്കുന്നു replay_no_stall I/Os-ന് കാരണമാകുന്നു
ഓർഡറിംഗിനെ മാനിക്കുമ്പോൾ തന്നെ കഴിയുന്നത്ര വേഗത്തിൽ വീണ്ടും പ്ലേ ചെയ്യുക.

replay_redirect=str
ഉപയോഗിച്ച് I/O പാറ്റേണുകൾ വീണ്ടും പ്ലേ ചെയ്യുമ്പോൾ വായിക്കുക_അയോളജി സ്ഥിരസ്ഥിതി സ്വഭാവം വീണ്ടും പ്ലേ ചെയ്യുക എന്നതാണ്
ഓരോ IOP-യും റെക്കോർഡ് ചെയ്‌ത പ്രധാന/ചെറിയ ഉപകരണത്തിലേക്ക് IOPS. ക്രമീകരണം
replay_redirect എല്ലാ ഐ‌ഒ‌പി‌എസുകളും ഒരൊറ്റ നിർദ്ദിഷ്ട ഉപകരണത്തിലേക്ക് വീണ്ടും പ്ലേ ചെയ്യാൻ കാരണമാകുന്നു
അത് റെക്കോർഡ് ചെയ്‌ത ഉപകരണം പരിഗണിക്കാതെ തന്നെ.

replay_align=int
2 മൂല്യത്തിന്റെ ഈ ശക്തിയിലേക്ക് ഒരു ട്രെയ്‌സിൽ IO ഓഫ്‌സെറ്റുകളുടെയും ദൈർഘ്യങ്ങളുടെയും നിർബന്ധിത വിന്യാസം.

റീപ്ലേ_സ്കെയിൽ=int
ട്രെയ്‌സുകൾ വീണ്ടും പ്ലേ ചെയ്യുമ്പോൾ സ്കെയിൽ സെക്‌ടർ ഈ ഘടകത്താൽ ഓഫ്‌സെറ്റ് ചെയ്യുന്നു.

ഓരോ_ജോലി_ലോഗുകൾക്കും=bool
സജ്ജമാക്കിയാൽ, ഇത് ഓരോ ഫയലിനും സ്വകാര്യ ഫയൽനാമങ്ങൾക്കൊപ്പം bw/clat/iops ലോഗ് ജനറേറ്റുചെയ്യുന്നു. അല്ലെങ്കിൽ
സെറ്റ്, സമാന പേരുകളുള്ള ജോലികൾ ലോഗ് ഫയലിന്റെ പേര് പങ്കിടും. സ്ഥിരസ്ഥിതി: ശരി.

എഴുതുക_bw_log=str
നൽകിയിട്ടുണ്ടെങ്കിൽ, ഈ ജോബ് ഫയലിൽ ജോലികളുടെ ഒരു ബാൻഡ്‌വിഡ്ത്ത് ലോഗ് എഴുതുക. സംഭരിക്കാൻ ഉപയോഗിക്കാം
അവരുടെ ജീവിതകാലത്തെ ജോലികളുടെ ബാൻഡ്‌വിഡ്‌ത്തിന്റെ ഡാറ്റ. ഉൾപ്പെടുത്തിയിട്ടുണ്ട്
ഈ ടെക്സ്റ്റ് ഫയലുകളെ നല്ല ഗ്രാഫുകളാക്കി മാറ്റാൻ fio_generate_plots സ്ക്രിപ്റ്റ് gnuplot ഉപയോഗിക്കുന്നു.
കാണുക എഴുതുക_lat_log നൽകിയിരിക്കുന്ന ഫയൽ നാമത്തിന്റെ പെരുമാറ്റത്തിന്. ഈ ഓപ്ഷനായി, പോസ്റ്റ്ഫിക്സ് ആണ്
_bw.x.log, ഇവിടെ x എന്നത് ജോലിയുടെ സൂചികയാണ് (1..N, ഇവിടെ N എന്നത് ജോലികളുടെ എണ്ണം).
If ഓരോ_ജോലി_ലോഗുകൾക്കും തെറ്റാണ്, അപ്പോൾ ഫയലിന്റെ പേരിൽ ജോലി സൂചിക ഉൾപ്പെടില്ല.

എഴുതുക_lat_log=str
അതുപോലെ തന്നെ എഴുതുക_bw_log, എന്നാൽ I/O പൂർത്തീകരണ ലേറ്റൻസികൾ എഴുതുന്നു. ഫയലിന്റെ പേര് നൽകിയിട്ടില്ലെങ്കിൽ
ഈ ഓപ്‌ഷനിൽ, "jobname_type.x.log" എന്നതിന്റെ സ്ഥിരസ്ഥിതി ഫയൽനാമം ഉപയോഗിക്കുന്നു, ഇവിടെ x ആണ്
ജോലിയുടെ സൂചിക (1..N, ഇവിടെ N എന്നത് ജോലികളുടെ എണ്ണം). ഫയലിന്റെ പേര് ആണെങ്കിലും
നൽകിയിരിക്കുന്നു, ഫിയോ ഇപ്പോഴും ലോഗ് തരം കൂട്ടിച്ചേർക്കും. എങ്കിൽ ഓരോ_ജോലി_ലോഗുകൾക്കും തെറ്റാണ്, അപ്പോൾ
ഫയലിന്റെ പേരിൽ ജോലി സൂചിക ഉൾപ്പെടില്ല.

എഴുതുക_iops_log=str
അതുപോലെ തന്നെ എഴുതുക_bw_log, എന്നാൽ IOPS എഴുതുന്നു. ഈ ഓപ്‌ഷനിൽ ഫയലിന്റെ പേര് നൽകിയിട്ടില്ലെങ്കിൽ,
"jobname_type.x.log" എന്നതിന്റെ സ്ഥിരസ്ഥിതി ഫയൽനാമം ഉപയോഗിക്കുന്നു, ഇവിടെ x എന്നത് സൂചികയാണ്
ജോലി (1..N, ഇവിടെ N എന്നത് ജോലികളുടെ എണ്ണം). ഫയലിന്റെ പേര് നൽകിയാലും, ഫിയോ ചെയ്യും
ഇപ്പോഴും ലോഗിന്റെ തരം കൂട്ടിച്ചേർക്കുക. എങ്കിൽ ഓരോ_ജോലി_ലോഗുകൾക്കും തെറ്റാണ്, അപ്പോൾ ഫയലിന്റെ പേര് ഉണ്ടാകില്ല
തൊഴിൽ സൂചിക ഉൾപ്പെടുത്തുക.

log_avg_msec=int
ഡിഫോൾട്ടായി, fio ഓരോ IO-യ്ക്കും iops, ലേറ്റൻസി അല്ലെങ്കിൽ bw ലോഗിൽ ഒരു എൻട്രി ലോഗ് ചെയ്യും.
പൂർത്തിയാക്കുന്നു. ഡിസ്ക് ലോഗിലേക്ക് എഴുതുമ്പോൾ, അത് വളരെ വലുതായി വളരും
വലിപ്പം. ഈ ഓപ്‌ഷൻ സജ്ജീകരിക്കുന്നത് ഫിയോയെ ഓരോ ലോഗ് എൻട്രിയും വ്യക്തമാക്കിയതിലും ശരാശരിയാക്കുന്നു
സമയ കാലയളവ്, ലോഗിന്റെ റെസല്യൂഷൻ കുറയ്ക്കുന്നു. 0 ലേക്ക് ഡിഫോൾട്ടുകൾ.

ലോഗ്_ഓഫ്സെറ്റ്=bool
ഇത് സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിൽ, ഐഒലോഗ് ഓപ്ഷനുകളിൽ ഐഒ എൻട്രിക്കുള്ള ബൈറ്റ് ഓഫ്സെറ്റ് ഉൾപ്പെടും
മറ്റ് ഡാറ്റ മൂല്യങ്ങൾ പോലെ.

ലോഗ്_കംപ്രഷൻ=int
ഇത് സജ്ജീകരിച്ചാൽ, മെമ്മറി നിലനിർത്താൻ ഫിയോ ഐഒ ലോഗുകൾ കംപ്രസ് ചെയ്യും
കാൽപ്പാട് താഴെ. ഒരു ലോഗ് നിർദ്ദിഷ്‌ട വലുപ്പത്തിൽ എത്തുമ്പോൾ, ആ ചങ്ക് നീക്കം ചെയ്യപ്പെടും
പശ്ചാത്തലത്തിൽ കംപ്രസ് ചെയ്തു. IO ലോഗുകൾ വളരെ കംപ്രസ്സബിൾ ആയതിനാൽ,
ഇത് ദൈർഘ്യമേറിയ റണ്ണുകൾക്ക് നല്ല മെമ്മറി സേവിംഗ്സ് നൽകുന്നു. പോരായ്മയാണ്
കംപ്രഷൻ ചില പശ്ചാത്തല സിപിയു സൈക്കിളുകൾ ഉപയോഗിക്കും, അതിനാൽ ഇത് റണ്ണിനെ ബാധിച്ചേക്കാം.
എന്നിരുന്നാലും, ലോഗിംഗ് സിസ്റ്റത്തിന്റെ ഭൂരിഭാഗവും വിനിയോഗിക്കുകയാണെങ്കിൽ ഇതും ശരിയാണ്
ഓർമ്മ. അതിനാൽ നിങ്ങളുടെ വിഷം എടുക്കുക. IO ലോഗുകൾ ഒരു ഓട്ടത്തിന്റെ അവസാനം സാധാരണയായി സേവ് ചെയ്യപ്പെടും
ചങ്കുകൾ വിഘടിപ്പിച്ച് അവ നിർദ്ദിഷ്ട ലോഗ് ഫയലിൽ സൂക്ഷിക്കുന്നു. ഈ സവിശേഷത
zlib ന്റെ ലഭ്യതയെ ആശ്രയിച്ചിരിക്കുന്നു.

log_store_compressed=bool
സജ്ജമാക്കിയാൽ, ഒപ്പം ലോഗ്_compression സജ്ജീകരിച്ചിരിക്കുന്നു, ഫിയോ ലോഗ് ഫയലുകൾ a-ൽ സംഭരിക്കും
കംപ്രസ് ചെയ്ത ഫോർമാറ്റ്. ഫിയോ ഉപയോഗിച്ച് അവയെ വിഘടിപ്പിക്കാം --ഇൻഫ്ലേറ്റ്-ലോഗ്
കമാൻഡ് ലൈൻ പാരാമീറ്റർ. ഫയലുകൾ ഒരു ഉപയോഗിച്ച് സൂക്ഷിക്കും .fz പ്രത്യയം.

block_error_percentiles=bool
സജ്ജീകരിച്ചാൽ, റൈറ്റുകളിൽ നിന്നും ട്രിമ്മുകളിൽ നിന്നും ട്രിം ബ്ലോക്ക് വലിപ്പത്തിലുള്ള യൂണിറ്റുകളിൽ പിശകുകൾ രേഖപ്പെടുത്തുക, ഔട്ട്പുട്ട് a
പിശകുകൾ ലഭിക്കാൻ എത്ര ട്രിമ്മുകൾ എടുത്തു, ഏത് തരത്തിലുള്ള പിശക് ആയിരുന്നു എന്നതിന്റെ ഹിസ്റ്റോഗ്രാം
നേരിട്ടു.

disable_lat=bool
മൊത്തം ലേറ്റൻസി നമ്പറുകളുടെ അളവുകൾ പ്രവർത്തനരഹിതമാക്കുക. വെട്ടിമാറ്റാൻ മാത്രം ഉപയോഗപ്രദമാണ്
കോളുകളുടെ എണ്ണം കിട്ടുന്ന സമയം(2), അത് വളരെ ഉയർന്ന പ്രകടനത്തെ സ്വാധീനിക്കുന്നതിനാൽ
IOPS നിരക്കുകൾ. ഈ കോളുകളുടെ ഒരു വലിയ തുക ശരിക്കും ഒഴിവാക്കാൻ ശ്രദ്ധിക്കുക
disable_slat, disable_bw എന്നിവയ്‌ക്കൊപ്പം ഓപ്ഷൻ ഉപയോഗിക്കണം.

disable_clat=bool
പൂർത്തീകരണ ലേറ്റൻസി നമ്പറുകളുടെ അളവുകൾ പ്രവർത്തനരഹിതമാക്കുക. കാണുക disable_lat.

disable_slat=bool
സമർപ്പിക്കൽ ലേറ്റൻസി നമ്പറുകളുടെ അളവുകൾ പ്രവർത്തനരഹിതമാക്കുക. കാണുക disable_lat.

disable_bw_measurement=bool
ത്രൂപുട്ട്/ബാൻഡ്‌വിഡ്ത്ത് നമ്പറുകളുടെ അളവുകൾ പ്രവർത്തനരഹിതമാക്കുക. കാണുക disable_lat.

ലോക്ക്മെം=int
നിർദ്ദിഷ്‌ട മെമ്മറിയുടെ അളവ് പിൻ ചെയ്യുക മ്ലാക്ക്(2). a യെ അനുകരിക്കാൻ ഉപയോഗിക്കാം
ചെറിയ അളവിലുള്ള മെമ്മറി. ഓരോ തൊഴിലാളിക്കും നിശ്ചയിച്ചിട്ടുള്ള തുകയാണ്.

exec_prerun=str
ജോലി പ്രവർത്തിപ്പിക്കുന്നതിന് മുമ്പ്, നിർദ്ദിഷ്ട കമാൻഡ് ഉപയോഗിച്ച് പ്രവർത്തിപ്പിക്കുക സിസ്റ്റം(3).
ഔട്ട്പുട്ട് എന്ന ഫയലിൽ റീഡയറക്‌ട് ചെയ്‌തു jobname.prerun.txt

exec_postrun=str
അതുപോലെ തന്നെ exec_prerun, എന്നാൽ ജോലി പൂർത്തിയായതിന് ശേഷം കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്യുന്നു.
ഔട്ട്പുട്ട് എന്ന ഫയലിൽ റീഡയറക്‌ട് ചെയ്‌തു jobname.postrun.txt

ഐയോഷെഡ്യൂളർ=str
ഫയൽ ഹോസ്റ്റുചെയ്യുന്ന ഉപകരണം നിർദ്ദിഷ്ട I/O ഷെഡ്യൂളറിലേക്ക് മാറ്റാൻ ശ്രമിക്കുക.

disk_util=bool
പ്ലാറ്റ്ഫോം പിന്തുണയ്ക്കുന്നുണ്ടെങ്കിൽ ഡിസ്ക് ഉപയോഗ സ്ഥിതിവിവരക്കണക്കുകൾ സൃഷ്ടിക്കുക. സ്ഥിരസ്ഥിതി: ശരി.

ക്ലോക്ക് സോഴ്സ്=str
സമയത്തിന്റെ അടിസ്ഥാനമായി നൽകിയിരിക്കുന്ന ക്ലോക്ക് സോഴ്സ് ഉപയോഗിക്കുക. പിന്തുണയ്ക്കുന്ന ഓപ്ഷനുകൾ ഇവയാണ്:

കിട്ടുന്ന സമയം
കിട്ടുന്ന സമയം(2)

ക്ലോക്ക്_ഗെറ്റ് ടൈം
ക്ലോക്ക്_ഗെറ്റ് ടൈം(2)

സിപിയു ആന്തരിക സിപിയു ക്ലോക്ക് ഉറവിടം

സിപിയു അത് വിശ്വസനീയമാണെങ്കിൽ, അത് വളരെ വേഗതയുള്ളതാണ്
(ഒപ്പം ഫിയോ സമയ കോളുകൾക്ക് കനത്തതാണ്). എങ്കിൽ ഫിയോ ഈ ക്ലോക്ക് സോഴ്‌സ് സ്വയമേവ ഉപയോഗിക്കും
ഇത് പ്രവർത്തിക്കുന്ന സിസ്റ്റത്തിൽ പിന്തുണയ്ക്കുകയും വിശ്വസനീയമായി കണക്കാക്കുകയും ചെയ്യുന്നു
മറ്റൊരു ക്ലോക്ക് സോഴ്സ് പ്രത്യേകമായി സജ്ജീകരിച്ചിരിക്കുന്നു. x86/x86-64 CPU-കൾക്കായി, ഇത് പിന്തുണയ്ക്കുന്നു എന്നാണ്
TSC മാറ്റമില്ലാത്തത്.

gtod_reduce=bool
എല്ലാം പ്രവർത്തനക്ഷമമാക്കുക കിട്ടുന്ന സമയം(2) കുറയ്ക്കൽ ഓപ്ഷനുകൾ (disable_clat, disable_slat,
disable_bw) കൂടാതെ സമയപരിധിയുടെ കൃത്യത കുറച്ച് ശരിക്കും ചുരുക്കുക
കിട്ടുന്ന സമയം(2) കോളുകളുടെ എണ്ണം. ഈ ഓപ്‌ഷൻ പ്രവർത്തനക്ഷമമാക്കിയാൽ, ഞങ്ങൾ ഏകദേശം 0.4% മാത്രമേ ചെയ്യുന്നുള്ളൂ
എല്ലാ സമയവും സൂക്ഷിക്കൽ പ്രവർത്തനക്ഷമമാക്കിയിരുന്നെങ്കിൽ gtod() കോളുകൾ ഞങ്ങൾ ചെയ്യുമായിരുന്നു.

gtod_cpu=int
ചില സമയങ്ങളിൽ അത് നേടുന്നതിന് ഒരു ത്രെഡ് എക്സിക്യൂഷൻ സമർപ്പിക്കുന്നത് വിലകുറഞ്ഞതാണ്
വര്ത്തമാന കാലം. ഫിയോ (ഉദാഹരണത്തിന്, ഡാറ്റാബേസുകൾ) വളരെ തീവ്രമാണ്
കിട്ടുന്ന സമയം(2) കോളുകൾ. ഈ ഓപ്‌ഷൻ ഉപയോഗിച്ച്, ചെയ്യുന്നതിനായി നിങ്ങൾക്ക് ഒരു സിപിയു മാറ്റിവെക്കാം
ഒരു പങ്കിട്ട മെമ്മറി ലൊക്കേഷനിലേക്ക് നിലവിലെ സമയം ലോഗ് ചെയ്യുന്നതല്ലാതെ മറ്റൊന്നുമല്ല. പിന്നെ മറ്റൊന്ന്
IO വർക്ക്ലോഡുകൾ പ്രവർത്തിപ്പിക്കുന്ന ത്രെഡുകൾ/പ്രക്രിയകൾക്ക് പകരം ആ സെഗ്മെന്റ് പകർത്തിയാൽ മതി
a ഉപയോഗിച്ച് കേർണലിലേക്ക് പ്രവേശിക്കുന്നു കിട്ടുന്ന സമയം(2) വിളിക്കുക. ഇവ ചെയ്യുന്നതിനായി മാറ്റിവെച്ച സിപിയു
സമയ കോളുകൾ മറ്റ് ഉപയോഗങ്ങളിൽ നിന്ന് ഒഴിവാക്കപ്പെടും. ഫിയോ ഇത് സ്വമേധയാ മായ്‌ക്കും
മറ്റ് ജോലികളുടെ സിപിയു മാസ്ക്.

അവഗണിക്കുക_പിശക്=str
ചില സമയങ്ങളിൽ പരിശോധനയ്ക്കിടെ ചില പിശകുകൾ അവഗണിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നു, ആ സാഹചര്യത്തിൽ നിങ്ങൾക്ക് വ്യക്തമാക്കാം
ഓരോ പിശക് തരത്തിനും പിശക് പട്ടിക.
ignor_error=READ_ERR_LIST,WRITE_ERR_LIST,VERIFY_ERR_LIST
തന്നിരിക്കുന്ന പിശക് തരത്തിനായുള്ള പിശകുകൾ ':' കൊണ്ട് വേർതിരിച്ചിരിക്കുന്നു. പിശക് ചിഹ്നമായിരിക്കാം ('ENOSPC',
'ENOMEM') അല്ലെങ്കിൽ ഒരു പൂർണ്ണസംഖ്യ.
ഉദാഹരണം:ignign_error=EAGAIN,ENOSPC:122 .
ഈ ഓപ്‌ഷൻ READ-ൽ നിന്ന് EAGAIN, കൂടാതെ WRITE-ൽ നിന്ന് ENOSPC, 122(EDQUOT) എന്നിവ അവഗണിക്കും.

പിശക്_ഡമ്പ്=bool
മാരകമല്ലെങ്കിലും എല്ലാ പിശകുകളും ഇല്ലാതാക്കുകയാണെങ്കിൽ, സ്ഥിരസ്ഥിതിയായി ശരിയാണ്. പ്രവർത്തനരഹിതമാണെങ്കിൽ മാത്രം
മാരകമായ പിശക് തള്ളപ്പെടും

പ്രൊഫൈൽ=str
ഒരു നിർദ്ദിഷ്ട ബിൽറ്റ്-ഇൻ പ്രകടന പരിശോധന തിരഞ്ഞെടുക്കുക.

cgroup=str
ഈ നിയന്ത്രണ ഗ്രൂപ്പിലേക്ക് ജോലി ചേർക്കുക. അത് നിലവിലില്ലെങ്കിൽ, അത് സൃഷ്ടിക്കപ്പെടും. സംവിധാനം
ഇത് പ്രവർത്തിക്കുന്നതിന് മൌണ്ട് ചെയ്ത cgroup blkio മൗണ്ട് പോയിന്റ് ഉണ്ടായിരിക്കണം. നിങ്ങളുടെ സിസ്റ്റം എങ്കിൽ
ഇത് മൌണ്ട് ചെയ്തിട്ടില്ല, നിങ്ങൾക്ക് ഇത് ചെയ്യാൻ കഴിയും:

# mount -t cgroup -o blkio none /cgroup

cgroup_weight=int
cgroup-ന്റെ ഭാരം ഈ മൂല്യത്തിലേക്ക് സജ്ജമാക്കുക. വരുന്ന ഡോക്യുമെന്റേഷൻ കാണുക
കേർണൽ, അനുവദനീയമായ മൂല്യങ്ങൾ 100..1000 പരിധിയിലാണ്.

cgroup_nodelete=bool
സാധാരണയായി ഫിയോ, ജോലി പൂർത്തിയാക്കിയ ശേഷം സൃഷ്ടിച്ച cgroups ഇല്ലാതാക്കും. ലേക്ക്
ഈ സ്വഭാവം അസാധുവാക്കുകയും ജോലി പൂർത്തിയാക്കിയ ശേഷം cgroups ഉപേക്ഷിക്കുകയും ചെയ്യുക, സജ്ജമാക്കുക
cgroup_nodelete=1. വിവിധ cgroup ഫയലുകൾ പരിശോധിക്കണമെങ്കിൽ ഇത് ഉപയോഗപ്രദമാകും
ജോലി പൂർത്തിയാക്കിയ ശേഷം. സ്ഥിരസ്ഥിതി: തെറ്റ്

uid=int
അഭ്യർത്ഥിക്കുന്ന ഉപയോക്താവായി പ്രവർത്തിക്കുന്നതിന് പകരം, ഉപയോക്തൃ ഐഡി ഈ മൂല്യത്തിലേക്ക് സജ്ജീകരിക്കുക
ത്രെഡ്/പ്രോസസ് ഏത് ജോലിയും ചെയ്യുന്നു.

gid=int
ഗ്രൂപ്പ് ഐഡി സജ്ജമാക്കുക, കാണുക uid.

യൂണിറ്റ്_ബേസ്=int
റിപ്പോർട്ടിംഗിനുള്ള അടിസ്ഥാന യൂണിറ്റ്. അനുവദനീയമായ മൂല്യങ്ങൾ ഇവയാണ്:

0 സ്വയമേവ കണ്ടെത്തൽ ഉപയോഗിക്കുക (സ്ഥിരസ്ഥിതി).

8 ബൈറ്റ് അടിസ്ഥാനമാക്കിയുള്ളത്.

1 ബിറ്റ് അടിസ്ഥാനമാക്കിയുള്ളത്.

ഫ്ലോ_ഐഡി=int
ഒഴുക്കിന്റെ ഐഡി. വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ, അത് ആഗോള പ്രവാഹമായി മാറും. കാണുക ഒഴുകുക.

ഒഴുകുക=int
ടോക്കൺ അടിസ്ഥാനമാക്കിയുള്ള ഒഴുക്ക് നിയന്ത്രണത്തിൽ ഭാരം. ഈ മൂല്യം ഉപയോഗിക്കുകയാണെങ്കിൽ, അവിടെ a ഒഴുകുക
കൌണ്ടർ രണ്ടോ അതിലധികമോ പ്രവർത്തനങ്ങളുടെ അനുപാതം നിയന്ത്രിക്കാൻ ഇത് ഉപയോഗിക്കുന്നു
ജോലികൾ. fio ഈ ഫ്ലോ കൗണ്ടറിനെ പൂജ്യത്തിനടുത്തായി നിലനിർത്താൻ ശ്രമിക്കുന്നു. ദി ഒഴുകുക പാരാമീറ്റർ നിലകൊള്ളുന്നു
ഓരോ ആവർത്തനത്തിലും ഫ്ലോ കൗണ്ടറിലേക്ക് എത്ര ചേർക്കണം അല്ലെങ്കിൽ കുറയ്ക്കണം എന്നതിന്
പ്രധാന I/O ലൂപ്പ്. അതായത്, ഒരു ജോലി ഉണ്ടെങ്കിൽ ഒഴുക്ക്=8 കൂടാതെ മറ്റൊരു ജോലിയുണ്ട് ഒഴുക്ക്=-1എന്നിട്ട്
ഒന്ന് മറ്റൊന്നുമായി താരതമ്യം ചെയ്യുമ്പോൾ ഏകദേശം 1:8 അനുപാതം ഉണ്ടായിരിക്കും.

ഒഴുക്ക്_വാട്ടർമാർക്ക്=int
ഫ്ലോ കൗണ്ടറിന്റെ സമ്പൂർണ്ണ മൂല്യം എത്താൻ അനുവദിക്കുന്ന പരമാവധി മൂല്യം
ജോലിക്ക് മുമ്പ് കൗണ്ടറിന്റെ കുറഞ്ഞ മൂല്യത്തിനായി കാത്തിരിക്കണം.

ഒഴുക്ക്_ഉറക്കം=int
ഫ്ലോ വാട്ടർമാർക്ക് കഴിഞ്ഞ് കാത്തിരിക്കേണ്ട സമയപരിധി മൈക്രോസെക്കൻഡിൽ
പ്രവർത്തനങ്ങൾ വീണ്ടും ശ്രമിക്കുന്നതിന് മുമ്പ് കവിഞ്ഞു

clat_percentiles=bool
പൂർത്തീകരണ ലേറ്റൻസികളുടെ ശതമാനം റിപ്പോർട്ടിംഗ് പ്രവർത്തനക്ഷമമാക്കുക.

percentile_list=ഫ്ലോട്ട്_ലിസ്റ്റ്
പൂർത്തീകരണ ലേറ്റൻസികൾക്കും ബ്ലോക്കിനുമായി പെർസെന്റൈലുകളുടെ ഡിഫോൾട്ട് ലിസ്റ്റ് തിരുത്തിയെഴുതുക
പിശക് ഹിസ്റ്റോഗ്രാം. ഓരോ സംഖ്യയും ശ്രേണിയിലെ ഒരു ഫ്ലോട്ടിംഗ് നമ്പറാണ് (0,100], കൂടാതെ
പട്ടികയുടെ പരമാവധി ദൈർഘ്യം 20 ആണ്. അക്കങ്ങൾ വേർതിരിക്കാൻ ':' ഉപയോഗിക്കുക. ഉദാഹരണത്തിന്,
--percentile_list=99.5:99.9 ഫിയോ പൂർത്തീകരണത്തിന്റെ മൂല്യങ്ങൾ റിപ്പോർട്ട് ചെയ്യാൻ ഇടയാക്കും.
നിരീക്ഷിച്ച ലേറ്റൻസികളിൽ യഥാക്രമം 99.5% ഉം 99.9% ഉം കുറഞ്ഞു.

അയോഎൻജിൻ പരാമീറ്ററുകൾ പട്ടിക
ഒരു നിർദ്ദിഷ്‌ട അയോഎൻജിൻ ഉപയോഗത്തിലായിരിക്കുമ്പോൾ മാത്രമേ ചില പാരാമീറ്ററുകൾ സാധുതയുള്ളൂ. ഇവ ഉപയോഗിക്കുന്നു
സാധാരണ പാരാമീറ്ററുകൾക്ക് സമാനമായി, കമാൻഡ് ലൈനിൽ ഉപയോഗിക്കുമ്പോൾ, അവ
ioengine കഴിഞ്ഞ് വരണം.

(സിപിയു) cpuload=int
CPU സൈക്കിളുകളുടെ നിർദ്ദിഷ്‌ട ശതമാനം ഉപയോഗിക്കാൻ ശ്രമിക്കുക.

(cpu)cpuchunks=int
നൽകിയിരിക്കുന്ന സമയത്തിന്റെ ചക്രങ്ങളായി ലോഡ് വിഭജിക്കുക. മൈക്രോസെക്കൻഡിൽ.

(cpu)exit_on_io_done=bool
IO ത്രെഡുകൾ പൂർത്തിയാകുമ്പോൾ കണ്ടെത്തുക, തുടർന്ന് പുറത്തുകടക്കുക.

(libaio)userspace_reap
സാധാരണയായി, libaio എഞ്ചിൻ ഉപയോഗത്തിലുണ്ടെങ്കിൽ, fio io_getevents സിസ്റ്റം കോൾ ഉപയോഗിക്കും
പുതുതായി തിരിച്ചെത്തിയ ഇവന്റുകൾ കൊയ്യാൻ. ഈ ഫ്ലാഗ് ഓണാക്കിയാൽ, AIO റിംഗ് വായിക്കപ്പെടും
ഇവന്റുകൾ കൊയ്യാൻ യൂസർ-സ്‌പെയ്‌സിൽ നിന്ന് നേരിട്ട്. എപ്പോൾ മാത്രമേ റീപ്പിംഗ് മോഡ് പ്രവർത്തനക്ഷമമാകൂ
കുറഞ്ഞത് 0 ഇവന്റുകൾക്കായുള്ള പോളിംഗ് (ഉദാ: iodepth_batch_complete=0 ചെയ്യുമ്പോൾ).

(net,netsplice)ഹോസ്റ്റ് നാമം=str
TCP അല്ലെങ്കിൽ UDP അടിസ്ഥാനമാക്കിയുള്ള IO-യ്ക്ക് ഉപയോഗിക്കേണ്ട ഹോസ്റ്റ് നാമം അല്ലെങ്കിൽ IP വിലാസം. ജോലി ഒരു ടിസിപി ആണെങ്കിൽ
ലിസണർ അല്ലെങ്കിൽ യുഡിപി റീഡർ, ഹോസ്റ്റ്നാമം ഉപയോഗിക്കില്ല, അത് ഒഴിവാക്കിയിരിക്കണം
സാധുവായ UDP മൾട്ടികാസ്റ്റ് വിലാസം.

(net,netsplice)പോർട്ട്=int
ബന്ധിപ്പിക്കുന്നതിനോ ബന്ധിപ്പിക്കുന്നതിനോ ഉള്ള TCP അല്ലെങ്കിൽ UDP പോർട്ട്. ഇത് ഉപയോഗിച്ചാൽ numjobs മുട്ടയിടാൻ
ഒരേ ജോലി തരത്തിന്റെ ഒന്നിലധികം സംഭവങ്ങൾ, അപ്പോൾ ഇത് ആരംഭ പോർട്ട് നമ്പറായിരിക്കും
കാരണം ഫിയോ പോർട്ടുകളുടെ ഒരു ശ്രേണി ഉപയോഗിക്കും.

(net,netsplice)ഇന്റർഫേസ്=str
UDP മൾട്ടികാസ്റ്റ് അയയ്ക്കുന്നതിനോ സ്വീകരിക്കുന്നതിനോ ഉപയോഗിക്കുന്ന നെറ്റ്‌വർക്ക് ഇന്റർഫേസിന്റെ IP വിലാസം
പാക്കറ്റുകൾ.

(net,netsplice)ttl=int
ഔട്ട്‌ഗോയിംഗ് UDP മൾട്ടികാസ്റ്റ് പാക്കറ്റുകൾക്കുള്ള ടൈം ടു ലൈവ് മൂല്യം. സ്ഥിരസ്ഥിതി: 1

(net,netsplice)നോഡ്ലേ=bool
TCP കണക്ഷനുകളിൽ TCP_NODELAY സജ്ജീകരിക്കുക.

(net,netsplice)പ്രോട്ടോക്കോൾ=str, പ്രോട്ടോ=str
ഉപയോഗിക്കേണ്ട നെറ്റ്‌വർക്ക് പ്രോട്ടോക്കോൾ. സ്വീകാര്യമായ മൂല്യങ്ങൾ ഇവയാണ്:

tcp ട്രാൻസ്മിഷൻ കൺട്രോൾ പ്രോട്ടോക്കോൾ

tcpv6 ട്രാൻസ്മിഷൻ കൺട്രോൾ പ്രോട്ടോക്കോൾ V6

udp ഉപയോക്തൃ ഡാറ്റഗ്രാം പ്രോട്ടോക്കോൾ

udpv6 ഉപയോക്തൃ ഡാറ്റഗ്രാം പ്രോട്ടോക്കോൾ V6

unix UNIX ഡൊമെയ്ൻ സോക്കറ്റ്

പ്രോട്ടോക്കോൾ TCP അല്ലെങ്കിൽ UDP ആയിരിക്കുമ്പോൾ, പോർട്ടും നൽകണം, അതുപോലെ തന്നെ
ജോലി ഒരു TCP ശ്രോതാവോ UDP റീഡറോ ആണെങ്കിൽ ഹോസ്റ്റിന്റെ പേര്. Unix സോക്കറ്റുകൾക്ക്, സാധാരണ
ഫയൽനാമം ഓപ്‌ഷൻ ഉപയോഗിക്കണം, പോർട്ട് അസാധുവാണ്.

(net,netsplice)കേൾക്കുക
ടിസിപി നെറ്റ്‌വർക്ക് കണക്ഷനുകൾക്കായി, ഇൻകമിംഗ് കണക്ഷനുകൾ കേൾക്കാൻ ഫിയോയോട് പറയുക
ഒരു ഔട്ട്‌ഗോയിംഗ് കണക്ഷൻ ആരംഭിക്കുന്നതിനേക്കാൾ. ഈ ഓപ്‌ഷനുണ്ടെങ്കിൽ ഹോസ്റ്റിന്റെ പേര് ഒഴിവാക്കണം
ഉപയോഗിക്കുന്നു.

(നെറ്റ്,പിംഗ്‌പോംഗ്)=bool
സാധാരണയായി ഒരു നെറ്റ്‌വർക്ക് റൈറ്റർ ഡാറ്റ എഴുതുന്നത് തുടരും, കൂടാതെ ഒരു നെറ്റ്‌വർക്ക് റീഡറും
പാക്കറ്റുകൾ മാത്രം കഴിക്കും. pingpong=1 സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിൽ, ഒരു എഴുത്തുകാരൻ അതിന്റെ സാധാരണ അയയ്‌ക്കും
റീഡർക്ക് പേലോഡ് ചെയ്യുക, തുടർന്ന് റീഡർ അതേ പേലോഡ് തിരികെ അയക്കുന്നത് വരെ കാത്തിരിക്കുക.
നെറ്റ്‌വർക്ക് ലേറ്റൻസി അളക്കാൻ ഇത് ഫിയോയെ അനുവദിക്കുന്നു. സമർപ്പണവും പൂർത്തീകരണവും
ലേറ്റൻസികൾ അയയ്‌ക്കുന്നതിനോ സ്വീകരിക്കുന്നതിനോ ചെലവഴിച്ച പ്രാദേശിക സമയവും പൂർത്തീകരണവും അളക്കുന്നു
മറ്റേ അറ്റം സ്വീകരിക്കുന്നതിനും തിരികെ അയയ്‌ക്കുന്നതിനും എത്ര സമയമെടുത്തുവെന്ന് ലേറ്റൻസി അളക്കുന്നു. വേണ്ടി
UDP മൾട്ടികാസ്റ്റ് ട്രാഫിക് pingpong=1 ഒരു വായനക്കാരന് മാത്രമായി സജ്ജീകരിക്കണം
ഒന്നിലധികം വായനക്കാർ ഒരേ വിലാസം കേൾക്കുന്നു.

(നെറ്റ്,window_size)=int
കണക്ഷനായി ആവശ്യമുള്ള സോക്കറ്റ് ബഫർ വലുപ്പം സജ്ജമാക്കുക.

(നെറ്റ്,mss)=int
TCP പരമാവധി സെഗ്‌മെന്റ് വലുപ്പം സജ്ജമാക്കുക (TCP_MAXSEG).

(e4defrag,donorname)=str
ഒരു ബ്ലോക്ക് ഡോണറായി ഫയൽ ഉപയോഗിക്കും (ഫയലുകൾക്കിടയിൽ വ്യാപ്തികൾ സ്വാപ്പ് ചെയ്യുക)

(e4defrag,inplace)=int
ഡോണർ ഫയൽ ബ്ലോക്ക് അലോക്കേഷൻ സ്ട്രാറ്റജി കോൺഫിഗർ ചെയ്യുക
0(സ്ഥിരസ്ഥിതി): init-ൽ ദാതാവിന്റെ ഫയൽ മുൻകൂട്ടി അനുവദിക്കുക

1: defragment ഇവന്റിനുള്ളിൽ ഉടനടി സ്ഥലം അനുവദിക്കുക, അതിന് ശേഷം സൗജന്യമായി
സംഭവം

(rbd)rbdനാമം=str
RBD-യുടെ പേര് വ്യക്തമാക്കുന്നു.

(rbd)കുളം=str
RBD അടങ്ങുന്ന സെഫ് പൂളിന്റെ പേര് വ്യക്തമാക്കുന്നു.

(rbd)ഉപഭോക്താവിന്റെ പേര്=str
Ceph ആക്‌സസ് ചെയ്യാൻ ഉപയോഗിക്കുന്ന ഉപയോക്തൃനാമം ('ക്ലയന്റ്.' പ്രിഫിക്‌സ് ഇല്ലാതെ) വ്യക്തമാക്കുന്നു
ക്ലസ്റ്റർ

(mtd) ഒഴിവാക്കുക=bool
അറിയപ്പെടുന്ന മോശം ബ്ലോക്കുകൾക്കെതിരായ പ്രവർത്തനങ്ങൾ ഒഴിവാക്കുക.

ഔട്ട്പ്

ഓടുമ്പോൾ, fio സൃഷ്ടിച്ച ജോലികളുടെ നില പ്രദർശിപ്പിക്കും. ഉദാഹരണത്തിന്:

ത്രെഡുകൾ: 1: [_r] [24.8% പൂർത്തിയായി] [ 13509/ 8334 kb/s] [eta 00h:01m:31s]

ബ്രാക്കറ്റുകളുടെ ആദ്യ സെറ്റിലെ പ്രതീകങ്ങൾ ഓരോ ത്രെഡുകളുടെയും നിലവിലെ നിലയെ സൂചിപ്പിക്കുന്നു.
സാധ്യമായ മൂല്യങ്ങൾ ഇവയാണ്:

P സജ്ജീകരിച്ചു, പക്ഷേ ആരംഭിച്ചിട്ടില്ല.
C ത്രെഡ് സൃഷ്ടിച്ചു.
I ആരംഭിച്ചു, കാത്തിരിക്കുന്നു.
R ഓട്ടം, തുടർച്ചയായ വായനകൾ.
r ഓട്ടം, ക്രമരഹിതമായ വായനകൾ.
W ഓട്ടം, തുടർച്ചയായ എഴുത്തുകൾ.
w ഓട്ടം, ക്രമരഹിതമായ എഴുത്തുകൾ.
M റണ്ണിംഗ്, മിക്സഡ് സീക്വൻഷ്യൽ റീഡുകൾ/എഴുതുകൾ.
m റണ്ണിംഗ്, മിക്സഡ് റാൻഡം റീഡുകൾ/എഴുതുകൾ.
F പ്രവർത്തിക്കുന്നു, നിലവിൽ കാത്തിരിക്കുന്നു fsync(2).
V റൺ ചെയ്യുന്നു, എഴുതിയ ഡാറ്റ പരിശോധിക്കുന്നു.
E പുറത്തുകടന്നു, പ്രധാന ത്രെഡ് വഴി കൊയ്തില്ല.
- പുറത്തുകടന്നു, ത്രെഡ് കൊയ്ത്തു.

രണ്ടാമത്തെ സെറ്റ് ബ്രാക്കറ്റുകൾ നിലവിലെ ഗ്രൂപ്പിന്റെ കണക്കാക്കിയ പൂർത്തീകരണ ശതമാനം കാണിക്കുന്നു.
മൂന്നാമത്തെ സെറ്റ് യഥാക്രമം റീഡ് ആൻഡ് റൈറ്റ് I/O നിരക്ക് കാണിക്കുന്നു. ഒടുവിൽ, കണക്കാക്കിയ ഓട്ടം
ജോലിയുടെ സമയം കാണിക്കുന്നു.

എപ്പോൾ fio പൂർത്തിയാക്കുന്നു (അല്ലെങ്കിൽ Ctrl-C തടസ്സപ്പെടുത്തുന്നു), ഇത് ഓരോ ത്രെഡിനും ഡാറ്റ കാണിക്കും
ഒരു കൂട്ടം ത്രെഡുകളും ഓരോ ഡിസ്കും ആ ക്രമത്തിൽ.

ഓരോ ത്രെഡിന്റെ സ്ഥിതിവിവരക്കണക്കുകൾ ആദ്യം ത്രെഡ്‌സ് ക്ലയന്റ് നമ്പർ, ഗ്രൂപ്പ്-ഐഡി, പിശക് കോഡ് എന്നിവ കാണിക്കുന്നു. ദി
ശേഷിക്കുന്ന കണക്കുകൾ ഇപ്രകാരമാണ്:

io I/O യുടെ മെഗാബൈറ്റുകളുടെ എണ്ണം.

bw ശരാശരി ഡാറ്റ നിരക്ക് (ബാൻഡ്‌വിഡ്ത്ത്).

ഓടുക ത്രെഡുകൾ റൺ ടൈം.

സ്ലാറ്റ് സമർപ്പിക്കൽ ലേറ്റൻസി മിനിമം, പരമാവധി, ശരാശരി, സ്റ്റാൻഡേർഡ് ഡീവിയേഷൻ. ഇതാണ്
I/O സമർപ്പിക്കാൻ എടുത്ത സമയം.

ക്ലാറ്റ് പൂർത്തീകരണ ലേറ്റൻസി മിനിമം, പരമാവധി, ശരാശരി, സ്റ്റാൻഡേർഡ് ഡീവിയേഷൻ. ഈ
സമർപ്പണത്തിനും പൂർത്തീകരണത്തിനും ഇടയിലുള്ള സമയമാണ്.

bw ബാൻഡ്‌വിഡ്ത്ത് കുറഞ്ഞത്, പരമാവധി, ലഭിച്ച മൊത്തം ബാൻഡ്‌വിഡ്ത്തിന്റെ ശതമാനം,
ശരാശരി, സാധാരണ വ്യതിയാനം.

സിപിയു CPU ഉപയോഗ സ്ഥിതിവിവരക്കണക്കുകൾ. ഉപയോക്താവും സിസ്റ്റം സമയവും സന്ദർഭത്തിന്റെ എണ്ണവും ഉൾപ്പെടുന്നു
ഈ ത്രെഡ് കടന്നുപോയ സ്വിച്ചുകളും വലുതും ചെറുതുമായ പേജ് പിശകുകളുടെ എണ്ണം.

IO ആഴം
I/O ആഴങ്ങളുടെ വിതരണം. ഓരോ ആഴത്തിലും (അല്ലെങ്കിൽ
തുല്യം) അതിന്, എന്നാൽ മുമ്പത്തെ ആഴത്തേക്കാൾ വലുതാണ്.

IO ഇഷ്യൂചെയ്തു
ഇഷ്യൂ ചെയ്ത റീഡ്/റൈറ്റ് അഭ്യർത്ഥനകളുടെ എണ്ണം, ഹ്രസ്വമായ വായന/എഴുതുകളുടെ എണ്ണം
അഭ്യർത്ഥനകൾ.

IO കാലതാമസം
I/O പൂർത്തീകരണ ലേറ്റൻസികളുടെ വിതരണം. അക്കങ്ങളും അതേപടി പിന്തുടരുന്നു
പോലെ പാറ്റേൺ IO ആഴം.

ഗ്രൂപ്പ് സ്ഥിതിവിവരക്കണക്കുകൾ കാണിക്കുന്നത്:
io I/O നടത്തിയ മെഗാബൈറ്റുകളുടെ എണ്ണം.
aggrb ഗ്രൂപ്പിലെ ത്രെഡുകളുടെ മൊത്തം ബാൻഡ്‌വിഡ്ത്ത്.
minb ഒരു ത്രെഡ് സോയുടെ ഏറ്റവും കുറഞ്ഞ ശരാശരി ബാൻഡ്‌വിഡ്ത്ത്.
maxb ഒരു ത്രെഡ് സോയുടെ പരമാവധി ശരാശരി ബാൻഡ്‌വിഡ്ത്ത്.
പുതിന ഗ്രൂപ്പിലെ ത്രെഡുകളുടെ ഏറ്റവും കുറഞ്ഞ റൺടൈം.
പരമാവധി ഗ്രൂപ്പിലെ ത്രെഡുകളുടെ ഏറ്റവും ദൈർഘ്യമേറിയ റൺടൈം.

അവസാനമായി, ഡിസ്ക് സ്ഥിതിവിവരക്കണക്കുകൾ ആദ്യം റീഡുകൾ ഉപയോഗിച്ച് പ്രിന്റ് ചെയ്യുന്നു:
iOS എല്ലാ ഗ്രൂപ്പുകളും നടത്തുന്ന I/O-കളുടെ എണ്ണം.
ലയിപ്പിക്കുക I/O ഷെഡ്യൂളറിലെ ലയനങ്ങളുടെ എണ്ണം.
ടിക്കുകൾ ഞങ്ങൾ ഡിസ്കിനെ തിരക്കിലാക്കിയ ടിക്കുകളുടെ എണ്ണം.
io_ക്യൂ
ഡിസ്ക് ക്യൂവിൽ ചെലവഴിച്ച ആകെ സമയം.
യൂട്ടിലിറ്റി ഡിസ്ക് ഉപയോഗം.

കറന്റ് ഔട്ട്‌പുട്ട് പ്രവർത്തിക്കുമ്പോൾ അത് ഡംപ് ചെയ്യാൻ ഫിയോ ലഭിക്കാനും സാധ്യതയുണ്ട്
ജോലി അവസാനിപ്പിക്കുന്നു. അത് ചെയ്യുന്നതിന്, fio the അയയ്ക്കുക $1 സിഗ്നൽ.

ടെർസെ ഔട്ട്പ്

എങ്കില് --കുറഞ്ഞത് / --append-terse ഓപ്ഷനുകൾ നൽകിയിരിക്കുന്നു, ഫലങ്ങൾ അച്ചടിക്കും/അനുബന്ധിക്കും
സ്ക്രിപ്റ്റഡ് ഉപയോഗത്തിന് അനുയോജ്യമായ ഒരു അർദ്ധവിരാമ-ഡീലിമിറ്റഡ് ഫോർമാറ്റിൽ. ഒരു ജോലി വിവരണം (എങ്കിൽ
നൽകിയിരിക്കുന്നത്) ഒരു പുതിയ ലൈനിൽ പിന്തുടരുന്നു. വരിയിലെ ആദ്യ നമ്പർ പതിപ്പ് ആണെന്ന് ശ്രദ്ധിക്കുക
നമ്പർ. ചില കാരണങ്ങളാൽ ഔട്ട്പുട്ട് മാറ്റേണ്ടി വന്നാൽ, ഈ സംഖ്യ വർദ്ധിപ്പിക്കും
ആ മാറ്റത്തെ സൂചിപ്പിക്കാൻ 1 കൊണ്ട്. ഫീൽഡുകൾ ഇവയാണ്:

കഠിനമായ പതിപ്പ്, fio പതിപ്പ്, ജോലിയുടെ പേര്, ഗ്രൂപ്പായി, പിശക്

സ്റ്റാറ്റസ് വായിക്കുക:
ആകെ ഐ / ഒ (കെ.ബി), ബാൻഡ്വിഡ്ത്ത് (കെബി/സെ), ഐഒപിഎസ്, റൺടൈം (മിസ്)

സമർപ്പിക്കൽ കാലതാമസം:
മിനിറ്റ് പരമാവധി, അർത്ഥമാക്കുന്നത്, സാധാരണ വ്യതിയാനം
പൂർത്തീകരണ കാലതാമസം:
മിനിറ്റ് പരമാവധി, അർത്ഥമാക്കുന്നത്, സാധാരണ വ്യതിയാനം
പൂർത്തീകരണ ലേറ്റൻസി ശതമാനം (20 ഫീൽഡുകൾ):
Xth ശതമാനം=ഉപയോഗം
മൊത്തം ലേറ്റൻസി:
മിനിറ്റ് പരമാവധി, അർത്ഥമാക്കുന്നത്, സാധാരണ വ്യതിയാനം
ബാൻഡ്‌വിഡ്ത്ത്:
മിനിറ്റ് പരമാവധി, ആകെത്തുകയായുള്ള ശതമാനം of ആകെ, അർത്ഥമാക്കുന്നത്, സാധാരണ വ്യതിയാനം

നില എഴുതുക:
ആകെ ഐ / ഒ (കെ.ബി), ബാൻഡ്വിഡ്ത്ത് (കെബി/സെ), ഐഒപിഎസ്, റൺടൈം (മിസ്)

സമർപ്പിക്കൽ കാലതാമസം:
മിനിറ്റ് പരമാവധി, അർത്ഥമാക്കുന്നത്, സാധാരണ വ്യതിയാനം
പൂർത്തീകരണ കാലതാമസം:
മിനിറ്റ് പരമാവധി, അർത്ഥമാക്കുന്നത്, സാധാരണ വ്യതിയാനം
പൂർത്തീകരണ ലേറ്റൻസി ശതമാനം (20 ഫീൽഡുകൾ):
Xth ശതമാനം=ഉപയോഗം
മൊത്തം ലേറ്റൻസി:
മിനിറ്റ് പരമാവധി, അർത്ഥമാക്കുന്നത്, സാധാരണ വ്യതിയാനം
ബാൻഡ്‌വിഡ്ത്ത്:
മിനിറ്റ് പരമാവധി, ആകെത്തുകയായുള്ള ശതമാനം of ആകെ, അർത്ഥമാക്കുന്നത്, സാധാരണ വ്യതിയാനം

സി പി യു ഉപയോഗം:
ഉപയോക്താവ്, സിസ്റ്റം, സന്ദർഭം സ്വിച്ചുകൾ, പ്രധാന പേജ് തെറ്റുകൾ, പ്രായപൂർത്തിയാകാത്ത പേജ് തെറ്റുകൾ

IO ഡെപ്ത് വിതരണം:
<=1, 2, 4, 8, 16, 32, > = 64

IO ലേറ്റൻസി വിതരണം:
മൈക്രോസെക്കൻഡ്:
<=2, 4, 10, 20, 50, 100, 250, 500, 750, 1000
മില്ലിസെക്കൻഡ്:
<=2, 4, 10, 20, 50, 100, 250, 500, 750, 1000, 2000, > = 2000

ഡിസ്ക് ഉപയോഗം (ഉപയോഗിക്കുന്ന ഓരോ ഡിസ്കിനും 1):
പേര്, വായിക്കുക ios, എഴുതുക ios, വായിക്കുക ലയിക്കുന്നു, എഴുതുക ലയിക്കുന്നു, വായിക്കുക ടിക്കുകൾ, എഴുതുക
ടിക്കുകൾ, വായിക്കുക ക്യൂവിൽ സമയം, എഴുതുക ക്യൂവിൽ സമയം, ഡിസ്ക് ഉപയോഗം ശതമാനം

പിശക് വിവരം (continue_on_error-നെ ആശ്രയിച്ചിരിക്കുന്നു, ഡിഫോൾട്ട് ഓഫ്):
മൊത്തം # തെറ്റുകൾ, ആദ്യം പിശക് കോഡ്

ടെക്സ്റ്റ് വിവരണം (അങ്ങനെയെങ്കിൽ നൽകിയിരിക്കുന്നു in config - ദൃശ്യമാകുന്നു on പുതിയ വര)

ഉപയോക്താവ് / സെർവർ

സാധാരണയായി നിങ്ങൾ IO ഉള്ള മെഷീനിൽ ഒരു സ്റ്റാൻഡ്-എലോൺ ആപ്ലിക്കേഷനായി fio പ്രവർത്തിപ്പിക്കും
ജോലിഭാരം സൃഷ്ടിക്കണം. എന്നിരുന്നാലും, ഫ്രണ്ട് എൻഡും ബാക്കെൻഡും പ്രവർത്തിപ്പിക്കാനും സാധിക്കും
ഫിയോയുടെ പ്രത്യേകം. മെഷീനിൽ(കളിൽ) ഒരു ഫിയോ സെർവർ പ്രവർത്തിക്കുന്നത് ഇത് സാധ്യമാക്കുന്നു.
മറ്റൊരു മെഷീനിൽ നിന്ന് നിയന്ത്രിക്കുമ്പോൾ IO വർക്ക്ലോഡ് പ്രവർത്തിക്കുന്നിടത്ത്.

സെർവർ ആരംഭിക്കുന്നതിന്, നിങ്ങൾ ചെയ്യേണ്ടത്:

fio --server=args

ആ മെഷീനിൽ, ഫിയോ എന്താണ് കേൾക്കുന്നതെന്ന് ആർഗ്സ് നിർവ്വചിക്കുന്നു. വാദങ്ങൾ രൂപത്തിലാണ്
'type:hostname അല്ലെങ്കിൽ IP:port'. 'ടൈപ്പ്' ഒന്നുകിൽ TCP/IP v4-ന് 'ip' (അല്ലെങ്കിൽ ip4), TCP/IP-ക്ക് 'ip6'
v6, അല്ലെങ്കിൽ ഒരു പ്രാദേശിക യുണിക്സ് ഡൊമെയ്ൻ സോക്കറ്റിനായി 'സോക്ക്'. 'hostname' എന്നത് ഒരു ഹോസ്റ്റ്നാമം അല്ലെങ്കിൽ IP ആണ്
വിലാസം, കൂടാതെ 'പോർട്ട്' എന്നത് കേൾക്കാനുള്ള പോർട്ട് ആണ് (ടിസിപി/ഐപിക്ക് മാത്രമേ സാധുതയുള്ളൂ, പ്രാദേശിക സോക്കറ്റല്ല).
ചില ഉദാഹരണങ്ങൾ:

1) ഫിയോ --സെർവർ

സ്ഥിരസ്ഥിതി പോർട്ടിലെ (8765) എല്ലാ ഇന്റർഫേസുകളിലും ശ്രദ്ധിച്ചുകൊണ്ട് ഒരു ഫിയോ സെർവർ ആരംഭിക്കുക.

2) fio --server=ip:hostname,4444

ഒരു ഫിയോ സെർവർ ആരംഭിക്കുക, ഹോസ്റ്റ് നെയിമിന്റെ ഐപിയിലും പോർട്ട് 4444-ലും ശ്രവിക്കുക.

3) fio --server=ip6:::1,4444

IPv6 ലോക്കൽ ഹോസ്റ്റ് ::1-ലും പോർട്ട് 4444-ലും ശ്രവിച്ചുകൊണ്ട് ഒരു ഫിയോ സെർവർ ആരംഭിക്കുക.

4) ഫിയോ --സെർവർ=,4444

പോർട്ട് 4444-ലെ എല്ലാ ഇന്റർഫേസുകളിലും ശ്രദ്ധിച്ചുകൊണ്ട് ഒരു ഫിയോ സെർവർ ആരംഭിക്കുക.

5) fio --server=1.2.3.4

സ്ഥിരസ്ഥിതി പോർട്ടിൽ IP 1.2.3.4 ശ്രവിച്ചുകൊണ്ട് ഒരു ഫിയോ സെർവർ ആരംഭിക്കുക.

6) fio --server=sock:/tmp/fio.sock

ലോക്കൽ സോക്കറ്റിൽ /tmp/fio.sock ശ്രവിച്ചുകൊണ്ട് ഒരു ഫിയോ സെർവർ ആരംഭിക്കുക.

ഒരു സെർവർ പ്രവർത്തിക്കുമ്പോൾ, നിങ്ങൾക്ക് ഒരു ക്ലയന്റിൽ നിന്ന് അതിലേക്ക് കണക്റ്റുചെയ്യാനാകും. ക്ലയന്റ് ഇതുപയോഗിച്ച് പ്രവർത്തിക്കുന്നു:

fio --local-args --client=server --remote-args

എവിടെ --ലോക്കൽ-ആർഗ്സ് എന്നത് ക്ലയന്റ് പ്രവർത്തിക്കുന്നിടത്ത് പ്രാദേശികമായ ആർഗ്യുമെന്റുകളാണ്,
'സെർവർ' എന്നത് കണക്ട് സ്ട്രിംഗ് ആണ്, കൂടാതെ --remote-args ഒപ്പം എന്നതിലേക്ക് അയക്കുന്നു
സെർവർ. 'സെർവർ' സ്ട്രിംഗ് സെർവർ വശത്ത് ചെയ്യുന്ന അതേ ഫോർമാറ്റ് പിന്തുടരുന്നു, to
IP/ഹോസ്റ്റ്‌നെയിം/സോക്കറ്റ്, പോർട്ട് സ്ട്രിംഗുകൾ എന്നിവ അനുവദിക്കുക. നിങ്ങൾക്ക് ഒന്നിലധികം ക്ലയന്റുകളിലേക്കും കണക്റ്റുചെയ്യാനാകും,
അത് ചെയ്യാൻ നിങ്ങൾക്ക് പ്രവർത്തിപ്പിക്കാം:

fio --client=server2 --client=server2

ഫിയോ സെർവറിലാണ് ജോബ് ഫയൽ സ്ഥിതി ചെയ്യുന്നതെങ്കിൽ, ലോക്കൽ ലോഡ് ചെയ്യാൻ നിങ്ങൾക്ക് സെർവറിനോട് പറയാം
ഫയലും. --remote-config ഉപയോഗിച്ചാണ് ഇത് ചെയ്യുന്നത്:

fio --client=server --remote-config /path/to/file.fio

അപ്പോൾ ഫിയോ ഈ ലോക്കൽ (സെർവറിലേക്ക്) ജോബ് ഫയൽ ഒന്ന് കൈമാറുന്നതിന് പകരം തുറക്കും
ക്ലയന്റ്.

നിങ്ങൾക്ക് ധാരാളം സെർവറുകൾ ഉണ്ടെങ്കിൽ (ഉദാഹരണം: 100 VMs/കണ്ടെയ്‌നറുകൾ), നിങ്ങൾക്ക് ഒരു ഫയലിന്റെ പാത്ത് നെയിം നൽകാം
--client ഓപ്ഷന്റെ പാരാമീറ്റർ മൂല്യമായി ഹോസ്റ്റ് IP-കൾ/പേരുകൾ അടങ്ങിയിരിക്കുന്നു. ഉദാഹരണത്തിന്,
2 ഹോസ്റ്റ്നാമങ്ങൾ അടങ്ങുന്ന ഒരു ഉദാഹരണം "host.list" ഫയൽ ഇതാ:

host1.your.dns.domain
host2.your.dns.domain

അപ്പോൾ ഫിയോ കമാൻഡ് ഇതായിരിക്കും:

fio --client=host.list

ഈ മോഡിൽ, നിങ്ങൾക്ക് സെർവർ-നിർദ്ദിഷ്ട പാരാമീറ്ററുകൾ അല്ലെങ്കിൽ ജോബ് ഫയലുകൾ, കൂടാതെ എല്ലാ സെർവറുകൾ എന്നിവയും ഇൻപുട്ട് ചെയ്യാൻ കഴിയില്ല
അതേ ജോലി ഫയൽ സ്വീകരിക്കുക.

ഒന്നിലധികം ഹോസ്റ്റുകളിൽ നിന്നുള്ള പങ്കിട്ട ഫയൽസിസ്റ്റം ഉപയോഗിച്ച് fio --client റണ്ണുകൾ പ്രവർത്തനക്ഷമമാക്കുന്നതിന്,
fio --client ഇപ്പോൾ സെർവറിന്റെ IP വിലാസം ഫയൽനാമത്തിലേക്ക് മുൻകൂർ ചെയ്യുന്നു. ഉദാഹരണത്തിന്, എങ്കിൽ
fio ഡയറക്‌ടറി /mnt/nfs/fio ഉപയോഗിക്കുന്നു കൂടാതെ --client ഉപയോഗിച്ച് fileio.tmp എന്ന ഫയൽനാമം എഴുതുന്നു.
IP വിലാസങ്ങൾ 1 കൂടാതെ h2, h192.168.10.120 എന്നീ രണ്ട് ഹോസ്റ്റ്നാമങ്ങൾ അടങ്ങുന്ന hostfile
192.168.10.121, അപ്പോൾ ഫിയോ രണ്ട് ഫയലുകൾ സൃഷ്ടിക്കും:

/mnt/nfs/fio/192.168.10.120.fileio.tmp
/mnt/nfs/fio/192.168.10.121.fileio.tmp

AUTHORS

fio ജെൻസ് ആക്സ്ബോ എഴുതിയത്[ഇമെയിൽ പരിരക്ഷിച്ചിരിക്കുന്നു]>, ഇപ്പോൾ ജെൻസ് ആക്സ്ബോ[ഇമെയിൽ പരിരക്ഷിച്ചിരിക്കുന്നു]>.
ഈ മാൻ പേജ് എഴുതിയത് ആരോൺ കരോൾ ആണ്[ഇമെയിൽ പരിരക്ഷിച്ചിരിക്കുന്നു]> ഡോക്യുമെന്റേഷൻ അടിസ്ഥാനമാക്കി
ജെൻസ് ആക്സ്ബോ എഴുതിയത്.

റിപ്പോർട്ടുചെയ്യുന്നു ബഗുകൾ

എന്നതിലേക്ക് ബഗുകൾ റിപ്പോർട്ട് ചെയ്യുക fio അയക്കേണ്ട പട്ടിക[ഇമെയിൽ പരിരക്ഷിച്ചിരിക്കുന്നു]>. കാണുക വായിക്കുക.

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