Video image edge device and scene algorithm software and hardware adaptation method and device

Abstract

The embodiment of the application provides a kind of video image edge device and scene algorithm software and hardware adaptation method and device, and the effective allocation of resources is realized by pooling processing and prediction analysis.Construct scheduling mechanism, combined with priority ordering and state rollback, establish reliable task processing strategy.Introduce service interface, ensure the security of system through secure channel and access control.The method effectively solves the deficiencies of traditional technology in resource management, task scheduling and service interface, etc., and provides technical support for software and hardware adaptation.

Description

Technical Field

[0001] This application relates to the field of data processing, specifically to a software and hardware adaptation method and apparatus for video image edge devices and scene algorithms. Background Technology

[0002] Existing software and hardware adaptation methods have significant shortcomings. Traditional systems perform poorly in resource management and pooling, failing to effectively predict and allocate resources, thus impacting system efficiency.

[0003] Furthermore, existing technologies suffer from bottlenecks in task scheduling and state recovery. Most systems lack robust prioritization mechanisms and rollback strategies, resulting in unreliable task processing.

[0004] The existing system has technical shortcomings in terms of service-oriented interfaces. There is a lack of in-depth consideration of interface security, making it difficult to achieve efficient access control through encryption mechanisms, thus impacting system security. Solving these problems is crucial for improving software and hardware compatibility. Summary of the Invention

[0005] To address the problems in the existing technology, this application provides a software and hardware adaptation method and apparatus for video image edge devices and scene algorithms, which can effectively solve the shortcomings of traditional technologies in resource management, task scheduling and service interfaces, and provide technical support for software and hardware adaptation.

[0006] To solve at least one of the above problems, this application provides the following technical solution: In a first aspect, this application provides a hardware and software adaptation method for video image edge devices and scene algorithms, including: Based on the hardware resources of edge devices, a hardware abstraction layer is constructed to generate a resource pool table. Computing resources, memory resources, and media processing resources are pooled and managed according to preset resource rules to generate a resource mapping table. A resource predictor is constructed based on the resource mapping table to generate a load prediction table. Resource usage trend analysis is performed on the load prediction table to generate a resource pre-allocation table. The resource pre-allocation table is called as an input parameter of the scheduling system. Based on the resource pre-allocation table, a preemptive recovery scheduling system is constructed to generate a task queue list. The algorithm tasks to be executed are classified according to preset priority rules to generate a priority mapping table. The task queue list is scheduled and sorted according to the priority mapping table to generate an execution sequence table, which is used for scheduling control of the algorithm container. Based on the execution sequence table, a state rollback mechanism is constructed to generate a state snapshot table. The task state of the state snapshot table is saved to generate a recovery parameter table, which is used for task recovery. Based on the recovery parameter table, a service-oriented interface is constructed to generate an interface description table. Device management, algorithm management, and media stream processing are encapsulated into services according to preset interface rules to generate a service interface table. A secure channel is constructed based on the service interface table to generate an encrypted channel table. Access control is applied to the encrypted channel table to generate a service call table. The service call table is then deployed to edge devices for hardware and software adaptation.

[0007] Furthermore, it also includes: establishing a hardware feature vector based on the processor architecture information of the edge device, dividing the computing unit clusters according to the processor instruction set type to generate a unit distribution table, performing performance evaluation on each computing unit cluster to generate a computing power evaluation table, mapping the computing power evaluation table according to the computing density index to generate a resource classification table, and constructing a computing task distributor to generate a task routing table based on the resource classification table. A resource scheduling model is established based on the task routing table. Computing resources, memory resources, and media processing resources are grouped and encoded according to the resource hierarchy table to generate a resource identifier table. A hardware abstraction interface is constructed based on the resource identifier table to generate a scheduling mapping table. The scheduling mapping table is then processed to generate a resource mapping table.

[0008] Furthermore, it also includes: extracting hardware resource load features based on the resource mapping table to construct a resource monitoring matrix; sampling the processor load rate, memory usage rate, and media processing unit utilization rate according to the time sequence relationship to generate a load sequence table; performing sliding window analysis on the load sequence table to generate a fluctuation interval table; and constructing a resource load prediction model based on the fluctuation interval table to generate a prediction parameter table. Based on the prediction parameter table, a trend prediction model is established to predict the load of hardware resources. The prediction results output by the trend prediction model are classified and mapped according to resource type to generate a resource prediction table. Based on the resource prediction table, a load warning threshold is constructed to generate a load prediction table. The load prediction table is then analyzed for resource usage trends to generate a resource pre-allocation table.

[0009] Furthermore, it also includes: building a scheduling executor based on a resource pre-allocation table to establish a scheduling management unit, labeling the tasks to be executed with task types to generate a task attribute table, performing time-series dependency analysis on the tasks in the task attribute table to generate a dependency relationship table, building a task dependency network based on the dependency relationship table to generate a scheduling matrix table, and grouping the scheduling matrix table according to the task runtime to generate a time slice table. A task preemption controller is established based on the time slice table. The task running status is marked according to the preemption priority to generate a preemption status table. A task suspension queue is constructed according to the preemption status table to generate a task queue list. The task queue list is classified according to a preset priority rule to generate a priority mapping table. The task queue list is scheduled and sorted according to the priority mapping table to generate an execution sequence table.

[0010] Furthermore, it also includes: building a checkpoint manager based on the execution sequence list to establish a state recording unit, mapping the task execution context information into memory to generate a context table, capturing the state of runtime variables in the context table to generate a variable state table, building a state dictionary based on the variable state table to generate a state mapping table, and indexing the state mapping table according to timestamps to generate a checkpoint table. A state memory is established based on the checkpoint table. The state of the task execution site is sampled according to the checkpoint position to generate a snapshot record table. A state storage queue is constructed based on the snapshot record table to generate a state snapshot table. The task state is saved on the state snapshot table to generate a recovery parameter table. The task is recovered based on the recovery parameter table.

[0011] Furthermore, it also includes: building an interface manager based on the recovery parameter table to establish a service registration unit, classifying the edge device functional modules into services to generate a functional classification table, defining the service modules in the functional classification table into interfaces to generate an interface definition table, building a service registration center based on the interface definition table to generate a service registry, and standardizing the service registry according to service type to generate an interface description table. A service encapsulator is established based on the interface description table. Device management, algorithm management, and media stream processing services are mapped according to standardized interfaces to generate a service mapping table. A service call channel is constructed based on the service mapping table to generate a communication interface table. The communication interface table is encapsulated into a service to generate a service interface table. A secure channel is constructed based on the service interface table to generate an encrypted channel table.

[0012] Furthermore, it also includes: building a security manager based on the service interface table to establish a channel encryption unit, selecting encryption protocols for service communication data to generate a protocol selection table, negotiating keys for encryption parameters in the protocol selection table to generate a key distribution table, building a secure channel generation channel configuration table based on the key distribution table, and generating an encrypted channel table by classifying the channel configuration table according to encryption strength. An access controller is established based on the encrypted channel table. Service call requests are verified according to the authentication policy to generate an authentication result table. An authorization table is generated based on the authentication result table. Access control is performed on the authorization table to generate a service call table. The hardware and software adaptation of the edge device is completed based on the service call table.

[0013] Secondly, this application provides a hardware and software adaptation device for video image edge devices and scene algorithms, comprising: The resource computing module is used to build a hardware abstraction layer based on the hardware resources of the edge device to generate a resource pool table, pool computing resources, memory resources, and media processing resources according to preset resource rules to generate a resource mapping table, build a resource predictor based on the resource mapping table to generate a load prediction table, perform resource usage trend analysis on the load prediction table to generate a resource pre-allocation table, and call the resource pre-allocation table as an input parameter of the scheduling system. The task execution module is used to construct a preemptive recovery scheduling system based on the resource pre-allocation table to generate a task queue list, classify the algorithm tasks to be executed according to preset priority rules to generate a priority mapping table, and sort the task queue list according to the priority mapping table to generate an execution sequence list, which is used for scheduling control of the algorithm container; and to construct a state rollback mechanism based on the execution sequence list to generate a state snapshot table, and save the task state of the state snapshot table to generate a recovery parameter table, which is used for task recovery. The software and hardware adaptation module is used to construct a service-oriented interface based on the recovery parameter table to generate an interface description table, encapsulate device management, algorithm management, and media stream processing into a service interface table according to preset interface rules, construct a secure channel based on the service interface table to generate an encrypted channel table, perform access control on the encrypted channel table to generate a service call table, and deploy the service call table to the edge device for software and hardware adaptation.

[0014] Thirdly, this application provides an electronic device, including a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the program to implement the hardware and software adaptation method for the video image edge device and scene algorithm.

[0015] Fourthly, this application provides a computer-readable storage medium storing a computer program thereon, which, when executed by a processor, implements the steps of the software and hardware adaptation method for the video image edge device and scene algorithm described above.

[0016] Fifthly, this application provides a computer program product, including a computer program / instruction, which, when executed by a processor, implements the steps of the software and hardware adaptation method for the video image edge device and scene algorithm.

[0017] As can be seen from the above technical solution, this application provides a software and hardware adaptation method and apparatus for video image edge devices and scene algorithms. Through pooling processing and predictive analysis, it achieves efficient resource allocation. A scheduling mechanism is constructed, combining priority sorting and state rollback to establish a reliable task processing strategy. A service-oriented interface is introduced, and system security is ensured through secure channels and access control. This method effectively solves the shortcomings of traditional technologies in resource management, task scheduling, and service interfaces, providing technical support for software and hardware adaptation. Attached Figure Description

