Prosecution Insights
Last updated: November 04, 2026
Application No. 18/791,669

PARALLEL CODE FRAGMENTS WITH FOREIGN CODE

Final Rejection §103§112
Filed
Aug 01, 2024
Examiner
RIVERA, ANIBAL
Art Unit
2192
Tech Center
2100 — Computer Architecture & Software
Assignee
Unisys Corporation
OA Round
2 (Final)
91%
Grant Probability
Favorable
3-4
OA Rounds
0m
Est. Remaining
99%
With Interview

Examiner Intelligence

Grants 91% — above average
91%
Career Allowance Rate
695 granted / 765 resolved
+35.8% vs TC avg
Moderate +12% lift
Without
With
+12.1%
Interview Lift
resolved cases with interview
Typical timeline
2y 3m
Avg Prosecution
41 currently pending
Career history
819
Total Applications
across all art units

Statute-Specific Performance

§101
14.9%
-25.1% vs TC avg
§103
44.0%
+4.0% vs TC avg
§102
25.5%
-14.5% vs TC avg
§112
8.3%
-31.7% vs TC avg
Black line = Tech Center average estimate • Based on career data from 765 resolved cases

Office Action

§103 §112
DETAILED ACTION This action is responsive to the application filed on September 28, 2026, in reply to the Non-Final Office Action mailed July 7, 2026. Claims 1-2, 4-6, 8-10 and 13-16 have been amended. Claims 1-20 are pending and presented for examination. The present application, filed on or after March 16, 2013, is being examined under the first inventor to file provisions of the AIA . Examiner Notes Examiner cites particular columns, paragraphs, figures and line numbers in the references as applied to the claims below for the convenience of the applicant. Although the specified citations are representative of the teachings in the art and are applied to the specific limitations within the individual claim, other passages and figures may apply as well. It is respectfully requested that, in preparing responses, the applicant fully consider the references in their entirety as potentially teaching all or part of the claimed invention, as well as the context of the passage as taught by the prior art or disclosed by the examiner. Response to Amendment The amendment filed September 28, 2026 has been entered. Support for the amendments is found in the specification as originally filed, for example at paragraphs [0034], [0036], [0042]-[0044], [0064], [0069]-[0071] and FIG. 8. No new matter has been added. The rejection of claims 4-5 and 8-15 under 35 U.S.C. 112(b) is withdrawn. Claims 4 and 9 now recite “the foreign code segment”; claim 8 now recites “the foreign code segment” in the translating step and “the machine-readable code in the second instruction architecture” in the causing step; claim 10 now recites “the computing environment is a hosted computing environment,” which takes antecedent basis from “a computing environment executing the application” in claim 8 and provides antecedent basis for “the hosted computing environment” in claims 11 and 12; and claim 13 now recites “the executable object.” The rejection of claims 1-20 on the ground of nonstatutory double patenting over claims of U.S. Patent No. 11,442,714 in view of Marathe and Jiang is withdrawn in view of the amendments to independent claims 1, 8 and 16. Applicant’s amendment necessitated the new grounds of rejection set forth below, including the rejection of claim 15 under 35 U.S.C. 112(b), which arises from the amendment of claim 15. Response to Arguments Applicant’s arguments filed September 28, 2026 have been fully considered. (a) With respect to the nonstatutory double patenting rejection, the rejection is withdrawn as set forth above, and Applicant’s arguments are moot. The Examiner notes, however, that Applicant’s position at page 4 of the Remarks that a secondary reference relied upon in a nonstatutory double patenting rejection must be commonly owned with the examined application is not correct. Common ownership determines whether a terminal disclaimer may be used to overcome the rejection (37 CFR 1.321); it does not limit the prior art that may be relied upon to show that an examined claim is an obvious variant of a reference claim. See In re Longi, 759 F.2d 887, 225 USPQ 645 (Fed. Cir. 1985); MPEP 804, subsection II.B. (b) With respect to the rejections under 35 U.S.C. 103, Applicant’s arguments that Miller, Marathe and Jiang do not teach selection-mask metadata indicating the second instruction architecture, a determination based on that metadata that the computing environment includes (claims 1 and 8) or has available (claim 16) a processor capable of executing the foreign code, a code length value (claim 6), or asynchronous continued execution (claim 18) are moot because the new grounds of rejection do not rely on Marathe or Jiang for any teaching or matter specifically challenged in the argument. Those features are taught by Tamir, Aguilar, Munshi and Tevanian, as set forth in the rejections below. (c) Applicant argues at pages 9-10 of the Remarks that Miller’s metadata identifies only a code level and that Miller never determines whether a second processor is present. These arguments are moot. Miller is not relied upon for metadata indicating the second instruction architecture or for the determining step; Tamir teaches both. Tamir’s ELF sections each carry a name “identifying the ISA corresponding to the binary representation 114 in that section,” and “the ISA of the processing core 102 on which the program 115 is to be run may be identified” so that the matching section is loaded (Tamir ¶[0034]; see also ¶[0057]). (d) Applicant argues at page 10 that no reference provides a fragment, untranslated into the first processor’s code, to a different processor while the executable object is translated for the first processor. This argument is not persuasive in view of the new grounds. Aguilar teaches a “combined executable program that contains both 32 bit (or 64bit) PU code and SPU code” in which the loader identifies the embedded SPU code from the file’s header information “and sends SPU file 4340 to memory 4370 using DMA 4430” (Aguilar ¶¶[0152]-[0153]), so that the SPU executes the embedded code “while PU 4300 executes PU program 4512” (¶[0154]). Miller supplies the translation of the executable object for the first processor (Miller ¶[0063]). (e) Applicant argues at pages 10-11 that the reasons to combine restate Applicant’s own disclosure and reflect hindsight. This argument is moot in view of the new grounds. Each rationale set forth below relies on a reason stated in the applied reference itself: Aguilar ¶¶[0008]-[0009], Tamir ¶[0034], Munshi ¶[0005] and ¶[0028], and Tevanian (4). Miller itself contemplates code levels that “add extended operators such as parallel floating point operations that may be used in graphics subsystems” (Miller ¶[0075]). (f) Applicant argues at pages 11-12 that routing a fragment to a different processor would change Miller’s principle of operation and render Miller unsatisfactory for its intended purpose. This argument is not persuasive. Miller’s principle of operation is to distribute a single executable containing parallel code fragments and to select, at translation time, which fragment is used, so that “execution features may be varied between the various endpoint computing systems without requiring distribution of different code sets to those endpoints” (Miller ¶[0039]). Miller expressly states that, although discussed in the context of hosted software, “it is recognized that the methods and systems described herein are not so limited” (¶[0039]). The combination keeps that principle intact: the selection mask still determines which fragment is enabled, the executable object is still translated for the first processor, and unselected fragments are still excluded. Only the selected foreign code segment is routed, as Aguilar teaches, to the processor whose instruction set it is written in. Miller is not rendered unsatisfactory for distributing a single executable whose features vary by platform; it is extended to platforms that include a second processor. See MPEP 2143.01(V)-(VI). (g) Applicant argues at page 13 that no reference translates the fragment into the second instruction architecture in response to detecting the selection mask during execution (claim 8). This argument is moot. Munshi teaches activating “a compute compiler 107 to online compile a loaded source program into an executable optimized for a target processor” (Munshi ¶[0032]; see also ¶[0053]), and Miller teaches that feature-bit changes are assessed “during execution of the code” (Miller ¶[0081]) and that the executable code “may be retranslated ‘on the fly’” (¶[0154]). (h) Applicant’s arguments regarding claims 2, 3, 5, 6, 9, 11 and 18 at pages 15-16 are moot in view of the new grounds, which rely on Tamir (claim 2), Munshi (claims 3, 9 and 18), Aguilar (claim 5) and Tevanian (claim 6) for the features argued. With respect to claim 11, the claim as written recites a handshake “to determine the parallel code fragment is executable by the hosted computing environment,” which Miller teaches (Miller ¶¶[0079], [0091], [0147]); the argument relies on the target processor of claim 10 rather than on any language of claim 11. Drawings The drawings are objected to as failing to comply with 37 CFR 1.84(p)(5) because they include the following reference characters not mentioned in the description. FIGS. 5 and 6 are objected to for the reasons set forth below. (a) FIG. 5 includes reference character 504 (“Code Fragment 1”) and reference character 528 (“Reset Feature Bit(s) / Enable Execution of Foreign Code”). Neither reference character is mentioned in the description of FIG. 5 at paragraphs [0056]-[0060]. (b) FIG. 6 includes reference character 606 (“Cause Process to Enable Parallel Code Fragments Associated with Selection Mask”). Reference character 606 is not mentioned in the description of FIG. 6, which describes blocks 602, 604 and 608 at paragraphs [0062]-[0064]. Corrected drawing sheets in compliance with 37 CFR 1.121(d) are required in reply to the Office action to avoid abandonment of the application. Any amended replacement drawing sheet should include all of the figures appearing on the immediate prior version of the sheet, even if only one figure is being amended. The figure or figure number of an amended drawing should not be labeled as “amended.” If a drawing figure is to be canceled, the appropriate figure must be removed from the replacement sheet, and where necessary, the remaining figures must be renumbered and appropriate changes made to the brief description of the several views of the drawings for consistency. Additional replacement sheets may be necessary to show the renumbering of the remaining figures. Each drawing sheet submitted after the filing date of an application must be labeled in the top margin as either “Replacement Sheet” or “New Sheet” pursuant to 37 CFR 1.121(d). If the changes are not accepted by the examiner, the applicant will be notified and informed of any required corrective action in the next Office action. The objection to the drawings will not be held in abeyance. Specification The disclosure is objected to because of the following informalities. Paragraph [0046] is objected to for the reasons set forth below. (a) Paragraph [0046] recites “the hosted computing environment 320.” The hosted computing environment of FIG. 3 is labeled 310, and reference character 320 does not appear in any figure. This should read “the hosted computing environment 310.” (b) Paragraph [0046] recites “field programmable gate array (FGPA).” This should read “field programmable gate array (FPGA).” Appropriate correction is required. Claim Rejections - 35 USC § 112 The following is a quotation of 35 U.S.C. 112(b): (b) CONCLUSION.—The specification shall conclude with one or more claims particularly pointing out and distinctly claiming the subject matter which the inventor or a joint inventor regards as the invention. The following is a quotation of 35 U.S.C. 112 (pre-AIA ), second paragraph: The specification shall conclude with one or more claims particularly pointing out and distinctly claiming the subject matter which the applicant regards as his invention. Claim 15 is rejected under 35 U.S.C. 112(b) or 35 U.S.C. 112 (pre-AIA ), second paragraph, as being indefinite for failing to particularly point out and distinctly claim the subject matter which the inventor or a joint inventor (or for applications subject to pre-AIA 35 U.S.C. 112, the applicant), regards as the invention. Where a claim is indefinite but is nonetheless susceptible of a reasonable interpretation, the claim has been examined on the merits on the basis of that interpretation, and the interpretation adopted is stated with each item below. See MPEP 2173.06(II). The following limitation renders the claim indefinite: (a) Claim 15 recites “wherein the metadata further indicates at least one of: processor capabilities of the target processor and streaming instructions.” As amended, the phrase “at least one of: A and B” may be read conjunctively, as requiring at least one processor capability and at least one streaming instruction (see SuperGuide Corp. v. DirecTV Enters., Inc., 358 F.3d 870, 886 (Fed. Cir. 2004)), or disjunctively, as requiring either item. The specification lists these items as alternative examples (“such as processor capabilities, streaming instructions, instruction architecture, or other information,” ¶[0042]). It is therefore unclear which scope is claimed. For purposes of examination, the limitation is interpreted as “wherein the metadata further indicates processor capabilities of the target processor or streaming instructions.” The rejections set forth below are based on this interpretation. Claim Rejections - 35 USC § 103 The following is a quotation of 35 U.S.C. 103 which forms the basis for all obviousness rejections set forth in this Office action: A patent for a claimed invention may not be obtained, notwithstanding that the claimed invention is not identically disclosed as set forth in section 102, if the differences between the claimed invention and the prior art are such that the claimed invention as a whole would have been obvious before the effective filing date of the claimed invention to a person having ordinary skill in the art to which the claimed invention pertains. Patentability shall not be negated by the manner in which the invention was made. The factual inquiries for establishing a background for determining obviousness under 35 U.S.C. 103 are summarized as follows: 1. Determining the scope and contents of the prior art. 2. Ascertaining the differences between the prior art and the claims at issue. 3. Resolving the level of ordinary skill in the pertinent art. 4. Considering objective evidence present in the application indicating obviousness or nonobviousness. Claims 1-2, 4-5, 7, 16 and 19-20 are rejected under 35 U.S.C. 103 as being unpatentable over Miller et al. (US Pub. No. 2022/0107795, hereinafter “Miller” – previously presented) in view of Aguilar, Jr. et al. (US Pub. No. 2005/0086655, hereinafter “Aguilar”) and further in view of Tamir et al. (US Pub. No. 2018/0173675, hereinafter “Tamir”). With respect to claim 1 (Currently Amended), Miller teaches a method comprising: (Miller discloses “a method for executing compiled code having parallel code fragments is provided” (Miller ¶[0006]).) obtaining an executable object associated with a first instruction architecture, the executable object including a parallel code fragment [[including a foreign code segment associated with a second instruction architecture]]; (Miller discloses executable code that contains parallel code fragments and is written in a first instruction set architecture: the instructions “store executable code having a plurality of parallel code fragments, each of the plurality of parallel code fragments representing alternative executable paths through a code stream, the code stream written in a non-native instruction set architecture with respect to the computing system” (Miller ¶[0007]); “[t]he applications 420 may be provided to the computing system 400 as executable code including a plurality of parallel code fragments” (¶[0064]).) obtaining a selection mask including metadata for identifying the parallel code fragment including the [[foreign code segment]], [[the metadata indicating the second instruction architecture]]; (Miller discloses feature bits, which read on the recited selection mask, carried in metadata that identifies the parallel code fragments: “[t]he parallel code fragments may be identified using metadata within the compiled code that identifies the code fragment and a code level required for compatibility with that code fragment” (Miller ¶[0073]); “the hosting firmware 412 will perform a process 604 to establish feature bits included within the received executable code having the parallel code fragments” (¶[0079]); “a list header for an entry in the list is emitted (operation 806) including feature bits as may be required” (¶[0089]).) in response to detecting the selection mask in the executable object, enabling execution of the parallel code fragment by at least: translating the executable object into machine-readable code executable by a first processor; (Miller discloses that, upon assessing the feature bits, the executable code is translated into native code for the host processor 402, which reads on the first processor: “the hosting firmware 412 translates instructions stored in the hosted environment 410 for execution from an instruction set architecture of the hosted environment 410 to a native instruction set architecture of the host computing environment, i.e., the instruction set architecture of the processor 402” (Miller ¶[0063]); “the code may be translated and executed according to the selected code level” (¶[0077]); “a first feature assessment operation may determine if a first feature is enabled (at operation 1106); if the feature is enabled, then it will be translated accordingly” (¶[0098]).) selecting the parallel code fragment including the [[foreign code segment]] based at least in part on the selection mask [[and the determining]]; (Miller discloses selecting, based on the feature bits, which parallel code fragment is translated: “[t]ranslating the executable code includes selecting a code fragment from among the plurality of parallel code fragments for execution based on the code level supported by the host platform” (Miller ¶[0005]); see also ¶[0098].) Miller is silent to disclose the parallel code fragment including a foreign code segment associated with a second instruction architecture, and providing the foreign code segment, as encoded in the second instruction architecture, to the second processor and causing the second processor to execute the foreign code segment; however, in an analogous art, Aguilar teaches: including a foreign code segment associated with a second instruction architecture (Aguilar discloses an executable program for a first processor (PU) that carries embedded code for a second processor (SPU) having a different instruction set: “Combined file 4400 is a combined executable program that contains both 32 bit (or 64bit) PU code and SPU code (e.g. SPU file 4340). Combined file 4400 may also be viewed as having embedded SPU code in a PU executable program” (Aguilar ¶[0152]); “each SPC may be accessed using different instruction sets” (¶[0177]); “the code for a particular file is formatted for a particular processor type and may not run if the code is loaded on a different processor type” (¶[0008]). The embedded SPU code reads on the foreign code segment, and the SPU instruction set reads on the second instruction architecture.) foreign code segment (The recitations of the foreign code segment in the obtaining-a-selection-mask and selecting limitations refer to the same embedded SPU code addressed above (Aguilar ¶¶[0152], [0160]: section header line 4740 “includes an ‘.spuelf’ program which is an SPU program”).) providing the foreign code segment, as encoded in the second instruction architecture, to the second processor and causing the second processor to execute the foreign code segment. (Aguilar discloses that the runtime loader extracts the embedded SPU code and sends it, unchanged, to the SPU, which executes it: “Runtime loader 4315 identifies SPU file 4340 from combined file 4400’s header information, and sends SPU file 4340 to memory 4370 using DMA 4430” (Aguilar ¶[0153]); “SPU 4350 is now able to execute SPU file 4340” (¶[0151]); the SPU ELF image is “validated that it is an SPU ELF image using the ELF” machine type “and then DMA’d onto an available SPU” (¶[0182]).) It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to modify the parallel code fragment of Miller to include a foreign code segment written in the instruction set of a second processor, and to provide that segment, as encoded, to the second processor for execution, as taught by Aguilar at ¶¶[0152]-[0153]. Aguilar explains that “in a heterogeneous processor environment, the code for a particular file is formatted for a particular processor type and may not run if the code is loaded on a different processor type,” and that what is needed is “a system and method for associating a processor type to a file and loading the file on a processor that corresponds to the associated processor type” (Aguilar ¶¶[0008]-[0009]). See KSR Int’l Co. v. Teleflex Inc., 550 U.S. 398, 417 (2007); MPEP 2143, subsection I(C). Miller in view of Aguilar is silent to disclose the metadata indicating the second instruction architecture, determining, based at least in part on the metadata, that a computing environment executing the executable object includes a second processor capable of executing operations included in the second instruction architecture, and selecting based at least in part on the determining; however, in an analogous art, Tamir teaches: the metadata indicating the second instruction architecture (Tamir discloses metadata in the executable that names the instruction set architecture of each code portion: “[e]ach of the ELF sections may have a different name (included in the section header) identifying the ISA corresponding to the binary representation 114 in that section” (Tamir ¶[0034]).) determining, based at least in part on the metadata, that a computing environment executing the executable object includes a second processor capable of executing operations included in the second instruction architecture; (Tamir discloses a computing device whose processing cores have different ISAs, “[a]t least two of the processing cores 102 included in the processor system 110 may have different ISAs” (Tamir ¶[0027]), and a loader that identifies the ISA of a processing core and matches it to the ISA named in the section header: “the ISA of the processing core 102 on which the program 115 is to be run may be identified, and the binary representation 114 included in the ELF section corresponding to that ISA may be selectively loaded and executed” (¶[0034]); “the dynamic loader 160 may identify the desired binary representation 114 by comparing the ISA specified in the control signal to the ISA name included in an ELF section header” (¶[0057]). Matching the section’s ISA name against the identified ISA of a core of the computing device 100 is a determination, based on the metadata, that the computing device includes a processing core capable of executing operations in that ISA.) and the determining (Tamir discloses that the code portion is selected on the basis of that match: the binary representation “included in the ELF section corresponding to that ISA may be selectively loaded and executed (without executing the binary representations 114 in the ELF sections corresponding to other ISAs)” (Tamir ¶[0034]).) It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to modify the selection-mask metadata of Miller in view of Aguilar to name the instruction set architecture of the foreign code segment, and to select the parallel code fragment upon determining that the computing environment includes a processor having that instruction set architecture, as taught by Tamir at ¶[0034]. Tamir explains that “[i]n this manner, the multi-architecture binary executable 116 may be selectively loaded to execute on multiple different ISAs” (Tamir ¶[0034]). See KSR Int’l Co. v. Teleflex Inc., 550 U.S. 398, 417 (2007); MPEP 2143, subsection I(C). With respect to claim 2 (Currently Amended), Miller teaches wherein the computing environment is a hosted computing environment, and wherein the determining comprises performing a handshake operation between an operating system and firmware of the hosted computing environment to determine that the hosted computing environment includes [[the second processor]] and that the executable object includes the parallel code fragment executable by [[the second processor]]. (Miller discloses a hosted computing environment (Miller ¶¶[0035], [0062]) in which the hosted operating system and the hosting firmware perform a handshake: “A handshake operation 1508 is performed between a hosted operating system 410 and processor executable 412 to establish feature bits” (¶[0147]); “the hosted environment 410 will trigger an initialization and handshaking process 606 with the hosting firmware 412” (¶[0079]); and that the environment determines whether the executable includes parallel code fragments it can execute: “determining whether the hosted environment 410 and hosting firmware 412 are aware of the parallel code fragments included in the executable code (operation 902) and whether the hosted environment 410 supports processing of the parallel code fragments (operation 904)” (¶[0091]).) Miller in view of Aguilar is silent to disclose; however, in an analogous art, Tamir teaches the second processor (Tamir discloses that the computing device includes a second processing core having a second ISA: “[a]t least two of the processing cores 102 included in the processor system 110 may have different ISAs” (Tamir ¶[0027]); and that the ISA of the core that will run the code “may be identified” so that the code portion for that ISA is loaded (¶[0034]).) It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to modify the handshake of Miller in view of Aguilar so that it determines that the hosted computing environment includes a processor having the second instruction architecture and that the executable object includes a parallel code fragment executable by that processor, as taught by Tamir at ¶[0034]. Tamir explains that “[i]n this manner, the multi-architecture binary executable 116 may be selectively loaded to execute on multiple different ISAs” (Tamir ¶[0034]). See KSR Int’l Co. v. Teleflex Inc., 550 U.S. 398, 417 (2007); MPEP 2143, subsection I(C). With respect to claim 4 (Currently Amended), Miller in view of Tamir is silent to disclose wherein the method further comprises obtaining, from the second processor, a result of executing the foreign code segment; however, in an analogous art, Aguilar teaches wherein the method further comprises obtaining, from the second processor, a result of executing the foreign code segment. (Aguilar discloses that the SPU returns the result of executing the embedded SPU code to the PU: “When SPU file 4340 is finished processing data using plug-in 4510, SPU file 4340 sends acknowledgment 4570 to PU 4300 which indicates that SPU 4350 is finished processing data. In one embodiment, acknowledgement 4570 may include processed data or may include a memory location reference where PU 4300 retrieves resultant data” (Aguilar ¶[0155]); see also ¶[0134] (“the SPU executes the spulet and generates a result”).) It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to modify Miller in view of Tamir so that the first processor obtains, from the second processor, the result of executing the foreign code segment, as taught by Aguilar at ¶[0155]. Aguilar explains that the acknowledgement “may include processed data or may include a memory location reference where PU 4300 retrieves resultant data” (Aguilar ¶[0155]), which is how work delegated to the second processor is returned to the program that delegated it. See KSR Int’l Co. v. Teleflex Inc., 550 U.S. 398, 417 (2007); MPEP 2143, subsection I(C). With respect to claim 5 (Currently Amended), Miller teaches wherein the method further comprises continuing execution of the executable object at a merge point encoded in the executable object [[based on the result]]. (Miller discloses a merge point encoded in the executable code by metadata, at which execution continues after the selected fragment: “[i]f a parallel code fragment at the next code level is emitted, a merge point code location is marked using metadata” (Miller ¶[0086]); “if the feature is enabled, then it will be translated accordingly (at operation 1108) followed by a translation of the merge point code (operation 1122)” (¶[0098]); “merge point code is translated as well, merging all portions of the translated code (operation 1210)” (¶[0101]).) Miller in view of Tamir is silent to disclose; however, in an analogous art, Aguilar teaches based on the result (Aguilar discloses that the PU proceeds using the result returned by the SPU: “acknowledgement 4570 may include processed data or may include a memory location reference where PU 4300 retrieves resultant data” (Aguilar ¶[0155]).) It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to modify Miller in view of Tamir so that execution continues at Miller’s merge point based on the result returned by the second processor, as taught by Aguilar at ¶[0155]. Aguilar explains that the returned acknowledgement “may include processed data or may include a memory location reference where PU 4300 retrieves resultant data” (Aguilar ¶[0155]), so that the delegating program can carry on with that data. See KSR Int’l Co. v. Teleflex Inc., 550 U.S. 398, 417 (2007); MPEP 2143, subsection I(C). With respect to claim 7 (Original), Miller teaches wherein the executable object includes a plurality of parallel code fragments that are enabled by the selection mask. (Miller discloses “storing executable code having a plurality of parallel code fragments” (Miller ¶[0006]) whose features are each enabled by feature bits: “a first feature assessment operation may determine if a first feature is enabled (at operation 1106) … Similarly, a second feature assessment operation may be executed as the first feature is not enabled (at operation 1110)” (¶[0098]).) With respect to claim 16 (Currently Amended), Miller teaches a system comprising: a processor; and a memory coupled to the processor storing instructions that, as a result of being executed by the processor, cause the processor to: (Miller discloses “a computing system is disclosed that includes a processor and a memory. When instructions stored in the memory are executed by the processor, the instructions cause the computing system to perform” (Miller ¶[0005]).) execute a set of operations encoded in an executable object including a parallel code fragment, where the parallel code fragment includes [[foreign code associated with a target instruction architecture corresponding to a target processor, the target instruction architecture being different from an instruction architecture in which the set of operations is encoded]]; (Miller discloses executing operations encoded in executable code that contains parallel code fragments (Miller ¶¶[0007], [0064]).) determine the parallel code fragment within the executable object is enabled based at least in part on a selection mask associated with the parallel code fragment, [[the selection mask including metadata indicating the target instruction architecture]]; (Miller discloses determining from feature bits associated with the parallel code fragments whether a fragment is enabled: “the hosting firmware 412 will perform a process 604 to establish feature bits included within the received executable code having the parallel code fragments” (Miller ¶[0079]); “the compiled executable code including the parallel code fragments can be assessed to determine if particular features are enabled” (¶[0098]).) translate the parallel code fragment including the [[foreign code]]; (Miller discloses translating the enabled parallel code fragment: “if the feature is enabled, then it will be translated accordingly” (Miller ¶[0098]).) Miller is silent to disclose foreign code associated with a target instruction architecture corresponding to a target processor, the target instruction architecture being different from an instruction architecture in which the set of operations is encoded; determining, based at least in part on the metadata, that the target processor is available to execute the foreign code; providing to the target processor the foreign code encoded in the target instruction architecture; and obtaining a result of executing the foreign code from the target processor; however, in an analogous art, Aguilar teaches: foreign code associated with a target instruction architecture corresponding to a target processor, the target instruction architecture being different from an instruction architecture in which the set of operations is encoded (Aguilar discloses SPU code embedded in a PU executable program (Aguilar ¶[0152]), where the SPU code is written for the SPU’s instruction set, which differs from that of the PU program: “each SPC may be accessed using different instruction sets” (¶[0177]); “the code for a particular file is formatted for a particular processor type and may not run if the code is loaded on a different processor type” (¶[0008]).) foreign code (The recitation of the foreign code in the translating limitation refers to the same embedded SPU code addressed above (Aguilar ¶¶[0152], [0160]).) determine, based at least in part on the metadata, that the target processor is available to execute the foreign code; (Aguilar discloses that, using the metadata in the code’s header, the embedded code is validated for the SPU and sent to an available SPU: “the SPU ELF image is parsed in memory, validated that it is an SPU ELF image using the ELF” machine type, “and then DMA’d onto an available SPU” (Aguilar ¶[0182]); see also ¶[0162] (“sent to an available SPU using a DMA execution”).) provide to the target processor the foreign code encoded in the target instruction architecture; and (Aguilar discloses that the embedded SPU code is sent to the SPU in its SPU form: “Runtime loader 4315 identifies SPU file 4340 from combined file 4400’s header information, and sends SPU file 4340 to memory 4370 using DMA 4430” (Aguilar ¶[0153]).) obtain a result of executing the foreign code from the target processor. (Aguilar discloses that “acknowledgement 4570 may include processed data or may include a memory location reference where PU 4300 retrieves resultant data” (Aguilar ¶[0155]).) It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to modify the parallel code fragment of Miller to include foreign code written for a target processor having a different instruction set, to determine that such a processor is available, to provide the foreign code to it as encoded, and to obtain the result of its execution, as taught by Aguilar at ¶¶[0152]-[0153]. Aguilar explains that “in a heterogeneous processor environment, the code for a particular file is formatted for a particular processor type and may not run if the code is loaded on a different processor type,” and that what is needed is “a system and method for associating a processor type to a file and loading the file on a processor that corresponds to the associated processor type” (Aguilar ¶¶[0008]-[0009]). See KSR Int’l Co. v. Teleflex Inc., 550 U.S. 398, 417 (2007); MPEP 2143, subsection I(C). Miller in view of Aguilar is silent to disclose the selection mask including metadata indicating the target instruction architecture; however, in an analogous art, Tamir teaches: the selection mask including metadata indicating the target instruction architecture (Tamir discloses metadata naming the ISA of each code portion: “[e]ach of the ELF sections may have a different name (included in the section header) identifying the ISA corresponding to the binary representation 114 in that section” (Tamir ¶[0034]); see also ¶[0057].) It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to modify the selection mask of Miller in view of Aguilar to include metadata naming the instruction set architecture of the foreign code, so that the enabled fragment is matched to a target processor having that instruction set architecture, as taught by Tamir at ¶[0034]. Tamir explains that “[i]n this manner, the multi-architecture binary executable 116 may be selectively loaded to execute on multiple different ISAs” (Tamir ¶[0034]). See KSR Int’l Co. v. Teleflex Inc., 550 U.S. 398, 417 (2007); MPEP 2143, subsection I(C). With respect to claim 19 (Original), Miller teaches wherein determining the parallel code fragment within the executable object is enabled further comprises obtaining the selection mask in response to a user enabling the parallel code fragment in a user interface. (Miller discloses a user interface (“a display 409 can be used for viewing a local version of a user interface,” Miller ¶[0062]) through which a user selects features carried in parallel code fragments: “a user may select to incorporate or exclude debugging breakpoints” (¶[0153]); and that the feature bits are established in response to that selection: “[t]he code file is provided to a debugger 1504, which can be used to toggle on a debug state … A handshake operation 1508 is performed between a hosted operating system 410 and processor executable 412 to establish feature bits” (¶[0147]).) With respect to claim 20 (Original), Miller teaches wherein, prior to obtaining the selection mask, the processor executes the set of operations encoded in the executable object without executing the parallel code fragment. (Miller discloses a default execution path executed when no parallel code fragment is enabled: “[t]he executable code will further include a default execution path that may be used in the event none of the parallel code fragments is associated with a compatible code level” (Miller ¶[0073]); “[i]f parallel code fragment support is not provided, only the neutral (default path) code requires translation” (¶[0101]).) Claims 3, 8-15 and 17-18 are rejected under 35 U.S.C. 103 as being unpatentable over Miller et al. (US Pub. No. 2022/0107795, hereinafter “Miller” – previously presented) in view of Aguilar, Jr. et al. (US Pub. No. 2005/0086655, hereinafter “Aguilar”) and Tamir et al. (US Pub. No. 2018/0173675, hereinafter “Tamir”), and further in view of Munshi et al. (US Pub. No. 2008/0276220, hereinafter “Munshi”). With respect to claim 3 (Original), Miller in view of Aguilar and Tamir is silent to disclose wherein the method further comprises determining the second processor is capable of executing the foreign code segment based at least in part on a capability of the second processor; however, in an analogous art, Munshi teaches wherein the method further comprises determining the second processor is capable of executing the foreign code segment based at least in part on a capability of the second processor. (Munshi discloses determining, from the capabilities of each attached processor, which processor can execute an existing executable: the capability data structure records “whether the physical compute device support a processing feature, a memory accessing mechanism or a named extension” (Munshi ¶[0039]); “[t]he selection may be determined based on a matching between the compute capability requirement against the compute capabilities stored in the capability data structure” (¶[0040]); “process 600 may select, for each physical compute device associated with a logical compute device, one or more existing compute kernel executables compatible with the physical compute device” (¶[0051]).) It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to modify Miller in view of Aguilar and Tamir to determine, from a capability of the second processor, that it is capable of executing the foreign code segment before the segment is provided to it, as taught by Munshi at ¶¶[0040] and [0051]. Munshi explains the need “to allow an application to perform a task in any available processing resources, such as CPUs and one or more GPUs, capable of performing the task” (Munshi ¶[0005]). See KSR Int’l Co. v. Teleflex Inc., 550 U.S. 398, 417 (2007); MPEP 2143, subsection I(C). With respect to claim 8 (Currently Amended), Miller teaches one or more computer storage media having executable instructions embodied thereon, which, when executed by a processing device, cause the processing device to perform operations comprising: (Miller discloses “a computer-readable storage device is disclosed, and has computer-executable instructions stored thereon which are executable by a processor of a computing system” (Miller ¶[0007]).) executing an application based on an executable object encoded in a first instruction architecture, the executable object including a parallel code fragment [[containing a foreign code segment]]; (Miller discloses applications provided “as executable code including a plurality of parallel code fragments” (Miller ¶[0064]), the code stream being “written in a non-native instruction set architecture with respect to the computing system” (¶[0007]).) enabling the parallel code fragment based on a selection mask including metadata [[indicating a second instruction architecture associated with a target processor]]; (Miller discloses enabling parallel code fragments based on feature bits identified by metadata (Miller ¶¶[0073], [0079]): “if the feature is enabled, then it will be translated accordingly” (¶[0098]).) in response to detecting the selection mask in the executable object during execution of the application, executing the parallel code fragment by at least: (Miller discloses that the feature bits are assessed during execution and the enabled fragment is translated and executed: “[d]uring subsequent execution, the hosting firmware 412 and hosted environment 410 cooperate during execution of the code, and will assess the feature bits to determine whether a change to the enabled features has occurred” (Miller ¶[0081]); the executable code “may be retranslated ‘on the fly’” (¶[0154]).) translating the parallel code fragment including the [[foreign code segment]] [[into machine-readable code in the second instruction architecture]]; and (Miller discloses translating the enabled parallel code fragment (Miller ¶¶[0063], [0098]).) Miller is silent to disclose the parallel code fragment containing a foreign code segment; however, in an analogous art, Aguilar teaches: containing a foreign code segment (Aguilar discloses “embedded SPU code in a PU executable program” (Aguilar ¶[0152]), the SPU code being written for a processor that may be “accessed using different instruction sets” (¶[0177]).) foreign code segment (The recitation of the foreign code segment in the translating limitation refers to the same embedded SPU code (Aguilar ¶¶[0152], [0160]).) It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to modify the parallel code fragment of Miller to contain a foreign code segment written for a processor having a different instruction set, as taught by Aguilar at ¶¶[0152]-[0153]. Aguilar explains that “in a heterogeneous processor environment, the code for a particular file is formatted for a particular processor type and may not run if the code is loaded on a different processor type,” and that what is needed is “a system and method for associating a processor type to a file and loading the file on a processor that corresponds to the associated processor type” (Aguilar ¶¶[0008]-[0009]). See KSR Int’l Co. v. Teleflex Inc., 550 U.S. 398, 417 (2007); MPEP 2143, subsection I(C). Miller in view of Aguilar is silent to disclose metadata indicating a second instruction architecture associated with a target processor, and determining, based at least in part on the metadata, that a computing environment executing the application includes the target processor; however, in an analogous art, Tamir teaches: indicating a second instruction architecture associated with a target processor (Tamir discloses section-header metadata “identifying the ISA corresponding to the binary representation 114 in that section” (Tamir ¶[0034]), each ISA corresponding to a processing core 102 having that ISA (¶[0027]).) determining, based at least in part on the metadata, that a computing environment executing the application includes the target processor; (Tamir discloses that “the ISA of the processing core 102 on which the program 115 is to be run may be identified, and the binary representation 114 included in the ELF section corresponding to that ISA may be selectively loaded and executed” (Tamir ¶[0034]), and that the loader compares “the ISA specified in the control signal to the ISA name included in an ELF section header” (¶[0057]). Matching the ISA named in the metadata against the ISA of a core of the computing device 100 determines that the computing device includes the processor targeted by the code.) It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to modify the selection mask of Miller in view of Aguilar to include metadata naming the instruction set architecture of the target processor, and to determine from that metadata that the computing environment includes the target processor, as taught by Tamir at ¶[0034]. Tamir explains that “[i]n this manner, the multi-architecture binary executable 116 may be selectively loaded to execute on multiple different ISAs” (Tamir ¶[0034]). See KSR Int’l Co. v. Teleflex Inc., 550 U.S. 398, 417 (2007); MPEP 2143, subsection I(C). Miller in view of Aguilar and Tamir is silent to disclose translating into machine-readable code in the second instruction architecture, and causing the target processor to execute the machine-readable code in the second instruction architecture; however, in an analogous art, Munshi teaches: into machine-readable code in the second instruction architecture (Munshi discloses translating code at run time into an executable for the target processor: “the compute runtime layer 109 may activate a compute compiler 107 to online compile a loaded source program into an executable optimized for a target processor, e.g. a CPU or a GPU, configured to execute the executable” (Munshi ¶[0032]); “process 600 may build a new compute kernel executable optimized for a physical compute device from the corresponding computer kernel source using an online compiler” (¶[0053]).) causing the target processor to execute the machine-readable code in the second instruction architecture. (Munshi discloses executing the executable built for a physical compute device on that device: “process 500 may select one of the plurality of executables loaded to the compute kernel object corresponding to the selected compute kernel instance for execution in a physical compute device associated with the logical compute device” (Munshi ¶[0048]); see also ¶[0056].) It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to modify Miller in view of Aguilar and Tamir so that, in response to detecting the selection mask during execution, the parallel code fragment is translated into machine code in the instruction architecture of the target processor and executed by that processor, as taught by Munshi at ¶¶[0032], [0048] and [0053]. Munshi explains the need “to allow an application to perform a task in any available processing resources, such as CPUs and one or more GPUs, capable of performing the task” (Munshi ¶[0005]). See KSR Int’l Co. v. Teleflex Inc., 550 U.S. 398, 417 (2007); MPEP 2143, subsection I(C). With respect to claim 9 (Currently Amended), Miller teaches wherein the processing device further performs the operations comprising resuming execution of the application at a merge point encoded in the executable object [[in response to obtaining a result of executing the foreign code segment from the target processor]]. (Miller discloses a merge point encoded in the executable code by metadata, at which execution resumes after the selected fragment (Miller ¶[0086]: “a merge point code location is marked using metadata”; ¶¶[0098], [0101]).) Miller in view of Aguilar and Tamir is silent to disclose [[in response to obtaining a result of executing the foreign code segment from the target processor]]; however, in an analogous art, Munshi teaches [[in response to obtaining a result of executing the foreign code segment from the target processor]] (Munshi discloses that the host determines that execution on the compute device has completed and obtains its result before proceeding: “[p]rocess 500 may determine the completion of executing a compute kernel execution instance by querying a status of the compute event object identifying the compute kernel execution instance” (Munshi ¶[0049]); “process 500 may retrieve results of executing a compute kernel execution instance” (¶[0050]).) It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to modify Miller in view of Aguilar and Tamir so that execution of the application resumes at the merge point in response to obtaining the result of executing the foreign code segment from the target processor, as taught by Munshi at ¶¶[0049]-[0050]. Munshi explains the need “to allow an application to perform a task in any available processing resources, such as CPUs and one or more GPUs, capable of performing the task” (Munshi ¶[0005]). See KSR Int’l Co. v. Teleflex Inc., 550 U.S. 398, 417 (2007); MPEP 2143, subsection I(C). With respect to claim 10 (Currently Amended), Miller teaches wherein the computing environment is a hosted computing environment, and the processing device [[and the target processor]] are components of the hosted computing environment. (Miller discloses a hosted computing environment 410 provided on a computing system whose processor 402 executes it: “the hosted environment 410 is executable from memory 404 via a processor 402 based on execution of hosting firmware 412” (Miller ¶[0063]); see also ¶¶[0035], [0062].) Miller in view of Aguilar and Munshi is silent to disclose; however, in an analogous art, Tamir teaches and the target processor (Tamir discloses a single computing device 100 whose processor system 110 includes processing cores of different ISAs: “[a]t least two of the processing cores 102 included in the processor system 110 may have different ISAs” (Tamir ¶[0027]); see also ¶[0026].) It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to modify Miller in view of Aguilar and Munshi so that the target processor is a component of the same hosted computing environment as the processing device, as in Tamir’s computing device having cores of different instruction set architectures, as taught by Tamir at ¶[0034]. Tamir explains that “[i]n this manner, the multi-architecture binary executable 116 may be selectively loaded to execute on multiple different ISAs” (Tamir ¶[0034]). See KSR Int’l Co. v. Teleflex Inc., 550 U.S. 398, 417 (2007); MPEP 2143, subsection I(C). With respect to claim 11 (Original), Miller teaches wherein the processing device further performs the operations comprising causing an operating system and firmware of the hosted computing environment to perform a handshake operation to determine the parallel code fragment is executable by the hosted computing environment. (Miller discloses “[a] handshake operation 1508 is performed between a hosted operating system 410 and processor executable 412 to establish feature bits” (Miller ¶[0147]); “the hosted environment 410 will trigger an initialization and handshaking process 606 with the hosting firmware 412” (¶[0079]); and determining “whether the hosted environment 410 supports processing of the parallel code fragments (operation 904)” (¶[0091]).) With respect to claim 12 (Original), Miller teaches wherein the processing device further performs the operations comprising causing the operating system to update a user interface to indicate that the parallel code fragment is executable by the hosted computing environment. (Miller discloses that “a display 409 can be used for viewing a local version of a user interface, e.g., to view executing tasks on the computing system 400 and/or within the hosted environment 410” (Miller ¶[0062]), through which the user is presented features available in parallel code fragments and “a user may select to incorporate or exclude debugging breakpoints” (¶[0153]).) With respect to claim 13 (Currently Amended), Miller teaches wherein executing the application based on the executable object further comprises translating instructions included in the executable object into machine code to be executed by the processing device. (Miller discloses “the hosting firmware 412 translates instructions stored in the hosted environment 410 for execution from an instruction set architecture of the hosted environment 410 to a native instruction set architecture of the host computing environment, i.e., the instruction set architecture of the processor 402” (Miller ¶[0063]); “the code that is executed has been translated to the native machine language of the host computing system” (¶[0077]).) With respect to claim 14 (Currently Amended), Miller in view of Tamir and Munshi is silent to disclose wherein the metadata further indicates a type associated with the target processor; however, in an analogous art, Aguilar teaches wherein the metadata further indicates a type associated with the target processor. (Aguilar discloses metadata in the code’s header identifying the type of processor on which the code is to run: “the header includes a processor identifier, such as a machine type, that distinguishes which type of processor the dependent file should run” (Aguilar ¶[0166]); “ELF header 4760 includes a machine type, such as” SPU, “which informs a runtime loader that the independent program should be loaded onto an SPU” (¶[0163]).) It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to modify the selection-mask metadata of Miller in view of Tamir and Munshi to further indicate the type of the target processor, as taught by Aguilar at ¶[0166]. Aguilar explains that the processor identifier “distinguishes which type of processor the dependent file should run” (Aguilar ¶[0166]), which lets the loader route the code to the right processor in a system having more than one processor type (¶[0009]). See KSR Int’l Co. v. Teleflex Inc., 550 U.S. 398, 417 (2007); MPEP 2143, subsection I(C). With respect to claim 15 (Currently Amended), Miller in view of Aguilar and Tamir is silent to disclose wherein the metadata further indicates at least one of: processor capabilities of the target processor and streaming instructions; however, in an analogous art, Munshi teaches wherein the metadata further indicates at least one of: processor capabilities of the target processor and streaming instructions. (Munshi discloses data associated with the code that specifies the processor capabilities required of the target processor: “[a]n application may send a hint including desired list of capability requirements for a data processing task” (Munshi ¶[0028]); “a compute capability requirement may identify a list of required capabilities for requesting processing resources to perform a task for the application” (¶[0040]); and “each executable may be stored with description data including, for example, the type, version and vendor of the target physical compute device” (¶[0057]). The claim recites the metadata content in the alternative and the prior art need teach only one alternative.) It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to modify the selection-mask metadata of Miller in view of Aguilar and Tamir to further indicate the processor capabilities required of the target processor, as taught by Munshi at ¶¶[0028] and [0040]. Munshi explains the need “to allow an application to perform a task in any available processing resources, such as CPUs and one or more GPUs, capable of performing the task” (Munshi ¶[0005]). See KSR Int’l Co. v. Teleflex Inc., 550 U.S. 398, 417 (2007); MPEP 2143, subsection I(C). With respect to claim 17 (Original), Miller in view of Aguilar and Tamir is silent to disclose wherein translating the parallel code fragment further comprises generating machine code executable by the target processor; however, in an analogous art, Munshi teaches wherein translating the parallel code fragment further comprises generating machine code executable by the target processor. (Munshi discloses “activat[ing] a compute compiler 107 to online compile a loaded source program into an executable optimized for a target processor, e.g. a CPU or a GPU, configured to execute the executable” (Munshi ¶[0032]); “process 600 may build a new compute kernel executable optimized for a physical compute device” (¶[0053]).) It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to modify the translation of the parallel code fragment of Miller in view of Aguilar and Tamir to generate machine code executable by the target processor, as taught by Munshi at ¶¶[0032] and [0053]. Munshi explains the need “to allow an application to perform a task in any available processing resources, such as CPUs and one or more GPUs, capable of performing the task” (Munshi ¶[0005]). See KSR Int’l Co. v. Teleflex Inc., 550 U.S. 398, 417 (2007); MPEP 2143, subsection I(C). With respect to claim 18 (Original), Miller in view of Aguilar and Tamir is silent to disclose wherein the processor continues execution of the executable object asynchronously during execution of the foreign code by the target processor; however, in an analogous art, Munshi teaches wherein the processor continues execution of the executable object asynchronously during execution of the foreign code by the target processor. (Munshi discloses that the host application continues to run while the compute device executes the delegated code: “Process 800B may run the application at block 809 asynchronously to performing an API function at block 813.” (Munshi ¶[0058]); “API calls to a compute runtime, such as compute runtime 109 of FIG. 1, to execute a compute kernel may be asynchronous in nature.” (¶[0046]).) It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to modify Miller in view of Aguilar and Tamir so that the processor continues executing the executable object asynchronously while the target processor executes the foreign code, as taught by Munshi at ¶¶[0046] and [0058]. Munshi explains the need “to allow an application to perform a task in any available processing resources, such as CPUs and one or more GPUs, capable of performing the task” (Munshi ¶[0005]). See KSR Int’l Co. v. Teleflex Inc., 550 U.S. 398, 417 (2007); MPEP 2143, subsection I(C). Claim 6 is rejected under 35 U.S.C. 103 as being unpatentable over Miller et al. (US Pub. No. 2022/0107795, hereinafter “Miller” – previously presented) in view of Aguilar, Jr. et al. (US Pub. No. 2005/0086655, hereinafter “Aguilar”) and Tamir et al. (US Pub. No. 2018/0173675, hereinafter “Tamir”), and further in view of Tevanian et al. (US Pat. No. 5,604,905, hereinafter “Tevanian”). With respect to claim 6 (Currently Amended), Miller in view of Tamir is silent to disclose wherein the parallel code fragment comprises a code length value and a payload comprising instructions in the second instruction architecture executable by the second processor, the payload including the foreign code segment, and wherein providing the foreign code segment to the second processor comprises obtaining, from the executable object, a number of bytes of the payload indicated by the code length value; however, in an analogous art, Aguilar teaches wherein the parallel code fragment comprises [[a code length value and]] a payload comprising instructions in the second instruction architecture executable by the second processor, the payload including the foreign code segment, and wherein providing the foreign code segment to the second processor comprises [[obtaining, from the executable object, a number of bytes of the payload indicated by the code length value]]. (Aguilar discloses SPU code embedded in a PU executable program (Aguilar ¶[0152]) as an “‘.spuelf’ program which is an SPU program that a runtime loader loads into an SPU’s local store” (¶[0160]), the SPU code being written for the SPU’s instruction set (¶[0177]), and providing that code to the SPU: the runtime loader “sends SPU file 4340 to memory 4370 using DMA 4430” (¶[0153]).) It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to modify the parallel code fragment of Miller in view of Tamir to comprise a payload of instructions in the second instruction architecture that includes the foreign code segment, and to provide that payload to the second processor, as taught by Aguilar at ¶¶[0152]-[0153]. Aguilar explains that “in a heterogeneous processor environment, the code for a particular file is formatted for a particular processor type and may not run if the code is loaded on a different processor type,” and that what is needed is “a system and method for associating a processor type to a file and loading the file on a processor that corresponds to the associated processor type” (Aguilar ¶¶[0008]-[0009]). See KSR Int’l Co. v. Teleflex Inc., 550 U.S. 398, 417 (2007); MPEP 2143, subsection I(C). Miller in view of Aguilar and Tamir is silent to disclose; however, in an analogous art, Tevanian teaches: a code length value (Tevanian discloses a header that records, for each architecture-specific block of object code, its size: “The architecture information includes CPU type 401, CPU sub-type 402, offset 403, size 404 and alignment 405”; “[t]he size 404 is the size of the object code file” (Tevanian, Detailed Description (11); FIG. 4).) obtaining, from the executable object, a number of bytes of the payload indicated by the code length value (Tevanian discloses locating and loading the architecture-specific block using the recorded size: “the system determines the location, size and alignment of the object code block of the CPU type, using the header information provided” (Tevanian, Detailed Description (18)); “the system loads and executes the located object code block” (Detailed Description (19)).) It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to modify the parallel code fragment of Miller in view of Aguilar and Tamir to carry a code length value for the payload and to obtain from the executable object the number of payload bytes that value indicates, as taught by Tevanian at Detailed Description (11) and (18). Tevanian explains that “[u]sing the header information for that block of object code, the appropriate object code is loaded for use by the requester” (Tevanian, Detailed Description (4)). See KSR Int’l Co. v. Teleflex Inc., 550 U.S. 398, 417 (2007); MPEP 2143, subsection I(C). Conclusion Applicant’s amendment necessitated the new ground(s) of rejection presented in this Office action. Accordingly, THIS ACTION IS MADE FINAL. See MPEP § 706.07(a). Applicant is reminded of the extension of time policy as set forth in 37 CFR 1.136(a). A shortened statutory period for reply to this final action is set to expire THREE MONTHS from the mailing date of this action. In the event a first reply is filed within TWO MONTHS of the mailing date of this final action and the advisory action is not mailed until after the end of the THREE-MONTH shortened statutory period, then the shortened statutory period will expire on the date the advisory action is mailed, and any nonprovisional extension fee (37 CFR 1.17(a)) pursuant to 37 CFR 1.136(a) will be calculated from the mailing date of the advisory action. In no event, however, will the statutory period for reply expire later than SIX MONTHS from the mailing date of this final action. Any inquiry concerning this communication or earlier communications from the examiner should be directed to ANIBAL RIVERACRUZ whose telephone number is (571)270-1200. The examiner can normally be reached Monday-Friday 9:30 AM-6:00 PM. Examiner interviews are available via telephone, in-person, and video conferencing using a USPTO supplied web-based collaboration tool. To schedule an interview, applicant is encouraged to use the USPTO Automated Interview Request (AIR) at http://www.uspto.gov/interviewpractice. If attempts to reach the examiner by telephone are unsuccessful, the examiner’s supervisor, Hyung S Sough can be reached at 571-272-6799. The fax phone number for the organization where this application or proceeding is assigned is 571-273-8300. Information regarding the status of published or unpublished applications may be obtained from Patent Center. Unpublished application information in Patent Center is available to registered users. To file and manage patent submissions in Patent Center, visit: https://patentcenter.uspto.gov. Visit https://www.uspto.gov/patents/apply/patent-center for more information about Patent Center and https://www.uspto.gov/patents/docx for information about filing in DOCX format. For additional questions, contact the Electronic Business Center (EBC) at 866-217-9197 (toll-free). If you would like assistance from a USPTO Customer Service Representative, call 800-786-9199 (IN USA OR CANADA) or 571-272-1000. /ANIBAL RIVERACRUZ/ Primary Examiner, Art Unit 2192
Read full office action

