A decentralized distributed data recall method and system based on logical neighborhood mapping and sequential consistency constraints

Abstract

The present application belongs to the technical field of distributed storage and data communication, and relates to a decentralized distributed data recall method and system based on logical neighborhood mapping and sequential consistency constraint. The method is executed in the kernel state storage subsystem of an operating system, and unified semantic modeling and scheduling control are performed on all types of memory and storage resources through a uniform resource entity abstraction layer and a uniform resource entity life cycle trigger model. The method sets a data positioning mechanism without a central index, a data discovery mechanism without broadcasting, and supports a data recovery system for migration through a data fragment structure with a verifiable source. Under the condition of no central index, the present application realizes deterministic data recovery through a node detection range limitation and a data fragment self-validation mechanism.

Description

Technical Field

[0001] This invention relates to the field of distributed storage and data communication technology, and in particular to a decentralized distributed data retrieval method and system based on logical neighborhood mapping and sequential consistency constraints. Background Technology

[0002] Existing distributed storage systems have the following problems during data recovery: (1) Central index dependency: Data location depends on centralized metadata service, and once it fails, it will affect the data recovery capability.

[0003] (2) Broadcast discovery is inefficient: Broadcasting or flooding query methods can lead to problems such as excessive network load, uncontrollable latency, and poor scalability.

[0004] (3) Data source cannot be verified: Existing systems have difficulty confirming whether data fragments come from legitimate paths or have been copied or forged.

[0005] (4) Security and migration conflict: Some systems achieve security by strongly binding nodes, but this also leads to problems such as difficulty in data migration and inability to recover after node changes.

[0006] Therefore, there is an urgent need in this field for a technical solution to address the above problems. Summary of the Invention

[0007] To address the aforementioned issues, this invention discloses a technical solution that enables deterministic data recovery under conditions without a central index, through a limited node detection range and a data fragment self-verification mechanism.

[0008] The technical solution of this invention is implemented as follows: The first aspect of this invention discloses a decentralized distributed data retrieval method based on logical neighborhood mapping and sequential consistency constraints. This method is executed in the operating system kernel-mode storage subsystem and performs unified semantic modeling and scheduling control of all types of memory and storage resources through a unified resource entity abstraction layer and a unified resource entity lifecycle triggering model. The method includes the following steps: Step 1: Before data and control flow enter the storage or computing path, the operating system kernel-mode storage subsystem constructs a Unified Resource Entity Abstraction Layer (URE Abstraction Layer) to perform normalized high-order semantic modeling of heterogeneous local or remote files, memory pages, vector data, model parameters, agent skills, and knowledge blocks. The operating system kernel-mode storage subsystem normalizes all physical and virtual memory resources into a unified resource entity descriptor and mounts physical page frames (PFN objects) to perform decoupling mapping, which is used to shield the differences in underlying hardware and establish unified addressing semantics. Step 2: The unified resource entity lifecycle triggering model maps system behavior into resource entity lifecycle events, which serve as state transition trigger signals in the resource entity lifecycle state machine. Step 3: Construct a resource entity space topology neighborhood in kernel mode and introduce a unified communication-memory mapping layer to normalize cross-end network communication behavior into virtualized entities that can be addressed and controlled at the resource entity level. The virtual entities establish a temporal causal binding relationship with the physical resource entity frame number through the resource entity table management structure; In the architecture design of step three, the virtualized entity specifically refers to the normalized projection of cross-end network communication behavior in the kernel; Step 4: The unified resource entity lifecycle trigger event sequence and the kernel monotonic clock are used together to generate a resource entity-level monotonic signature; When the edge sovereign hardware (HTA) is detected to be offline and not in real-time online, the cloud blind node cluster is allowed to continue to maintain service continuity and perform data fragment reconstruction. During the reconstruction process, the unified resource entity lifecycle state machine continuously records the resource entity lifecycle state transition sequence and generates a runtime state metric (RSM) corresponding to the resource entity. The runtime state metric (RSM) constitutes the RSM credential. The RSM credential adopts a defined quaternion data structure, which is explicitly expressed as RSM = {TS,PSDHash, PSS, StateLog}, where TS is a time series digest, PSDHash is a neighborhood topology digest, PSS is a monotonic signature, and StateLog is a state transition log digest. The operating system kernel-mode storage subsystem encapsulates the RSM credential and the intermediate data fragments generated by reconstruction into a temporary resource entity with a specific state ownership characteristic (STA), and forcibly pushes it into the kernel decoupled temporary storage latch layer (Suspended_Locked Layer, or SL) built in kernel mode for suspension and isolation. This removes the absolute dependence of the data retrieval path on the real-time online status of the hardware and prevents it from uncontrolled modification of the main memory. Once the sovereign hardware on the edge has returned to online status and detected a heartbeat, the asynchronous release primitive logic is activated. The temporary resource entity in the kernel decoupled temporary latch layer and the RSM certificate are concatenated and submitted to the edge. The edge then performs monotonicity and causal chain verification (delayed causal final review and confirmation) on the RSM certificate using its local resource entity lifecycle state machine. Only after the verification is passed is the certificate formally merged into the main memory, completing the streaming decentralized recall. The resource entity-level monotonic signature is used to characterize the irreversible evolution sequence of the resource entity's lifecycle in the time dimension and is bound to the unified resource entity descriptor for sequential consistency verification during the subsequent recovery process. The recovery process includes, but is not limited to, the data retrieval and reconstruction process in step six; Step 5: The system executes resource entity lifecycle erasure coding in the unified resource entity lifecycle trigger path; The lifecycle erasure coding of the resource entity is automatically activated in a unified trigger path; The resource entity lifecycle erasure coding calculation is applied to the set of abstract resource entities in the unified resource entity abstraction layer, thereby achieving a strong binding execution between the coding process and the resource entity lifecycle. In this invention, the physical and electrical characteristics of active fuse breaking and the black-box forensics mechanism are as follows: Figure 5 The causal feature sequence is the full running trajectory on the time axis, which is a dynamic time-series signal collected in real time in the kernel state (specifically including the memory resource entity state migration trajectory monitored by the life cycle trigger model, or the token clock signal sequence continuously generated on the bus or channel).

[0009] When the reset primitive issued by the operating system kernel storage subsystem causes a synchronous interruption in the data transmission chain, the underlying hardware bus (including but not limited to device control paths and protocol extension fields) will inevitably and spontaneously cause the bus to enter a high-impedance state (Hi-Z) or a secondary electrical signal behavior of continuously pulling the level low due to the sudden loss of the transaction clock.

[0010] The suspending signal characteristics generated by this electrical property can be directly used as an active fuse physical observation point for external black-box forensic auditing without relying on the upper-level software stack of the operating system. Even if the general operating system crashes or is completely hijacked by malicious objects, auditors can directly capture the high-impedance state (Hi-Z) physical imprint and the causal signature (CTC) sequence in the configurable register space using a logic analyzer or oscilloscope, achieving hardware-level deterministic causal tracing of sovereign asset hijacking events.

[0011] Step 6: When a remote node participates in data retrieval, its returned data (or the temporary data returned after the end-side sovereign hardware heartbeat is restored and re-enters the network) flows back to the kernel resource entity lifecycle state machine through the unified communication-memory mapping layer, and performs sequential consistency matching verification with the corresponding resource entity frame object in the local resource entity space topology neighborhood; the resource entity frame object is a physical or logical resource entity frame object that actually exists in the local memory topology neighborhood and has a deterministic memory resource entity frame number (PFNObject) addressing. If the matching verification is successful (i.e., the monotonic signature is monotonically increasing and does not violate the path constraint), the unified communication-memory mapping layer attaches the memory descriptor of the returned data to the physical resource entity table entry of the resource entity space topology neighborhood, registers it as a valid resource entity lifecycle extension event, and releases the streaming access permission; If the matching verification fails (i.e., invalid resource entity path disturbance events such as non-monotonic sequence, abnormal neighborhood constraint, abnormal resource entity descriptor verification, abnormal path constraint, or failed resource entity mapping verification are detected), the state machine immediately and irreversibly transitions to the permission-locked state, triggering the unified resource entity lifecycle triggering model to forcibly rewrite its access permissions, clearing its corresponding page table permission bit (PTE set to zero) and triggering TLB invalidation refresh, directly blocking all subsequent memory addressing actions in the resource entity table event source of the memory management unit (MMU), and completing the physical execution closed loop; The method further includes a service continuity control step of cascaded rights confirmation and asynchronous recall: when the end-side sovereign hardware is detected to be in an offline state that is not real-time online, the cloud blind node cluster is allowed to continue to maintain service continuity and perform data fragment reconstruction, generate unified resource entity fragments with specific state ownership characteristics, and forcibly push them into the decoupled temporary storage layer built in kernel mode for suspension and isolation, thereby removing the absolute dependence of the data recall path on the real-time online state of the hardware; after the end-side sovereign hardware is restored to the online state, the asynchronous release logic is activated, and the unified resource entity fragments in the decoupled temporary storage layer are submitted to the end side for delayed causal final review and rights confirmation, completing the streaming data recall; In this invention, a Uniform Resource Entity (URE) includes a physical resource entity object addressed by a physical resource entity frame number or a logical resource entity object with a uniform semantic description; in step six, a Uniform Resource Entity (URE) is a physical or logical resource entity frame object that actually exists in the local memory topology neighborhood and is addressed by a deterministic memory resource entity frame number (PFN).

