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 § 112
The following is a quotation of 35 U.S.C. 112(b):
(B) CONCLUSION.—The specification shall conclude with one or more claims particularly pointing out and distinctly claiming the subject matter which the inventor or a joint inventor regards as the invention.
The following is a quotation of pre-AIA 35 U.S.C. 112, second paragraph::
The specification shall conclude with one or more claims particularly pointing out and distinctly claiming the subject matter which the applicant regards as his invention.
Claims 1-8 are rejected under 35 U.S.C. 112(b) or pre-AIA 35 U.S.C. 112, second paragraph, as being indefinite for failing to particularly point out and distinctly claim the subject matter which the inventor or a joint inventor, or for pre-AIA the applicant regards as the invention.
Claim 1 discloses “the notification comprising a slot identifier of (pointer to) the slot that contains the received data” (emphasis added). The scope of the claim is indefinite because it appears to present two alternative and potentially non-equivalent forms - “slot identifier” and “pointer to” - within a single claim limitation, joined by a parenthetical. It is unclear whether the claim requires (a) a slot identifier, (b) a pointer to the slot, (c) either an identifier or a pointer, or (d) some hybrid of the two.
Claims 2-8 are also rejected based on their dependency on the respective parent claims.
Claim 2 discloses “consuming the high priority level notification when its timestamp indicates it is later in time than a timestamp associated with the high priority notification queue corresponding to the high priority level notification” (emphasis added). The phrases “its timestamp,” “it,” and “the high priority notification queue corresponding to the high priority level notification” lack clear antecedent basis in claim 1. It is unclear which specific element “its” and “it” refer to, and which queue is meant by “corresponding to,” particularly where multiple notifications and multiple queues may be in scope.
Additionally, the phrase “when its timestamp indicates it is later in time than a timestamp associated with the high priority notification queue” is ambiguous as to which timestamps are being compared. It is not explicit whether the comparison is between (a) the notification’s timestamp and the timestamp of the most recently consumed notification in the corresponding queue, or (b) the notification’s timestamp and some other timestamp stored or associated with the queue. The lack of explicit identification of the timestamps being compared renders the scope of the claim unclear.
Claim 3 is also rejected based on their dependency on the respective parent claim 2.
Claim Rejections - 35 USC § 102
In the event the determination of the status of the application as subject to AIA 35 U.S.C. 102 and 103 (or as subject to pre-AIA 35 U.S.C. 102 and 103) is incorrect, any correction of the statutory basis for the rejection will not be considered a new ground of rejection if the prior art relied upon, and the rationale supporting the rejection, would be the same under either status.
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)(1) the claimed invention was patented, described in a printed publication, or in public use, on sale or otherwise available to the public before the effective filing date of the claimed invention.
Claims 1, 5, 6, 9-13, and 15-19 are rejected under 35 U.S.C. 102(a)(1) as being anticipated by Lafferty et al. (US 2023/0079452, hereinafter Lafferty).
Regarding claim 1, Lafferty discloses
A method in a network device for notifying a plurality of readers running on the network device of data to be processed, the method comprising:
receiving a plurality of data to be processed, each received data (paragraph [0218]: This grain data is received by the AMF Service on the remote host, and is written to the target pool—this is a “remote write” operation on the remote host) having a priority level among a plurality of priority levels including a normal priority level and one or more high priority levels (paragraphs [0231]-[0238], [0244]-[0247] describe Priority Delay states (Immediate, Preferred remote, Backup remote) and that the Writer field of RWC sets the priority; paragraph [0238] explains holding a grain reference for the configured delay to permit RWC cancellation; Note: A broad reading of “having a priority level” as “associated with a priority level for processing” aligns with the disclosure);
storing each received data in a slot among a plurality of slots in a shared memory (paragraph [0151]: The write notification queue has one entry for each grain in the pool; paragraph [0122]: References to pools [408] held by function processes [406] are pointers to shared memory [410]; paragraph [0218]: …written to the target pool…; Note: The “slots” map to grain slots in the pool (shared memory). Lafferty discloses writing received grain data to a pool (paragraph [0218]) and that each grain slot corresponds to an entry in the write-notification queue (paragraph [0151]));
adding a corresponding notification for each received data into an entry in a main notification queue (paragraph [0151]: The write notification queue has one entry for each grain in the pool; paragraph [0203]; Whenever a write lock is released and new grain data is available (i.e. there has been no error code posted to the grain) the function process posts the index of the newly updated grain into the Write notification queue and increments the write notification semaphore), the notification comprising a slot identifier of (pointer to) the slot that contains the received data (paragraph [0201]: The AMF service is not directly involved in granting write locks to AMF function processes—these are obtained by the function process directly interacting with the pool via a pointer to the shared memory block within which the pool is implemented; paragraph [0202]: The Write notification queue comprises an array of integers stored in the pool's shared memory block, and a control structure stored in the pool header. The control structure has a global mutex, a pair of pointers into the queue and the write notification semaphore) and the priority level of the received data (paragraphs [0231]-[0238]: priority level association);
when a notification points to received data that is at one of the high priority levels, then storing a pointer to the entry in the main notification queue that contains the notification into one of a plurality of priority notification queues that corresponds to the high priority level of the received data (paragraphs [0231]-[0238]: Priority Delay queues hold grain references according to priority; paragraph [0254]: The grain reference enters the priority delay queue [1008]; Note 1: High-priority notifications are placed into the appropriate priority-delay queue (paragraphs [0231]-[0238], [0254]). The grain reference serves as a pointer to the main-queue entry for the same grain. Interpreting the grain reference as a pointer to the main-queue entry is reasonable given both structures reference the same grain; Note 2: the broadest reasonable interpretation of a method (or process) claim having contingent limitations requires only those steps that must be performed and does not include steps that are not required to be performed because the condition(s) precedent are not met (MPEP 2111.04 II Contingent Limitations). Accordingly, patentable weight is not given because the storing step is not performed if the disclosed condition is not met)); and
signaling the plurality of readers for each notification that is added to the main notification queue (paragraph [0203]: Whenever a write lock is released and new grain data is available (i.e. there has been no error code posted to the grain) the function process posts the index of the newly updated grain into the Write notification queue and increments the write notification semaphore. There is a thread in the AMF Service which is signalled whenever the value of the semaphore is non-zero. This thread retrieves the indexes of any newly written grains from the write notification thread and processes them with the remote-write algorithm; Note: Lafferty discloses signaling threads (readers) via the semaphore whenever a notification is posted to the write notification queue),
wherein each reader, in response to being signaled, scans the plurality of priority notification queues to consume one or more notifications in the main notification queue and scans the main notification queue to consume notifications that were not already consumed via one of the plurality of priority notification queues (paragraph [0151]: one entry per grain; paragraph [0203]: There is a thread in the AMF Service…. This thread retrieves indexes from the write-notification queue and processes them; paragraphs [0231]-[0238]: Priority Delay states (Immediate, Preferred remote, Backup remote) and behavior for holding/forwarding grain references; paragraph [0254]: priority-delay queue processing and forwarding grain references; Note 1: Readers process notifications by scanning priority-delay queues (paragraphs [0238], [0254]) to handle high-priority items, then scan the main queue (paragraph [0203]) to handle remaining notifications. The one-entry-per-grain design (paragraph [0151]) ensures items processed via priority queues are not reprocessed from the main queue; Note 2: Regarding “notifications not already consumed via one of the plurality of priority notification queues,” the architecture implies that items processed via priority-delay queues would not be processed again from the main queue, and remaining items are processed directly from the main queue).
Regarding claim 5, Lafferty discloses
further comprising the reader programming hardware in the network is based on data stored in a slot of the shared memory pointed to in a consumed notification (paragraph [0218]: grain data written to the pool; paragraph [0238]: forwarding grain reference to link gateway for processing; Note: Processing grain data may involve programming hardware (e.g., link gateway, encoder/decoder) based on the data in the grain slot (paragraphs [0218], [0238]). The consumed notification points to the slot in shared memory containing this data).
Regarding claim 6, Lafferty discloses
further comprising tombstoning an earlier notification in the main notification queue when a subsequent notification targets the same slot as the earlier notification (paragraph [0151]: one entry per grain in the pool; paragraph [0203]: posting grain index into write-notification queue; paragraph [0164]: grain header/timestamp check; Note 1: Later notifications for the same grain slot supersede earlier ones (paragraphs [0151], [0203]), rendering the earlier notification obsolete - functionally equivalent to tombstoning; Note 2: the broadest reasonable interpretation of a method (or process) claim having contingent limitations requires only those steps that must be performed and does not include steps that are not required to be performed because the condition(s) precedent are not met (MPEP 2111.04 II Contingent Limitations). Accordingly, patentable weight is not given because the tombstoning step is not performed if the disclosed condition is not met).
Regarding claim 9, Lafferty discloses
A network device comprising: a memory; one or more computer processors; and a computer-readable storage device comprising instructions for controlling the one or more computer processors to (paragraph [0064]: a system is a set of computers or virtual machines running AMF services and connected by a network or networks; The computer inherently includes processor, memory, storage devices):
receive data for processing, the data (paragraph [0218]: This grain data is received by the AMF Service on the remote host, and is written to the target pool—this is a “remote write” operation on the remote host) being associated with a priority level (paragraphs [0231]-[0238], [0244]-[0247] describe Priority Delay states (Immediate, Preferred remote, Backup remote) and that the Writer field of RWC sets the priority; paragraph [0238] explains holding a grain reference for the configured delay to permit RWC cancellation); and
store a notification that references the received data into an entry in a main notification queue (paragraph [0151]: The write notification queue has one entry for each grain in the pool; paragraph [0203]; Whenever a write lock is released and new grain data is available (i.e. there has been no error code posted to the grain) the function process posts the index of the newly updated grain into the Write notification queue and increments the write notification semaphore);
store a reference to the entry into one of a plurality of priority notification queues that corresponds to the priority level associated with the received data (paragraphs [0231];[0238] describe Priority Delay states and the holding of grain references for a configured delay; paragraph [0254]: The grain reference enters the priority delay queue [1008]; Note: Lafferty discloses separate priority-delay queues (plurality of priority notification queues) into which grain references are placed according to their priority level (paragraphs [0231]-[0238], [0254]). The grain reference corresponds to the notification in the main queue, satisfying the claim’s requirement to store a reference to the main queue entry in the appropriate priority queue); and
process the notifications stored in the main notification queue, including: scanning the plurality of priority notification queues and, for each priority notification queue, consuming at least one notification by using a reference stored in the priority notification queue to access a corresponding notification stored in the main notification queue and processing the data in the corresponding notification (paragraph [0203]: posting grain index into write-notification queue and service thread retrieval/processing; paragraph [0238]: holding a grain reference for a configured delay, then passing it to the link gateway for processing; paragraph [0254]: grain reference entering the priority delay queue and being processed (after the delay ends); Note1: Priority-delay queues are scanned/processed when their delay expires (paragraphs [0238], [0254]). These queues contain references to grains that are also represented in the main notification queue. Processing involves using the reference to access the corresponding grain/notification in the main queue and then performing the remote-write or other processing (paragraph [0203]). This matches the claim’s requirement for scanning priority queues, consuming notifications by reference, and processing the corresponding data; Note 2: Regarding “use a reference from the priority queue to access a notification in the main queue,” it discloses that priority queues hold grain references and the main queue holds grain indexes for the same grains. Under BRI, using the reference to process the grain inherently involves accessing the corresponding main queue entry; Note 3: Regarding “notifications not already consumed via one of the plurality of priority notification queues,” the architecture implies that items processed via priority-delay queues would not be processed again from the main queue, and remaining items are processed directly from the main queue); and
scanning the main notification queue and consuming one or more notifications in the main notification queue that were not already consumed via one of the plurality of priority notification queues (paragraph [0151]: The write notification queue has one entry for each grain in the pool. This queue is used, in conjunction with the associated control block stored in the pool header, to generate a notification in the AMF Service whenever grain data is successfully written to the pool by an AMF function process. The write notification queue is used to implement remote writes; paragraph [0203]: Whenever a write lock is released and new grain data is available (i.e. there has been no error code posted to the grain) the function process posts the index of the newly updated grain into the Write notification queue and increments the write notification semaphore. There is a thread in the AMF Service which is signalled whenever the value of the semaphore is non-zero. This thread retrieves the indexes of any newly written grains from the write notification thread and processes them with the remote-write algorithm; Note: The AMF service thread scans the write-notification queue when signaled by the semaphore (paragraph [0203]). Any notifications not already handled via the priority-delay queues are retrieved and processed directly from the main queue. This meets the claim’s requirement to scan and consume from the main queue those notifications not already consumed via a priority queue).
Regarding claim 10, Lafferty discloses
wherein the plurality of priority notification queues are scanned in order of priority followed by scanning the main notification queue (paragraph [0203]: service thread retrieves indexes from the write-notification queue and processes them; paragraphs [0231]-[0238]: Priority Delay states (Immediate, Preferred remote, Backup remote) and behavior for holding/forwarding grain references; paragraph [0254]: the grain reference enters the priority delay queue [1008]; Note: Lafferty discloses multiple priority classes (Immediate/Preferred/Backup) and priority-delay queues that control the timing/ordering of when grain references are forwarded/processed (paragraphs [0231]-[0238], [0254]). The main queue is processed by the AMF service thread (paragraph [0203]). Scanning priority queues in priority order, then scanning the main queue, is a natural ordering consistent with these disclosed priority-delay mechanism and processing paths).
Regarding claim 11, Lafferty discloses
wherein the computer-readable storage device further comprises instructions for controlling the one or more computer processors to store the received data to the memory, wherein the notifications include references to locations in the memory that contain the received data (paragraph [0218]: This grain data is received by the AMF Service on the remote host, and is written to the target pool—this is a ‘remote write’ operation…; paragraphs [0151], [0203]: write-notification queue entries are grain indexes (references to grain locations); paragraph [0121] References to pools [408] held by function processes [406] are pointers to shared memory [410]).
Regarding claim 12, Lafferty discloses
wherein scanning the main notification queue includes, encountering a previously unconsumed notification referenced in one of the plurality of priority notification queues and consuming the previously unconsumed notification (paragraph [0203]: Whenever a write lock is released and new grain data is available (i.e. there has been no error code posted to the grain) the function process posts the index of the newly updated grain into the Write notification queue and increments the write notification semaphore. There is a thread in the AMF Service which is signalled whenever the value of the semaphore is non-zero. This thread retrieves the indexes of any newly written grains from the write notification thread and processes them with the remote-write algorithm; paragraphs [0231]-[0238], [0244]-[0247]: define priority levels (Immediate/Preferred/Backup) and how RWC Writer sets priority; Immediate = no hold; Preferred/Backup = configured delay; Note: The AMF service thread scans the write-notification queue when signaled and encounters entries that remain posted (previously unconsumed). Notifications referencing grains with higher-priority link settings (Immediate/Preferred) qualify as “high priority” under BRI. The thread retrieves and processes such entries, thereby consuming the previously unconsumed high-priority notification).
Regarding claim 13, Lafferty discloses
wherein the computer-readable storage device further comprises instructions for controlling the one or more computer processors to tombstone an earlier notification in the main notification queue when a subsequent notification targets the same slot as the earlier notification (paragraph [0151]: The write notification queue has one entry for each grain in the pool; paragraph [0164]: header/nominal timestamp checks; prevents duplicate write locks; paragraph [0203]: posting the index of the newly updated grain into the Write notification queue; Note: One-entry-per-grain semantics (paragraph [0151]) and re-posting of a grain index on update (paragraph [0203]) mean a later notification for the same grain slot supersedes an earlier one — functionally the earlier entry is rendered obsolete (tombstoned)).
Regarding claim 15, Lafferty discloses
A method in a network device comprising:
receiving data for processing, the data (paragraph [0218]: This grain data is received by the AMF Service on the remote host, and is written to the target pool—this is a “remote write” operation on the remote host) being associated with a priority level (paragraphs [0231]-[0238], [0244]-[0247]: Priority Delay states (Immediate, Preferred remote, Backup remote) and that the Writer field of RWC sets the priority; paragraph [0238]: holding a grain reference for the configured delay to permit RWC cancellation);
adding a notification of the received data to a main notification queue (paragraph [0151]: The write notification queue has one entry for each grain in the pool; paragraph [0203]; Whenever a write lock is released and new grain data is available (i.e. there has been no error code posted to the grain) the function process posts the index of the newly updated grain into the Write notification queue and increments the write notification semaphore);
when the received data is associated with a priority level higher than a lowest priority level, then adding a pointer to the notification in the main notification queue to a priority notification queue that corresponds to the priority level of the data (paragraph [0254] On Host B [1016] Producer function writes grain data to the pool [1012]. This generates a write notification in the AMF service which (among other things) causes a reference to the newly written grain to be sent to the transfer link connecting Gary on Host A to Gary on Host B. The link [1006] presently has a priority of 1 and the grain reference enters the priority delay queue [1008]; Note: the broadest reasonable interpretation of a method (or process) claim having contingent limitations requires only those steps that must be performed and does not include steps that are not required to be performed because the condition(s) precedent are not met (MPEP 2111.04 II Contingent Limitations). Accordingly, patentable weight is not given because the adding step is not performed if the disclosed condition is not met); and
scanning the plurality of priority notification queues (paragraph [0238]: If the priority delay is set to preferred remote or backup remote, then the grain reference is held for the corresponding delay before being passed to the link gateway; paragraph [0254] On Host B [1016] Producer function writes grain data to the pool [1012]. This generates a write notification in the AMF service which (among other things) causes a reference to the newly written grain to be sent to the transfer link connecting Gary on Host A to Gary on Host B. The link [1006] presently has a priority of 1 and the grain reference enters the priority delay queue; Note: Priority delay queue processed when delay expires; held references passed to link gateway) to consume one or more notifications in the main notification queue (paragraph [0203]: the function process posts the index of the newly updated grain into the Write notification queue and increments the write notification semaphore … This thread retrieves the indexes of any newly written grains … and processes them with the remote-write algorithm) and the main notification queue to consume notifications that were not already consumed via one of the plurality of priority notification queues (paragraph [0203]: Whenever a write lock is released and new grain data is available (i.e. there has been no error code posted to the grain) the function process posts the index of the newly updated grain into the Write notification queue and increments the write notification semaphore. There is a thread in the AMF Service which is signalled whenever the value of the semaphore is non-zero. This thread retrieves the indexes of any newly written grains from the write notification thread and processes them with the remote-write algorithm).
Regarding claim 16, Lafferty discloses
further comprising signaling one or more readers (paragraph [0203]: There is a thread in the AMF Service which is signalled whenever the value of the semaphore is non-zero) to scan the plurality of priority notification queues (paragraph [0203]: the function process posts the index of the newly updated grain into the Write notification queue and increments the write notification semaphore … This thread retrieves the indexes of any newly written grains … and processes them with the remote-write algorithm) and the main notification queue (paragraph [0238]: If the priority delay is set to preferred remote or backup remote, then the grain reference is held for the corresponding delay before being passed to the link gateway; paragraph [0254] On Host B [1016] Producer function writes grain data to the pool [1012]. This generates a write notification in the AMF service which (among other things) causes a reference to the newly written grain to be sent to the transfer link connecting Gary on Host A to Gary on Host B. The link [1006] presently has a priority of 1 and the grain reference enters the priority delay queue; Note: Priority delay queue processed when delay expires; held references passed to link gateway).
Regarding claim 17, Lafferty discloses
wherein the one or more readers program hardware in the network device (paragraph [0080]: Realtime output hardware receives grains from the system that contain the required output time encoded in the nominal timestamp—these grains are buffered by the hardware and delivered … at the correct time) with the data referenced in the notification (paragraph [0175]: A read lock cannot be granted until a write lock has been granted and then released indicating that the required data is available).
Regarding claim 18, Lafferty discloses
wherein scanning the main notification queue includes, encountering a previously unconsumed high priority level notifications in the main notification queue and consuming the previously unconsumed high priority level notification (paragraph [0203]: Whenever a write lock is released and new grain data is available (i.e. there has been no error code posted to the grain) the function process posts the index of the newly updated grain into the Write notification queue and increments the write notification semaphore. There is a thread in the AMF Service which is signalled whenever the value of the semaphore is non-zero. This thread retrieves the indexes of any newly written grains from the write notification thread and processes them with the remote-write algorithm; paragraphs [0231]-[0238], [0244]-[0247]: define priority levels (Immediate/Preferred/Backup) and how RWC Writer sets priority; Immediate = no hold; Preferred/Backup = configured delay; Note: The AMF service thread scans the write-notification queue when signaled and encounters entries that remain posted (previously unconsumed). Notifications referencing grains with higher-priority link settings (Immediate/Preferred) qualify as “high priority” under BRI. The thread retrieves and processes such entries, thereby consuming the previously unconsumed high-priority notification).
Regarding claim 19, Lafferty discloses
further comprising tombstoning an earlier notification in the main notification queue (paragraph [0151]: the write notification queue has one entry for each grain in the pool; Note: The queue is keyed by grain index; a new notification for the same grain replaces the earlier one, functionally marking it obsolete (“tombstoning”)) when a subsequent notification targets the same slot as the earlier notification (paragraph [0164]: If the nominal timestamp is found in the index… a second write lock cannot be granted (Note: Prevents simultaneous processing of multiple notifications for the same slot; ensures earlier notifications are effectively invalidated when a new one arrives); paragraph [0203]: whenever a write lock is released… the function process posts the index of the newly updated grain into the Write notification queue… (Note: Posting a new index for the same grain slot (same nominal timestamp/index) supersedes the earlier notification for that slot; only the latest is processed)).
Claim Rejections - 35 USC § 103
In the event the determination of the status of the application as subject to AIA 35 U.S.C. 102 and 103 (or as subject to pre-AIA 35 U.S.C. 102 and 103) is incorrect, any correction of the statutory basis for the rejection will not be considered a new ground of rejection if the prior art relied upon, and the rationale supporting the rejection, would be the same under either status.
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 of this title, 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 4 and 8 are rejected under 35 U.S.C. 103 as being unpatentable over Lafferty et al. (US 2023/0079452, hereinafter Lafferty) in view of Kodama (US 2007/0133531, hereinafter Kodama).
Regarding claim 4, Lafferty discloses
further comprising scanning the main notification queue subsequent to scanning the plurality of priority notification queues, including: … (paragraph [0203]: service thread retrieves indexes from the write-notification queue and processes them; paragraphs [0231]-[0238]: Priority Delay states (Immediate, Preferred remote, Backup remote) and behavior for holding/forwarding grain references; paragraph [0254]: the grain reference enters the priority delay queue [1008]; Note: Lafferty discloses multiple priority classes (Immediate/Preferred/Backup) and priority-delay queues that control the timing/ordering of when grain references are forwarded/processed (paragraphs [0231]-[0238], [0254]). The main queue is processed by the AMF service thread (paragraph [0203]). Scanning priority queues in priority order, then scanning the main queue, is a natural ordering consistent with these disclosed priority-delay mechanism and processing paths).
Lafferty does not disclose first consuming any unconsumed high priority level notifications in the main notification queue; and subsequent to the first consuming, consuming normal priority level notifications. Kodama discloses first consuming any unconsumed high priority level notifications in the main notification queue; and subsequent to the first consuming, consuming normal priority level notifications (paragraph [0146]: (4) A step of extracting the first pointer information or i-th next-pointer information from each queue in the order of priority of a next queue, the high-priority queue, and the low-priority queue, the next queue holding the i-th (where i is an integer of 1 or more) next-pointer information for searching for another output destination of the packet). It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to modify the teaching of Lafferty by incorporating Kodama’s canning/processing these queues in priority order (high to low). The motivation would have been to process a high-priority flow, which is given priority over other flows to reduce delay fluctuation (Kodama paragraph [0012], [0013]).
Regarding claim 8, Lafferty discloses
further comprising each reader, scanning the plurality of priority notification queues …, followed by scanning the main notification queue to consume notifications in sequence from an earliest unconsumed notification (paragraph [0203]: service thread retrieves indexes from the write-notification queue and processes them; paragraphs [0231]-[0238]: Priority Delay states (Immediate, Preferred remote, Backup remote) and behavior for holding/forwarding grain references; paragraph [0254]: the grain reference enters the priority delay queue [1008]; Note: Lafferty discloses multiple priority classes (Immediate/Preferred/Backup) and priority-delay queues that control the timing/ordering of when grain references are forwarded/processed (paragraphs [0231]-[0238], [0254]). The main queue is processed by the AMF service thread (paragraph [0203]). Scanning priority queues in priority order, then scanning the main queue, is a natural ordering consistent with these disclosed priority-delay mechanism and processing paths).
Lafferty does not disclose scanning the plurality of priority notification queues in order from a highest priority notification queue to a lowest priority notification queue. Kodama discloses scanning the plurality of priority notification queues in order from a highest priority notification queue to a lowest priority notification queue (paragraph [0146]: (4) A step of extracting the first pointer information or i-th next-pointer information from each queue in the order of priority of a next queue, the high-priority queue, and the low-priority queue, the next queue holding the i-th (where i is an integer of 1 or more) next-pointer information for searching for another output destination of the packet). It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to modify the teaching of Lafferty by incorporating Kodama’s canning/processing these queues in priority order (high to low). The motivation would have been to process a high-priority flow, which is given priority over other flows to reduce delay fluctuation (Kodama paragraph [0012], [0013]).
Claims 7, 14, and 20 are rejected under 35 U.S.C. 103 as being unpatentable over Lafferty et al. (US 2023/0079452, hereinafter Lafferty) in view of Munipalle (US 2021/0382863, hereinafter Munipalle).
Regarding claim 7, Lafferty discloses
compacting … , including updating each of the plurality of priority notification queues with new pointers to the main notification queue (paragraph [0254]: On Host B [1016] Producer function writes grain data to the pool [1012]. This generates a write notification in the AMF service which (among other things) causes a reference to the newly written grain to be sent to the transfer link connecting Gary on Host A to Gary on Host B. The link [1006] presently has a priority of 1 and the grain reference enters the priority delay queue [1008]; Note: Priority notification queues in AMF hold grain references/pointers (paragraph[0254]); those references point to grain indexes which are also represented in the write-notification queue. If compaction changes main-queue storage/indices (or advances ring/head pointers), the AMF runtime would update priority-delay queue entries (pointers) to remain consistent. The spec shows the two layers (main queue of indexes and separate priority-delay queues of references), supporting an implied update step when underlying queue storage changes).
Lafferty does not disclose compacting the main notification queue to remove tombstoned notifications in response to the main notification queue becoming full. Munipalle discloses compacting the main notification queue to remove tombstoned notifications in response to the main notification queue becoming full (paragraph [0022]: From time to time, a “compaction” process may be performed on the layered data structure to move data from one layer to another within the data structure. During compaction, TTL timestamps may be used to identify expired time-restricted data records. In some embodiments, these expired records may be marked (e.g., via a process sometimes called “tombstoning”) for eviction to one or more message queues for further handling; paragraph [0053]: the compaction process 210 is being performed on data blocks 310B and 310C since at least one criterion for performing compaction is met: the data blocks 310B and 310C both meet the size threshold for a data block to be compacted since both the data blocks are full). It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to modify the teaching of Lafferty by incorporating Munipalle’s performing compaction process by marking expired records via “tombstoning” process for eviction to one or more message queues when data blocks are full. The motivation would have been to improve the handling of time-restricted data records (Munipalle paragraph [0022]).
Regarding claim 14, Lafferty discloses
wherein the computer-readable storage device further comprises instructions for controlling the one or more computer processors to compact …, including updating each of the plurality of priority notification queues with references to the compacted main notification queue (paragraph [0254]: On Host B [1016] Producer function writes grain data to the pool [1012]. This generates a write notification in the AMF service which (among other things) causes a reference to the newly written grain to be sent to the transfer link connecting Gary on Host A to Gary on Host B. The link [1006] presently has a priority of 1 and the grain reference enters the priority delay queue [1008]; Note: Priority notification queues in AMF hold grain references/pointers (paragraph[0254]); those references point to grain indexes which are also represented in the write-notification queue. If compaction changes main-queue storage/indices (or advances ring/head pointers), the AMF runtime would update priority-delay queue entries (pointers) to remain consistent. The spec shows the two layers (main queue of indexes and separate priority-delay queues of references), supporting an implied update step when underlying queue storage changes).
Lafferty does not disclose to compact the main notification queue to remove tombstoned notifications in response to the main notification queue becoming full. Munipalle discloses to compact the main notification queue to remove tombstoned notifications in response to the main notification queue becoming full (paragraph [0022]: From time to time, a “compaction” process may be performed on the layered data structure to move data from one layer to another within the data structure. During compaction, TTL timestamps may be used to identify expired time-restricted data records. In some embodiments, these expired records may be marked (e.g., via a process sometimes called “tombstoning”) for eviction to one or more message queues for further handling; paragraph [0053]: the compaction process 210 is being performed on data blocks 310B and 310C since at least one criterion for performing compaction is met: the data blocks 310B and 310C both meet the size threshold for a data block to be compacted since both the data blocks are full). It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to modify the teaching of Lafferty by incorporating Munipalle’s performing compaction process by marking expired records via “tombstoning” process for eviction to one or more message queues when data blocks are full. The motivation would have been to improve the handling of time-restricted data records (Munipalle paragraph [0022]).
Regarding claim 20, Lafferty discloses
further comprising: compacting …, including updating each of the plurality of priority notification queues with new pointers to the main notification queue (paragraph [0254]: On Host B [1016] Producer function writes grain data to the pool [1012]. This generates a write notification in the AMF service which (among other things) causes a reference to the newly written grain to be sent to the transfer link connecting Gary on Host A to Gary on Host B. The link [1006] presently has a priority of 1 and the grain reference enters the priority delay queue [1008]; Note: Priority notification queues in AMF hold grain references/pointers (paragraph[0254]); those references point to grain indexes which are also represented in the write-notification queue. If compaction changes main-queue storage/indices (or advances ring/head pointers), the AMF runtime would update priority-delay queue entries (pointers) to remain consistent. The spec shows the two layers (main queue of indexes and separate priority-delay queues of references), supporting an implied update step when underlying queue storage changes).
Lafferty does not disclose compacting the main notification queue to remove tombstoned notifications in response to the main notification queue becoming full. Munipalle discloses the compacting the main notification queue to remove tombstoned notifications in response to the main notification queue becoming full (paragraph [0022]: From time to time, a “compaction” process may be performed on the layered data structure to move data from one layer to another within the data structure. During compaction, TTL timestamps may be used to identify expired time-restricted data records. In some embodiments, these expired records may be marked (e.g., via a process sometimes called “tombstoning”) for eviction to one or more message queues for further handling; paragraph [0053]: the compaction process 210 is being performed on data blocks 310B and 310C since at least one criterion for performing compaction is met: the data blocks 310B and 310C both meet the size threshold for a data block to be compacted since both the data blocks are full). It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to modify the teaching of Lafferty by incorporating Munipalle’s performing compaction process by marking expired records via “tombstoning” process for eviction to one or more message queues when data blocks are full. The motivation would have been to improve the handling of time-restricted data records (Munipalle paragraph [0022]).
Allowable Subject Matter
Claims 2 and 3 would be allowable if rewritten to overcome the rejection(s) under 35 U.S.C. 112(b) or 35 U.S.C. 112 (pre-AIA ), 2nd paragraph, set forth in this Office action and to include all of the limitations of the base claim and any intervening claims.
Conclusion
Any inquiry concerning this communication or earlier communications from the examiner should be directed to SISLEY N. KIM whose telephone number is (571)270-7832. The examiner can normally be reached M-F 11:30AM -7:30PM.
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, April Y. Blair can be reached on (571)270-1014. 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.
/SISLEY N KIM/Primary Examiner, Art Unit 2196 12/26/2025