[0018] To more clearly illustrate the technical solutions in the embodiments of this application 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 some embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0019] Figure 1 This is a flowchart illustrating the hardware and software adaptation method for video image edge devices and scene algorithms in this application embodiment. Figure 2 This is a structural diagram of the hardware and software adaptation device for video image edge devices and scene algorithms in the embodiments of this application; Figure 3 This is a schematic diagram of the structure of the electronic device in the embodiments of this application.

[0020] Figure label: Electronic device 9600, central processing unit 9100, memory 9140, communication module 9110, input unit 9120, audio processor 9130, display 9160, power supply 9170, buffer memory 9141, application / function storage unit 9142, data storage unit 9143, driver storage unit 9144, antenna 9111, speaker 9131, microphone 9132. Detailed Implementation

[0021] To make the objectives, technical solutions, and advantages of the embodiments of this application clearer, the technical solutions of the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this application, not all embodiments. Based on the embodiments of this application, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application.

[0022] The acquisition, storage, use, and processing of data in this application comply with relevant laws and regulations.

[0023] To address the problems existing in current technologies, this application provides a hardware and software adaptation method and apparatus for video image edge devices and scene algorithms. Through pooling processing and predictive analysis, it achieves efficient resource allocation. A scheduling mechanism is constructed, combining priority sorting and state rollback to establish a reliable task processing strategy. A service-oriented interface is introduced, and system security is ensured through secure channels and access control. This method effectively solves the shortcomings of traditional technologies in resource management, task scheduling, and service interfaces, providing technical support for hardware and software adaptation.

[0024] To effectively address the shortcomings of traditional technologies in resource management, task scheduling, and service interfaces, and to provide technical support for software and hardware adaptation, this application provides an embodiment of a software and hardware adaptation method for video image edge devices and scene algorithms. See [link to relevant documentation]. Figure 1 The hardware and software adaptation method for video image edge devices and scene algorithms specifically includes the following: Step S101: Based on the hardware resources of the edge device, a hardware abstraction layer is constructed to generate a resource pool table. Computing resources, memory resources, and media processing resources are pooled and managed according to preset resource rules to generate a resource mapping table. A resource predictor is constructed based on the resource mapping table to generate a load prediction table. Resource usage trend analysis is performed on the load prediction table to generate a resource pre-allocation table. The resource pre-allocation table is called as an input parameter of the scheduling system. First, the processor architecture, acceleration units, and media subsystem list of edge devices are accessed. Basic descriptions are aligned according to chip model and instruction set to establish a unified numbering system for computing resources, memory resources, and media processing resources. Based on this numbering, the capabilities of processing cores, video memory, and encoding / decoding channels are labeled, specifying concurrency limits, bandwidth ranges, and latency levels, serving as input fields for the hardware abstraction layer. Subsequently, similar resources are aggregated into logical groups, registering resource ownership relationships and cross-group access overhead, forming a resource pool index that can be read by upper layers.

[0025] Based on the resource pool index, computing resources are mapped to schedulable units according to kernel cluster and operator adaptability, memory resources are mapped to allocation units according to continuity and affinity, and media processing resources are mapped to working units according to encoding / decoding direction and pixel format. Cross-unit reference keys are generated for each of the three types of units, and mutual exclusion relationships and shared boundaries are recorded, resulting in a resource mapping structure with constraint fields. This structure will be used by the subsequent trend analysis module for resource association retrieval.

[0026] The resource mapping structure is read by the resource sampling process to construct monitoring entries on the timeline. Processor load rate, memory usage, and media channel utilization are collected, and peak, average, and fluctuation amplitudes are aggregated using a fixed-step sliding window. Scene labels are added according to device operating modes. The collected results, along with the previously entered cross-unit reference keys, are backfilled into the monitoring details to ensure that the computation, storage, and media usage status at the same time can be queried in a linked manner.

[0027] Based on the monitoring details, a load prediction model, "Resource Trend Evaluator," is instantiated. The model takes the most recent multi-window monitoring sequence as input and outputs the interval-level occupancy probability and fluctuation score for each unit over several future time intervals. To suppress misjudgments caused by short-term spikes, a hierarchical regression of scene labels is introduced, and a confidence reduction strategy is applied to the sparse label layer, writing the reduced values ​​back to the prediction entries as a reference for downstream threshold calculations.

[0028] A load prediction table is generated based on the predicted entries, and aggregated by resource type and logical group to output the occupancy and available capacity in the time slice. To facilitate subsequent scheduling, a key-value mapping is additionally generated to clarify the memory affinity group and media channel constraint relationship corresponding to a certain computing unit, thereby quickly determining composable resource clusters within the same time slice. If a mutual exclusion flag exists, a reservation flag is set within that time slice to prevent migration overhead caused by cross-cluster preemption.

[0029] Resource usage trend analysis is performed on the load forecast table, dividing the time-slice series into relaxed, transitional, and strained zones, and defining resource occupancy boundaries within each zone. The analysis process uses the aforementioned confidence reduction values, lowering the weight of segments with insufficient confidence to prevent zone drift. After partitioning, a targeted pre-occupancy ratio and reclamation priority are generated for each resource logical group, forming executable pre-allocation entries.

[0030] Optionally, a scoring formula is defined to sort the pre-assigned items: Z = a1·Û + a2· a3· .

[0031] In the formula, Z is the item score; Û is the normalized value of the predicted occupancy intensity; the This is the normalized value of the fluctuation amplitude; the... This is a normalized value for cross-group relocation costs; a1, a2, and a3 are non-negative weights. This score is used to determine, within the same time slice, which resource clusters should be reserved in advance and which can be reclaimed later.

[0032] Based on the scoring results and partition annotations, a resource pre-allocation table is generated, providing four key fields: time slice, resource cluster, reservation ratio, and reclamation order. The resource pre-allocation table inherits the mutual exclusion and affinity tags from the resource mapping structure and retains the source time window and weight version for easy verification during operation. For time slices with stressful zones, the pre-allocation table includes a fallback plan, pointing to a similar backup resource cluster.

[0033] Finally, the resource pre-allocation table is invoked as an input parameter of the scheduling system and matched with the task attribute and priority mapping in subsequent steps. Based on this, the scheduler reserves and freezes resource clusters before entering a time slice, and reads the reclamation order from the pre-allocated entries when tasks are suspended or resumed, achieving continuous supply to the algorithm containers. Thus, the hardware abstraction and prediction products constructed in the preceding steps form a traceable link with the subsequent preemption and recovery.

[0034] Step S102: Based on the resource pre-allocation table, a preemption recovery scheduling system is constructed to generate a task queue list. The tasks to be executed are classified according to a preset priority rule to generate a priority mapping table. The task queue list is sorted according to the priority mapping table to generate an execution sequence table, which is used for scheduling control of the algorithm container. Based on the execution sequence table, a state rollback mechanism is constructed to generate a state snapshot table. The task state of the state snapshot table is saved to generate a recovery parameter table, which is used for task recovery. First, the resource pre-allocation table and the mutual exclusion and affinity tags of resource clusters output in step S101 are read, and the available resources and reservation ratio within the current time slice are aligned with the scheduling clock. Next, input parameters are collected for the task to be executed, including task type, real-time requirements, estimated runtime, and resource affinity preferences, and mapped to the resource cluster key to generate scheduling-oriented task entries. Entries that cannot be mapped are marked as pending migration and will only be attempted to be loaded in the relaxed time slice.

[0035] A management unit for the preemption and recovery scheduling system is established based on the aforementioned task entries. First, a priority mapping table is generated according to preset priority rules. These rules categorize alarm, analysis, and background processing tasks into layers, and introduce remaining time limits and resource conflict factors as weighting factors to update the temporary level of each entry. To avoid level oscillations, a retention period is added for entries with short-term fluctuations. During the retention period, entries are not downgraded; reassessment is only triggered in timeout or resource-scarce areas.

[0036] The priority mapping table is read by the scheduling and sorting process, and combined with the resource pre-allocation ratio within the time slice, a list of executable task teams is generated. During sorting, tasks are first grouped by temporary level, and then sorted within each group by estimated duration and resource affinity, while excluding combinations that conflict with mutual exclusion markers. For entries with the same level and similar estimated durations, tasks consistent with the current cache hotspot are prioritized to reduce context switching costs.

[0037] The execution sequence is calculated based on the task team list, and an execution sequence table is output. The execution sequence follows the order of "high priority loading first, conflict avoidance based on proximity, and affinity priority matching," and provides the start time, expected resource clusters occupied, and preemption threshold indication for each entry. For the relaxed time slice, low-level entries are allowed to be filled, but an interruptible flag is set; for the stressed time slice, only recoverable entries are allowed, and a rollback window is reserved.

[0038] The execution sequence list is read by the algorithm container scheduling and control unit, and containers are created, started, and paused in sequence. Before starting, the resource pre-allocation table is compared again to confirm that the resource freeze is in place; during operation, the remaining time limit and actual usage are monitored, and if a preemption threshold indication is triggered, the interruption point is recorded and the system switches to a higher priority entry. When paused, a dirty page snapshot of the container is taken to reduce the page reload overhead during recovery.

[0039] A state rollback mechanism is built on top of the execution sequence list, establishing a coordinated strategy for checkpoints and snapshots. Checkpoints are triggered by fixed step sizes and key stage events, capturing the runtime context of the algorithm container, input buffer offsets, and internal model caches. Snapshots incrementally record memory pages and handle tables, both using the same timestamp space to ensure replay consistency.

