പിവിഎസ്-സ്റ്റുഡിയോയുടെ സ്വതന്ത്ര അവലോകനം (ലിനക്സ്, സി++)

ലിനക്സിനു കീഴിൽ പിവിഎസ് വിശകലനം ചെയ്യാൻ പഠിച്ച ഒരു പ്രസിദ്ധീകരണം ഞാൻ കണ്ടു, അത് എന്റെ സ്വന്തം പ്രോജക്റ്റുകളിൽ പരീക്ഷിക്കാൻ തീരുമാനിച്ചു. അതിൽ നിന്ന് പുറത്തുവന്നതും ഇതാണ്.

ഉള്ളടക്കം

1. പുലി
2. Минусы
3. ഫലങ്ങൾ
4. Afterword

പുലി

പ്രതികരിക്കുന്ന പിന്തുണ

ഞാൻ ഒരു ട്രയൽ കീ അഭ്യർത്ഥിച്ചു, അവർ അത് അതേ ദിവസം എനിക്ക് അയച്ചു.

സാമാന്യം വ്യക്തമായ ഡോക്യുമെന്റേഷൻ

പ്രശ്‌നങ്ങളൊന്നുമില്ലാതെ അനലൈസർ സമാരംഭിക്കാൻ ഞങ്ങൾക്ക് കഴിഞ്ഞു. കൺസോൾ കമാൻഡുകൾക്കുള്ള സഹായവും ലഭ്യമാണ് (ഇവിടെ ചില പരാതികൾ ഉണ്ടെങ്കിലും, വിഭാഗം കാണുക Минусы).

മൾട്ടി-ത്രെഡഡ് വിശകലനത്തിന്റെ സാധ്യത

അനലൈസറിന് ഒരു "സ്റ്റാൻഡേർഡ്" ഓപ്ഷൻ ഉണ്ട് -j, നിരവധി ജോലികളിൽ സമാന്തരമായി വിശകലനം നടത്താൻ അനുവദിക്കുന്നു. ഇത് ധാരാളം സമയം ലാഭിക്കുന്നു.

നല്ല ദൃശ്യവൽക്കരണം

ടെക്‌സ്‌റ്റ് മുതൽ ഒരു ചെറിയ വെബ് മൂക്ക് വരെ നിരവധി വ്യത്യസ്ത ഔട്ട്‌പുട്ട് ഫോർമാറ്റുകൾ. വെബ് ഇന്റർഫേസ് സൗകര്യപ്രദവും സംക്ഷിപ്തവുമാണ്, കോഡിലെ വരികൾക്ക് അടുത്തുള്ള സൂചനകളും ഡയഗ്നോസ്റ്റിക് വിവരണങ്ങളിലേക്കുള്ള ലിങ്കുകളും ഉണ്ട്.

അസംബ്ലിയിൽ എളുപ്പമുള്ള സംയോജനം

എല്ലാ ഡോക്യുമെന്റേഷനും അവരുടെ വെബ്‌സൈറ്റിൽ ഉണ്ട്, നിങ്ങളുടെ പ്രോജക്റ്റ് CMake ഉപയോഗിച്ചാണ് നിർമ്മിച്ചതെങ്കിൽ, എല്ലാം വളരെ ലളിതമാണെന്ന് മാത്രമേ എനിക്ക് പറയാൻ കഴിയൂ.

നല്ല ഡയഗ്നോസ്റ്റിക് വിവരണങ്ങൾ

നിങ്ങൾ മോഡിൽ ഔട്ട്പുട്ട് സൃഷ്ടിക്കുകയാണെങ്കിൽ fullhtml, തുടർന്ന് ഓരോ സന്ദേശത്തിനും ഒരു ഡയഗ്നോസ്റ്റിക് വിവരണത്തിലേക്ക് ഒരു ലിങ്ക് ഉണ്ട്, വിശദീകരണങ്ങളും കോഡ് ഉദാഹരണങ്ങളും അധിക ലിങ്കുകളും.

Минусы

അനലൈസർ സി++ ഭാഷയെക്കുറിച്ചുള്ള അജ്ഞത

നിർഭാഗ്യവശാൽ, PVS ചിലപ്പോൾ വാക്യഘടന പിശകുകൾ വരുത്തുകയും കോഡ് പൂർണ്ണമായും ശരിയാകുമ്പോൾ തെറ്റായ പോസിറ്റീവ് സന്ദേശങ്ങൾ സൃഷ്ടിക്കുകയും ചെയ്യുന്നു.