[0012] Step 7: When the unified resource entity lifecycle triggering model detects an anomaly, it immediately triggers the kernel-level resource entity lifecycle controlled circuit breaker mechanism, and the operating system kernel-mode storage subsystem performs resource entity mapping release, resource entity physical zeroing, and lifecycle state freezing. The anomalies include: path hijacking anomalies such as detected sequence non-monotonicity, neighborhood constraint anomaly, resource entity descriptor verification anomaly, path constraint anomaly, or resource entity mapping verification failure. When the circuit breaker is triggered, the operating system kernel-mode storage subsystem issues a reset primitive (the reset primitive is a hardware-level forced reset or reset control instruction issued by the operating system kernel-mode storage subsystem), causing a synchronous interruption of all data transmission chains related to the target resource entity, forming an 'active transmission chain interruption causal feature'; at the same time, the system performs kernel-mode redirection and guides the protocol path of the communication path between storage and peripherals, writing the causal signature code (CTC) feature sequence as the result of unidirectional convergence of the causal feature sequence into the configurable register space, protocol extension field, and control message payload area associated with the device control path, thereby generating a specific causal fingerprint (CHF). The causal feature sequence is the full running trajectory on the time axis, which is a dynamic timing signal collected in real time in the kernel state (including the memory resource entity state migration trajectory monitored by the life cycle trigger model, or the token clock signal sequence continuously generated on the bus or channel); the causal signature code (CTC) sequence is a physical imprint actively output on the hardware bus by the system when an interrupt is executed. When the reset primitive causes a synchronous interruption in the data transmission chain, the underlying hardware bus (including but not limited to the device control path and protocol extension fields) suddenly loses the transaction clock, which causes the bus to enter a high impedance state (Hi-Z) or the level to be continuously pulled low in the physical circuit, thereby forming a suspended signal feature, which serves as an active fuse physical observation point for external black box forensic auditing; The device control path and protocol extension fields include, but are not limited to, PCIe, NVMe, USB, SATA, CXL, RDMA, or local high-speed switching matrix (Switch Fabric).

[0013] When the unified resource entity lifecycle trigger model detects an anomaly and triggers the circuit breaker mechanism, the subsequent physical blocking and signature injection actions are all forcibly driven and executed by the operating system kernel-mode storage subsystem.

[0014] Furthermore, in step one, the unified resource entity semantic structure includes operating system standard memory resource entities, large resource entity memory structures, GPU / NPU heterogeneous video memory resource entities, object physical resource entities in virtualization environments, and peripheral buffer resource entities mapped via DMA. The unified resource entity descriptor includes a resource entity physical state vector, a resource entity lifecycle state identifier, a memory or video memory resource type-independent identifier field, a virtualization environment mapping identifier, and a DMA or heterogeneous computing channel mapping handle. The unified resource entity descriptor is used to represent a unified semantic mapping for all computing and storage resources.

[0015] Furthermore, in step two, the system behaviors include memory reclamation behavior, resource entity swapping behavior, write-back behavior, asynchronous I / O completion behavior, DMA transfer completion event, and GPU / NPU memory scheduling event.

[0016] Furthermore, in step three, the cross-end network communication behavior includes network communication sockets, remote direct memory access channels, and zero-copy network buffers; The resource entity spatial topological neighborhood includes the physical mapping relationship of the unified resource entity descriptor, the consistency of the life cycle state, and the resource entity state migration history. The resource entity spatial topological neighborhood is used to replace the central index structure or broadcast discovery mechanism, mapping and normalizing network addressing behavior into page table access behavior, and transforming node communication behavior into page lifecycle migration behavior. In step four, the resource entity-level monotonic signature is generated by the event sequence generated by the unified resource entity lifecycle triggering model and the system monotonic clock, which is used to ensure the irreversibility and non-replayability of the resource entity state evolution path.

[0017] Furthermore, in step five, the unified resource entity lifecycle triggering model achieves unified control and normalized mapping of all storage and memory paths through the physical event source of the resource entity lifecycle in the operating system kernel. The physical event sources for the lifecycle of resource entities include the memory management unit resource entity table event source, the memory allocator resource entity block description event source, and the user-mode resource entity lifecycle backflow mechanism. The memory management unit resource entity table event source is the resource entity table creation event and resource entity missing event generated by the system when the memory management unit performs virtual address to physical address translation. This event source corresponds to the resource entity state transition in all VA→PA mapping processes, and when triggered, the corresponding resource entity is marked as at least one of the states including Active, Dirty, Reclaim, and Migratin. The memory allocator resource entity block description event source is the block-level description structure behavior generated by the system when the physical memory allocator performs resource entity allocation by intercepting the physical memory allocator. This includes continuous large resource entity allocation behavior, user-mode memory pool allocation behavior, GPU / NPU unified memory resource entity allocation behavior, and object physical resource entity allocation behavior in a virtualization environment. The user-mode resource entity lifecycle reflow mechanism includes eBPF kernel-mode behavior probe, resource entity table hardware state reflow mechanism, and time-consistent memory mapping synchronization mechanism. The unified triggering path includes the UPLT-triggered write-back path, resource entity reclamation path, resource entity migration path, and resource entity swap-out path.

[0018] Furthermore, the recovery process must simultaneously satisfy three types of consistency constraints: resource entity spatial topological neighborhood, resource entity-level monotonic signature, and unified resource entity descriptor; otherwise, the data reconstruction operation will be rejected.

[0019] Furthermore, when the resource entity lifecycle abnormal circuit breaker mechanism is triggered, the underlying reset primitive is executed by the operating system kernel-mode storage subsystem; The reset primitive causes a synchronous interruption in all data transmission chains related to the target resource entity, thus forming an active transmission chain interruption causal feature. While executing the reset primitive, the operating system kernel-mode storage subsystem forcibly injects a globally unique causal signature into the standard protocol layer of the peripheral communication path to leave a specific causal fingerprint at the physical storage and data path layers, and triggers observable bus high-impedance state or level suspension signal characteristics at the hardware bus layer by a synchronous interrupt. The causal signature (CTC) contains a non-fixed verification sequence with exclusive verification characteristics generated by the multidimensional state vector of the current abnormal page descriptor through a one-way hash function or a specific matrix mapping, and is forcibly injected into the standard protocol layer stored in the peripheral communication path; The standard protocol layer includes the PCIe configuration space standard register mapping layer, the NVMe command queue standard protocol field, and the device control channel control frame header field; Causal signature (CTC) forms a cryptographic fingerprint at the bus protocol layer that is strongly causally bound to the system software logic.

[0020] Furthermore, in step seven, the data fragment retrieval process also includes a linkage verification with the hardware execution path: Anchor mapping: Each data fragment identifier is cryptographically mapped and bound to at least one SEPS session anchor; State collision: During the data fragment reconstruction phase, the recall end initiates a hardware event chain comparison request for the fragment to the SEPS protocol stack; Path blocking: If the physical read path of the data fragment does not generate a hardware event chain trajectory that conforms to the current controlled memory domain, or if the memory resource entity to which the data fragment belongs is not in an authorized access state, a SEPS hardware-level termination instruction is triggered, and the recall permission of the physical node that serves as the physical carrier of the remote node is blocked.

[0021] Furthermore, the cascaded confirmation and asynchronous recall mechanism includes: When the edge-side sovereign hardware HTA is offline, the cloud-based blind node cluster continues to perform data fragment reconstruction; During the reconstruction process, the unified resource entity lifecycle state machine continuously records the resource entity lifecycle state transition sequence and generates the runtime state metric (RSM) corresponding to the resource entity. The runtime state metric includes at least one of the following: lifecycle state vector, resource entity-level monotonic signature (PSMS), and resource entity spatial topological neighborhood PSD feature summary. The cloud encapsulates runtime state metrics and unified resource entity fragments generated by reconstruction into temporary resource entities with state ownership characteristics (STA), and writes them into the decoupled temporary storage layer. Once the HTA is back online, the delayed rights confirmation will be completed using the runtime status metric as the final causal basis.

[0022] Furthermore, the method also includes introducing an adaptive spatiotemporal constraint operator into the sequential consistency constraint: when the timestamp delay returned by the target distributed node, which is the responder of the recall request, exceeds a preset security threshold or fails to respond, the operating system kernel-mode storage subsystem automatically switches to a degraded consistency mode; the current computation transaction is suspended through the kernel decoupled temporary latch layer, and a secondary redirection recall based on the logical neighborhood topology is triggered by the kernel storage driver layer.

[0023] The "target distributed node" referred to in this invention refers to a decentralized blind computing node, edge device, or cloud storage server that actually carries, stores, or reconstructs intermediate data fragments of the Unified Resource Entity (URE) in a decentralized distributed network topology.

[0024] The timestamp is a monotonically increasing clock semantic fingerprint asynchronously encapsulated and returned along with the data stream by the target distributed node based on its local high-precision hardware timer when it responds to a recall request or pushes data fragments from the endpoint. The timestamp directly serves as the original evolution data source for the time series summary (TS) within the runtime state metric RSM in the endpoint kernel state, used to perform monotonicity and causal chain verification of the logical neighborhood topology on the endpoint.

[0025] When the operating system kernel-mode storage subsystem detects that the timestamp returned by a specific target distributed node has an arrival delay exceeding the preset nanosecond / microsecond level safety threshold (Delta T_{safe}) due to network side channel congestion, physical network outage, or node crash, or is in a completely unresponsive state within the counting period, the system automatically switches to degraded consistency mode by activating the adaptive spatiotemporal constraint operator.

[0026] At this point, the kernel no longer synchronously waits for the causal confirmation signal of the node, but instead calls the routing_track_policy strategy to forcibly suspend and isolate the current computational transaction through the kernel decoupled temporary latch layer (SLL-122), and drives the kernel storage driver layer to initiate secondary redirection addressing and fragment retrieval to other heterogeneous and complementary target distributed nodes in the network based on the local topology neighborhood digest (PSDHash), thereby ensuring the continuous survival capability of the end side when individual distributed nodes die or Byzantine failure occurs.

