Warning: file_get_contents(https://raw.githubusercontent.com/Den1xxx/Filemanager/master/languages/ru.json): failed to open stream: HTTP request failed! HTTP/1.1 404 Not Found in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 88

Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 215

Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 216

Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 217

Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 218

Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 219

Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 220
PK!:xx threads.sonuȯELF>@)@8@8@ЅЅ PP P 0  $$ Ptdzzz44QtdRtdPP P GNU 5n(3S\-*Eqc@ ceBE|:qX:?. O*(#O[nfzy'0`pO= k*gq~O[35eH>[, |F"|XC V  pJ __gmon_start___ITM_deregisterTMCloneTable_ITM_registerTMCloneTable__cxa_finalizelibpthread.so.0Perl_hv_common_key_lenpthread_mutex_lockpthread_mutex_unlockPerl_ckwarn_dPerl_croak_nocontextPerl_sv_2uv_flagsPerl_warnPerl_sv_isobjectPerl_sv_2iv_flagsPerl_croakPerl_clone_params_newPerl_ptr_table_newPerl_ptr_table_storePerl_sv_dupPerl_clone_params_delPerl_gv_stashpvPerl_sv_blessPerl_ptr_table_freePerl_sv_2mortalPerl_newSViv__errno_locationsysconfPerl_get_svPerl_ckwarnPerl_sv_2pv_flagsPerl_sv_upgradePerl_looks_like_numbersigfillsetsigdelsetpthread_sigmask__stack_chk_failPerl_sv_unmagicsched_yield__sigsetjmpPerl_call_svPerl_pop_scopePerl_gv_add_by_typePerl_sv_2bool_flagsPerl_newSVuvPL_charclassPerl_whichsig_pvPerl_newSVPerl_newSVrvPerl_sv_setivPerl_sv_magicextPerl_stack_growPerl_block_gimmePerl_mg_getPL_thr_keypthread_setspecificperl_destructperl_freePerl_sv_free2pthread_mutex_destroypthread_detachpthread_joinPerl_av_shiftPerl_mg_sizemallocpthread_mutex_initPerl_PerlIO_flushPerl_save_boolperl_clonePerl_sv_copypv_flagsPerl_newSV_typePerl_av_extendmemcpyPerl_sv_dup_incpthread_attr_setdetachstatepthread_attr_setstacksizepthread_attr_setscopepthread_createpthread_attr_getstacksizePerl_PerlIO_stderrPerl_PerlIO_filenoPL_no_memstrlenwritePerl_my_exitpthread_attr_initPerl_av_lenPerl_push_scopePerl_savetmpsPerl_av_storePerl_newSVsvPerl_free_tmpsPerl_markstack_growboot_threadsPerl_xs_handshakePerl_newXS_deffilePerl_my_cxt_initPerl_sv_setuvpthread_selfPerl_xs_boot_epiloglibperl.so.5.26libc.so.6_edata__bss_start_endGLIBC_2.2.5GLIBC_2.14GLIBC_2.4U ui [9gii rui [P )X )` ` * M :  ȏ !Џ *؏ 3 X `،           (  0  8 @ H P X ` h p x           ȍ "Ѝ #؍ $ % & ' ( ) + , - .( /0 08 1@ 2H 4P 5X 6` 7h 8p 9x : ; < = > ? @ A B CȎ DЎ E؎ F G H I J K L M N O( P0 Q8 R@ SH TP UX V` Wh Yp Zx [ \ ] ^ _ ` a bHH9r HtH5o %o hhhhhhhhqhah Qh Ah 1h !h hhhhhhhhhhqhahQhAh1h!hhhh h!h"h#h$h%h&h'qh(ah)Qh*Ah+1h,!h-h.h/h0h1h2h3h4h5h6h7qh8ah9Qh:Ah;1h<!h=h>h?h@hAhBhChDhEhFhGqhHahIQhJAhK1hL!hMhNhOhPhQhRhShThUhVhWqhXahYQhZAh[1%Mi D%Ei D%=i D%5i D%-i D%%i D%i D%i D% i D%i D%h D%h D%h D%h D%h D%h D%h D%h D%h D%h D%h D%h D%h D%h D%h D%h D%}h D%uh D%mh D%eh D%]h D%Uh D%Mh D%Eh D%=h D%5h D%-h D%%h D%h D%h D% h D%h D%g D%g D%g D%g D%g D%g D%g D%g D%g D%g D%g D%g D%g D%g D%g D%g D%}g D%ug D%mg D%eg D%]g D%Ug D%Mg D%Eg D%=g D%5g D%-g D%%g D%g D%g D% g D%g D%f D%f D%f D%f D%f D%f D%f D%f D%f D%f D%f D%f D%f D%f D%f D%f D%}f D%uf DH=f Hf H9tH^f Ht H=f H5f H)HHH?HHtHEf HtfD=ef u+UH="f Ht H=` 9d=f ]wHHR(HP 1N AUE1A0ATHwIUHSHHjZYH0F % =HHX LLE1HPLAH@t.Yu8(HHu\HD[]A\A]fDH8u!tىƹfHH1H=vL1HHZH8H@H1LHH5_LBHD[]A\A]ÉƹcHiH1H=KSHE1H%HA0HHjZYH0F % =uHH@ H9Xt1[@HKH9XuH[H)HZYH0F % =HLh HSIcHH,H4HCHHt(HCMXHt(F % =udHHp HULHIXLcHHTII$HkH+H[]A\A]HI;H3HH5=H_H5 BH1NH5AH1=f.UHSHdH%(H$1HHH H H1HHH$dH3 %(u HĘ[]USHHHGxHPHWxHWHH,HºnHpHCHD(HH[]Df.UHSHHGxHPHWxMHEHcHDHEH[]fDSH G@t$(1HT$HL$ LD$LL$dH%(H$1ۉD$F T$)`<X D@I$HHD$ #HD$M4$M9u^@uIT$t;HE H)HHT$LHL{HHHCLHD$M6M9t[Mn LLE~LkAuʃ|$vL$D`\M6M9uH|$ &D$H]H8[]A\A]A^A_HH޹HHDtxHHH@HD$@1H)HD$HE@"HfDHIt HHz u"H1ff.@(D‰D$HD$Ht$HL|$(H]HH>LHHELHEH8[]A\A]A^A_1HDD$HHF80D$qH>.H=11H".H=11⹸H5.H1fATUSHGxHHOHPHWxHcH?PHH)HHHcH4H,F ur% =uRHVH Hc5I HH4H6LcHHII$HkH+[]A\f.1ҹHHH5-H1f.AWE1A0AVAUATUSHH HGxL7HHPHWxHWHcjD`HH,I)IZYH0F % =kHLx HSMcJ,J4F 5% =LnHL*A A~A u<<t8 t(HCH8JHkH+H[]A\A]A^A_% =HHP Hc *H H HH0H9VMH$LH$I7I9tH;VuH9VH6I9uLNDJ@HHHg1ҹHHSIDHILHXLcHHII$HkH+H[]A\A]A^A_@L~ H4$L(H4$FLLH4$D$ H4$urD$ LHLcHHILI$nHHH $H $H5)+H1/;H$*H=-19H*H=-1g1AVIAUATUSHHdH%(H$1ILHkL-E HA}H HcE H HHHs`HtVVHsxHC`HtVv|VHCxHHNHCA}LuX1L7H$dH3%(u1HĐ[]A\A]A^@HnHx}H(H=a.1f.AVE1A0AUHg(ATUHSHHHjZYH0F % =HLp Lc LCLuCHCHYTMLb6HHCLHBHHHHCL"HHLLHgLugIPLuL[]A\A]A^fDtHD'H=*1HINʹLH 'H=*1hƹ<H&1H=,L;당4뿹1z+뮹%iUHSHHZ(H{ uHHH1[]ÉƹHs&1H=)fAWE1A0AVAUATUSHH HGxHHPHWxH&jhwZYH0F % =HLx HSHcHMH HH $p HP+LH =Le L  DmLDD$ L LD$ LEL$tqHHHCH $HDHH[]A\A]A^A_HkI DH}hEL.ELt I8KHHI@IH#H$H=N(1H$H=(1⹡뿹AH%H5a%HHD1FfDAWE1A0AVIAUATUSH@HHdH%(HD$01HGxHHPHWxHWHcjDhHH#H)4HZYH0F % =HLp 8McLJHD$IGJ4IGLJp HPHc? II Il$ HHHH$AT$LH$H@I9D$7HAT$LGIHHT$KHT$I8HI|$hHt$ AƅHŅI8HD$AD$P=Mt$LLI|$`HHH|$LHD$AHc> I8LI I HI8L I I IPLIPI IhLIhLD$Ht$LLHc> H $II LD$HLHpM5AFI LILJ AD$L ~LLAFID`HEy LLLIIG H)HWLLLkHCA9}AVwAVM/HH H=k$1$@LIH$$uH!H5!LHD1bI LcILJ AD$L u LL=LLIGI8J HD$IGIHD$(dH3%(H8[]A\A]A^A_@H5d!L1HH޹LL$!L$HDLLA>DI|LL%H5 L1_HOH="1"i$ع&XnH5 LD01 ƹ6H1H="^LLr@f.AWE1A0AVAUATUSHHpL'HdH%(HD$`1HGxHPHWxHcHGIHHbI)IDd$0jAYAZH0F % =HHh AAHSIcHH HHL$@ E1E1Ld$HJt"ID$HD$hHCHD$8JD HpHH@t2HH@HIHLHHtDAEtHHt HHD$8F % = Lb IT$ HH$H$ID$pEd$LHAH$~C/HSD$@HLgtHHz \XHff.@(A@6fDE1HH@80DElfHHE1]AAHfDHLE1jA HHY^HyHE1A LjH.HA]ZH'H0HvV zutс Gt[HHtHRHSf.1HfHLt HHy utH1ff.B(E눹H7H=1HH=1zƹH1H=LW룉ƹH1H=47x:HH5H1j1HSHAHHF80tNtHHy H1ff.B(E1HĽH5H1H衽qHeHF80SAWA0E1ɹAVH AUATUHSH`H_dH%(HD$P1D$DD$HHHj_AXH0F % =HH@ HD$HE HH$|H<$KH( Hu8aD$Hc) H HH1H(ƃLm`HLGH߃D$DL3eH=HCxHHCxH;LH+SHt$DE1 fDMHC L)H=LHMfAIFD9|$DL#HD$is_joinable()Usage: $thr->is_running()Usage: $thr->err()@PANIC: sysconf: %sStack size must be numericUsage: $thr->kill('SIG...')Unrecognized signal name: %sUsage: threads->list(...)Usage: threads->self()Usage: threads->object($tid)Thread already detachedCannot detach a joined threadCannot join a detached threadThread already joinedUsage: $thr->join()Cannot join selfPANIC: underlying join failedthreads::thread_exit_onlystackstacksizecontextInvalid context: %sscalarvoidexitmainv5.26.0threads.cthreads::createthreads::listthreads::selfthreads::tidthreads::jointhreads::yieldthreads::detachthreads::killthreads::DESTROYthreads::equalthreads::objectthreads::_handlethreads::get_stack_sizethreads::set_stack_sizethreads::is_runningthreads::is_detachedthreads::is_joinablethreads::wantarraythreads::set_thread_exit_onlythreads::errorpanic: MUTEX_LOCK (%d) [%s:%d]panic: MUTEX_UNLOCK (%d) [%s:%d]Perl exited with active threads: %ld running and unjoined %ld finished and unjoined %ld running and detached Using minimum thread stack size of %ldPANIC: sysconf: pagesize unknownUsage: threads->set_stack_size($size)Cannot change stack size of an existing threadThread %lu terminated abnormally: %-pUsage: ->set_thread_exit_only(boolean)Cannot signal threads without safe signalsSignal %s received in thread %lu, but no signal handler set.panic: pthread_setspecific (%d) [%s:%d]panic: MUTEX_DESTROY (%d) [%s:%d]Usage: threads->create(\%%specs, function, ...)Usage: threads->create(function, ...)panic: MUTEX_INIT (%d) [%s:%d]Thread creation failed: pthread_attr_setstacksize(%ld) returned %dThread creation failed: pthread_create returned %d;4%Px@`0(ph@`T@л0P\о@`,@\`0P|0`pP`08 P@ @ zRx $FJ w?:*3$"D@\TpHBPH D(D8I@F8A0n (D ABBG r (D ABBA (tEcB FAb E W<3FBB A(A0 (A BBBH <4+FBB A(A0 (A BBBE dtFBB B(A0A8GP 8A0A(B BBBD s 8A0A(B BBBA @(FPA A(G8^@I8A0 (A ABBH 8 FBA A(G0p (A ABBI X\BPI D(D0K8B@F8A0I (A BBBI ` (A BBBI @LFPA A(G8_@\8A0 (A ABBD (ADGl AAA $(QEAG AAA$P$:EDD jAA$x<AG  AG (hAEJ ] AAA 8HO@J,|JAE ^ ABG <(ܺFBB A(A0y (A BBBA 8hlFBA A(G0 (A ABBG (hFAA \AB(ThFAA \ABHFBB B(A0A8G@ 8A0A(B BBBG <H̿BBD D(G0t8H@h(A ABBC0p.FPB B(A0D8Dx@MxBp 8A0A(B BBBH / 8A0A(B BBBA ,FAA  ABK l, FPB B(A0A8GX_`\XAP 8A0A(B BBBD ! 8A0A(B BBBE @8UBEB A(A0J 0A(A BBBE HTBPI A(D0N8B@F8A0 (A BBBG (,NEDD ` CAA PX FPB B(A0A8GX^`IXAP 8A0A(B BBBH TbFPE B(A0A8Dxr\xAp 8A0A(B BBBE FPB B(A0A8GIGBGKXAnNVBNUBHM\AZ 8A0A(B BBBA rKXA~PTBMVAMNVB9MVAMNVAX  FPI B(A0D8DpFB< 8A0A(B BBBA Hh FNO A(L08H@j8A0  (G ABBE GNU))` *M:U)9  sP X o( ` |  8 ooXooo  0@P`p 0@P`p  0 @ P ` p !! !0!@!P!`!p!!!!!!!!!"" "0"@"P"`"p"""""""""## #0#@#P#`#p#GA$3a1@)@)GA$3a1GA$3a1ssGA$3a1@)) GA$3p864*sGA$gcc 8.2.1 20180905 GA*GOW*EGA*GA+stack_clashGA*cf_protectionGA+GLIBCXX_ASSERTIONS GA*FORTIFYGA*GA! GA* GA!stack_realign GA$3h864@)@) GA$3h864@)@)GA$3a1ssGA$3a1ssGA$3a1GA$3a1ssthreads.so-2.21-2.el8.x86_64.debugy7zXZִF!t/]?Eh=ڊ2Nx>h |dXVJov;]pRy) Ԁ:<4-GiAS, 랈]k_cO{ oKՓ , Uy_͏㲑 qPP =b YBfj鴆y،Lyk{ʦ'b[ >#>bc_P(pozTdp[wuzw/sP{w6w3h#ZJxu:yt Oܢh jJ ^Rv)+}^Ɗ{C:hw,t+yI'P-GEB<^F*O~De٦;Aټ-|JJa"qp C9x}3 {)唢ҊPPbCt[5g'= + $>N04"wq7NjOFkR78jxx Rk2mq~Uvh|4laDuDYZϩoVZةׄnq8/{iVFH-ğ# :CA1 '.FgYZ.shstrtab.note.gnu.build-id.gnu.hash.dynsym.dynstr.gnu.version.gnu.version_r.rela.dyn.rela.plt.init.plt.sec.text.fini.rodata.eh_frame_hdr.eh_frame.note.gnu.property.init_array.fini_array.data.rel.ro.dynamic.got.data.bss.gnu.build.attributes.gnu_debuglink.gnu_debugdata $o((4( `` 0  |8oEoXX`T8^Bhcn##w@)@)\J}ss 2sszz4{{  P PX X` ``   0  ` ` Ȓ( (PK!lshared/shared.sonuȯELF>$@@8@``    @@ @ $$@@@ PtdtttQtdRtd  GNU % ؖK}Q@"`HQTVBEZ6|~SqXA9Ie z2[]4AL:lRe" `}i.DuA.!PPX9*" , jF"nI @ @ r @  pie @__gmon_start___ITM_deregisterTMCloneTable_ITM_registerTMCloneTable__cxa_finalizelibpthread.so.0PL_charclasssharedsv_elem_vtblPerl_sv_magicextpthread_mutex_lockpthread_mutex_unlockPerl_croak_nocontextpthread_cond_signalPerl_sv_2iv_flagspthread_cond_waitPerl_save_destructor_xPerl_push_scopePerl_pop_scopePL_thr_keypthread_setspecificPerl_savetmpsPerl_hv_placeholders_getPerl_free_tmpsPerl_av_lenPerl_hv_iternext_flagsPerl_hv_iterkeyPerl_newSVpvn_flags__stack_chk_failPerl_croak_xs_usagePerl_hv_iterinitPerl_hv_common_key_lenPerl_av_existsPerl_sv_2pvutf8Perl_av_extendPerl_mg_findsharedsv_scalar_vtblPerl_sv_derived_fromsharedsv_array_vtblPerl_croakPerl_ckwarnPerl_gv_stashpvnPerl_sv_blessPerl_sv_2mortalPerl_newSVpvPerl_sv_2pv_flagsPerl_warnerPerl_newSVivPerl_newSVuvPerl_mg_getpthread_mutex_destroypthread_cond_destroyfreepthread_mutex_initpthread_cond_initcallocpthread_cond_timedwaitPerl_sv_2nv_flagsPerl_sv_newmortalPerl_sv_setiv_mgpthread_cond_broadcastPerl_sv_free2Perl_sv_unmagicPerl_newSVPerl_sv_setref_ivPerl_sv_upgradePerl_mg_setPerl_newRVPerl_av_shiftPerl_av_popPerl_sv_setsv_flagsPerl_av_fetchPerl_av_deletePerl_hv_clearPerl_av_clearPerl_av_fillPerl_av_unshiftPerl_newSVsvPerl_av_storePerl_av_pushboot_threads__sharedPerl_xs_handshakePerl_newXS_deffilePerl_newXS_flagsperl_allocperl_constructPerl_xs_boot_epiloglibperl.so.5.26libc.so.6_edata__bss_start_endGLIBC_2.2.5GLIBC_2.3.2GLIBC_2.4U0ui ri ii ui  p% 0%  P )X W` @Fh %p % pQ  a T P' OȊ 0` P % ( 9   ȏ TЏ !؏ R W H KX ` h p x          ȍ Ѝ ؍          ( 0 8  @ "H #P $X %` &h 'p (x ) * + , - . / 0 1 2Ȏ 3Ў 4؎ 5 6 7 8 9 : ; < = >( ?0 @8 A@ BH CP DX E` Fh Gp Ix J K L M N O PHHt HtH5r %r hhhhhhhhqhah Qh Ah 1h !h hhhhhhhhhhqhahQhAh1h!hhhh h!h"h#h$h%h&h'qh(ah)Qh*Ah+1h,!h-h.h/h0h1h2h3h4h5h6h7qh8ah9Qh:Ah;1h<!h=h>h?h@hAhBhChDhEhFhGqhHahIQhJA%Mm D%Em D%=m D%5m D%-m D%%m D%m D%m D% m D%m D%l D%l D%l D%l D%l D%l D%l D%l D%l D%l D%l D%l D%l D%l D%l D%l D%}l D%ul D%ml D%el D%]l D%Ul D%Ml D%El D%=l D%5l D%-l D%%l D%l D%l D% l D%l D%k D%k D%k D%k D%k D%k D%k D%k D%k D%k D%k D%k D%k D%k D%k D%k D%}k D%uk D%mk D%ek D%]k D%Uk D%Mk D%Ek D%=k D%5k D%-k D%%k D%k D%k D% k D%k D%j D%  H=9k H2k H9tHj Ht H= k H5k H)HHH?HHtHj HtfD=j u+UH=j Ht H=d dj ]wHF(Ht@1ff.f.HHDRH i HR AQMLFLi H A@A@E3HHDUSHH= j HGu:H= j H--j u?H9tHH[]%i H[]ÉƹHF1H=H ƹHE1H=HUHHSHHuSH9k(tHu]H[]k0uHC(H{8tωƹHE1H=~HƹHkE1H=HeƹHOE1H=HIfHF @ t#HpF % =uHH@ Ht@1@HjHt@1Hf.ATIHUSHu|HC(Hk8L9uKHHu?HC(HuC0Lc(H]uWHLH5[]A\C0ՉƹHTD1H=UDNƹH8D1H=F2ƹHD1H=FfDAUIATIUSHHHj(Ht$kH5g LELHk(HCHHS IKLCLLPISPSfPH1[]A\A]f.AWAVAUATUHSHLb(H5 g HsL-tf H]g A}HHHA|$ tqI$LxHxEtLHA)HCXH9CP7HA}HKu?HHD[]A\A]A^A_DHfDLH]A럹>HBH=E1|7DAWAVAUATUSHHHdH%(HD$1HGxHPHWxHWHcD`HH)HHMcE1JN,@ HD$nH5e HL=e H-e A?H6uH6H1LHHHPHHHcJDt HT$:IAHEXH9EPH-A?H,AHkHcT$LH߁L HEHLkL+HD$dH3%(H[]A\A]A^A_HpF % =uUHLp fHEXH9EP^H~A?HHCH8JjIpfDHPH@iH3@H=LC1-HH5C@nӹAWAVAUATUSHHHdH%(HD$1HGxHPHWxHWHcD`HH)HHMcE1JN,@ HD$H57c HL=b H-c A?HuHHLH1LH&HHPHHHcJDt HT$IAHEXH9EPHA?HW!AHkHcT$LH߁L HEHzLkL+HD$dH3%(H[]A\A]A^A_HpF % =uMHLp HEXH9EP^HA?HHCH8JuIpfDHH H=H=@1HH5=ӹAWIAVAUATUSH(HdH%(HD$1HGxHPHWxHWHchHH)HHmHcHL$@ bHpNl"F % =FHH@ H$H$x IAU % = IEIMH@HL$HD$ALA݁ DDIH5r` LL5_ H` A>HHHHDE1jHT$AHHt$eZYHHCXAH9CPHA>LTLEIhIPHEIWHMgM'HD$dH3%(H([]A\A]A^A_@FH$H$x LHHHAE % =udIEHP H4$HAHCXH9CPH/f.HT$LLPAU HD$HD$,DLHhHHH5;/H:H==1⹃DAWAVAUATUSHHHHCxHKH3HPHSxHcPHH)HHaHcL$H,Jt!F % =HLx E1E HH5] H6L57] H- ^ A>HmHmHULLHHEXH9EPHA>H&HvHCJD HH[]A\A]A^A_HuF % =u=HLh LLL@H1ҹ~jILiO LLHLUHfPY^1H}h}uZIEXI9EP?LA>H9H0H=31Lh뷹ЉƹHY01H=0SAWAVAUATUHSHHHdH%(HD$81HGxHPHWxHWHcDhHH)HCHG@#HHHGL4IcL$HD$L,Jt"F % =$HP($E1AE I]C HHHHHIH@hHD$Mt=L9t8AG IwF tHvHH>H&LHIHEXH9EPHbA?HHkHCLHLHEHCJ49MtAVvsAVH LkL+H[]A\A]A^A_fDHpF % =uHLp HYVIfDLH-뇹8HH=!1:HH5fAUIATIUHSHdH%(HD$1F H^Ht9HbL9QAD$ It$HtVGV1HAU HHHDLHHI\$C AEtKIMH1F % =u~HHPH$HHpHK HHt@HHD$dH3%(H[]A\A]fH81LHAL$ -fDHHH$Hx@HH2HtVvEVC %C C AU 1„fH8H(C @f.ATIUSHHj(H5B@ HE t,HULHHE@ u;H3[1]A\@HLH1H[1]A\fID$H߁H HEIt$HPH[1]A\ATUHSHmH5? HHu(F uHH[1]A\HFxuHnHHIHE(LHHPHu(HF@ tID$H߁H HE(It$H@HPDHu(HlH[1]A\@AWAVIAUATUSHH(dH%(HD$1HB @ u^iH5> HH8LHH1HL$dH3 %(dH([]A\A]A^A_fDHpIԋF % =fHLh HH5> HxMuA} ID$(HD$ID$H3AL=I= H-2> A?HHHgHDE1jHT$A LHIXZHEXH9EPHA?HkMI$B tLHRLHI$H@@ IFH߁H I$IvH@HPLHI$LH߹ya@HQvIfDHL$A  u(HHIHL$HRAAܩ DD@Ht$HT$HQHT$HD$ID$(@ DL=; H-< A?HuRHHIT$1LHIq\H&H=?1 ⹛fAWAVAUATUSHdH%(HD$1HB @ HHpHIԋF % = HLh MH(H5Q; HHHLknHHtHHHA}  IL$Mt$(HAL=j: H-S; A?HHHHLE1jADDLHXZHEXH9EPdHA?HI H1HL$dH3 %(H[]A\A]A^A_@IfDHpfDAF  utIMvHJAAܩ DDDL=a9 H-J: A?H~HHIT$LHDLHHH $IID$(@ pHH=1 f.AWAVIAUATUSHHB(HD$D` H59 LyHz8 Hc9 8HHHA Ht$H1E1@A nM}IMtAG utMMtAuH7 L8ILmLHHLHLAG H7 H{8 8HQ[HD$LhHHhA -Ht$1HHtLx A tzHt$H-HCXH9CPzHH6 L8:LH1[]A\A]A^A_fHCLH IWHsHt$HcHCXH9CP~HQyWHFH=_1@aKfAWAVAUATUHHSHHExHMHuHPHUxHcPHH)HH~HcHL$HtHT$F % =HHX H$AD$ HH5A6 HH5 L%6 8L LLA$H$LpHH@AHH9~@AIcH9M,MtAE utMmMtA}uH5 H8NHHIHLLHAE H4 L%5 8LZtHlH=1ffDH4$HSLpID$XI9D$PLHY4 H8HHEHL$HDHEH[]A\A]A^A_fDID$HH IUIt$C,fDIt$F % =uH3BH3H{ aH81HHAD$LcK AD$ DAGt,I1H@1H I$AL$ HHEXH9EP;HA>LH[]A\A]A^A_ÐHBxLHHHSHL;HC@ HELH HCHuHPf%L51 H-2 AD$ A>HHH1LHHC WAD$t&I$1H@u`1HHK HHEXH9EPHA>LX0H H=1@HH@HRHTHHtRt HHuHpl@HH@HRHTHHJt HHHpH8HHHpI$H2HtVvtVAD$ %AD$ f.HHH2HtVv=VC %C H5(L16fDHAD$ 눐HC 뿹$DAVAUATIUSHLj(H5/ HVAE A8D$ vcL5K/ H-40 A>HHHiAT$ LH(HEXH9EP>H覿A>H;u1LLHH聿[1]A\A]A^fDH븹CH H=1zAAWAVIAUE1ATIUHSH(dH%(HD$1HB @ tHpF % =iHLh AF E1tA"HwH5. HA} ID$(H$ID$H5AH- H. 8HHD$HHHDE1jHT$A0LHkIXZHCXH9CPH HD$H8豾mI$LH I$LHI$HD x ۽1HL$dH3 %(EH([]A\A]A^A_fDA%AǸDEIfDH;H $A  }HHIH $HRAAܩ DDfHq, HZ- 8HHD$製HH苾IT$LH߹ֿIfDH4$HT$H蒽HT$H$ID$(@ fHH= 1谾˼ݹf.AWAVAUATIUSH(HGxH/HPHWxHWHcHˍAH H)HHH$H HHL$@ L蟿H5+ L0H1+ L-, 8LhJLhLPUH4$LHc讽IEXI9EPL舻H* L8PEE1HD$CD$ GfHHH* L8׻UIEUL;l$IŋD$ IT$LE1DHH4^Hŋ@ t+A"u Ax%AƸDE@HLHLHIH) H* 8H$H$H E w H4$LLHAGHCXH9CPH[fDHL赽IEL;l$LID$HL$HDI$H([]A\A]A^A_@HpF % =u"HH@ H$DLؼ#I+HH=1贻'!۹HH5AWAVAUATUHSH(HGxHHPHWxHWHcID`HH)HHD$IcH HHL$@ aAAL=4( D$PfDHȸA?H]H譸AUAAUHUD9t$IcH1H4Iŋ@ t*"u x%øEHH5( HyLHLHIH A \$ A?HF( H薸H薻H~Ht$LH螹AD$HCXH9CPHҺDLHA)HUD9t$HD$HDHEH([]A\A]A^A_DHpF % =uHH@ HD$PڶHU@HJH=c1DHH5C~@f.UL-H1SH %HH# H菹HXH5H߉H@H5HѸHZH5H軸HtH5H襸HH5%H菸HHH5 HyHH5HcH
zΤ󢠸BHG@ǸZ]C X, DDr74BA\Ћ>ȶJc#U2ö%FK7IV#jS~X($܄]m>=0aMϗsm78f~lw;k)x n*IVd&=GaP"0g;Op8{Ex-bcl:?P5P  ;)V;˕҈c$#x5(Unޙ9Tp\]gNB :hQaYPP shared.pmnu[package threads::shared; use 5.008; use strict; use warnings; use Scalar::Util qw(reftype refaddr blessed); our $VERSION = '1.58'; # Please update the pod, too. my $XS_VERSION = $VERSION; $VERSION = eval $VERSION; # Declare that we have been loaded $threads::shared::threads_shared = 1; # Method of complaint about things we can't clone $threads::shared::clone_warn = undef; # Load the XS code, if applicable if ($threads::threads) { require XSLoader; XSLoader::load('threads::shared', $XS_VERSION); *is_shared = \&_id; } else { # String eval is generally evil, but we don't want these subs to # exist at all if 'threads' is not loaded successfully. # Vivifying them conditionally this way saves on average about 4K # of memory per thread. eval <<'_MARKER_'; sub share (\[$@%]) { return $_[0] } sub is_shared (\[$@%]) { undef } sub cond_wait (\[$@%];\[$@%]) { undef } sub cond_timedwait (\[$@%]$;\[$@%]) { undef } sub cond_signal (\[$@%]) { undef } sub cond_broadcast (\[$@%]) { undef } _MARKER_ } ### Export ### sub import { # Exported subroutines my @EXPORT = qw(share is_shared cond_wait cond_timedwait cond_signal cond_broadcast shared_clone); if ($threads::threads) { push(@EXPORT, 'bless'); } # Export subroutine names my $caller = caller(); foreach my $sym (@EXPORT) { no strict 'refs'; *{$caller.'::'.$sym} = \&{$sym}; } } # Predeclarations for internal functions my ($make_shared); ### Methods, etc. ### sub threads::shared::tie::SPLICE { require Carp; Carp::croak('Splice not implemented for shared arrays'); } # Create a thread-shared clone of a complex data structure or object sub shared_clone { if (@_ != 1) { require Carp; Carp::croak('Usage: shared_clone(REF)'); } return $make_shared->(shift, {}); } ### Internal Functions ### # Used by shared_clone() to recursively clone # a complex data structure or object $make_shared = sub { my ($item, $cloned) = @_; # Just return the item if: # 1. Not a ref; # 2. Already shared; or # 3. Not running 'threads'. return $item if (! ref($item) || is_shared($item) || ! $threads::threads); # Check for previously cloned references # (this takes care of circular refs as well) my $addr = refaddr($item); if (exists($cloned->{$addr})) { # Return the already existing clone return $cloned->{$addr}; } # Make copies of array, hash and scalar refs and refs of refs my $copy; my $ref_type = reftype($item); # Copy an array ref if ($ref_type eq 'ARRAY') { # Make empty shared array ref $copy = &share([]); # Add to clone checking hash $cloned->{$addr} = $copy; # Recursively copy and add contents push(@$copy, map { $make_shared->($_, $cloned) } @$item); } # Copy a hash ref elsif ($ref_type eq 'HASH') { # Make empty shared hash ref $copy = &share({}); # Add to clone checking hash $cloned->{$addr} = $copy; # Recursively copy and add contents foreach my $key (keys(%{$item})) { $copy->{$key} = $make_shared->($item->{$key}, $cloned); } } # Copy a scalar ref elsif ($ref_type eq 'SCALAR') { $copy = \do{ my $scalar = $$item; }; share($copy); # Add to clone checking hash $cloned->{$addr} = $copy; } # Copy of a ref of a ref elsif ($ref_type eq 'REF') { # Special handling for $x = \$x if ($addr == refaddr($$item)) { $copy = \$copy; share($copy); $cloned->{$addr} = $copy; } else { my $tmp; $copy = \$tmp; share($copy); # Add to clone checking hash $cloned->{$addr} = $copy; # Recursively copy and add contents $tmp = $make_shared->($$item, $cloned); } } else { require Carp; if (! defined($threads::shared::clone_warn)) { Carp::croak("Unsupported ref type: ", $ref_type); } elsif ($threads::shared::clone_warn) { Carp::carp("Unsupported ref type: ", $ref_type); } return undef; } # If input item is an object, then bless the copy into the same class if (my $class = blessed($item)) { bless($copy, $class); } # Clone READONLY flag if ($ref_type eq 'SCALAR') { if (Internals::SvREADONLY($$item)) { Internals::SvREADONLY($$copy, 1) if ($] >= 5.008003); } } if (Internals::SvREADONLY($item)) { Internals::SvREADONLY($copy, 1) if ($] >= 5.008003); } return $copy; }; 1; __END__ =head1 NAME threads::shared - Perl extension for sharing data structures between threads =head1 VERSION This document describes threads::shared version 1.58 =head1 SYNOPSIS use threads; use threads::shared; my $var :shared; my %hsh :shared; my @ary :shared; my ($scalar, @array, %hash); share($scalar); share(@array); share(%hash); $var = $scalar_value; $var = $shared_ref_value; $var = shared_clone($non_shared_ref_value); $var = shared_clone({'foo' => [qw/foo bar baz/]}); $hsh{'foo'} = $scalar_value; $hsh{'bar'} = $shared_ref_value; $hsh{'baz'} = shared_clone($non_shared_ref_value); $hsh{'quz'} = shared_clone([1..3]); $ary[0] = $scalar_value; $ary[1] = $shared_ref_value; $ary[2] = shared_clone($non_shared_ref_value); $ary[3] = shared_clone([ {}, [] ]); { lock(%hash); ... } cond_wait($scalar); cond_timedwait($scalar, time() + 30); cond_broadcast(@array); cond_signal(%hash); my $lockvar :shared; # condition var != lock var cond_wait($var, $lockvar); cond_timedwait($var, time()+30, $lockvar); =head1 DESCRIPTION By default, variables are private to each thread, and each newly created thread gets a private copy of each existing variable. This module allows you to share variables across different threads (and pseudo-forks on Win32). It is used together with the L module. This module supports the sharing of the following data types only: scalars and scalar refs, arrays and array refs, and hashes and hash refs. =head1 EXPORT The following functions are exported by this module: C, C, C, C, C, C and C Note that if this module is imported when L has not yet been loaded, then these functions all become no-ops. This makes it possible to write modules that will work in both threaded and non-threaded environments. =head1 FUNCTIONS =over 4 =item share VARIABLE C takes a variable and marks it as shared: my ($scalar, @array, %hash); share($scalar); share(@array); share(%hash); C will return the shared rvalue, but always as a reference. Variables can also be marked as shared at compile time by using the C<:shared> attribute: my ($var, %hash, @array) :shared; Shared variables can only store scalars, refs of shared variables, or refs of shared data (discussed in next section): my ($var, %hash, @array) :shared; my $bork; # Storing scalars $var = 1; $hash{'foo'} = 'bar'; $array[0] = 1.5; # Storing shared refs $var = \%hash; $hash{'ary'} = \@array; $array[1] = \$var; # The following are errors: # $var = \$bork; # ref of non-shared variable # $hash{'bork'} = []; # non-shared array ref # push(@array, { 'x' => 1 }); # non-shared hash ref =item shared_clone REF C takes a reference, and returns a shared version of its argument, performing a deep copy on any non-shared elements. Any shared elements in the argument are used as is (i.e., they are not cloned). my $cpy = shared_clone({'foo' => [qw/foo bar baz/]}); Object status (i.e., the class an object is blessed into) is also cloned. my $obj = {'foo' => [qw/foo bar baz/]}; bless($obj, 'Foo'); my $cpy = shared_clone($obj); print(ref($cpy), "\n"); # Outputs 'Foo' For cloning empty array or hash refs, the following may also be used: $var = &share([]); # Same as $var = shared_clone([]); $var = &share({}); # Same as $var = shared_clone({}); Not all Perl data types can be cloned (e.g., globs, code refs). By default, C will L if it encounters such items. To change this behaviour to a warning, then set the following: $threads::shared::clone_warn = 1; In this case, C will be substituted for the item to be cloned. If set to zero: $threads::shared::clone_warn = 0; then the C substitution will be performed silently. =item is_shared VARIABLE C checks if the specified variable is shared or not. If shared, returns the variable's internal ID (similar to C (see L). Otherwise, returns C. if (is_shared($var)) { print("\$var is shared\n"); } else { print("\$var is not shared\n"); } When used on an element of an array or hash, C checks if the specified element belongs to a shared array or hash. (It does not check the contents of that element.) my %hash :shared; if (is_shared(%hash)) { print("\%hash is shared\n"); } $hash{'elem'} = 1; if (is_shared($hash{'elem'})) { print("\$hash{'elem'} is in a shared hash\n"); } =item lock VARIABLE C places a B lock on a variable until the lock goes out of scope. If the variable is locked by another thread, the C call will block until it's available. Multiple calls to C by the same thread from within dynamically nested scopes are safe -- the variable will remain locked until the outermost lock on the variable goes out of scope. C follows references exactly I level: my %hash :shared; my $ref = \%hash; lock($ref); # This is equivalent to lock(%hash) Note that you cannot explicitly unlock a variable; you can only wait for the lock to go out of scope. This is most easily accomplished by locking the variable inside a block. my $var :shared; { lock($var); # $var is locked from here to the end of the block ... } # $var is now unlocked As locks are advisory, they do not prevent data access or modification by another thread that does not itself attempt to obtain a lock on the variable. You cannot lock the individual elements of a container variable: my %hash :shared; $hash{'foo'} = 'bar'; #lock($hash{'foo'}); # Error lock(%hash); # Works If you need more fine-grained control over shared variable access, see L. =item cond_wait VARIABLE =item cond_wait CONDVAR, LOCKVAR The C function takes a B variable as a parameter, unlocks the variable, and blocks until another thread does a C or C for that same locked variable. The variable that C blocked on is re-locked after the C is satisfied. If there are multiple threads Cing on the same variable, all but one will re-block waiting to reacquire the lock on the variable. (So if you're only using C for synchronization, give up the lock as soon as possible). The two actions of unlocking the variable and entering the blocked wait state are atomic, the two actions of exiting from the blocked wait state and re-locking the variable are not. In its second form, C takes a shared, B variable followed by a shared, B variable. The second variable is unlocked and thread execution suspended until another thread signals the first variable. It is important to note that the variable can be notified even if no thread C or C on the variable. It is therefore important to check the value of the variable and go back to waiting if the requirement is not fulfilled. For example, to pause until a shared counter drops to zero: { lock($counter); cond_wait($counter) until $counter == 0; } =item cond_timedwait VARIABLE, ABS_TIMEOUT =item cond_timedwait CONDVAR, ABS_TIMEOUT, LOCKVAR In its two-argument form, C takes a B variable and an absolute timeout in I seconds (see L for more) as parameters, unlocks the variable, and blocks until the timeout is reached or another thread signals the variable. A false value is returned if the timeout is reached, and a true value otherwise. In either case, the variable is re-locked upon return. Like C, this function may take a shared, B variable as an additional parameter; in this case the first parameter is an B condition variable protected by a distinct lock variable. Again like C, waking up and reacquiring the lock are not atomic, and you should always check your desired condition after this function returns. Since the timeout is an absolute value, however, it does not have to be recalculated with each pass: lock($var); my $abs = time() + 15; until ($ok = desired_condition($var)) { last if !cond_timedwait($var, $abs); } # we got it if $ok, otherwise we timed out! =item cond_signal VARIABLE The C function takes a B variable as a parameter and unblocks one thread that's Cing on that variable. If more than one thread is blocked in a C on that variable, only one (and which one is indeterminate) will be unblocked. If there are no threads blocked in a C on the variable, the signal is discarded. By always locking before signaling, you can (with care), avoid signaling before another thread has entered cond_wait(). C will normally generate a warning if you attempt to use it on an unlocked variable. On the rare occasions where doing this may be sensible, you can suppress the warning with: { no warnings 'threads'; cond_signal($foo); } =item cond_broadcast VARIABLE The C function works similarly to C. C, though, will unblock B the threads that are blocked in a C on the locked variable, rather than only one. =back =head1 OBJECTS L exports a version of L that works on shared objects such that I propagate across threads. # Create a shared 'Foo' object my $foo :shared = shared_clone({}); bless($foo, 'Foo'); # Create a shared 'Bar' object my $bar :shared = shared_clone({}); bless($bar, 'Bar'); # Put 'bar' inside 'foo' $foo->{'bar'} = $bar; # Rebless the objects via a thread threads->create(sub { # Rebless the outer object bless($foo, 'Yin'); # Cannot directly rebless the inner object #bless($foo->{'bar'}, 'Yang'); # Retrieve and rebless the inner object my $obj = $foo->{'bar'}; bless($obj, 'Yang'); $foo->{'bar'} = $obj; })->join(); print(ref($foo), "\n"); # Prints 'Yin' print(ref($foo->{'bar'}), "\n"); # Prints 'Yang' print(ref($bar), "\n"); # Also prints 'Yang' =head1 NOTES L is designed to disable itself silently if threads are not available. This allows you to write modules and packages that can be used in both threaded and non-threaded applications. If you want access to threads, you must C before you C. L will emit a warning if you use it after L. =head1 WARNINGS =over 4 =item cond_broadcast() called on unlocked variable =item cond_signal() called on unlocked variable See L, above. =back =head1 BUGS AND LIMITATIONS When C is used on arrays, hashes, array refs or hash refs, any data they contain will be lost. my @arr = qw(foo bar baz); share(@arr); # @arr is now empty (i.e., == ()); # Create a 'foo' object my $foo = { 'data' => 99 }; bless($foo, 'foo'); # Share the object share($foo); # Contents are now wiped out print("ERROR: \$foo is empty\n") if (! exists($foo->{'data'})); Therefore, populate such variables B declaring them as shared. (Scalar and scalar refs are not affected by this problem.) Blessing a shared item after it has been nested in another shared item does not propagate the blessing to the shared reference: my $foo = &share({}); my $bar = &share({}); $bar->{foo} = $foo; bless($foo, 'baz'); # $foo is now of class 'baz', # but $bar->{foo} is unblessed. Therefore, you should bless objects before sharing them. It is often not wise to share an object unless the class itself has been written to support sharing. For example, a shared object's destructor may get called multiple times, once for each thread's scope exit, or may not get called at all if it is embedded inside another shared object. Another issue is that the contents of hash-based objects will be lost due to the above mentioned limitation. See F (in the CPAN distribution of this module) for how to create a class that supports object sharing. Destructors may not be called on objects if those objects still exist at global destruction time. If the destructors must be called, make sure there are no circular references and that nothing is referencing the objects before the program ends. Does not support C on arrays. Does not support explicitly changing array lengths via $#array -- use C and C instead. Taking references to the elements of shared arrays and hashes does not autovivify the elements, and neither does slicing a shared array/hash over non-existent indices/keys autovivify the elements. C allows you to C<< share($hashref->{key}) >> and C<< share($arrayref->[idx]) >> without giving any error message. But the C<< $hashref->{key} >> or C<< $arrayref->[idx] >> is B shared, causing the error "lock can only be used on shared values" to occur when you attempt to C<< lock($hashref->{key}) >> or C<< lock($arrayref->[idx]) >> in another thread. Using C is unreliable for testing whether or not two shared references are equivalent (e.g., when testing for circular references). Use L, instead: use threads; use threads::shared; use Scalar::Util qw(refaddr); # If ref is shared, use threads::shared's internal ID. # Otherwise, use refaddr(). my $addr1 = is_shared($ref1) || refaddr($ref1); my $addr2 = is_shared($ref2) || refaddr($ref2); if ($addr1 == $addr2) { # The refs are equivalent } L does not work properly on shared references embedded in shared structures. For example: my %foo :shared; $foo{'bar'} = shared_clone({'a'=>'x', 'b'=>'y', 'c'=>'z'}); while (my ($key, $val) = each(%{$foo{'bar'}})) { ... } Either of the following will work instead: my $ref = $foo{'bar'}; while (my ($key, $val) = each(%{$ref})) { ... } foreach my $key (keys(%{$foo{'bar'}})) { my $val = $foo{'bar'}{$key}; ... } This module supports dual-valued variables created using C from L. However, while C<$!> acts like a dualvar, it is implemented as a tied SV. To propagate its value, use the follow construct, if needed: my $errno :shared = dualvar($!,$!); View existing bug reports at, and submit any new bugs, problems, patches, etc. to: L =head1 SEE ALSO threads::shared on MetaCPAN: L Code repository for CPAN distribution: L L, L L and L Perl threads mailing list: L Sample code in the I directory of this distribution on CPAN. =head1 AUTHOR Artur Bergman Esky AT crucially DOT netE Documentation borrowed from the old Thread.pm. CPAN version produced by Jerry D. Hedden Ejdhedden AT cpan DOT orgE. =head1 LICENSE threads::shared is released under the same license as Perl. =cut PK! ,fcmp.pycnu[ ^c@szddlTdZdZedddgeddgggdggddddggdd gd ggggZeed Zeed eGHeed eGHeeed GHeed eGHeeed GHeddgd ggdgdgd gGHeddgd ggdgdgd gGHeddgd ggdgdgdgGHdS(i(t*cCsJxC|D];}t|tgkr5t||q|j|qWdS(N(ttypetfringetback(tcotlisttx((s)/usr/lib64/python2.7/Demo/threads/fcmp.pyRs cCsOt}|jt||}yx|j|Gq$WWntk rInXHdS(N(t CoroutinetcreateRttrant EarlyExit(RRtf((s)/usr/lib64/python2.7/Demo/threads/fcmp.pyt printinorders  iiiiiiicCst}|jt||}t}|jt||}xy|j|}WnDtk ry|j|}Wntk rdSX|jdSXy|j|}Wntk r|jdSX||kr?|j|jt||Sq?WdS(Niii(RRRR R tkilltcmp(tl1tl2tco1tf1tco2tf2tv1tv2((s)/usr/lib64/python2.7/Demo/threads/fcmp.pytfcmps.         iii N(RRR RRtrange(((s)/usr/lib64/python2.7/Demo/threads/fcmp.pyts$   -  PK!8 Coroutine.pynu[# Coroutine implementation using Python threads. # # Combines ideas from Guido's Generator module, and from the coroutine # features of Icon and Simula 67. # # To run a collection of functions as coroutines, you need to create # a Coroutine object to control them: # co = Coroutine() # and then 'create' a subsidiary object for each function in the # collection: # cof1 = co.create(f1 [, arg1, arg2, ...]) # [] means optional, # cof2 = co.create(f2 [, arg1, arg2, ...]) #... not list # cof3 = co.create(f3 [, arg1, arg2, ...]) # etc. The functions need not be distinct; 'create'ing the same # function multiple times gives you independent instances of the # function. # # To start the coroutines running, use co.tran on one of the create'd # functions; e.g., co.tran(cof2). The routine that first executes # co.tran is called the "main coroutine". It's special in several # respects: it existed before you created the Coroutine object; if any of # the create'd coroutines exits (does a return, or suffers an unhandled # exception), EarlyExit error is raised in the main coroutine; and the # co.detach() method transfers control directly to the main coroutine # (you can't use co.tran() for this because the main coroutine doesn't # have a name ...). # # Coroutine objects support these methods: # # handle = .create(func [, arg1, arg2, ...]) # Creates a coroutine for an invocation of func(arg1, arg2, ...), # and returns a handle ("name") for the coroutine so created. The # handle can be used as the target in a subsequent .tran(). # # .tran(target, data=None) # Transfer control to the create'd coroutine "target", optionally # passing it an arbitrary piece of data. To the coroutine A that does # the .tran, .tran acts like an ordinary function call: another # coroutine B can .tran back to it later, and if it does A's .tran # returns the 'data' argument passed to B's tran. E.g., # # in coroutine coA in coroutine coC in coroutine coB # x = co.tran(coC) co.tran(coB) co.tran(coA,12) # print x # 12 # # The data-passing feature is taken from Icon, and greatly cuts # the need to use global variables for inter-coroutine communication. # # .back( data=None ) # The same as .tran(invoker, data=None), where 'invoker' is the # coroutine that most recently .tran'ed control to the coroutine # doing the .back. This is akin to Icon's "&source". # # .detach( data=None ) # The same as .tran(main, data=None), where 'main' is the # (unnameable!) coroutine that started it all. 'main' has all the # rights of any other coroutine: upon receiving control, it can # .tran to an arbitrary coroutine of its choosing, go .back to # the .detach'er, or .kill the whole thing. # # .kill() # Destroy all the coroutines, and return control to the main # coroutine. None of the create'ed coroutines can be resumed after a # .kill(). An EarlyExit exception does a .kill() automatically. It's # a good idea to .kill() coroutines you're done with, since the # current implementation consumes a thread for each coroutine that # may be resumed. import thread import sync class _CoEvent: def __init__(self, func): self.f = func self.e = sync.event() def __repr__(self): if self.f is None: return 'main coroutine' else: return 'coroutine for func ' + self.f.func_name def __hash__(self): return id(self) def __cmp__(x,y): return cmp(id(x), id(y)) def resume(self): self.e.post() def wait(self): self.e.wait() self.e.clear() class Killed(Exception): pass class EarlyExit(Exception): pass class Coroutine: def __init__(self): self.active = self.main = _CoEvent(None) self.invokedby = {self.main: None} self.killed = 0 self.value = None self.terminated_by = None def create(self, func, *args): me = _CoEvent(func) self.invokedby[me] = None thread.start_new_thread(self._start, (me,) + args) return me def _start(self, me, *args): me.wait() if not self.killed: try: try: apply(me.f, args) except Killed: pass finally: if not self.killed: self.terminated_by = me self.kill() def kill(self): if self.killed: raise TypeError, 'kill() called on dead coroutines' self.killed = 1 for coroutine in self.invokedby.keys(): coroutine.resume() def back(self, data=None): return self.tran( self.invokedby[self.active], data ) def detach(self, data=None): return self.tran( self.main, data ) def tran(self, target, data=None): if not self.invokedby.has_key(target): raise TypeError, '.tran target %r is not an active coroutine' % (target,) if self.killed: raise TypeError, '.tran target %r is killed' % (target,) self.value = data me = self.active self.invokedby[target] = me self.active = target target.resume() me.wait() if self.killed: if self.main is not me: raise Killed if self.terminated_by is not None: raise EarlyExit, '%r terminated early' % (self.terminated_by,) return self.value # end of module PK! ,fcmp.pyonu[ ^c@szddlTdZdZedddgeddgggdggddddggdd gd ggggZeed Zeed eGHeed eGHeeed GHeed eGHeeed GHeddgd ggdgdgd gGHeddgd ggdgdgd gGHeddgd ggdgdgdgGHdS(i(t*cCsJxC|D];}t|tgkr5t||q|j|qWdS(N(ttypetfringetback(tcotlisttx((s)/usr/lib64/python2.7/Demo/threads/fcmp.pyRs cCsOt}|jt||}yx|j|Gq$WWntk rInXHdS(N(t CoroutinetcreateRttrant EarlyExit(RRtf((s)/usr/lib64/python2.7/Demo/threads/fcmp.pyt printinorders  iiiiiiicCst}|jt||}t}|jt||}xy|j|}WnDtk ry|j|}Wntk rdSX|jdSXy|j|}Wntk r|jdSX||kr?|j|jt||Sq?WdS(Niii(RRRR R tkilltcmp(tl1tl2tco1tf1tco2tf2tv1tv2((s)/usr/lib64/python2.7/Demo/threads/fcmp.pytfcmps.         iii N(RRR RRtrange(((s)/usr/lib64/python2.7/Demo/threads/fcmp.pyts$   -  PK! Coroutine.pycnu[ ^c@snddlZddlZdd dYZdefdYZdefdYZdd d YZdS( iNt_CoEventcBs>eZdZdZdZdZdZdZRS(cCs||_tj|_dS(N(tftsyncteventte(tselftfunc((s./usr/lib64/python2.7/Demo/threads/Coroutine.pyt__init__Is cCs%|jdkrdSd|jjSdS(Nsmain coroutinescoroutine for func (RtNonet func_name(R((s./usr/lib64/python2.7/Demo/threads/Coroutine.pyt__repr__MscCs t|S(N(tid(R((s./usr/lib64/python2.7/Demo/threads/Coroutine.pyt__hash__SscCstt|t|S(N(tcmpR (txty((s./usr/lib64/python2.7/Demo/threads/Coroutine.pyt__cmp__VscCs|jjdS(N(Rtpost(R((s./usr/lib64/python2.7/Demo/threads/Coroutine.pytresumeYscCs|jj|jjdS(N(Rtwaittclear(R((s./usr/lib64/python2.7/Demo/threads/Coroutine.pyR\s (t__name__t __module__RR R RRR(((s./usr/lib64/python2.7/Demo/threads/Coroutine.pyRHs      tKilledcBseZRS((RR(((s./usr/lib64/python2.7/Demo/threads/Coroutine.pyR`st EarlyExitcBseZRS((RR(((s./usr/lib64/python2.7/Demo/threads/Coroutine.pyRast CoroutinecBsPeZdZdZdZdZddZddZddZ RS(cCsHtd|_|_id|j6|_d|_d|_d|_dS(Ni(RRtactivetmaint invokedbytkilledtvaluet terminated_by(R((s./usr/lib64/python2.7/Demo/threads/Coroutine.pyRds   cGs7t|}d|j|Es  PK!__  telnet.pynu[# Minimal interface to the Internet telnet protocol. # # *** modified to use threads *** # # It refuses all telnet options and does not recognize any of the other # telnet commands, but can still be used to connect in line-by-line mode. # It's also useful to play with a number of other services, # like time, finger, smtp and even ftp. # # Usage: telnet host [port] # # The port may be a service name or a decimal port number; # it defaults to 'telnet'. import sys, os, time from socket import * import thread BUFSIZE = 8*1024 # Telnet protocol characters IAC = chr(255) # Interpret as command DONT = chr(254) DO = chr(253) WONT = chr(252) WILL = chr(251) def main(): if len(sys.argv) < 2: sys.stderr.write('usage: telnet hostname [port]\n') sys.exit(2) host = sys.argv[1] try: hostaddr = gethostbyname(host) except error: sys.stderr.write(sys.argv[1] + ': bad host name\n') sys.exit(2) # if len(sys.argv) > 2: servname = sys.argv[2] else: servname = 'telnet' # if '0' <= servname[:1] <= '9': port = eval(servname) else: try: port = getservbyname(servname, 'tcp') except error: sys.stderr.write(servname + ': bad tcp service name\n') sys.exit(2) # s = socket(AF_INET, SOCK_STREAM) # try: s.connect((host, port)) except error, msg: sys.stderr.write('connect failed: %r\n' % (msg,)) sys.exit(1) # thread.start_new(child, (s,)) parent(s) def parent(s): # read socket, write stdout iac = 0 # Interpret next char as command opt = '' # Interpret next char as option while 1: data, dummy = s.recvfrom(BUFSIZE) if not data: # EOF -- exit sys.stderr.write( '(Closed by remote host)\n') sys.exit(1) cleandata = '' for c in data: if opt: print ord(c) ## print '(replying: %r)' % (opt+c,) s.send(opt + c) opt = '' elif iac: iac = 0 if c == IAC: cleandata = cleandata + c elif c in (DO, DONT): if c == DO: print '(DO)', else: print '(DONT)', opt = IAC + WONT elif c in (WILL, WONT): if c == WILL: print '(WILL)', else: print '(WONT)', opt = IAC + DONT else: print '(command)', ord(c) elif c == IAC: iac = 1 print '(IAC)', else: cleandata = cleandata + c sys.stdout.write(cleandata) sys.stdout.flush() ## print 'Out:', repr(cleandata) def child(s): # read stdin, write socket while 1: line = sys.stdin.readline() ## print 'Got:', repr(line) if not line: break s.send(line) main() PK!; squasher.pynu[# Coroutine example: general coroutine transfers # # The program is a variation of a Simula 67 program due to Dahl & Hoare, # (Dahl/Dijkstra/Hoare, Structured Programming; Academic Press, 1972) # who in turn credit the original example to Conway. # # We have a number of input lines, terminated by a 0 byte. The problem # is to squash them together into output lines containing 72 characters # each. A semicolon must be added between input lines. Runs of blanks # and tabs in input lines must be squashed into single blanks. # Occurrences of "**" in input lines must be replaced by "^". # # Here's a test case: test = """\ d = sqrt(b**2 - 4*a*c) twoa = 2*a L = -b/twoa R = d/twoa A1 = L + R A2 = L - R\0 """ # The program should print: # d = sqrt(b^2 - 4*a*c);twoa = 2*a; L = -b/twoa; R = d/twoa; A1 = L + R; #A2 = L - R #done # getline: delivers the next input line to its invoker # disassembler: grabs input lines from getline, and delivers them one # character at a time to squasher, also inserting a semicolon into # the stream between lines # squasher: grabs characters from disassembler and passes them on to # assembler, first replacing "**" with "^" and squashing runs of # whitespace # assembler: grabs characters from squasher and packs them into lines # with 72 character each, delivering each such line to putline; # when it sees a null byte, passes the last line to putline and # then kills all the coroutines # putline: grabs lines from assembler, and just prints them from Coroutine import * def getline(text): for line in string.splitfields(text, '\n'): co.tran(codisassembler, line) def disassembler(): while 1: card = co.tran(cogetline) for i in range(len(card)): co.tran(cosquasher, card[i]) co.tran(cosquasher, ';') def squasher(): while 1: ch = co.tran(codisassembler) if ch == '*': ch2 = co.tran(codisassembler) if ch2 == '*': ch = '^' else: co.tran(coassembler, ch) ch = ch2 if ch in ' \t': while 1: ch2 = co.tran(codisassembler) if ch2 not in ' \t': break co.tran(coassembler, ' ') ch = ch2 co.tran(coassembler, ch) def assembler(): line = '' while 1: ch = co.tran(cosquasher) if ch == '\0': break if len(line) == 72: co.tran(coputline, line) line = '' line = line + ch line = line + ' ' * (72 - len(line)) co.tran(coputline, line) co.kill() def putline(): while 1: line = co.tran(coassembler) print line import string co = Coroutine() cogetline = co.create(getline, test) coputline = co.create(putline) coassembler = co.create(assembler) codisassembler = co.create(disassembler) cosquasher = co.create(squasher) co.tran(coputline) print 'done' # end of example PK!3h!!find.pycnu[ ^c@sddlZddlZddlZddlZddlZddlTddlZdddYZdZdZ dZ edS( iN(t*tWorkQcBs>eZdZdZdZdZdZdZRS(cCsAtj|_tj|_|jjg|_d|_dS(Ni(tthreadtallocatetmutexttodotacquiretworktbusy(tself((s)/usr/lib64/python2.7/Demo/threads/find.pyt__init__,s   cCs_||f}|jj|jj||jjt|jdkr[|jjndS(Ni(RRRtappendtreleasetlenR(R tfunctargstjob((s)/usr/lib64/python2.7/Demo/threads/find.pytaddwork3s    cCs|jj|jj|jdkr\t|jdkr\|jj|jjdS|jd}|jd=|jd|_|jjt|jdkr|jjn|S(Nii(RRRRR RR tNone(R R((s)/usr/lib64/python2.7/Demo/threads/find.pyt_getwork;s  $     cCsb|jj|jd|_|jdkrQt|jdkrQ|jjn|jjdS(Nii(RRRR RRR (R ((s)/usr/lib64/python2.7/Demo/threads/find.pyt _doneworkJs  $cCsQtjdx=|j}|s&Pn|\}}t|||jqWdS(Ngh㈵>(ttimetsleepRtapplyR(R RRR((s)/usr/lib64/python2.7/Demo/threads/find.pyt_workerQs    cCsV|js dSx+t|dD]}tj|jdqW|j|jjdS(Ni((RtrangeRt start_newRRR(R tnworkersti((s)/usr/lib64/python2.7/Demo/threads/find.pytrun[s   (t__name__t __module__R RRRRR(((s)/usr/lib64/python2.7/Demo/threads/find.pyR#s      c Csd}tjtjdd\}}x2|D]*\}}|dkr,tj|}q,q,W|sotjg}nt}x'|D]}|jt |t |fqWt j }|j |t j }tj jd||dS(Niis-w:s-wsTotal time %r sec. (tgetopttsystargvtstringtatoitostcurdirRRtfindtselectorRRtstderrtwrite( RtoptsRtopttargtwqtdirtt1tt2((s)/usr/lib64/python2.7/Demo/threads/find.pytmainfs      cCs#|td@dko"t|t S(Nii(tST_MODEtS_ISLNK(R/tnametfullnametstat((s)/usr/lib64/python2.7/Demo/threads/find.pyR(}scCs%ytj|}Wn*tjk r?}t|GdG|GHdSXx|D]}|tjtjfkrGtjj||}ytj|}Wn,tjk r}t|GdG|GHqGnX|||||r|GHnt |t rtjj |s|j t |||fqqqGqGWdS(Nt:(R%tlistdirterrortreprR&tpardirtpathtjointlstattS_ISDIRR3tismountRR'(R/tpredR.tnamestmsgR5R6R7((s)/usr/lib64/python2.7/Demo/threads/find.pyR's$ (( R!R R#RR%R7RRR2R(R'(((s)/usr/lib64/python2.7/Demo/threads/find.pyts       C   PK!eITTsync.pynu[# Defines classes that provide synchronization objects. Note that use of # this module requires that your Python support threads. # # condition(lock=None) # a POSIX-like condition-variable object # barrier(n) # an n-thread barrier # event() # an event object # semaphore(n=1) # a semaphore object, with initial count n # mrsw() # a multiple-reader single-writer lock # # CONDITIONS # # A condition object is created via # import this_module # your_condition_object = this_module.condition(lock=None) # # As explained below, a condition object has a lock associated with it, # used in the protocol to protect condition data. You can specify a # lock to use in the constructor, else the constructor will allocate # an anonymous lock for you. Specifying a lock explicitly can be useful # when more than one condition keys off the same set of shared data. # # Methods: # .acquire() # acquire the lock associated with the condition # .release() # release the lock associated with the condition # .wait() # block the thread until such time as some other thread does a # .signal or .broadcast on the same condition, and release the # lock associated with the condition. The lock associated with # the condition MUST be in the acquired state at the time # .wait is invoked. # .signal() # wake up exactly one thread (if any) that previously did a .wait # on the condition; that thread will awaken with the lock associated # with the condition in the acquired state. If no threads are # .wait'ing, this is a nop. If more than one thread is .wait'ing on # the condition, any of them may be awakened. # .broadcast() # wake up all threads (if any) that are .wait'ing on the condition; # the threads are woken up serially, each with the lock in the # acquired state, so should .release() as soon as possible. If no # threads are .wait'ing, this is a nop. # # Note that if a thread does a .wait *while* a signal/broadcast is # in progress, it's guaranteeed to block until a subsequent # signal/broadcast. # # Secret feature: `broadcast' actually takes an integer argument, # and will wake up exactly that many waiting threads (or the total # number waiting, if that's less). Use of this is dubious, though, # and probably won't be supported if this form of condition is # reimplemented in C. # # DIFFERENCES FROM POSIX # # + A separate mutex is not needed to guard condition data. Instead, a # condition object can (must) be .acquire'ed and .release'ed directly. # This eliminates a common error in using POSIX conditions. # # + Because of implementation difficulties, a POSIX `signal' wakes up # _at least_ one .wait'ing thread. Race conditions make it difficult # to stop that. This implementation guarantees to wake up only one, # but you probably shouldn't rely on that. # # PROTOCOL # # Condition objects are used to block threads until "some condition" is # true. E.g., a thread may wish to wait until a producer pumps out data # for it to consume, or a server may wish to wait until someone requests # its services, or perhaps a whole bunch of threads want to wait until a # preceding pass over the data is complete. Early models for conditions # relied on some other thread figuring out when a blocked thread's # condition was true, and made the other thread responsible both for # waking up the blocked thread and guaranteeing that it woke up with all # data in a correct state. This proved to be very delicate in practice, # and gave conditions a bad name in some circles. # # The POSIX model addresses these problems by making a thread responsible # for ensuring that its own state is correct when it wakes, and relies # on a rigid protocol to make this easy; so long as you stick to the # protocol, POSIX conditions are easy to "get right": # # A) The thread that's waiting for some arbitrarily-complex condition # (ACC) to become true does: # # condition.acquire() # while not (code to evaluate the ACC): # condition.wait() # # That blocks the thread, *and* releases the lock. When a # # condition.signal() happens, it will wake up some thread that # # did a .wait, *and* acquire the lock again before .wait # # returns. # # # # Because the lock is acquired at this point, the state used # # in evaluating the ACC is frozen, so it's safe to go back & # # reevaluate the ACC. # # # At this point, ACC is true, and the thread has the condition # # locked. # # So code here can safely muck with the shared state that # # went into evaluating the ACC -- if it wants to. # # When done mucking with the shared state, do # condition.release() # # B) Threads that are mucking with shared state that may affect the # ACC do: # # condition.acquire() # # muck with shared state # condition.release() # if it's possible that ACC is true now: # condition.signal() # or .broadcast() # # Note: You may prefer to put the "if" clause before the release(). # That's fine, but do note that anyone waiting on the signal will # stay blocked until the release() is done (since acquiring the # condition is part of what .wait() does before it returns). # # TRICK OF THE TRADE # # With simpler forms of conditions, it can be impossible to know when # a thread that's supposed to do a .wait has actually done it. But # because this form of condition releases a lock as _part_ of doing a # wait, the state of that lock can be used to guarantee it. # # E.g., suppose thread A spawns thread B and later wants to wait for B to # complete: # # In A: In B: # # B_done = condition() ... do work ... # B_done.acquire() B_done.acquire(); B_done.release() # spawn B B_done.signal() # ... some time later ... ... and B exits ... # B_done.wait() # # Because B_done was in the acquire'd state at the time B was spawned, # B's attempt to acquire B_done can't succeed until A has done its # B_done.wait() (which releases B_done). So B's B_done.signal() is # guaranteed to be seen by the .wait(). Without the lock trick, B # may signal before A .waits, and then A would wait forever. # # BARRIERS # # A barrier object is created via # import this_module # your_barrier = this_module.barrier(num_threads) # # Methods: # .enter() # the thread blocks until num_threads threads in all have done # .enter(). Then the num_threads threads that .enter'ed resume, # and the barrier resets to capture the next num_threads threads # that .enter it. # # EVENTS # # An event object is created via # import this_module # your_event = this_module.event() # # An event has two states, `posted' and `cleared'. An event is # created in the cleared state. # # Methods: # # .post() # Put the event in the posted state, and resume all threads # .wait'ing on the event (if any). # # .clear() # Put the event in the cleared state. # # .is_posted() # Returns 0 if the event is in the cleared state, or 1 if the event # is in the posted state. # # .wait() # If the event is in the posted state, returns immediately. # If the event is in the cleared state, blocks the calling thread # until the event is .post'ed by another thread. # # Note that an event, once posted, remains posted until explicitly # cleared. Relative to conditions, this is both the strength & weakness # of events. It's a strength because the .post'ing thread doesn't have to # worry about whether the threads it's trying to communicate with have # already done a .wait (a condition .signal is seen only by threads that # do a .wait _prior_ to the .signal; a .signal does not persist). But # it's a weakness because .clear'ing an event is error-prone: it's easy # to mistakenly .clear an event before all the threads you intended to # see the event get around to .wait'ing on it. But so long as you don't # need to .clear an event, events are easy to use safely. # # SEMAPHORES # # A semaphore object is created via # import this_module # your_semaphore = this_module.semaphore(count=1) # # A semaphore has an integer count associated with it. The initial value # of the count is specified by the optional argument (which defaults to # 1) passed to the semaphore constructor. # # Methods: # # .p() # If the semaphore's count is greater than 0, decrements the count # by 1 and returns. # Else if the semaphore's count is 0, blocks the calling thread # until a subsequent .v() increases the count. When that happens, # the count will be decremented by 1 and the calling thread resumed. # # .v() # Increments the semaphore's count by 1, and wakes up a thread (if # any) blocked by a .p(). It's an (detected) error for a .v() to # increase the semaphore's count to a value larger than the initial # count. # # MULTIPLE-READER SINGLE-WRITER LOCKS # # A mrsw lock is created via # import this_module # your_mrsw_lock = this_module.mrsw() # # This kind of lock is often useful with complex shared data structures. # The object lets any number of "readers" proceed, so long as no thread # wishes to "write". When a (one or more) thread declares its intention # to "write" (e.g., to update a shared structure), all current readers # are allowed to finish, and then a writer gets exclusive access; all # other readers & writers are blocked until the current writer completes. # Finally, if some thread is waiting to write and another is waiting to # read, the writer takes precedence. # # Methods: # # .read_in() # If no thread is writing or waiting to write, returns immediately. # Else blocks until no thread is writing or waiting to write. So # long as some thread has completed a .read_in but not a .read_out, # writers are blocked. # # .read_out() # Use sometime after a .read_in to declare that the thread is done # reading. When all threads complete reading, a writer can proceed. # # .write_in() # If no thread is writing (has completed a .write_in, but hasn't yet # done a .write_out) or reading (similarly), returns immediately. # Else blocks the calling thread, and threads waiting to read, until # the current writer completes writing or all the current readers # complete reading; if then more than one thread is waiting to # write, one of them is allowed to proceed, but which one is not # specified. # # .write_out() # Use sometime after a .write_in to declare that the thread is done # writing. Then if some other thread is waiting to write, it's # allowed to proceed. Else all threads (if any) waiting to read are # allowed to proceed. # # .write_to_read() # Use instead of a .write_in to declare that the thread is done # writing but wants to continue reading without other writers # intervening. If there are other threads waiting to write, they # are allowed to proceed only if the current thread calls # .read_out; threads waiting to read are only allowed to proceed # if there are no threads waiting to write. (This is a # weakness of the interface!) import thread class condition: def __init__(self, lock=None): # the lock actually used by .acquire() and .release() if lock is None: self.mutex = thread.allocate_lock() else: if hasattr(lock, 'acquire') and \ hasattr(lock, 'release'): self.mutex = lock else: raise TypeError, 'condition constructor requires ' \ 'a lock argument' # lock used to block threads until a signal self.checkout = thread.allocate_lock() self.checkout.acquire() # internal critical-section lock, & the data it protects self.idlock = thread.allocate_lock() self.id = 0 self.waiting = 0 # num waiters subject to current release self.pending = 0 # num waiters awaiting next signal self.torelease = 0 # num waiters to release self.releasing = 0 # 1 iff release is in progress def acquire(self): self.mutex.acquire() def release(self): self.mutex.release() def wait(self): mutex, checkout, idlock = self.mutex, self.checkout, self.idlock if not mutex.locked(): raise ValueError, \ "condition must be .acquire'd when .wait() invoked" idlock.acquire() myid = self.id self.pending = self.pending + 1 idlock.release() mutex.release() while 1: checkout.acquire(); idlock.acquire() if myid < self.id: break checkout.release(); idlock.release() self.waiting = self.waiting - 1 self.torelease = self.torelease - 1 if self.torelease: checkout.release() else: self.releasing = 0 if self.waiting == self.pending == 0: self.id = 0 idlock.release() mutex.acquire() def signal(self): self.broadcast(1) def broadcast(self, num = -1): if num < -1: raise ValueError, '.broadcast called with num %r' % (num,) if num == 0: return self.idlock.acquire() if self.pending: self.waiting = self.waiting + self.pending self.pending = 0 self.id = self.id + 1 if num == -1: self.torelease = self.waiting else: self.torelease = min( self.waiting, self.torelease + num ) if self.torelease and not self.releasing: self.releasing = 1 self.checkout.release() self.idlock.release() class barrier: def __init__(self, n): self.n = n self.togo = n self.full = condition() def enter(self): full = self.full full.acquire() self.togo = self.togo - 1 if self.togo: full.wait() else: self.togo = self.n full.broadcast() full.release() class event: def __init__(self): self.state = 0 self.posted = condition() def post(self): self.posted.acquire() self.state = 1 self.posted.broadcast() self.posted.release() def clear(self): self.posted.acquire() self.state = 0 self.posted.release() def is_posted(self): self.posted.acquire() answer = self.state self.posted.release() return answer def wait(self): self.posted.acquire() if not self.state: self.posted.wait() self.posted.release() class semaphore: def __init__(self, count=1): if count <= 0: raise ValueError, 'semaphore count %d; must be >= 1' % count self.count = count self.maxcount = count self.nonzero = condition() def p(self): self.nonzero.acquire() while self.count == 0: self.nonzero.wait() self.count = self.count - 1 self.nonzero.release() def v(self): self.nonzero.acquire() if self.count == self.maxcount: raise ValueError, '.v() tried to raise semaphore count above ' \ 'initial value %r' % self.maxcount self.count = self.count + 1 self.nonzero.signal() self.nonzero.release() class mrsw: def __init__(self): # critical-section lock & the data it protects self.rwOK = thread.allocate_lock() self.nr = 0 # number readers actively reading (not just waiting) self.nw = 0 # number writers either waiting to write or writing self.writing = 0 # 1 iff some thread is writing # conditions self.readOK = condition(self.rwOK) # OK to unblock readers self.writeOK = condition(self.rwOK) # OK to unblock writers def read_in(self): self.rwOK.acquire() while self.nw: self.readOK.wait() self.nr = self.nr + 1 self.rwOK.release() def read_out(self): self.rwOK.acquire() if self.nr <= 0: raise ValueError, \ '.read_out() invoked without an active reader' self.nr = self.nr - 1 if self.nr == 0: self.writeOK.signal() self.rwOK.release() def write_in(self): self.rwOK.acquire() self.nw = self.nw + 1 while self.writing or self.nr: self.writeOK.wait() self.writing = 1 self.rwOK.release() def write_out(self): self.rwOK.acquire() if not self.writing: raise ValueError, \ '.write_out() invoked without an active writer' self.writing = 0 self.nw = self.nw - 1 if self.nw: self.writeOK.signal() else: self.readOK.broadcast() self.rwOK.release() def write_to_read(self): self.rwOK.acquire() if not self.writing: raise ValueError, \ '.write_to_read() invoked without an active writer' self.writing = 0 self.nw = self.nw - 1 self.nr = self.nr + 1 if not self.nw: self.readOK.broadcast() self.rwOK.release() # The rest of the file is a test case, that runs a number of parallelized # quicksorts in parallel. If it works, you'll get about 600 lines of # tracing output, with a line like # test passed! 209 threads created in all # as the last line. The content and order of preceding lines will # vary across runs. def _new_thread(func, *args): global TID tid.acquire(); id = TID = TID+1; tid.release() io.acquire(); alive.append(id); \ print 'starting thread', id, '--', len(alive), 'alive'; \ io.release() thread.start_new_thread( func, (id,) + args ) def _qsort(tid, a, l, r, finished): # sort a[l:r]; post finished when done io.acquire(); print 'thread', tid, 'qsort', l, r; io.release() if r-l > 1: pivot = a[l] j = l+1 # make a[l:j] <= pivot, and a[j:r] > pivot for i in range(j, r): if a[i] <= pivot: a[j], a[i] = a[i], a[j] j = j + 1 a[l], a[j-1] = a[j-1], pivot l_subarray_sorted = event() r_subarray_sorted = event() _new_thread(_qsort, a, l, j-1, l_subarray_sorted) _new_thread(_qsort, a, j, r, r_subarray_sorted) l_subarray_sorted.wait() r_subarray_sorted.wait() io.acquire(); print 'thread', tid, 'qsort done'; \ alive.remove(tid); io.release() finished.post() def _randarray(tid, a, finished): io.acquire(); print 'thread', tid, 'randomizing array'; \ io.release() for i in range(1, len(a)): wh.acquire(); j = randint(0,i); wh.release() a[i], a[j] = a[j], a[i] io.acquire(); print 'thread', tid, 'randomizing done'; \ alive.remove(tid); io.release() finished.post() def _check_sort(a): if a != range(len(a)): raise ValueError, ('a not sorted', a) def _run_one_sort(tid, a, bar, done): # randomize a, and quicksort it # for variety, all the threads running this enter a barrier # at the end, and post `done' after the barrier exits io.acquire(); print 'thread', tid, 'randomizing', a; \ io.release() finished = event() _new_thread(_randarray, a, finished) finished.wait() io.acquire(); print 'thread', tid, 'sorting', a; io.release() finished.clear() _new_thread(_qsort, a, 0, len(a), finished) finished.wait() _check_sort(a) io.acquire(); print 'thread', tid, 'entering barrier'; \ io.release() bar.enter() io.acquire(); print 'thread', tid, 'leaving barrier'; \ io.release() io.acquire(); alive.remove(tid); io.release() bar.enter() # make sure they've all removed themselves from alive ## before 'done' is posted bar.enter() # just to be cruel done.post() def test(): global TID, tid, io, wh, randint, alive import random randint = random.randint TID = 0 # thread ID (1, 2, ...) tid = thread.allocate_lock() # for changing TID io = thread.allocate_lock() # for printing, and 'alive' wh = thread.allocate_lock() # for calls to random alive = [] # IDs of active threads NSORTS = 5 arrays = [] for i in range(NSORTS): arrays.append( range( (i+1)*10 ) ) bar = barrier(NSORTS) finished = event() for i in range(NSORTS): _new_thread(_run_one_sort, arrays[i], bar, finished) finished.wait() print 'all threads done, and checking results ...' if alive: raise ValueError, ('threads still alive at end', alive) for i in range(NSORTS): a = arrays[i] if len(a) != (i+1)*10: raise ValueError, ('length of array', i, 'screwed up') _check_sort(a) print 'test passed!', TID, 'threads created in all' if __name__ == '__main__': test() # end of module PK!}c telnet.pyonu[ ^c@sddlZddlZddlZddlTddlZd ZedZedZedZ edZ ed Z d Z d Z d Ze dS(iN(t*iiiiiiicCsttjdkr5tjjdtjdntjd}yt|}Wn9tk rtjjtjddtjdnXttjdkrtjd}nd}d|d kodknrt|}nHyt |d}Wn2tk r/tjj|d tjdnXt t t }y|j ||fWn7tk r}tjjd |ftjdnXtjt|ft|dS( Nisusage: telnet hostname [port] is: bad host name ttelnett0t9ttcps: bad tcp service name sconnect failed: %r (tlentsystargvtstderrtwritetexitt gethostbynameterrortevalt getservbynametsockettAF_INETt SOCK_STREAMtconnecttthreadt start_newtchildtparent(thostthostaddrtservnametporttstmsg((s+/usr/lib64/python2.7/Demo/threads/telnet.pytmains6    cCswd}d}xd|jt\}}|sJtjjdtjdnd}x|D]}|rt|GH|j||d}qW|r+d}|tkr||}qN|t t fkr|t krdGndGtt }qN|t t fkr|t krdGndGtt }qNd Gt|GHqW|tkrDd}d GqW||}qWWtj j|tj jqWdS( Nits(Closed by remote host) is(DO)s(DONT)s(WILL)s(WONT)s (command)s(IAC)(trecvfromtBUFSIZERRR R tordtsendtIACtDOtDONTtWONTtWILLtstdouttflush(Rtiactopttdatatdummyt cleandatatc((s+/usr/lib64/python2.7/Demo/threads/telnet.pyRBsD          cCs1x*tjj}|sPn|j|qWdS(N(RtstdintreadlineR"(Rtline((s+/usr/lib64/python2.7/Demo/threads/telnet.pyRjs i (RtosttimeRRR tchrR#R%R$R&R'RRR(((s+/usr/lib64/python2.7/Demo/threads/telnet.pyts$        $ ( PK!+wwfind.pynu[# A parallelized "find(1)" using the thread module. # This demonstrates the use of a work queue and worker threads. # It really does do more stats/sec when using multiple threads, # although the improvement is only about 20-30 percent. # (That was 8 years ago. In 2002, on Linux, I can't measure # a speedup. :-( ) # I'm too lazy to write a command line parser for the full find(1) # command line syntax, so the predicate it searches for is wired-in, # see function selector() below. (It currently searches for files with # world write permission.) # Usage: parfind.py [-w nworkers] [directory] ... # Default nworkers is 4 import sys import getopt import string import time import os from stat import * import thread # Work queue class. Usage: # wq = WorkQ() # wq.addwork(func, (arg1, arg2, ...)) # one or more calls # wq.run(nworkers) # The work is done when wq.run() completes. # The function calls executed by the workers may add more work. # Don't use keyboard interrupts! class WorkQ: # Invariants: # - busy and work are only modified when mutex is locked # - len(work) is the number of jobs ready to be taken # - busy is the number of jobs being done # - todo is locked iff there is no work and somebody is busy def __init__(self): self.mutex = thread.allocate() self.todo = thread.allocate() self.todo.acquire() self.work = [] self.busy = 0 def addwork(self, func, args): job = (func, args) self.mutex.acquire() self.work.append(job) self.mutex.release() if len(self.work) == 1: self.todo.release() def _getwork(self): self.todo.acquire() self.mutex.acquire() if self.busy == 0 and len(self.work) == 0: self.mutex.release() self.todo.release() return None job = self.work[0] del self.work[0] self.busy = self.busy + 1 self.mutex.release() if len(self.work) > 0: self.todo.release() return job def _donework(self): self.mutex.acquire() self.busy = self.busy - 1 if self.busy == 0 and len(self.work) == 0: self.todo.release() self.mutex.release() def _worker(self): time.sleep(0.00001) # Let other threads run while 1: job = self._getwork() if not job: break func, args = job apply(func, args) self._donework() def run(self, nworkers): if not self.work: return # Nothing to do for i in range(nworkers-1): thread.start_new(self._worker, ()) self._worker() self.todo.acquire() # Main program def main(): nworkers = 4 opts, args = getopt.getopt(sys.argv[1:], '-w:') for opt, arg in opts: if opt == '-w': nworkers = string.atoi(arg) if not args: args = [os.curdir] wq = WorkQ() for dir in args: wq.addwork(find, (dir, selector, wq)) t1 = time.time() wq.run(nworkers) t2 = time.time() sys.stderr.write('Total time %r sec.\n' % (t2-t1)) # The predicate -- defines what files we look for. # Feel free to change this to suit your purpose def selector(dir, name, fullname, stat): # Look for world writable files that are not symlinks return (stat[ST_MODE] & 0002) != 0 and not S_ISLNK(stat[ST_MODE]) # The find procedure -- calls wq.addwork() for subdirectories def find(dir, pred, wq): try: names = os.listdir(dir) except os.error, msg: print repr(dir), ':', msg return for name in names: if name not in (os.curdir, os.pardir): fullname = os.path.join(dir, name) try: stat = os.lstat(fullname) except os.error, msg: print repr(fullname), ':', msg continue if pred(dir, name, fullname, stat): print fullname if S_ISDIR(stat[ST_MODE]): if not os.path.ismount(fullname): wq.addwork(find, (fullname, pred, wq)) # Call the main program main() PK!IREADMEnu[This directory contains some demonstrations of the thread module. These are mostly "proof of concept" type applications: Generator.py Generator class implemented with threads. sync.py Condition variables primitives by Tim Peters. telnet.py Version of ../sockets/telnet.py using threads. Coroutine.py Coroutines using threads, by Tim Peters (22 May 94) fcmp.py Example of above, by Tim squasher.py Another example of above, also by Tim PK!j+j+sync.pyonu[ ^c@sddlZdddYZdddYZdddYZddd YZd dd YZd Zd ZdZdZ dZ dZ e dkre ndS(iNt conditioncBsDeZddZdZdZdZdZddZRS(cCs|dkrtj|_n3t|drHt|drH||_n tdtj|_|jjtj|_d|_ d|_ d|_ d|_ d|_ dS(Ntacquiretreleases.condition constructor requires a lock argumenti(tNonetthreadt allocate_locktmutexthasattrt TypeErrortcheckoutRtidlocktidtwaitingtpendingt toreleaset releasing(tselftlock((s)/usr/lib64/python2.7/Demo/threads/sync.pyt__init__s        cCs|jjdS(N(RR(R((s)/usr/lib64/python2.7/Demo/threads/sync.pyR*scCs|jjdS(N(RR(R((s)/usr/lib64/python2.7/Demo/threads/sync.pyR-scCs3|j|j|j}}}|js5tdn|j|j}|jd|_|j|jx?|j|j||jkrPn|j|jqoW|j d|_ |j d|_ |j r|jn7d|_ |j |jko dknrd|_n|j|jdS(Ns1condition must be .acquire'd when .wait() invokedii( RR R tlockedt ValueErrorRR R RR RR(RRR R tmyid((s)/usr/lib64/python2.7/Demo/threads/sync.pytwait0s2           "  cCs|jddS(Ni(t broadcast(R((s)/usr/lib64/python2.7/Demo/threads/sync.pytsignalNsicCs|dkrtd|fn|dkr/dS|jj|jrt|j|j|_d|_|jd|_n|dkr|j|_nt|j|j||_|jr|j rd|_|j j n|jj dS(Nis.broadcast called with num %rii( RR RR R R RtminRR R(Rtnum((s)/usr/lib64/python2.7/Demo/threads/sync.pyRQs"        N( t__name__t __module__RRRRRRR(((s)/usr/lib64/python2.7/Demo/threads/sync.pyRs      tbarriercBseZdZdZRS(cCs"||_||_t|_dS(N(tnttogoRtfull(RR((s)/usr/lib64/python2.7/Demo/threads/sync.pyRfs  cCs]|j}|j|jd|_|jr9|jn|j|_|j|jdS(Ni(R RRRRRR(RR ((s)/usr/lib64/python2.7/Demo/threads/sync.pytenterks      (RRRR!(((s)/usr/lib64/python2.7/Demo/threads/sync.pyRes teventcBs5eZdZdZdZdZdZRS(cCsd|_t|_dS(Ni(tstateRtposted(R((s)/usr/lib64/python2.7/Demo/threads/sync.pyRws cCs4|jjd|_|jj|jjdS(Ni(R$RR#RR(R((s)/usr/lib64/python2.7/Demo/threads/sync.pytpost{s   cCs'|jjd|_|jjdS(Ni(R$RR#R(R((s)/usr/lib64/python2.7/Demo/threads/sync.pytclears  cCs'|jj|j}|jj|S(N(R$RR#R(Rtanswer((s)/usr/lib64/python2.7/Demo/threads/sync.pyt is_posteds   cCs7|jj|js&|jjn|jjdS(N(R$RR#RR(R((s)/usr/lib64/python2.7/Demo/threads/sync.pyRs  (RRRR%R&R(R(((s)/usr/lib64/python2.7/Demo/threads/sync.pyR"vs     t semaphorecBs&eZddZdZdZRS(icCs>|dkrtd|n||_||_t|_dS(Nis semaphore count %d; must be >= 1(RtcounttmaxcountRtnonzero(RR*((s)/usr/lib64/python2.7/Demo/threads/sync.pyRs    cCsQ|jjx |jdkr/|jjqW|jd|_|jjdS(Nii(R,RR*RR(R((s)/usr/lib64/python2.7/Demo/threads/sync.pytps  cCs`|jj|j|jkr2td|jn|jd|_|jj|jjdS(Ns:.v() tried to raise semaphore count above initial value %ri(R,RR*R+RRR(R((s)/usr/lib64/python2.7/Demo/threads/sync.pytvs   (RRRR-R.(((s)/usr/lib64/python2.7/Demo/threads/sync.pyR)s  tmrswcBs>eZdZdZdZdZdZdZRS(cCsRtj|_d|_d|_d|_t|j|_t|j|_dS(Ni( RRtrwOKtnrtnwtwritingRtreadOKtwriteOK(R((s)/usr/lib64/python2.7/Demo/threads/sync.pyRs    cCsK|jjx|jr)|jjqW|jd|_|jjdS(Ni(R0RR2R4RR1R(R((s)/usr/lib64/python2.7/Demo/threads/sync.pytread_ins   cCsh|jj|jdkr(tdn|jd|_|jdkrW|jjn|jjdS(Nis,.read_out() invoked without an active readeri(R0RR1RR5RR(R((s)/usr/lib64/python2.7/Demo/threads/sync.pytread_outs  cCs]|jj|jd|_x#|js2|jrB|jjq Wd|_|jjdS(Ni(R0RR2R3R1R5RR(R((s)/usr/lib64/python2.7/Demo/threads/sync.pytwrite_ins   cCsr|jj|js"tdnd|_|jd|_|jrT|jjn |jj|jj dS(Ns-.write_out() invoked without an active writerii( R0RR3RR2R5RR4RR(R((s)/usr/lib64/python2.7/Demo/threads/sync.pyt write_outs      cCsu|jj|js"tdnd|_|jd|_|jd|_|jsd|jjn|jjdS(Ns1.write_to_read() invoked without an active writerii( R0RR3RR2R1R4RR(R((s)/usr/lib64/python2.7/Demo/threads/sync.pyt write_to_reads     (RRRR6R7R8R9R:(((s)/usr/lib64/python2.7/Demo/threads/sync.pyR/s    cGsytjtd}atjtjtj|dG|GdGttGdGHtjtj ||f|dS(Nisstarting threads--talive( ttidRtTIDRtioR;tappendtlenRtstart_new_thread(tfunctargsR ((s)/usr/lib64/python2.7/Demo/threads/sync.pyt _new_threads    c CsWtjdG|GdG|G|GHtj||dkr||}|d}xQt||D]@}|||kr]||||||<||<|d}q]q]W||d|||<||dRRtrangeR"RDt_qsortRR;tremoveR%( R<tatltrtfinishedtpivottjtitl_subarray_sortedtr_subarray_sorted((s)/usr/lib64/python2.7/Demo/threads/sync.pyRGs,    !      cCstjdG|GdGHtjx]tdt|D]F}tjtd|}tj||||||<||RRRFR@twhtrandintR;RHR%(R<RIRLRORN((s)/usr/lib64/python2.7/Demo/threads/sync.pyt _randarrays    !  cCs.|tt|kr*td|fndS(Ns a not sorted(RFR@R(RI((s)/usr/lib64/python2.7/Demo/threads/sync.pyt _check_sortscCs6tjdG|GdG|GHtjt}tt|||jtjdG|GdG|GHtj|jtt|dt |||jt |tjdG|GdGHtj|j tjdG|GdGHtjtjt j |tj|j |j |jdS(NRt randomizingtsortingisentering barriersleaving barrier(R>RRR"RDRTRR&RGR@RUR!R;RHR%(R<RItbartdoneRL((s)/usr/lib64/python2.7/Demo/threads/sync.pyt _run_one_sorts4                 cCsXddl}|jadatjatjatjagad}g}x/t |D]!}|j t |ddq^Wt |}t }x+t |D]}t t||||qW|jdGHtrtdtfnxWt |D]I}||}t||ddkr9td|d fnt|qWd GtGd GHdS( Niiiii s*all threads done, and checking results ...sthreads still alive at endslength of arrays screwed ups test passed!sthreads created in all(trandomRSR=RRR<R>RRR;RFR?RR"RDRZRRR@RU(R[tNSORTStarraysRORXRLRI((s)/usr/lib64/python2.7/Demo/threads/sync.pyttest7s2         t__main__(((((( RRRR"R)R/RDRGRTRURZR^R(((s)/usr/lib64/python2.7/Demo/threads/sync.pyts TE     ! PK!7\fcmp.pynu[# Coroutine example: controlling multiple instances of a single function from Coroutine import * # fringe visits a nested list in inorder, and detaches for each non-list # element; raises EarlyExit after the list is exhausted def fringe(co, list): for x in list: if type(x) is type([]): fringe(co, x) else: co.back(x) def printinorder(list): co = Coroutine() f = co.create(fringe, co, list) try: while 1: print co.tran(f), except EarlyExit: pass print printinorder([1,2,3]) # 1 2 3 printinorder([[[[1,[2]]],3]]) # ditto x = [0, 1, [2, [3]], [4,5], [[[6]]] ] printinorder(x) # 0 1 2 3 4 5 6 # fcmp lexicographically compares the fringes of two nested lists def fcmp(l1, l2): co1 = Coroutine(); f1 = co1.create(fringe, co1, l1) co2 = Coroutine(); f2 = co2.create(fringe, co2, l2) while 1: try: v1 = co1.tran(f1) except EarlyExit: try: v2 = co2.tran(f2) except EarlyExit: return 0 co2.kill() return -1 try: v2 = co2.tran(f2) except EarlyExit: co1.kill() return 1 if v1 != v2: co1.kill(); co2.kill() return cmp(v1,v2) print fcmp(range(7), x) # 0; fringes are equal print fcmp(range(6), x) # -1; 1st list ends early print fcmp(x, range(6)) # 1; 2nd list ends early print fcmp(range(8), x) # 1; 2nd list ends early print fcmp(x, range(8)) # -1; 1st list ends early print fcmp([1,[[2],8]], [[[1],2],8]) # 0 print fcmp([1,[[3],8]], [[[1],2],8]) # 1 print fcmp([1,[[2],8]], [[[1],2],9]) # -1 # end of example PK!B} 6AA squasher.pycnu[ ^c@sdZddlTdZdZdZdZdZddlZeZej eeZ ej eZ ej eZ ej eZ ej eZeje d GHdS( s} d = sqrt(b**2 - 4*a*c) twoa = 2*a L = -b/twoa R = d/twoa A1 = L + R A2 = L - R i(t*cCs1x*tj|dD]}tjt|qWdS(Ns (tstringt splitfieldstcottrantcodisassembler(ttexttline((s-/usr/lib64/python2.7/Demo/threads/squasher.pytgetline-scCs[xTtjt}x.tt|D]}tjt||q%WtjtdqWdS(Nt;(RRt cogetlinetrangetlent cosquasher(tcardti((s-/usr/lib64/python2.7/Demo/threads/squasher.pyt disassembler1s cCsxtjt}|dkr[tjt}|dkrBd}q[tjt||}n|dkrx#tjt}|dkrjPqjqjWtjtd|}ntjt|qWdS(NRt^s t (RRRt coassembler(tchtch2((s-/usr/lib64/python2.7/Demo/threads/squasher.pytsquasher8s        cCsd}xXtjt}|dkr(Pnt|dkrStjt|d}n||}q W|ddt|}tjt|tjdS(NtsiHR(RRR R t coputlinetkill(RR((s-/usr/lib64/python2.7/Demo/threads/squasher.pyt assemblerKs  cCsxtjt}|GHqWdS(N(RRR(R((s-/usr/lib64/python2.7/Demo/threads/squasher.pytputlineYsNtdone(ttestt CoroutineRRRRRRRtcreateR RRRR R(((s-/usr/lib64/python2.7/Demo/threads/squasher.pyts         PK!j+j+sync.pycnu[ ^c@sddlZdddYZdddYZdddYZddd YZd dd YZd Zd ZdZdZ dZ dZ e dkre ndS(iNt conditioncBsDeZddZdZdZdZdZddZRS(cCs|dkrtj|_n3t|drHt|drH||_n tdtj|_|jjtj|_d|_ d|_ d|_ d|_ d|_ dS(Ntacquiretreleases.condition constructor requires a lock argumenti(tNonetthreadt allocate_locktmutexthasattrt TypeErrortcheckoutRtidlocktidtwaitingtpendingt toreleaset releasing(tselftlock((s)/usr/lib64/python2.7/Demo/threads/sync.pyt__init__s        cCs|jjdS(N(RR(R((s)/usr/lib64/python2.7/Demo/threads/sync.pyR*scCs|jjdS(N(RR(R((s)/usr/lib64/python2.7/Demo/threads/sync.pyR-scCs3|j|j|j}}}|js5tdn|j|j}|jd|_|j|jx?|j|j||jkrPn|j|jqoW|j d|_ |j d|_ |j r|jn7d|_ |j |jko dknrd|_n|j|jdS(Ns1condition must be .acquire'd when .wait() invokedii( RR R tlockedt ValueErrorRR R RR RR(RRR R tmyid((s)/usr/lib64/python2.7/Demo/threads/sync.pytwait0s2           "  cCs|jddS(Ni(t broadcast(R((s)/usr/lib64/python2.7/Demo/threads/sync.pytsignalNsicCs|dkrtd|fn|dkr/dS|jj|jrt|j|j|_d|_|jd|_n|dkr|j|_nt|j|j||_|jr|j rd|_|j j n|jj dS(Nis.broadcast called with num %rii( RR RR R R RtminRR R(Rtnum((s)/usr/lib64/python2.7/Demo/threads/sync.pyRQs"        N( t__name__t __module__RRRRRRR(((s)/usr/lib64/python2.7/Demo/threads/sync.pyRs      tbarriercBseZdZdZRS(cCs"||_||_t|_dS(N(tnttogoRtfull(RR((s)/usr/lib64/python2.7/Demo/threads/sync.pyRfs  cCs]|j}|j|jd|_|jr9|jn|j|_|j|jdS(Ni(R RRRRRR(RR ((s)/usr/lib64/python2.7/Demo/threads/sync.pytenterks      (RRRR!(((s)/usr/lib64/python2.7/Demo/threads/sync.pyRes teventcBs5eZdZdZdZdZdZRS(cCsd|_t|_dS(Ni(tstateRtposted(R((s)/usr/lib64/python2.7/Demo/threads/sync.pyRws cCs4|jjd|_|jj|jjdS(Ni(R$RR#RR(R((s)/usr/lib64/python2.7/Demo/threads/sync.pytpost{s   cCs'|jjd|_|jjdS(Ni(R$RR#R(R((s)/usr/lib64/python2.7/Demo/threads/sync.pytclears  cCs'|jj|j}|jj|S(N(R$RR#R(Rtanswer((s)/usr/lib64/python2.7/Demo/threads/sync.pyt is_posteds   cCs7|jj|js&|jjn|jjdS(N(R$RR#RR(R((s)/usr/lib64/python2.7/Demo/threads/sync.pyRs  (RRRR%R&R(R(((s)/usr/lib64/python2.7/Demo/threads/sync.pyR"vs     t semaphorecBs&eZddZdZdZRS(icCs>|dkrtd|n||_||_t|_dS(Nis semaphore count %d; must be >= 1(RtcounttmaxcountRtnonzero(RR*((s)/usr/lib64/python2.7/Demo/threads/sync.pyRs    cCsQ|jjx |jdkr/|jjqW|jd|_|jjdS(Nii(R,RR*RR(R((s)/usr/lib64/python2.7/Demo/threads/sync.pytps  cCs`|jj|j|jkr2td|jn|jd|_|jj|jjdS(Ns:.v() tried to raise semaphore count above initial value %ri(R,RR*R+RRR(R((s)/usr/lib64/python2.7/Demo/threads/sync.pytvs   (RRRR-R.(((s)/usr/lib64/python2.7/Demo/threads/sync.pyR)s  tmrswcBs>eZdZdZdZdZdZdZRS(cCsRtj|_d|_d|_d|_t|j|_t|j|_dS(Ni( RRtrwOKtnrtnwtwritingRtreadOKtwriteOK(R((s)/usr/lib64/python2.7/Demo/threads/sync.pyRs    cCsK|jjx|jr)|jjqW|jd|_|jjdS(Ni(R0RR2R4RR1R(R((s)/usr/lib64/python2.7/Demo/threads/sync.pytread_ins   cCsh|jj|jdkr(tdn|jd|_|jdkrW|jjn|jjdS(Nis,.read_out() invoked without an active readeri(R0RR1RR5RR(R((s)/usr/lib64/python2.7/Demo/threads/sync.pytread_outs  cCs]|jj|jd|_x#|js2|jrB|jjq Wd|_|jjdS(Ni(R0RR2R3R1R5RR(R((s)/usr/lib64/python2.7/Demo/threads/sync.pytwrite_ins   cCsr|jj|js"tdnd|_|jd|_|jrT|jjn |jj|jj dS(Ns-.write_out() invoked without an active writerii( R0RR3RR2R5RR4RR(R((s)/usr/lib64/python2.7/Demo/threads/sync.pyt write_outs      cCsu|jj|js"tdnd|_|jd|_|jd|_|jsd|jjn|jjdS(Ns1.write_to_read() invoked without an active writerii( R0RR3RR2R1R4RR(R((s)/usr/lib64/python2.7/Demo/threads/sync.pyt write_to_reads     (RRRR6R7R8R9R:(((s)/usr/lib64/python2.7/Demo/threads/sync.pyR/s    cGsytjtd}atjtjtj|dG|GdGttGdGHtjtj ||f|dS(Nisstarting threads--talive( ttidRtTIDRtioR;tappendtlenRtstart_new_thread(tfunctargsR ((s)/usr/lib64/python2.7/Demo/threads/sync.pyt _new_threads    c CsWtjdG|GdG|G|GHtj||dkr||}|d}xQt||D]@}|||kr]||||||<||<|d}q]q]W||d|||<||dRRtrangeR"RDt_qsortRR;tremoveR%( R<tatltrtfinishedtpivottjtitl_subarray_sortedtr_subarray_sorted((s)/usr/lib64/python2.7/Demo/threads/sync.pyRGs,    !      cCstjdG|GdGHtjx]tdt|D]F}tjtd|}tj||||||<||RRRFR@twhtrandintR;RHR%(R<RIRLRORN((s)/usr/lib64/python2.7/Demo/threads/sync.pyt _randarrays    !  cCs.|tt|kr*td|fndS(Ns a not sorted(RFR@R(RI((s)/usr/lib64/python2.7/Demo/threads/sync.pyt _check_sortscCs6tjdG|GdG|GHtjt}tt|||jtjdG|GdG|GHtj|jtt|dt |||jt |tjdG|GdGHtj|j tjdG|GdGHtjtjt j |tj|j |j |jdS(NRt randomizingtsortingisentering barriersleaving barrier(R>RRR"RDRTRR&RGR@RUR!R;RHR%(R<RItbartdoneRL((s)/usr/lib64/python2.7/Demo/threads/sync.pyt _run_one_sorts4                 cCsXddl}|jadatjatjatjagad}g}x/t |D]!}|j t |ddq^Wt |}t }x+t |D]}t t||||qW|jdGHtrtdtfnxWt |D]I}||}t||ddkr9td|d fnt|qWd GtGd GHdS( Niiiii s*all threads done, and checking results ...sthreads still alive at endslength of arrays screwed ups test passed!sthreads created in all(trandomRSR=RRR<R>RRR;RFR?RR"RDRZRRR@RU(R[tNSORTStarraysRORXRLRI((s)/usr/lib64/python2.7/Demo/threads/sync.pyttest7s2         t__main__(((((( RRRR"R)R/RDRGRTRURZR^R(((s)/usr/lib64/python2.7/Demo/threads/sync.pyts TE     ! PK!B} 6AA squasher.pyonu[ ^c@sdZddlTdZdZdZdZdZddlZeZej eeZ ej eZ ej eZ ej eZ ej eZeje d GHdS( s} d = sqrt(b**2 - 4*a*c) twoa = 2*a L = -b/twoa R = d/twoa A1 = L + R A2 = L - R i(t*cCs1x*tj|dD]}tjt|qWdS(Ns (tstringt splitfieldstcottrantcodisassembler(ttexttline((s-/usr/lib64/python2.7/Demo/threads/squasher.pytgetline-scCs[xTtjt}x.tt|D]}tjt||q%WtjtdqWdS(Nt;(RRt cogetlinetrangetlent cosquasher(tcardti((s-/usr/lib64/python2.7/Demo/threads/squasher.pyt disassembler1s cCsxtjt}|dkr[tjt}|dkrBd}q[tjt||}n|dkrx#tjt}|dkrjPqjqjWtjtd|}ntjt|qWdS(NRt^s t (RRRt coassembler(tchtch2((s-/usr/lib64/python2.7/Demo/threads/squasher.pytsquasher8s        cCsd}xXtjt}|dkr(Pnt|dkrStjt|d}n||}q W|ddt|}tjt|tjdS(NtsiHR(RRR R t coputlinetkill(RR((s-/usr/lib64/python2.7/Demo/threads/squasher.pyt assemblerKs  cCsxtjt}|GHqWdS(N(RRR(R((s-/usr/lib64/python2.7/Demo/threads/squasher.pytputlineYsNtdone(ttestt CoroutineRRRRRRRtcreateR RRRR R(((s-/usr/lib64/python2.7/Demo/threads/squasher.pyts         PK!Vm Generator.pynu[# Generator implementation using threads import sys import thread class Killed(Exception): pass class Generator: # Constructor def __init__(self, func, args): self.getlock = thread.allocate_lock() self.putlock = thread.allocate_lock() self.getlock.acquire() self.putlock.acquire() self.func = func self.args = args self.done = 0 self.killed = 0 thread.start_new_thread(self._start, ()) # Internal routine def _start(self): try: self.putlock.acquire() if not self.killed: try: apply(self.func, (self,) + self.args) except Killed: pass finally: if not self.killed: self.done = 1 self.getlock.release() # Called by producer for each value; raise Killed if no more needed def put(self, value): if self.killed: raise TypeError, 'put() called on killed generator' self.value = value self.getlock.release() # Resume consumer thread self.putlock.acquire() # Wait for next get() call if self.killed: raise Killed # Called by producer to get next value; raise EOFError if no more def get(self): if self.killed: raise TypeError, 'get() called on killed generator' self.putlock.release() # Resume producer thread self.getlock.acquire() # Wait for value to appear if self.done: raise EOFError # Say there are no more values return self.value # Called by consumer if no more values wanted def kill(self): if self.killed: raise TypeError, 'kill() called on killed generator' self.killed = 1 self.putlock.release() # Clone constructor def clone(self): return Generator(self.func, self.args) def pi(g): k, a, b, a1, b1 = 2L, 4L, 1L, 12L, 4L while 1: # Next approximation p, q, k = k*k, 2L*k+1L, k+1L a, b, a1, b1 = a1, b1, p*a+q*a1, p*b+q*b1 # Print common digits d, d1 = a//b, a1//b1 while d == d1: g.put(int(d)) a, a1 = 10L*(a%b), 10L*(a1%b1) d, d1 = a//b, a1//b1 def test(): g = Generator(pi, ()) g.kill() g = Generator(pi, ()) for i in range(10): print g.get(), print h = g.clone() g.kill() while 1: print h.get(), sys.stdout.flush() test() PK!Q, Generator.pycnu[ ^c@s^ddlZddlZdefdYZdddYZdZdZedS( iNtKilledcBseZRS((t__name__t __module__(((s./usr/lib64/python2.7/Demo/threads/Generator.pyRst GeneratorcBs>eZdZdZdZdZdZdZRS(cCsstj|_tj|_|jj|jj||_||_d|_d|_tj |j ddS(Ni(( tthreadt allocate_locktgetlocktputlocktacquiretfunctargstdonetkilledtstart_new_threadt_start(tselfR R ((s./usr/lib64/python2.7/Demo/threads/Generator.pyt__init__ s      cCsyzO|jj|jsNyt|j|f|jWqNtk rJqNXnWd|jstd|_|jj nXdS(Ni( RRR tapplyR R RR Rtrelease(R((s./usr/lib64/python2.7/Demo/threads/Generator.pyRs      cCsN|jrtdn||_|jj|jj|jrJtndS(Ns put() called on killed generator(R t TypeErrortvalueRRRRR(RR((s./usr/lib64/python2.7/Demo/threads/Generator.pytput%s      cCsH|jrtdn|jj|jj|jrAtn|jS(Ns get() called on killed generator( R RRRRRR tEOFErrorR(R((s./usr/lib64/python2.7/Demo/threads/Generator.pytget/s      cCs/|jrtdnd|_|jjdS(Ns!kill() called on killed generatori(R RRR(R((s./usr/lib64/python2.7/Demo/threads/Generator.pytkill9s   cCst|j|jS(N(RR R (R((s./usr/lib64/python2.7/Demo/threads/Generator.pytclone@s(RRRRRRRR(((s./usr/lib64/python2.7/Demo/threads/Generator.pyR s   c Csd\}}}}}x||d|d|d}}}||||||||||f\}}}}||||}} xU|| kr|jt|d||d||}}||||}} qWqWdS(Nllll l (llll l(Rtint( tgtktatbta1tb1tptqtdtd1((s./usr/lib64/python2.7/Demo/threads/Generator.pytpiCs$6cCsttd}|jttd}xtdD]}|jGq5WH|j}|jx|jGtjjqcWdS(Ni ((( RR%RtrangeRRtsyststdouttflush(Rtith((s./usr/lib64/python2.7/Demo/threads/Generator.pyttestPs    ((R'Rt ExceptionRRR%R,(((s./usr/lib64/python2.7/Demo/threads/Generator.pyts  : PK!}c telnet.pycnu[ ^c@sddlZddlZddlZddlTddlZd ZedZedZedZ edZ ed Z d Z d Z d Ze dS(iN(t*iiiiiiicCsttjdkr5tjjdtjdntjd}yt|}Wn9tk rtjjtjddtjdnXttjdkrtjd}nd}d|d kodknrt|}nHyt |d}Wn2tk r/tjj|d tjdnXt t t }y|j ||fWn7tk r}tjjd |ftjdnXtjt|ft|dS( Nisusage: telnet hostname [port] is: bad host name ttelnett0t9ttcps: bad tcp service name sconnect failed: %r (tlentsystargvtstderrtwritetexitt gethostbynameterrortevalt getservbynametsockettAF_INETt SOCK_STREAMtconnecttthreadt start_newtchildtparent(thostthostaddrtservnametporttstmsg((s+/usr/lib64/python2.7/Demo/threads/telnet.pytmains6    cCswd}d}xd|jt\}}|sJtjjdtjdnd}x|D]}|rt|GH|j||d}qW|r+d}|tkr||}qN|t t fkr|t krdGndGtt }qN|t t fkr|t krdGndGtt }qNd Gt|GHqW|tkrDd}d GqW||}qWWtj j|tj jqWdS( Nits(Closed by remote host) is(DO)s(DONT)s(WILL)s(WONT)s (command)s(IAC)(trecvfromtBUFSIZERRR R tordtsendtIACtDOtDONTtWONTtWILLtstdouttflush(Rtiactopttdatatdummyt cleandatatc((s+/usr/lib64/python2.7/Demo/threads/telnet.pyRBsD          cCs1x*tjj}|sPn|j|qWdS(N(RtstdintreadlineR"(Rtline((s+/usr/lib64/python2.7/Demo/threads/telnet.pyRjs i (RtosttimeRRR tchrR#R%R$R&R'RRR(((s+/usr/lib64/python2.7/Demo/threads/telnet.pyts$        $ ( PK!3h!!find.pyonu[ ^c@sddlZddlZddlZddlZddlZddlTddlZdddYZdZdZ dZ edS( iN(t*tWorkQcBs>eZdZdZdZdZdZdZRS(cCsAtj|_tj|_|jjg|_d|_dS(Ni(tthreadtallocatetmutexttodotacquiretworktbusy(tself((s)/usr/lib64/python2.7/Demo/threads/find.pyt__init__,s   cCs_||f}|jj|jj||jjt|jdkr[|jjndS(Ni(RRRtappendtreleasetlenR(R tfunctargstjob((s)/usr/lib64/python2.7/Demo/threads/find.pytaddwork3s    cCs|jj|jj|jdkr\t|jdkr\|jj|jjdS|jd}|jd=|jd|_|jjt|jdkr|jjn|S(Nii(RRRRR RR tNone(R R((s)/usr/lib64/python2.7/Demo/threads/find.pyt_getwork;s  $     cCsb|jj|jd|_|jdkrQt|jdkrQ|jjn|jjdS(Nii(RRRR RRR (R ((s)/usr/lib64/python2.7/Demo/threads/find.pyt _doneworkJs  $cCsQtjdx=|j}|s&Pn|\}}t|||jqWdS(Ngh㈵>(ttimetsleepRtapplyR(R RRR((s)/usr/lib64/python2.7/Demo/threads/find.pyt_workerQs    cCsV|js dSx+t|dD]}tj|jdqW|j|jjdS(Ni((RtrangeRt start_newRRR(R tnworkersti((s)/usr/lib64/python2.7/Demo/threads/find.pytrun[s   (t__name__t __module__R RRRRR(((s)/usr/lib64/python2.7/Demo/threads/find.pyR#s      c Csd}tjtjdd\}}x2|D]*\}}|dkr,tj|}q,q,W|sotjg}nt}x'|D]}|jt |t |fqWt j }|j |t j }tj jd||dS(Niis-w:s-wsTotal time %r sec. (tgetopttsystargvtstringtatoitostcurdirRRtfindtselectorRRtstderrtwrite( RtoptsRtopttargtwqtdirtt1tt2((s)/usr/lib64/python2.7/Demo/threads/find.pytmainfs      cCs#|td@dko"t|t S(Nii(tST_MODEtS_ISLNK(R/tnametfullnametstat((s)/usr/lib64/python2.7/Demo/threads/find.pyR(}scCs%ytj|}Wn*tjk r?}t|GdG|GHdSXx|D]}|tjtjfkrGtjj||}ytj|}Wn,tjk r}t|GdG|GHqGnX|||||r|GHnt |t rtjj |s|j t |||fqqqGqGWdS(Nt:(R%tlistdirterrortreprR&tpardirtpathtjointlstattS_ISDIRR3tismountRR'(R/tpredR.tnamestmsgR5R6R7((s)/usr/lib64/python2.7/Demo/threads/find.pyR's$ (( R!R R#RR%R7RRR2R(R'(((s)/usr/lib64/python2.7/Demo/threads/find.pyts       C   PK!Q, Generator.pyonu[ ^c@s^ddlZddlZdefdYZdddYZdZdZedS( iNtKilledcBseZRS((t__name__t __module__(((s./usr/lib64/python2.7/Demo/threads/Generator.pyRst GeneratorcBs>eZdZdZdZdZdZdZRS(cCsstj|_tj|_|jj|jj||_||_d|_d|_tj |j ddS(Ni(( tthreadt allocate_locktgetlocktputlocktacquiretfunctargstdonetkilledtstart_new_threadt_start(tselfR R ((s./usr/lib64/python2.7/Demo/threads/Generator.pyt__init__ s      cCsyzO|jj|jsNyt|j|f|jWqNtk rJqNXnWd|jstd|_|jj nXdS(Ni( RRR tapplyR R RR Rtrelease(R((s./usr/lib64/python2.7/Demo/threads/Generator.pyRs      cCsN|jrtdn||_|jj|jj|jrJtndS(Ns put() called on killed generator(R t TypeErrortvalueRRRRR(RR((s./usr/lib64/python2.7/Demo/threads/Generator.pytput%s      cCsH|jrtdn|jj|jj|jrAtn|jS(Ns get() called on killed generator( R RRRRRR tEOFErrorR(R((s./usr/lib64/python2.7/Demo/threads/Generator.pytget/s      cCs/|jrtdnd|_|jjdS(Ns!kill() called on killed generatori(R RRR(R((s./usr/lib64/python2.7/Demo/threads/Generator.pytkill9s   cCst|j|jS(N(RR R (R((s./usr/lib64/python2.7/Demo/threads/Generator.pytclone@s(RRRRRRRR(((s./usr/lib64/python2.7/Demo/threads/Generator.pyR s   c Csd\}}}}}x||d|d|d}}}||||||||||f\}}}}||||}} xU|| kr|jt|d||d||}}||||}} qWqWdS(Nllll l (llll l(Rtint( tgtktatbta1tb1tptqtdtd1((s./usr/lib64/python2.7/Demo/threads/Generator.pytpiCs$6cCsttd}|jttd}xtdD]}|jGq5WH|j}|jx|jGtjjqcWdS(Ni ((( RR%RtrangeRRtsyststdouttflush(Rtith((s./usr/lib64/python2.7/Demo/threads/Generator.pyttestPs    ((R'Rt ExceptionRRR%R,(((s./usr/lib64/python2.7/Demo/threads/Generator.pyts  : PK! Coroutine.pyonu[ ^c@snddlZddlZdd dYZdefdYZdefdYZdd d YZdS( iNt_CoEventcBs>eZdZdZdZdZdZdZRS(cCs||_tj|_dS(N(tftsyncteventte(tselftfunc((s./usr/lib64/python2.7/Demo/threads/Coroutine.pyt__init__Is cCs%|jdkrdSd|jjSdS(Nsmain coroutinescoroutine for func (RtNonet func_name(R((s./usr/lib64/python2.7/Demo/threads/Coroutine.pyt__repr__MscCs t|S(N(tid(R((s./usr/lib64/python2.7/Demo/threads/Coroutine.pyt__hash__SscCstt|t|S(N(tcmpR (txty((s./usr/lib64/python2.7/Demo/threads/Coroutine.pyt__cmp__VscCs|jjdS(N(Rtpost(R((s./usr/lib64/python2.7/Demo/threads/Coroutine.pytresumeYscCs|jj|jjdS(N(Rtwaittclear(R((s./usr/lib64/python2.7/Demo/threads/Coroutine.pyR\s (t__name__t __module__RR R RRR(((s./usr/lib64/python2.7/Demo/threads/Coroutine.pyRHs      tKilledcBseZRS((RR(((s./usr/lib64/python2.7/Demo/threads/Coroutine.pyR`st EarlyExitcBseZRS((RR(((s./usr/lib64/python2.7/Demo/threads/Coroutine.pyRast CoroutinecBsPeZdZdZdZdZddZddZddZ RS(cCsHtd|_|_id|j6|_d|_d|_d|_dS(Ni(RRtactivetmaint invokedbytkilledtvaluet terminated_by(R((s./usr/lib64/python2.7/Demo/threads/Coroutine.pyRds   cGs7t|}d|j|Es  PK!:xx threads.sonuȯPK!lshared/shared.sonuȯPK!>PP Ashared.pmnu[PK! ,fcmp.pycnu[PK!8 ژCoroutine.pynu[PK! ,fcmp.pyonu[PK! Coroutine.pycnu[PK!__  Stelnet.pynu[PK!; squasher.pynu[PK!3h!!find.pycnu[PK!eITTsync.pynu[PK!}c Btelnet.pyonu[PK!+wwLfind.pynu[PK!I]READMEnu[PK!j+j+_sync.pyonu[PK!7\,fcmp.pynu[PK!B} 6AA :squasher.pycnu[PK!j+j+sync.pycnu[PK!B} 6AA Ysquasher.pyonu[PK!Vm Generator.pynu[PK!Q, Generator.pycnu[PK!}c .telnet.pycnu[PK!3h!!Kfind.pyonu[PK!Q, Generator.pyonu[PK!  Coroutine.pyonu[PK: