X-Git-Url: https://perl5.git.perl.org/perl5.git/blobdiff_plain/c6d0653ecf0dad132c23d7d0cee4e6f636535da7..acbe17fc4e3c447b48d980c85cdc81b3190f66eb:/pod/perlhack.pod diff --git a/pod/perlhack.pod b/pod/perlhack.pod index 155773d..629f4d5 100644 --- a/pod/perlhack.pod +++ b/pod/perlhack.pod @@ -273,7 +273,7 @@ From http://rsync.samba.org/README.html: "Rsync uses rsh or ssh for communication. It does not need to be setuid and requires no special privileges for installation. It - does not require a inetd entry or a deamon. You must, however, + does not require an inetd entry or a daemon. You must, however, have a working rsh or ssh system. Using ssh is recommended for its security features." @@ -350,11 +350,11 @@ from Andreas K =back -=head3 Why rsync the source tree +=head2 Why rsync the source tree =over 4 -=item It's easier +=item It's easier to rsync the source tree Since you don't have to apply the patches yourself, you are sure all files in the source tree are in the right state. @@ -378,11 +378,11 @@ more ... (see Sarathy's remark). =back -=head3 Why rsync the patches +=head2 Why rsync the patches =over 4 -=item It's easier +=item It's easier to rsync the patches If you have more than one machine that you want to keep in track with bleadperl, it's easier to rsync the patches only once and then apply @@ -410,7 +410,7 @@ the current source tree (i.e. perl@7582.tar.gz), which will be an excellent point to start with when choosing to use the 'rsync the patches' scheme. Starting with perl@7582, which means a set of source files on which the latest applied patch is number 7582, you apply all -succeeding patches available from than on (7583, 7584, ...). +succeeding patches available from then on (7583, 7584, ...). You can use the patches later as a kind of search archive. @@ -434,7 +434,7 @@ look how others apply the fix. =item Finding the source of misbehaviour When you keep in sync with bleadperl, the pumpking would love to -I that the community efforts realy work. So after each of his +I that the community efforts really work. So after each of his sync points, you are to 'make test' to check if everything is still in working order. If it is, you do 'make ok', which will send an OK report to perlbug@perl.org. (If you do not have access to a mailer @@ -442,7 +442,7 @@ from the system you just finished successfully 'make test', you can do 'make okfile', which creates the file C, which you can than take to your favourite mailer and mail yourself). -But of course, as always, things will not allways lead to a success +But of course, as always, things will not always lead to a success path, and one or more test do not pass the 'make test'. Before sending in a bug report (using 'make nok' or 'make nokfile'), check the mailing list if someone else has reported the bug already and if @@ -469,24 +469,27 @@ for reference. =head2 Submitting patches -Always submit patches to I. This lets other -porters review your patch, which catches a surprising number of errors -in patches. Either use the diff program (available in source code -form from I), or use Johan Vromans' -I (available from I). Unified diffs -are preferred, but context diffs are accepted. Do not send RCS-style -diffs or diffs without context lines. More information is given in -the I file in the Perl source distribution. -Please patch against the latest B version (e.g., if -you're fixing a bug in the 5.005 track, patch against the latest -5.005_5x version). Only patches that survive the heat of the -development branch get applied to maintenance versions. - -Your patch should update the documentation and test suite. +Always submit patches to I. If you're +patching a core module and there's an author listed, send the author a +copy (see L). This lets other porters review +your patch, which catches a surprising number of errors in patches. +Either use the diff program (available in source code form from +I), or use Johan Vromans' I +(available from I). Unified diffs are preferred, +but context diffs are accepted. Do not send RCS-style diffs or diffs +without context lines. More information is given in the +I file in the Perl source distribution. Please +patch against the latest B version (e.g., if you're +fixing a bug in the 5.005 track, patch against the latest 5.005_5x +version). Only patches that survive the heat of the development +branch get applied to maintenance versions. + +Your patch should update the documentation and test suite. See +L. To report a bug in Perl, use the program I which comes with Perl (if you can't get Perl to work, send mail to the address -I or I). Reporting bugs through +I or I). Reporting bugs through I feeds into the automated bug-tracking system, access to which is provided through the web at I. It often pays to check the archives of the perl5-porters mailing list to @@ -570,6 +573,13 @@ Modules shipped as part of the Perl core live in the F and F subdirectories: F is for the pure-Perl modules, and F contains the core XS modules. +=item Tests + +There are tests for nearly all the modules, built-ins and major bits +of functionality. Test files all have a .t suffix. Module tests live +in the F and F directories next to the module being +tested. Others live in F. See L + =item Documentation Documentation maintenance includes looking after everything in the @@ -1146,7 +1156,7 @@ the code which implements the addition operator: 1 PP(pp_add) 2 { - 3 djSP; dATARGET; tryAMAGICbin(add,opASSIGN); + 3 dSP; dATARGET; tryAMAGICbin(add,opASSIGN); 4 { 5 dPOPTOPnnrl_ul; 6 SETn( left + right ); @@ -1241,7 +1251,7 @@ Run the program with the given arguments. =item break source.c:xxx Tells the debugger that we'll want to pause execution when we reach -either the named function (but see L!) or the given +either the named function (but see L!) or the given line in the named source file. =item step @@ -1299,7 +1309,7 @@ C<+> operator: (gdb) break Perl_pp_add Breakpoint 1 at 0x46249f: file pp_hot.c, line 309. -Notice we use C and not C - see L. +Notice we use C and not C - see L. With the breakpoint in place, we can run our program: (gdb) run -e '$b = "6XXXX"; $c = 2.3; $a = $b + $c' @@ -1308,7 +1318,7 @@ Lots of junk will go past as gdb reads in the relevant source files and libraries, and then: Breakpoint 1, Perl_pp_add () at pp_hot.c:309 - 309 djSP; dATARGET; tryAMAGICbin(add,opASSIGN); + 309 dSP; dATARGET; tryAMAGICbin(add,opASSIGN); (gdb) step 311 dPOPTOPnnrl_ul; (gdb) @@ -1371,7 +1381,7 @@ similar output to L. } } -< finish this later > +# finish this later # =head2 Patching @@ -1387,6 +1397,9 @@ the C happens at runtime, so it's going to be in one of the F files. Sure enough, C is in F. Since we're going to be altering this file, let's copy it to F. +[Well, it was in F when this tutorial was written. It has now been +split off with C to its own file, F] + Now let's look over C: we take a pattern into C, and then loop over the pattern, taking each format character in turn into C. Then for each possible format character, we swallow up @@ -1532,6 +1545,156 @@ We end up with a patch looking a little like this: And finally, we submit it, with our rationale, to perl5-porters. Job done! +=head2 Patching a core module + +This works just like patching anything else, with an extra +consideration. Many core modules also live on CPAN. If this is so, +patch the CPAN version instead of the core and send the patch off to +the module maintainer (with a copy to p5p). This will help the module +maintainer keep the CPAN version in sync with the core version without +constantly scanning p5p. + +=head2 Adding a new function to the core + +If, as part of a patch to fix a bug, or just because you have an +especially good idea, you decide to add a new function to the core, +discuss your ideas on p5p well before you start work. It may be that +someone else has already attempted to do what you are considering and +can give lots of good advice or even provide you with bits of code +that they already started (but never finished). + +You have to follow all of the advice given above for patching. It is +extremely important to test any addition thoroughly and add new tests +to explore all boundary conditions that your new function is expected +to handle. If your new function is used only by one module (e.g. toke), +then it should probably be named S_your_function (for static); on the +other hand, if you expect it to accessable from other functions in +Perl, you should name it Perl_your_function. See L +for more details. + +The location of any new code is also an important consideration. Don't +just create a new top level .c file and put your code there; you would +have to make changes to Configure (so the Makefile is created properly), +as well as possibly lots of include files. This is strictly pumpking +business. + +It is better to add your function to one of the existing top level +source code files, but your choice is complicated by the nature of +the Perl distribution. Only the files that are marked as compiled +static are located in the perl executable. Everything else is located +in the shared library (or DLL if you are running under WIN32). So, +for example, if a function was only used by functions located in +toke.c, then your code can go in toke.c. If, however, you want to call +the function from universal.c, then you should put your code in another +location, for example util.c. + +In addition to writing your c-code, you will need to create an +appropriate entry in embed.pl describing your function, then run +'make regen_headers' to create the entries in the numerous header +files that perl needs to compile correctly. See L +for information on the various options that you can set in embed.pl. +You will forget to do this a few (or many) times and you will get +warnings during the compilation phase. Make sure that you mention +this when you post your patch to P5P; the pumpking needs to know this. + +When you write your new code, please be conscious of existing code +conventions used in the perl source files. See for +details. Although most of the guidelines discussed seem to focus on +Perl code, rather than c, they all apply (except when they don't ;). +See also I file in the Perl source distribution +for lots of details about both formatting and submitting patches of +your changes. + +Lastly, TEST TEST TEST TEST TEST any code before posting to p5p. +Test on as many platforms as you can find. Test as many perl +Configure options as you can (e.g. MULTIPLICITY). If you have +profiling or memory tools, see L +below for how to use them to futher test your code. Remember that +most of the people on P5P are doing this on their own time and +don't have the time to debug your code. + +=head2 Writing a test + +Every module and built-in function has an associated test file (or +should...). If you add or change functionality, you have to write a +test. If you fix a bug, you have to write a test so that bug never +comes back. If you alter the docs, it would be nice to test what the +new documentation says. + +In short, if you submit a patch you probably also have to patch the +tests. + +For modules, the test file is right next to the module itself. +F tests F. This is a recent innovation, +so there are some snags (and it would be wonderful for you to brush +them out), but it basically works that way. Everything else lives in +F. + +=over 3 + +=item F + +Testing of the absolute basic functionality of Perl. Things like +C, basic file reads and writes, simple regexes, etc. These are +run first in the test suite and if any of them fail, something is +I broken. + +=item F + +These test the basic control structures, C, C, +subroutines, etc... + +=item F + +Tests basic issues of how Perl parses and compiles itself. + +=item F + +Tests for built-in IO functions, including command line arguments. + +=item F + +The old home for the module tests, you shouldn't put anything new in +here. There are still some bits and pieces hanging around in here +that need to be moved. Perhaps you could move them? Thanks! + +=item F + +Tests for perl's built in functions that don't fit into any of the +other directories. + +=item F + +Tests for POD directives. There are still some tests for the Pod +modules hanging around in here that need to be moved out into F. + +=item F + +Testing features of how perl actually runs, including exit codes and +handling of PERL* environment variables. + +=back + +The core uses the same testing style as the rest of Perl, a simple +"ok/not ok" run through Test::Harness, but there are a few special +considerations. + +For most libraries and extensions, you'll want to use the Test::More +library rather than rolling your own test functions. If a module test +doesn't use Test::More, consider rewriting it so it does. For the +rest it's best to use a simple C style to avoid +broken core functionality from causing the whole test to collapse. + +When you say "make test" Perl uses the F program to run the +test suite. All tests are run from the F directory, B the +directory which contains the test. This causes some problems with the +tests in F, so here's some opportunity for some patching. + +You must be triply conscious of cross-platform concerns. This usually +boils down to using File::Spec and avoiding things like C and +C unless absolutely necessary. + + =head1 EXTERNAL TOOLS FOR DEBUGGING PERL Sometimes it helps to use external tools while debugging and @@ -1674,6 +1837,248 @@ standard Perl testset you would create and run Purify as: which would instrument Perl in memory, run Perl on test.pl, then finally report any memory problems. +=head2 Compaq's/Digital's Third Degree + +Third Degree is a tool for memory leak detection and memory access checks. +It is one of the many tools in the ATOM toolkit. The toolkit is only +available on Tru64 (formerly known as Digital UNIX formerly known as +DEC OSF/1). + +When building Perl, you must first run Configure with -Doptimize=-g +and -Uusemymalloc flags, after that you can use the make targets +"perl.third" and "test.third". (What is required is that Perl must be +compiled using the C<-g> flag, you may need to re-Configure.) + +The short story is that with "atom" you can instrument the Perl +executable to create a new executable called F. When the +instrumented executable is run, it creates a log of dubious memory +traffic in file called F. See the manual pages of atom and +third for more information. The most extensive Third Degree +documentation is available in the Compaq "Tru64 UNIX Programmer's +Guide", chapter "Debugging Programs with Third Degree". + +The "test.third" leaves a lot of files named F in the t/ +subdirectory. There is a problem with these files: Third Degree is so +effective that it finds problems also in the system libraries. +Therefore there are certain types of errors that you should ignore in +your debugging. Errors with stack traces matching + + __actual_atof|__catgets|_doprnt|__exc_|__exec|_findio|__localtime|setlocale|__sia_|__strxfrm + +(all in libc.so) are known to be non-serious. You can also +ignore the combinations + + Perl_gv_fetchfile() calling strcpy() + S_doopen_pmc() calling strcmp() + +causing "rih" (reading invalid heap) errors. + +There are also leaks that for given certain definition of a leak, +aren't. See L for more information. + +=head2 PERL_DESTRUCT_LEVEL + +If you want to run any of the tests yourself manually using the +pureperl or perl.third executables, please note that by default +perl B explicitly cleanup all the memory it has allocated +(such as global memory arenas) but instead lets the exit() of +the whole program "take care" of such allocations, also known +as "global destruction of objects". + +There is a way to tell perl to do complete cleanup: set the +environment variable PERL_DESTRUCT_LEVEL to a non-zero value. +The t/TEST wrapper does set this to 2, and this is what you +need to do too, if you don't want to see the "global leaks": + + PERL_DESTRUCT_LEVEL=2 ./perl.third t/foo/bar.t + +=head2 Profiling + +Depending on your platform there are various of profiling Perl. + +There are two commonly used techniques of profiling executables: +I and I. + +The first method takes periodically samples of the CPU program +counter, and since the program counter can be correlated with the code +generated for functions, we get a statistical view of in which +functions the program is spending its time. The caveats are that very +small/fast functions have lower probability of showing up in the +profile, and that periodically interrupting the program (this is +usually done rather frequently, in the scale of milliseconds) imposes +an additional overhead that may skew the results. The first problem +can be alleviated by running the code for longer (in general this is a +good idea for profiling), the second problem is usually kept in guard +by the profiling tools themselves. + +The second method divides up the generated code into I. +Basic blocks are sections of code that are entered only in the +beginning and exited only at the end. For example, a conditional jump +starts a basic block. Basic block profiling usually works by +I the code by adding I +book-keeping code to the generated code. During the execution of the +code the basic block counters are then updated appropriately. The +caveat is that the added extra code can skew the results: again, the +profiling tools usually try to factor their own effects out of the +results. + +=head2 Gprof Profiling + +gprof is a profiling tool available in many UNIX platforms, +it uses F. + +You can build a profiled version of perl called "perl.gprof" by +invoking the make target "perl.gprof" (What is required is that Perl +must be compiled using the C<-pg> flag, you may need to re-Configure). +Running the profiled version of Perl will create an output file called +F is created which contains the profiling data collected +during the execution. + +The gprof tool can then display the collected data in various ways. +Usually gprof understands the following options: + +=over 4 + +=item -a + +Suppress statically defined functions from the profile. + +=item -b + +Suppress the verbose descriptions in the profile. + +=item -e routine + +Exclude the given routine and its descendants from the profile. + +=item -f routine + +Display only the given routine and its descendants in the profile. + +=item -s + +Generate a summary file called F which then may be given +to subsequent gprof runs to accumulate data over several runs. + +=item -z + +Display routines that have zero usage. + +=back + +For more detailed explanation of the available commands and output +formats, see your own local documentation of gprof. + +=head2 GCC gcov Profiling + +Starting from GCC 3.0 I is officially available +for the GNU CC. + +You can build a profiled version of perl called F by +invoking the make target "perl.gcov" (what is required that Perl must +be compiled using gcc with the flags C<-fprofile-arcs +-ftest-coverage>, you may need to re-Configure). + +Running the profiled version of Perl will cause profile output to be +generated. For each source file an accompanying ".da" file will be +created. + +To display the results you use the "gcov" utility (which should +be installed if you have gcc 3.0 or newer installed). F is +run on source code files, like this + + gcov sv.c + +which will cause F to be created. The F<.gcov> files +contain the source code annotated with relative frequencies of +execution indicated by "#" markers. + +Useful options of F include C<-b> which will summarise the +basic block, branch, and function call coverage, and C<-c> which +instead of relative frequencies will use the actual counts. For +more information on the use of F and basic block profiling +with gcc, see the latest GNU CC manual, as of GCC 3.0 see + + http://gcc.gnu.org/onlinedocs/gcc-3.0/gcc.html + +and its section titled "8. gcov: a Test Coverage Program" + + http://gcc.gnu.org/onlinedocs/gcc-3.0/gcc_8.html#SEC132 + +=head2 Pixie Profiling + +Pixie is a profiling tool available on IRIX and Tru64 (aka Digital +UNIX aka DEC OSF/1) platforms. Pixie does its profiling using +I. + +You can build a profiled version of perl called F by +invoking the make target "perl.pixie" (what is required is that Perl +must be compiled using the C<-g> flag, you may need to re-Configure). + +In Tru64 a file called F will also be silently created, +this file contains the addresses of the basic blocks. Running the +profiled version of Perl will create a new file called "perl.Counts" +which contains the counts for the basic block for that particular +program execution. + +To display the results you use the F utility. The exact +incantation depends on your operating system, "prof perl.Counts" in +IRIX, and "prof -pixie -all -L. perl" in Tru64. + +In IRIX the following prof options are available: + +=over 4 + +=item -h + +Reports the most heavily used lines in descending order of use. +Useful for finding the hotspot lines. + +=item -l + +Groups lines by procedure, with procedures sorted in descending order of use. +Within a procedure, lines are listed in source order. +Useful for finding the hotspots of procedures. + +=back + +In Tru64 the following options are available: + +=over 4 + +=item -p[rocedures] + +Procedures sorted in descending order by the number of cycles executed +in each procedure. Useful for finding the hotspot procedures. +(This is the default option.) + +=item -h[eavy] + +Lines sorted in descending order by the number of cycles executed in +each line. Useful for finding the hotspot lines. + +=item -i[nvocations] + +The called procedures are sorted in descending order by number of calls +made to the procedures. Useful for finding the most used procedures. + +=item -l[ines] + +Grouped by procedure, sorted by cycles executed per procedure. +Useful for finding the hotspots of procedures. + +=item -testcoverage + +The compiler emitted code for these lines, but the code was unexecuted. + +=item -z[ero] + +Unexecuted procedures. + +=back + +For further information, see your system's manual pages for pixie and prof. + =head2 CONCLUSION We've had a brief look around the Perl source, an overview of the stages