Prosecution Timeline

Aug 01, 2024
Application Filed
Jul 07, 2026
Non-Final Rejection mailed — §103, §112
Sep 28, 2026
Response Filed
Oct 21, 2026
Final Rejection mailed — §103, §112 (current)

Precedent Cases

Applications granted by this same examiner with similar technology

Patent 12783230
AUTOMATED SYSTEM TO CREATE "CHANGE HISTORY" AND/OR " COMMIT-MESSAGE" IN RESPONSE TO USER EDITS
2y 8m to grant Granted Nov 03, 2026
Patent 12775544
GENERATIVE AI FOR INDUSTRIAL AUTOMATION DESIGN ENVIRONMENT TEST
3y 1m to grant Granted Oct 27, 2026
Patent 12762043
VEHICLE CONTROL SYSTEM AND VEHICLE CONTROL METHOD
2y 8m to grant Granted Oct 13, 2026
Patent 12761900
METHOD AND SYSTEM OF FLEET-BASED DATA ADAPTATION AND ADAPTATION BY DRIVER ASSISTANCE SYSTEMS OF INDIVIDUAL VEHICLES
2y 4m to grant Granted Oct 13, 2026
Patent 12754718
USER-CENTRIC AND LLM-ENHANCED ADAPTIVE ETL CODE SYNTHESIS
2y 10m to grant Granted Oct 06, 2026
Study what changed to get past this examiner. Based on 5 most recent grants.

Strategy Recommendation AI-generated — please review before filing

Get a prosecution strategy drawn from examiner precedents, rejection analysis, and claim mapping.
Typically takes 5-10 seconds — AI-generated, attorney review required before filing

Prosecution Projections

3-4
Expected OA Rounds
91%
Grant Probability
99%
With Interview (+12.1%)
2y 3m (~0m remaining)
Median Time to Grant
Moderate
PTA Risk
Based on 765 resolved cases by this examiner. Grant probability derived from career allowance rate.

Sign in with your work email

Enter your email to receive a magic link. No password needed.

Personal email addresses (Gmail, Yahoo, etc.) are not accepted.

Free tier: 3 strategy analyses per month