Daha çox

Python ilə əlaqəli bir şey Masaüstü üçün ArcGIS-də qəzaya səbəb olur?


Problem: ArcMap 10.3, Python ilə əlaqəli bir işlətdiyim zaman (Toolboxes, Field Calulator, və s.) Masaüstünə çökür.

Bu nöqtəyə necə gəldim: Python proqramlaşdırma ilə bir az tanış olmaq üçün çalışırdım və Learn Python The Hard Way təlimatından istifadə etməyi seçdim.
Bu, Python-un yüklənməsini, quraşdırılmasını və Powershell-dən istifadə edərək mühitin qurulmasını əhatə edirdi.
ArcGIS-in quraşdırılmasından etibarən Python quraşdırılması artıq olduğundan bu bəzi problemlərə səbəb olduğuna inanıram. Əsas HDD-də artıq bir "Python27" qovluğu var idi.

Sual: ArcMap-a Python üçün "Python27 ArcGIS10.3" qovluğuna baxmasını necə deyə bilərəm? ArcGIS-in tamamilə yenidən qurulmasının qarşısını almaq istərdim.

Düşünmək üçün ekran görüntüləri:

^ İlkin araşdırmalardan bu sahələrə bir növ Python kataloqu daxil etməyim lazım olduğunu gördüm, amma oraya nəyin girməsi lazım olduğuna əmin deyiləm.


Problemi həll etmək üçün aşağıdakıları etdim:

  • ArcGIS10.3 qovluğum xaricində olan Python əlavə yükləmələri / nümunələri silindi.
  • "Python'u Hard Way Öyrən" bölümündəki addımları izləyərək "Python27 ArcGIS10.3" -ə ​​baxmasını söyləyərək mühitimi sıfırlayın.
  • ArcGIS Desktop üçün əsas qovluqdakı Quraşdırma tətbiqindən "Təmir Proqramı" istifadə edilmişdir

Şeylər indi stabil və işlək görünür.


PyQt5 - Palette / StyleSheet dəyişiklikləri, eventFilter istifadə edərək proqramın çökməsinə səbəb olur

PyQt5 istifadə edərək Windows 'kalkulyatorunu təqlid etməyə çalışdım. Xüsusi bir pəncərə sərhədi kimi istifadə etdiyim QLabeldəki mətnin rəngini dəyişdirməyim lazım olan bir nöqtəyə gəldim (şəffaflıq kimi şeylərə icazə vermək üçün).

QEvent və eventFilter kimi şeyləri sınamağa və qara rəng çalarları ilə şəffaf rəng ilə şəffaf olmayan arasında keçmək üçün isActiveWindow kimi metodlardan istifadə etməyə başladım.

Bunu edərək, arxa planın mükəmməl şəkildə dəyişdiyi bir mərhələyə çatdım, amma çalışdığım andan QLabel / Text-i qarışığa əlavə etdim, proqram müxtəlif nöqtələrdə çökür. Harada və nə üçün olduğunu və konsoldan istifadə edərək "Prosedur çıxış kodu ilə tamamlandı -1073740791 (0xC0000409)" yazdırdığımı yaza bilmədim.

Həm də bunun niyə baş verdiyinə dair hazırkı məlumat və təcrübəm üçün açıq bir şey tapa bilmədim. İndiyə qədər YouTube, Google və mövcud StackOverflow məzmunu məni azdırdı. :(

Lütfən, proqramlaşdırma, Python və daha da çox PyQt5 üçün yeni olduğumu nəzərə al.


Fayl adı istifadəçi tərəfindən idarə olunarsa, özünüzü zəifliklərə görə aça bilərsiniz (məsələn, təcavüzkar verilənlər bazası parolu ilə konfiqurasiya sənədlərini oxumağa cəhd edə bilər). Ancaq yüklənmiş bir fayl üçün yalnız bir fayl sapı açmaq çox şey edə bilməz.

Bəlkə də əsas mexanizm buferləşdirmə məqsədi ilə bütün faylı oxumağa çalışsaydı, RAM-i doldura və prosesi çökə bilər, lakin Python bunu etmir: bütün faylı oxumaq üçün əvvəlcə f.read ( ) - ancaq bununla etdiyiniz və dosyanı açmamağınızdır. Yalnız sənədin açılması zərərsizdir.

Əməliyyat sistemlərində ümumiyyətlə bir anda aça biləcəkləri məhdud sayda fayl var (xüsusən məhdud sayda fayl təsvirçiləri və ya Unix kimi sistemlərdə fd və ya Windows-da HANDLE). İnsanlara bunları bağlamadan təsadüfən bir sayını açmalarına icazə verərsənsə, OS-nin daha çox fayl açmasına mane olacaq və bəlkə də səhv davranmasına və ya qəzaya uğramasına səbəb olan bu həddi boşaltmaq mümkün ola bilər. Buna baxmayaraq xidmətdən imtina etməkdən başqa bir şey üçün istifadə etmək çətin olardı. Ayrıca, proqramlarda neçə fayl aça biləcəyi (sistem limitindən aşağı) kvotalar ola bilər, buna görə tək bir səhv davranış proqramı çox iş görə bilmədi və prosesin bütün sənədləri proses normal çıxdıqda sərbəst buraxılır funksiyanı bərpa etmək üçün kifayətdir (həqiqətən, əksər proqramlar çoxdan özlərini qəzaya salacaqdı).

Yenə də insanların serverinizə bir sənəd açmasını söylədiyiniz təqdirdə, birdən çoxunun açıla biləcəyinə dair bir məhdudiyyətin olması və faylın bağlanması (istifadəçi təlimat vermirsə, avtomatik olaraq) yaxşı olardı əvvəl baş vermək) mümkün qədər qısa müddətdən sonra.

Başqa bir risk, hansı OS üzərində işlədiyinizə və hansı yol növlərini qəbul etdiyinə görə şəbəkə əlaqələrinin açılması ola bilər. Məsələn, sistem Windows şəbəkə tərzi yollarını ( server share path to file) və ya SMB (Samba alət dəstindəki Unix-like-larda tətbiq olunan Windows şəbəkə protokolu) yollarını qəbul edirsə (smb: // server / paylaşma / yol) və ya serverinizin şəbəkə bağlantısı açmasına səbəb ola biləcək yerli fayl sisteminə hələ quraşdırılmamış (və ya köhnə Windows terminini istifadə etmək üçün "uyğunlaşdırılan") hər hansı bir şəbəkə fayl sisteminə daxil olmaq üçün digər yollar bir təcavüzkarın qutusuna və bəlkə də kimliyini təsdiqləməyə çalışın. Bu, server haqqında məlumatları aşkar edə bilər və təcavüzkarların zərərli cavablar yolu ilə serverə güzəşt etməyə çalışması üçün bir vektor təmin edə bilər.

Beləliklə, fayl adlarını uzaq yollar olmadığına əmin ola biləcəyiniz şeylərlə məhdudlaşdırmalısınız. Ümumiyyətlə, ehtimal ki, yolların yalnız fayl adlarına icazə verilməsinə icazə verilməməlidir. Ancaq düşünə biləcəyim iki risk bunlardır. Əks təqdirdə, olduqca təhlükəsizdir.


VS Kodu 17.10, 18.04 təsadüfi və tamamilə dondurulmasına səbəb olur

Zəhmət olmasa oxu: Son bitə baxın. Bunun Ubuntu ilə əlaqəli bir məsələ olduğuna inanmıram, əksinə VS Kodu.

Bu yaxınlarda, 17.10-dan aşağı 18.04 (bu gün yenilədim), Ubuntu təsadüfi və tamamilə donacaq. Kursoru hərəkət etdirə bilmirəm və ya klaviaturadan istifadə edə bilmirəm. Təbii ki, bir TTY seansına heç bir uğurla keçməyə çalışdım. Hər dəfə SysRq + R E I S U B-yə müraciət etməliyəm, buna üstünlük verilmir.

Bu ola biləcəyi nəzəriyyəsi ilə qrafik sürücülərini dəyişdirməyə çalışdım. Əvvəlcə açıq mənbəli nVidia sürücüsünü istifadə edirdim və heç bir nəticə vermədən mülkiyyətə keçdim. Hazırda açıq mənbə sürücüsündən istifadə edirəm.

Tipik olaraq açdığım hər şey Firefoxdur (bir ton sekmə deyil) yükləndi) və VS Kodu, ən çox bir neçə fayl və bir terminal açıqdır.

