KR100649799B1 - Method and apparatus for implementing fast subclass and subtype checks - Google Patents

Abstract

We present a method and an apparatus for performing fast subtype checks during program execution. According to one aspect of the invention, a class associated with an object that is part of an object-based computing system is another type of subtype. The method of determining acknowledgment may include obtaining a candidate type at a dynamic storage location associated with a class associated with the object, and possibly the same as a candidate type. And comparing a candidate type with respect to the first type. Next, a determination is made as to whether the candidate type substantially matches the first type. When determining that the candidate type substantially matches the first type, an indication that the candidate type is a subtype of the first type ( supply indications. In one embodiment, the candidate type obtained at the dynamic storage location is obtained from a cache element in the class associated with the object.

Description

METHOD AND APPARATUS FOR IMPLEMENTING FAST SUBCLASS AND SUBTYPE CHECKS}

The invention is illustrated with reference to the following figures.

1 shows a representative picture of a conventional class hierarchy;

FIG. 2A shows a processing flow diagram illustrating the steps involved in determining whether an object is a subtype of a particular type, in accordance with an embodiment of the present invention; FIG.

FIG. 2B illustrates a process flow diagram illustrating steps involved in comparing a type against a loaded cache, eg, step 208 of FIG. 2A, in accordance with an embodiment of the present invention. Represents;

2C shows a representative picture of a class with cache elements, in accordance with an embodiment of the invention;

3 shows a representative picture of a computer system suitable for implementing the present invention; And

4 shows a representative picture of a virtual machine, in accordance with an embodiment of the invention.

* Reference Number Description

9102 class structure

202: How to determine if an object is a subtype of type "B"

330: computer system

405 compile-time environment

435 run-time environment

440 virtual machine

The present invention generally relates to determining relationships between objects in an object-based system. More particularly, the present invention relates to the efficient execution of subtype checks on objects in an object-based system.

Many computing systems based on objects are built so that objects become part of a particular class and sub-class, etc. These classes and sub-classes class) defines the functions available for an object. During program execution, a virtual machine typically checks the relationships between objects to facilitate the execution of a program. In one example, a virtual machine may check the relationship between sub-classes, subtypes, or objects. For some programming languages, such as the JavaTM programming language developed by Sun Microsystems, Inc. of Palo Alto, California, includes a sub-class check in the programming language. Such sub-class checking generally involves determining whether a particular object has a given type. That is, the class structure associated with a program is examined to determine the type of a particular object.

1 shows a representative picture of a conventional class structure. The class structure 102, for example, the class hierarchy, includes a class 106, a sub-class 110, and the like. In general, class 106 is an abstract class that may include a number of sub-classes 110. As shown in FIG. 1, sub-class “1” 110a, sub-class “2” 110b, sub-class “N” 110c, and the like are “direct” subs of class 106. -Class, and sub-class "A1" 110d is a direct sub-class of sub-class "1" 110a. Since sub-class "A1" 110d is a sub-class of sub-class "1" 110a which becomes a sub-class of class 106, sub-class "A1" 110d is class 106. It can be called an indirect class of.

Class 106 generally includes a variety of different function functions, or methods. Each sub-class 110 includes a different set of functional functions. As an example, sub-class "1" 110a would include functional functionality specific to objects that are part of this class. As long as it is a member of class 106, an object can execute virtually any functional function associated with class 106. In addition, an object that becomes a member of the sub-class 110 becomes a member of the class 106. As such, an object that is a member of any sub-class of the sub-class 110 may execute a function function related to the class 106. However, an object that is a member of a particular sub-class, for example, sub-class "1" 110a, is different from a sub-class, such as sub-class "2" 110b, than this class. Can't perform specific function function. Therefore, the determination of which sub-class 110 an object belongs to determines the functional function that such object can execute.

For the purpose of efficiently representing the object defined by class 106 as an object defined by sub-class "1" 110a, a narrowing cast may be used that is defined at run time. . However, because the object defined by class 106 may be defined by sub-class "2" 110b rather than by sub-class "1" 110a, sub-class "1" 110a. A check is performed to determine if the object associated with) is correct. As is well known to those skilled in the art, a check as to whether an object is related to sub-class "1" 110a is efficient as a check to determine that the object is at least related to sub-class "1" 110a. . In other words, an object associated with sub-class "A1" 110d will generally be determined to also be associated with sub-class "1" 110a.

