Attachment 236091 Details for Bug 196757 – minimal testcase

minimal testcase

p3.html (text/plain), 16.23 KB, created by Martin Stransky on 2007-10-24 11:37:44 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Martin Stransky

Created: 2007-10-24 11:37:44 UTC

Size: 16.23 KB

patch

obsolete

><head>
></head>
>
><body>
>  <div style="position: absolute;">
>   These optimizations are probably the easiest that one can perform. The approach
>   is to compile the code without any optimizations flagged at all and then run the
>   binary on a problem that is similar to the work you will be doing. This will
>   establish a baseline time. After reading the man page, manual, or other
>   documentation that explains the flags available for that compiler, recompile the
>   code with those options, and rerun the code on the same data set. Be careful to
>   check that the results are identical or close to the baseline run results, for some
>   compilers are known to rearrange the program's instructions for more efficient
>   These optimizations are probably the easiest that one can perform. The approach
>   is to compile the code without any optimizations flagged at all and then run the
>   binary on a problem that is similar to the work you will be doing. This will
>   establish a baseline time. After reading the man page, manual, or other
>   documentation that explains the flags available for that compiler, recompile the
>   code with those options, and rerun the code on the same data set. Be careful to
>   check that the results are identical or close to the baseline run results, for some
>   compilers are known to rearrange the program's instructions for more efficient
>   execution, which may have the side effect of producing incorrect results. There may
>   be compiler flags to force strict ordering of the instructions, or you can select a
>   lower level of optimization. Things to try include default optimization, frequently
>   These optimizations are probably the easiest that one can perform. The approach
>   is to compile the code without any optimizations flagged at all and then run the
>   binary on a problem that is similar to the work you will be doing. This will
>   establish a baseline time. After reading the man page, manual, or other
>   documentation that explains the flags available for that compiler, recompile the
>   code with those options, and rerun the code on the same data set. Be careful to
>   check that the results are identical or close to the baseline run results, for some
>   compilers are known to rearrange the program's instructions for more efficient
>   execution, which may have the side effect of producing incorrect results. There may
>   be compiler flags to force strict ordering of the instructions, or you can select a
>   lower level of optimization. Things to try include default optimization, frequently
>   These optimizations are probably the easiest that one can perform. The approach
>   is to compile the code without any optimizations flagged at all and then run the
>   binary on a problem that is similar to the work you will be doing. This will
>   establish a baseline time. After reading the man page, manual, or other
>   documentation that explains the flags available for that compiler, recompile the
>   code with those options, and rerun the code on the same data set. Be careful to
>   check that the results are identical or close to the baseline run results, for some
>   compilers are known to rearrange the program's instructions for more efficient
>   execution, which may have the side effect of producing incorrect results. There may
>   be compiler flags to force strict ordering of the instructions, or you can select a
>   lower level of optimization. Things to try include default optimization, frequently
>   These optimizations are probably the easiest that one can perform. The approach
>   is to compile the code without any optimizations flagged at all and then run the
>   binary on a problem that is similar to the work you will be doing. This will
>   establish a baseline time. After reading the man page, manual, or other
>   documentation that explains the flags available for that compiler, recompile the
>   code with those options, and rerun the code on the same data set. Be careful to
>   check that the results are identical or close to the baseline run results, for some
>   compilers are known to rearrange the program's instructions for more efficient
>   execution, which may have the side effect of producing incorrect results. There may
>   be compiler flags to force strict ordering of the instructions, or you can select a
>   lower level of optimization. Things to try include default optimization, frequently
>   execution, which may have the side effect of producing incorrect results. There may
>   be compiler flags to force strict ordering of the instructions, or you can select a
>   lower level of optimization. Things to try include default optimization, frequently
>   These optimizations are probably the easiest that one can perform. The approach
>   is to compile the code without any optimizations flagged at all and then run the
>   binary on a problem that is similar to the work you will be doing. This will
>   establish a baseline time. After reading the man page, manual, or other
>   documentation that explains the flags available for that compiler, recompile the
>   code with those options, and rerun the code on the same data set. Be careful to
>   check that the results are identical or close to the baseline run results, for some
>   compilers are known to rearrange the program's instructions for more efficient
>   execution, which may have the side effect of producing incorrect results. There may
>   be compiler flags to force strict ordering of the instructions, or you can select a
>   lower level of optimization. Things to try include default optimization, frequently
>   These optimizations are probably the easiest that one can perform. The approach
>   is to compile the code without any optimizations flagged at all and then run the
>   binary on a problem that is similar to the work you will be doing. This will
>   establish a baseline time. After reading the man page, manual, or other
>   documentation that explains the flags available for that compiler, recompile the
>   code with those options, and rerun the code on the same data set. Be careful to
>   check that the results are identical or close to the baseline run results, for some
>   compilers are known to rearrange the program's instructions for more efficient
>   execution, which may have the side effect of producing incorrect results. There may
>   be compiler flags to force strict ordering of the instructions, or you can select a
>   lower level of optimization. Things to try include default optimization, frequently
>   These optimizations are probably the easiest that one can perform. The approach
>   is to compile the code without any optimizations flagged at all and then run the
>   binary on a problem that is similar to the work you will be doing. This will
>   establish a baseline time. After reading the man page, manual, or other
>   documentation that explains the flags available for that compiler, recompile the
>   code with those options, and rerun the code on the same data set. Be careful to
>   check that the results are identical or close to the baseline run results, for some
>   compilers are known to rearrange the program's instructions for more efficient
>   execution, which may have the side effect of producing incorrect results. There may
>   be compiler flags to force strict ordering of the instructions, or you can select a
>   lower level of optimization. Things to try include default optimization, frequently
>   These optimizations are probably the easiest that one can perform. The approach
>   is to compile the code without any optimizations flagged at all and then run the
>   binary on a problem that is similar to the work you will be doing. This will
>   establish a baseline time. After reading the man page, manual, or other
>   documentation that explains the flags available for that compiler, recompile the
>   code with those options, and rerun the code on the same data set. Be careful to
>   check that the results are identical or close to the baseline run results, for some
>   compilers are known to rearrange the program's instructions for more efficient
>   execution, which may have the side effect of producing incorrect results. There may
>   be compiler flags to force strict ordering of the instructions, or you can select a
>   lower level of optimization. Things to try include default optimization, frequently
>   These optimizations are probably the easiest that one can perform. The approach
>   is to compile the code without any optimizations flagged at all and then run the
>   binary on a problem that is similar to the work you will be doing. This will
>   establish a baseline time. After reading the man page, manual, or other
>   documentation that explains the flags available for that compiler, recompile the
>   code with those options, and rerun the code on the same data set. Be careful to
>   check that the results are identical or close to the baseline run results, for some
>   compilers are known to rearrange the program's instructions for more efficient
>   execution, which may have the side effect of producing incorrect results. There may
>   be compiler flags to force strict ordering of the instructions, or you can select a
>   lower level of optimization. Things to try include default optimization, frequently
>   These optimizations are probably the easiest that one can perform. The approach
>   is to compile the code without any optimizations flagged at all and then run the
>   binary on a problem that is similar to the work you will be doing. This will
>   establish a baseline time. After reading the man page, manual, or other
>   documentation that explains the flags available for that compiler, recompile the
>   code with those options, and rerun the code on the same data set. Be careful to
>   check that the results are identical or close to the baseline run results, for some
>   compilers are known to rearrange the program's instructions for more efficient
>   execution, which may have the side effect of producing incorrect results. There may
>   be compiler flags to force strict ordering of the instructions, or you can select a
>   lower level of optimization. Things to try include default optimization, frequently
>   These optimizations are probably the easiest that one can perform. The approach
>   is to compile the code without any optimizations flagged at all and then run the
>   binary on a problem that is similar to the work you will be doing. This will
>   establish a baseline time. After reading the man page, manual, or other
>   documentation that explains the flags available for that compiler, recompile the
>   code with those options, and rerun the code on the same data set. Be careful to
>   check that the results are identical or close to the baseline run results, for some
>   compilers are known to rearrange the program's instructions for more efficient
>   execution, which may have the side effect of producing incorrect results. There may
>   be compiler flags to force strict ordering of the instructions, or you can select a
>   lower level of optimization. Things to try include default optimization, frequently
>   These optimizations are probably the easiest that one can perform. The approach
>   is to compile the code without any optimizations flagged at all and then run the
>   binary on a problem that is similar to the work you will be doing. This will
>   establish a baseline time. After reading the man page, manual, or other
>   documentation that explains the flags available for that compiler, recompile the
>   code with those options, and rerun the code on the same data set. Be careful to
>   check that the results are identical or close to the baseline run results, for some
>   compilers are known to rearrange the program's instructions for more efficient
>   execution, which may have the side effect of producing incorrect results. There may
>   be compiler flags to force strict ordering of the instructions, or you can select a
>   lower level of optimization. Things to try include default optimization, frequently
>   These optimizations are probably the easiest that one can perform. The approach
>   is to compile the code without any optimizations flagged at all and then run the
>   binary on a problem that is similar to the work you will be doing. This will
>   establish a baseline time. After reading the man page, manual, or other
>   documentation that explains the flags available for that compiler, recompile the
>   code with those options, and rerun the code on the same data set. Be careful to
>   check that the results are identical or close to the baseline run results, for some
>   compilers are known to rearrange the program's instructions for more efficient
>   execution, which may have the side effect of producing incorrect results. There may
>   be compiler flags to force strict ordering of the instructions, or you can select a
>   lower level of optimization. Things to try include default optimization, frequently
>   These optimizations are probably the easiest that one can perform. The approach
>   is to compile the code without any optimizations flagged at all and then run the
>   binary on a problem that is similar to the work you will be doing. This will
>   establish a baseline time. After reading the man page, manual, or other
>   documentation that explains the flags available for that compiler, recompile the
>   code with those options, and rerun the code on the same data set. Be careful to
>   check that the results are identical or close to the baseline run results, for some
>   compilers are known to rearrange the program's instructions for more efficient
>   execution, which may have the side effect of producing incorrect results. There may
>   be compiler flags to force strict ordering of the instructions, or you can select a
>   lower level of optimization. Things to try include default optimization, frequently
>   These optimizations are probably the easiest that one can perform. The approach
>   is to compile the code without any optimizations flagged at all and then run the
>   binary on a problem that is similar to the work you will be doing. This will
>   establish a baseline time. After reading the man page, manual, or other
>   documentation that explains the flags available for that compiler, recompile the
>   code with those options, and rerun the code on the same data set. Be careful to
>   check that the results are identical or close to the baseline run results, for some
>   compilers are known to rearrange the program's instructions for more efficient
>   execution, which may have the side effect of producing incorrect results. There may
>   be compiler flags to force strict ordering of the instructions, or you can select a
>   lower level of optimization. Things to try include default optimization, frequently
>   These optimizations are probably the easiest that one can perform. The approach
>   is to compile the code without any optimizations flagged at all and then run the
>   binary on a problem that is similar to the work you will be doing. This will
>   establish a baseline time. After reading the man page, manual, or other
>   documentation that explains the flags available for that compiler, recompile the
>   code with those options, and rerun the code on the same data set. Be careful to
>   check that the results are identical or close to the baseline run results, for some
>   compilers are known to rearrange the program's instructions for more efficient
>   execution, which may have the side effect of producing incorrect results. There may
>   be compiler flags to force strict ordering of the instructions, or you can select a
>   lower level of optimization. Things to try include default optimization, frequently
>   These optimizations are probably the easiest that one can perform. The approach
>   is to compile the code without any optimizations flagged at all and then run the
>   binary on a problem that is similar to the work you will be doing. This will
>   establish a baseline time. After reading the man page, manual, or other
>   documentation that explains the flags available for that compiler, recompile the
>   code with those options, and rerun the code on the same data set. Be careful to
>   check that the results are identical or close to the baseline run results, for some
>   compilers are known to rearrange the program's instructions for more efficient
>   execution, which may have the side effect of producing incorrect results. There may
>   be compiler flags to force strict ordering of the instructions, or you can select a
>   lower level of optimization. Things to try include default optimization, frequently
>
></body>
></html>

Actions: View

Attachments on bug 196757: 236091