Kobayashi does not explicitly disclose obtaining the first data size from recording information of a writing process executed by an application; however, regarding this limitation, Blagodurov discloses in Paragraph [0038] “Although developers may manually annotate objects as described, annotating objects manually may be impractical for programs with larger numbers of objects. Thus, as described above, to reduce the overhead associated with annotating large numbers of objects, in some embodiments, a compiler (and/or another hardware or software entity) automatically annotates at least some of the objects. In some of these embodiments, one or more rules (or guidelines, conditions, etc.) are used by the compiler when determining objects to be annotated and/or how to annotate objects. The rules include thresholds and/or other criteria that are used to determine how objects are to be annotated.
Kobayashi does not clearly state that the first data size is derived from recording information of a writing process carried out by an application. However, Blagodurov addresses this limitation in Paragraph [0038], explaining that while developers can manually annotate objects, this approach becomes impractical for programs with a large number of objects. To mitigate the overhead of annotating numerous objects, a compiler or another hardware or software entity may automatically annotate some objects. In certain cases, the compiler uses specific rules, guidelines, or conditions to decide which objects to annotate and how to annotate them. These rules include thresholds or other criteria that guide the annotation process.
Kobayashi does not clearly state the method for determining the initial data size based on information recorded from a writing process conducted by an application. However, Blagodurov addresses this issue in Paragraph [0038], noting that while developers may manually annotate objects, this can be impractical for programs with a large number of objects. To alleviate the burden of annotating many objects, some embodiments propose that a compiler or another software or hardware tool automatically performs some annotations. In these cases, specific rules or guidelines are employed by the compiler to decide which objects should be annotated and how. These rules may include thresholds and other criteria for determining the annotation process.
Kobayashi does not explicitly describe how the initial data size is calculated from data stored in a writing operation performed by an application. But Blagodurov discusses this in Paragraph [0038], where he says that developers can annotate objects manually, but this is not practical for programs with many objects. In order to reduce the burden of annotating a large number of objects, some embodiments suggest that some annotations are automatically done by a compiler or other software or hardware tool. In such instances, certain rules or guidelines are used by the compiler to determine which objects are to be annotated and in what manner. These rules can contain thresholds and other criteria for deciding the annotation process.
Kobayashi does not explicitly specify how to calculate the initial data size from information obtained from a writing process performed by an application. But Blagodurov solves this problem in Paragraph [0038], where he points out that although developers can annotate objects by hand, this is not feasible for programs with many objects. In some embodiments, to reduce the workload of annotating many objects, a compiler or other software or hardware tool is provided to automatically perform some annotations. In these situations, certain rules or conventions are used by the compiler to determine which objects are annotated and how. These rules may contain thresholds and other criteria for annotation.