[0027] The second aspect of this invention discloses a decentralized distributed data retrieval system based on logical neighborhood mapping and sequential consistency constraints. The retrieval system is deployed in an operating system and runs across multiple distributed physical nodes. The retrieval system includes a unified resource entity semantic abstraction module, a lifecycle event triggering module, a topological neighborhood construction and mapping module, a sequential consistency pipeline module, a logical neighborhood range detection module, a self-verifying multi-constraint reconstruction module, and a kernel-level circuit breaker blocking module. The unified resource entity semantic abstraction module is used to drive the operating system kernel-mode storage subsystem to abstract all physical and virtual memory resources into a unified resource entity semantic structure before data enters the storage or computing path, and to normalize all resources into a unified resource entity descriptor when they enter the system, so as to shield the differences in underlying hardware and establish a unified addressing semantic. The lifecycle event triggering module is used to map the user-mode behavior or peripheral bus signal of the operating system into a unified resource entity lifecycle event through a unified resource entity lifecycle triggering model, and input it into the kernel-mode storage subsystem of the operating system as a state transition trigger signal in the resource entity lifecycle state machine. The topology neighborhood construction and mapping module is used to construct the resource entity space topology neighborhood in the operating system kernel-mode storage subsystem, and introduce a unified communication-memory mapping layer to normalize cross-end network communication behavior into virtualized entities that can be addressed and controlled at the resource entity level. The virtualized entities establish a temporal causal binding relationship with the physical resource entity frame number through the resource entity table management structure. The sequential consistency pipeline module is used to atomically anchor the sequence of lifecycle triggering events of a unified resource entity to the kernel transaction boundary, so as to form a sequentially consistent data writing pipeline in the block device driver layer of the operating system kernel-mode storage subsystem. The logical neighborhood range detection module is used to dynamically converge and calculate a logical neighborhood containing at least one remote node based on the identifier of the target data fragment under the condition of no central metadata index, and send fragment recall detection requests only to the remote nodes within the logical neighborhood. The self-verifying multi-constraint reconstruction module is used to return the data to the kernel resource entity lifecycle state machine through the unified communication-memory mapping layer when remote nodes participate in data retrieval. The data is then matched and verified with the unified resource entity (URE) in the local resource entity space topology neighborhood. The operating system kernel-mode storage subsystem performs atomic retrieval and reconstruction of distributed data fragments when the consistency of resource entity surface descriptors, the consistency of resource entity lifecycle polymorphism, and the consistency of user-mode variable windows are satisfied simultaneously. The kernel-level circuit breaker module is used to immediately trigger the kernel-level resource entity lifecycle circuit breaker mechanism of the operating system when the unified resource entity lifecycle triggering model detects an access anomaly. The kernel-mode storage subsystem of the operating system executes the underlying reset primitive to synchronously interrupt the data transmission chain and form an observable specific causal fingerprint at the physical storage and data path layer.

[0028] Furthermore, when the heterogeneous computing unit performs semantic retrieval on the reconstructed data in the physical memory, the kernel-mode storage subsystem rigidly records the number of times the data asset is retrieved and invoked through the state transition counter of the resource entity lifecycle state machine, and generates an immutable audit log with causal feature codes, which serves as the data asset ownership certificate for the distributed physical node.

[0029] A causal feature sequence is a complete runtime trajectory along the timeline. It is a series of dynamic time-series signals collected in real time in kernel mode. Examples include the state transition trajectory of memory resource entities monitored by UPLT, or the Token Clock (TGC) signal sequence continuously generated on the bus by the W1 Magic Wand. It is a streaming, multi-dimensional time-series data.

[0030] When the system triggers a circuit breaker, the kernel storage subsystem will use the aforementioned dynamic "causal feature sequence" as an independent variable, perform unidirectional convergence through a specific nonlinear function (hash or matrix mapping), and forcibly write or lock it into hardware registers (such as PCIe configuration space, NVMe command queue head, eFuse).

[0031] Reset primitive: A hardware-level forced reset or reset control instruction issued by the operating system kernel-mode storage subsystem (e.g., pulling the reset pin low on the physical bus, or forcibly performing a hardware reset in the storage controller).

[0032] The Causal Trace Code (CTC) sequence is not the "input condition" that triggers an interrupt, but rather a "physical imprint (output result)" that the system actively leaves on the hardware bus when executing an interrupt. The closed loop of this mechanism is as follows: When the Unified Resource Entity Lifecycle Triggering Model detects malicious intrusion or path hijacking anomalies in kernel mode, it immediately triggers a circuit breaker mechanism. The kernel-mode storage subsystem issues a reset primitive, causing a synchronous interruption of all data transmission chains related to the target resource entity (forming an "active transmission chain interruption causal feature"). Simultaneously, the system forcibly injects a causal signature (CTC) into the peripheral communication path standard protocol layer. When the system executes the "reset primitive," causing a "synchronous interruption" of the data transmission chain, the underlying hardware bus (such as a PCIe link or DMA control line) inevitably experiences secondary electrical signal behavior in the physical circuitry due to the sudden loss of its transaction clock (such as the bus entering a high-impedance state Hi-Z or a continuously low level). This forms a "suspended signal feature." It is a secondary result caused by the interruption and also a physical observation point reserved for external black-box forensics.

[0033] Causal signature (CTC) sequence is written into the configurable register space, protocol extension field, and control message payload region associated with the device control path to generate a specific causal fingerprint (CHF).

[0034] The device control path and protocol extension fields include, but are not limited to, any one or more combinations of the following: PCIe bus, NVMe protocol, USB, Serial Advanced Technology Attachment (SATA), Compute Fast Link (CXL) architecture, Remote Direct Memory Access (RDMA) protocol, and Switch Fabric.

[0035] In this invention, the operating system (OS) serves as the foundational global environment, providing a standard user-mode and kernel-mode isolated environment, as well as basic network / process resource scheduling; The operating system kernel-mode storage subsystem, as the specific control and execution unit in the high-authority kernel layer of the operating system that manages I / O, memory descriptors and underlying hardware buses, is the main body for the physical distribution of core instructions; A distributed data retrieval system is a global business logic combination spanning multiple nodes from the edge to the cloud. It "relies" on the operating system environment and "controls / drives" the kernel-mode storage subsystem to complete physical blocking and retrieval in high-risk situations.

[0036] The advantages of this invention are as follows: Decentralized recovery capability: No need to rely on a central index; Deterministic data discovery: replacing broadcasting mechanisms with neighborhood mapping.

[0037] Data source verifiable: Data credibility is ensured through a labeling mechanism.

[0038] Supports migration and expansion: Allows node changes without affecting recovery capabilities.

[0039] Enhanced resistance to attacks: effectively prevents data forgery, replay attacks, and injection via unauthorized paths; High feasibility of engineering implementation: The technical solution of this invention is applicable to fields such as distributed storage, edge networks, and decentralized systems. Attached Figure Description

[0040] To more clearly illustrate the technical solutions in the embodiments of the present invention or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are only one embodiment of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0041] Figure 1 This is a block diagram illustrating the decentralized addressing principle based on the resource entity topological neighborhood restricted neighborhood graph (PSD) in a decentralized network according to an embodiment of the present invention. Figure 2 This is a flowchart illustrating the delayed causal final review and confirmation timing of rights under the heterogeneous grid disconnection state in an embodiment of the present invention. Figure 3 This is a diagram showing the lifecycle evolution and permission blocking state machine structure of the Unified Resource Entity (URE) in this embodiment of the invention. Figure 4 This is a schematic diagram of the timing causal binding mechanism of the unified communication-memory mapping layer (MMAPSyncChannel) in an embodiment of the present invention; Figure 5 This is a flowchart illustrating the chip-level peripheral bus signature injection process under the kernel circuit breaker mechanism in this embodiment of the invention. Detailed Implementation

[0042] The technical solutions of the present invention will be clearly and completely described below with reference to the embodiments and accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0043] Unless otherwise defined, all technical and scientific terms used in this invention have the same meaning as commonly understood by one of ordinary skill in the art to which this invention pertains; the terminology used in the detailed description is for the purpose of describing particular embodiments only and is not intended to limit the invention; the terms “comprising” and “having” and any variations thereof in the specification and claims of this invention are intended to cover non-exclusive inclusion.

[0044] In the description of specific embodiments of the present invention, technical terms such as "first" and "second" are used only to distinguish different objects and should not be construed as indicating or implying relative importance or implicitly specifying the number, specific order, or primary and secondary relationship of the indicated technical features. In the description of the embodiments of the present invention, "multiple" means two or more, unless otherwise explicitly defined.

[0045] In this invention, the reference to "embodiment" means that a specific feature, structure, or characteristic described in connection with an embodiment may be included in at least one embodiment of the invention. The appearance of this phrase in various places in the specification does not necessarily refer to the same embodiment, nor is it a separate or alternative embodiment mutually exclusive with other embodiments. It will be explicitly and implicitly understood by those skilled in the art that the embodiments described in this invention can be combined with other embodiments.

[0046] In the description of the embodiments of this invention, the term "and / or" is merely a description of the relationship between associated objects, indicating that three relationships can exist. For example, A and / or B can represent: A existing alone, A and B existing simultaneously, or B existing alone. Additionally, in this invention, the character " / " generally indicates that the preceding and following associated objects have an "or" relationship.

[0047] Throughout this invention, numerical values ​​represent approximate measures or limits of a range to cover minute deviations from a given value, as well as embodiments with approximately the mentioned value and embodiments with the exact mentioned value. Except for the working examples provided at the end of the detailed description, all numerical values ​​of parameters (e.g., quantities or conditions) in this specification (including the appended claims) should be understood to be modified in all cases by the term “about,” regardless of whether “about” actually appears before the numerical value. “About” indicates that the stated numerical value allows for some minor inaccuracy (approaching the exact value in some way; approximately or reasonably approaching the value; almost). If the inaccuracy provided by “about” is not otherwise understood in this general sense in the art, then “about” as used in this invention at least indicates a variation that can be produced by common methods of measuring and using such a parameter. For example, “about” may include a variation of less than or equal to 5%, optionally less than or equal to 4%, optionally less than or equal to 3%, optionally less than or equal to 2%, optionally less than or equal to 1%, optionally less than or equal to 0.5%, and in some respects, optionally less than or equal to 0.1%.

[0048] Additionally, the disclosure of the range includes the disclosure of all values ​​across the entire range and the disclosure of further subdivided ranges, including the endpoints and subranges given for these ranges.

[0049] To address various issues in existing data retrieval systems, this invention proposes a technical solution. This solution employs a data location method without a central index, utilizing a non-broadcast data discovery mechanism and a data fragment structure with verifiable sources to support a migrated data recovery system. The technical solution includes a logical neighborhood-based limited detection mechanism, a neighborhood load adjustment mechanism, a conditionally self-proving data fragment verification mechanism, a node identifier tolerance verification mechanism, a hierarchical detection and non-broadcast communication mechanism, a lightweight metadata snapshot mechanism, a sequential consistency constraint mechanism, a memory-level data reconstruction mechanism, and system stability constraints, as detailed below: I. Logical Neighborhood-Based Limited Detection Mechanism The system constructs a logical neighborhood mapping relationship based on the data fragment identifier to limit the node detection range.