[0040] The checkpoints and snapshots are merged into a state snapshot table, and the index key required for recovery is written into it. To support rapid recovery, the state snapshot table retains multiple version entries for the most recent few time slices and indicates whether the dependent external resource handles are still valid. If a handle becomes invalid, a handle rebinding strategy is executed before the recovery parameters are generated to avoid recovery to an unavailable channel.

[0041] A recovery parameter table is generated based on the state snapshot table, including the container recovery entry point, memory remapping scheme, input buffer replay range, and model cache reconstruction instructions. During recovery, target nodes with affinity to the current resource cluster are selected first. If the affinity is insufficient, the backup clusters in the resource pre-allocation table are referenced for equivalent mapping, and the scheduling instructions for subsequent time slices are updated to prevent the re-triggering of similar conflicts.

[0042] Finally, the recovery parameter table is invoked by the scheduling system after the preemption ends to replay and resume the suspended tasks. Simultaneously, the version numbers of the execution sequence table and the recovery parameter table are written back to the scheduling log for subsequent priority reassessment and time slice allocation, thus establishing a traceable association between the output of step S102 and the subsequent service interface configuration.

[0043] Step S103: Based on the recovery parameter table, construct a service-oriented interface to generate an interface description table. Encapsulate device management, algorithm management, and media stream processing into a service interface table according to preset interface rules. Construct a secure channel to generate an encrypted channel table based on the service interface table. Perform access control on the encrypted channel table to generate a service call table. Deploy the service call table to the edge device for software and hardware adaptation.

[0044] First, the recovery parameter table and execution sequence table output in step S102 are read. The container recovery entry point, memory remapping scheme, and input buffer playback range are aligned to serve as the input source for interface modeling. Based on this input, the device's functional modules are categorized into three types: device management, algorithm management, and media stream processing. A request and response data structure is established for each type, clearly defining the boundary conditions for required and optional fields. Fields involving recovery actions are marked with idempotency requirements in the metadata to prevent state drift caused by repeated calls.

[0045] Based on the input source, a set of service interface definitions is constructed, defining verbs, paths, and message body structures for each operation according to preset interface rules. The device management side covers status query, resource detection, and channel configuration; the algorithm management side covers container startup, pause, resumption, and unloading; and the media stream processing side covers stream subscription, keyframe request, and cache playback. Each operation references the recovery parameter identifier from step S102 as a key, ensuring that the interface call accurately locates the container instance to be restored and its dependent resources.

[0046] The defined set is read by the interface orchestration process to generate an interface description table. This table registers paths, methods, field constraints, and error codes at the operation level, along with version identifiers and compatibility policies. To support cross-version deployment, alternative mappings are set for deprecated fields in the description table. When an old field is detected during a call, the new field is automatically populated back according to the mapping, and this backfilling behavior is recorded for subsequent auditing.

[0047] Based on the interface description table, service encapsulation is completed, and a service interface table is output. The encapsulation process binds serialization and deserialization strategies to each operation and injects a parameter validator to perform a consistency comparison between the recovery entry point and resource mapping fields. If the comparison fails, a clear error code and location information are returned without modifying the device-side state. For media playback and container recovery operations that require long processing times, heartbeats and retry windows are set to ensure call continuity under network fluctuations.

[0048] The service interface table is read by the security construction process to negotiate and configure a secure channel. First, the encryption protocol family and certificate chain source are configured according to the interface category. Second, two-way authentication is enabled for algorithm recovery and media playback operations, and replay protection is enabled at the session layer. After the secure channel is established, an encrypted channel table is output, recording the session identifier, key derivation parameters, and time-to-live (TTL), which are used as the basis for subsequent access control decisions.

[0049] Access control is implemented based on the encrypted channel table, generating a service call table. Access control uses a three-factor matching based on the caller's identity, operation type, and resource scope. It prioritizes checking whether recovery operations have control over the target container, and then checks whether media playback is within the authorized streaming channel set. Cross-tenant requests are rejected and their source fingerprints are recorded; for requests within the same tenant but exceeding authorized permissions, a least privilege fallback is triggered, allowing only read-only queries.

[0050] Deployment is carried out according to the service call table, mapping the gateway routes of each interface to the device-side processing entry points to complete registration and activation on the edge devices. During deployment, canary deployments are implemented for critical paths, initially importing a small number of requests during low-load periods to observe latency and failure rates, and then gradually expanding the coverage. If session anomalies or certificate verification failures are observed, the most recent route change is revoked according to the rollback policy in the description table to ensure that existing sessions are not interrupted.

[0051] After the deployment is completed, the versions of the service call table and interface description table are written into the device-side metadata and a reference relationship is established with the execution sequence table in step S102. During runtime, the scheduling and control unit of the algorithm container accepts recovery and pause requests through the service interface table, the security management unit verifies the channel status through the encrypted channel table, and the media module performs bitstream playback based on the same call table. Thus, recovery parameters are stably exposed at the interface layer, and subsequent steps can directly obtain the information required for hardware and software adaptation in a service-oriented manner and drive the joint operation of edge devices.

[0052] As described above, the hardware and software adaptation method for video image edge devices and scene algorithms provided in this application can achieve effective resource allocation through pooling processing and predictive analysis. A scheduling mechanism is constructed, combining priority sorting and state rollback to establish a reliable task processing strategy. A service-oriented interface is introduced, and system security is ensured through secure channels and access control. This method effectively addresses the shortcomings of traditional technologies in resource management, task scheduling, and service interfaces, providing technical support for hardware and software adaptation.

[0053] In one embodiment of the hardware and software adaptation method for video image edge devices and scene algorithms in this application, the method may further include the following: Step S201: Establish a hardware feature vector based on the processor architecture information of the edge device, divide the computing unit clusters according to the processor instruction set type to generate a unit distribution table, perform performance evaluation on each computing unit cluster to generate a computing power evaluation table, map the computing power evaluation table according to the computing density index to generate a resource classification table, and construct a computing task distributor to generate a task routing table based on the resource classification table. Step S202: Establish a resource scheduling model based on the task routing table, group and encode computing resources, memory resources, and media processing resources according to the resource hierarchy table to generate a resource identifier table, construct a hardware abstraction interface based on the resource identifier table to generate a scheduling mapping table, and perform regularization processing on the scheduling mapping table to generate a resource mapping table.

[0054] First, the chip model, instruction set, and accelerated instruction support list of the edge device are collected and encoded into a hardware feature vector after alignment with the processor architecture fields. The vector includes pipeline depth, cache level, vector width, integer and floating-point operator sets, and built-in media unit markers. Missing fields are filled with device self-test results to ensure that subsequent clustering is not affected by null values. This vector serves as input for computational unit identification and is written into the unit identification details for traceability.

[0055] Based on the detailed unit identification, the processing cores are divided into computing unit clusters according to instruction set type and kernel topology, and a unit distribution table is output. During partitioning, shared cache within the same cluster and cross-cluster interconnect bandwidth are recorded as constraints for subsequent evaluation. Heterogeneous accelerators are clustered separately and their executable operator sets are labeled to ensure that incompatible targets can be quickly filtered when matching tasks with operators.

[0056] The cell distribution table is read by the performance evaluation process to generate a computing power evaluation table. The evaluation adopts a combination of offline benchmarks and online micro-benchmarks: the offline part calculates the backoff ratio under instruction throughput and memory access pressure, while the online part injects small operator sequences to measure the actual latency and energy consumption tradeoff. The evaluation results provide throughput ranges and stability labels by operator family, and are associated with the aforementioned shared cache and interconnect bandwidth to form comparable entries.

[0057] Based on the aforementioned computing power assessment table, a hierarchical mapping is performed according to the computing density index, outputting a resource grading table. The grading is primarily based on the number of standardized operators that can be completed per unit time, while energy consumption coefficients and bandwidth constraints are introduced as secondary factors to avoid misleading mappings based solely on peak values. The mapping results classify each unit cluster into several grade intervals, retaining boundary descriptions and confidence markers between grades to facilitate subsequent downgrade rollback.

[0058] The resource hierarchy table is read by the task distribution logic to construct a computational task distributor and generate a task routing table. The distributor receives the operator sequence and time limit label of the tasks to be scheduled. First, it filters feasible clusters using the operator set, and then sorts them by priority and affinity to produce candidate routes. If there are mutually exclusive resource tags in the candidate clusters, the one with the least cross-cluster interference within the same level is selected, and a backup route is recorded for switching during preemption.

[0059] Based on the aforementioned task routing table, a resource scheduling model is established. Computing resources, memory resources, and media processing resources are grouped and coded according to a resource hierarchy table, outputting a resource identifier table. During coding, a unique identifier is assigned to each group and affinity is bound, clearly defining the preferred memory domain and directly connectable media channel corresponding to a certain computing cluster, reducing cross-domain migration. The resource identifier table and the task routing table are associated through a common affinity key, ensuring direct lookup during the scheduling phase.

[0060] Based on the resource identifier table, a hardware abstraction interface is constructed, outputting a scheduling mapping table. This interface maps the task's operator sequence, data layout, and time-slice requests to the underlying call sequence, and verifies the consistency of affinity keys and mutex tags before each call. For requests that cannot satisfy affinity constraints, a route degradation suggestion is returned, pointing to an alternative route to avoid blind submissions that could cause blocking.