ഉദാഹരണത്തിന്, തിരികെ നൽകുന്ന ഒരു ഫംഗ്ഷൻ ഉണ്ട് void:

template <typename T>
auto copy (const void * source, void * destination)
    ->
        std::enable_if_t
        <
            std::is_copy_constructible<T>::value
        >
{
    new (destination) T(*static_cast<const T *>(source));
}

അതെ എന്നതാണ് പ്രധാന വാക്ക് auto അർത്ഥമാക്കാം void, അതിനാണ് കാര്. എന്നാൽ പിവിഎസ് ഇനിപ്പറയുന്ന സന്ദേശങ്ങൾ നൽകി:

dynamic_tuple_management.hpp:29:1: error: V591 Non-void function should return a value.
dynamic_tuple_management.hpp:29:1: error: V2542 Function with a non-void return type should return a value from all exit paths.

വളരെ മന്ദഗതിയിലുള്ള സൈറ്റ്

അതെ, ഓരോ സന്ദേശത്തിനും അടുത്തുള്ള വെബ് ഇന്റർഫേസിൽ ഉദാഹരണങ്ങളുള്ള അനുബന്ധ ഡയഗ്നോസ്റ്റിക് വിവരണത്തിലേക്ക് ഒരു ലിങ്ക് ഉണ്ട്. എന്നാൽ നിങ്ങൾ ഒരു ലിങ്കിൽ ക്ലിക്കുചെയ്യുമ്പോൾ, നിങ്ങൾ വളരെക്കാലം കാത്തിരിക്കേണ്ടിവരും, ചിലപ്പോൾ അത് സംഭവിക്കും 504 ഗേറ്റ്‌വേ സമയം കഴിഞ്ഞു.

ഭാഷ

എല്ലാ വിവരണങ്ങളും റഷ്യൻ ഭാഷയിലാണ്, അത് മികച്ചതാണ്. എന്നാൽ റിപ്പോർട്ടിൽ നിന്നുള്ള ലിങ്കുകൾ എല്ലായ്പ്പോഴും ഇംഗ്ലീഷ് പതിപ്പിലേക്ക് നയിക്കുന്നു. ഭാഷ മാറ്റാൻ കഴിയുന്നത് നന്നായിരിക്കും, അതുവഴി നിങ്ങൾക്ക് റഷ്യൻ ഭാഷയിൽ ഉടനടി ഡയഗ്നോസ്റ്റിക്സ് കാണാൻ കഴിയും. ഇന്റർഫേസിൽ അത്തരമൊരു ഓപ്ഷൻ ഞാൻ കണ്ടെത്തിയില്ല.

കൺസോൾ വഴി ഡയഗ്നോസ്റ്റിക് ലെവലിൽ പ്രവർത്തിക്കുന്നത് അസൗകര്യമാണ്

രണ്ട് കമാൻഡുകൾ ഉപയോഗിച്ചുവെന്ന വസ്തുതയിൽ നിന്ന് നമുക്ക് ആരംഭിക്കാം (ഇത് pvs-studio-analyzer и plog-converter) ഡയഗ്നോസ്റ്റിക്സ് വ്യക്തമാക്കുന്നതിനുള്ള വ്യത്യസ്ത ഫോർമാറ്റുകൾ.

വേണ്ടി സഹായം pvs-studio-analyzer വായിക്കുന്നു:

-a [MODE], --analysis-mode [MODE]
    MODE defines the type of warnings:
    1 - 64-bit errors;
    2 - reserved;
    4 - General Analysis;
    8 - Micro-optimizations;
    16 - Customers Specific Requests;
    32 - MISRA.
    Modes can be combined by adding the values
    Default: 4

എങ്ങോട്ട് പോകണം എന്നറിയാൻ ഞാൻ ഒരുപാട് നേരം ശ്രമിച്ചു ചേർക്കുക ("മൂല്യങ്ങൾ ചേർക്കുന്നു") കീകൾ. ഞാൻ അവയെ കോമകളാൽ വേർതിരിച്ച് പട്ടികപ്പെടുത്താൻ ശ്രമിച്ചു:

pvs-studio-analyzer analyze ... -a 1,4,16

ഞാൻ പലതവണ കീ രജിസ്റ്റർ ചെയ്യാൻ ശ്രമിച്ചു:

pvs-studio-analyzer analyze ... -a 1 -a 4 -a 16