[0050] Each data fragment contains a file identifier (File_UUID) and a fragment number (Shard_Index).

[0051] The system generates a logical location identifier (LogicalLocator) based on the above information.

[0052] The detection process is as follows: 1. The node initiates a recovery request; 2. Determine the target neighborhood based on the logical location identifier; 3. Only send probe requests to nodes within the neighborhood; 4. Receive candidate fragment responses.

[0053] The limited detection mechanism also includes a neighborhood load adjustment mechanism: when the load within the logical neighborhood serving as the detection range exceeds a preset threshold, this recall system expands the coverage of the logical neighborhood or performs offset mapping on the logical neighborhood to distribute the pressure of cross-network requests. This mechanism effectively avoids network-wide broadcasting, significantly reduces network load, and provides a deterministic data fragment discovery path.

[0054] The discovery and detection behavior of the remote node is strictly limited to a local range based on the preset logical neighborhood mapping relationship, rather than being broadcast across the entire network; and when the detection behavior triggers subsequent hardware linkage verification and blocking, the direct object of the blocking is the distributed physical node that serves as the physical carrier of the remote node.

[0055] II. Conditional Self-Proving Data Fragment Verification Mechanism Each data fragment contains a validation tag (TextTag): TextTag=HMAC(K_derived,File_UUID⊕Shard_Index⊕Node_ID⊕Seq_ID); The verification process is as follows: When receiving fragments, the system performs verification tag check and source consistency judgment.

[0056] The conditionally self-proving data fragment verification mechanism has the following mechanisms: (1) Source consistency verification: used to determine whether the fragment is generated by a legitimate path.

[0057] (2) Migration rebinding mechanism: In a legitimate migration scenario, the verification label is allowed to be regenerated under the new node identifier and the verification context is updated.

[0058] The above mechanisms can prevent data forgery, support node migration, and avoid data deadlock.

[0059] Verification tags are used to verify the consistency of data sources, but do not restrict legitimate migration behavior.

[0060] III. Node Identifier Tolerance Verification Mechanism The system supports tolerance-based verification of Node_ID. During the verification process, identifier changes within a preset range are allowed, using either set matching or range-based determination.

[0061] This mechanism can improve system stability, reduce the false positive rate, and adapt to changes in the node environment.

[0062] IV. Layered Detection and Non-Broadcast Communication Mechanisms The system employs a multi-layered detection path, including: Local neighborhood detection; Extended neighborhood detection; Historical path retrospective exploration.

[0063] Multi-layered detection mechanisms can improve recovery success rates, avoid broadcast storms, and support weak network environments.

[0064] V. Lightweight Metadata Snapshot Mechanism The distributed physical node maintains a lightweight metadata snapshot locally, which includes historical remote node records, data distribution summary, and the most recently successfully recalled path; This design not only significantly reduces the cold start cost of the distributed physical nodes in a decentralized metadata index environment, but also greatly improves the efficiency of cross-end data fragment recovery and assembly.

[0065] In actual operation, the distributed physical nodes can directly target the corresponding remote nodes and their physical carriers that have successfully provided fragments based on the historical records in the local snapshot, thereby locking the detection range within a precise logical neighborhood in the first stage.

[0066] VI. Sequential Consistency Constraint Mechanism Each data fragment contains a sequence identifier (Seq_ID), which indicates the order in which it was generated or distributed.

[0067] The constraints are as follows: During the verification process, the system compares the Seq_ID of the current fragment with the sequence of received fragments to determine whether they meet the preset order consistency relationship.

[0068] Illegal determination: When a sequence identifier rollback, sequence discontinuity, or abnormal jump is detected, the data fragment is rejected from participating in data recovery.

[0069] The above mechanisms can prevent old data replay, prevent path rollback attacks, and ensure the consistency of the data recovery process.

[0070] Sequential consistency is used to verify the relationship between data generation, and does not involve global consistency protocols or distributed consensus mechanisms.

[0071] VII. Memory-level Data Reconstruction Mechanism When the preset erasure coding recovery conditions are met, the operating system kernel-mode storage subsystem atomically performs the reconstruction and assembly of distributed data fragments within the stateless transient resource entity buffer (physical memory domain) of the end device.

[0072] The erasure coding recovery condition specifically satisfies the following mathematical logic relationship: Shard_Count ≥ k; Where Shard_Count represents the total absolute number of legitimate data fragments (Shards) from each of the remote nodes that the current local node successfully received and passed the self-verification multi-constraint verification through the logical neighborhood detection. The "≥" sign in the above formula is used to limit the minimum number of boundaries that trigger the refactoring behavior; k represents the core reconstruction threshold (i.e. the minimum number of data blocks / fragments required to recover the complete original data stream) in the preset erasure coding (EC) system. k is a positive integer, and its value is strictly less than or equal to the total number of data blocks m initially divided in the distributed storage system.

[0073] The operating system kernel-mode storage subsystem is only allowed to activate the memory reconstruction pipeline when the number of valid fragments Shard_Count reaches or exceeds the threshold k, thereby ensuring deterministic recovery efficiency in a decentralized environment.

[0074] The above mechanisms can reduce I / O overhead, improve recovery efficiency, and reduce disk dependency.

[0075] VIII. System Stability Constraints The system's neighborhood mapping mechanism and fragment verification mechanism are both adaptive, enabling them to adapt to different network environments and improve system stability.

[0076] The technical solution of the present invention will be described in more detail below through embodiments.

[0077] It should be noted that the scheme proposed in this embodiment is executed in the operating system kernel-mode storage subsystem, and performs unified semantic modeling and scheduling control of all types of memory and storage resources through the Unified Page Abstraction Layer (UPAL) and the Unified Page Lifecycle Trigger (UPLT).

[0078] Furthermore, in this embodiment, the underlying logical judgment of the distributed resource access and control architecture is abstracted by the operating system kernel as a physical order monotonic logical constraint relationship. Any access request x to the unified resource entity (URE) and resource r must pass the joint verification of three physically orthogonal axes (space, time, and state) in the kernel mode to be effective. The joint verification control primitive is expressed as follows: Access(x, r) = ∡(Ψspace(x, r) ∧ Φtime(r) ∧ Ωstate(r)) Where: Ⅱ(⋅) is the conditional judgment indicator function executed by the kernel-mode storage subsystem (if the judgment is true, the physical control channel is released; if the judgment is false, the kernel circuit breaker is triggered immediately).

[0079] Ψspace(x, r) represents the spatial topological bounding constraints based on the restricted neighborhood graph in the resource entity table management structure (PFN mapping table). The kernel-mode storage subsystem achieves non-broadcast data discovery by querying whether the current request source x falls within the restricted neighborhood topological closure formed by asset access relationships, lifecycle association relationships, and causal dependencies.

[0080] Φtime(r) represents the temporal monotonically increasing constraint between the kernel monotonic clock signature and the permanent sequence signature (PSS) in the Physical Sequence Monotonic Structure Record (PSMSRecord), used to comprehensively intercept temporal replay attacks and Spectral Fragment injection.

[0081] Ωstate(r) represents the underlying physical fields (timestamp TS, neighborhood topology digest PSDHash, permanent sequence signature PSS, and state transition log digest) in the Physical Sequence Monotonic Structure Record (PSMSRecord). Causal consistency physical comparison constraints of StateLogHash.

[0082] This embodiment achieves deterministic positioning without a central index through the linkage of the aforementioned kernel control primitives and establishes hardware-level circuit breaker defense.

[0083] Those skilled in the art should understand that the specific values ​​and specific engineering binary code implementations of the parameter matrix mapping, the specific causal signature (CTC) generation matrix, and the allocation and scheduling weights of kernel-mode page frames described in the above embodiments can be directly implemented by those skilled in the art through conventional engineering experiments or software programming, based on the system architecture and control flow logic disclosed in this specification, combined with existing common sense of general operating system kernel underlying development and standard bus protocol specifications (such as PCIe / NVMe specifications).

[0084] The variations in the specific engineering implementations described above do not depart from the framework of the core technical solution of this invention. The technical solutions disclosed in this specification are sufficient to provide complete, clear, and explicit technical guidance for those skilled in the art to implement and reproduce the methods and systems of this invention.

[0085] In one specific embodiment, such as Figure 1 As shown, a decentralized distributed data retrieval method based on logical neighborhood mapping and sequential consistency constraints is executed in the operating system kernel-mode storage subsystem. Its complete execution flow throughout its entire lifecycle is as follows: S1, Decentralized Location and Neighborhood Addressing Stage: Before data enters the storage path, the operating system kernel-mode storage subsystem constructs a unified resource entity abstraction layer and instantiates it in the kernel as a restricted neighborhood graph (PSD topology graph structure) composed of resource access and causal dependencies. For example... Figure 1 As shown, the system uses this static topology constraint layer to limit the detection range of distributed nodes, replacing global broadcasting, and realizing deterministic data addressing without a central index.

[0086] S2, Offline Suspension and Delayed Causal Final Judgment and Confirmation Stage: such as Figure 2 As shown, when the end-side sovereign hardware experiences extreme offline disconnection, the cloud-based blind-state computing cluster continues to maintain service continuity and performs data fragment reconstruction, generating RSM credentials (Physically Ordered Monotonic Structure Records, PSMSRecord). The operating system kernel-mode storage subsystem forcibly pushes the aforementioned credentials into a kernel-mode temporary latch layer for suspension and isolation until the heartbeat is restored, at which point the asynchronous release primitive is activated to perform delayed causal final verification and ownership confirmation, and then the credentials are merged into main memory.

