DETAILED ACTION
Notice of Pre-AIA or AIA Status
The present application, filed on or after March 16, 2013, is being examined under the first inventor to file provisions of the AIA .
Claim Objections
Claim(s) 6 objected to because of the following informalities:
Claim 6 recites “a code module that includes the instruction causing the system failure”. The examiner believes this is a typo. A suggested amendment to the claim is “[[a]] the code module that includes the instruction causing the system failure”. For examination purposes, the claim will be interpreted as suggested.
Appropriate correction is required.
Claim Rejections - 35 USC § 112
The following is a quotation of the first paragraph of 35 U.S.C. 112(a):
(a) IN GENERAL.—The specification shall contain a written description of the invention, and of the manner and process of making and using it, in such full, clear, concise, and exact terms as to enable any person skilled in the art to which it pertains, or with which it is most nearly connected, to make and use the same, and shall set forth the best mode contemplated by the inventor or joint inventor of carrying out the invention.
The following is a quotation of the first paragraph of pre-AIA 35 U.S.C. 112:
The specification shall contain a written description of the invention, and of the manner and process of making and using it, in such full, clear, concise, and exact terms as to enable any person skilled in the art to which it pertains, or with which it is most nearly connected, to make and use the same, and shall set forth the best mode contemplated by the inventor of carrying out his invention.
Claims 1-9, 16, 22-24 rejected under 35 U.S.C. 112(a) or 35 U.S.C. 112 (pre-AIA ), first paragraph, as failing to comply with the written description requirement. The claim(s) contains subject matter which was not described in the specification in such a way as to reasonably convey to one skilled in the relevant art that the inventor or a joint inventor, or for applications subject to pre-AIA 35 U.S.C. 112, the inventor(s), at the time the application was filed, had possession of the claimed invention.
Claim 1 recites retrieving a resolution statement stored in association with the matched reference memory dump. The original disclosure as filed does not provide support for this limitation. The original disclosure as filed only provides support for storing a resolution statement received in association with the matched reference memory dump. See [0035], [0037] of the specification. Based on the lack of support for this limitation, initiating a remediation operation for a code module that includes the instruction causing the system failure based on the retrieved resolution statement is also not supported due to its dependency.
Claim(s) 2-9 fail to cure the deficiencies of their base claims and are rejected on the same grounds.
Claim 16 recites retrieving remediation information stored in association with the matched reference memory dump. The original disclosure as filed does not provide support for this limitation. The original disclosure as filed only provides support for storing remediation information received in association with the matched reference memory dump. See [0035], [0037] of the specification. Based on the lack of support for this limitation, initiating a remediation operation for the code module based on the retrieved remediation information is also not supported due to its dependency.
Claim 16 recites updating memory-dump processing information for subsequently received memory dumps associated with the code module. The original disclosure as filed does not provide support for this limitation. The original disclosure as filed only provides support for updating memory-dump processing information for subsequently received memory dumps. See [0037] of the specification.
Claim 22 recites updating, based on the similarity values, memory-dump processing information for subsequently received memory dumps associated with a code module that includes the instruction causing the system failure. The original disclosure as filed does not provide support for this limitation. The original disclosure as filed only provides support for updating…memory-dump processing information for subsequently received memory dumps or updating, based on the similarity values, memory-dump processing information for…a code module that includes the instruction causing the system failure. See [0037] of the specification.
Claim 23 recites retrieving remediation information stored in association with the matched reference memory dump. The original disclosure as filed does not provide support for this limitation. The original disclosure as filed only provides support for storing remediation information received in association with the matched reference memory dump. See [0035], [0037] of the specification. Based on the lack of support for this limitation, initiating a remediation operation for the code module based on the retrieved remediation information is also not supported due to its dependency.
Claim 23 recites updating memory-dump processing information for subsequently received memory dumps associated with the code module. The original disclosure as filed does not provide support for this limitation. The original disclosure as filed only provides support for updating memory-dump processing information for subsequently received memory dumps. See [0037] of the specification.
Claim 24 recites retrieving remediation information stored in association with the matched reference memory dump. The original disclosure as filed does not provide support for this limitation. The original disclosure as filed only provides support for storing remediation information received in association with the matched reference memory dump. See [0035], [0037] of the specification. Based on the lack of support for this limitation, initiating a remediation operation for the code module based on the retrieved remediation information is also not supported due to its dependency.
Claim 24 recites storing updated reference-dump information for the memory dump, the updated reference-dump information comprising the list of operations of the machine code instructions, a case description, and resolution information, and updating memory-dump processing information for subsequently received memory dumps associated with the code module based on the updated reference-dump information. The original disclosure as filed does not provide support for this limitation. The original disclosure as filed only provides support for storing…reference-dump information for the memory dump, the…reference-dump information comprising the list of operations of the machine code instructions, a case description, and resolution information, and updating memory-dump processing information for subsequently received memory dumps or storing updated reference-dump information for the memory dump, the updated reference-dump information comprising…resolution information, and updating memory-dump processing information for subsequently received memory dumps. See [0037] of the specification.
Claim Rejections - 35 USC § 101
35 U.S.C. 101 reads as follows:
Whoever invents or discovers any new and useful process, machine, manufacture, or composition of matter, or any new and useful improvement thereof, may obtain a patent therefor, subject to the conditions and requirements of this title.
Claim(s) 1-9, 11-16, 21-24 rejected under 35 U.S.C. 101 because the claimed invention is directed to judicial exceptions without significantly more.
Claim(s) 1-9 recite(s) methods, claim(s) 11-15, 21-24 recite(s) systems, and claim(s) 16 recite(s) computer program products comprising computer readable storage media not to be construed as storage in the form of transitory signals per se. Therefore, claim(s) 1-9, 11-16, 21-24 fall(s) within a statutory category.
Claim 1 recites abstract ideas.
detecting, on the computing system, a given error event causing a system failure corresponds to observations, which are mental processes. The specification does not provide detail on how the limitation is performed. Therefore, the broadest reasonable interpretation of the limitation includes a human performing a mental process of observing an indication that a given error event caused a system failure.
generating trace information of the memory dump to identify an instruction causing the system failure of the memory dump and a memory location of the instruction; extracting a plurality of machine code instructions preceding the instruction causing the system failure based on the memory location; removing a data part and not operations of the instructions being executed, from the plurality of machine code instructions, to generate a list of operations of the machine code instructions; and comparing the list of operations of the machine code instructions to a plurality of reference memory dumps to identify similarity values of the plurality of reference memory dumps to the memory dump corresponds to data analysis steps recited at a high level of generality such that they could practically be performed in the human mind, and amounts to performing mental processes in a computer environment. The broadest reasonable interpretation of the limitation in light of the specification encompasses data analysis of human-readable text. The specification does not provide detail on how the generating limitation is performed, but discloses that a human can process a memory dump ([0042]). Therefore, the generating limitation could be a human reading a memory dump and selecting a relevant portion. The remaining limitations amount to parsing and evaluating human-readable text (Fig. 5, 6, [0043], [0044], [0048]).
Claim 1 does not recite additional limitations that integrate the judicial exceptions into practical application.
executing, by a processor on a computing system, a plurality of operating system (OS) instructions amounts to merely using a computer in its ordinary capacity, which is mere instructions to apply an exception. See MPEP 2106.05(f).
generating, on the computing system, a memory dump for the given error event, wherein the memory dump comprises the plurality of OS instructions amounts to mere data gathering, which is insignificant extra-solution activity. See MPEP 2106.05(g).
selecting a matched reference memory dump from the plurality of reference memory dumps based on the similarity values, retrieving a resolution statement stored in association with the matched reference memory dump amounts to mere data gathering, which is insignificant extra-solution activity. See MPEP 2106.05(g).
resolving the given error event in the computing system based on the plurality of reference memory dumps wherein resolving the given error event comprises initiating a remediation operation for a code module that includes the instruction causing the system failure based on the retrieved resolution statement amounts to an attempt to cover any solution to an identified problem with no restriction on how the result is accomplished and no description of the mechanism for accomplishing the result, which is mere instructions to apply an exception. See MPEP 2106.05(f).
The claim does not include additional elements that are sufficient to amount to significantly more than the judicial exceptions because the additional elements amount to mere instructions to apply an exception and insignificant extra-solution activity. See MPEP 2106.05(f) and MPEP 2106.05(g).
Claim 2 does not recite additional limitations that integrate the judicial exceptions into practical application.
identifying a developer to process the memory dump for the given error event based on the similarity values amounts to mere data output, which is insignificant extra-solution activity. See MPEP 2106.05(g).
The claim does not include additional elements that are sufficient to amount to significantly more than the judicial exceptions because the additional elements amount to insignificant extra-solution activity. See MPEP 2106.05(g).
Claim 3 does not recite additional limitations that integrate the judicial exceptions into practical application.
storing the memory dump in a data storage, wherein storing the memory dump comprises storing a case description, the list of operations of the machine code instructions of the memory dump, and a resolution statement of the memory dump amounts to mere data output, which is insignificant extra-solution activity. See MPEP 2106.05(g).
The claim does not include additional elements that are sufficient to amount to significantly more than the judicial exceptions because the additional elements amount to insignificant extra-solution activity. See MPEP 2106.05(g).
Claim 4 does not recite additional limitations that integrate the judicial exceptions into practical application.
storing the memory dump, wherein storing the memory dump comprises storing one or more of a system description of the memory dump, a resolution statement of the memory dump, and developer information of a developer assigned to process the memory dump amounts to mere data output, which is insignificant extra-solution activity. See MPEP 2106.05(g).
The claim does not include additional elements that are sufficient to amount to significantly more than the judicial exceptions because the additional elements amount to insignificant extra-solution activity. See MPEP 2106.05(g).
Claim 5 refines recited abstract ideas.
wherein generating the trace information of the memory dump to identify the memory location of the instruction causing the system failure further comprises identifying the memory location based on an instruction set architecture (ISA) of a processor executing the machine code instructions of the system failure corresponds to data analysis steps recited at a high level of generality such that they could practically be performed in the human mind, and amounts to performing mental processes in a computer environment. The broadest reasonable interpretation of the limitation in light of the specification encompasses data analysis of human-readable text. The specification does not provide detail on how the generating limitation is performed, but discloses that a human can process a memory dump ([0042]). Therefore, the generating limitation could be a human reading a memory dump and selecting a relevant portion based on prior knowledge.
The claim does not contain additional limitations that integrate the judicial exceptions into practical application and does not contain additional limitations that are sufficient to amount to significantly more than the judicial exceptions.
Claim 6 refines recited abstract ideas.
wherein extracting the plurality of machine code instructions preceding the instruction based on the memory location further comprises starting at the instruction causing the system failure, and collecting a plurality of instructions until a name of a code module that includes the instruction causing the system failure is found corresponds to data analysis steps recited at a high level of generality such that they could practically be performed in the human mind, and amounts to performing mental processes in a computer environment. The broadest reasonable interpretation of the limitation in light of the specification encompasses data analysis of human-readable text by parsing and evaluating human-readable text (Fig. 5, 6, [0043], [0044], [0048]).
The claim does not contain additional limitations that integrate the judicial exceptions into practical application and does not contain additional limitations that are sufficient to amount to significantly more than the judicial exceptions.
Claim 7 refines recited abstract ideas.
wherein generating the list of operations of the machine code instructions further comprises creating a graph of the list of operations of the machine code instructions corresponds to data analysis steps recited at a high level of generality such that they could practically be performed in the human mind, and amounts to performing mental processes in a computer environment. The broadest reasonable interpretation of the limitation in light of the specification encompasses data analysis of human-readable text by parsing and evaluating human-readable text (Fig. 5, 6, [0043], [0044], [0048]).
The claim does not contain additional limitations that integrate the judicial exceptions into practical application and does not contain additional limitations that are sufficient to amount to significantly more than the judicial exceptions.
Claim 8 refines recited abstract ideas.
wherein comparing the list of operations of the machine code instructions to the plurality of reference memory dumps to identify the similarity values of the plurality of reference memory dumps to the memory dump further comprises comparing the graph of the list of operations of the machine code to the plurality of reference memory dumps to identify the similarity values of the plurality of reference memory dumps to the memory dump corresponds to data analysis steps recited at a high level of generality such that they could practically be performed in the human mind, and amounts to performing mental processes in a computer environment. The broadest reasonable interpretation of the limitation in light of the specification encompasses data analysis of human-readable text by parsing and evaluating human-readable text (Fig. 5, 6, [0043], [0044], [0048]).
The claim does not contain additional limitations that integrate the judicial exceptions into practical application and does not contain additional limitations that are sufficient to amount to significantly more than the judicial exceptions.
Claim 9 refines recited abstract ideas.
wherein comparing the list of operations of the machine code instructions to the plurality of reference memory dumps to identify the similarity values of the plurality of reference memory dumps to the memory dump further comprises identifying a control window including the instruction causing the system failure and the list of operations of the machine code instructions; and identifying a number of instructions within the control window of the memory dump that match instructions of respective reference memory dumps to identify the similarity values of the plurality of reference memory dumps to the memory dump corresponds to data analysis steps recited at a high level of generality such that they could practically be performed in the human mind, and amounts to performing mental processes in a computer environment. The broadest reasonable interpretation of the limitation in light of the specification encompasses data analysis of human-readable text by parsing and evaluating human-readable text (Fig. 5, 6, [0043], [0044], [0048]).
The claim does not contain additional limitations that integrate the judicial exceptions into practical application and does not contain additional limitations that are sufficient to amount to significantly more than the judicial exceptions.
Claim 11 recites abstract ideas.
generating trace information of the memory dump to identify an instruction causing the system failure from the plurality of OS instructions in the memory dump and a memory location of the instruction; extracting a plurality of machine code instructions preceding the instruction causing the system failure from the plurality of OS instructions based on the memory location; removing a data part and not operations of the plurality of machine code instructions, to generate a list of operations of the machine code instructions; and comparing the list of operations of the machine code instructions to a plurality of reference memory dumps to identify similarity values of the plurality of reference memory dumps to the memory dump corresponds to data analysis steps recited at a high level of generality such that they could practically be performed in the human mind, and amounts to performing mental processes in a computer environment. The broadest reasonable interpretation of the limitation in light of the specification encompasses data analysis of human-readable text. The specification does not provide detail on how the generating limitation is performed, but discloses that a human can process a memory dump ([0042]). Therefore, the generating limitation could be a human reading a memory dump and selecting a relevant portion. The remaining limitations amount to parsing and evaluating human-readable text (Fig. 5, 6, [0043], [0044], [0048]).
Claim 11 does not recite additional limitations that integrate the judicial exceptions into practical application.
A system, comprising one or more computer processors; and a memory containing a program which when executed by the one or more computer processors performs an operation amounts to mere instructions to implement the abstract ideas on a computer, which is mere instructions to apply an exception. See MPEP 2106.05(f).
receiving, from a computing system, a memory dump for a given error event, wherein the memory dump comprises a plurality of operating system (OS) instructions that resulted in the given error event causing a system failure when executed on the computing system amounts to mere data gathering, which is insignificant extra-solution activity. See MPEP 2106.05(g).
resolving the given error event in the computing system based on the plurality of reference memory dumps amounts to an attempt to cover any solution to an identified problem with no restriction on how the result is accomplished and no description of the mechanism for accomplishing the result, which is mere instructions to apply an exception. See MPEP 2106.05(f).
The claim does not include additional elements that are sufficient to amount to significantly more than the judicial exceptions because the additional elements amount to insignificant extra-solution activity and mere instructions to apply an exception. See MPEP 2106.05(f) and MPEP 2106.05(g).
Claim 12 does not recite additional limitations that integrate the judicial exceptions into practical application.
identifying a developer to process the memory dump for the given error event based on the similarity values amounts to mere data output, which is insignificant extra-solution activity. See MPEP 2106.05(g).
The claim does not include additional elements that are sufficient to amount to significantly more than the judicial exceptions because the additional elements amount to insignificant extra-solution activity. See MPEP 2106.05(g).
Claim 13 refines recited abstract ideas.
wherein generating the trace information of the memory dump to identify the memory location of the instruction causing the system failure further comprises identifying the memory location based on an instruction set architecture (ISA) of a processor executing the machine code instructions of the system failure corresponds to data analysis steps recited at a high level of generality such that they could practically be performed in the human mind, and amounts to performing mental processes in a computer environment. The broadest reasonable interpretation of the limitation in light of the specification encompasses data analysis of human-readable text. The specification does not provide detail on how the generating limitation is performed, but discloses that a human can process a memory dump ([0042]). Therefore, the generating limitation could be a human reading a memory dump and selecting a relevant portion based on prior knowledge.
The claim does not contain additional limitations that integrate the judicial exceptions into practical application and does not contain additional limitations that are sufficient to amount to significantly more than the judicial exceptions.
Claim 14 refines recited abstract ideas.
wherein generating the list of operations of the machine code instructions further comprises creating a graph of the list of operations of the machine code instructions; and wherein comparing the list of operations of the machine code instructions to the plurality of reference memory dumps to identify the similarity values of the plurality of reference memory dumps to the memory dump further comprises comparing the graph of the list of operations of the machine code instructions to the plurality of reference memory dumps to identify the similarity values of the plurality of reference memory dumps to the memory dump corresponds to data analysis steps recited at a high level of generality such that they could practically be performed in the human mind, and amounts to performing mental processes in a computer environment. The broadest reasonable interpretation of the limitation in light of the specification encompasses data analysis of human-readable text by parsing and evaluating human-readable text (Fig. 5, 6, [0043], [0044], [0048]).
The claim does not contain additional limitations that integrate the judicial exceptions into practical application and does not contain additional limitations that are sufficient to amount to significantly more than the judicial exceptions.
Claim 15 refines recited abstract ideas.
wherein comparing the list of operations of the machine code instructions and the plurality of reference memory dumps to identify the similarity values of the plurality of reference memory dumps to the memory dump further comprises: identifying a control window including the instruction causing the system failure and the list of operations of the machine code instructions; and identifying a number of instructions within the control window of the memory dump that match instructions of respective reference memory dumps to identify the similarity values of the plurality of reference memory dumps to the memory dump corresponds to data analysis steps recited at a high level of generality such that they could practically be performed in the human mind, and amounts to performing mental processes in a computer environment. The broadest reasonable interpretation of the limitation in light of the specification encompasses data analysis of human-readable text by parsing and evaluating human-readable text (Fig. 5, 6, [0043], [0044], [0048]).
The claim does not contain additional limitations that integrate the judicial exceptions into practical application and does not contain additional limitations that are sufficient to amount to significantly more than the judicial exceptions.
Claim 21 does not recite additional limitations that integrate the judicial exceptions into practical application.
wherein resolving the given error event comprises initiating processing of remediation information for a code module that includes the instruction causing the system failure based on the similarity values amounts to mere data gathering, which is insignificant extra-solution activity. See MPEP 2106.05(g).
The claim does not include additional elements that are sufficient to amount to significantly more than the judicial exceptions because the additional elements amount to insignificant extra-solution activity. See MPEP 2106.05(g).
Claim 22 does not recite additional limitations that integrate the judicial exceptions into practical application.
updating, based on the similarity values, memory-dump processing information for subsequently received memory dumps associated with a code module that includes the instruction causing the system failure amounts to mere data gathering, which is insignificant extra-solution activity. See MPEP 2106.05(g).
The claim does not include additional elements that are sufficient to amount to significantly more than the judicial exceptions because the additional elements amount to insignificant extra-solution activity. See MPEP 2106.05(g).
Claim 23 does not recite additional limitations that integrate the judicial exceptions into practical application.
wherein resolving the given error event comprises initiating a remediation operation for a code module that includes the instruction causing the system failure based on the retrieved remediation information amounts to an attempt to cover any solution to an identified problem with no restriction on how the result is accomplished and no description of the mechanism for accomplishing the result, which is mere instructions to apply an exception. See MPEP 2106.05(f).
selecting a matched reference memory dump from the plurality of reference memory dumps based on the similarity values, retrieving remediation information stored in association with the matched reference memory dump, and updating memory-dump processing information for subsequently received memory dumps associated with the code module amounts to mere data gathering, which is insignificant extra-solution activity. See MPEP 2106.05(g).
The claim does not include additional elements that are sufficient to amount to significantly more than the judicial exceptions because the additional elements amount to insignificant extra-solution activity and mere instructions to apply an exception. See MPEP 2106.05(f) and MPEP 2106.05(g).
Claim 24 does not recite additional limitations that integrate the judicial exceptions into practical application.
wherein resolving the given error event comprises initiating a remediation operation for a code module that includes the instruction causing the system failure based on the retrieved remediation information amounts to an attempt to cover any solution to an identified problem with no restriction on how the result is accomplished and no description of the mechanism for accomplishing the result, which is mere instructions to apply an exception. See MPEP 2106.05(f).
selecting a matched reference memory dump from the plurality of reference memory dumps based on the similarity values, retrieving remediation information stored in association with the matched reference memory dump, and storing updated reference-dump information for the memory dump, the updated reference-dump information comprising the list of operations of the machine code instructions, a case description, and resolution information, and updating memory-dump processing information for subsequently received memory dumps associated with the code module based on the updated reference-dump information amounts to mere data gathering, which is insignificant extra-solution activity. See MPEP 2106.05(g).
The claim does not include additional elements that are sufficient to amount to significantly more than the judicial exceptions because the additional elements amount to insignificant extra-solution activity and mere instructions to apply an exception. See MPEP 2106.05(f) and MPEP 2106.05(g).
Claim 16 recites abstract ideas.
generating trace information of the memory dump to identify an instruction causing the system failure from the plurality of OS instructions in the memory dump and a memory location of the instruction; identifying, based on the trace information, a code module that includes the instruction causing the system failure; extracting a plurality of machine code instructions preceding the instruction causing the system failure from the plurality of OS instructions based on the memory location; removing a data part and not operations of the plurality of machine code instructions, to generate a list of operations of the machine code instructions; and comparing the list of operations of the machine code instructions to a plurality of reference memory dumps to identify similarity values of the plurality of reference memory dumps to the memory dump corresponds to data analysis steps recited at a high level of generality such that they could practically be performed in the human mind, and amounts to performing mental processes in a computer environment. The broadest reasonable interpretation of the limitation in light of the specification encompasses data analysis of human-readable text. The specification does not provide detail on how the generating limitation is performed, but discloses that a human can process a memory dump ([0042]). Therefore, the generating limitation could be a human reading a memory dump and selecting a relevant portion. The remaining limitations amount to parsing and evaluating human-readable text (Fig. 5, 6, [0043], [0044], [0048]).
Claim 16 does not recite additional limitations that integrate the judicial exceptions into practical application.
A computer program product comprising a computer-readable storage medium having computer-readable program code embodied therewith, the computer-readable program code executable by one or more computer processors to perform an operation amounts to mere instructions to implement the abstract ideas on a computer, which is mere instructions to apply an exception. See MPEP 2106.05(f).
receiving, from a computing system, a memory dump for a given error event, wherein the memory dump comprises a plurality of operating system (OS) instructions that resulted in the given error event causing a system failure when executed on the computing system; selecting a matched reference memory dump from the plurality of reference memory dumps based on the similarity values; retrieving remediation information stored in association with the matched reference memory dump; and updating memory-dump processing information for subsequently received memory dumps associated with the code module amounts to mere data gathering, which is insignificant extra-solution activity. See MPEP 2106.05(g).
initiating a remediation operation for the code module based on the retrieved remediation information amounts to an attempt to cover any solution to an identified problem with no restriction on how the result is accomplished and no description of the mechanism for accomplishing the result, which is mere instructions to apply an exception. See MPEP 2106.05(f).
The claim does not include additional elements that are sufficient to amount to significantly more than the judicial exceptions because the additional elements amount to insignificant extra-solution activity and mere instructions to apply an exception. See MPEP 2106.05(f) and MPEP 2106.05(g).
For at least the reasons provided above, claim(s) 1-9, 11-16, 21-24 are not patent eligible.
Allowable Subject Matter
Claims 1-9, 11-16, 21-24 would be allowable if rewritten or amended to overcome the rejection(s) under 35 U.S.C. 101 set forth in this Office action.
The following is a statement of reasons for the indication of allowable subject matter:
None of the prior art of record, either alone or when combined, teaches or suggests comparing the list of operations of the machine code instructions to a plurality of reference memory dumps to identify similarity values of the plurality of reference memory dumps to the memory dump as recited in claim(s) 1, 11, 16.
Response to Arguments
Applicant's arguments, see pg. 9-21, filed 05/12/2026, with respect to the 101 rejection(s) of claim(s) 1-9, 11-16, 21-24 have been fully considered but they are not persuasive.
On pg. 10-12, Applicant argues:
“The Office indicated during the interview that, in its view, the claimed memory-dump and machine-code analysis could still be characterized as analysis of data, and that merely "resolving" an error event may be viewed as too general unless the claim recites a more specific technical change or remediation tied to the identified failure and reference memory dumps. The Office Action similarly characterized the prior "resolving" limitation as an attempt to cover any solution to an identified problem with no restriction on how the result is accomplished. In response to the Office's comments, and to advance prosecution toward allowance, Applicant has amended claim 1 to further clarify the technical nature of the claimed resolution operation. Applicant does not concede that prior claim 1 was patent ineligible.
As amended, claim 1 no longer merely recites "resolving the given error event in the computing system based on the plurality of reference memory dumps." Instead, amended claim 1 now recites that resolving the given error event comprises selecting a matched reference memory dump from the plurality of reference memory dumps based on the similarity values, retrieving a resolution statement stored in association with the matched reference memory dump, and initiating a remediation operation for a code module that includes the instruction causing the system failure based on the retrieved resolution statement.
This amendment directly addresses the concern expressed in the Office Action and discussed during the interview. Amended claim 1 now restricts the resolution operation to a particular computer-implemented remediation workflow tied to the claimed memory-dump analysis. Specifically, the claimed remediation is tied to: (i) a matched reference memory dump selected based on the claimed similarity values; (ii) a stored resolution statement associated with the matched reference memory dump; and (iii) a code module that includes the specific instruction identified as causing the system failure. Thus, amended claim 1 expressly connects the earlier machine-code and memory-dump processing limitations to a downstream remediation operation in the computing system.
Support for the amendment is provided throughout the specification, including at least paragraphs [0034], [0037], [0039], [0042], and [0049]. For example, paragraph [0034] describes system 200 as including data storage 210 for storing the new memory dump, processing updates of the new memory dump, reference memory dumps, case report 404, and resolution statement information. Paragraph [0037] describes storing a new memory dump with a plurality of reference memory dumps that have been processed and resolved, and storing a resolution statement when the system problem is resolved. Paragraph [0039] provides support for the claimed code-module hook by describing collecting instructions until a name of the code module that includes the instruction causing the system failure is found. Paragraph [0042] describes a dump matcher process and further describes that, once the problem is resolved, a resolution statement is received, processed, and stored for the memory dump. Paragraph [0049] further describes comparing the list of operations of the machine code instructions to reference memory dumps to identify similarity values and storing reference memory dump information including operation lists, case descriptions, and resolution statements. These passages are relied upon for the disclosed computer-implemented memory-dump processing architecture, code-module identification, storage of resolution information associated with resolved reference memory dumps, and use of matched reference-dump information in connection with remediation of the computing-system failure.”
The Examiner respectfully disagrees. As noted above, the original disclosure as filed does not provide support for the amendment. Given the broadest reasonable interpretation, the additional elements in the amendment do not recite additional limitations that integrate the judicial exceptions into practical application or amount to significantly more than the judicial exceptions. Limitations (i) and (ii) cited in the arguments amount to mere data gathering of a resolution statement based on the abstract ideas, which is insignificant extra-solution activity. See MPEP 2106.05(g). Limitation (iii) cited in the arguments amounts to an attempt to cover any remediation to a code module that includes the specific instruction identified as causing the system failure with no restriction on how the result is accomplished and no description of the mechanism for accomplishing the result, which is mere instructions to apply an exception. See MPEP 2106.05(f). The claim does not include additional elements that are sufficient to amount to significantly more than the judicial exceptions because the additional elements amount to insignificant extra-solution activity and mere instructions to apply an exception. See MPEP 2106.05(f) and MPEP 2106.05(g).
On pg. 13-14, Applicant argues:
“Applicant respectfully submits that independent claim 11 is patent eligible under 35 U.S.C. @ 101 without amendment. Claim 11 is directed to a system comprising one or more computer processors and a memory containing a program which, when executed by the one or more computer processors, performs a specific computer-failure analysis operation. The claim is not directed to a person reviewing information, a generic mental process, or generic data analysis divorced from computer technology. Rather, claim 11 recites receiving a memory dump from a computing system for a given error event, where the memory dump comprises operating system instructions that resulted in a system failure when executed on the computing system, generating trace information of that memory dump to identify an instruction causing the system failure and a memory location of that instruction, extracting machine code instructions preceding the failure-causing instruction from the operating system instructions based on the memory location, removing data parts while preserving operations of the machine code instructions to generate a list of operations, comparing that operation list to reference memory dumps to identify similarity values, and resolving the error event in the computing system based on the reference memory dumps.
The rejection characterizes the claimed memory-dump processing as data analysis that could practically be performed in the human mind because the broadest reasonable interpretation allegedly encompasses analysis of human-readable text. Applicant respectfully disagrees. The broadest reasonable interpretation must be reasonable in light of the claim language and the specification. Claim 11 does not recite generic text, ordinary records, or information that exists independently of a computer. Claim 11 recites a processor-executed operation involving a memory dump generated from a computing system failure, operating system instructions that resulted in the failure, trace information identifying a failure-causing instruction and memory location, machine code instructions preceding the failure-causing instruction, and removal of data parts from those machine code instructions while preserving operations. These limitations are rooted in computer execution, memory state, operating system instructions, processor instruction architecture, and machine-code-level failure analysis.
The Office's position improperly abstracts away the technological character of the claim. The claim does not merely compare generic information. It compares a specific operation-level representation generated from machine code instructions extracted from a memory dump associated with an operating system failure. In particular, the claimed system removes data parts from the machine code instructions while preserving operations, thereby generating a list of operations that can be compared to reference memory dumps. This is not a mental process; it is a particular computer-implemented representation and comparison technique for memory-dump analysis. The specification explains that this operation-level processing enables matching of a new memory dump with reference memory dumps where compared memory dumps are caused by similar issues but include changes to code that are not applicable to traditional direct string and function comparison methods. The specification further explains that the disclosed embodiments can significantly reduce analysis time by using machine-code-operation-level similarity information from resolved reference memory dumps to support resolution of a computing-system failure.”
The Examiner respectfully disagrees. The specification, [0042], [0044], explicitly states that a human can process a dump, and that the dump is human readable. Even if the processes are performed in a computer environment, performing a mental process in a computer environment is still a mental process. See MPEP 2106.04(a)(2)(III)(C). “changes to code that are not applicable to traditional direct string and function comparison methods” are not reflected in the claim. “Reduce analysis time” amounts to improving abstract ideas, which does not integrate the judicial exceptions into practical application or amount to significantly more than the judicial exceptions. See MPEP 2106.05(a), 2106.04(d), and 2106.05(I)(A).
On pg. 14-15, Applicant argues:
“Claim 11 also integrates any alleged abstract idea into a practical application. The claim applies the alleged analysis to a specific technological environment and to a specific technological problem: diagnosing and resolving system failures reflected in operating system memory dumps. The claimed system does not merely collect, classify, or display information. It receives a memory dump generated from a system failure, identifies the failure-causing instruction and its memory location, extracts machine code instructions preceding that instruction, strips data parts while retaining operations, compares the resulting operation list against reference memory dumps to identify similarity values, and resolves the error event in the computing system based on the reference memory dumps. This ordered combination uses a machine-code-level abstraction of a failure path to improve computer-failure diagnosis and resolution.
The rejection further treats the receiving of the memory dump as mere data gathering and the resolving limitation as mere instructions to apply an exception. Applicant respectfully submits that this analysis does not evaluate the claim as a whole. The memory dump is not incidental data gathered before an abstract idea is performed; it is the technological artifact generated by the computing-system failure and is the object on which the claimed system operates. Likewise, the resolving limitation is not a disconnected post-solution instruction. It is the use of the claimed similarity values and reference memory dumps in the computing system to address the same error event whose failure-causing instruction and machine-code operations were identified by the preceding limitations. In the ordered combination of claim 11, the receiving and resolving limitations are integral parts of the disclosed computer-failure analysis pipeline.
The specification confirms the technological nature of this pipeline. Paragraph [0013] explains that embodiments generate trace information of a new memory dump to identify a memory location of an instruction causing the system failure, remove data parts rather than operations from instructions preceding the instruction causing the memory dump, build a list of operations, and match that list to reference dumps that have had similar processing. Paragraph [0034] describes system 200 as including a Dump Analysis Control component, a new memory dump to be processed, reference memory dumps, and data storage for the new memory dump, processing updates, reference memory dumps, case report, and resolution statement information. Paragraphs [0038]-[0040] describe identifying the memory location based on an instruction set architecture, extracting preceding machine code instructions, removing data parts while preserving operations, identifying a control window, counting matching instructions, creating a graph, and comparing to reference dumps. Paragraph [0042] describes a dump matcher process and further describes receiving, processing, and storing a resolution statement once the problem is resolved. Paragraph [0049] similarly describes comparing the list of operations of the machine code instructions to reference memory dumps to identify similarity values, and storing reference dump information including operation lists, case descriptions, and resolution statements.”
The Examiner respectfully disagrees. The claimed invention does not improve computer-failure diagnosis and resolution. The claim merely perform mental processes to identify a human that will provide diagnosis and resolution of the failure. See Fig. 4 and [0042] of the specification. Performing mental processes to determine where to gather data amounts to performing mental processes for mere data gathering, which is insignificant extra-solution activity. See MPEP 2106.05(g).The resolution amounts to an attempt to cover any solution to the error event with no restriction on how the result is accomplished and no description of the mechanism for accomplishing the result, which is mere instructions to apply an exception. See MPEP 2106.05(f). The claim does not include additional elements that are sufficient to amount to significantly more than the judicial exceptions because the additional elements amount to insignificant extra-solution activity and mere instructions to apply an exception. See MPEP 2106.05(f) and MPEP 2106.05(g).
On pg. 15, Applicant argues:
The Office has also acknowledged that none of the prior art of record, either alone or in
combination, teaches or suggests comparing the list of operations of the machine code instructions to a plurality of reference memory dumps to identify similarity values of the plurality of reference memory dumps to the memory dump, as recited in independent claims 1, 11, and 16. That acknowledged point is not an insignificant extra-solution activity or a generic computer implementation. It is the core machine-code-level memory-dump comparison mechanism recited in claim 11 and used to resolve the computing-system error event.
Accordingly, claim 11 is patent eligible without amendment. When considered as a whole, claim 11 recites a specific system for processing operating system memory dumps using trace information, memory locations, extracted machine code instructions, removal of data parts while preserving operations, and operation-level similarity comparison against reference memory dumps to resolve a computing-system failure. Claim 11 therefore integrates any alleged abstract idea into a practical application and recites significantly more than any alleged judicial exception. Applicant respectfully requests withdrawal of the rejection of claim 11 under 35 U.S.C. @ 101.”
The Examiner respectfully disagrees. As made clear by the courts, the "‘novelty’ of any element or steps in a process, or even of the process itself, is of no relevance in determining whether the subject matter of a claim falls within the § 101 categories of possibly patentable subject matter. See MPEP 2106.05(I).
On pg. 16-17, Applicant argues:
“These amendments directly address the Office's concern that the claims could be characterized as analysis of data and that merely "resolving" an error event may be viewed as too general. As amended, claim 16 no longer ends with an unrestricted result. Instead, the claim recites a particular way in which the claimed machine-code-operation comparison is used in a computer system: the similarity values are used to select a matched reference memory dump, remediation information stored in association with the matched reference memory dump is retrieved, the retrieved remediation information is used to initiate a remediation operation for the code module containing the failure-causing instruction, and memory-dump processing information is updated for subsequently received memory dumps associated with that code module. Thus, the claimed analysis is integrated into both a current computer-system remediation workflow and a forward-looking update to subsequent memory-dump processing.
Amended claim 16 is also consistent with the type of practical application reflected in USPTO eligibility Example 40. In that example, eligibility was supported because the claimed analysis did not merely collect and compare information, but used the comparison result to change subsequent computer network monitoring. Similarly here, amended claim 16 does not merely receive and analyze memory- dump information. Instead, the claim uses the operation-level comparison of machine code instructions to reference memory dumps to select a matched reference memory dump, retrieve remediation information stored in association with the matched reference memory dump, initiate a remediation operation for the implicated code module based on the retrieved remediation information, and update memory-dump processing information for later memory dumps associated with that same code module. The claim therefore uses the analysis result to change downstream computer-failure processing, which is a practical application in computer technology.
Support for the amendments is provided throughout the specification. Paragraph [0034] describes system 200 as including data storage 210 for storing the new memory dump, processing updates of the new memory dump, reference memory dumps, case report 404, and resolution statement information. Paragraph [0037] describes storing a new memory dump with a plurality of reference memory dumps that have been processed and resolved, and storing a resolution statement when the system problem is resolved. Paragraph [0039] supports the code-module limitation by describing starting at the instruction causing the system failure and collecting instructions until a name of the code module that includes the instruction causing the system failure is found. Paragraph [0042] describes a dump matcher process and further describes that, once the problem is resolved, a resolution statement is received, processed, and stored for the memory dump. Paragraph [0049] further describes comparing the list of operations of the machine code instructions to reference memory dumps to identify similarity values and storing reference memory dump information including operation lists, case descriptions, and resolution statements.
These passages provide written-description support for amended claim 16 because they disclose the same operative chain now reflected in the claim. The specification discloses processing a memory dump to identify a failure-causing instruction and associated code module, using machine-code operation information to compare the memory dump against reference memory dumps, using similarity-based matching to identify corresponding reference-dump information, retrieving remediation information associated with a matched reference memory dump, initiating a remediation operation for the implicated code module based on the retrieved remediation information, and storing processing updates and related information for continued use in memory-dump analysis. Thus, a person of ordinary skill in the art would understand that the disclosed computer program product can use matched reference-dump information and associated remediation information to initiate further processing for the implicated code module and update memory-dump processing information for later memory dumps associated with that module.
Accordingly, amended claim 16 is not directed merely to a judicial exception. The claim recites a specific computer-implemented technique for processing memory dumps at the machine-code-operation level and using the result of that processing to alter downstream handling of a computing-system failure and subsequent memory-dump processing for the implicated code module. Applicant respectfully submits that amended claim 16 integrates any alleged abstract idea into a practical application and is patent eligible under 35 U.S.C. @ 101.”
The Examiner respectfully disagrees. As noted above, the original disclosure as filed does not provide support for the amendment. Given the broadest reasonable interpretation, the additional elements in the amendment do not recite additional limitations that integrate the judicial exceptions into practical application or amount to significantly more than the judicial exceptions. “selecting a matched reference memory dump and retrieving remediation information stored in association with the matched reference memory dump” amounts to mere data gathering of remediation information based on the abstract ideas, which is insignificant extra-solution activity. See MPEP 2106.05(g). “the retrieved remediation information is used to initiate a remediation operation for the code module containing the failure-causing instruction” amounts to an attempt to cover any remediation to a code module containing the failure-causing instruction with no restriction on how the result is accomplished and no description of the mechanism for accomplishing the result, which is mere instructions to apply an exception. See MPEP 2106.05(f). Since the specification does not provide any detail on “update memory-dump processing information for later memory dumps associated with that same code module”, the broadest reasonable interpretation of this limitation amounts to continuing to collect dump information for the code module without any change in how collection or processing is performed. This amounts to mere data gathering, which is insignificant extra-solution activity. See MPEP 2106.05(g). The claim does not include additional elements that are sufficient to amount to significantly more than the judicial exceptions because the additional elements amount to insignificant extra-solution activity and mere instructions to apply an exception. See MPEP 2106.05(f) and MPEP 2106.05(g).
On pg. 18-19, Applicant argues:
“Claim 21 further recites that resolving the given error event comprises initiating processing of remediation information for a code module that includes the instruction causing the system failure based on the similarity values. Thus, claim 21 ties the claimed similarity comparison to remediation-related processing for the particular code module associated with the failure-causing instruction. The claim therefore does not end with merely identifying similar data or outputting a similarity score. Instead, the similarity values are used to initiate further computer-system processing directed to the code module implicated by the failure.
Claim 22 further recites updating, based on the similarity values, memory-dump processing information for subsequently received memory dumps associated with a code module that includes the instruction causing the system failure. This limitation provides an additional practical application because the result of the current memory-dump analysis is used to affect later processing of memory dumps associated with the same code module. The claim therefore applies the machine-code-operation comparison in a forward-looking computer-processing workflow, rather than merely using the comparison as an end in itself.
Claim 23 further integrates the similarity comparison into both current failure handling and subsequent memory-dump processing. In particular, claim 23 recites selecting a matched reference memory dump based on the similarity values, retrieving remediation information stored in association with the matched reference memory dump, initiating a remediation operation for a code module that includes the instruction causing the system failure based on the retrieved remediation information, and updating memory-dump processing information for subsequently received memory dumps associated with the code module. Claim 23 therefore requires the system to use the similarity values to identify a matched reference dump and then apply remediation information associated with that matched reference dump in code-module-specific remediation processing and subsequent memory-dump processing tied to the implicated code module.
Claim 24 provides a still more detailed implementation of the same technical framework. Claim 24 recites selecting a matched reference memory dump based on the similarity values, retrieving remediation information stored in association with the matched reference memory dump, initiating a remediation operation for the code module based on the retrieved remediation information, storing updated reference-dump information for the memory dump, and updating memory-dump processing information for subsequently received memory dumps associated with the code module based on the updated reference-dump information. Thus, claim 24 expressly links the matched reference dump, stored remediation information, remediation operation, updated reference-dump information, and subsequent memory-dump processing into an integrated computer-failure resolution workflow.
Support for claims 21-24 is provided throughout the specification. For example, paragraph [0034] describes system 200 as including data storage for storing the new memory dump, processing updates of the new memory dump, reference memory dumps, a case report, and resolution statement information. Paragraph [0037] describes storing a new memory dump with reference memory dumps that have been processed and resolved, and storing a resolution statement when the system problem is resolved. Paragraph [0039] supports the code-module limitations by describing collecting instructions until a name of the code module that includes the instruction causing the system failure is found. Paragraph [0042] describes the dump matcher process and receiving, processing, and storing a resolution statement once the problem is resolved. Paragraph [0049] further describes comparing the operation list to reference memory dumps to identify similarity values, and storing reference dump information including operation lists, case descriptions, and resolution statements.
These passages demonstrate possession of the claimed subject matter because they describe a system in which memory dumps are processed to identify failure-causing instructions and associated code modules, machine-code-operation information is compared against reference memory dumps to identify similarity values, and similarity-based reference-dump information is used and stored in connection with resolution and subsequent processing of memory dumps. Claims 21-24 merely provide more particular implementations of this disclosed architecture, including code-module-specific remediation processing based on remediation information associated with a matched reference memory dump and updating of memory-dump processing information for subsequently received memory dumps associated with the implicated code module.
The claims also further address the Office's concern that the pending claims could be characterized as mere data analysis or as reciting a generalized "resolving" result. Claims 21-24 do not merely collect or compare information. They use the generated similarity values and matched reference dump information to initiate remediation-related processing, update subsequent memory-dump processing, store updated reference-dump information, and use that updated information for later memory-dump processing associated with the implicated code module. Accordingly, these claims integrate the claimed machine-code-level memory-dump analysis into practical computer-system processing.”
The Examiner respectfully disagrees. As noted above, the original disclosure as filed does not provide support for claims 22-24. Given the broadest reasonable interpretation, the additional elements in the amendment do not recite additional limitations that integrate the judicial exceptions into practical application or amount to significantly more than the judicial exceptions.
Claim 21 amounts to storing received information regarding the failure, which is mere data gathering, an insignificant extra-solution activity. See MPEP 2106.05(g).
Regarding claim 22, since the specification does not provide any detail on “updating, based on the similarity values, memory-dump processing information for subsequently received memory dumps associated with a code module that includes the instruction causing the system failure”, the broadest reasonable interpretation of this limitation amounts to continuing to collect dump information for the code module without any change in how collection or processing is performed. This amounts to mere data gathering, which is insignificant extra-solution activity. See MPEP 2106.05(g).
Regarding claim 23, “selecting a matched reference memory dump, retrieving remediation information stored in association with the matched reference memory dump” amounts to mere data gathering of remediation information based on the abstract ideas, which is insignificant extra-solution activity. See MPEP 2106.05(g). “initiating a remediation operation for a code module that includes the instruction causing the system failure based on the retrieved remediation information” amounts to an attempt to cover any remediation to an instruction causing the system failure with no restriction on how the result is accomplished and no description of the mechanism for accomplishing the result, which is mere instructions to apply an exception. See MPEP 2106.05(f). Since the specification does not provide any detail on “updating memory-dump processing information for subsequently received memory dumps associated with the code module”, the broadest reasonable interpretation of this limitation amounts to continuing to collect dump information for the code module without any change in how collection or processing is performed. This amounts to mere data gathering, which is insignificant extra-solution activity. See MPEP 2106.05(g). Furthermore, the claim does not reflect “apply remediation information associated with that matched reference dump in subsequent memory-dump processing tied to the implicated code module”.
Regarding claim 24, “selecting a matched reference memory dump, retrieving remediation information stored in association with the matched reference memory dump” amounts to mere data gathering of remediation information based on the abstract ideas, which is insignificant extra-solution activity. See MPEP 2106.05(g). “initiating a remediation operation for a code module that includes the instruction causing the system failure based on the retrieved remediation information” amounts to an attempt to cover any remediation to an instruction causing the system failure with no restriction on how the result is accomplished and no description of the mechanism for accomplishing the result, which is mere instructions to apply an exception. See MPEP 2106.05(f). Since the specification does not provide any detail on “storing updated reference-dump information for the memory dump, and updating memory-dump processing information for subsequently received memory dumps associated with the code module based on the updated reference-dump information”, the broadest reasonable interpretation of this limitation amounts to continuing to collect dump information for the code module without any change in how collection or processing is performed. This amounts to mere data gathering, which is insignificant extra-solution activity. See MPEP 2106.05(g).
The claims do not include additional elements that are sufficient to amount to significantly more than the judicial exceptions because the additional elements amount to insignificant extra-solution activity and mere instructions to apply an exception. See MPEP 2106.05(f) and MPEP 2106.05(g).
Conclusion
THIS ACTION IS MADE FINAL. 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 ALBERT LI whose telephone number is (571)272-5721. The examiner can normally be reached M-F 8:00AM-4:00PM PT.
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, Bryce Bonzo can be reached at (571)272-3655. 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.
/A.L./Examiner, Art Unit 2113 /BRYCE P BONZO/Supervisory Patent Examiner, Art Unit 2113
Prosecution Insights