Loading ...
a bug ... an incorrect castwas causingcrash in compiler code optimization
a static contextcausescompilers to generate bad optimization code
exit(1 ) functioncausescompiler error with optimization
exit(1 ) functioncausescompiler error with optimization
different compilation flagsinfluencingthe optimization level used by the compiler
functioncausescompiler error with optimization
functioncausescompiler error with optimization
the sensemay causethe compiler to mis - optimize things
generally(passive) are causedagain a compiler optimization issue
This Intel Labs teamhas contributeda series of compiler optimization
Reliance on undefined behaviorwas leadingto compiler optimization issues
The -O optioncausesthe compiler to optimize the compiled code
likelyto causethe compiler to optimize the code out
the early reasonsresultingfrom poor compiler optimization
Developers trying to write performance - tuned programs ... waysleadto optimization opportunities for the compiler
Profs(passive) led bycompiler construction and optimization
30 years agoresultedin a compiler optimization of some sort
Immedateswill resultin compiler un - optimizing
by Intel itself(passive) designed byproprietary optimizing compiler
Intel itself(passive) designed bya proprietary optimizing compiler
by Intel itself(passive) designed bya proprietary optimizing compiler
available(passive) is designedPrecedence Optimization
This talk ... to automatically learnhow to designcompiler optimisation heuristics
to improve code(passive) are designedCompiler optimizations
Developersmay setcompiler optimization
to high(passive) was setThe compiler optimization
to high(passive) is setCompiler optimization
the rearrangement and substitution of both program elements and machine instructionsresultingfrom compiler optimization
not the inline keywordcausesa compiler optimization
mainly(passive) is ... designedCompiler optimization
by this setting(passive) are ... influenced bysome compiler optimizations
to use this informationto designcompiler optimizations
specially(passive) is ... designed An optimizing compiler
enormeous complexitiesto designthis optimizing compiler
by SET - OPTIMIZER(passive) set byCOMPILE , optimization
Backwhen ... were inventedoptimizing compilers
mode off , the collector > still looks for interior pointers from the stack and > registersresultfrom compiler > optimizations
Even with all_interior_pointers mode off , the collector still looks for interior pointers from the stack and registersresultfrom compiler optimizations
> Even with all_interior_pointers mode off , the collector still looks for interior pointers from the stack and registersresultfrom compiler optimizations
A $ inellipse ( ) bug(passive) caused byA $ inellipse ( ) bug
An $ inellipse ( ) bug(passive) caused byAn $ inellipse ( ) bug
Fixed bug in(passive) caused byFixed bug in
in run timescould resultin run times
than the Debug build configurationsettingthan the Debug build configuration
a failure of our sequential executioncan causea failure of our sequential execution
to -O0 , thenis setto -O0 , then
in strange behaviourmay resultin strange behaviour
in improvements to code size and/or performancemay resultin improvements to code size and/or performance
This problem(passive) is caused byThis problem
the problem(passive) is causedthe problem
in more efficient codecan resultin more efficient code
problemsare ... causingproblems
problemscauseproblems
in the order of execution of the operations to be different than what the programmer intendedcould resultin the order of execution of the operations to be different than what the programmer intended
multiple threads to see a different valuecausemultiple threads to see a different value
differences in the generated programcausingdifferences in the generated program
to some crashesleadingto some crashes
The bug(passive) is caused byThe bug
in very different bytecoderesultingin very different bytecode
surprising behaviorcan causesurprising behavior
write +wo ... causewrite +
bit - for - bit differences between the codes and among architecturescausebit - for - bit differences between the codes and among architectures
a convergence bug(passive) caused bya convergence bug
oftencauseoften
which objects can be stack allocateddiscoverwhich objects can be stack allocated
write + reorderingwo ... causewrite + reordering
in codecan resultin code
the game to run WAY too fastcausesthe game to run WAY too fast
the compiler crash's causingthe compiler crash
possible problems(passive) caused bypossible problems
many harmless cases where uninitialized data is loaded and manipulated by the program(passive) often caused bymany harmless cases where uninitialized data is loaded and manipulated by the program
problemCan causeproblem
the problemis causingthe problem
this problem(passive) is caused bythis problem
possible issues(passive) caused bypossible issues
errors(passive) caused byerrors
program to run slowercausingprogram to run slower
to run slower Running a java program at the command linecausingto run slower Running a java program at the command line
the issuemay be causingthe issue