[0061] Finally, the scheduling mapping table is processed into a resource mapping table through rule-based processing. The rule-based process standardizes field naming, converges abnormal branches, and solidifies degradation paths, ensuring that routing configurations from different sources can be consumed by the scheduler under the same semantics. In subsequent steps, the resource mapping table is simultaneously read by the resource trend evaluator and the scheduling executor for load monitoring correlation retrieval and rapid decision-making within time slices.

[0062] In one embodiment of the hardware and software adaptation method for video image edge devices and scene algorithms in this application, the method may further include the following: Step S301: Extract hardware resource load features based on the resource mapping table to construct a resource monitoring matrix. Sample the processor load rate, memory usage rate, and media processing unit utilization rate according to the time sequence relationship to generate a load sequence table. Perform sliding window analysis on the load sequence table to generate a fluctuation interval table. Construct a resource load prediction model based on the fluctuation interval table to generate a prediction parameter table. Step S302: Based on the prediction parameter table, perform load prediction on hardware resources to establish a trend prediction model, classify and map the prediction results output by the trend prediction model according to resource type to generate a resource prediction table, construct a load warning threshold based on the resource prediction table to generate a load prediction table, and perform resource usage trend analysis on the load prediction table to generate a resource pre-allocation table.

[0063] First, the resource mapping table and resource identifier table output in step S202 are read. The affinity keys and mutual exclusion tags of computing resources, memory resources, and media processing resources are normalized to form a list of monitoring objects. Next, processor load rate, memory usage rate, and media processing unit utilization rate are sampled at a unified clock to fill in dropped frames and anomalies. The three types of indicators within the same time slice are aligned according to resource affinity keys and encoded into a row-column indexable resource monitoring matrix. The sampling interval and scene label are recorded to facilitate subsequent layered analysis.

[0064] Based on the resource monitoring matrix, time-series analysis is performed, sliding along the time axis with a fixed step size to calculate the mean, peak value, and fluctuation amplitude, while also marking the direction of change between adjacent windows. Segments with continuously reversed direction of change are marked with an unstable flag, and cross-validated with mutually exclusive flags to eliminate spurious fluctuations caused by short-term preemption. The processed data generates a load sequence table, establishing a one-to-one mapping between each sequence and its resource affinity key, ensuring that subsequent predictions can be aggregated at the resource cluster level.

[0065] The load sequence list is read by the sliding window analysis process, and time periods for the relaxed, transitional, and stressed zones are defined based on the fluctuation amplitude and instability markers, outputting a fluctuation interval table. Scene labels are read during interval definition to stratify the data and avoid threshold drift caused by the superposition of cross-scene characteristics. For samples near the interval boundaries, buffer markers are added to limit overfitting during model training.

[0066] Based on the fluctuation interval table, a resource load prediction model, "Segment Trend Maker," is trained and instantiated, outputting a prediction parameter table. This model takes stratified sequence segments as input, predicts the occupancy ratio and fluctuation trend over multiple future time slices, and returns the confidence level for each output. To suppress noise, the weights of buffered samples are reduced during training, and low-confidence entries are marked with caution labels during prediction, serving as a reference domain for subsequent threshold generation.

[0067] The prediction parameter table is read by the inference pipeline to establish an online instance of the trend prediction model. This model performs rolling predictions on the current monitoring matrix, outputting occupancy results covering three categories: computing resources, memory resources, and media processing resources. Subsequently, resource type aggregation mappings are generated to produce a resource prediction table, retaining affinity keys for direct lookup with the resource mapping table to quickly identify assemblable resource clusters and potential conflict clusters.

[0068] Based on the resource prediction table, load warning thresholds are calculated. Multi-level thresholds are set by comprehensively considering predicted occupancy, fluctuation trends, and cautious marking, with appropriate tightening of thresholds for resource clusters with high rates of mutual exclusion conflicts. After threshold calculation, a load prediction table is generated, marking the warning level and recommended reservation ratio for each time slice, and recording the source model and version number to ensure consistency in subsequent traceability.

[0069] To facilitate consumption scheduling, a threshold scoring relationship is defined to generate resource pre-allocation entries from the load forecast table: R = b1· + b2· b3· .

[0070] In the formula, R is the pre-assigned score; the The normalized value of the occupancy prediction; The normalized value of the fluctuation tendency; the This is a normalized value of the mutual exclusion conflict probability; b1, b2, and b3 are non-negative weights. This score sorts resource clusters within each time slice, determining the order of reservation and reclamation.

[0071] Based on the scoring results and warning levels, a resource pre-allocation table is generated, specifying time slices, resource clusters, reservation ratios, and reclamation priorities. It also inherits affinity keys and mutual exclusion tags to facilitate direct matching with the scheduling order in step S102. During runtime, the scheduler reads this table before entering a time slice to freeze resources. When a high warning level occurs, low-scoring clusters are released in advance according to the reclamation sequence, thus closing the time-series link of monitoring, prediction, and allocation.

[0072] In one embodiment of the hardware and software adaptation method for video image edge devices and scene algorithms in this application, the method may further include the following: Step S401: Based on the resource pre-allocation table, construct a scheduling executor and establish a scheduling management unit. Label the tasks to be executed with task types to generate a task attribute table. Perform time-series dependency analysis on the tasks in the task attribute table to generate a dependency relationship table. Based on the dependency relationship table, construct a task dependency network to generate a scheduling matrix table. Group the scheduling matrix table according to the task runtime to generate a time slice table. Step S402: Establish a task preemption controller based on the time slice table, mark the task running status according to the preemption priority to generate a preemption status table, construct a task suspension queue according to the preemption status table to generate a task queue list, classify the task queue list according to a preset priority rule to generate a priority mapping table, and schedule and sort the task queue list according to the priority mapping table to generate an execution sequence table.

[0073] First, the resource pre-allocation table generated in steps S301 to S302 is read, and the available resource clusters and their reclamation order are fixed within the current time period, serving as the resource boundaries for the scheduler. Next, the input parameters for the algorithm tasks to be executed, including function category, input / output channels, time limit labels, and estimated runtime, are encoded into unified task entries. Tasks are labeled with task types based on function category and channel type, forming a task attribute table. The aforementioned resource cluster affinity keys are referenced in the entries to ensure that attributes and resource boundaries are linked.

[0074] Based on the task attribute table, temporal dependency analysis is performed to identify dependency pairs according to the data sequence and control signal triggering relationships, and a dependency table is output. During the analysis, the buffer depth and keyframe requirements of the input and output channels are read, and dependency pairs that do not meet the minimum buffer requirements are marked as easily blocking relationships, providing constraints for subsequent network construction. For tasks with cross-module feedback, loop markers are added and their concurrency is limited to avoid unbounded waiting.

[0075] The dependency table is used to construct a task dependency network, mapping task entries to nodes and dependency pairs to directed edges, with blocking and time-limit labels attached to the edges, outputting a scheduling matrix table. To support subsequent grouping, the estimated runtime and resource affinity of each node are written into the node attribute area of ​​the matrix; a mutual exclusion domain is set for the set of edges that cannot be parallelized to ensure that they are not grouped into the same batch.

[0076] Based on the scheduling matrix table, time groups are performed, dividing the time into several intervals according to the estimated runtime and mutual exclusion domains to generate a time slice table. During grouping, priority is given to ensuring that the expansion order of dependent topologies is not disrupted, and resource consumption within each time slice is limited to the reserved proportion in the resource pre-allocation table. Tasks marked with loops are deployed in a layered manner, placing the triggering side first, and then scheduling the feedback side in subsequent time slices to reduce resource contention within the same slice.

[0077] The task preemption controller is instantiated based on the time slice table. Each task's running status is labeled with a preemption priority, and a preemption status table is output. The priority is obtained by weighting three factors: time urgency, resource conflict intensity, and business level. The resource conflict intensity is calculated based on the remaining reservation percentage of the task's time slice and the overlap of mutual exclusion domains. To avoid short-term fluctuations, a minimum hold time is set for newly promoted tasks, ensuring they are not downgraded within this time.

[0078] The preemption status table is read to construct a task suspension queue. Combined with the sequence order of the time slice table, tasks to be run and those that can be suspended are arranged in descending order of priority, and a task queue list is output. For tasks of the uninterruptible type, a non-suspendable flag is set on the entry, allowing replacement only at the time slice boundary; for tasks of the recoverable type, the recovery point period and snapshot size are added to facilitate direct consumption by the subsequent rollback mechanism.

[0079] Based on the task team list, task classification is performed, and a priority mapping table is generated according to preset priority rules. During classification, items within the same business level are bucketed according to their time urgency, and then resource affinity is used as a parallel dispersal factor to avoid clustering of high-affinity items and causing single-cluster congestion. Migration costs are added to items that migrate across time slices to limit frequent jumps between adjacent time slices.

[0080] The priority mapping table is read by the sorting process to schedule and sort the task queue list, outputting an execution sequence list. The sorting follows a two-level strategy: first, between time slices, it is sorted by slice order and high priority first; then, within a slice, it is sorted by affinity priority and estimated shortest priority, while eliminating combinations that conflict with the resource pre-allocation table. For tail entries within a slice that cannot meet resource boundaries, they are postponed to the next time slice while retaining their original priority, avoiding priority oscillations caused by postponement.

