Abstract: The present invention relates to polypeptide having alpha-amylase activity. The present invention also relates to polynucleotides encoding the polypeptides; nucleic acid constructs, vectors, and host cells comprising the polynucleotides; and methods of using the polypeptides.

Abstract: A capability for limited customization that utilizes existing virtual dispatch table technology and allows selective customization is provided. Such a capability combines the usage of virtual dispatch tables with both customized and non-customized code to reduce, or even eliminate over-customization. Further, such a capability may employ a runtime system that decides what methods to customize based on several factors including, but not limited to the size of a class hierarchy, the amount of available space for compiled code, and the amount of available time for compilation.

Abstract: One embodiment of the present invention provides a system that supports efficient access to object properties in a dynamic object-oriented programming language. During operation, the system receives a request to access a property for an object associated with a given map object. The system then determines a hash value using the given map object and a signature for the property, and uses the hash value to retrieve a code stub from a cache. Next, the system executes this code stub, which includes instructions that facilitate accessing the property, to access a memory field associated with the property.

Abstract: One embodiment of the present invention provides a system that uses map objects to access object properties for a program written in a dynamic object-oriented programming language, thereby facilitating property access for languages that allow additional properties to be defined for objects at runtime. During operation, the system receives an object of an object type. This object is associated with a memory region and a given map object (from a set of map objects associated with the given object type) that describes how properties of the object are mapped to fields in the memory region. When receiving a request to access a property of the object, the system determines whether the given map object includes a field mapping for the property. If so, the system accesses a field in the memory region associated with the property using the field mapping.

Abstract: One embodiment of the present invention provides a system that reduces memory usage by encoding two values in a single field. During operation, the system receives a string. After determining the length of the string, the system allocates a first set of bits in the single field to store the length of the string, where the size of this first set of bits depends upon the determined length of the string. The system then stores the length of the string in the first set of bits. Subsequently, the system computes a hash code for the string. The system then allocates a second set of bits from the remaining unallocated bits in the single field to store this hash code, and stores the hash code in this second set of bits. Thereafter, the system can access the string length value from the single field and can also use the entire single field as a hash value for the string.

Abstract: One embodiment of the present invention provides a system for type tagging values in a compiled activation frame in a lazy manner to facilitate garbage collection. This system operates in a mixed-mode environment that supports both interpretation of byte codes and execution of compiled native code. Upon receiving an invocation of a method, the system creates an activation frame for the method on the execution stack. If the method is executing in interpreted mode, the interpreter maintains a tag for each value in the activation frame during execution. The tag indicates whether the value is a reference type or a primitive type. However, if the method is executing in compiled mode, the system allocates space for tags for each value in the activation frame, but does not fill in the tags during execution. This allows the tags to be filled in at a future time when needed.

Abstract: A technique for dynamic dispatch involves adapting a method at a dispatch point to reference a state cache. State of the state cache may be associated with an object type and a method signature. When a method is adapted at the dispatch point to reference a state cache, the reference is to a state cache associated with a state that matches the method signature and the object type of the object dispatched upon. The state cache may be shared among multiple methods with similar associated states to reduce memory requirements.

Abstract: Systems and methods for implementing message dispatch for an object-oriented program are provided. Receiver type information is collected at a site of a method that dispatches messages to receiver objects. The receiver type information is saved for subsequent execution of the program. By saving the receiver type information, the program may be more efficient as it is not necessary to collect the receiver type information again. Additionally, inlining information may be saved with the receiver type information.

Abstract: A technique for dynamically relocating an object during garbage collection involves guaranteeing bounds on thread pause times. A process according to the technique may include pausing threads, bounding pause times by scanning only one of a plurality of threads, and resuming the threads. Another process according to the technique may include suspending a plurality of threads, relocating an object to a new memory location, updating references associated with an old memory location for only one of the threads such that the references are associated with the new memory location, and resuming the threads. In an embodiment, the process may include initially marking each of the threads “unscanned.” In another embodiment, the process may include reading the object from the first memory location and writing the object to the second memory location. An example system according to the technique may include a scheduler and a relocation engine.

Abstract: A technique for sharing code fragments involves detecting identical code fragments, then replacing code fragments with references to an identical code fragment. A process according to the technique may include detecting identical code fragments in one or more modules, presenting at runtime a single code fragment that is identical to the identical code fragments, and automatically sharing the single code fragment among the one or more modules. A system according to the technique may include a code fragments database that may includes code fragments and a code server configured to receive requests for a program and provide references to one or more of the code fragments in the code fragments database. Another system according to the technique may include a first object, a second object, and a method object, wherein a reference associated with a first method of the first object and the reference associated with a second method of the second object are pointers to the method object.