അപ്പോഴാണ് എനിക്ക് മനസ്സിലായത് ഇവ ബിറ്റ് മാസ്കുകളാണെന്ന്! നിങ്ങൾക്ക് ആവശ്യമുണ്ട് സംഗ്രഹംപക്ഷേ ഇല്ല ചേർക്കുക അർത്ഥങ്ങൾ. ഉദാഹരണത്തിന്, പൊതുവായ ഡയഗ്നോസ്റ്റിക്സ്, മൈക്രോ ഒപ്റ്റിമൈസേഷനുകൾക്കുള്ള ഡയഗ്നോസ്റ്റിക്സ്, മിസ്ര എന്നിവ ലഭിക്കുന്നതിന്, നിങ്ങൾ അവ സംഗ്രഹിക്കേണ്ടതുണ്ട് (4 + 8 + 32 = 44):

pvs-studio-analyzer analyze ... -a 44

ഉപയോക്തൃ ഇന്റർഫേസുകളിൽ ബിറ്റ്മാസ്കുകൾ ഉപയോഗിക്കുന്നത് പൊതുവെ മോശം രൂപമാണ്. ഇതെല്ലാം ആന്തരികമായി സംഗ്രഹിക്കാം, കൂടാതെ ഉപയോക്താവിനായി ഒരു കൂട്ടം ഫ്ലാഗുകൾ സജ്ജീകരിക്കാം.

കൂടാതെ, ഒരു യൂട്ടിലിറ്റിയും ഉണ്ട് plog-converter, ഇത് മനുഷ്യർക്ക് വായിക്കാൻ കഴിയുന്ന സ്റ്റാറ്റിക് വിശകലന വിവരങ്ങൾ സൃഷ്ടിക്കുന്നു. അവൾക്ക് വേറെയും പ്രശ്നങ്ങളുണ്ട്.

പ്രോഗ്രാമിനുള്ള സഹായം plog-converter റിപ്പോർട്ടുകൾ:

-a, --analyzer            Specifies analyzer(s) and level(s) to be
                          used for filtering, i.e.
                          'GA:1,2;64:1;OP:1,2,3;CS:1;MISRA:1,2'
                          Default: GA:1,2

മുമ്പ് ഇല്ലാതിരുന്ന ചില "ലെവലുകൾ" ഇവിടെ പ്രത്യക്ഷപ്പെട്ടു, ഡോക്യുമെന്റേഷനിൽ അവയെക്കുറിച്ച് ഒന്നും ഞാൻ കണ്ടെത്തിയില്ല.

പൊതുവേ, അത് വ്യക്തമല്ല. അതുകൊണ്ടാണ് ഞാൻ എല്ലാം പരമാവധി സജ്ജമാക്കിയത്.

ക്യാച്ചിൽ ഒരു കൂട്ടം മണ്ടത്തരങ്ങൾ

ഞാൻ വിശകലനം ചെയ്ത മൂന്ന് പ്രോജക്റ്റുകളിൽ രണ്ടെണ്ണം ഒരു യൂണിറ്റ് ടെസ്റ്റിംഗ് ലൈബ്രറി ഉപയോഗിക്കുന്നു Catch2. സന്ദേശങ്ങളുടെ സിംഹഭാഗവും (!!! ഒന്നിൽ 90 ൽ 138 ഉം മറ്റൊന്നിൽ 297 ൽ 344 ഉം!!!) ഇനിപ്പറയുന്ന ഫോം ഉണ്ട്:

മൾട്ടിത്രെഡിംഗ് കണക്കിലെടുക്കുന്നില്ല

മാറ്റമില്ലാത്ത വേരിയബിളുകളെക്കുറിച്ചോ അനന്തമായ ലൂപ്പുകളെക്കുറിച്ചോ ധാരാളം തെറ്റായ പോസിറ്റീവുകൾ ഉണ്ട്, അതേസമയം ഈ വേരിയബിളുകൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നത് വ്യത്യസ്ത ത്രെഡുകളിൽ നിന്നാണ്, ഇത് അങ്ങനെയല്ലെങ്കിൽ, യൂണിറ്റ് ടെസ്റ്റുകൾ പ്രവർത്തിക്കില്ല.

എന്നിരുന്നാലും, ഒരു സ്റ്റാറ്റിക് അനലൈസറിന് ഇത് കണക്കിലെടുക്കാൻ കഴിയുമോ? അറിയില്ല.

ഫലങ്ങൾ