Yeniləmə: Sistem qeydlərində heç bir əlamət yoxdur bir şey heç olmasa, səhv bir şey olsun. Bunun əlaqəli olub olmadığını bilmirəm, amma bəzən (və xüsusən önyükləndikdən sonra) proqramlar, hətta komanda xətti proqramları üçün əhəmiyyətli bir vaxt (> 5-10 saniyə) çəkir.

Yenə bir yeniləmə! - Bütün GNOME uzantıları əlil olsa belə, yenə də çökdü. Hələ də qəzaya uğrayan XFCE-ni sınadım.

Xülasə: Ubuntu təsadüfi görünən zamanlarda tamamilə donur və qeydlərdə heç bir iz qoymur və hər hansı bir xüsusi masa üstü mühiti və ya GNOME uzantıları ilə əlaqəli deyil.

(ehtimal ki, son) yeniləmə: Bunun VS Kodu ilə bağlı bir problem olduğuna əminəm. Günlərdir GNOME işlədirəm, digər Electron tətbiqləri açıqdır (Slack, Pulse, və s.) Və bir dəfə də dondurmamışam. Twitter-də VS kodum var, və hələ cavab vermədikləri üçün bir səhv hesabatı yazacağam.


Panelistlər cavab verir:

Tyler Gakstatter

Python ilə əlaqəli bir şey Desktop for ArcGIS-də qəzaya səbəb olur? - Coğrafi İnformasiya Sistemləri

TSTL: Şablon Ssenarisi Test Dili

TSTL, domen üçün spesifik bir dildir (DSL) və proqram üçün testlərin avtomatlaşdırılmış şəkildə yaradılmasını dəstəkləyən alətlər dəstidir. Bu tətbiq Python'u hədəf alır. Siz (Python-da) bir test yaratmaq üçün istifadə olunan bir sıra komponentləri və test edilmiş sistem üçün saxlamaq istədiyiniz xüsusiyyətləri təyin edirsiniz və TSTL sisteminiz üçün testlər yaradırsınız. TSTL testin təkrar oynatılmasını, testin azaldılmasını və kodun əhatə dairəsinin analizini dəstəkləyir və bəzi inkişaf etmiş test nəsil metodları üçün düymə dəstəyi daxildir. Başqa sözlə, TSTL a əmlak əsaslı test alət.

Mülkiyyətə əsaslanan test nədir? Mülkiyyətə əsaslanan test, xüsusi girişlər və ya zəng ardıcıllığı üçün nəticələr göstərən inkişaf etdiricilərə deyil, daha çox ümumi davranış spesifikasiyasına əsaslanan testdir və ümumi spesifikasiyanın mövcud olduğundan əmin olmaq üçün bir çox testin avtomatik istehsalı ilə birləşdirilir. Mülkiyyətə əsaslanan testlər haqqında daha çox məlumat üçün baxın:

https://github.com/trailofbits/deepstate (simvolik təhlili qarışdıran və mülkə əsaslanan testlərlə qarışıq olan bir vasitədir, dizaynı TSTL-dən bir qədər məlumat alan C və C ++ üçün)

Ən son tstl-i pip istifadə edərək ən asanlıqla əldə edə bilərsiniz. pip install tstl yaxşı işləməlidir. Daha yaxın bir şey istəyirsinizsə, edə bilərsiniz:

Kod əhatə dairəsi üçün Ned Batchelder-in əhatə dairəsini də qurmalısınız.

TSTL-nin necə işlədiyi barədə bir fikir əldə etmək üçün bir oyuncaq nümunəsini sınayaq. TSTL-dən istifadə edərək sadə bir "tapmacanı" həll etmək üçün 510 tam dəyərini yalnız bir neçə satır Python kodundan istifadə edərək, yalnız kiçik bir əməliyyat dəstindən istifadə etmək mümkün olub olmadığını yoxlamaq üçün istifadə edəcəyik (4 əlavə et, 3 çıxart, 3-ə vur, və 0-dan başlayaraq iki) güc istehsal edin.

Normal Pythonda olduğu kimi # bir şərhi göstərir. Şərh sətirləri təsvir olunan TSTL kodunun altındadır.

Bu, bir neçə saniyədə mülkü pozmağın bir yolunu tapmalı (510 dəyərini çıxarın), bu "uğursuz testin" maksimal dərəcədə sadə bir versiyasını tapmalı və testi ehtiva edən bir nutrell.test faylı hazırlamalıdır. Əgər buraxmış olsaydıq TSTL ya 510 istehsal etmək üçün bir yol tapmış olardı, ya da (daha az ehtimal) güc çağırışında bir daşqın istehsal etmək üçün bir yol tapmış olardı: ya bir uğursuzluq olaraq qəbul ediləcəkdi.

Bu, yeni yaratdığınız testi yenidən oxuyacaq.

TSTL-nin əsas ideyası, bir testdə bir sıra mümkün addımların və bir test uğursuzluğu hesab edilə bilən xüsusiyyətləri izah edən xüsusiyyətlərin müəyyənləşdirilməsidir və TSTL-də bir test uğursuzluğuna səbəb olacaq bir sıra hərəkətlərin olub olmadığını öyrənməlidir. Əməliyyatlar funksiya və ya metod çağırışları və ya giriş məlumatlarını yığan addımlar ola bilər (məsələn, təhlilçiyə keçmək üçün bir sətir qurmaq) və ya həqiqətən, Python ilə edə biləcəyiniz hər şey.

TSTL bir neçə standart alət quraşdırır: TSTL kompilyatoru özü, tstl təsadüfi bir test generatoru tstl_rt bağımsız testlər istehsal etmək üçün bir vasitə, tstl_standalone TSTL test sənədlərini təkrar oynatmaq üçün bir vasitə, tstl_replay üçün TSTL testlərinin düzəldilməsi və normallaşdırılması üçün bir vasitə, tstl_reduce və a bir sıra testləri reqressiya, tstl_regress kimi aparmaq üçün vasitədir.

Lazım olanların çoxunu yalnız tstl, tstl_rt, tstl_replay və tstl_reduce əmrləri ilə edə bilərsiniz.

  • tstl & ltfilename.tstl & gt .tstl faylını test üçün sut.py interfeysinə yığır.
  • tstl_rt cari qovluqdakı sut.py-də təsadüfi test aparır və aşkar edilmiş səhvləri .test fayllarına atır
  • tstl_replay & ltfilename.test & gt yadda saxlanmış bir TSTL testini keçirir və --verbose ilə keçib uğursuz olub olmadığını bildirir, testin icrasının kifayət qədər ətraflı izini verir.
  • tstl_reduce & ltfilename.test & gt & ltnewfilename.tstl & gt & ltfilename.test & gt, daha qısa, daha asan başa düşülən test istehsal etmək üçün üzərində azalma və normallaşdırma işləyir və çıxışı & ltnewfilename.tstl & gt kimi saxlayır.