In the JavaTM environment, a function function is statically encoded as long as it determines the sub-type of the object, for example the subtype of the is_subtype function function. The method used to statically encode the functional function may vary, but one commonly used method involves the use of a two-dimensional bit matrix, where (i, One bit at the position defined by j) encodes the result of is_subtype (ti, tj). Using this matrix, subtype checks effectively include indexing into the matrix to determine the sub-type of the object. However, the size of the matrix is practically important, and sub-type checking is sometimes slowed down due to bit adjustment of the commonly required instructions.

In general, when doing sub-type checking, substantially all sub-types of the type, for example, substantially all of the sub-classes of one class, should be checked to determine the sub-type of a particular object. In some taxonomy class structures, for example, in the class structure 102 in FIG. 1, the number of sub-classes to be examined is relatively large. As an example, a class can have hundreds of related sub-classes. As such, when multiple sub-types are available, as is the case with interfaces defined in the JavaTM programming language, the implementation of sub-type checking is sometimes proved inefficient. That is, when multiple sub-types are available, checking each sub-type as described above generally wastes time. In addition, in systems using multiple inheritance layers, for example in systems defined by the C ++ programming language, it is also sometimes not efficient to implement sub-type checking. For systems with multiple handed down layers, it is practically difficult to perform subtype checks efficiently because each handed down layer must be checked.

The implementation of efficient sub-type checks is important because checks occur frequently. When checks occur frequently during program execution, the overhead associated with checks is relatively large. In some cases, as will be appreciated by those skilled in the art, runtime subtype checking, or testing, requires approximately eight instructions, particularly if the runtime subtype checking occurs repeatedly, which would be severe for the entire program. This can be a problem. Therefore, the frequent sub-type checking slows down the execution of the program.

In general, when checking sub-types during execution of a program, virtually all classes and methods associated with the program are known. The data structure is often organized to list all the classes and methods associated with the program, making the classes and methods easily accessible. In other words, the data structure is relatively large and wastes valuable system resources. In addition, the requirement that all classes and methods associated with a program be known is not compatible with systems that use dynamic linking, or dynamic class loading, in which case the classes and methods that are associated with a program can be efficiently This is because it is converted. As a result, the program's functionality is compromised by the lack of dynamic linking. In an environment using dynamic linking, the data structures are recalculated after all operations involving class loading, which is a waste of time and thus not efficient.

Therefore, what is required is a method and apparatus for improving the efficiency when subtype checks occur. More specifically, what is really needed is a method of efficiently performing subtype checks without having to recalculate the data structure each time a class loading operation occurs. Device and the like.

We present a method and device for performing fast subtype checks during program execution. In accordance with one aspect of the present invention, a method for quickly and efficiently determining the type associated with an object that is part of an object-based computing system includes: Obtaining a candidate type at a dynamic storage location associated with the class associated with the candidate and for a first type that is likely to be the same as the candidate type. Comparing the type (candidate type). Next, a determination is made as to whether the candidate type substantially matches the first type. When determining that the candidate type substantially matches the first type, an indication is provided that the candidate type is primary with the first type.

In accordance with one aspect of the present invention, a computer system is adapted to determine a type associated with a first object present in the computer system. Such computer systems include a processor, memory, and loading mechanisms for loading candidate types into memory. The candidate type is obtained from the class object associated with the first object. The computer system also includes a comparison mechanism for comparing a candidate type against a first type, and a determination mechanism for determining whether the candidate type substantially matches the first type. do. An indicator in the computer system is provided to provide an indication that the candidate type matches the first type when determining that the candidate type substantially matches the first type.