[0087] S3, Lifecycle Evolution and State Machine Defense Phase: such as Figure 3As shown, during the recall and confirmation process described above, the flow of the Unified Resource Entity (URE) is monitored in real time by the lifecycle state machine. If a timing constraint anomaly or descriptor consistency check failure is detected, the state machine directly bypasses the process scheduler, triggers the MMU-level blocking mechanism, and executes kernel inter-core interrupt TLB invalidation refresh, blocking illegal access at the hardware addressing level and forcibly migrating to the lifecycle termination state.

[0088] S4, memory-mapped channel timing causality binding phase: such as Figure 4 As shown, access initiated by user-space heterogeneous resource consumers is converged on the resource range by the unified communication-memory mapping layer based on PSD topological neighborhood constraints, and the management structure locks the PFN physical page frame. When anomalies such as timing non-monotonicity are detected, the channel calls the kernel module to achieve kernel-space redirection and hardware-level access blocking by clearing page table entries and broadcasting a TLB refresh, triggering a controlled circuit breaker.

[0089] S5, Hardware Bus Feature Code Injection and Physical Blocking Stage: (e.g.) Figure 5 As shown, following the aforementioned controlled circuit breaker action, to prevent malicious objects from completely hijacking the software stack, the Lifecycle Triggering Model (UPLT) captures multi-dimensional state vectors and generates globally exclusive causal signatures (CTCs). The kernel-mode redirection mechanism forcibly writes the CTC signature sequence into the configurable register space and protocol extension fields associated with the device control path, using the underlying bus protocol to induce at least one observable hardware suspension characteristic such as the bus physical circuit entering a high-impedance state or a bus silent state, thereby locking the data channel at the physical hardware path level.

[0090] The method of this embodiment will now be described in detail: Step 1: Unified Resource Entity Abstraction Modeling (UPAL) Before data enters the storage or computing path, the system abstracts all physical and virtual memory resources into a unified resource entity semantic structure (UnifiedPageEntity, UPE). The UPE does not distinguish the following underlying implementation differences: Operating system standard memory resource entity (BasePage); HugePage is a large resource entity memory structure. GPU / NPU heterogeneous memory resource entities; Object Physical Resource Entities (GPPs) in a virtualized environment; Peripheral buffer resource entities mapped via DMA; All of the above resources are normalized into a Unified Page Descriptor (UPD) when they enter the system, which is used to shield the differences in the underlying hardware and establish a unified addressing semantics. Step 2: Triggering the Unified Scheduling Step (UPLT) during the resource entity lifecycle. The system does not rely on specific I / O paths or kernel subsystems for implementation. Instead, it abstractly models the state transition behavior of all resource entities through the Unified Resource Entity Lifecycle Triggering Model (UPLT). UPLT maps the following system behaviors to resource entity lifecycle events: Memory reclamation behavior (reclaim); Resource entity swap behavior; Writeback behavior; Asynchronous I / O completion behavior (AIO / io_uring); DMA transfer complete event; GPU / NPU memory scheduling events.

[0091] All of the above behaviors no longer exist as independent mechanisms, but are uniformly transformed into state transition trigger signals in the resource entity lifecycle state machine; Step 3: Unified Mapping of Network-Resource Entity Space (UPMLayer) When constructing the PageSpatialDomain (PSD) in kernel mode, the system does not directly use physical memory as the sole semantic space. Instead, it introduces a Unified Packet-to-PageMapping Layer (UPM) to normalize cross-end network communication behavior into resource entity-level addressable control entities, including: Network communication socket; Remote Direct Memory Access Channel (RDMA); Zero-copy network buffer.

[0092] All of the aforementioned cross-end communication behaviors are mapped to Virtual Unified Resource Entities (URE) (VirtualPageEntity, VPE) in kernel mode, and further establish a temporal causal binding relationship with the Physical Resource Entity Frame Number (PFN) through the resource entity table management structure.

[0093] It should be noted that the resource entity space topology neighborhood mentioned in this embodiment is essentially a control flow graph in kernel mode where cross-network data transmission paths are degenerated into resource entity table addressing paths. The resource entity space topology neighborhood will transform network addressing behavior into resource entity table access behavior; node communication behavior into resource entity lifecycle migration behavior.

[0094] Step 4: Resource Entity-Level Monotonic State Signature Binding Step (PSMS) The system generates a resource entity-level monotonic signature (PSMS) by combining the unified resource entity lifecycle trigger event sequence (UPLTEventStream) with the kernel monotonic clock. PSMS is used to characterize the irreversible evolution sequence of a resource entity's lifecycle over time and is bound to the Unified Resource Entity Descriptor (UPD) for sequential consistency verification during subsequent recovery processes.

[0095] Step 5: Resource Entity Lifecycle Erasure Coding and Kernel Binding Execution Steps (PLEC) The system performs Page-Lifecycle Erasure Coding (PLEC) in the unified resource entity lifecycle trigger path. PLEC does not exist as a standalone computing module, but is automatically activated through the following unified triggering path: UPLT-triggered write-back path; Resource entity recycling pathways; Resource entity migration path; Resource entity swapping path.

[0096] The encoding computation is applied directly to the UPAL abstract resource entity set, rather than the specific hardware implementation path, thereby achieving a strong binding execution between the encoding process and the lifecycle of the resource entities; Step Six: Network Backflow and Distributed Recall Closed Loop When a remote node participates in data retrieval, its returned data is not treated as an independent network result, but is instead flowed back to the kernel resource entity lifecycle state machine through the UPM layer and matched and verified with the Unified Resource Entity (URE) in the local PSD. If a match is found, the communication behavior corresponding to the remote node is registered as a valid resource entity lifecycle extension event.

[0097] If a match is successful, the memory descriptor (sk_buff or RDMA scatter table) of the network packet is directly mounted to the Physical Resource Entity (PTE) table entry of the PSD through the UPM layer, and registered as a valid resource entity lifecycle extension event; otherwise, the UPLT state machine is triggered to forcibly rewrite the access permissions (PROT_NONE) of the virtual unified resource entity (URE), directly blocking all subsequent memory addressing actions on the hardware MMU side, as a physical execution closed loop of the invalid resource entity path disturbance event.

[0098] Step 7: Resource Entity-Level Anomaly Consistency Circuit Breaking Procedure When any of the following anomalies are detected: UPAL semantic mapping conflict; PSMS sequences are not monotonic; PSD neighborhood structural fracture; The UPLT trigger chain was interrupted abnormally; The system immediately triggers the kernel-level resource entity lifecycle circuit breaker mechanism and executes: Unmap resource entities; Physically clear the resource entity; Freeze the lifecycle state.

[0099] In this embodiment, the Uniform Resource Entity Descriptor (UPD), as the core structure of the Uniform Resource Entity Abstraction Layer (UPAL), is used to represent a unified semantic mapping of all computing and storage resources, and includes: Resource entity physical state vector; Resource entity lifecycle status identifier; A field unrelated to memory or video memory resource types; Virtual environment mapping identifier; DMA or heterogeneous computing channel mapping handle.

[0100] The Uniform Resource Entity Descriptor (UPD) is used to ensure that all underlying resources are abstracted into a uniform resource entity semantic structure before entering the system, without preserving hardware-specific semantics.

[0101] In this embodiment, the resource entity spatial topological neighborhood (PSD) is determined by the physical mapping relationship of the unified resource entity descriptor (UPD), the consistency of the lifecycle state, and the resource entity state migration history, and is used to replace the central index structure or broadcast discovery mechanism.

[0102] In this embodiment, the resource entity-level monotonic signature (PSMS) is generated by the event sequence generated by the Unified Resource Entity Lifecycle Triggering Model (UPLT) and the system monotonic clock, which is used to ensure the irreversibility and non-replayability of the resource entity state evolution path.

[0103] In this embodiment, the equivalent execution channel of the Unified PageLifecycleTrigger (UPLT) is not an abstract scheduling model, but rather achieves unified control and normalized mapping of all storage and memory paths through PageLifecyclePhysicalEventSources (PLPES) in the operating system kernel, including: a. Memory Management Unit Resource Entity Table Event Source (MMUEventSource) By intercepting the resource entity table creation event and the resource entity missing (PageFault) event generated by the memory management unit (MMU) when performing virtual address to physical address translation, these events are used as the first type of physical event source triggered by the resource entity lifecycle. This event source corresponds to the state transition of all resource entities in the VA→PA mapping process, and when triggered, marks the corresponding resource entity as one or more of the following state combinations: Active, Dirty, Reclaim, Migrating. b. Memory Allocator Resource Entity Block Description Event Source (AllocatorEventSource) By intercepting the block-level description structure (including but not limited to the resource entity block allocation result or semantic equivalent structure of the BuddyAllocator system) generated by the physical memory allocator when performing resource entity allocation, it is uniformly mapped as the second type of event source in the resource entity lifecycle. The event sources further cover continuous large resource entity (HugePage) allocation behavior, user-mode memory pool allocation behavior, GPU / NPU unified memory resource entity allocation behavior, and object physical resource entity allocation behavior (GPP) in virtualization environment.

[0104] All of the above allocation behaviors are normalized into unified resource entity lifecycle events, without preserving underlying implementation differences; c. User-mode resource entity lifecycle reflow mechanism For user-space storage acceleration paths, the system no longer uses logical synchronization or abstract reflow, but instead achieves forced lifecycle normalization through the following three types of kernel-level event sources: c.1 eBPF kernel-mode behavior probe By using kernel-mode eBPF probes to trace the execution path of user-mode storage behavior, user-mode memory pool allocation and release behavior is converted into a kernel observable event stream. c.2 Resource Entity Table Hardware State Backflow Mechanism (PTEFeedback) The resource entity lifecycle status interrupt signal is triggered by the hardware status bits in the resource entity table structure (IOMMU or internal MMU resource entity table entry) of the resource entity table entry and the heterogeneous computing unit (GPU / NPU). The hardware status bits include, but are not limited to: Dirty Bit in the Heterogeneous Resource Entity Table; Accessed / Referenced Bit; Hardware validity / presence bit. Memory barriers and invalidation synchronization markers (TLB Invalidation / Flush Indicator). Remote Direct Memory Access (RDMA) and hardware transaction success count status flags for the bus controller.