[0081] According to the execution sequence list, the scheduling management unit completes resource freezing and container preheating at the beginning of the slice and reads the preemption status table in real time during operation. If a high-priority task is detected to arrive and resources are insufficient, preemption is executed according to the suspendable flag in the queue list, the interruption point is recorded, and a snapshot is triggered. After preemption ends, the execution sequence list remains in effect, and unfinished tasks are filled in the next slice in the original order to ensure that the dependency network is not broken.

[0082] Finally, the execution sequence table, along with the recovery point period in the task attribute table, is submitted to the subsequent state rollback and recovery process in step S402 as input for snapshot triggering and playback order. Thus, the boundaries of resource pre-allocation are strictly enforced within this step, task dependencies are explicitly maintained through a matrix structure, and the resulting execution sequence table provides a directly usable timing control basis for subsequent preemption, suspension, and recovery.

[0083] In one embodiment of the hardware and software adaptation method for video image edge devices and scene algorithms in this application, the method may further include the following: Step S501: Based on the execution sequence list, build a checkpoint manager to establish a state record unit, perform memory mapping on the task running context information to generate a context table, perform state capture on the runtime variables in the context table to generate a variable state table, build a state dictionary based on the variable state table to generate a state mapping table, and index the state mapping table according to the timestamp to generate a checkpoint table. Step S502: Establish a state storage based on the checkpoint table, sample the state of the task execution site according to the checkpoint position to generate a snapshot record table, construct a state storage queue based on the snapshot record table to generate a state snapshot table, save the task state of the state snapshot table to generate a recovery parameter table, and perform task recovery based on the recovery parameter table.

[0084] First, based on the execution sequence list output in steps S401 to S402, the checkpoint manager is enabled within the scheduling management unit, and a status record unit is established according to the time slice entry point and task-level trigger event. The thread stack, handle table, and input buffer offset of each running algorithm container are memory-mapped to generate a context table, and the mapped area is associated with the container identifier and resource affinity key to ensure that subsequent retrieval can quickly locate the container based on time slice.

[0085] Based on the aforementioned context table, fine-grained capture is performed on runtime variables, distinguishing between three categories: read-only configurations, variable counts, and temporary caches, and outputting a variable status table. Before capture, the mutex and affinity tags in the resource pre-allocation table are read to avoid full locking of memory pages in high-conflict areas, instead using page-level copy-on-write to reduce pause time. After capture, each variable is tagged with a persistence tag, indicating the differences between those that can be rebuilt and those that require restoration of the original value.

[0086] The variable state table is normalized, a state dictionary is constructed, and a state mapping table is generated. The state dictionary uniformly registers variable names, memory offsets, serialization strategies, and reconstruction functions, and provides alternative reference keys for non-serializable objects for lazy loading during the recovery phase. To ensure cross-version compatibility, migration mappings are retained in the dictionary for replaced fields, and the source version number is recorded.

[0087] A time index is established based on the state mapping table, binding each capture moment with a time slice number and an internal stage identifier of the container, and outputting a checkpoint table. During index generation, the difference sets of two consecutive captures are fingerprinted to retain fast paths for small differences, and mandatory checkpoints are added at high-frequency stage events to prevent the loss of valid rollback points within long transaction segments.

[0088] A state memory is instantiated based on the checkpoint table. The state of the task execution environment is sampled according to the checkpoint positions to form a snapshot record table. An incremental strategy is used for sampling memory pages, recording only the differing pages, and the sampling is linked to the liveness status of external resource handles. If a handle is about to expire, a replacement allocation instruction is appended to the snapshot. After snapshots are generated, they are enqueued according to time sequence and container identifier to obtain a state memory queue.

[0089] The state storage queue is encapsulated as a state snapshot table, with the necessary read cursors and consistency check values ​​appended for recovery. To reduce merging overhead during recovery, the state snapshot table performs difference merging across multiple snapshots during the enqueue phase, ensuring that each time slice retains at most one directly replayable composite snapshot. Simultaneously, the resource affinity groups that this snapshot depends on are registered, allowing for priority selection of matching nodes during the recovery phase.

[0090] A recovery parameter table is generated based on the state snapshot table. This table includes the recovery entry point, required memory remapping relationships, input buffer replay range, and reconstruction plans for non-serializable objects. During recovery parameter generation, the original ordering position in the execution sequence table is read, and the task to be recovered is inserted before its successor node to avoid disrupting the topological order of dependent networks. If the current resource clusters are insufficient, equivalent mapping is performed using spare clusters in the resource pre-allocation table, and the resource freeze indication for subsequent time slices is updated synchronously.

[0091] Driven by the recovery parameter table, the task recovery is executed. The nearest synthesized snapshot is located using the read cursor. The input buffer is replayed first, and then the variable count and temporary cache are written back item by item according to the state map. Items marked as rebuildable are called with delayed loading of the rebuild function to ensure that the critical path is reset first. After recovery is complete, a success flag and the snapshot version used are written back to the checkpoint manager. Expired snapshots are closed and difference pages are released, forming a traceable closed loop and providing a stable basis for recovery calls in subsequent service interfaces.

[0092] In one embodiment of the hardware and software adaptation method for video image edge devices and scene algorithms in this application, the method may further include the following: Step S601: Based on the recovery parameter table, build an interface manager to establish a service registration unit, classify the edge device function modules into services to generate a function classification table, define the service modules in the function classification table into interfaces to generate an interface definition table, build a service registration center based on the interface definition table to generate a service registry, and standardize the service registry according to the service type to generate an interface description table. Step S602: Based on the interface description table, establish a service wrapper, map the device management, algorithm management, and media stream processing services according to standardized interfaces to generate a service mapping table, construct a service call channel based on the service mapping table to generate a communication interface table, encapsulate the communication interface table into a service to generate a service interface table, and construct a secure channel based on the service interface table to generate an encrypted channel table.

[0093] First, the recovery parameter table and status snapshot table output from steps S501 to S502 are read. Three key fields—container recovery entry, resource affinity group, and playback range—are extracted from the interface side as initial input for interface modeling. Based on this input, the functional modules of the edge device are categorized into service-oriented classes: device management, algorithm management, and media stream processing, outputting a functional classification table. During classification, idempotent markers are added to operations involving recovery, and a foreign key association is established with the container recovery entry to ensure that the interface accurately points to the instance to be recovered.

[0094] Based on the aforementioned functional classification table, interface definitions are developed, clearly defining the request message body, response message body, and error code set, thus generating an interface definition table. During the definition process, consistency verification rules are set for fields involving resource affinity and replay range, and a field selectivity matrix is ​​introduced to limit the source of values ​​under default conditions to the aforementioned recovery parameter table. For long-running operations such as container recovery and stream replay, heartbeat message structures and retry windows are defined to support call stability in weak network scenarios.

[0095] The interface definition table is read by the service registration process to establish a service registry center, register the path, method, and version number of each operation, and output the service registry. To support cross-version compatibility, a field migration mapping is generated during registration. When an old version field is encountered, it is automatically populated back to the new version field, and the migration event is recorded. After registration is completed, the service registry is standardized according to service type, and field naming and error code ranges are unified to generate an interface description table.

[0096] Based on the interface description table, a service wrapper is instantiated to map three types of operations—device management, algorithm management, and media stream processing—to standardized interfaces, outputting a service mapping table. During encapsulation, a serialization strategy and parameter validator are bound to each operation, and the container recovery entry point is compared with the resource affinity group at the entry point. If a conflict is found, a locatable error code is immediately returned without changing the device-side state. To reduce the burden on the client side, response caching is enabled for frequently queried interfaces with expiration times.

[0097] The service mapping table is read by the channel construction process, and a communication interface table is generated based on the operation type and latency sensitivity to select the communication mode. For short transaction operations, a request-response channel is used; for continuous streaming operations, a session channel is established with a heartbeat routing mechanism. The channel side performs monotonicity checks on the replay range and timestamp fields in the message body to prevent out-of-order calls from causing state rollback.

[0098] Service encapsulation is performed on the communication interface table to output a service interface table. During the encapsulation phase, a retry strategy and idempotent keys are injected into each channel to ensure that duplicate recovery requests are executed only once. For subscriptions and keyframe requests involving external media streams, a bandwidth reservation hint field is provided and aligned with the resource affinity group to avoid additional resource contention during time slices in high-pressure zones.

[0099] The service interface table is read by the security construction process, and encryption suites and certificate chains are configured according to service sensitivity levels to establish a secure two-way authentication session, outputting an encrypted channel table. To resist replay attacks, a joint verification of timestamps and one-time random variables is introduced on the channel side, and session identifiers and key derivation information are recorded at the session layer. When certificate expiration or time drift is detected, the channel immediately degrades to a read-only query state, waiting for the certificate to be updated before resuming write operations.

[0100] Finally, the interface description table and the encrypted channel table are registered as callable metadata on the device side for subsequent steps to read. During runtime, the algorithm management receives recovery and pause commands through the service interface table, and the media module performs cached playback through the same channel; all calls are located using foreign keys derived from the recovery parameter table, achieving a seamless connection from state recovery to external services.

[0101] In one embodiment of the hardware and software adaptation method for video image edge devices and scene algorithms in this application, the method may further include the following: Step S701: Based on the service interface table, build a security manager to establish a channel encryption unit, select encryption protocols for service communication data to generate a protocol selection table, perform key negotiation on the encryption parameters in the protocol selection table to generate a key distribution table, build a secure channel generation channel configuration table according to the key distribution table, and generate an encrypted channel table by classifying the channel configuration table according to encryption strength. Step S702: Establish an access controller based on the encrypted channel table, verify the identity of service call requests according to the authentication policy to generate an authentication result table, construct an authorization table based on the authentication result table, perform access control on the authorization table to generate a service call table, and complete the hardware and software adaptation of the edge device based on the service call table.