എന്റെ ഓപ്പൺ സോഴ്സ് പ്രോജക്റ്റുകളിൽ PVS യഥാർത്ഥ ബഗുകളൊന്നും കണ്ടെത്തിയില്ല ബഴ്സ്റ്റ് и പ്രോക്സിമ, അതുപോലെ ഒരു വർക്കിംഗ് ഡ്രാഫ്റ്റിൽ, വ്യക്തമായ കാരണങ്ങളാൽ, എനിക്ക് അവതരിപ്പിക്കാൻ കഴിയില്ല. ശരിയാണ്, ചില പോരായ്മകൾ ഇതിനകം തന്നെ പിടികൂടി നേരത്തെ തന്നെ ശരിയാക്കിയിട്ടുണ്ട് എന്നത് ഓർമിക്കേണ്ടതാണ് Cppcheck и scan-build.

പൊതുവേ, ഈ അനലൈസറുകളിൽ നിന്നുള്ള മതിപ്പ് ഏകദേശം സമാനമാണ്: അതെ, അവർ എന്തെങ്കിലും പിടിക്കുന്നു, ചിലപ്പോൾ പ്രധാനപ്പെട്ട എന്തെങ്കിലും പോലും, എന്നാൽ മൊത്തത്തിൽ കംപൈലർ മതിയാകും.

ഞങ്ങളുടെ ടീം സോഫ്‌റ്റ്‌വെയർ ഡെവലപ്‌മെന്റ് രീതികൾ ഉപയോഗിക്കുന്നത് സാധ്യമാണ് (എനിക്ക് വ്യക്തിപരമായി അങ്ങനെ ചിന്തിക്കാൻ ഇഷ്ടമാണ്) കുറഞ്ഞ അളവിലുള്ള വൃത്തികെട്ട കോഡ് സൃഷ്‌ടിക്കാൻ ഞങ്ങളെ അനുവദിക്കുന്നു. വീരോചിതമായി അവയെ മറികടക്കുന്നതിനേക്കാൾ നല്ലത് പ്രശ്നങ്ങൾ സൃഷ്ടിക്കാതിരിക്കുന്നതാണ്.

അതുകൊണ്ട്, ആരുടെയും കാലിൽ നിന്ന് വെടിയുകയോ നെറ്റിയിൽ ഒരു റേക്ക് കൊണ്ട് അടിക്കുകയോ ചെയ്യാത്ത വിധത്തിൽ C++ ൽ എങ്ങനെ എഴുതാം എന്നതിനെക്കുറിച്ച് ചില ഉപദേശങ്ങൾ നൽകാനുള്ള സ്വാതന്ത്ര്യം ഞാൻ എടുക്കുന്നു.

കംപൈലർ ഡയഗ്നോസ്റ്റിക്സ് പരമാവധി പ്രയോജനപ്പെടുത്തുക

ഞങ്ങളുടെ ടീം ഇനിപ്പറയുന്ന സമാഹാര ഓപ്ഷനുകൾ ഉപയോഗിക്കുന്നു (നിങ്ങളെ ഉപദേശിക്കുന്നു):

-Werror

-Wall
-Wextra
-Wpedantic

-Wcast-align
-Wcast-qual
-Wconversion
-Wctor-dtor-privacy
-Wenum-compare
-Wfloat-equal
-Wnon-virtual-dtor
-Wold-style-cast
-Woverloaded-virtual
-Wredundant-decls
-Wsign-conversion
-Wsign-promo

നിങ്ങളുടെ പ്രോജക്റ്റിൽ അവ പ്രവർത്തനക്ഷമമാക്കുകയും നിങ്ങളുടെ കോഡിനെ കുറിച്ച് ധാരാളം പഠിക്കുകയും ചെയ്യുക.

നിലവാരം പുലർത്തുക

സ്റ്റാൻഡേർഡ് അനലോഗുകൾ ഉണ്ടെങ്കിൽ പ്ലാറ്റ്‌ഫോം-ആശ്രിത കാര്യങ്ങൾ ഉപയോഗിക്കാതിരിക്കാൻ ശ്രമിക്കുക, അവ കൂടാതെ നിങ്ങൾക്ക് ചെയ്യാൻ കഴിയുന്നില്ലെങ്കിൽ, അവയെ മാക്രോകൾക്കായി (അല്ലെങ്കിൽ മറ്റെന്തെങ്കിലും) പ്രത്യേക ബ്ലോക്കുകളിൽ പൊതിയുക, പിന്തുണയില്ലാത്ത സാഹചര്യങ്ങളിൽ നിങ്ങളുടെ കോഡ് കംപൈൽ ചെയ്യാൻ അനുവദിക്കരുത്.