Bütün bu alətlər çox sayda konfiqurasiya seçimi təklif edir - kömək bütün TSTL alətləri üçün dəstəklənən seçimlərin siyahısını hazırlayacaqdır.

TSTL-ni başa düşməyin ən asan yolu nümunələri yoxlamaq ola bilər / AVL / avlnew.tstl (https://github.com/agroce/tstl/blob/master/examples/AVL/avlnew.tstl). son dil formatı.

avlnew.tstl bir AVL ağac sinfi üçün olduqca tam xüsusiyyətli bir test cihazı yaradır. Yalnız bir neçə kod sətri ilə çox sürətli və kifayət qədər təsirli bir şey yaza bilərsiniz:

Bu, AVL ağac tətbiqetmə testimizdə iki növ "şey" in olduğunu söyləyir: int və avl. Python'da bu şeyləri necə yaratacağımızı və bunlarla nə edə biləcəyimizi təyin edirik və sonra TSTL hərəkət ardıcıllığı yaradır, yəni testlər, bu bizim tərifimizə uyğun gəlir. TSTL, bütün AVL ağaclarının hər zaman düzgün balanslaşdırıldığını da yoxlayır. İstəsəydik, avlnew.tstl-də olduğu kimi, AVL ağacımızın bir dəstin "kimi" işlədiyinə də əmin ola bilərik --- bir şey əlavə etdikdə o şeyi tapa bilərik və bir şeyi sildikdə artıq tapa bilmərik o.

Avl modulunu, SUT-u idxal etmək üçün "xam Python" ilə başladığımızı unutmayın. TSTL idxalda, taxma adlardan və joker işarələrdən istifadəni dəstəkləsə də, sınaqdan keçirilmiş modulları həmişə sadə bir idxal ilə idxal etməlisiniz. Bu, TSTL-nin test ediləcək kodu müəyyənləşdirməsinə və avtomatik olaraq əhatə dairəsini, statik analiz dəstəkli test metodlarını və düzgün modul idarə edilməsini təmin edir. Digər tərəfdən standart kitabxanadakı kommunal kodu istədiyiniz şəkildə idxal edilə bilər.

Bunu (və ya avlnew.tstl) 30 saniyə sınasaq, belə bir şey görünəcək:

/ tstl / sample / AVL $ tstl_rt --timeout 30

Bir çox (lakin hamısı deyil!) Proqramları üçün sadə təsadüfi testlərə daha güclü alternativ, hər bir fərdi testdəki hərəkətləri məhdudlaşdıran sürü testindən istifadə etməkdir (məsələn, əlavə edin, ancaq silin və ya inorder keçidləri tapın, lakin yoxdur) (bax http : //agroce.github.io/issta12.pdf).

Burada metod çox vacib deyil sadə təsadüfi testlər yalnız 60 saniyədə AVL ağac kodunu əhatə edən layiqli bir iş görür. Avl.py-nin 205 sətrindəki self.rebalance () çağırışını qaldıraraq bir səhv təqdim etsək, hər iki metod da avtomatik olaraq azaldılmış uğursuz bir test vəziyyətini bildirəcəkdir. Varsayılan olaraq, təsadüfi test cihazı, uğursuzluğa səbəb olan icra zamanı nə baş verdiyini daha ətraflı göstərmək üçün testi geniş bir rejimdə aparacaqdır.

--Output istifadə edərək, uğursuz test adlanan bir faylda saxlanıla bilər və standalone.py yardım proqramı ilə TSTL-nin özünə ehtiyac duymayan tamamilə bağımsız bir test vəziyyətinə çevrilə bilər. Çıxış olmadan test yenə də qeyd olunur, lakin ad tstl_rt proses kimliyinə əsaslanır. Hər iki halda da, müstəqil bir testə çevrilmədən, tstl_replay & lttestname & gt istifadə edərək, qeyd edilmiş bir testi asanlıqla yenidən işə sala və tstl_reduce istifadə edərək onu azalda bilərsiniz. --Verbose bayrağı təkrar oynatmaq üçün faydalıdır, çünki bir sınaq zamanı nəyin baş verdiyini dəqiq göstərəcəkdir.

Başlamaq üçün son faydalı işarə bəzən uğursuz testlərin Python tərcüməçisini çökdürdüyü bir şeyi (məsələn, C-də tətbiq olunan bir kitabxana) sınamaq istəyə biləcəyinizdir. Bu mümkündür, ancaq bir az səy tələb edir. Əvvəlcə - replayable seçimi ilə tstl_rt çalıştırın. Bu, generatorun test etdiyiniz qovluqda currtest.test sənədini saxlamasına səbəb olur: bu fayl cari testi saxlayır. Təsadüfi test cihazı çökərsə, bu, qəzaya səbəb olan əməliyyatı da əhatə edəcəkdir. Bir neçə nadir hallarda, keçmiş testlərin davranışı bir qəza ilə də əlaqəlidir (modulu yenidən yükləmək həqiqətən sistemin vəziyyətini sıfırlamır - məsələn, hardware ilə əlaqəli). Bu hallar üçün --total istifadə edin və təsadüfi test cihazı tərəfindən həyata keçirilmiş BÜTÜN əməliyyatları ehtiva edən fulltest.test sənədinə baxın.

Currtest.test və fulltest.test sənədləri normal TSTL sənədləri kimi işləyir və təkrar proqramı ilə yenidən oxudula bilər və ya müstəqil fayllara çevrilə bilər. Bununla birlikdə, test azaldılması və normallaşmanın düzgün işləməsi üçün, --sandbox arqumentini tstl_reduce-ə ötürərək azaldılmalıdır.

Sonsuz bir döngəyə girərək uğursuz olan testlər nədir? Qəzalar üçün istifadə edilən eyni texnika işləyir. Bununla birlikdə, bir müddət ilə tstl_rt çalıştırmanız lazımdır (məsələn, UNIX kimi sistemlərdə olsanız ulimit istifadə edərək). Tstl_reduce yardım proqramı bu cür testləri idarə etmək üçün --timeout arqumenti verir, lakin bu, hələlik yalnız ulimit dəstəkləyən sistemlərdə işləyir. Çox nadir hallarda, bir sınaq icrası kilidlənə bilər, çünki məsələn, uğursuzluq standart girişdən bir oxunuşa səbəb olur. Bunu vurursan, mənimlə əlaqə qur.

Nəhayət, TSTL testini daha çox ənənəvi yanaşmalarla necə birləşdirirsiniz, məsələn, pytest? Nümunələr qovluğundakı test_tstl_regressions.py faylı bir yolu göstərir. Bütün maraqlanan TSTL testlərinizi sut.py-nin yaşadığı qovluq altındakı bir tstl_tests qovluğuna əlavə etsəniz, bütün TSTL testlərinizi pytest-dən keçirə bilərsiniz. Bəlkə də daha maraqlısı budur ki, bu fayl, 60 saniyəlik təsadüfi testin pytest tərəfindən həyata keçirilməsini məcbur edən sadə bir zəng edəni də ağlı başında olmaq üçün bağlayır. Təsadüfi testin konfiqurasiyasını asanlıqla düzəldə bilərsiniz - tez-tez "- isti" əlavə etmək yaxşı bir fikirdir.

TSTL və mutasiya testi

Universalmutator alətindən istifadə edərək, səhv tapmaq üçün TSTL test qoşqularınızın gücünü asanlıqla araşdıra bilərsiniz. Məsələn, AVL qoşqularımızı istifadə edərək 10 saniyəlik təsadüfi testin nə qədər təsirli olduğunu görmək istəsəydik, bunu edə bilərik:

Bu, sınaqlarımızın əhatə etmədiyi mutantların hesabını bildirir və bu, yalnız API-nin bir hissəsini hədəf alsaq, az maraqlana bilər. Açığını deyim ki, mutasiya testindən istifadə etməkdən daha çox hansı kodu əhatə etməməyin asan yolları var! Beləliklə, təhlilimizi səxavətlə böyük bir fasilə istifadə edərək AVL qoşqu ilə əhatə olunmuş kodla məhdudlaşdırmaq istəyə bilərik:

Bəzən yalnız tstl_rt və ya hətta tstl_rt --swarm etmək kifayət deyil. Testləri yaxşılaşdırmaq üçün başqa variantlar var. Bir çox hallarda xüsusilə güclü biri, testlərə rəhbərlik etmək üçün kod xətləri baxımından funksiyaların ölçüsündən istifadə edir. Bunu etmək üçün əvvəlcə TSTL-in ölçülərini təyin etməsinə icazə verdiniz:

tstl_rt --generateLOC sut.loc --timeout 120

Sonra testə rəhbərlik etmək üçün yaradılan dosyadan istifadə edirsiniz:

Kod əhatə dairəsini --noCover ilə söndürmək üçün daha sürətli testlər üçün (təsadüfi testin gücü qismən hər dəqiqə çox sayda test yaratmaqda olduğundan) yaxşı bir fikirdir. Testlərinizin kodunuzu yaxşı əhatə etdiyini yoxlamaq istəyirsinizsə, bu o qədər də yaxşı deyil, ancaq metaldan pedala qədər bug ovlamaq üçün çox vaxt yoldur.

Testləri yaxşılaşdıracaq başqa şeylər var. --ProfileProbs seçimi, test zamanı TSTL qoşquundakı hər bir hərəkətin nə qədər edildiyi barədə məlumat toplayır və daha az görülən hərəkətlərə qarşı təsadüfi hərəkət seçimini xətti olaraq qərəzləndirir. Bu, əksər hallarda test istehsalını əhəmiyyətli dərəcədə ləngidir, lakin bir çox proqram üçün (xüsusən də mürəkkəb olanlar), vurulması çətin olan hərəkətləri araşdıraraq və SUT-u işlədərək giriş məlumatları yaratmaq üçün daha az vaxt sərf edərək kod əhatə dairəsini və arızanın aşkarlanmasını da kəskin şəkildə yaxşılaşdırır. . Bu hallarda, əlilliyi olan hərəkətləri həyata keçirmək cəhdləri nəticəsində yaranan test məhsuldarlığının itkisi test keyfiyyətinin yaxşılaşdırılması ilə əvəzlənəndən çoxdur. Hər ikisi də əməliyyat ehtimallarının qurulmasına güvəndiyindən, --profileProbs və --biasLOC təəssüf ki, uyğun deyil.

Bəzi proqramlar üçün qoşqu faylının quruluşu test istehsalını ləngidir və --useDependencies seçimi test qabiliyyətini 2-10 dəfə artırır. Lakin, əksər proqramlar üçün bu seçim test istehsalını təxminən iki dəfə ləngidir.

Bu seçimlərin faydası çox geniş dəyişdiyindən, ən yaxşısı sadəcə onları sınamaqdır. --ProfileProbs üçün test probleminiz üçün təsirli olarsa (ehtimal ki, yaradılan testlərin sayında böyük bir azalma ilə müşayiət olunur) kod əhatə dairəsində böyük bir artım görməlisiniz və --useDependencies üçün sayda böyük bir artım görməlisiniz aparılmış testlərin / test əməliyyatlarının.

"Yüksək əhatə dairəsi" testlərindən istifadə edən əhatə dairəsinə əsaslanan "genetik alqoritmlər" yanaşmasını da sınaya bilərsiniz:

tstl_rt - istismar 0.8 - 0.5-i dəyişdirin

--ReducePool əlavə etmək bəzən bu metodun fəaliyyətini də yaxşılaşdırır.

Nəticələri yaxşılaşdırdığını yoxlamaq üçün istismarı tənzimləyə və parametrlərini dəyişdirə bilərsiniz. Kod xəttləri və ya profilə əsaslanan ehtimalları istismar yanaşması və / və ya sürü testi ilə birləşdirə bilərsiniz. Təəssüf ki, --exploit istifadə etmək, hesablama kodunun əhatə dairəsinin üstələməməsi üçün --noCover ilə qaça bilməyəcəyiniz deməkdir.

TSTL-nin avtomatik olaraq təcrübələr aparması və müəyyən bir qoşqu sınamaq üçün sizə ən yaxşı konfiqurasiyanı məsləhət verməsi üçün bir yol üzərində işləyirik.

Çox sürətli "reqressiya testləri" dəsti almaq üçün --quickTests seçimi ilə tstl_rt'u uzun müddət yaxşı bir konfiqurasiyada çalıştırabilir və yüksək kod əhatəli çox qısa testlər toplusu yarada bilərsiniz.

TSTL avtomatlaşdırılmış səhv lokalizasiyasını dəstəkləyir. Bir səhv tapan bir qoşqu varsa, belə bir şey işlədərək bu böcəyin təbiəti haqqında bir az məlumat əldə edə bilərsiniz:

Bu, bir saat ərzində TSTL-i çalışdıracaq, bir sıra uğursuz test halları yaradır (bir saat ərzində səhvləriniz nisbətən asanlıqla tapıla bilərsə) və sonra yoxlanılan koddakı ən çox ehtimal olunan səhvli 20 bəyanat və budaq barədə məlumat verin. Bu koddan bəziləri təsdiqləmə dəyərlərini yazdırmaq və ya səhv üçün səhv işləmək kimi şeylərə qarışa bilər, ancaq təcrübəmizdə lokallaşdırma nəticələrində arabir kodu tapmaq şansınız böyükdür. Əslində, bir neçə dəfə səhvinizi tapmaq üçün beş dəqiqə kifayət edərsə, yaxşı bir lokalizasiya üçün beş dəqiqəlik bir iş kifayət edəcəkdir. Birdən çox səhviniz varsa nəticələrin daha pis olduğunu unutmayın!

Sürü testindən səmərəli istifadə etməyin bir yolu tətbiq etməkdir yönəldilmiş sürü testi, sürünün kod əhatə dairəsi ilə necə qarşılıqlı əlaqədə olduğuna dair məlumatların nadir hallarda əhatə olunan ifadələrin və filialların əhatə dairəsini artırmaq üçün istifadə olunduğu bir yanaşma.

Bunu etmək üçün tstl_rt istifadə edərək ilk testinizi (bir saat və ya daha çox) aşağıdakı variantlarla aparın:

Bu, proqramınızı sınayacaq və iki maraqlı sənəd hazırlayacaq. & ltfilename2 & gt, əhatə olunduqları sayına görə sıralanmış, budaqları və ifadələri olan sadə bir mətn faylı ehtiva edəcəkdir. Bu, əsasən gcov və ya digər vasitələrdən tanış ola biləcəyiniz növün sadələşdirilmiş bir versiyasıdır. Bu fayla baxa və maraqlı görünən, lakin nadir hallarda örtülmüş kodu müəyyən edə bilərsiniz.

Sonra maraqlı kodun identifikatorunu (mötərizə daxil olmaqla tam sətir) götürün və tstl_directedswarm alətini belə istifadə edin:

tstl_directedswarm & ltfilename1 & gt "& ltcoverage target & gt" & ltprobFile & gt

(& ltfilename1 & gt, sürü testinin orijinal işində istehsal etdiyiniz sənəddir.) Bu, hədəf kodun əhatə olunmasına kömək edən ("tetikleyici") və maneə törədən ("yatırmaq") və bir sənəd (probFile) hazırlamağa çalışacaqdır. daha fokuslanmış sürü testində istifadə ehtimalı ilə. Alət hər hansı bir tətikləyici və ya bastırıcı təyin etmirsə, - güvən seçimi və 0.95-dən az bir rəqəmlə yenidən çalışaraq tələb olunan güvən nə qədər az olsa, tetikleyiciler və bastırıcılar tapmaq ehtimalı bir o qədər yüksəkdir, lakin onlar daha az ehtimal olunur mənalı olmaq - bir nəticə əldə edənə qədər yavaş-yavaş endirməyə cəhd edə bilərsiniz. Sonra yenidən belə bir şəkildə test edin:

tstl_rt --swarm --swarmProbs & ltprobFile & gt

Ümumiyyətlə nadir hallarda örtülü olan kodu bu şəkildə yaxşı əhatə etməlisiniz. Nadir hallarda örtülmüş kodu əhatə etmək çox vaxt maraqlı görünməmiş yeni kodu açdığından, nadir hallarda örtülü kodu intial qaçışınızdan araşdırdıqdan sonra təkrarlamaq istəyə bilərsiniz. Əlbətdə ki, TSTL-in fokuslanmış işləri üçün sürü əhatə dairəsini və tam əhatə statistikasını saxlaya və araşdırmağa davam edə bilərsiniz.

Yönləndirilmiş sürü sınağına getmək üçün daha sistematik bir yol sınamaqdır:

tstl_analyzeswarm & ltfilename1 & gt & ltprefix & gt - cutoff 0.5

qaçış zamanı vurulan, ekvivalentlik siniflərinə (eyni trigger və basdırıcı dəsti olan hədəflərə) qruplaşdırılan və hər bir ekvivalentlik sinfində ən az vurulan hədəf tərəfindən sıralanan BÜTÜN əhatə hədəfləri üçün tetikleyiciler və bastırıcılar yaratmaq. Çıxış & ltprefix & gt ilə başlayan fayllarda saxlanılacaq: & ltprefix & gt.N.probs adlı bir fayl --swarmProbs ilə istifadə edilə bilən və tək bir .class faylı ilə bütün hədəflər, tetikleyiciler, bastırıcılar və siniflər üçün minimum frekanslar. , üstəgəl ehtimal sənədlərinə işarələr. Ən nadir hədəflər üçün siniflər üçün yaradılan ehtimal sənədləri arasında təkrarlanmaq yönəldilmiş sürü sınağına getmək üçün yaxşı bir yoldur. Yuxarıdakı 0.5, testlərin ən azı bu hissəsinin vurduğu hədəflərin yaxşı sınaqdan keçirildiyi və nəzərə alınmadığı hər hansı bir kəsmə ola bilər. Bunu 0,01-ə endirmək çox sayda test yaradan ilkin qaçışlar üçün yaxşı işləyə bilər.

TSTL və Amerikan Fuzzy Lop (AFL) Fuzzer

TSTL testləri yaratmaq üçün AFL (http://lcamtuf.coredump.cx/afl/) istifadə edə bilərsiniz. AFL-nin özünü və python-afl pip paketini quraşdırmalısınız (və ya https://github.com/jwilk/python-afl adresindəki github'dan kodu götürün). Sonra tərtib edilmiş bir TSTL qoşqu ilə istənilən qovluqda AFL istifadə edərək çaşqınlıq edə bilərsiniz:

tstl_afl_fuzz --output & ltoutputdir & gt --input & ltinputdir & gt

Bu, əvvəlcə TSTL-nin AFL-nin qurulması üçün yaxşı başlanğıc testləri yaratması və sonra SUT-da bir gün AFL çalıştırması üçün bəzi (ümumiyyətlə yaxşı) standart parametrlərdən istifadə edəcəkdir. Bir gün yetərli olmaya bilər, buna görə TSTL təsadüfi test cihazı ilə eyni --timeout parametri dəstəklənir. Ayrıca - isti əlavə edərək sürü testindən də istifadə edə bilərsiniz. Digər, daha az istifadə olunan variantlar da var. AFL tərəfindən yaradılan uğursuz testlər aflail kimi saxlanacaq. & LtPID & gt.test cari qovluqda. Bir tövsiyə: & ltoutputdir & gt SSD-nizi həqiqətən çəkmək istəmədiyiniz təqdirdə, ehtimal ki, bir ramdisk olmalıdır (bunu həqiqi bir sabit diskdə etməyi düşünməyin).

Tstl_afl_fuzz üçün -persist seçimini də sınamalısınız ki, bu da tez-tez füzinq sürətini böyük bir fərqlə yaxşılaşdıracaq və AFL nəticələrini kəskin dərəcədə yaxşılaşdıracaq (nəticəsi çox vacib olduğundan), bu, davamlı olmayan rejimə nisbətən bir qədər az sınaqdan keçir. . Daha çox testlə, bu, ehtimal ki, standart ayar olacaq, beləliklə döngədən irəlidə atlamaq istəyə bilərsiniz və yalnız davamlı rejimdə problem yarandığı təqdirdə davamlı deyil.

Bu, ən yaxşı halda yalnız AFL ilə əlverişsiz olan şeyləri qarışdırmaq üçün AFL-in möhtəşəm heuristikasını istifadə etməyə imkan verdiyindən güclü bir test variantıdır. Mürəkkəb TSTL xüsusiyyətləri qura, qrammatika yaratma və API çağırış ardıcıllıqlarını qarışdıra və TSTL tərzində diferensial test edə bilərsiniz, lakin AFL-nin köklənmiş giriş yaratma metodlarından istifadə edə bilərsiniz. Əsas çatışmazlıq odur ki, AFL həqiqətən TSTL-nin verdiyindən daha sürətli icra oluna bilən proqramları gözləyir, buna görə də SUT-unuz qeyri-adi olmadığı təqdirdə TSTL-in bir saat ərzində edə biləcəyi şeyləri yaxşılaşdırmaq üçün günlərlə çalışmalısınız. Lakin tstl_rt heç bir problem tapmadığı zaman, əlbəttə ki, bir həftəlik ağır yük testləri üçün cəlbedici bir seçimdir.

Tstl_afl_fuzz istifadə etmirsinizsə, ancaq py-afl-fuzz-a birbaşa zəng etsəniz, ehtimal ki (yaddaş məhdudlaşdırmasının onsuz da işləmədiyi Mac OS istisna olmaqla) TSTL-nin işləməsi üçün böyük bir -m-ə ehtiyacınız var.

Başlıq altında tstl_afl əmri bir bayt faylını götürür və hər N baytını (N qoşqu sayının neçə hərəkətindən asılıdır) bir TSTL hərəkətinin indeksi (əməliyyat sayını modul) kimi şərh edir, həmişəki kimi sut.py-dən istifadə edir. Tstl_afl bir uğursuzluq aşkar etdikdə, eyni zamanda aflfail adı altında şərti bir TSTL test faylı da istehsal edir. & LtPID & gt.test. İlk 4 baytı sürü sınağına nəzarət etmək üçün bir toxum kimi şərh etmək üçün - isti istifadə edə bilərsiniz, beləliklə AFL - in sürü testindən istifadə etməsinə icazə verin, bu, faylın digər TSTL alətləri tərəfindən səhv təfsir ediləcəyi mənfi cəhətdir. - isti seçim. Əksər TSTL alətləri oxunacaq testlərin AFL formatında olduğunu göstərən --afl seçimini edir və - sürü testləri olduqlarını göstərmək üçün --aflswarm.

tstl_afl, bayt əsaslı girişdən yaradılan cari qovluğa bir TSTL test sənədini atan --alwaysSave seçimindən istifadə edərək tək bir AFL bayt sənədini normal TSTL test sənədinə çevirmək üçün də faydalıdır.

Çox sayda sənədin AFL formatına və ondan dönüştürülməsi üçün alətlər də mövcuddur. tstl_toafl sadəcə mövcud TSTL test sənədlərini götürür və AFL bayt girişlərinə çevirir və tstl_fromafl gözlənilən əksini edir (və sənədlərin yığın formatında olduğunu göstərən bir arqument götürür). tstl_aflcorpus təsadüfi olaraq AFL-yə başlamaq üçün yeni SUT əhatəsini tetikleyen girişlər yaradır, ancaq tstl_rt --quickTests ilə sürətli testlər yaratmaq və tstl_toafl ilə çevirmək adətən daha asandır. tstl_aflcorpus AFL sürü formatını istifadə etməyə imkan verir, lakin yalnız --swarm ilə işə salın. Sürü formatının işləmə tərzinə görə, təəssüf ki, standart TSTL testindən sürü format testi çıxarmaq hazırda mümkün deyil.

tstl_smallcheck, verilən dərinlik həddinə qədər testlər yaratmaq üçün dərinlikdən ilk axtarışdan istifadə edən xüsusi təyinatlı bir sınaq generatorudur. Alət əhatə dairəsini artıran testləri çıxarır və bir uğursuzluqla qarşılaşdıqda dayanır. Dərinlik 3-dən 10-a (ən çox) addımdan çox olarsa, nadir hallarda başa çatacaq, bir uğursuzluq vurmasa. Səbriniz tükənirsə, prosesi CTRL-C ilə yarımçıq qoya bilərsiniz və vasitə aşkar olunmuş testləri xilas edəcəkdir.

Dərin "dolğun" testlərə qovuşmağın bir yolu, orijinal işləmə ilə eyni dərinliyi (və kiçik bir başlanğıc dərinliyi) istifadə edərək məhdud sayda dəfəyə qədər artan testlərdən araşdırma aparmaq üçün - rekursiv seçimdən istifadə etməkdir.

Yalnız birincisində dayanmaqla qalmayacaq bütün uğursuz testləri toplamaq istəyirsinizsə, - çox seçimini istifadə etməlisiniz. Kiçik ölçüləri və hərtərəfli tədqiqat istəyi (bu vasitədən istifadə etdiniz) sayəsində, bu vasitə sürüşmə riskindən qaçınmaq üçün örtük testlərinin və ya uğursuzluqların azalmasına və normallaşdırılmasına imkan vermir.

- recursive ilə yanaşı, DFS zamanı artıq tədqiq edilmiş dövlətlərə yenidən səfər etməmək üçün --visited və yavisitedList istifadə edə bilərsiniz, bunun üçün bir az diqqət tələb olunur. Alət uğursuz olarsa və ya testlər etibarlı / düzgün görünmürsə, qoşqularınızı --defaultReplay ilə yenidən yığmaq istəyə bilərsiniz, çünki dövlət əsaslı geri çəkilmə işə yaramır. Bir çox halda, bu şəraitdə dövlət müqayisəsinin yüksək qiyməti səbəbindən ziyarət edilən dövlətlərin qeydini aparmaq çox da faydalı ola bilməz.

Tstl_rt istifadə təsadüfi testlər, ehtimal ki, həmişə bu yanaşmadan daha təsirli olur, lakin tstl_smallcheck, dörd addımdan az olan bir testin hər hansı bir uğursuzluğa səbəb ola bilməməsi kimi tstl_rt'ın təmin edə bilməyəcəyini təmin edə bilər. --FromTests seçimindən istifadə edərək mövcud sürətli testlərdən kiçik bir imtahana başlamaq, testinizə əlavə etimad göstərmək üçün bir yoldur.

Bəziləriniz soruşa bilər: "TSTL Hipotezdən https://hypothesis.readthedocs.io/az/latest/ test alətindən nə ilə fərqlənir?" Bir neçə cavab var. Birincisi, TSTL, ehtimal ki, Hipotezdən daha az cilalanmışdır, indi! Ancaq daha əhəmiyyətlisi, Hipoteza və TSTL hər ikisi də testlər yaradır, lakin bunlar ilk növbədə müxtəlif növ testlər yaratmaq məqsədi daşıyır. Hipotez, QuickCheck ailəsini nəzərdən keçirdiyimiz şeydir: bir siyahı, bir simli və ya daha mürəkkəb bir şeyi giriş olaraq qəbul edən bir f funksiyanız varsa, hipotez istifadə etmək istədiyiniz şeydir. F, g və h funksiyalarınız varsa və bunlar yalnız şeyləri qaytarmır, görünməz sistem vəziyyətini dəyişdirirsə (həm də digər funksiyalara daxil ola biləcək şeyləri qaytarırsa), TSTL istəyə bilərsiniz. Hipotez ilə dövlət əsaslı metod ardıcıllığı çağırışları testi edə bilərsiniz, ancaq TSTL ilə daha asan ola bilər və TSTL-nin qurulduğu budur. Beləliklə, bir çeşidləmə tətbiqetməsini test edirsinizsə, Hipotez demək olar ki, daha yaxşıdır. Bir fayl sistemi kimi bir şey test edirsinizsə, TSTL-ə baxmaq istəyə bilərsiniz. Bir sətri giriş kimi götürən bir təhlilçini sınaqdan keçirirsinizsə, vəziyyətinizdən asılı olaraq hər iki vasitə də faydalı ola bilər. Tipik istifadəçi üçün əlavə bir fərq, TSTL-nin diferensial / istinad testlərini həyata keçirmək üçün kifayət qədər daxili dəstəyinə sahib olmasıdır, burada SUT-un bir referans tətbiqetmə ilə müqayisə edildiyi, ehtimal olunan gözlənilən fərqləri idarə etmək üçün bəzi kodlarla (yaxşı bir görünüş üçün pyfakefs nümunəsinə baxın) bunun nə qədər güclü ola biləcəyini). Nəhayət, TSTL praktik bir test aləti kimi qurulmuşdur, lakin dizaynı yeni proqram test alqoritmləri ilə sınaq üçün bir platforma kimi faydalı etmək qərarından çox təsirlənir.

Bənzərlik həm TSTL, həm də Hipotezanın ənənəvi vahid sınaqlarına bənzəməməsidir. They instead let you define the idea of a valid input (either some data values, or in TSTL a sequence of method calls and assignments that more resembles a traditional do-some-stuff-and-then-check-it unit test) and assert general properties about the behavior of a system under valid input.

Tips for Handling Numerous Bugs

If you test real software with a good harness, you may well find many issues. There are a few ways to deal with this. First, using --normalize when doing --multiple runs with tstl_rt can help. In some cases (file systems) normalization (or even reduction) goes too far. In testing at NASA, we found that "last operation" was a good heuristic for different bugs. Using --keepLast in testing (or when using tstl_reduce ) forces reduction and normalization to leave the last step alone. Normalization can still move it around, or change the pool it uses, but is much more careful about changing the actual action performed. There is also a tool tstl_triage that takes a glob expression for a set of tests, runs them all, and reports ones with different (heuristic) failure signatures. In particular, it gives you the shortest test for each signature. Remember that triage requires a glob expression (in quotes) not a list of files. This is so it can handle even sets of tests that go beyond the shell expansion limit. We assume that you won't need to handle that many tests in regression, but for triage, who knows? Another tool, tstl_fpf takes similar arguments to tstl_triage but instead of clustering tests into groups that are likely the same bug, it ranks all tests, such that very different tests are high in the ranking, using the "furthest-point-first" (FPF) method proposed by Chen et. al in PLDI 2013.

For more details on TSTL, the best starting point is a comprehensive journal paper in STTT: http://agroce.github.io/sttt17.pdf. There are also NASA Formal Methods (NFM) and International Symposium on Software Testing and Analysis (ISSTA) 2015 papers at http://agroce.github.io/nfm15.pdf and http://agroce.github.io/issta15.pdf, with some implementation details or concepts that are not present in the more up-to-date and complete paper. In particular, the NFM paper, "A Little* Language for Testing" has a deprecated syntax and other issues, but is the most concise explanation of the core TSTL idea: a DSL embedding a full programming language, designed to make testing (and building testing tools) easy.

There is a more recent paper describing test normalization, a feature unique to TSTL, in more detail, http://agroce.github.io/issta17.pdf, as well as a tool paper describing how to use TSTL's test manipulation commands (http://agroce.github.io/issta17tool.pdf).

The NFM and ISSTA papers use an early version of TSTL syntax, which marks pools and TSTL constructs with % signs. "Modern" TSTL uses <> by default, though if for some reason you need <> in your code (and to prepare for a future C++ version) this can be turned off and only % supported.

Note that documentation above is preliminary. The best way to get started, once you understand the basic tools ( tstl , tstl_rt , tstl_replay , and tstl_reduce ) is to examine the examples directory and try out real TSTL test harnesses. For the brave, reading tstl/randomtester.py provides considerable guidance in how to (efficiently) use TSTL in a generic testing tool, with TSTL providing an interface to the underlying application/library to be tested.

Note that TSTL was originally written for Python 2.7, has mostly been developed/tested that way, and is not extremely well-tested yet with Python 3.0+. However, it should work ok, thanks to mrbean-bremen, and the Travis tests check that TSTL works fine on Python 3.6. Earlier 3.0+ versions may have some "gotchas."

There are no developer docs yet, which will hopefully change in the future. The best shakedown test for tstl is to compile and run (using tstl_rt ) the AVL example. Removing any call to the balancing function in the avl.py code should cause TSTL to produce a failing test case.

Who is responsible for TSTL?

Alex Groce (agroce) wrote this file, and most of the current code base, and is running the show. If there is a problem with TSTL, it is my fault, and don't blame anyone below.

Josie Holmes (josieholmes) contributed to core language design changes, and is responsible for the ideas (and some of the code) for the various slippage reduction strategies, plus the LOC bias work and Markov things. Before Josie's work, TSTL was extremely hard to read, and considerably less efficient.

Jervis Pinto was the other original TSTL-er, and has his fingerprints on various parts of the early design and code that form the foundations of TSTL.

Pranjal Mittal contributed a number of critical elements, including the initial effort to prepare TSTL for a pip release as a useful tool, and has helped publicize TSTL.

Pooria Azimi added the <int,1> notation, which turns out to be one of the most important changes, and eliminated the need for the exceedingly awkward way of handling binding via Python functions and commit point based guards. Without this, you really don't have a useful TSTL.

Kevin Kellar developed a (beta) Java version of TSTL: https://github.com/flipturnapps/TSTL-Java.

My (Alex's) other graduate students (Amin Alipour, Rahul Gopinath, Arpit Christi, Chaoqiang Zhang, Shalini Shamasunder) and almost-mine graduate student (Iftekhar Ahmed) contributed to the general intellectual climate in which TSTL was born.

Students in CS 499 at Northern Arizona University and CS 362, 562, and 569 at Oregon State University contributed a lot of ideas, and a few concrete language/tool changes or bug reports. These are too numerous to mention, and in some cases I don't recall who asked "why do you do it that stupid way?" in class, and got me thinking that it was in fact a stupid way to do things.

Ned Batchelder, David R. MacIver, and John Regehr have no actual code in TSTL, but all contributed in significant ways to various implementation aspects, in ways that go beyond the general disclaimer that TSTL freely steals from the entire software testing (research) community.

The pyfakefs team (mrbean-bremen and jmcgeheeiv on github) really worked with me to test pyfakefs, which resulted in a number of nice improvements to TSTL and to differential testing in particular. More recently, mrbean-bremen has taken the lead in making TSTL compatible with Python 3, which seems to mostly be done now!

Jakub Wilk helped with modifications to python-afl that made TSTL/AFL integration work much better.

Corey Kosak helped turn this README into something that you might actually enjoy reading, and gets to the point much faster than previous versions.

* Do you actually remember that asterisk way up there? The footnote is that TSTL edir a little language. However, in another sense, it embeds all of Python which makes it pretty big. It depends on how you think about it.


My Pi keeps crashing — where should I look?

I know my problem is too vague to solve the root problem. Please help me on my way.

My problem
I have a Pi setup with owncloud. And a external hard drive with videos on it.
It just functions as a NAS. I use SFTP for all my connections.
But it (seemingly) crashes at random. It crashed last night when it was idling, and does so a few times a week. Pulling the plug and reinserting it creates a successful reboot.

  • It's a Pi 2 Model B.
  • I tried 2 different power supplies for the Pi. Neither had problems with an older Pi model.
  • The external drive is externally powered.
  • I run the Pi headless.
  • When it crashes I can't login or reach it in any way. The power LED is lit.

My question:

  • Where should I look to narrow this down?
  • What might I do the log this behaviour?
  • Where is a place to get more specific support for this kind of broad, vague problems?

What helped so far

A comment made by Goldilocks to determine the difference if it really crashes or I just can log in.


As stuff is stored into, left, and eventually pulled out of RAM, some corruption naturally occurs (theories vary, but the one with the most weight right now is EMI from the computer itself). ECC is a feature of RAM and motherboards that allows detection and correction of this corruption.

The corruption is usually pretty minor (ECC can usually detect and fix 1-2 bits per 64 bit "word" - and that's waaaaay beyond the typical error rates), but increases in frequency with the density of the RAM. Your average workstation/PC will never notice it. On a server where you're running high density RAM 24/7 in a high-demand environment serving critical services, you take every step you possibly can to prevent stuff from breaking.

Also note that ECC RAM must be supported by your motherboard, and the average workstation/PC does not support it.

ECC RAM is more expensive than non-ECC, is much more sensitive to clock speeds, and can incur a small (1-2%) performance hit. If it helps, an analogy that works is RAM to RAID controllers. On your PC, that hardware-assisted software RAID built into your chipset is great protection against single disk failures. On a server, that would never be enough. You need high-end, battery-backed fully hardware RAID with onboard RAM to ensure that you don't lose data due to a power outage, disk failure, or whatever.

So no, you don't really need ECC RAM in your workstation. The benefit simply will not justify the price.

10% you'd expect from the additional chip area, for the same usable amount of RAM). It might be worth revisiting particularly the last sentence in light of this. &ndash user Oct 18 '15 at 13:07

If this article is anything to go by, then you should use ECC RAM.

It's not just a matter of "I don't run a server, so I don't need it". It depends how much you value your data. It's not just a matter of occasional crashes - the problem is you could get corruption and have no way of knowing that it's going on.

ECC RAM gets more interesting as memory sizes grow. The probability of a single bit error in a machine with 8GB of RAM is quite a lot higher than it was in the days of a 640K PC/XT, simply due to the larger number of bits. On a database server where that RAM might be in a disk buffer, a bit error can corrupt disk storage as well. Generally you would expect to use ECC memory on a server.

Some workstations (particularly those with Xeon or Opteron CPUs) take registered memory, which pretty much only comes in ECC flavours anyway. On a desktop PC you may view it as overkill.

ECC RAM is designed to aid in preventing and fixing memory based errors, usually using some sort of hamming code or modular redundancy. This is very useful in servers that contained important data, or need high availability, but it comes at a cost.

Whilst its probably worth paying the extra for your important servers, do you really want to do so for your desktop machine, does it matter if there is the occasionally memory error? Sure it matters if your SQL database drops some data during a transaction, but do you care if your word document is affected by a slight memory blip?

If you want a reliable workstation then you want ECC RAM for it. It will crash less often and work done on it and documents cached in RAM will not be randomly corrupted.

An additional benefit of ECC over what was mentioned above is that you can detect bad RAM. While running a long memtest86 session will usually find any problems, there may be very specific problems with the RAM which only show up rarely and in certain use cases. This can still happen much more frequently than the corruption that perfectly good ECC RAM is designed to protect against -- maybe once every month. So if you install monitoring software, you can be sure that your RAM is good, or replace bad chips. Still a marginal benefit, but as ECC memory is not much more expensive than normal RAM, it may be worth it.

ECC memory now costs about the same as non-ECC memory, as prices have dropped. So check prices if prices are anywhere close, buy ECC if your workstation accommodates it.

I think there may be some confusion just based on the title of the question.

If you just mean the average desktop PC, then that is usually based on a platform that doesn't even have ECC support.

If you mean a workstation class computer, then it quite likely comes with ECC memory whether you care about it or not.
Overall, the workstation class is typically based on essentially server hardware but with proper graphics and packaged in a different form-factor.

The expected workload is also more taxing than that of the desktop PC, so if you acknowledge that ECC makes sense for servers, then I think it's not much of a stretch that ECC also makes sense for workstations.

For Desktop PCs, there's some debate whether ECC would make sense or not. It can absolutely be argued that everything ought to have ECC but, right now, it's not practical as the industry has decided to make ECC a feature to differentiate higher end hardware.

According to the article Zan Lynx linked in the comments: DRAM Errors in the Wild: A Large-Scale Field Study, the uncorrectable errors are common while random correctable errors appear rarely in a system. The incidence is probably a few in a year, but it depends on the usage.

So in a server environment the correctable errors might not be that important, but you boot the server machines rarely, so uncorrectable errors caused by failing RAM can be there undetected for a while corrupting your data. I think that's the main reason why servers need ECC. Workstations boot and so check RAM frequently, so hardware failures can be detected by every reboot. If that frequency is sufficient for your business, then I think you won't need ECC RAM in your workstation.

If we are talking about memory errors, it is better to version the important documents on the server. So if the workstation reads and modifies something, then the original content should not be overwritten on the server. Regular backups can do the same for you.

Another aspect of this question is security. If your workstation is connected to any non-safe network, then it might be vulnerable to the row hammer attack, which exploits a DRAM related phenomenon. So from security perspective it is better to use ECC RAM.

I would use ECC everywhere, always, and I'm upset and disappointed I cannot get it on my MacBook Pro laptop, because otherwise it could completely replace my desktop server. In my desktop server, over 10 years I have had to replace 2 memory sticks due to persistent errors which would have just been random crashes and data corruption if it were not for ECC detecting and correcting them. Not counting all the errors in those failed sticks, I would estimate seeing about 8 errors per year. Of course, this is a tiny sample and anecdotal evidence a much better resource is Google's study which showed that about 1/3 of their servers experienced at least one memory error in a given year.

I agree with Linus Torvalds (creator of Linux) that the real driving force behind keeping ECC unavailable is Intel:

Torvalds takes the bold position that the lack of ECC RAM in consumer technology is Intel's fault due to the company's policy of artificial market segmentation. Intel has a vested interest in pushing deeper-pocketed businesses toward its more expensive—and profitable—server-grade CPUs rather than letting those entities effectively use the necessarily lower-margin consumer parts.

Removing support for ECC RAM from CPUs that aren't targeted directly at the server world is one of the ways Intel has kept those markets strongly segmented. Torvalds' argument here is that Intel's refusal to support ECC RAM in its consumer-targeted parts—along with its de facto near-monopoly in that space—is the real reason that ECC is nearly unavailable outside the server space.


StackTracker - Cross-platform desktop notification app

The application displays a task tray notification when someone has posted an answer or a comment to a question you are tracking on any of the StackExchange sites. Clicking the notification will open the corresponding question in your browser.

License

GPL - Full LICENSE file available in the repo (below)

Download

Linux build: Download Linux ZIP (Requires Python 2.6 and PyQt4 to be installed)

Run >> python StackTracker.py from the StackTracker folder

Windows build: Download Windows ZIP (May need Microsoft VC++ DLL installed)

Launch the StackTracker.exe .

Mac OS X build: Download Mac OS X tarball (Requires Growl to be installed)

Launch StackTracker.app . Only tested in Leopard/Snow Leopard on Intel-based Macs.


kill -9 (SIGKILL) always works, provided you have the permission to kill the process. Basically either the process must be started by you and not be setuid or setgid, or you must be root. There is one exception: even root cannot send a fatal signal to PID 1 (the init process).

However kill -9 is not guaranteed to work dərhal. All signals, including SIGKILL, are delivered asynchronously: the kernel may take its time to deliver them. Usually, delivering a signal takes at most a few microseconds, just the time it takes for the target to get a time slice. However, if the target has blocked the signal, the signal will be queued until the target unblocks it.

Normally, processes cannot block SIGKILL. But kernel code can, and processes execute kernel code when they call system calls. Kernel code blocks all signals when interrupting the system call would result in a badly formed data structure somewhere in the kernel, or more generally in some kernel invariant being violated. So if (due to a bug or misdesign) a system call blocks indefinitely, there may effectively be no way to kill the process. (But the process will be killed if it ever completes the system call.)

A process blocked in a system call is in uninterruptible sleep. The ps or top command will (on most unices) show it in state D (originally for “disk”, I think).

A classical case of long uninterruptible sleep is processes accessing files over NFS when the server is not responding modern implementations tend not to impose uninterruptible sleep (e.g. under Linux, the intr mount option allows a signal to interrupt NFS file accesses).

If a process remains in uninterruptible sleep for a long time, you can get information about what it's doing by attaching a debugger to it, by running a diagnostic tool such as strace or dtrace (or similar tools, depending on your unix flavor), or with other diagnostic mechanisms such as /proc/PID/syscall under Linux. See Can't kill wget process with `kill -9` for more discussion of how to investigate a process in uninterruptible sleep.

You may sometimes see entries marked Z (or H under Linux, I don't know what the distinction is) in the ps or top output. These are technically not processes, they are zombie processes, which are nothing more than an entry in the process table, kept around so that the parent process can be notified of the death of its child. They will go away when the parent process pays attention (or dies).


Videoya baxın: شرح اساسيات لغة بايثون 3: الدرس السابع (Oktyabr 2021).