In accordance with another aspect of the invention, a method of performing subtype checks on an object that is a member of a particular class includes a stored element from a location associated with the particular class. Includes; The stored element includes information associated with a first sub-type that may be associated with an object. In addition, the method may further comprise determining that the information contained in the stored element is related to an actual subtype associated with an object, and when the stored element is related to the actual sub-type, Providing an indication that the information contained in the stored element is related to the actual sub-type. In one embodiment, the method further comprises: determining the actual sub-type of the object when the information contained in the stored element is not related to an actual sub-type, and which is associated with a particular class. Storing information relating to the actual sub-type to a location.

Hereinafter, the present invention will be described in detail with reference to the accompanying drawings.

In general, subtype checks performed to determine subtype relationships between objects require a significant amount of computer memory space. This space is a pre-computed data structure that is often used for instructions that involve performing subtype checks, and for storing all types and methods that involve the execution of computer programs. computed data structure). In addition to the overhead required to run recurring sub-type checks, the space required for subtype checks often slows down the execution of the program.

By storing the expected result of the sub-type check, the amount of overhead associated with performing the sub-type check is effectively reduced. In particular, when a program is executed, when a sub-type associated with an object is first checked for a particular type, the actual check can be performed using any method well known to those skilled in the art. Subsequent checks on objects of the same class have the same sub-type results, so storing the result of the actual check, for example by storing the result of the computer calculation of the first check, The overhead associated with running the test can be noticeably reduced. In other words, for the same check, a dynamic subtype check mechanism that uses caching allows previous subtype check results to be cached, so that if the cache value is determined to be the correct value, i. This can be used to speed up the same test when the same test is performed later. In one embodiment, cached data, which is stored data for high-speed processing, may be used and maintained as a type descriptor for the object being inspected.

After the initial check that determines the sub-type of the object "s", which is associated with a class, is performed, the result of the initial check is stored. By storing the result of the initial sub-type check, the next time the check requires a sub-type of the object "s", the stored result causes the same sub-type check to proceed more quickly. . By way of example, when the sub-type of object "s" is checked against type "T", that is, when determining whether object "s" is a particular sub-type "T", There is a relatively fast comparison between the associated stored type descriptor and the sub-type "T". When the type of the object "s" is equal to the sub-type "T", the comparison is determined to be successful and conventional sub-type checking is not necessary. Therefore, the overhead associated with conventional sub-type checking can be avoided. Optionally, when the type of the object "s" does not match the sub-type "T", conventional sub-type checking can be used to determine the type of the object "s". In some cases, this check may include traversing the class classification scheme to find a suitable subtype, and may include raising an exception when a suitable sub-type cannot be found.

In FIG. 2A, the steps involved in determining whether an object is a sub-type or sub-class of a particular type will be described according to an embodiment of the present invention. In particular, the process of determining whether an object is a sub-type of type "B" will be described. The process 202 of determining whether an object is a subtype of type "B" begins at step 204, where the type of the object, e.g., the class of the object, is associated with a computer system. Loaded into a register. As is known to those skilled in the art, the entire class of an object is known, for example an abstract class of objects. Once the class of the object has been loaded into a register, the cache element of the loaded class in step 206 is loaded into the memory of the computer, for example. Cache elements or caches, etc. will be described with respect to FIG. 2C.

After the cache is loaded, type B is compared against the loaded cache at step 208. The steps involved in comparing the type B with the loaded cache will be described below with respect to FIG. 2B. Regarding the result of the type B comparison for the loaded cache, a decision is made at step 210. In the described embodiment, if the result of the comparison of type B with the loaded cache is true, for example, if the determination determines that the type B and the loaded cache match, then the object is type B in step 222. A true value is returned to the function that requested the determination of whether the sub-type of. In other words, if the loaded class and type B are the same class, or if the loaded class is a sub-type of type B, then a true value is returned. Once the true value is returned, we complete the process of determining whether the object is of type B.

Optionally, if it is determined in step 210 that the comparison of type B does not provide true results for the loaded cache, then a subtype relationship between the class of object and type B is completed in step 212. do. That is, when determining that an object's class and type B are not the same, if there is any relationship between the object's class and type B, it performs a computation by a computer that determines the relationship. After the sub-type relationship is completed, processing flow proceeds to step 214, where the calculation for the sub-type produces a true result, i.e., the sub-type relationship between the object's class and type B is valid. With respect to the decision, a decision is made at step 214.

