Bilang isang computational pisisista, ako madalas ko tumatakbo programa na binubuo ng maraming nakapugad para-loops . Sa ngayon, ang aking nasa kalayuan loop cycle sa pamamagitan ng milyon-milyong mga data points at iba't-ibang loob loops galugarin sampu-sampung libo ng mga parameter. lagi ako may kalikot ang mga setting sa loob loops sa mga paraan na maging sanhi ng tumakbo ang oras para mag-iba sa pagitan ng 10 seconds at 10 linggo.
Annoyingly, ito ay hindi palaging madaling mahulaan kung gaano katagal ang programa ay tatakbo pagkatapos ng bawat set ng mga pagbabago. Gayundin, ang aking code ng paminsan-minsan ay may bugs na gumawa ng mga ito hang walang katapusan. Kapag ang inaasahan magpatakbo ng isang programa ng oras ay sinusukat sa linggo, ito ay reassuring upang makita ang mga regular na mga ulat sa pag-unlad. Kung hindi mag-alala ako na ang programa ay tahimik crashed.
Sa una ko na lang slapped isang i-print ang pahayag sa pinakamalayo sa-loop, encased sa isang kung-pagkatapos ay pahayag na lamang aktibo minsan sa 1000 loops. Ang i-print ang pahayag na ginagamit ang oras lumipas mula sa simula ng loop at ang pag-unlad na ginawa sa pagtatantya ng oras ang natitira. Ito ay tumingin ng kaunti tulad nito (kasama ang ilang mga uri ng pagpapatala ):
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | ( NULL ) ; //Grab starting time. start_time = oras (null); / / sunggaban panimulang oras. i = 0 ; i < i_end ; i ++ ) { para sa (i = 0; i <i_end; i + +) ( i + 1 ) % 1000 == 0 ) { //Only print every 1000 loops. kung ((i + 1)% 1000 == 0) (/ / Tanging ang i-print sa bawat 1000 loops. ( NULL ) ; //Grab current time. current_time = oras (null); / / sunggaban kasalukuyang panahon. start_time ; timespan = current_time - start_time; / / Ang TOTAL oras upang makumpleto ay maaaring makuha sa pamamagitan ng / / Naghahati timespan ng maliit na bahagi ay tapos na. / / Pagkatapos subtracting timespan, ang oras ang natitira / / Ay kaliwa (sa segundo, na kung saan ay madalas na nakalilito). ( i + 1 ) / ( i_end + 1 ) - timespan ; time_remaining = timespan / (i + 1) / (i_end + 1) - timespan; ( i + 1 ) / i_end * 100 << "% finished, " hukuman <<(i + 1) / i_end * 100 <<"% tapos na," "seconds remaining." << endl ; <<Time_remaining <<"segundo natitira." <<Endl; ) j = 0 ; j < j_end ; j ++ ) { para sa (j = 0; j <j_end; j + +) ( / / Huwag ng maraming bagay-bagay dito. ) ) |
Ito sufficed hanggang ako binago sa setting ng loob loops sa isang paraan na nadagdagan ang oras tatakbo higit. Ang unang abiso kinuha na oras upang lumitaw, na isaalang-alang ko unacceptably mabagal. Pagkatapos ako tried na gawin ang mga i-print ang pahayag buhayin ang bawat 10 loops sa bilis up notifications kapag ang tumakbo ng panahon ay masyadong mahaba, ngunit puno na ang log file na may megabytes ng pahayag at i-print ang pinabagal down sa programa. Ito ay naging malinaw na mabilis hacks ay pagpunta sa nangangailangan ng isang pulutong ng patuloy na maintenance. Kailangan ko ng isang abiso sistema na maaaring awtomatikong iakma sa maikli at mahabang ulit tumakbo.
tawag ko sa aking mga solusyon "Automated Notifications". Ang pinakabagong bersyon ay v1.2, na maaaring i-download dito .
Features:
- Ang panahon hanggang sa ang unang abiso ay lilitaw maaaring kinokontrol na hiwalay mula sa iba pang mga abiso, at ito mga default na 10 segundo.
- Ang dami ng oras sa pagitan ng lahat ng mga kasunod na abiso ay kontrolado ng isang variable na tumutukoy ng isang target na pagitan sa pagitan ng mga abiso. Ang aktwal na pagitan ay sa loob ng 30% ng target na ito (5 minuto default).
- Ang pinakamababang numero (default ay 4) ng mga abiso ay nakalimbag sa pamamagitan ng ipaalam sa (). Ito lamang activates kung ang inaasahan na patakbuhin ay mas mababa kaysa sa napili na pagitan sa pagitan ng mga abiso.
- Ang oras ang natitira ay nakalimbag sa isang tao-nababasa format gamit ang seconds_to_string () function. Time ay iniulat sa taon, linggo, araw, oras, minuto, segundo. Walang higit sa 2 mga yunit ay nakalimbag sa bawat pahayag upang mabawasan ang kalat ng mga basura (kahit na ang halaga na ito ay napapasadyang).
- Ang isang i-print ang mga ulat na pahayag ang oras lumipas sa dulo ng loop, kaya ang tinatayang oras ang natitira ay maaaring ingat laban sa kung gaano katagal sa loop talaga kinuha.
- Ang mga panlabas na loop maaaring magsimula sa anumang (positibong! - Kailangan upang ayusin ito!) Index, hindi lamang 0 tulad ng sa halimbawa sa itaas.
- Karamihan sa mga abiso ng mga opsyon ay naka-set sa ibabaw ng bawat loop, kaya maraming mga loops ay maaaring isinaayos naiiba (tingnan custom_example.cpp).
- Ito ay maaring isang magandang ideya na ilagay ang code sa ang notification function na ini-imbak ang iyong data sa disk upang kung ang computer crashes o ang kapangyarihan goes out, ang aplikasyon ay restarted mula sa huling point abiso. Ang variable na notification.partial_saves_enabled ay sinadya upang buksan ito hindi nakasulat ang code, ngunit maari ka din na kailangan upang pumasa sa isang bagong argumento upang ipaalam sa () function na naglalaman ng data na nais mong nakasulat sa disk.
Mga Pangangailangan:
- Inilaan para gamitin sa C + + programa, masuri gamit ang g + + tagatala na lumapit sa Ubuntu 8.10 64-bit .
- Ang iyong nasa kalayuan loop cycle ay dapat higit sa maraming mga indeks (dose-dosenang o higit pa). Ang mga loop ay maaaring magsimula sa anumang index na gusto mo, ngunit ito pangangailangan upang madagdagan ng 1 sa bawat loop.
- Nangangailangan ang iostream, iomanip at vector aklatan (makukuha sa Ubuntu sa pamamagitan ng default).
Ang programa ay maghiwalay sa 3 file: common_declarations.hpp ay naglalaman ng mga kahulugan at datatype function declarations, common_functions.cpp ay may kahulugan function para ipaalam sa () at sec2human () habang example.cpp ay lamang ng isang halimbawa loop na gumagamit ng Automated Notifications.
dibisyon na ito ay hindi kinakailangan, ngunit ko natagpuan ito ay isang mahusay na paraan upang maisaayos ang mga mas malalaking proyektong software. Sa ganitong paraan, gaano ginagamit ang function na madalang nagbago maaaring ipinahayag at tinukoy sa mga karaniwang mga file at mga naipon nang hiwalay mula sa mga programa na lamang gamitin ang mga function.
Ang Makefile kasama Automated Notifications compiles sa dalawang hakbang upang ilarawan ito pamamaraan. Matapos ang pagdaragdag ng maraming mga function sa aking bersyon ng mga karaniwang mga file, ang unang hakbang compilation tumatagal ng halos isang minuto sa aking computer. Ang hakbang na ito lamang ay nangyayari kapag ang mga karaniwang mga file ay na-edit, gayunpaman, na nangangahulugan na ito ay bihira kinakailangan. Ang ikalawang hakbang compilation, sa ibang dako, ay mas madalas at magkano ang mas mabilis.
Sa pamamagitan ng ang paraan, common_declarations.hpp ay naglalaman ng mga linya "gamit namespace magkaroon ng mga std". Ko na basahin na ito ay masamang programming pagsasanay, ngunit hindi ko tumakbo sa anumang malubhang kahihinatnan pa, at ito ay hindi maginhawa sa may sa uri "magkaroon ng mga std::" sa bawat panahon na gusto kong gamitin ang "hukuman".
Narito ang kung ano ang example.cpp ganito ang hitsura:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 | /************************************************* ******* Layunin: Ang programang ito ay nagpapatakbo ng isang set ng mga nakapugad loops na gawin walang kaukulan kalkulasyon para sa ilang mga minuto (eksaktong oras ay depende sa bilis ng sa iyong computer at ang mga limitasyon ng nakapugad loops). Ito ay sinadya upang ipakita ang ipaalam sa () function. ************************************************** ******* Written by pipi Scientist Unang isinulat: 2009/02/26 Last modified: 2009/03/08 ************************************************** ******/ / / Header file "common_declarations.hpp" declares marami / / Function, constants at datatypes. Upang gamitin ang / / Function na ipinahayag sa ito, kailangan mo ang link na ito programa / / Sa object code na ginawa gamit ang common_functions.cpp. # Isama ang "common_declarations.hpp" Int main () ( / / Ipinahayag counter at limitasyon para sa mga loops. 0 ,i,j,i_start = 30 ,i_end = 200000 ,j_end = 200000 ; matagal temp = 0, i, j, i_start = 30, i_end = 200000, j_end = 200000; / / Magpasimula variable para ipaalam sa (). notification_struct abiso; / / Palitan ang string na ito sa anumang nais mo. "Example loop" ; abiso. prefix = "Halimbawa loop"; / / Ang iyong panimulang index ay marahil ay naiiba. i_start ; abiso. starting_index = i_start; / / Ang iyong nagtatapos index ay malamang din ay naiiba. i_end - notification. starting_index ; abiso. num_loops = i_end - abiso. starting_index; i = notification. starting_index ; i < i_end ; i ++ ) { para sa (i = abiso. starting_index; i <i_end; i + +) ( / / Regular na i-print ang oras ang natitira. ; ipaalam (notification, i); j = 0 ; j < j_end ; j ++ ) { para sa (j = 0; j <j_end; j + +) ( / / Lubos na lubos inutil pagkalkula. ( i * j * j * j - 2 * i + 3 * j ) ; temp + = (i * j * j * j - 2 * i + 3 * j); ) / / Dulo ng mga loop sa loob. ) / / Dulo ng mga panlabas na loop. / / Record oras sa dulo ng programa. time ( NULL ) ; abiso. end_time = oras (null); notification. end_time - notification. start_time ; abiso. time_total = abiso. end_time - abiso. start_time; notification. prefix << " took " hukuman <<abiso. prefix <<"kinuha" notification. time_total ) << endl ; <<Seconds_to_string (notification. time_total) <<endl; / / Kung ang temp ay hindi ginamit sa tabi-tabi, programa na ito ay umaabot / / 0 seconds. tingin ko na ang resulta ng-O2 / / Bandila halata na ang mga loops sa itaas ay hindi kinakailangan. bumalik temp; ) |
Kapag tumakbo, ito produces output na ganito ang hitsura na ito (tandaan na ang unang linya ay lilitaw sa loob ng ilang segundo, at ang kasunod na abiso ng mga 25% hiwalay dahil ang tinatayang oras ng tumakbo ang program na ito ay mas mababa kaysa sa pagitan ng default):
1 2 3 4 5 6 | Halimbawa loop ay sa 8.20%. Time kaliwa: 1 minuto, 52 segundo Halimbawa loop ay sa 33.20%. Time kaliwa: 1 minuto, 20 segundo Halimbawa loop ay sa 58.19%. Time kaliwa: 51 segundo Halimbawa loop ay sa 83.19%. Time kaliwa: 20 segundo Halimbawa loop kinuha 2 minuto, 1 segundo ` |
Ako ay nagbago ang mga limitasyon ng loops pamamagitan ng pagdagdag ng mga zero 4 sa bawat i_end at j_end, ngunit ang unang linya pa rin lumitaw sa loob ng ilang segundo:
1 2 | Halimbawa loop ay sa 0.00%. Time kaliwa: 285 taon, 10 na linggo ` |
Malinaw na, hindi ko maghintay para sa na ang isa sa matapos. Ngunit ang punto ay na ako mabilis Alam ko gusto mamatay ng lumang siglo gulang bago ito did. Sinasadya, ako tried pagdagdag ng ilang mga karagdagang mga zero sa j_end at ito na dulot ng unang abiso na kumuha ng isang irritatingly mahabang oras upang lumitaw. Ito ang mangyayari dahil ang mga panlabas na loop tumatagal ng isang mahabang oras sa pag-unlad lamang ng isang beses. ako hindi pa sigurado kung gusto ko sa address na ang problemang ito.
Automated Notifications ay libreng software, lisensyado sa ilalim ng GPLv3 sa halip na ang CC lisensiya na ang magpahinga ng ang site ay gumagamit ng. Kung sinuman paunawa ng anumang bugs o ay may anumang mga mungkahi para sa kung paano upang mapabuti ang Automated Notifications, pakisabi sa akin ng mga puna sa ibaba. Ako din usyoso upang makita kung paano ang iba ay may lutasin ang problemang ito, hindi alintana ng mga wika ito ay nakasulat in
Bersyon ng Kasaysayan
v1.2 - 2009/03/08 - Pinasimple mga default na setting sa iklian example.cpp, idinagdag custom_example.cpp.
v1.1 - 2009/02/27 - Pinalitan max at min na pagitan sa target_interval.
v1.0 - 2009/02/26 - Orihinal na release.
Huling binago Agosto 2, 2009
Ako mabigla hindi mo gamitin ang isang timer tumakip. Walang ibabaw habang ang loop ay tumatakbo at tiyak na kontrol ng sample na pagitan. Basta kailangan ang ilang mga paraan upang makuha ang mga variable ng loop sa matakpan Handler at ang mga resulta sa labas.
Hindi gamitin na dahil hindi ko gusto narinig ito ng bago. Salamat, kukunin ko na tumingin sa ito.
Ang "produksyon" bersyon ng function na ito ay tumatanggap ng isang istraktura na may ilang GB ng data at autosaves ito sa disk. I'm wondering kung isang timer tumakip maipadala na magkano ang data sa isang transparent fashion? Ibig sabihin, ang buong istraktura ng mga pangangailangan upang maipadala sa pamamagitan ng reference bilang isang argument na walang paggawa ng isang lokal na kopya ng data (ito bahagya akma sa memorya na.)
Dagdag dito, ang function ng mga pangangailangan upang maging sa tinatawag na eksaktong lugar sa ang code, hindi sa loob ng loop sa loob, sa kabilang banda ang autosave function ay hindi gagana ng maayos. Kung ang lahat ng ito ay posible na may timer makatakip, isang tao masiyahan point ako sa ilang mga code halimbawa.
(Ed. tandaan: ang puna na ito ay orihinal nai-post dito .)
Bakit? Iyon ay nangangahulugan lamang na ako para buksan ang mga file na mas kapag gusto kong gumanap ng pagpapanatili ng malawak na sa programa.
Ipon ay siguradong mas mabilis na kung ikaw lamang baguhin ang 1 sa 100 katulad laki ng mga file, ngunit ko na pinili upang lumikha ng dalawang pangunahing mga file source: ang una ay malimit na-edit at malalaking (30k linya), habang ang pangalawang ay na-edit ng mga dose-dosenang beses sa isang araw at lamang ay may mga linya ng 1K. Ang Makefile compiles ang mga malalaking file sa object code na kung saan ay pagkatapos ay naka-link sa code ng bagay mula sa maliit na file. Ang mga malalaking file ay pagkatapos noon lamang naipon kung ang pagbabago ng petsa ng malaking source file ay mas bago kaysa sa mga malalaking file object. Kahit na ang sumulat ng libro ulit para sa mga malalaking file ay lamang ~ 10 segundo sa isang netbook kung optimization ay pinigilan, at ito ay hindi malinaw na ang aking ilista ulit ay lalaki mas mabilis kaysa sa CPU ay bilis. (Lalo na kung kahanay g + + kailanman ay makakakuha ng disenteng.)
akala ko ay isa sabihin na ang code segmentation ay tumutulong upang ipatupad ang "ilang mga interconnections sa pagitan ng mga function na" prinsipyo. (O kahit na ano ito ay tinatawag na pormal na-ang paniwala na ang mga function ay dapat makipag-ugnayan sa lamang ng ilang mga mahusay na tinukoy na paraan.) Ideal na ito ay theoretically kaakit-akit, ngunit tila nakakainis na ipatupad nang walang nagpapahintulot para sa mga pana-panahong mga eksepsiyon. hindi ko gusto na baguhin ang isang kapaki-pakinabang na gabay sa isang matibay na batas ay malamang na lang mabagal ako pababa.
Ako din isulat ang code sa pamamagitan ng aking sarili, kaya ang mga dahilan na kinasasangkutan programming team ay hindi talagang kaugnay. Ang isang mabuting bersyon control system mo paiba-iba ay dapat na-minimize ng mga isyu na ito anyway.
Mayroon bang anumang mga tunay na (ibig sabihin, produktibo, scalability) dahilan sa aabandunahin ito diskarte at simulan ang paglagay ng mga bagong pag-andar sa magkahiwalay na mga file? Hindi ako isang propesyonal na programista, kaya maaring ako ay may hindi nakuha ng isang bagay na ang isang computer science PhD ay isaalang-alang ang halata at nag-uudyok na ...
Dahil ang lisensiya mo ang iyong code sa ilalim ng GPL (kaya talaga welcome ka o hindi bababa sa hindi isip ang iba sa pag-aaral at ibahagi ang iyong code) pagkatapos code manageability ay nice na magkaroon ng na maaaring nakakamit sa pamamagitan ng modularity .
Ang pinaka-mahalagang bagay upang tandaan ay na split ang iyong code ayon sa kung ano ito ay (lohikal paghihiwalay). Upang maging matapat Hindi ko pa tumingin sa iyong code kaya marahil ito ay hindi mag-aplay sa kasong ito (marahil isang tunay malaki file ay ganap).
Ang pagkakaroon ng sinabi na, sa pagtatapos ng araw na walang matibay na batas, mga alituntunin lamang nalikha mula sa karanasan at isang pulutong ng mga pagkakamali:)
Magaling puntos. Salamat para sa mga artikulo.