[0102] First, the service interface table and interface description table output in step S602 are read. A security manager is instantiated on the device side, and the communication channels to be protected are divided into sets based on operation sensitivity and session type. For each channel, message body field constraints and heartbeat policies are extracted as input for encryption parameter selection, ensuring that subsequent negotiations do not violate the timing and idempotency requirements of the interface.

[0103] Encryption protocol selection is performed based on the aforementioned channel set, generating a protocol selection table. The selection process maps operational sensitivity to latency tolerance: high-sensitivity channels such as container recovery and media playback are preferentially assigned stronger suites, while query channels are matched with low-latency suites, and the certificate chain source and session replay protection switch are recorded. For channels with cross-tenant calls, tenant isolation tags are added to limit the key derivation domain and prevent key reuse across tenants.

[0104] The protocol selection table is read by the key negotiation process. Combined with the device's hardware root of trust and time synchronization status, key negotiation is completed, and a key distribution table is output. The distribution table registers the session identifier, master key derivation parameters, and key rolling period. For streaming channels, an additional sub-key segmentation strategy is configured to ensure key freshness within long sessions. Channels that fail to negotiate record the reason for the failure and fall back to a read-only query state, waiting for the certificate and clock to be repaired before retrying.

[0105] A secure channel is constructed based on the key distribution table, and a channel configuration table is output. The configuration process involves binding an encryption suite, replay window, and message integrity verification algorithm to each channel, and aligning sequence numbers and time drift tolerances on both devices. Frame-level verification and sliding window reset commands are enabled for media channels requiring resumable transmission to avoid duplicate consumption caused by out-of-order delivery or retries.

[0106] Based on the channel configuration table, an encrypted channel table is generated by categorizing channels according to encryption strength. After categorization, two-way authentication and key rolling acceleration are enabled for high-strength levels, one-way authentication and a fixed rolling period are enabled for medium-strength levels, and read-only queries and minimum permissions are enforced for low-strength levels. The encrypted channel table retains a mapping key with the service interface table for direct lookup during the access control phase.

[0107] The encrypted channel table is read by the access controller, which verifies the identity of incoming service call requests according to the authentication policy and outputs an authentication result table. The verification process includes certificate validity, session identifier matching, and timestamp monotonicity checks. For failed requests, the source fingerprint and reason for failure are recorded, and rate limiting is triggered to prevent brute-force attempts from overloading device channel resources.

[0108] A permission management module is built based on the authentication result table to generate an authorization table. The authorization table uses the caller's identity, interface operation, and resource scope as three dimensions, combined with the idempotent key in the service interface table and the tenant isolation flag, to provide three categories of judgment: allow, read-only, and deny, along with audit levels. For operations involving container recovery and resource reconfiguration, two-factor authentication is mandatory before permission can be granted.

[0109] Access control is executed according to the authorization table, and a service call table is output. Before allowing access, the control process compares the strength level and operation sensitivity of the encrypted channel table again. If they do not match, the access is downgraded to read-only or directly rejected, and a locatable error code is returned. For approved requests, a call sequence number and session digest are written to facilitate subsequent replay and tracing; for rejected requests, the tenant-side risk threshold is updated to improve the verification strength of same-origin requests in the short term.

[0110] Finally, the service call table serves as the execution entry point for edge device hardware and software adaptation and is consumed by the scheduling system: algorithm management drives container control according to the allowed resumption and pause instructions, device management completes resource configuration and query based on the authorized channels, and the media module performs stream playback within the controlled session. The runtime log synchronously records the version information of the encrypted channel table and the authorization table, providing a traceable basis for subsequent rounds of policy fine-tuning and security auditing.

[0111] To effectively address the shortcomings of traditional technologies in resource management, task scheduling, and service interfaces, and to provide technical support for software and hardware adaptation, this application provides an embodiment of a software and hardware adaptation device for video image edge devices and scene algorithms, used to implement all or part of the software and hardware adaptation method for the aforementioned video image edge device and scene algorithm. See [link to embodiment]. Figure 2 The hardware and software adaptation device for the video image edge device and scene algorithm specifically includes the following: Resource computing module 10 is used to build a hardware abstraction layer based on the hardware resources of edge devices to generate a resource pool table, pool computing resources, memory resources, and media processing resources according to preset resource rules to generate a resource mapping table, build a resource predictor based on the resource mapping table to generate a load prediction table, perform resource usage trend analysis on the load prediction table to generate a resource pre-allocation table, and call the resource pre-allocation table as an input parameter of the scheduling system. The task execution module 20 is used to construct a preemptive recovery scheduling system based on the resource pre-allocation table to generate a task queue list, classify the algorithm tasks to be executed according to preset priority rules to generate a priority mapping table, and sort the task queue list according to the priority mapping table to generate an execution sequence list, which is used for the scheduling control of the algorithm container; construct a state rollback mechanism based on the execution sequence list to generate a state snapshot table, and save the task state of the state snapshot table to generate a recovery parameter table, which is used for task recovery; The software and hardware adaptation module 30 is used to construct a service-oriented interface based on the recovery parameter table to generate an interface description table, encapsulate device management, algorithm management, and media stream processing into a service interface table according to preset interface rules, construct a secure channel based on the service interface table to generate an encrypted channel table, perform access control on the encrypted channel table to generate a service call table, and deploy the service call table to the edge device for software and hardware adaptation.

[0112] As described above, the hardware and software adaptation device for video image edge devices and scene algorithms provided in this application embodiment can achieve effective resource allocation through pooling processing and predictive analysis. A scheduling mechanism is constructed, combining priority sorting and state rollback to establish a reliable task processing strategy. A service-oriented interface is introduced, and system security is ensured through secure channels and access control. This method effectively solves the shortcomings of traditional technologies in resource management, task scheduling, and service interfaces, providing technical support for hardware and software adaptation.

[0113] From a hardware perspective, in order to effectively address the shortcomings of traditional technologies in resource management, task scheduling, and service interfaces, and to provide technical support for software and hardware adaptation, this application provides an embodiment of an electronic device for implementing all or part of the software and hardware adaptation method for video image edge devices and scene algorithms. The electronic device specifically includes the following components: The system comprises a processor, memory, a communications interface, and a bus; wherein the processor, memory, and communications interface communicate with each other via the bus; the communications interface is used to realize information transmission between the hardware and software adaptation device for video image edge devices and scene algorithms and related devices such as core business systems, user terminals, and related databases; the logic controller can be a desktop computer, tablet computer, or mobile terminal, etc., and this embodiment is not limited to these. In this embodiment, the logic controller can be implemented with reference to the embodiments of the hardware and software adaptation method for video image edge devices and scene algorithms in the embodiments, and the embodiments of the hardware and software adaptation device for video image edge devices and scene algorithms are incorporated herein, and repeated details will not be described again.

[0114] It is understood that the user terminal may include smartphones, tablet computers, network set-top boxes, portable computers, desktop computers, personal digital assistants (PDAs), in-vehicle devices, smart wearable devices, etc. Among these, the smart wearable devices may include smart glasses, smartwatches, smart bracelets, etc.

[0115] In practical applications, the hardware and software adaptation method for video image edge devices and scene algorithms can be executed on the electronic device side as described above, or all operations can be completed in the client device. The choice can be made based on the processing power of the client device and the limitations of the user's usage scenario. This application does not impose any limitations on this. If all operations are completed in the client device, the client device may further include a processor.

[0116] The aforementioned client device may have a communication module (i.e., a communication unit) that can communicate with a remote server to achieve data transmission with the server. The server may include a server on the task scheduling center side; in other implementation scenarios, it may also include a server on an intermediate platform, such as a server on a third-party server platform that has a communication link with the task scheduling center server. The server may include a single computer device, a server cluster consisting of multiple servers, or a distributed server structure.

[0117] Figure 3This is a schematic block diagram illustrating the system configuration of the electronic device 9600 according to an embodiment of this application. Figure 3 As shown, the electronic device 9600 may include a central processing unit 9100 and a memory 9140; the memory 9140 is coupled to the central processing unit 9100. It is worth noting that... Figure 3 This is an example; other types of structures can also be used to supplement or replace this structure to achieve telecommunications functions or other functions.

[0118] In one embodiment, the hardware and software adaptation method for video image edge devices and scene algorithms can be integrated into the central processing unit 9100. The central processing unit 9100 can be configured to perform the following control: Step S101: Based on the hardware resources of the edge device, a hardware abstraction layer is constructed to generate a resource pool table. Computing resources, memory resources, and media processing resources are pooled and managed according to preset resource rules to generate a resource mapping table. A resource predictor is constructed based on the resource mapping table to generate a load prediction table. Resource usage trend analysis is performed on the load prediction table to generate a resource pre-allocation table. The resource pre-allocation table is called as an input parameter of the scheduling system. Step S102: Based on the resource pre-allocation table, a preemption recovery scheduling system is constructed to generate a task queue list. The tasks to be executed are classified according to a preset priority rule to generate a priority mapping table. The task queue list is sorted according to the priority mapping table to generate an execution sequence table, which is used for scheduling control of the algorithm container. Based on the execution sequence table, a state rollback mechanism is constructed to generate a state snapshot table. The task state of the state snapshot table is saved to generate a recovery parameter table, which is used for task recovery. Step S103: Based on the recovery parameter table, construct a service-oriented interface to generate an interface description table. Encapsulate device management, algorithm management, and media stream processing into a service interface table according to preset interface rules. Construct a secure channel to generate an encrypted channel table based on the service interface table. Perform access control on the encrypted channel table to generate a service call table. Deploy the service call table to the edge device for software and hardware adaptation.