[0105] This mechanism triggers a low-level hardware interrupt signal through the state transition of hardware state bits, forcing the state evolution events of the heterogeneous computing units in the zero-copy dynamic buffer, independent video memory space, or unified virtual addressing (UVA) space executed in user mode to be asynchronously written back or synchronously reported to the resource entity lifecycle state machine of the operating system kernel-mode storage subsystem in real time and without blind spots.

[0106] This ensures that even when heterogeneous computing units bypass the main CPU and directly perform software or hardware passthrough, or utilize user-space storage acceleration paths (including but not limited to GPU Direct Storage, physical bus passthrough topology, etc.) for data retrieval and reconstruction without kernel intervention, their physical execution trajectory is still subject to the rigid lifecycle constraints and auditing of the Unified Resource Entity Lifecycle Triggering Model (UPLT) throughout the entire time period. This fundamentally eliminates the behavior of heterogeneous computing power paths bypassing kernel control in user space to maliciously evade control or hijack high-dimensional paths.

[0107] c.3 Timing-consistent memory mapping synchronization mechanism (MMAPSyncChannel) By changing the monotonic timing counter of the mmap mapping region, the consistency of the resource entity state transition between user mode and kernel mode is checked, thereby ensuring that user mode memory operations cannot escape the UPLT lifecycle control domain.

[0108] All user-space storage acceleration paths are uniformly unified into a Page-level Traceable Lifecycle Flow under UPLT control.

[0109] All the above event sources are uniformly converted into page-level traceable physical lifecycle flow with physical lifecycle states under the action of UPLT, thereby realizing unified lifecycle constraints on all memory and storage paths.

[0110] In this embodiment, the recovery process must simultaneously satisfy three types of consistency constraints: PSD, PSMS, and UPD; otherwise, the data reconstruction operation will be rejected.

[0111] When the resource entity lifecycle anomaly circuit breaker mechanism is triggered, it not only manifests as a logical state change, but also forms an observable specific causal fingerprint (CHF) at the physical storage and data path layers, including: a. Protocol-level asynchronous reset and signature injection mechanism When the system triggers a circuit breaker for a resource entity's lifecycle, it generates a globally unique causal trace code (CTC) through the unified communication control path and injects it into the standard protocol layer of the peripheral communication path, including but not limited to: PCIe configuration space standard register mapping layer; NVMe command queue standard protocol fields; Device control channel control frame header fields; The generation of the causal signature code (CTC) satisfies the following conditions: a.1, derived from the current lifecycle state of the Unified Resource Entity Lifecycle Triggering Model (UPLT); a.2, Bind to the Physical Resource Entity Frame Number (PFN) / Virtual Uniform Resource Entity (URE) VPE of the current Uniform Resource Entity (URE); a.3, It has the ability to propagate consistently across devices; a.4, and the causal signature CTC contains a non-fixed verification sequence with exclusive verification characteristics generated by the multi-dimensional state vector of the current abnormal resource entity descriptor through a one-way hash function or a specific matrix mapping, thereby forming a cryptographic fingerprint with strong causal binding to the system software logic at the bus protocol layer.

[0112] The causality identification mechanism in this embodiment is as follows: During system circuit breaker failure, if an external device (such as a solid-state drive controller or bus arbiter) detects the CTC sequence, its behavior is physically determined as an "active page lifecycle control interrupt event"; otherwise, it is classified as an uncontrolled hardware anomaly or power failure behavior. This uses physical fingerprinting to distinguish between "normal I / O degradation," "hardware failure," and "active page lifecycle circuit breaker control behavior."

[0113] b. Causal characteristics of active transmission link interruption This reset primitive will cause a synchronization interruption in all data transmission chains related to the target resource entity, including: b.1, DMA transfer queue suspended; b.2, The write transaction to the storage controller is aborted; b.3, The PCIe data stream transmission window is closed.

[0114] c. Characteristics of media layer pending signals driven by kernel soft interrupts At the physical media layer, a pending level signal triggered by the kernel soft interrupt mechanism can be observed, satisfying the following conditions: c.1, This is not a power-level power-off behavior; c.2 is not a hardware malfunction behavior; c.3, is a controlled interrupt sequence actively generated by the resource entity lifecycle triggering model.

[0115] In this embodiment, specific causal fingerprints are used to distinguish the following three types of system behavior, thereby enabling auditable differentiation of abnormal states of storage paths: Normal I / O degradation; Hardware failure or power outage; Active resource entity lifecycle circuit breaker control behavior.

[0116] In some preferred embodiments, the data fragment retrieval process further includes a linkage verification step with the hardware execution path: a. Anchor mapping: Each data fragment identifier is cryptographically mapped and bound to one or more SEPS session anchors (SessionAnchors); b. State collision: During the data fragment reconstruction phase, the recall end initiates an HEC (Hardware Event Chain) comparison request for the fragment to the SEPS protocol stack; c. Path blocking: If the physical read path of the fragment does not produce an HEC trajectory that matches the current CMD (Controlled Memory Domain) expectation, or if the memory resource entity to which the fragment belongs is not in an "authorized access state", then the SEPS hardware-level termination instruction is triggered, and the recall permission of the physical node is blocked.

[0117] In a preferred embodiment, the present invention also introduces a Unified Resource Entity (URE) abstract model for unified representation and governance of underlying resources in operating systems and heterogeneous computing environments.

[0118] The Unified Resource Entity (URE) is used to replace the traditional approach of modeling specific resource types separately. Its core principle is: All schedulable, accessible, or mapped computing resources are abstracted into resource entity objects under a unified semantics.

[0119] In practical applications, each Uniform Resource Entity (URE) includes at least the following attributes: Resource Identifier; Address mapping descriptor; Access Control Descriptor; Lifecycle State; Runtime Context Binding; in: Lifecycle status is used to indicate whether a resource is in the creation, activation, migration, or destruction state; The runtime home context is used to bind the calling body and execution environment of a resource during execution.

[0120] In this embodiment, URE serves only as a unified abstraction layer, and its specific physical or virtual resource forms include, but are not limited to, the contents shown in the table below:

[0121] In this embodiment, the operating system kernel-mode storage subsystem manages URE in a unified manner through its internally built kernel-level resource scheduling module, as follows: Resource mapping phase: Mapping different types of underlying resources to a unified URE object; Access control phase: URE permissions are verified through the Unified Access Control Interface (UACI). State change phase: Update the URE lifecycle state when accessing or migrating resources; Audit logging phase: Record URE access behavior to the runtime state audit log.

[0122] In a preferred embodiment, the Unified Resource Entity (URE) works in conjunction with the runtime state measurement system: When each URE object is accessed or its execution state transitions, its multidimensional dynamic characteristics are captured by the Unified Resource Entity Lifecycle Triggering Model (UPLT) to generate a corresponding runtime behavior record. The runtime behavior record is used to construct the Execution Fingerprint Vector (EFV).

[0123] The execution fingerprint vector (EFV) is further used to verify the data order consistency between the execution end and the distributed nodes. At the same time, the execution fingerprint vector (EFV) is provided as an input parameter to the kernel-mode storage subsystem to evaluate the nonlinear chaotic evolution state and dynamic accumulated overhead during system operation, serving as a global metric for adaptively triggering the controlled circuit breaker mechanism or degraded call trajectory of the system.

[0124] This embodiment introduces a unified resource entity (URE) abstract model, achieving deep decoupling of heterogeneous resource types, enhancing the scalability of the kernel architecture, strengthening the consistency of global access control, and providing a standardized underlying foundation for higher-level data governance and runtime security policies. Resource type decoupling: Multiple heterogeneous resources such as physical page frames (Page), direct memory access peripheral buffer (DMA), heterogeneous computing memory (GPU), and remote direct memory access (RDMA) are uniformly converged into a single high-order semantic modeling space in kernel mode, eliminating the specific differences of the underlying hardware interaction protocol.

[0125] Enhanced scalability: When the system introduces new storage media or computing resource types, it is only necessary to establish the corresponding addressing semantic mapping in the unified resource entity abstraction layer. No modifications are required to the kernel core's sequential consistency scheduling and logical neighborhood convergence core algorithms, thus achieving modular and seamless expansion.

[0126] Strengthening the consistency of access control: All access requests for heterogeneous resources in the data retrieval and flow path are forcibly directed and constrained to the execution of a unified control path consisting of a unified access control interface (UACI) and a lifecycle state machine, ensuring the strength of the system's sovereignty security defense in all scenarios, including standard operation, extreme offline, and controlled circuit breaking.

[0127] Provides general upper-level high-level foundation support: By providing normalized abstract feature output and control flow primitive interface to the outside, it can seamlessly support upper-level external trusted audit agents or advanced runtime security detection modules to perform full behavior trajectory measurement, consistency asynchronous verification and adaptive storage governance, ensuring the dynamic evolution continuity of the entire decentralized computing network under a more macro-architecture.

[0128] It should be noted that Page is only one specific implementation of URE and does not constitute a limitation of the URE model; the operating system memory page is only one instantiation of URE in the memory subsystem; the definition of URE does not depend on any specific hardware paging mechanism; URE can also be mapped to non-paging structure resources, such as GPU memory or RDMA regions.

[0129] In one implementation, this embodiment also supports sovereign trust extension in extremely heterogeneous disconnected networks.

[0130] When the endpoint sovereign hardware (HTA) is detected to be offline due to network jitter or physical isolation, the cloud-based blind node cluster is allowed to continue maintaining service continuity and perform data fragment reconstruction. During the reconstruction process, the unified resource entity lifecycle state machine continuously records the resource entity lifecycle state transition sequence and generates the runtime state metric (RSM) corresponding to the resource entity.

[0131] The runtime state metric RSM uses a defined quaternion data structure, explicitly expressed as RSM = {TS, PSDHash, PSS, StateLog}, where TS is a time series summary (used to anchor logically irreversible clocks), PSDHash is a neighborhood topology summary (used to map high-dimensional topological relationships), PSS is a monotonic state signature (used for sequential consistency verification), and StateLog is a state transition log summary (used to audit historical state transition paths).