സ്റ്റാൻഡേർഡ് ഓപ്പറേഷൻ സെമാന്റിക്സിൽ ഉറച്ചുനിൽക്കുക

കൂട്ടിച്ചേർക്കൽ സങ്കലനമായിരിക്കണം, ഗുണനം ഗുണനമായിരിക്കണം, ഫംഗ്‌ഷൻ കോൾ ഫംഗ്‌ഷൻ കോൾ ആയിരിക്കണം, പകർപ്പ് പകർപ്പായിരിക്കണം, കൊണ്ടുപോകണം, കൊണ്ടുപോകണം, കണ്ടെയ്‌നർ ആവർത്തിക്കാവുന്നതായിരിക്കണം, ഇറ്ററേറ്ററിന് പ്രമോഷൻ ഉണ്ടായിരിക്കണം ++ ഒപ്പം dereferencing *. അങ്ങനെ പലതും.

ആശയം വ്യക്തമാണെന്ന് ഞാൻ കരുതുന്നു. ബൈൻഡിംഗ് അല്ലാത്ത, എന്നാൽ നിങ്ങളുടെ കോഡിന്റെ എല്ലാ ഉപയോക്താക്കളും വായനക്കാരും കാണാൻ പ്രതീക്ഷിക്കുന്ന സ്ഥാപിത കൺവെൻഷനുകളുണ്ട്. മറ്റുള്ളവരെ മറികടക്കാൻ ശ്രമിക്കരുത്, അല്ലാത്തപക്ഷം നിങ്ങൾ സ്വയം മറികടക്കും.

അനുയോജ്യമായ കോഡ് എഴുതുക

ഒന്നാമതായി, ഞാൻ ഉദ്ദേശിക്കുന്നത് സാധാരണ ലൈബ്രറിയാണ്. നിങ്ങളുടെ ക്ലാസുകളുടെയും ഫംഗ്‌ഷനുകളുടെയും ഇന്റർഫേസുകൾ സ്റ്റാൻഡേർഡ്, മറ്റ് ലൈബ്രറികൾ (ഉദാഹരണത്തിന്, ബൂസ്റ്റ്) ഉപയോഗിച്ച് ഉപയോഗിക്കാൻ കഴിയുന്നത് വളരെ അഭികാമ്യമാണ്.

STL, ബൂസ്റ്റ് ഇന്റർഫേസുകൾ നോക്കാൻ മടിക്കേണ്ടതില്ല. അപൂർവമായ ഒഴിവാക്കലുകളോടെ, യോഗ്യനായ ഒരു റോൾ മോഡൽ നിങ്ങൾ അവിടെ കാണും.

ഓപ്പൺ സോഴ്‌സ് ടൂളുകൾ പരമാവധി പ്രയോജനപ്പെടുത്തുക

ഒരേ സ്റ്റാറ്റിക് വിശകലനത്തിനായി, CMake ബിൽഡ് സിസ്റ്റം ഉപയോഗിച്ച് ഏത് പ്രോജക്റ്റിലേക്കും ഒരു തവണ മാത്രം ബന്ധിപ്പിക്കാൻ കഴിയുന്ന രണ്ട് ഓപ്പൺ ഫ്രീ ടൂളുകളെങ്കിലും ഉണ്ട്.

എന്റെ സമീപകാല പ്രസിദ്ധീകരണത്തിൽ നിങ്ങൾക്ക് ഇതിനെക്കുറിച്ച് കൂടുതൽ വായിക്കാം.

Afterword

അവസാനമായി, PVS അല്ലെങ്കിൽ മറ്റേതെങ്കിലും സ്റ്റാറ്റിക് അനലൈസറുകൾ ഉപയോഗിക്കരുതെന്ന് ഞാൻ വാദിക്കുന്നില്ലെന്ന് ഊന്നിപ്പറയാൻ ഞാൻ ആഗ്രഹിക്കുന്നു. എന്നാൽ സ്റ്റാറ്റിക് അനലൈസർ നിങ്ങളുടെ കോഡിൽ കാര്യമായ പിശകുകൾ നിരന്തരം കണ്ടെത്തുന്നത് എങ്ങനെയെന്ന് ചിന്തിക്കാൻ ഞാൻ നിങ്ങളെ പ്രോത്സാഹിപ്പിക്കുന്നു.

ഇതൊരു അനന്തരഫലം മാത്രമാണ്. കാരണം കണ്ടെത്തുകയും ഇല്ലാതാക്കുകയും വേണം.

അവലംബം: www.habr.com