[0119] As described above, the electronic device provided in this application embodiment achieves efficient resource allocation through pooling and predictive analytics. A scheduling mechanism is constructed, combining priority sorting and state rollback to establish a reliable task processing strategy. Service-oriented interfaces are introduced, and system security is ensured through secure channels and access control. This method effectively addresses the shortcomings of traditional technologies in resource management, task scheduling, and service interfaces, providing technical support for software and hardware adaptation.

[0120] In another embodiment, the hardware and software adaptation device for the video image edge device and scene algorithm can be configured separately from the central processing unit 9100. For example, the hardware and software adaptation device for the video image edge device and scene algorithm can be configured as a chip connected to the central processing unit 9100, and the hardware and software adaptation method function of the video image edge device and scene algorithm can be realized through the control of the central processing unit.

[0121] like Figure 3 As shown, the electronic device 9600 may further include: a communication module 9110, an input unit 9120, an audio processor 9130, a display 9160, and a power supply 9170. It is worth noting that the electronic device 9600 does not necessarily need to include these components. Figure 3 All components shown; in addition, the electronic device 9600 may also include Figure 3 For components not shown, please refer to existing technologies.

[0122] like Figure 3 As shown, the central processing unit 9100, sometimes also referred to as a controller or operating control, may include a microprocessor or other processor device and / or logic device, which receives inputs and controls the operation of various components of the electronic device 9600.

[0123] The memory 9140 may be, for example, one or more of a cache, flash memory, hard drive, removable media, volatile memory, non-volatile memory, or other suitable devices. It may store the aforementioned failure-related information, and also store a program for executing that information. The central processing unit 9100 may execute the program stored in the memory 9140 to perform information storage or processing, etc.

[0124] Input unit 9120 provides input to central processing unit 9100. Input unit 9120 may be, for example, a keypad or touch input device. Power supply 9170 provides power to electronic device 9600. Display 9160 displays images and text. Display may be, for example, an LCD display, but is not limited thereto.

[0125] The memory 9140 can be a solid-state memory, such as a read-only memory (ROM), random access memory (RAM), a SIM card, etc. It can also be a memory that retains information even when power is off, can be selectively erased, and contains more data; examples of this type of memory are sometimes referred to as EPROMs. The memory 9140 can also be some other type of device. The memory 9140 includes a buffer memory 9141 (sometimes referred to as a buffer). The memory 9140 may include an application / function storage unit 9142 for storing application programs and function programs or processes for executing the operation of the electronic device 9600 via the central processing unit 9100.

[0126] The memory 9140 may also include a data storage unit 9143 for storing data, such as contacts, digital data, pictures, sounds, and / or any other data used by the electronic device. The driver storage unit 9144 of the memory 9140 may include various drivers for the electronic device for communication functions and / or for performing other functions of the electronic device (such as messaging applications, address book applications, etc.).

[0127] The communication module 9110 is a transmitter / receiver that sends and receives signals via the antenna 9111. The communication module 9110 (transmitter / receiver) is coupled to the central processing unit 9100 to provide input signals and receive output signals, which is the same as in a conventional mobile communication terminal.

[0128] Based on different communication technologies, multiple communication modules 9110 can be configured in the same electronic device, such as cellular network modules, Bluetooth modules, and / or wireless LAN modules. The communication module 9110 (transmitter / receiver) is also coupled to a speaker 9131 and a microphone 9132 via an audio processor 9130 to provide audio output via the speaker 9131 and receive audio input from the microphone 9132, thereby realizing typical telecommunications functions. The audio processor 9130 may include any suitable buffer, decoder, amplifier, etc. Additionally, the audio processor 9130 is coupled to a central processing unit 9100, enabling on-device recording via the microphone 9132 and on-device playback of stored audio via the speaker 9131.

[0129] Embodiments of this application also provide a computer-readable storage medium capable of implementing all steps of the software and hardware adaptation method for video image edge devices and scene algorithms with the execution subject being a server or client in the above embodiments. The computer-readable storage medium stores a computer program that, when executed by a processor, implements all steps of the software and hardware adaptation method for video image edge devices and scene algorithms with the execution subject being a server or client in the above embodiments. For example, when the processor executes the computer program, it implements the following steps: Step S101: Based on the hardware resources of the edge device, a hardware abstraction layer is constructed to generate a resource pool table. Computing resources, memory resources, and media processing resources are pooled and managed according to preset resource rules to generate a resource mapping table. A resource predictor is constructed based on the resource mapping table to generate a load prediction table. Resource usage trend analysis is performed on the load prediction table to generate a resource pre-allocation table. The resource pre-allocation table is called as an input parameter of the scheduling system. Step S102: Based on the resource pre-allocation table, a preemption recovery scheduling system is constructed to generate a task queue list. The tasks to be executed are classified according to a preset priority rule to generate a priority mapping table. The task queue list is sorted according to the priority mapping table to generate an execution sequence table, which is used for scheduling control of the algorithm container. Based on the execution sequence table, a state rollback mechanism is constructed to generate a state snapshot table. The task state of the state snapshot table is saved to generate a recovery parameter table, which is used for task recovery. Step S103: Based on the recovery parameter table, construct a service-oriented interface to generate an interface description table. Encapsulate device management, algorithm management, and media stream processing into a service interface table according to preset interface rules. Construct a secure channel to generate an encrypted channel table based on the service interface table. Perform access control on the encrypted channel table to generate a service call table. Deploy the service call table to the edge device for software and hardware adaptation.

[0130] As described above, the computer-readable storage medium provided in this application embodiment achieves efficient resource allocation through pooling processing and predictive analytics. A scheduling mechanism is constructed, combining priority sorting and state rollback to establish a reliable task processing strategy. A service-oriented interface is introduced, and system security is ensured through secure channels and access control. This method effectively addresses the shortcomings of traditional technologies in resource management, task scheduling, and service interfaces, providing technical support for software and hardware adaptation.

[0131] Embodiments of this application also provide a computer program product capable of implementing all steps in the software and hardware adaptation method for video image edge devices and scene algorithms, where the execution subject is a server or client, as described in the above embodiments. When executed by a processor, this computer program / instruction implements the steps of the software and hardware adaptation method for video image edge devices and scene algorithms. For example, the computer program / instruction implements the following steps: Step S101: Based on the hardware resources of the edge device, a hardware abstraction layer is constructed to generate a resource pool table. Computing resources, memory resources, and media processing resources are pooled and managed according to preset resource rules to generate a resource mapping table. A resource predictor is constructed based on the resource mapping table to generate a load prediction table. Resource usage trend analysis is performed on the load prediction table to generate a resource pre-allocation table. The resource pre-allocation table is called as an input parameter of the scheduling system. Step S102: Based on the resource pre-allocation table, a preemption recovery scheduling system is constructed to generate a task queue list. The tasks to be executed are classified according to a preset priority rule to generate a priority mapping table. The task queue list is sorted according to the priority mapping table to generate an execution sequence table, which is used for scheduling control of the algorithm container. Based on the execution sequence table, a state rollback mechanism is constructed to generate a state snapshot table. The task state of the state snapshot table is saved to generate a recovery parameter table, which is used for task recovery. Step S103: Based on the recovery parameter table, construct a service-oriented interface to generate an interface description table. Encapsulate device management, algorithm management, and media stream processing into a service interface table according to preset interface rules. Construct a secure channel to generate an encrypted channel table based on the service interface table. Perform access control on the encrypted channel table to generate a service call table. Deploy the service call table to the edge device for software and hardware adaptation.

[0132] As described above, the computer program product provided in this application embodiment achieves efficient resource allocation through pooling and predictive analytics. A scheduling mechanism is constructed, combining priority sorting and state rollback to establish a reliable task processing strategy. Service-oriented interfaces are introduced, and system security is ensured through secure channels and access control. This method effectively addresses the shortcomings of traditional technologies in resource management, task scheduling, and service interfaces, providing technical support for software and hardware adaptation.

[0133] Those skilled in the art will understand that embodiments of the present invention can be provided as methods, apparatus, or computer program products. Therefore, the present invention can take the form of a completely hardware embodiment, a completely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, the present invention can take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, etc.) containing computer-usable program code.

[0134] This invention is described with reference to flowchart illustrations and / or block diagrams of methods, apparatus (devices), and computer program products according to embodiments of the invention. It will be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, special-purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, generate instructions for implementing the flowchart illustrations and / or block diagrams. Figure 1 One or more processes and / or boxes Figure 1 A device that provides the functions specified in one or more boxes.

[0135] These computer program instructions may also be stored in a computer-readable storage medium that can direct a computer or other programmable data processing device to function in a particular manner, such that the instructions stored in the computer-readable storage medium produce an article of manufacture including instruction means, which are implemented in a process Figure 1 One or more processes and / or boxes Figure 1 The function specified in one or more boxes.

[0136] These computer program instructions may also be loaded onto a computer or other programmable data processing equipment to cause a series of operational steps to be performed on the computer or other programmable equipment to produce a computer-implemented process, thereby providing instructions that execute on the computer or other programmable equipment for implementing the process. Figure 1 One or more processes and / or boxes Figure 1 The steps of the function specified in one or more boxes.