[0132] The cloud encapsulates the RSM credential and the intermediate resource entity fragments generated by reconstruction into a temporary resource entity with a specific state ownership characteristic (STA), and forcibly pushes it into the kernel-mode built temporary latch layer 122 (Suspended_Locked Layer 122, or SL for short) for suspension and isolation. It is in a suspended state and isolated from the main file system, preventing it from uncontrolled modification of main memory, thereby removing the absolute dependence of the data retrieval path on the real-time online state of the hardware. Once the endpoint sovereign hardware returns to online status and detects a heartbeat recovery, the asynchronous release primitive logic is activated. The temporary resource entities and RSMs in the temporary latch layer SL are then submitted to the endpoint. The endpoint, using its local resource entity lifecycle state machine, performs monotonicity and causal chain verification on the RSMs (delayed causal final verification). After successful verification, the temporary layer data is formally merged into main memory, completing the streaming decentralized distributed data retrieval.

[0133] In a preferred embodiment, this embodiment also introduces scenario-adaptive multi-layered scheduling logic into the kernel-mode storage subsystem. The system continuously probes the reachability and heartbeat status of the end-side sovereign hardware (HTA) to dynamically match and seamlessly switch between two completely different physical and storage scenarios: 1) First layer: Daily workflow track (Workflow Layer) Scene matching feature: Automatically activated when the system is in a standard operating state where the end-side sovereign hardware is online in real time and the network topology is in a low-latency, high-reliability state.

[0134] Storage media matching: The system binds the physical domain of the Unified Resource Entity (URE) to high-speed storage and computing media (including but not limited to local NVMe SSD, main RAM, heterogeneous GPU memory, or LAN edge nodes connected via RDMA remote direct memory access).

[0135] At this point, the resource entity spatial topological neighborhood (PSD) converges to a preset minimum bound. When the application layer or data consuming agent initiates resource access, the data is directly back-streamed and mounted in kernel-mode zero-copy form through the unified communication-memory mapping layer (MMAPSyncChannel), performing high-frequency, low-latency, and high-throughput streaming recall. The recall timeliness reaches the microsecond to millisecond level, ensuring high determinism and high-throughput continuous execution of daily workflows under standard online conditions.

[0136] To complement the aforementioned dual-track hierarchical scheduling, this embodiment explicitly adds a status and policy field to the packed structure of the structure ure_descriptor (Uniform Resource Entity Descriptor): struct __attribute__((packed)) ure_descriptor { uint64_t re_id; / / Unique identifier for the resource entity uint32_t pfn_mapping; / / Physical page frame mapping uint8_t lifecycle_state; / / Current lifecycle state machine state uint8_t routing_track_policy; / / Append: Scene-level routing policy track identifier (Workflow / Suspended) uint16_t dynamic_heartbeat; / / Append: Real-time online heartbeat count value of the end-side sovereign hardware (HTA); The dynamic_heartbeat state, detected dynamically by the kernel, directly triggers the dual-track switching.

[0137] 2) Second Layer: Ultimate Rescue Layer for Network Outage / Disaster Recovery Scene matching feature: Automatically triggered when the system detects extreme abnormal events such as sudden physical network outage, hardware edge damage, physical node loss of connection for some reason, or malicious network path hijacking of the end-side sovereign hardware.

[0138] Storage media matching: The system will downgrade the control flow to a strong and weak trust decoupling mode, and transfer data redundancy and disaster recovery overhead to external warm and cold storage media (including but not limited to external decentralized centerless grid clusters and large-capacity heterogeneous multi-center cloud backup grids) in a discrete manner.

[0139] Under this framework, even if the end-side hardware goes offline briefly or enters a physical blockage, the external decentralized mesh cluster continues to concurrently perform data fragment reconstruction calculations in the encrypted domain, injecting a signature with a State Specific Ownership Feature (STA) into the generated intermediate resource entities. Subsequently, these reconstructed fragments are forcibly pushed into a specially created decoupled suspended buffer layer in the kernel for physical suspension and complete isolation latching, preventing unauthorized modification of the main file system. Once the sovereign hardware detects a heartbeat recovery and re-entries back online, the kernel storage subsystem immediately activates the asynchronous release primitive, cascading the accumulated memories and digital assets in the suspended buffer layer to the end-side for delayed causal final verification. After verification, these are merged into main memory, achieving "ultimate physical recovery" and seamless service continuity in extreme disaster environments.

[0140] It should be noted that the above are merely preferred embodiments of the present invention and are not intended to limit the present invention. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the protection scope of the present invention.

Claims

1. A decentralized distributed data retrieval method based on logical neighborhood mapping and sequential consistency constraints, characterized in that, The method is executed in the operating system kernel-mode storage subsystem, and performs unified semantic modeling and scheduling control of all types of memory and storage resources through a unified resource entity abstraction layer and a unified resource entity lifecycle triggering model. The method includes the following steps: Step 1: Before data and control flow enter the storage or computing path, the operating system kernel-mode storage subsystem constructs a unified resource entity abstraction layer for normalized high-order semantic modeling of heterogeneous local or remote files, memory pages, vector data, model parameters, agent skills, and knowledge blocks. The operating system kernel-mode storage subsystem normalizes all physical and virtual memory resources into a unified resource entity descriptor and mounts physical page frames to perform decoupling mapping, which is used to shield the differences in underlying hardware and establish unified addressing semantics. Step 2: The unified resource entity lifecycle triggering model maps system behavior into resource entity lifecycle events, which serve as state transition trigger signals in the resource entity lifecycle state machine. Step 3: Construct a resource entity space topology neighborhood in kernel mode and introduce a unified communication-memory mapping layer to normalize cross-end network communication behavior into virtualized entities that can be addressed and controlled at the resource entity level. The virtual entities establish a temporal causal binding relationship with the physical resource entity frame number through the resource entity table management structure; Step 4: The unified resource entity lifecycle trigger event sequence and the kernel monotonic clock are used together to generate a resource entity-level monotonic signature; When the edge-side sovereign hardware is detected to be in an offline state that is not online in real time, the cloud-based blind node cluster is allowed to continue to maintain service continuity and perform data fragment reconstruction. During the reconstruction process, the unified resource entity lifecycle state machine continuously records the resource entity lifecycle state transition sequence and generates a runtime state metric (RSM) corresponding to the resource entity. The runtime state metric (RSM) constitutes the RSM credential. The RSM credential adopts a defined quaternion data structure, which is explicitly expressed as RSM = {TS, PSDHash, PSS, StateLog}, where TS is a time series digest, PSDHash is a neighborhood topology digest, PSS is a monotonic signature, and StateLog is a state transition log digest. The operating system kernel-mode storage subsystem encapsulates the RSM credential and the intermediate data fragments generated by reconstruction into a temporary resource entity with specific state ownership characteristics, and forcibly pushes it into the kernel decoupled temporary latch layer constructed in kernel mode for suspension and isolation, thereby removing the absolute dependence of the data retrieval path on the real-time online state of the hardware and preventing it from uncontrolled modification of main memory. Once the sovereign hardware on the edge has returned to online status and detected a heartbeat, the asynchronous release primitive logic is activated. The temporary resource entity in the kernel decoupled temporary latch layer and the RSM certificate are concatenated and submitted to the edge. The edge combines its local resource entity lifecycle state machine to perform monotonicity and causal chain verification on the RSM certificate. After the verification is passed, it is officially merged into the main memory, completing the streaming decentralized recall. Step 5: The system executes resource entity lifecycle erasure coding in the unified resource entity lifecycle trigger path; The lifecycle erasure coding of the resource entity is automatically activated in a unified trigger path; The resource entity lifecycle erasure coding calculation is applied to the set of abstract resource entities in the unified resource entity abstraction layer, thereby achieving a strong binding execution between the coding process and the resource entity lifecycle. Step 6: When a remote node participates in data retrieval, its returned data flows back to the kernel resource entity lifecycle state machine through the unified communication-memory mapping layer, and performs sequential consistency matching verification with the corresponding resource entity frame object in the local resource entity spatial topology neighborhood; the resource entity frame object is a physical or logical resource entity frame object that actually exists in the local memory topology neighborhood and has deterministic memory resource entity frame number addressing. If the matching verification is successful, the unified communication-memory mapping layer attaches the memory descriptor of the returned data to the physical resource entity table entry of the resource entity spatial topology neighborhood, registers it as a valid resource entity lifecycle extension event, and releases streaming access permissions; If the matching verification fails, the state machine immediately and irreversibly transitions to the permission-locked state, triggering the unified resource entity lifecycle triggering model to forcibly rewrite its access permissions, clearing its corresponding page table permission bits and triggering TLB invalidation refresh, directly blocking all subsequent memory addressing actions in the memory management unit resource entity table event source, and completing the physical execution closed loop. Step 7: When the unified resource entity lifecycle triggering model detects an anomaly, it immediately triggers the kernel-level resource entity lifecycle controlled circuit breaker mechanism, and the operating system kernel-mode storage subsystem performs the following actions: resource entity mapping release, resource entity physical zeroing, and lifecycle state freezing; The anomalies include: detected sequence non-monotonicity, neighborhood constraint anomaly, resource entity descriptor verification anomaly, path constraint anomaly, or path hijacking anomaly where resource entity mapping verification fails. When the circuit breaker is triggered, the operating system kernel-mode storage subsystem performs the following active physical blocking and fingerprinting operations: Issue a reset primitive to force a synchronous interruption in the data transmission chain related to the target resource entity, thereby forming a causal characteristic of active transmission chain interruption; The kernel-mode redirection is performed and the protocol path for communication between storage and peripherals is bootstrapping. The causal signature (CTC) sequence, which is the result of one-way convergence of the causal signature sequence, is written into the configurable register space, protocol extension field and control message payload area associated with the device control path. This generates a specific causal fingerprint on the underlying hardware bus and causes the underlying hardware bus to generate a pending signal feature due to the termination of the transaction clock. The device control path and protocol extension fields include PCIe, NVMe, USB, SATA, CXL, RDMA, or local high-speed switching matrix; The method further includes service continuity control steps of cascaded rights confirmation and asynchronous recall: when the end-side sovereign hardware is detected to be in an offline state that is not real-time online, the cloud blind-state node cluster is allowed to continue to maintain service continuity and perform data fragment reconstruction, generate unified resource entity fragments with specific state ownership characteristics, and forcibly push them into the decoupled temporary storage layer built in kernel mode for suspension and isolation, thereby removing the absolute dependence of the data recall path on the real-time online state of the hardware; after the end-side sovereign hardware is restored to the online state, the asynchronous release logic is activated, and the unified resource entity fragments in the decoupled temporary storage layer are submitted to the end side for delayed causal final review and rights confirmation, completing the streaming data recall.