If it is determined at step 214 that there is no sub-type relationship between the class of the object and type B, then at step 220 a false value is returned to the function that required the sub-type checking. Once the false value is returned, the process of determining whether the object is a sub-type of type B is complete. However, if it is determined in step 214 that there is a sub-type between the object's class and type B, the flow of processing proceeds to step 216 where the cache of the class in the object Is "filled" into class B. In other words, a reference to class B, or type B, is stored into the class cache element of the object. Finally, after the object's class cache is filled with type B, a true value is returned to the system at step 218 to indicate that there is a sub-type relationship between the object's class and type B. Then, the process of determining whether the object is a sub-type of type B is completed.

In FIG. 2B, the step of comparing Type B against a loaded cache, eg, a class of a particular object, will be described according to an embodiment of the present invention. That is, one embodiment of step 208 in FIG. 2A will be discussed. The comparison of type B for the loaded cache begins at step 232 where a cache element is loaded into a register. In particular, as will be described below with respect to FIG. 2C, the class cache element of an object is loaded into a register. After loading the cache element into a register, the contents of the register are compared to type B in step 234. As discussed above, a check mechanism that uses caching allows previous subtype check results to be cached, allowing the cached values to be used when the same check is performed later, thereby speeding up the same check. To be able. By allowing cache elements to be used in the inspection, the cache elements can be easily accessed. Suitable methods for comparing the contents of the cache element and the registers can be used, and such methods are generally known by those skilled in the art. Once the contents of the register are compared to type B, the process of comparing type B against the loaded cache is complete.

As discussed above, a class, for example a class object, contains a cache element, which stores the result of a previous sub-type check. 2C shows a representative picture of a class with cache elements in accordance with an embodiment of the invention. Object "S" 252 includes a header 256 and has a class pointer to class 260. Class 260 includes a header 264 and a cache element 268. As described above, the cache element 268 is installed to store the results of the first, sub-type check as previously associated with, for example, the class 260. When initializing class 260, cache element 268 is initialized to some value. As one example, cache element 268 may be initialized to identify class 260. In general, when executing a program, or when performing sub-type checking in more detail, the cache element 268 may be considered as a "dynamic" storage element because the results stored in the cache element 268 may change. Can be. That is, the contents of cache element 268 may be updated.

During sub-type checking that includes object "s" 252, when object "s" 252 is known to be a member of class 260, cache element 268 is accessed to access class 260. Results of the most recent sub-type check, including In general, cache element 268 may be updated to store the most recent sub-type check result that includes class 260. As such, if the result stored in cache element 268 is not a sub-type associated with object "s" 252, then the actual sub-type associated with object "s" 252 once determined is cached. May be stored in element 268. In some embodiments, storing and retrieving information in cache element 268 also includes synchronization to address cache coherency issues that may occur.

3 illustrates a typical general purpose computer system suitable for implementing the present invention. Computer system 330 includes a number of processors 332, which may include a number of processors 332, called central processing units (CPUs), coupled to memory devices. Include. The memory device includes a first storage device 334 such as a RAM and a first storage device 336 such as a ROM.

Computer system 330, or more specifically CPUs 332, may be installed to support a virtual machine. One example of a virtual machine supported in a computer system will be described below with respect to FIG. 4. As is known in the art, the ROM 336 operates to pass data and instructions to CPUs 332 in one direction, and the RAM 334 operates to transfer data and instructions in either direction to or from the CPUs. . The first storage devices 334, 336 both include substantially any suitable computer-readable media. Secondary storage medium 338, which generally becomes a mass memory device, may also be coupled to the CPUs in both directions. Generally, the second storage medium 338 is installed to supply additional data storage capacity and is read by a computer used to store programs, computer program code devices, data, and similar devices, including computer code, and the like. The second storage medium 338 can be a computer-readable medium. In general, the second storage medium 338 is a storage medium such as a hard disk or tape, which may be later than the first storage device 334, 336. The second storage medium 338 can take the form of a known device, including, but not limited to, a magnetic tape reader, a paper tape reader, and the like. . Where appropriate, information remaining within the second storage medium 338 may be incorporated into a standard form as part of a RAM 334, such as virtual memory. A special first storage device 334, such as a CD-ROM, can exchange data with the CPUs 332 in one direction.