[0137] Specific embodiments have been used to illustrate the principles and implementation methods of this invention. The descriptions of the embodiments above are only for the purpose of helping to understand the method and core ideas of this invention. At the same time, for those skilled in the art, there will be changes in the specific implementation methods and application scope based on the ideas of this invention. Therefore, the content of this specification should not be construed as a limitation of this invention.

Claims

1. A hardware and software adaptation method for video image edge devices and scene algorithms, characterized in that, The method includes: Based on the hardware resources of edge devices, a hardware abstraction layer is constructed to generate a resource pool table. Computing resources, memory resources, and media processing resources are pooled and managed according to preset resource rules to generate a resource mapping table. A resource predictor is constructed based on the resource mapping table to generate a load prediction table. Resource usage trend analysis is performed on the load prediction table to generate a resource pre-allocation table. The resource pre-allocation table is called as an input parameter of the scheduling system. Based on the resource pre-allocation table, a preemptive recovery scheduling system is constructed to generate a task queue list. The algorithm tasks to be executed are classified according to preset priority rules to generate a priority mapping table. The task queue list is scheduled and sorted according to the priority mapping table to generate an execution sequence table, which is used for scheduling control of the algorithm container. Based on the execution sequence table, a state rollback mechanism is constructed to generate a state snapshot table. The task state of the state snapshot table is saved to generate a recovery parameter table, which is used for task recovery. Based on the recovery parameter table, a service-oriented interface is constructed to generate an interface description table. Device management, algorithm management, and media stream processing are encapsulated into services according to preset interface rules to generate a service interface table. A secure channel is constructed based on the service interface table to generate an encrypted channel table. Access control is applied to the encrypted channel table to generate a service call table. The service call table is then deployed to edge devices for hardware and software adaptation.

2. The software and hardware adaptation method for video image edge devices and scene algorithms according to claim 1, characterized in that, The hardware abstraction layer based on edge device hardware resources generates a resource pool table, and pools computing resources, memory resources, and media processing resources according to preset resource rules to generate a resource mapping table, including: A hardware feature vector is established based on the processor architecture information of the edge device. A unit distribution table is generated by dividing the computing unit clusters according to the processor instruction set type. A computing power evaluation table is generated by evaluating the performance of each computing unit cluster. The computing power evaluation table is mapped hierarchically according to the computing density index to generate a resource hierarchy table. A computing task distributor is constructed based on the resource hierarchy table to generate a task routing table. A resource scheduling model is established based on the task routing table. Computing resources, memory resources, and media processing resources are grouped and encoded according to the resource hierarchy table to generate a resource identifier table. A hardware abstraction interface is constructed based on the resource identifier table to generate a scheduling mapping table. The scheduling mapping table is then processed to generate a resource mapping table.

3. The software and hardware adaptation method for video image edge devices and scene algorithms according to claim 1, characterized in that, The process of constructing a resource predictor based on the resource mapping table to generate a load prediction table, performing resource usage trend analysis on the load prediction table to generate a resource pre-allocation table, and using the resource pre-allocation table as input parameters of the scheduling system includes: Based on the resource mapping table, hardware resource load features are extracted to construct a resource monitoring matrix. Processor load rate, memory usage rate, and media processing unit utilization rate are sampled according to time sequence to generate a load sequence table. The load sequence table is analyzed by sliding window to generate a fluctuation interval table. Based on the fluctuation interval table, a resource load prediction model is constructed to generate a prediction parameter table. Based on the prediction parameter table, a trend prediction model is established to predict the load of hardware resources. The prediction results output by the trend prediction model are classified and mapped according to resource type to generate a resource prediction table. Based on the resource prediction table, a load warning threshold is constructed to generate a load prediction table. The load prediction table is then analyzed for resource usage trends to generate a resource pre-allocation table.

4. The software and hardware adaptation method for video image edge devices and scene algorithms according to claim 1, characterized in that, The step of constructing a preemptive recovery scheduling system based on the resource pre-allocation table to generate a task queue list, classifying the tasks to be executed according to preset priority rules to generate a priority mapping table, and scheduling and sorting the task queue list according to the priority mapping table to generate an execution sequence list includes: Based on the resource pre-allocation table, a scheduling executor is constructed to establish a scheduling management unit. The tasks to be executed are labeled with task types to generate a task attribute table. The tasks in the task attribute table are subjected to time-series dependency analysis to generate a dependency relationship table. Based on the dependency relationship table, a task dependency network is constructed to generate a scheduling matrix table. The scheduling matrix table is grouped according to the task runtime to generate a time slice table. A task preemption controller is established based on the time slice table. The task running status is marked according to the preemption priority to generate a preemption status table. A task suspension queue is constructed according to the preemption status table to generate a task queue list. The task queue list is classified according to a preset priority rule to generate a priority mapping table. The task queue list is scheduled and sorted according to the priority mapping table to generate an execution sequence table.

5. The software and hardware adaptation method for video image edge devices and scene algorithms according to claim 1, characterized in that, The process involves constructing a state rollback mechanism based on the execution sequence list to generate a state snapshot table, saving the task state of the state snapshot table to generate a recovery parameter table, which is used for task recovery, including: A checkpoint manager is built based on the execution sequence list to establish a state recording unit. The task execution context information is memory-mapped to generate a context table. The runtime variables in the context table are state-captured to generate a variable state table. A state dictionary is built based on the variable state table to generate a state mapping table. The state mapping table is indexed by timestamps to generate a checkpoint table. A state memory is established based on the checkpoint table. The state of the task execution site is sampled according to the checkpoint position to generate a snapshot record table. A state storage queue is constructed based on the snapshot record table to generate a state snapshot table. The task state is saved on the state snapshot table to generate a recovery parameter table. The task is recovered based on the recovery parameter table.

6. The software and hardware adaptation method for video image edge devices and scene algorithms according to claim 1, characterized in that, The step of constructing a service-oriented interface based on the recovery parameter table to generate an interface description table, and encapsulating device management, algorithm management, and media stream processing into a service interface table according to preset interface rules, includes: Based on the recovery parameter table, an interface manager is built to establish a service registration unit. The functional modules of the edge devices are classified into services to generate a functional classification table. The service modules in the functional classification table are defined into interfaces to generate an interface definition table. Based on the interface definition table, a service registration center is built to generate a service registry. The service registry is standardized according to the service type to generate an interface description table. A service encapsulator is established based on the interface description table. Device management, algorithm management, and media stream processing services are mapped according to standardized interfaces to generate a service mapping table. A service call channel is constructed based on the service mapping table to generate a communication interface table. The communication interface table is encapsulated into a service to generate a service interface table. A secure channel is constructed based on the service interface table to generate an encrypted channel table.

7. The software and hardware adaptation method for video image edge devices and scene algorithms according to claim 1, characterized in that, The step of constructing a secure channel and generating an encrypted channel table based on the service interface table, performing access control on the encrypted channel table to generate a service call table, and deploying the service call table to edge devices for software and hardware adaptation includes: Based on the service interface table, a security manager is built to establish a channel encryption unit. The service communication data is encrypted to select the encryption protocol to generate a protocol selection table. The encryption parameters in the protocol selection table are negotiated to generate a key distribution table. A secure channel is built according to the key distribution table to generate a channel configuration table. The channel configuration table is classified according to the encryption strength to generate an encrypted channel table. An access controller is established based on the encrypted channel table. Service call requests are verified according to the authentication policy to generate an authentication result table. An authorization table is generated based on the authentication result table. Access control is performed on the authorization table to generate a service call table. The hardware and software adaptation of the edge device is completed based on the service call table.

8. A hardware and software adaptation device for video image edge devices and scene algorithms, characterized in that, The device includes: The resource computing module is used to build a hardware abstraction layer based on the hardware resources of the edge device to generate a resource pool table, pool computing resources, memory resources, and media processing resources according to preset resource rules to generate a resource mapping table, build a resource predictor based on the resource mapping table to generate a load prediction table, perform resource usage trend analysis on the load prediction table to generate a resource pre-allocation table, and call the resource pre-allocation table as an input parameter of the scheduling system. The task execution module is used to construct a preemptive recovery scheduling system based on the resource pre-allocation table to generate a task queue list, classify the algorithm tasks to be executed according to preset priority rules to generate a priority mapping table, and sort the task queue list according to the priority mapping table to generate an execution sequence list, which is used for scheduling control of the algorithm container; and to construct a state rollback mechanism based on the execution sequence list to generate a state snapshot table, and save the task state of the state snapshot table to generate a recovery parameter table, which is used for task recovery. The software and hardware adaptation module is used to construct a service-oriented interface based on the recovery parameter table to generate an interface description table, encapsulate device management, algorithm management, and media stream processing into a service interface table according to preset interface rules, construct a secure channel based on the service interface table to generate an encrypted channel table, perform access control on the encrypted channel table to generate a service call table, and deploy the service call table to the edge device for software and hardware adaptation.

9. An electronic device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, characterized in that, When the processor executes the program, it implements the steps of the software and hardware adaptation method for video image edge devices and scene algorithms as described in any one of claims 1 to 7.

10. A computer-readable storage medium having a computer program stored thereon, characterized in that, When executed by a processor, the computer program implements the steps of the hardware and software adaptation method for video image edge devices and scene algorithms as described in any one of claims 1 to 7.

Images