CSC/ECE 517 Fall 2009/wiki1b 11 cc: Difference between revisions
No edit summary |
No edit summary |
||
| Line 1: | Line 1: | ||
== '''Static vs. dynamic o-o languages from the perspective of performance''' == | == '''Static vs. dynamic o-o languages from the perspective of performance''' == | ||
Typing | Typing | ||
---- | ---- | ||
Object-oriented programs can be analized either dynamically, i.e., based on run-time information, or statically, i.e., based on program analysis alone. Two promising optimization techniques for object-oriented languages are type feedback (dynamic) and concrete type inference (static) | Object-oriented programs can be analized either dynamically, i.e., based on run-time information, or statically, i.e., based on program analysis alone. Two promising optimization techniques for object-oriented languages are type feedback (dynamic) and concrete type inference (static) | ||
Static Object-Oriented Language ( type inference ) | Static Object-Oriented Language ( type inference ) | ||
---- | ---- | ||
Statically-typed languages require that all variables are declared with a specific type. The compiler will then ensure that at any given time the variable contains only an object compatible with that type. By enforcing the type constraint on objects contained or referred to by the variable, the compiler can ensure calling method error can never occur at run-time. It enforces safer, more reliable code, and increases efficiency of the resulting product as well. On the other hand, a static type system can hinder evolution of software in some circumstances. Upper classes restrict the inherited ones evolving into various form from its strict type-binding. | Statically-typed languages require that all variables are declared with a specific type. The compiler will then ensure that at any given time the variable contains only an object compatible with that type. By enforcing the type constraint on objects contained or referred to by the variable, the compiler can ensure calling method error can never occur at run-time. It enforces safer, more reliable code, and increases efficiency of the resulting product as well. On the other hand, a static type system can hinder evolution of software in some circumstances. Upper classes restrict the inherited ones evolving into various form from its strict type-binding. | ||
Eiffel , Java , C# , C++ , Visual Basic | Eiffel , Java , C# , C++ , Visual Basic | ||
Dynamic Object-Oriented Language ( type feedback ) | Dynamic Object-Oriented Language ( type feedback ) | ||
---- | ---- | ||
| Line 24: | Line 18: | ||
Performance Comparison | Performance Comparison | ||
---- | ---- | ||
Table. Performance comparison of type inference and type feedback. | Table. Performance comparison of type inference and type feedback. | ||
CounterAct | CounterAct | ||
---- | ---- | ||
Dynamic O-O languages monitors previous executions of the program to determine the set possible receiver classes. In turn , Static O-O languages computes the set of possible receiver classes by analyzing the program’s source code. This characteristics bring consideration opposed to the belief that the static O-O languages are efficient in performance. Compilers cannot predict the typical usage. With this reason, statical way shows more overhead when leading to calling methods called infrequently in case that the methods are small subset of vast method pool. | Dynamic O-O languages monitors previous executions of the program to determine the set possible receiver classes. In turn , Static O-O languages computes the set of possible receiver classes by analyzing the program’s source code. This characteristics bring consideration opposed to the belief that the static O-O languages are efficient in performance. Compilers cannot predict the typical usage. With this reason, statical way shows more overhead when leading to calling methods called infrequently in case that the methods are small subset of vast method pool. | ||
References | References | ||
---- | ---- | ||
External Links | External Links | ||
---- | ---- | ||
Revision as of 12:11, 19 September 2009
Static vs. dynamic o-o languages from the perspective of performance
Typing
Object-oriented programs can be analized either dynamically, i.e., based on run-time information, or statically, i.e., based on program analysis alone. Two promising optimization techniques for object-oriented languages are type feedback (dynamic) and concrete type inference (static)
Static Object-Oriented Language ( type inference )
Statically-typed languages require that all variables are declared with a specific type. The compiler will then ensure that at any given time the variable contains only an object compatible with that type. By enforcing the type constraint on objects contained or referred to by the variable, the compiler can ensure calling method error can never occur at run-time. It enforces safer, more reliable code, and increases efficiency of the resulting product as well. On the other hand, a static type system can hinder evolution of software in some circumstances. Upper classes restrict the inherited ones evolving into various form from its strict type-binding. Eiffel , Java , C# , C++ , Visual Basic
Dynamic Object-Oriented Language ( type feedback )
A dynamic type system doesn't require variables to be declared as a specific type. Any variable can contain any value or object. In many cases this can make the software more flexible and amenable to change. However, care must be taken that variables hold the expected kind of object. Typically, if a variable contains an object of a different type than a user of the object expects, some sort of calling method error is raised at run-time. On the other hand , if the type of the object is not what it was originally expected to be, it may not understand the messages being sent to it. Even worse that it may be interpreted in a wrong way. Smalltalk , Ruby , Python , Perl
Performance Comparison
Table. Performance comparison of type inference and type feedback.
CounterAct
Dynamic O-O languages monitors previous executions of the program to determine the set possible receiver classes. In turn , Static O-O languages computes the set of possible receiver classes by analyzing the program’s source code. This characteristics bring consideration opposed to the belief that the static O-O languages are efficient in performance. Compilers cannot predict the typical usage. With this reason, statical way shows more overhead when leading to calling methods called infrequently in case that the methods are small subset of vast method pool.
References
External Links