2. The method according to claim 1, characterized in that, In step one, the unified resource entity semantic structure includes the operating system standard memory resource entity, the large resource entity memory structure, the GPU / NPU heterogeneous video memory resource entity, the object physical resource entity in the virtualization environment, and the peripheral buffer resource entity mapped by DMA. The unified resource entity descriptor includes a resource entity physical state vector, a resource entity lifecycle state identifier, a memory or video memory resource type-independent identifier field, a virtualization environment mapping identifier, and a DMA or heterogeneous computing channel mapping handle. The unified resource entity descriptor is used to represent a unified semantic mapping for all computing and storage resources.

3. The method according to claim 1, characterized in that, In step two, the system behaviors include memory reclamation behavior, resource entity swapping behavior, write-back behavior, asynchronous I / O completion behavior, DMA transfer completion event, and GPU / NPU memory scheduling event.

4. The method according to claim 1, characterized in that, In step three, the cross-end network communication behavior includes network communication sockets, remote direct memory access channels, and zero-copy network buffers; The resource entity spatial topological neighborhood includes the physical mapping relationship of the unified resource entity descriptor, the consistency of the life cycle state, and the resource entity state migration history. The resource entity spatial topological neighborhood is used to replace the central index structure or broadcast discovery mechanism, mapping and normalizing network addressing behavior into page table access behavior, and transforming node communication behavior into page lifecycle migration behavior. In step four, the resource entity-level monotonic signature is generated by the event sequence generated by the unified resource entity lifecycle triggering model and the system monotonic clock, which is used to ensure the irreversibility and non-replayability of the resource entity state evolution path.

5. The method according to claim 1, characterized in that, In step five, the unified resource entity lifecycle triggering model achieves unified control and normalized mapping of all storage and memory paths through the physical event source of the resource entity lifecycle in the operating system kernel. The physical event sources for the lifecycle of resource entities include the memory management unit resource entity table event source, the memory allocator resource entity block description event source, and the user-mode resource entity lifecycle backflow mechanism. The memory management unit resource entity table event source is the resource entity table creation event and resource entity missing event generated by the system when the memory management unit performs virtual address to physical address translation. This event source corresponds to the resource entity state transition in all VA→PA mapping processes, and when triggered, the corresponding resource entity is marked as at least one of the states including Active, Dirty, Reclaim, and Migratin. The memory allocator resource entity block description event source is the block-level description structure behavior generated by the system when the physical memory allocator performs resource entity allocation by intercepting the physical memory allocator. This includes continuous large resource entity allocation behavior, user-mode memory pool allocation behavior, GPU / NPU unified memory resource entity allocation behavior, and object physical resource entity allocation behavior in a virtualization environment. The user-mode resource entity lifecycle reflow mechanism includes eBPF kernel-mode behavior probe, resource entity table hardware state reflow mechanism, and time-consistent memory mapping synchronization mechanism. The unified triggering path includes the UPLT-triggered write-back path, resource entity reclamation path, resource entity migration path, and resource entity swap-out path.

6. The method according to claim 1, characterized in that, The recovery process must simultaneously satisfy three types of consistency constraints: resource entity spatial topological neighborhood, resource entity-level monotonic signature, and unified resource entity descriptor; otherwise, the data reconstruction operation will be refused.

7. The method according to claim 1, characterized in that, When the abnormal circuit breaker mechanism for the lifecycle of a resource entity is triggered, the underlying reset primitive is executed by the kernel-mode storage subsystem of the operating system. The reset primitive causes a synchronous interruption in all data transmission chains related to the target resource entity, thus forming an active transmission chain interruption causal feature. While executing the reset primitive, the operating system kernel-mode storage subsystem forcibly injects globally unique causal signatures into the standard protocol layer of the peripheral communication path to retain specific causal fingerprints at the physical storage and data path layers, and triggers observable bus high-impedance state or level suspension signal characteristics at the hardware bus layer by synchronous interrupts.

8. The method according to claim 7, characterized in that, The causal signature includes a non-fixed verification sequence with exclusive verification characteristics generated by the multi-dimensional state vector of the current abnormal page descriptor through a one-way hash function or a specific matrix mapping, and is forcibly injected into the standard protocol layer of the storage and peripheral communication path; The standard protocol layer includes the PCIe configuration space standard register mapping layer, the NVMe command queue standard protocol field, and the device control channel control frame header field; Causal signatures form cryptographic fingerprints at the bus protocol layer that are strongly causally linked to the system software logic.

9. The method according to claim 1, characterized in that, In step seven, the data fragment retrieval process also includes a linkage verification with the hardware execution path: Anchor mapping: Each data fragment identifier is cryptographically mapped and bound to at least one SEPS session anchor; State collision: During the data fragment reconstruction phase, the recall end initiates a hardware event chain comparison request for the fragment to the SEPS protocol stack; Path blocking: If the physical read path of the data fragment does not generate a hardware event chain trajectory that conforms to the current controlled memory domain, or if the memory resource entity to which the data fragment belongs is not in an authorized access state, a SEPS hardware-level termination instruction is triggered, and the recall permission of the physical node that serves as the physical carrier of the remote node is blocked.

10. The method according to claim 1, characterized in that, The cascaded ownership confirmation and asynchronous recall mechanism includes: When the edge-side sovereign hardware is offline, the cloud-based blind node cluster continues to perform data fragment reconstruction. During the reconstruction process, the unified resource entity lifecycle state machine continuously records the resource entity lifecycle state transition sequence and generates runtime state metric values ​​corresponding to the resource entity. The runtime state metric includes at least one of the following: lifecycle state vector, resource entity-level monotonic signature (PSMS), and resource entity spatial topological neighborhood PSD feature summary. The cloud encapsulates runtime state metrics and unified resource entity fragments generated by reconstruction into temporary resource entities with state ownership characteristics, and writes them into the decoupled temporary storage layer. Once the end-side sovereign hardware returns to online, the delayed rights confirmation is completed using runtime state metrics as the final causal basis.

11. The method according to claim 1, characterized in that, It also includes introducing an adaptive spatiotemporal constraint operator into the sequential consistency constraint: when the timestamp delay returned by the target distributed node, which is the responder of the recall request, exceeds the preset security threshold or does not respond, the operating system kernel-mode storage subsystem automatically switches to degraded consistency mode; the current computing transaction is suspended through the kernel decoupling temporary latch layer, and the kernel storage driver layer triggers a secondary redirection recall based on the logical neighborhood topology graph.

12. A decentralized distributed data retrieval system based on logical neighborhood mapping and sequential consistency constraints, characterized in that, The recall system is deployed in the operating system and runs across multiple distributed physical nodes. The recall system includes a unified resource entity semantic abstraction module, a lifecycle event triggering module, a topological neighborhood construction and mapping module, a sequential consistency pipeline module, a logical neighborhood range detection module, a self-verifying multi-constraint reconstruction module, and a kernel-level circuit breaker blocking module. The unified resource entity semantic abstraction module is used to drive the operating system kernel-mode storage subsystem to abstract all physical and virtual memory resources into a unified resource entity semantic structure before data enters the storage or computing path, and to normalize all resources into a unified resource entity descriptor when they enter the system, so as to shield the differences in underlying hardware and establish a unified addressing semantic. The lifecycle event triggering module is used to map the user-mode behavior or peripheral bus signal of the operating system into a unified resource entity lifecycle event through a unified resource entity lifecycle triggering model, and input it into the kernel-mode storage subsystem of the operating system as a state transition trigger signal in the resource entity lifecycle state machine. The topology neighborhood construction and mapping module is used to construct the resource entity space topology neighborhood in the operating system kernel-mode storage subsystem, and introduce a unified communication-memory mapping layer to normalize cross-end network communication behavior into virtualized entities that can be addressed and controlled at the resource entity level. The virtualized entities establish a temporal causal binding relationship with the physical resource entity frame number through the resource entity table management structure. The sequential consistency pipeline module is used to atomically anchor the sequence of lifecycle triggering events of a unified resource entity to the kernel transaction boundary, so as to form a sequentially consistent data writing pipeline in the block device driver layer of the operating system kernel-mode storage subsystem. The logical neighborhood range detection module is used to dynamically converge and calculate a logical neighborhood containing at least one remote node based on the identifier of the target data fragment under the condition of no central metadata index, and send fragment recall detection requests only to the remote nodes within the logical neighborhood. The self-verifying multi-constraint reconstruction module is used to return the data to the kernel resource entity lifecycle state machine through the unified communication-memory mapping layer when remote nodes participate in data retrieval. The data is then matched and verified with the unified resource entity (URE) in the local resource entity space topology neighborhood. The operating system kernel-mode storage subsystem performs atomic retrieval and reconstruction of distributed data fragments when the consistency of resource entity surface descriptors, the consistency of resource entity lifecycle polymorphism, and the consistency of user-mode variable windows are satisfied simultaneously. The kernel-level circuit breaker module is used to immediately trigger the kernel-level resource entity lifecycle circuit breaker mechanism of the operating system when the unified resource entity lifecycle triggering model detects an access anomaly. The kernel-mode storage subsystem of the operating system executes the underlying reset primitive to synchronously interrupt the data transmission chain and form an observable specific causal fingerprint at the physical storage and data path layer.

13. The system according to claim 12, characterized in that, When the heterogeneous computing unit performs semantic retrieval on the reconstructed data in the physical memory, the kernel-mode storage subsystem rigidly records the number of times the data assets are retrieved and invoked through the state transition counter of the resource entity lifecycle state machine, and generates an immutable audit log with causal feature codes, which serves as the data asset ownership certificate for the distributed physical node.

Images