Known inputs such as video monitors, trackballs, mice, keyboards, microphones, touch-sensitive displays, transducer card readers, magnetic or paper tape readers, tablets, stylus, voice or hand recorded recognition devices, and other computers CPUs 332 may be coupled to one or more input / output devices 340, including, but not limited to, devices, and the like. Finally, using a network connection as shown at 312, the CPUs 332 may be used in a computer network or telecommunication network such as an internet network or an intranet network. ) May be optionally combined. In the network connection 312, it is contemplated that the CPUs 332 may receive information in a network. In addition, the CPUs 332 may output information to the network in the course of performing the method steps described above. The information represented by a series of instructions executed using the CPUs 332 can be received at the network and output to the network, for example, in the form of a computer data signal embodied as a carrier wave. The devices, techniques, and the like described above are known to those skilled in the art working on computer hardware, computer software, and the like.

As described above, the virtual machine may run on the computer system 330. 4 shows a representative illustration of a virtual machine supported by the computer system 330 in FIG. 3 and suitable for implementing the present invention. When a computer program, for example, a computer program written in the JavaTM programming language, is executed, the source code 410 is compiled into a compiler 420 in a compile-time environment. Is supplied. The compiler 420 converts the source code 410 into the byte code 430. Generally, at the time that source code 410 is produced by a software developer, source code 410 is converted to byte code 430.

In general, byte code 430 may be regenerated, downloaded, or otherwise distributed over a network, for example, network 312 of FIG. 3, or a storage device such as first storage 334 of FIG. 3. Are stored in. In the described embodiment, the byte code 430 is an independent platform. In other words, byte code 430 may be executed by any computer system running with a suitable virtual machine 440.

Byte code 430 is provided to a runtime environment 435 that includes a virtual machine 440. In one embodiment, the virtual machine may be JavaTM. The run-time environment 435 may generally be executed using a processor such as the CPUs 332 of FIG. 3 or some processor. The virtual machine 440 includes a compiler 442, an interpreter 444, and a runtime system 446. Byte code 430 is provided to compiler 442, or interpreter 444.

When byte code 430 is provided to compiler 442, the methods contained in byte code 430 are compiled into machine instructions. In one embodiment, the compiler 442 is a just-in-time compiler that delays the compilation of the method in byte code 430 until the method is just executed. to be. When byte code 430 is provided to interpreter 444, byte code 430 is read into interpreter 444 one byte code at a time. Then, when each byte code is read from the interpreter 444, the interpreter 444 performs the operation defined by each byte code. That is, the interpreter 444 “interpret” the byte code 430. In general, the interpreter 444 processes the byte code 430, and the interpreter 444 continues to perform operations substantially related to the byte code 430.

When one method is called by the other, or when it is called from the run-time environment 435, if the method is interpreted, the run-time system 446 may execute the sequence of byte codes 430. The method can be obtained from a run-time environment in the form of), which can be executed directly by the interpreter 444. On the other hand, if the invoked method is an uncompiled method, the runtime system 446 obtains the method from the runtime environment 435 in the form of a series of bytecodes 430, and then invokes the compiler 442. Proceed to work. The compiler 442 then generates machine instructions in the byte code 430, and the resulting machine instructions can be executed directly by the CPUs 332 of FIG. 3. In general, machine-language instructions are lost when virtual machine 440 exits.

While only a few embodiments have been described with respect to the present invention, it should be understood that the present invention may be practiced in many other forms without departing from the scope or spirit of the invention. For example, in some embodiments, a class object may include one or more cache elements. When a class object contains one or more cache elements, one or more previously result of a subtype check may be stored. That is, by storing one or more possible sub-types for an object, if it is determined that the sub-type stored in one cache element is not a sub-type for the object, the sub-type stored in another cache element is checked. can do. Although the present invention has been described in terms of storing a result that was previously a sub-type check in a cache element of a class, the previous result is not necessarily stored in the cache element. Optionally, the previous results can be stored at substantially any dynamic storage location, where the dynamic storage location is accessible during sub-type checking. By way of example, the results of a previous sub-type check may be stored in a section of computer code that is not directly related to the class. Optionally, the results of previous sub-type checks can be stored in a dynamically, globally accessible table, whenever a sub-type check containing a particular class can be run. The table is accessible. Such a table can be directly related to a particular class.