Abstract: A technique for dynamic dispatch involves adapting a method at a dispatch point to reference a state cache. State of the state cache may be associated with an object type and a method signature. When a method is adapted at the dispatch point to reference a state cache, the reference is to a state cache associated with a state that matches the method signature and the object type of the object dispatched upon. The state cache may be shared among multiple methods with similar associated states to reduce memory requirements.

Abstract: A system that associates an identifier with an instance defined within an object-oriented programming system. The system generates an identifier for the instance and associates a new near object with the instance, wherein the new near object points to a class specifying behavior for the object. The system stores the identifier in the new near object, and sets a class pointer located within a header of the instance to point to the new near object. In this way, the class pointer indirectly points to the class for the object through the new near object. The system can lock the instance to facilitate exclusive access to the instance by copying a near object associated with the instance to a method activation on the execution stack, and setting the class pointer of the instance to point to the copy of the near object on the execution stack.

Abstract: One embodiment of the present invention provides a system that dynamically compiles byte codes into native code to facilitate faster execution. This method operates in a mixed-mode system that supports execution of both compiled code and interpreter code. During operation, the system periodically determines if a currently executing thread is executing through the interpreter. If so, the system locates the method being executed by the thread and compiles the byte codes of the method into native code. Subsequent executions of the method utilize the faster-executing native code.

Abstract: Systems and methods for increasing the execution speed of virtual machine instructions for a function are provided. A portion of the virtual machine instructions of the function are compiled into native machine instructions so that the function includes both virtual and native machine instructions. Execution of the native machine instructions may be accomplished by overwriting a virtual machine instruction of the function with a virtual machine instruction that specifies execution of the native machine instructions. Additionally, the original virtual machine instruction may be stored so that the original virtual machine instructions can be regenerated.

Abstract: Methods and apparatus for dynamically compiling byte codes associated with methods during idle periods in the execution of a computer program are disclosed. The described methods are particularly suitable for use in computer systems that are arranged to execute both interpreted and compiled byte codes. In some embodiments, methods to be dynamically compiled are referenced in one or more lists. The lists may be prioritized to facilitate the compilation of the highest priority methods first. In one embodiment, a pair of compilation lists are provided with a first one of the compilation lists being created prior to processing the computer program while the other is created during the processing of the computer program.

Abstract: Systems and methods for implementing message dispatch for an object-oriented program are provided. Receiver type information is collected at a site of a method that dispatches messages to receiver objects. The receiver type information is saved for subsequent execution of the program. By saving the receiver type information, the program may be more efficient as it is not necessary to collect the receiver type information again. Additionally, inlining information may be saved with the receiver type information.

Abstract: Techniques for performing static binding of dispatched-calls in the presence of dynamic linking and loading are provided. A method for increasing the execution performance of a function at run-time includes compiling the function, which may either be interpreted or previously compiled, and identifying a call within the function to a process. The method also includes adding dependency information to the function. The dependency information is arranged to indicate a status of the function, and contains information pertaining to the class, the name, and the signature associated with the process. In one embodiment, the process is a virtual process, and the method includes analyzing a class structure associated with the function in order to determine when the virtual process is a substantially unique target of the call. In such an embodiment, the virtual process may be inlined into the function when it is determined that the virtual process is the substantially unique target of the call.

Abstract: One embodiment of the present invention provides a system that gathers code usage information to facilitate removing compiled code that has not been recently used. This method operates in a mixed-mode system that supports execution of both compiled code and interpreter code. During operation, the system gathers usage information for compiled methods within an application while the application is executing. Next, the system identifies compiled methods to be removed based on this usage information, and removes identified compiled methods so that interpreter code is executed for the compiled methods instead of compiled code. In this way, the system frees up the memory space used to store the compiled methods.

Abstract: Methods and apparatus for performing fast subtype checks during program execution are disclosed. According to one aspect of the present invention, a method for determining whether a class associated with an object that is a part of an object-based computing system is a subtype of another type includes obtaining a candidate type from a dynamic storage location that is associated with a class which is associated with the object, and comparing the candidate type against a first type that is potentially the same as the candidate type. A determination is then made as to whether the candidate type is substantially equal to the first type. When the determination is that the candidate type is substantially equal to the first type, an indication that the candidate type is a subtype of the first type is provided. In one embodiment, the candidate type obtained from the dynamic storage location is obtained from a cache element in the class associated with the object.

Abstract: Systems and methods for implementing an execution stack which stores frames for functions written in multiple programming languages are provided. The frames for functions written in different programming languages may be interleaved on the same execution stack. A data block on the execution stack may be utilized to traverse the execution stack around a frame by storing a stack pointer and frame pointer to a previous frame. Additionally, exceptions may be propagated, with conversion if necessary, through frames on the execution stack that are written in different programming languages.