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 Rejections - 35 USC § 102
The following is a quotation of the appropriate paragraphs of 35 U.S.C. 102 that form the basis for the rejections under this section made in this Office action:
A person shall be entitled to a patent unless –
(a)(2) the claimed invention was described in a patent issued under section 151, or in an application for patent published or deemed published under section 122(b), in which the patent or application, as the case may be, names another inventor and was effectively filed before the effective filing date of the claimed invention.
Claim(s) 1 - 9 is/are rejected under 35 U.S.C. 102(a)(2) as being anticipated by (Sivasubramanian et al., US 10,877,669).
Regarding claim 1, Sivasubramanian discloses:
a method, by a destination compute node (see at least Fig. 11 and col. 33 ln. 30 – 42 for the tables in storage nodes that acts as the storage for a client storage request (i.e. ends up as the destination for the client’s data and then is the destination node of said data), the method comprising:
provisioning additional resources for a processing table entry of a message processing table in response to resource exhaustion of the processing table entry (see at least Fig. 18 and col. 55 ln. 13 – 44 for providing additional resources for service demands for tables are higher (e.g. during demand a “burst”) );
incrementing a generation number of the processing table entry from a previous value to a current value (see at least col. 30 ln. 32 – 59 for new version of targeted items being used from the table and see at least col. 59 ln. 66 – col. 60 ln. 16 for the partition number being incremented);
rejecting a first message from a source compute node in response to the first message comprising the previous value of the generation number of the processing table entry (see at least col. 30 ln. 32 – 59 for values expected do not match then an error is generated for the API call/message, which would include non-version matches for the times such as the versioning features disclosed in col. 30 ln. 32 – 59 and col. 59 ln. 66 – col. 60 ln. 16 where the call/message is from the source compute node (client) that originates the call)); and
accepting the first message from the source compute node in response to the first message comprising the current value of the generation number of the processing table entry (see at least col. 30 ln. 32 – 59 wherein the instances where an error, missing result or the like is not present, which includes conditions of the correct versions as established in at least col. 30 ln. 32 – 59 and col. 59 ln. 66 – col. 60 ln. 16 the API call/message performs its normal function to the table and / or its entries, which indicates it was accepted).
Regarding claim 2, the rejection of claim 1 is incorporated and Sivasubramanian discloses:
first message comprises an index of the processing table entry, the index comprising the generation number (see at least col. 3 ln. 33 – 57 for API calls that include index values for items when interacting with the storage tables and at least col. 8 ln. 33 – 49 discloses that the indexes of ordering the data can include timestamps, which with one timestamp necessarily corresponding to a different time, then the relevant different time for the different entries then also indicates a different instance of entry (i.e. a different version) as discussed in at least col. 30 ln. 32 – 59 and col. 59 ln. 66 – col. 60 ln. 16).
Regarding claim 3, the rejection of claim 2 is incorporated and Sivasubramanian discloses:
the first message comprises a field for the index, and the field comprises a subfield for the generation number (see at least col. 3 ln. 33 – 57 for API calls that include index values for items when interacting with the storage tables and at least col. 8 ln. 33 – 49 discloses that the indexes of ordering the data can include timestamps, which with one timestamp necessarily corresponding to a different time, then the relevant different time for the different entries then also indicates a different instance of entry (i.e. a different version) as discussed in at least col. 30 ln. 32 – 59 and col. 59 ln. 66 – col. 60 ln. 16: note that fields are fundamental concepts in computer science where a piece of data within a larger data structure is held, here we have an index that is part of a larger data structure and itself has other subparts/subfields including the timestamp/version/generation data).
Regarding claim 4, the rejection of claim 1 is incorporated and Sivasubramanian discloses:
first message comprises an index of the processing table entry, the index being different than the generation number (see at least col. 3 ln. 33 – 57 for API calls that include index values for items when interacting with the storage tables and at least col. 8 ln. 33 – 49 discloses that the indexes of ordering the data can include timestamps, which with one timestamp necessarily corresponding to a different time, then the relevant different time for the different entries then also indicates a different instance of entry (i.e. a different version) as discussed in at least col. 30 ln. 32 – 59 and col. 59 ln. 66 – col. 60 ln. 16 and as the timestamp/version/generation number is only a part of the index it is not the whole index, making them different entities).
Regarding claim 5, the rejection of claim 4 is incorporated and Sivasubramanian discloses:
the first message comprises a first field for the index and a second field for the generation number (see at least col. 3 ln. 33 – 57 for API calls that include index values for items when interacting with the storage tables and at least col. 8 ln. 33 – 49 discloses that the indexes of ordering the data can include timestamps, which with one timestamp necessarily corresponding to a different time, then the relevant different time for the different entries then also indicates a different instance of entry (i.e. a different version) as discussed in at least col. 30 ln. 32 – 59 and col. 59 ln. 66 – col. 60 ln. 16: note that fields are fundamental concepts in computer science where a piece of data within a larger data structure is held, here we have an index that is part of a larger data structure and so the index itself is in its own field and itself has other subparts/subfields including the timestamp/version/generation data).
Regarding claim 6, the rejection of claim 1 is incorporated and Sivasubramanian discloses:
disabling the processing table entry before provisioning the additional resources for the processing table entry (see at least col. 55 ln. 45 – col. 56 ln. 2 for the situations when not sufficient resources are available to service the demand make for table processing where at least a portion of the additional demand is not performed, and therefore those tables involved are not available/disabled); and
enabling the processing table entry after provisioning the additional resources for the processing table entry (see at least col. 56 ln. 3 – 30 for increasing the resources when there were inadequate resources to accommodate the demand, as such it is expected with the adequate resources to meet the requisite demand that the system will then process the table interactions that were previously locked out for being… starved of resources).
Regarding claim 7, the rejection of claim 6 is incorporated and Sivasubramanian discloses:
disabling the processing table entry before provisioning the additional resources for the processing table entry ((see at least col. 55 ln. 45 – col. 56 ln. 2 for the situations when not sufficient resources are available to service the demand make for table processing where at least a portion of the additional demand is not performed, and therefore those tables involved are not available/disabled which then occurs before the additional provisioning of additional resources discussed in at least col. 56 ln. 3 – 30 (as well, there is no logical need to allocate additional resources to meet demand if there is no deficit in resources for said demand to begin with)); and
enabling the processing table entry after provisioning the additional resources for the processing table entry (see at least col. 56 ln. 3 – 30 for increasing the resources when there were inadequate resources to accommodate the demand, as such it is expected with the adequate resources to meet the requisite demand that the system will then process the table interactions that were previously locked out for being… starved of resources).
Regarding claim 8, the rejection of claim 7 is incorporated and Sivasubramanian discloses:
sending a semantic response to the source compute node, the semantic response lacking the current value of the generation number of the processing table entry (see at least col. 42 ln. 26 - 33 for an API function that supports richer semantics than the semantics in the Query API function and at least col.35 ln. 22 – 56 indicates that requests to the Query of Query API may return empty values (thus lacking the generation number)).
Regarding claim 9, the rejection of claim 1 is incorporated and Sivasubramanian discloses:
sending a semantic response to the source compute node, the semantic response comprising the current value of the generation number of the processing table entry (see at least col. 37 ln.17 – 11 (particularly ln. 45 – 10) where the example response to the Query API includes the date created field in the response which would be part of the timestamp from at least col. 8 ln. 33 – 49 and therefore contains the version/generation of the entry as opposed to one of a different date).
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.
Claims 10 - 20 is/are rejected under 35 U.S.C. 103 as being unpatentable over Sivasubramanian in view of Krishan et al. (hereinafter Krishan, US 2023/0229539).
Regarding claim 10, Sivasubramanian discloses:
a source compute node (see at least Fig. 25) comprising:
a processor (see at least Fig. 25); and
a non-transitory computer readable medium storing instructions which, when executed by the processor, cause the processor (see at least Fig. 25 and col. 65 ln. 9 - 36 for the computing node acting as a client invoking the system disclosed throughout the reference that includes software instructions necessary for the client to interact with the compute nodes that implement the service features of the reference) to:
send a message to a destination compute node, the message comprising a first value of a generation number of a processing table entry at the destination compute node (see at least Fig. 10 and col. ln. where a client node as disclosed in at least Fig. 25 and col. 65 ln. 9 – 36 sends a request (message) to a service node implementing the storage and API features for interacting with the table and its entries);
receive a first semantic response from the destination compute node, the first semantic response indicating resource exhaustion of the processing table entry (see at least col. 42 ln. 26 - 33 for an API function that supports richer semantics than other API function (indicating that they both support semantic response to their respective calls) and see at least Fig. 18 and col. 55 ln. 13 – 44 for providing additional resources for service demands for tables are higher and at least col. 56 ln. 30 – 42 for instances where the increased demand is observed the client/user may make a different, decreased request, where this then indicates that the client received a notification that the resources were insufficient and, therefore, may adjust accordingly);
receiving the first semantic response (see at least col. 42 ln. 26 - 33 for an API function that supports richer semantics than other API function (indicating that they both support semantic response to their respective calls)); and
send the message to the destination compute node, the message comprising a second value of the generation number of the processing table entry, the second value different than the first value (see at least col. 30 ln. 32 – 59 for the UpdateItem API call, so that one table entry than is later updated with a new, different value).
Sivasubramanian does not expressly disclose, however, Krishan discloses:
wait a predetermined duration in response to receiving the response (see at least ph. [0045] for one computing entity waiting a predetermined amount of time for a message response from another computing entity).
resend the message to the destination compute node after the wait of the predetermined duration (see at least ph. [045] for the health check messages being sent periodically, therefore, when a given health check and wait period has elapsed, a later check message will be sent).
It would have been obvious for a person of ordinary skill in the art before the effective filing date of the invention to modify the teachings of Sivasubramanian by the teachings of Krishan in order to establish a limit on the time that one system will wait for another interacting system before taking alternative action(s) rather than waiting indefinitely and the resources of the once waiting entity lying fallow for too long (thereby unnecessarily wasting its resources).
Regarding claim 11, the rejection of claim 10 is incorporated and Sivasubramanian discloses:
generate the second value of the generation number by incrementing the first value (see at least col. 30 ln. 32 – 59 for new version of targeted items being used from the table and see at least col. 59 ln. 66 – col. 60 ln. 16 for the partition number being incremented).
Regarding claim 12, the rejection of claim 10 is incorporated and Sivasubramanian discloses:
receive a second semantic response from the destination compute node, the second semantic response indicating generational mismatch with the processing table entry (see at least col. 30 ln. 32 – 59 for values expected do not match then an error is generated for the API call/message, which would include non-version matches for the times such as the versioning features disclosed in col. 30 ln. 32 – 59 and col. 59 ln. 66 – col. 60 ln. 16 where the call/message is from the source compute node (client) that originates the call)); and
send the message to the destination compute node, the message comprising a third value of the generation number of the processing table entry, the third value different than the second value (see at least col. 30 ln. 32 – 59 wherein the instances where an error, missing result or the like is not present, which includes conditions of the correct versions as established in at least col. 30 ln. 32 – 59 and col. 59 ln. 66 – col. 60 ln. 16 the API call/message performs its normal function to the table and / or its entries, which indicates it was accepted which would then indicate that it is a different and subsequent value than the value that produced the error, in some instances a third value from the previous two values).
Sivasubramanian does not expressly disclose, however, Krishan discloses:
resend the message to the destination compute node (see at least ph. [045] for the health check messages being sent periodically, therefore, when a given health check and wait period has elapsed, a later check message will be sent).
It would have been obvious for a person of ordinary skill in the art before the effective filing date of the invention to modify the teachings of Sivasubramanian by the teachings of Krishan in order to establish a limit on the time that one system will wait for another interacting system before taking alternative action(s) rather than waiting indefinitely and the resources of the once waiting entity lying fallow for too long (thereby unnecessarily wasting its resources).
Regarding claim 13, the rejection of claim 12 is incorporated and Sivasubramanian discloses:
the second semantic response comprises the third value of the generation number (see at least col. 30 ln. 32 – 59 wherein the instances where an error, missing result or the like is not present, which includes conditions of the correct versions as established in at least col. 30 ln. 32 – 59 and col. 59 ln. 66 – col. 60 ln. 16 the API call/message performs its normal function to the table and / or its entries, which indicates it was accepted which would then indicate that it is a different and subsequent value than the value that produced the error, in some instances a third value from the previous two values and as it must match the timestamp to avoid the error, then that relates to the current, be it a third, generation number value).
Regarding claim 14, the rejection of claim 12 is incorporated and Sivasubramanian discloses:
the message with the third value of the generation number is sent to the destination compute node without waiting after receiving the second semantic response (see at least col. 30 ln. 32 – 59 for the UpdateItem API call and this is done without creating an error and is therefore done successfully and therefore, immediately (without wait)).
Sivasubramanian does not expressly disclose, however, Krishan discloses:
resent to the destination compute node (see at least ph. [045] for the health check messages being sent periodically, therefore, when a given health check and wait period has elapsed, a later check message will be sent).
It would have been obvious for a person of ordinary skill in the art before the effective filing date of the invention to modify the teachings of Sivasubramanian by the teachings of Krishan in order to establish a limit on the time that one system will wait for another interacting system before taking alternative action(s) rather than waiting indefinitely and the resources of the once waiting entity lying fallow for too long (thereby unnecessarily wasting its resources).
Regarding claim 15, the rejection of claim 10 is incorporated and Sivasubramanian discloses:
the message comprises a field for addressing information of the message (see at least col. 3 ln. 33 – 57 for API calls values for items to be entered into a table, and as mentioned, since fields are fundamental concepts in computer science where a piece of data within a larger data structure is held, here we have an item that is part of a larger data structure the item for the table entry is itself in a field), and the field comprises a subfield for the generation number (see at least col. 3 ln. 33 – 57 for API calls that include index values for items when interacting with the storage tables and at least col. 8 ln. 33 – 49 discloses that the indexes of ordering the data can include timestamps, which with one timestamp necessarily corresponding to a different time, then the relevant different time for the different entries then also indicates a different instance of entry (i.e. a different version) as discussed in at least col. 30 ln. 32 – 59 and col. 59 ln. 66 – col. 60 ln. 16 where this is yet a part of the associated table entry item and therefore a subfield thereof).
Regarding claim 16, the rejection of claim 10 is incorporated and Sivasubramanian discloses:
the message comprises a first field for addressing information of the message and a second field for the generation number (see at least col. 3 ln. 33 – 57 for API calls that include index values for items when interacting with the storage tables and at least col. 8 ln. 33 – 49 discloses that the indexes of ordering the data can include timestamps, which with one timestamp necessarily corresponding to a different time, then the relevant different time for the different entries then also indicates a different instance of entry (i.e. a different version) as discussed in at least col. 30 ln. 32 – 59 and col. 59 ln. 66 – col. 60 ln. 16).
Regarding claim 17, Sivasubramanian discloses:
a system comprising:
a destination compute node comprising a message processing table (see at least Fig. 11 and col. 33 ln. 30 – 42 for the tables in storage nodes that acts as the storage for a client storage request (i.e. ends up as the destination for the client’s data and then is the destination node of said data) where these tables store the data from the message (items for the table)), the message processing table comprising a processing table entry (see at least col. 30 ln. 32 – 59 for items for the table), the processing table entry comprising a generation number (see at least col. 3 ln. 33 – 57 for API calls that include index values for items when interacting with the storage tables and at least col. 8 ln. 33 – 49 discloses that the indexes of ordering the data can include timestamps, which with one timestamp necessarily corresponding to a different time, then the relevant different time for the different entries then also indicates a different instance of entry (i.e. a different version) as discussed in at least col. 30 ln. 32 – 59 and col. 59 ln. 66 – col. 60 ln. 16); and
a source compute node (see at least Fig. 25, acting as a client node) configured to:
send a plurality of messages to the destination compute node in a particular order (see at least Fig. 10 and col. ln. where a client node as disclosed in at least Fig. 25 and col. 65 ln. 9 – 36 sends a request (message) to a service node implementing the storage and API features for interacting with the table and its entries and see at least col. 68 ln. 56 for operations (including messaging) therefore, being performed in a particular order and this may occur any number of times resulting in a plurality of messages sent to the destination node), each of the messages sent with a first value of the generation number of the processing table entry (at least col. 8 ln. 33 – 49 discloses that the indexes of ordering the data can include timestamps, which with one timestamp necessarily corresponding to a different time, then the relevant different time for the different entries then also indicates a different instance of entry (i.e. a different version) as discussed in at least col. 30 ln. 32 – 59 and col. 59 ln. 66 – col. 60 ln. 16);
receive a semantic response from the destination compute node (see at least col. 42 ln. 26 - 33 for an API function that supports richer semantics, indicating that the API calls produce semantic responses), the semantic response indicating generational mismatch with the processing table entry see at least col. 30 ln. 32 – 59 wherein the instances where an error, missing result or the like is not present, which includes conditions of the correct versions as established in at least col. 30 ln. 32 – 59 and col. 59 ln. 66 – col. 60 ln. 16 the API call/message performs its normal function to the table and / or its entries, which indicates it was accepted which would then indicate that it is a different and subsequent value than the value that produced the error); and
send the messages to the destination compute node in the particular order (see at least Fig. 10 and col. ln. where a client node as disclosed in at least Fig. 25 and col. 65 ln. 9 – 36 sends a request (message) to a service node implementing the storage and API features for interacting with the table and its entries and see at least col. 68 ln. 56 for operations (including messaging) therefore, being performed in a particular order and this may occur any number of times resulting in a plurality of messages sent to the destination node), each of the messages sent with a second value of the generation number of the processing table entry, the second value different than the first value (see at least col. 30 ln. 32 – 59 wherein the instances where an error, missing result or the like is not present, which includes conditions of the correct versions as established in at least col. 30 ln. 32 – 59 and col. 59 ln. 66 – col. 60 ln. 16 the API call/message performs its normal function to the table and / or its entries, which indicates it was accepted which would then indicate that it is a different than the value that produced the error before it).
Sivasubramanian does not expressly disclose, however, Krishan discloses:
resend the messages to the destination compute (see at least ph. [045] for the health check messages being sent periodically, therefore, when a given health check and wait period has elapsed, a later check message will be sent).
It would have been obvious for a person of ordinary skill in the art before the effective filing date of the invention to modify the teachings of Sivasubramanian by the teachings of Krishan in order to establish a limit on the time that one system will wait for another interacting system before taking alternative action(s) rather than waiting indefinitely and the resources of the once waiting entity lying fallow for too long (thereby unnecessarily wasting its resources).
Regarding claim 18, the rejection of claim 17 is incorporated and Sivasubramanian discloses:
provision additional resources for the processing table entry in response to resource exhaustion of the processing table entry (see at least Fig. 18 and col. 55 ln. 13 – 44 for providing additional resources for service demands for tables are higher (e.g. during demand a “burst”) ); and
increment the generation number of the processing table entry (see at least col. 30 ln. 32 – 59 for new version of targeted items being used from the table and see at least col. 59 ln. 66 – col. 60 ln. 16 for the partition number being incremented).
Regarding claim 19, the rejection of claim 17 is incorporated and Sivasubramanian discloses:
the semantic response comprises the second value of the generation number (see at least col. 42 ln. 26 - 33 for an API function that supports richer semantics, indicating that the API call responses are semantic in nations and see at least col. 30 ln. 32 – 59 wherein the instances where an error, missing result or the like is not present, which includes conditions of the correct versions as established in at least col. 30 ln. 32 – 59 and col. 59 ln. 66 – col. 60 ln. 16 the API call/message performs its normal function to the table and / or its entries, which indicates it was accepted which would then indicate that it is a different than the value that produced the error before it (a different second value then)).
Regarding claim 20, the rejection of claim 17 is incorporated and Sivasubramanian discloses:
the processing table entry further comprises an index and each of the messages is sent with the index (see at least col. 3 ln. 33 – 57 for API calls that include index values for items when interacting with the storage tables and at least col. 8 ln. 33 – 49 discloses that the indexes of ordering the data can include timestamps and as that is then a feature of each API call, they all have a respective index value).
References Cited Not Relied Upon
Bosshart et al. (US 10,721,167) a network forwarding system using match tables.
Mankovskii et al. (US 2017/0286189) discloses a virtual machine waiting a pretrained amount of time for a response.
Griffin et al. (US 2025/0045092) discloses remote systems waiting a predetermined period of time to receive a response from another remote system.
Conclusion
Any inquiry concerning this communication or earlier communications from the examiner should be directed to CRAIG C DORAIS whose telephone number is (571)270-3371. The examiner can normally be reached M-F 9:00 am - 6:00pm.
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, Pierre Vital can be reached at 5712724215. 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.
/CRAIG C DORAIS/Primary Examiner, Art Unit 2198
Prosecution Insights