In one embodiment, instead of implementing a check to determine which sub-type a particular object includes, the check may be implemented to determine that a particular object does not contain any sub-type. In general, in a segment of computer code, or as part of a global table, the results of the check may be stored in a cache element of the class. In other words, the cache element may be installed to accommodate subtype designation that does not match for a particular sub-type check.

In general, instructions or operations using sub-type checking may vary over a wide range, depending on the requirements of the particular system. In the JavaTM environment, for example, the "aastore" command, the "checkcast" command, and the "instanceof" command generally use sub-type checking.

In addition, the steps involved in performing sub-type checking in accordance with the present invention may vary. Without departing from the scope or spirit of the present invention, these steps are altered, reordered, added, and removed. By way of example, determining that a comparison indicates a "true" indication may be substituted for determining that a comparison indicates a "false" indication. Instead, when a class object contains one or more cache elements, the steps involved in performing sub-type checking are to check all cache elements until it finds a subtype match. Until it can efficiently cycle through each cache element. The present embodiment is therefore to be considered in all respects as illustrative and not restrictive, and the invention is not to be limited to the details given herein, but is to be defined by the appended claims and their equivalents.

Claims (23)

A method for determining whether a class associated with an object that is part of an object-oriented computer system is a subtype of another type, Obtaining a candidate type from a dynamic storage location associated with the class associated with the object; Comparing the candidate type with a first type; Determining whether the candidate type corresponds to a first type; And When there is a determination that the candidate type matches the first type, an indication that the candidate type is a subtype of the first type. A computer-implemented method, comprising: providing a fast sub-class test and a sub-type test by a computer. The method of claim 1, wherein a candidate type obtained from a dynamic storage location associated with a class associated with the object is obtained from a cache element in a class associated with the object. Computer-implemented sub-class test and sub-type test The method of claim 2, wherein comparing a candidate type with respect to the first type comprises: Loading a candidate type obtained from the cache element into one register; And And comparing the contents of said cache element with a first type. A computer-implemented fast sub-class check and sub-type check. 4. The method of any one of claims 1 to 3, further comprising calculating a type relationship between the class of the object and the first type when the candidate type does not match the first type. Computer-implemented characterized fast sub-class test and sub-type test 5. The method of claim 4, further comprising determining whether a type relationship exists between the class of the object and the first type, wherein a type relationship exists between the class of the object and the first type. And when it is determined that an indication for the first type is stored in the class cache element of the object, the fast sub-class check and the sub-type check are implemented by the computer. 6. The computer-implemented method of claim 5, further comprising loading the class of the object into a register. A computer system for determining a subtype associated with a first object residing in a computer system, Processor; Loading mechanism for loading a candidate type into memory associated with a computer system, where the candidate type is a storage location associated with a class object associated with the first object Obtained from-; A comparison mechanism for comparing the candidate type with the first type; A determination mechanism for determining whether the candidate type matches the first type; And And upon determining that the candidate type matches the first type, an indicator to provide an indication that the candidate type is a sub-type of the first type. Computer system that implements sub-type checking by computer 8. The computer system of claim 7, wherein the candidate type obtained in the class object is obtained from a cache element in the class object. 9. The method of claim 8, wherein a comparison mechanism for comparing the candidate type with the first type is provided. A loading mechanism for loading a candidate type obtained from the cache element into one register, and A computer system for implementing fast sub-class checking and sub-type checking by a computer comprising a comparison mechanism for comparing the contents of said cache element with a first type. The method of claim 7, wherein And a calculation mechanism for calculating a type relationship between the class of the object and the first type when it is determined that the candidate type does not match the first type. Computer system that implements class checking and sub-type checking by computer 11. The apparatus of claim 10, further comprising: a decision mechanism for determining whether a type relationship exists between a class of the object and a first type; And When there is a determination that a type relationship exists between a class of the object and a first type, A computer system for implementing fast sub-class checking and sub-type checking by a computer, further comprising a storage mechanism for storing a first type of representation into the cache element of the object class. A computer readable medium for causing a computer to determine a subtype associated with a first object that is part of an object oriented computer system, Computer code for obtaining a candidate type from a class object associated with the first object; Computer code for comparing the candidate type with a first type; Computer code for determining if the candidate type matches the first type; And when it is determined that the candidate type matches the first type, computer code that provides an indication that the candidate type is a sub-type of the first type. Computer readable media for computer-implemented sub-type testing delete A computer-implemented method for performing subtype checking on an object that is a particular class member. Obtaining a stored element from a location associated with a particular class, wherein the stored element includes information associated with a first sub-type that is shown to be associated with the object; -; Determining that information contained in the stored element relates to an actual subtype associated with the object; And When it is determined that the information contained in the stored element is related to the actual subtype, an indication is provided that the information contained in the stored element is related to the actual subtype. Computer-implemented fast sub-class inspection and sub-type inspection, comprising providing a The method of claim 14, When it is determined that the information contained in the stored element is not related to an actual subtype, determining an actual sub-type related to the object; And And storing the information related to the actual sub-type at a location associated with the particular class. A computer-implemented method for determining whether a class associated with an object of type 1 that is part of an object-oriented computer system is a subtype of another type, Obtaining a second type that is a candidate type for the object; Comparing the second type with a first type; Determining whether the second type matches the first type; And When there is a determination that the second type matches the first type, storing the information associated with the second type in a dynamic storage location associated with a class associated with the object, wherein the dynamic storage location Storing information in the computer, wherein the information is accessible for subsequent inspections and includes; and, comprising: a computer-implemented fast sub-class inspection and sub-type inspection; 17. The method of claim 16, further comprising providing an indication that the second type is a sub-type of the first type when it is determined that the second type matches the first type. Computer-implemented characterized fast sub-class test and sub-type test 18. The method of claim 17, wherein obtaining the second type comprises obtaining the second type from a data structure comprising a plurality of types. How to implement type checking by computer 19. The computer-implemented method of claim 18, further comprising generating a data structure comprising a plurality of types. The method according to any one of claims 16 to 19, When there is a determination that the second type does not match the first type, obtaining a third type, where the third type is a candidate type for the object and the third type comprises a plurality of types; Obtained from-; Comparing the third type with the first type; Determining whether the third type matches the first type; And And upon determining that the third type matches the first type, storing information related to the third type in a dynamic storage location. How to implement a scan by computer Storing the first candidate type in a dynamic storage location associated with a class associated with the object; Obtaining a first candidate type from the dynamic storage location; Comparing the first candidate type with an object type, wherein the object type is associated with an object; Determining whether the first candidate type and the object type are the same; And When it is determined that the first candidate type and the object type are the same, providing an indication that the first candidate type is a sub-type of the object type, A computer-implemented method for determining whether a class associated with an object that is part of an object-based computing system is a subtype of another type. The method of claim 21, wherein when it is determined that the first candidate type and the object type are not equal, Obtaining a second candidate type, wherein the second candidate type is not obtained at the dynamic storage location; Comparing the second candidate type with the object type; Determining whether the second candidate type and the object type are the same; When it is determined that the second candidate type and the object type are the same, providing an indication that the second candidate type is a sub-type of the object type; And And storing a second candidate type at the dynamic storage location. A computer-implemented method for determining whether a class associated with an object that is part of an object-based computing system is a subtype of another type. A computer system for determining a subtype associated with an object of a first type present in a computer system, Processor; A first mechanism for obtaining a second type that is a candidate type for the object; A comparator for comparing the second type with the first type; A decision mechanism for determining whether the second type matches the first type; And Dynamic storage mechanism for storing information associated with the second type at a dynamic storage location associated with a class associated with the object when it is determined that the second type matches the first type mechanism) wherein said information in said dynamic storage location is accessible for type checking that occurs later.-determining a subtype associated with an object of a first type present in a computer system. Computer systems

Images