An interactive resource scheduling and use input optimization system of a smart blackboard

Abstract

This application relates to the technical field of smart blackboards and discloses an interactive resource scheduling and utilization optimization system for smart blackboards. The system includes a task module that instantiates multimodal interactions into task nodes through intent parsing and associates them with resource nodes to form a dynamic interactive topology; an edge weight module that dynamically calculates the weights of the topology edges based on task demand intensity, resource load, and energy consumption; a decision module that transforms task nodes into agents and, through weight-based multi-round local policy interactions and conflict negotiation, enables the system to converge to a Nash equilibrium state in resource allocation; and a resource control module that issues precise control commands based on the equilibrium matching relationship. This system solves the problems of rigid resource allocation, insufficient real-time performance, and low energy efficiency in smart blackboards under concurrent multi-task interaction, achieving adaptive, high real-time, and low-energy resource scheduling based on interactive intents.

Description

Technical Field

[0001] This application relates to the technical field of intelligent blackboard resource scheduling, and discloses an interactive resource scheduling and usage optimization system for intelligent blackboards. Background Technology

[0002] With the increasing prevalence of smart blackboards in teaching, their integrated multimodal interaction methods, including touch, handwriting, voice, and gestures, place higher demands on the real-time scheduling of underlying computing resources. Existing smart blackboard operating system resource scheduling methods largely follow general strategies from traditional mobile devices or desktop systems, which have several shortcomings. For example, traditional schedulers receive abstract requests at the process / thread level and cannot understand specific interactive semantics such as handwriting rendering and gesture page turning, leading to a disconnect between resource allocation and actual needs, making fine-grained management difficult. When multiple interactive tasks occur concurrently, general scheduling strategies easily cause contention for GPU or CPU cores, resulting in interaction delays and rendering stutters. Furthermore, they cannot dynamically adjust hardware operating states according to actual task requirements, leading to resource idleness or overload and low energy efficiency. Existing methods are mostly centralized, predefined static rule scheduling, which cannot adapt to the sudden and variable nature of interactive tasks in smart blackboard teaching scenarios. They lack a mechanism for autonomous negotiation and rapid decision-making among multiple tasks based on real-time system states, making it difficult for the system as a whole to quickly achieve an efficient, fair, and stable allocation state. Finally, the issuance and execution of resource allocation instructions lack real-time feedback channels, and scheduling strategies cannot be adjusted online based on execution results. Summary of the Invention

[0003] The purpose of this section is to outline some aspects of the embodiments of this application and to briefly describe some preferred embodiments. Simplifications or omissions may be made in this section, as well as in the abstract and title of this application, to avoid obscuring the purpose of these documents, and such simplifications or omissions should not be construed as limiting the scope of this application.

[0004] To address the aforementioned technical issues, this application provides an interactive resource scheduling and utilization optimization system for a smart blackboard.

[0005] On the one hand, this application provides an interactive resource scheduling and usage optimization system for a smart blackboard, including...

[0006] The task module instantiates each interactive task in the smart blackboard as a task node and each physical computing resource as a resource node. Based on the real-time resource requirements of the task nodes, directed edges are established from the task nodes to the resource nodes, forming a dynamic interactive topology. The edge weight module calculates and dynamically updates the weight value for each directed edge in the interactive topology. The weight value is determined by the real-time demand intensity of the task node and the real-time load and energy consumption status of the resource node. The decision module transforms each task node into participation data, and calculates a local selection strategy based on the weight of the connected edges. Through multiple rounds of information interaction and conflict negotiation, the strategy of the participation data converges to a resource allocation equilibrium. Based on the matching relationship between each task node and resource node determined by the balanced state, the resource control module sends control commands to the smart blackboard operating system to adjust the working state of computing resources.

[0007] As a preferred embodiment of the interactive resource scheduling and utilization optimization system for a smart blackboard according to this application, wherein: The task module collects raw interactive data streams from touch, handwriting, voice, and images through multimodal interactive sensors on the smart blackboard; The original interactive data stream is input into a pre-trained intent recognition model, and the intent recognition model outputs the operation type classification and operation semantic vector of the current interaction. Based on the operation type classification and operation semantic vector, the resource requirement mapping table is invoked to parse out the combination of resource types required for the interactive task, quantify the intensity of resource requirements, and generate dynamic priority labels based on whether the interaction context is a teacher's main operation or a high-priority in-application operation to characterize the priority level of the task in resource competition. These labels are divided into three levels: high, medium, and low, and determined as feature vectors. Each independent and continuously occupied interaction process is instantiated as a task node carrying the aforementioned feature vector; the central processing unit core, graphics processing unit, memory block and network interface card in the smart blackboard are registered as resource nodes respectively, and each resource node is associated with its unique hardware identifier, measurable initial performance parameters and real-time availability and power consumption status provided by the system kernel.

[0008] As a preferred embodiment of the interactive resource scheduling and utilization optimization system for a smart blackboard according to this application, wherein: The task module matches the resource requirement type parsed from the feature vector with the resource capability type represented by the hardware identifier of each resource node, and creates a directed edge for each task node pointing to one or more matching candidate resource nodes. If the resource type combination includes graphics rendering, then a directed edge is created for the task node pointing to all graphics processor unit resource nodes; If the resource type combination includes general computing or speech / image recognition, then a directed edge is created for the task node pointing to all central processing unit core resource nodes; If the resource type combination contains data caching, then create directed edges for that task node pointing to all available memory block resource nodes; If the resource type combination includes real-time transmission, then a directed edge pointing to the network interface card resource node is created for that task node.

[0009] As a preferred embodiment of the interactive resource scheduling and utilization optimization system for a smart blackboard according to this application, wherein: The dynamic interactive topology structure uses all instantiated task nodes and resource nodes as vertices and directed edges representing real-time demand relationships in the task modules as connections to construct an initial topology graph. The dynamic interaction topology is updated in real time. When a new task node is instantiated, the current node and its directed edges are added. When the real-time performance status or real-time power consumption status of a resource node changes, its node attributes are updated. When the interaction request corresponding to a task node is completed, the current node and all its associated directed edges are removed from the dynamic interaction topology.

[0010] As a preferred embodiment of the interactive resource scheduling and utilization optimization system for a smart blackboard according to this application, wherein: The edge weight module periodically obtains the quantized resource demand intensity from the feature vector of the task node from the task module, and obtains the current load state and current power consumption state from the resource node. Based on the resource demand intensity, the current load state, and the current power consumption state, a comprehensive weight calculation is performed to obtain the current weight value of each directed edge; When a preset change in the resource demand intensity of any task node is detected, or when the current load state of any resource node exceeds the load threshold or the power consumption state exceeds the power consumption threshold, the weight value of the associated directed edge is immediately updated.

[0011] As a preferred embodiment of the interactive resource scheduling and utilization optimization system for a smart blackboard according to this application, wherein: The comprehensive weight calculation results in a weight value that is positively correlated with the intensity of resource demand and negatively correlated with the current load state and current power consumption state of the resource node.

[0012] As a preferred embodiment of the interactive resource scheduling and utilization optimization system for a smart blackboard according to this application, wherein: The decision-making module transforms each task node into participating data by creating an independent decision agent for each task node; Each decision agent reads the current weight values ​​of all directed edges connected to the task node and generates a local selection strategy based on the current weight values ​​of all directed edges connected to the task node. The local selection strategy is expressed as a selection probability distribution for each connected resource node. The selection probability is positively correlated with the weight value of the corresponding directed edge. Specifically, the selection probability of a single resource node is expressed as: the weight value of the edge corresponding to the node / the sum of the weight values ​​of all connected edges.

[0013] As a preferred embodiment of the interactive resource scheduling and utilization optimization system for a smart blackboard according to this application, wherein: In each round of information interaction and conflict negotiation, each decision agent randomly selects a resource node based on the probability distribution of the local selection strategy and broadcasts the randomly selected resource node through a shared message channel. Each decision agent simultaneously receives selection intentions broadcast by other decision agents; Each decision agent checks whether its preferred resource node conflicts with the choices of other agents, i.e., multiple agents have chosen the same resource node; If a conflict is detected, the relevant decision-making agent adjusts the selection according to the negotiation rules. The priority of the negotiation rules is as follows: first, compare the directed edge weights of the conflicting parties, and the one with the higher weight value obtains the right to occupy resources in this round; if the weight values ​​are the same, compare the dynamic priority labels of the task nodes, and the one with the higher priority obtains the right to occupy resources in this round; if the priorities are still the same, execute a random backoff mechanism to determine the right to occupy resources in this round.

[0014] As a preferred embodiment of the interactive resource scheduling and utilization optimization system for a smart blackboard according to this application, wherein: The strategies for participating in data converge to a resource allocation equilibrium through multiple rounds of information exchange and negotiation. At this point, the local selection strategies of all decision agents no longer change, achieving a stable task resource matching state. The resource allocation equilibrium is a Nash equilibrium state: in the Nash equilibrium state, no decision-making agent can obtain better expected returns by unilaterally changing its own resource selection strategy; The expected return is calculated by the return function. The current return of the decision agent is equal to the sum of the comprehensive weight values ​​of the directed edges corresponding to all selected resource nodes, minus the penalty value caused by resource conflicts with other agents. The penalty value is the number of conflicts × the current load coefficient L of the resource node × A. In each round of information interaction, the decision agent maximizes the value of the payoff function by adjusting its local selection strategy.

[0015] As a preferred embodiment of the interactive resource scheduling and utilization optimization system for a smart blackboard according to this application, wherein: The resource control module parses the matching relationship between each task node and resource node determined by the equilibrium state; The resource control module generates a sequence of underlying control instructions based on the type of resource nodes and their associated hardware identifiers in the matching relationship. The instruction sequence includes setting the operating frequency of a specified computing unit, adjusting the priority of a rendering unit, and allocating memory cache space; The instruction sequence is sent to the kernel scheduler and hardware driver of the smart blackboard operating system; After the instruction sequence is executed, the actual working status and real-time energy consumption of each resource node are monitored, and the actual working status and real-time energy consumption are fed back to the edge weight module to update the current load status and current power consumption status of the resource node.

[0016] The beneficial effects of this application are as follows: This application performs online intent parsing and feature extraction on multimodal interaction data through a task module, transforming the interaction into task nodes carrying clear operational semantics, quantified demand intensity, and priority labels, and constructing a dynamic topology graph by associating them with physical resource nodes. This enables the scheduling system to understand the essence of the task.

[0017] This application uses an edge weighting module to comprehensively consider the intensity of task demand, real-time resource load, and energy consumption status to calculate dynamic weights for each task resource connection edge. The weights reflect the value and cost of selecting specific resources in the current environment, so that scheduling decisions are no longer based solely on queue length or simple priority, but incorporate energy efficiency and real-time load considerations, providing guidance for optimizing resource selection.

[0018] This application transforms task nodes into autonomous decision-making agents through a decision-making module, and performs local strategy calculations and multi-round information interaction negotiations based on edge weights, simulating a distributed competition and cooperation process. This enables the system to quickly converge to an equilibrium state, in which no task agent is willing to unilaterally change its choice. As a result, the overall resource load is relatively balanced, conflicts are minimized, and the needs of high-priority tasks are respected, thereby improving the response speed of the smart blackboard to teacher interaction commands.

[0019] This application generates and issues hardware control commands through a resource control module, while monitoring the actual status after execution and feeding it back to the edge weight module. This allows the weight calculation to be updated based on the latest interaction commands, thereby influencing the next round of decision-making. This enables the smart blackboard to have the ability to adapt online and continuously optimize, effectively improving resource utilization and energy efficiency. Attached Figure Description

[0020] To more clearly illustrate the technical solutions of the embodiments of this application, the drawings used in the description of the embodiments will be briefly introduced below. Obviously, the drawings described below are only some embodiments of this application. For those skilled in the art, other drawings can be obtained through these drawings without creative effort. Wherein: Figure 1 The overall system flowchart of an interactive resource scheduling and utilization optimization system for a smart blackboard provided in this application; Figure 2 This application provides a flowchart of task instantiation and topology construction for an interactive resource scheduling and utilization optimization system for a smart blackboard. Figure 3 A flowchart of edge weight calculation and update for an interactive resource scheduling and usage optimization system for a smart blackboard provided in this application; Figure 4 The following is a flowchart of the decision agent negotiation and Nash equilibrium convergence of an interactive resource scheduling and usage optimization system for a smart blackboard provided in this application; Figure 5 This application provides a flowchart of the resource control and feedback adjustment process for an interactive resource scheduling and usage optimization system for a smart blackboard. Detailed Implementation

[0021] To make the above-mentioned objectives, features and advantages of this application more apparent and understandable, the specific embodiments of this application will be described in detail below with reference to the accompanying drawings.

[0022] Many specific details are set forth in the following description in order to provide a full understanding of this application. However, this application may also be implemented in other ways different from those described herein. Those skilled in the art can make similar extensions without departing from the spirit of this application. Therefore, this application is not limited to the specific embodiments disclosed below.

[0023] Secondly, the term "an embodiment" or "embodiment" as used herein refers to a specific feature, structure, or characteristic that may be included in at least one implementation of this application. The phrase "in one embodiment" appearing in different places in this specification does not necessarily refer to the same embodiment, nor is it a single embodiment or an embodiment selectively excluded from other embodiments.

[0024] Example 1 like Figure 1 As shown, a smart blackboard interactive resource scheduling and usage optimization system includes: The task module instantiates each interactive task in the smart blackboard as a task node and each physical computing resource as a resource node. Based on the real-time resource requirements of the task nodes, directed edges are established from the task nodes to the resource nodes, forming a dynamic interactive topology. The task module collects raw interactive data streams from touch, handwriting, voice, and images through multimodal interactive sensors on the smart blackboard; The multimodal interaction sensor is a heterogeneous set of sensing units integrated into the smart blackboard hardware system to collaboratively capture user interaction behaviors across different dimensions. Through different types of physical sensors, the user's tactile, pen-based, auditory, and visual interactions are converted into raw digital signal streams that can be processed by the computing system.

[0025] A preferred multimodal interactive sensor includes: a touch sensor, a handwriting sensor, a voice sensor, and an image sensor; The touch sensor is a capacitive or infrared touch film / frame covering the surface of the display panel. It detects the change in capacitance field or the blockage of infrared light path caused by the user's finger or conductive object touching the screen surface, and generates a continuous touch event stream containing the contact point coordinates (X,Y), pressure and timestamp.

[0026] The handwriting sensor consists of a dedicated digital pen and sensing layer based on electromagnetic induction or active capacitance. When the digital pen approaches or touches the screen, the sensor senses the coordinates of the pen tip, pressure, tilt angle, and even the pen's ID through electromagnetic coupling or capacitance changes, generating a sequence of handwriting trajectory points.

[0027] A microphone array consisting of multiple microphones integrated into the voice sensor converts air vibrations into analog electrical signals, which are then converted into digital audio streams via analog-to-digital conversion.

[0028] Multiple cameras are embedded in the frame of the smart blackboard, and image sensors are used to capture optical images of the scene in front of the blackboard through optical lenses and image sensors, generating continuous image frames or video streams to capture user gestures, body movements, or displayed objects.

[0029] In this application, the intent recognition model implementation method specifically includes: input layer and feature extraction, multimodal fusion and context encoding, and intent decoding and output.

[0030] The pre-trained intent recognition model uses the feature extraction and pattern recognition capabilities of deep neural networks to jointly analyze and understand parallel multi-source heterogeneous raw data streams, and infer the high-level, semantic intent behind user interaction behavior.

[0031] The input layer and feature extraction specifically include: the intent recognition model receives multimodal raw data streams such as tactile, pen-based, auditory, and visual data after synchronization and timestamp alignment. For example, touch and handwriting data are treated as time series, and spatiotemporal motion features are extracted using a one-dimensional convolutional neural network. For speech data, it is first converted into acoustic features, and then processed by an audio feature extraction network. For image data, visual spatial features are extracted using a two-dimensional convolutional neural network.

[0032] Multimodal fusion and context encoding specifically include: the intent recognition model fusing extracted tactile, pen-based, auditory, and visual features. A preferred fusion strategy includes concatenating and weighted summing at the feature level. The intent recognition model maintains a short-term interactive context memory, for example, by combining current-moment features with historical features from previous seconds through a long short-term memory network or a transformer encoder, to understand the correlation between consecutive operations.

[0033] Intent decoding and output specifically include: the intent recognition model decodes the intent using two parallel output heads through a fused joint feature representation containing contextual information. The intent recognition model also includes a classification head, which consists of a fully connected layer followed by a Softmax function that maps joint features to a predefined operation type classification probability distribution.

[0034] The semantic vector generation head sets up a fully connected layer to compress and encode joint features into a dense vector of fixed dimensions, namely the operational semantic vector. The training objective of the operational semantic vector is to make semantically similar operations close in distance and semantically different operations far apart in vector space.

[0035] The intent recognition model is trained in a supervised manner on a large labeled smart blackboard interaction dataset, where the training data includes raw sensor data and corresponding operation types and semantic labels. After training, it is deployed in the system for online, low-latency real-time inference.

[0036] The original interactive data stream is input into a pre-trained intent recognition model, and the intent recognition model outputs the operation type classification and operation semantic vector of the current interaction. The operation types are categorized as follows: handwriting rendering, interface swiping, object dragging, speech recognition, gesture recognition, and image processing. The process of model outputting operation type classification and operation semantic vectors During inference, the intent recognition model performs forward propagation calculations on the synchronous multimodal data for each time window, ultimately outputting both the operation type classification and the operation semantic vector simultaneously. The operation type classification serves as a clear category label and its confidence level output by the intent recognition model.

[0037] Specifically, the intent recognition model selects the category of the current multimodal input data as the judgment result from a predefined, discrete set of categories, such as handwriting rendering, interface swiping, object dragging, speech recognition, gesture recognition, and image processing, based on the learned patterns.

[0038] The operation semantic vector is a fixed-length vector composed of continuous numerical values, such as a 128-dimensional floating-point array, which is the output of the intent recognition model.

[0039] Specifically, the operation semantic vector is a distributed representation of the current interaction behavior by the intent recognition model, including detailed information that cannot be covered by simple classification labels. For example, under the handwriting rendering category, is it a quick sketch or a detailed drawing? Under the gesture recognition category, is it a zoom gesture or a rotation gesture?

[0040] Operation type classification divides the continuous interaction flow into discrete task units with clearly defined resource requirements. For example, if the task is determined to be handwriting rendering, it mainly requires GPU resources for graphics drawing; if it is determined to be speech recognition, it mainly requires CPU resources for audio processing.

[0041] The operation semantic vector, along with the classification label, serves as input. The resource requirement mapping table analyzes the operation semantic vector to find specific quantitative resource requirement intensity parameters. For example, for handwriting rendering, if the semantic vector indicates high pressure and slow speed for fine handwriting, it maps to higher GPU computing power and video memory bandwidth requirements; while the semantic vector for fast scrolling maps to extremely high requirements for touch event processing response latency.

[0042] Based on the operation type classification and operation semantic vector, the resource requirement mapping table is invoked to parse out the combination of resource types required for the interactive task, quantify the intensity of resource requirement, and generate dynamic priority labels based on whether the interactive context is a teacher's main operation or a high-priority in-application operation to characterize the priority level of the task in resource competition. These labels are divided into three levels: high, medium, and low. For example, whether it is a teacher's main operation or a high-priority in-application operation, the generated dynamic priority labels are determined as feature vectors.

[0043] Each independent and continuously occupied interaction process is instantiated as a task node carrying the aforementioned feature vector; the central processing unit core, graphics processing unit, memory block and network interface card in the smart blackboard are registered as resource nodes respectively, and each resource node is associated with its unique hardware identifier, measurable initial performance parameters and real-time availability and power consumption status provided by the system kernel.

[0044] The resource requirements mapping table can be preset according to the usage habits of teachers in different application scenarios and subjects.

[0045] Multimodal interaction sensors synchronously collect and convert raw signals from user touch, handwriting, voice, and images into a unified digital stream. A pre-trained intent recognition model performs fusion analysis and contextual understanding on the parallel data streams, outputting operation type classification and operation semantic vectors. The system calls the resource requirement mapping table, and the intent recognition model uses the operation type classification and semantic vector as the primary key to query the baseline requirements. It then uses the resource requirement mapping table for fine-tuning, parsing the required resource type combination, quantifying the intensity of resource requirements, and combining the dynamic priority label assigned by the interaction context. These three elements are packaged together into the task's feature vector.

[0046] Furthermore, each independent interaction is instantiated as a task node carrying this feature vector. Physical resources such as CPU cores and GPU units are abstracted into resource nodes with real-time load and power consumption status.

[0047] The task module matches the resource requirement type parsed from the feature vector with the resource capability type represented by the hardware identifier of each resource node, and creates a directed edge for each task node pointing to one or more matching candidate resource nodes. The specific matching method includes: when each resource node registers, its hardware identifier or associated metadata explicitly marks the resource capability type, such as graphics processing, general computing, data storage, and network transmission. The task module parses the resource type combination in the task node feature vector, such as [graphics rendering, data caching]. Each item in the resource type combination corresponds to one or more predefined, standardized resource requirement type tags from the system.

[0048] During matching, the system compares each resource requirement type tag of the task node with the resource capability types of all resource nodes.

[0049] If the resource type combination includes graphics rendering, then a directed edge is created for the task node pointing to all graphics processor unit resource nodes; Specifically, for matching graphics rendering resources, if the resource type combination of a task node includes graphics rendering, the resource node pool will be traversed to filter out all resource capability types, and a directed edge pointing to each filtered GPU resource node will be created for the current task node. Multiple edges will be created so that when executing a rendering task, the rendering task candidate can be scheduled to any available GPU in the system.

[0050] If the resource type combination includes general computing or speech / image recognition, then a directed edge is created for the task node pointing to all central processing unit core resource nodes; If the resource type combination includes data caching, the system will filter out resource nodes whose resource capability type is marked as data caching, i.e., all dynamically allocated memory blocks. Directed edges will be created for task nodes pointing to these memory block resource nodes.

[0051] If the resource type combination includes real-time transmission, the system will filter out the resource nodes marked as real-time transmission, i.e., network interface cards. A directed edge pointing to the network interface card resource node will be created for real-time transmission.

[0052] This application dynamically generates a bipartite graph structure through rule-driven matching and directed edge creation: the task node set and the resource node set constitute the two parts of the graph respectively, and the directed edges represent the feasibility relationship of which task can be a candidate for which resource, thus transforming the complex resource scheduling problem into a mathematical model on the graph structure that can perform weight calculation and strategy optimization.

[0053] The dynamic interactive topology structure uses all instantiated task nodes and resource nodes as vertices and directed edges representing real-time demand relationships in the task modules as connections to construct an initial topology graph. In this application, a preferred implementation method of the dynamic interactive topology structure includes: After initialization, an empty graph data structure is created, containing two vertex sets: a task node set and a resource node set. All subsequently instantiated nodes will be added to this graph as vertices. The graph edges consist of directed edges dynamically created by the task module according to matching rules, with each edge originating from a task node vertex and pointing to a resource node vertex. The resource type matching results are transformed into explicit graph connections, thereby formalizing the candidate allocation relationship between interaction requirements and computing resources into a bipartite directed graph model that can be processed by the algorithm.

[0054] Furthermore, the feature vectors of task nodes in the dynamic interactive topology graph determine the types of resources that need to be connected; the capability type identifiers of resource nodes determine the subset of vertices and the connection structure between task nodes and resource nodes. For example, for a handwriting rendering task node, the resource type combination in the feature vector includes graphics rendering. According to the matching rules, directed edges are created in the graph pointing to all vertices of GPU resource nodes with the capability type of graphics rendering. Therefore, the structure of the topology graph is a real-time, visualized mapping of task requirements and resource capabilities within the system.

[0055] Furthermore, the edge weighting module calculates weights by traversing all edges in the dynamic interactive topology graph; the decision-making module transforms each task node and its connected edges in the dynamic interactive topology graph into an independent decision agent for local game playing; and the resource control module finally issues instructions based on the stable matching state achieved in the graph evolution.

[0056] The dynamic interaction topology is updated in real time. When a new task node is instantiated, the current node and its directed edges are added. When the real-time performance status or real-time power consumption status of a resource node changes, its node attributes are updated. When the interaction request corresponding to a task node is completed, the current node and all its associated directed edges are removed from the dynamic interaction topology. The process is as follows: Figure 2 As shown.

[0057] A preferred method for real-time updating of the dynamic interactive topology includes: When a task module instantiates a new task node, it immediately performs two actions: First, it adds the task node as a new vertex to the task node set of the dynamic interactive topology. Second, the system reads the resource type combinations from the feature vector of the new node, and according to the matching rules, immediately traverses the current resource node set to find all resource nodes with matching capability types.

[0058] The system creates directed edges in the dynamic interactive topology, pointing from the vertex of the new task node to the vertex of every matching resource node.

[0059] Real-time performance and power consumption status of resource nodes are provided periodically by the interface. When performance and power consumption data are updated, the attribute data of the corresponding resource node vertices in the dynamic interactive topology are updated. The edge weight module re-obtains the weight values ​​of all directed edges of resource nodes based on the latest load and power consumption data, and the weight calculation method is as follows: Figure 3 As shown.

[0060] When the task module or resource control module confirms that an interaction request has been completed, the system performs a graph structure cleanup operation: locates the corresponding task node vertex in the dynamic interaction topology, then deletes all directed edges originating from the current task node vertex, disconnects the candidate relationship between the current task and all resource nodes; removes the task node vertex from the graph, and cancels the decision agent associated with the task node through the decision module.

[0061] The edge weight module calculates and dynamically updates the weight value for each directed edge in the interactive topology. The weight value is determined by the real-time demand intensity of the task node and the real-time load and energy consumption status of the resource node. The edge weight module periodically obtains the quantized resource demand intensity from the feature vector of the task node from the task module, and obtains the current load state and current power consumption state from the resource node. The module periodically scans or receives broadcast information from the task module. For each task node in the dynamic interactive topology, the edge weight module reads the quantized demand intensity for each resource type from the latest feature vector. For example, for a handwriting rendering task, it obtains the demand intensity values ​​for the graphics processing unit (GPU) and memory blocks respectively.

[0062] The edge weighting module polls the status of each registered resource node in real time through the performance monitoring interface provided by the operating system kernel. This includes: Current load status: For CPU / GPU cores, it is the average utilization over the past short period; for memory blocks, it is the ratio of used capacity to total capacity; for network interface cards, it is the bandwidth utilization normalized to a floating-point number between 0 and 1.

[0063] The current power consumption status is the instantaneous power consumption value read through the hardware driver or ACPI interface, for example, using the ratio of the current power consumption to the chip's maximum thermal design power as P.

[0064] Based on the resource demand intensity, the current load state, and the current power consumption state, a comprehensive weight calculation is performed to obtain the current weight value of each directed edge; When a preset change in the resource demand intensity of any task node is detected, or when the current load state of any resource node exceeds the load threshold or the power consumption state exceeds the power consumption threshold, the weight value of the associated directed edge is immediately updated.

[0065] Specifically, the load threshold setting is dynamically set based on the initial performance parameters of each resource node and the system stability requirements. For example, for CPU / GPU cores, the load threshold is typically set to 80%-90% of the maximum sustainable utilization to avoid heat buildup caused by prolonged full-load operation.

[0066] For memory blocks, the threshold can be set to 85% of the total capacity to prevent memory exhaustion from triggering slow swapping operations.

[0067] The power consumption threshold is set based on the device's thermal design power or power management strategy. For example, the power consumption threshold can be set to 70%-80%. When the power consumption exceeds this threshold, it indicates that the component may enter a high-heat, low-efficiency range.

[0068] The comprehensive weight calculation results in a weight value that is positively correlated with the resource demand intensity and negatively correlated with the current load state and current power consumption state of the resource node. The weight W(T,R) of a directed edge connecting task node T and resource node R is calculated as follows:

[0069] I represents the quantified resource demand intensity of task T for the type of resource node R.

[0070] L represents the current load status of resource node R; P represents the current power consumption status of resource node R.

[0071] α, β, and γ are adjustable gain coefficients used to control the relative importance of demand, load, and power consumption in the decision-making process. For example, in scenarios where energy efficiency is emphasized, γ can be increased.

[0072] ε is a very small positive number used to prevent the denominator from being zero, thus ensuring the numerical stability of the formula.

[0073] An example of a preferred immediate update method is as follows: the edge weight module employs a hybrid update strategy, primarily using periodic polling and secondarily using event triggering. While periodically acquiring data, the module performs two checks in real time: Compare the I value of the task node this time with the previous time. If the change exceeds the preset sensitivity threshold, mark the task node as a change in requirements.

[0074] Check the L and P values ​​of each resource node. If the load status and power consumption status both exceed the system's preset range, mark the resource node as out of limit.

[0075] If a node is marked, it is immediately searched in the dynamic interactive topology: If the requirements of a task node change, find all directed edges in the topology graph that originate from that task node.

[0076] If a resource node's state exceeds the limit, then find all directed edges in the topology graph that terminate at that resource node.

[0077] For all identified associated directed edges, immediately interrupt the current periodic calculation process, prioritize the use of the latest I, L, P data, recalculate the weight value W(T,R) for each edge according to the above weight calculation formula, and synchronously update the weight attributes of the corresponding edges in the graph.

[0078] After the weights are updated, the edge weight module sends an asynchronous notification signal to the decision module, informing it that the weights of a specific edge or region have changed, and adjusting the local selection strategy according to the new weights.

[0079] The decision module transforms each task node into participation data, and calculates a local selection strategy based on the weight of the connected edges. Through multiple rounds of information interaction and conflict negotiation, the strategy of the participation data converges to a resource allocation equilibrium. The decision module transforms each task node into participation data by creating an independent decision agent for each task node. The decision agent is the dedicated execution carrier of the participation data, responsible for reading the task feature vector and resource requirement attributes contained in the participation data, and executing the local selection strategy and negotiation logic corresponding to the participation data. Each decision agent reads the current weight values ​​of all directed edges connected to the task node and generates a local selection strategy based on the current weight values ​​of all directed edges connected to the task node. The local selection strategy is expressed as a selection probability distribution for each connected resource node. The selection probability is positively correlated with the weight value of the corresponding directed edge. Specifically, the selection probability of a single resource node is expressed as: the weight value of the edge corresponding to the node / the sum of the weight values ​​of all connected edges.

[0080] In this application, the creation of an independent decision agent for each task node is specifically implemented as follows: Once the task module instantiates a new task node and adds it to the dynamic interactive topology graph, the decision module is immediately triggered.

[0081] The identity identifier is bound to the task node ID it represents.

[0082] The decision context includes a dynamic priority label inherited from the task node's feature vector, and a list of real-time weight values ​​for all directed edges of that task node in the topology graph.

[0083] The policy state is used to store the current probability distribution of its selection of each candidate resource node, as well as historical selection records.

[0084] The decision function is the code or configuration that implements the logic for generating and adjusting strategies.

[0085] Through mapping, static task node data is transformed into participating data that can actively participate in the scheduling game, enabling each task to autonomously seek the optimal resources.

[0086] The specific implementation method of the local selection strategy generation logic in this application includes: At the start of each decision cycle, the decision agent reads the current weight values ​​of all directed edges connected to the corresponding task node by accessing the shared dynamic interactive topology graph data structure.

[0087] The decision-making agent employs normalized probability calculation based on the softmax function, transforming the weight vector into a selection probability distribution. The specific expression is: for the i-th candidate resource node of task node T... The probability of it being selected The calculation formula is:

[0088] in, It points to the resource node. The current weight of the directed edge, denominator It is the sum of the weights of all n outgoing edges of the task node.

[0089] In each round of information interaction and conflict negotiation, each decision agent randomly selects a resource node based on the probability distribution of the local selection strategy and broadcasts the randomly selected resource node through a shared message channel. Each decision agent simultaneously receives selection intentions broadcast by other decision agents; Each decision agent checks whether its preferred resource node conflicts with the choices of other agents, i.e., multiple agents have chosen the same resource node; If a conflict is detected, the relevant decision-making agent adjusts the selection according to the negotiation rules. The priority of the negotiation rules is as follows: first, compare the directed edge weights of the conflicting parties, and the one with the higher weight value obtains the right to occupy resources in this round; if the weight values ​​are the same, compare the dynamic priority labels of the task nodes, and the one with the higher priority obtains the right to occupy resources in this round; if the priorities are still the same, execute a random backoff mechanism to determine the right to occupy resources in this round.

[0090] The strategies for participating in data converge to a resource allocation equilibrium through multiple rounds of information exchange and negotiation. At this point, the local selection strategies of all decision agents no longer change, achieving a stable task resource matching state. Specifically, time is divided into discrete decision rounds, such as every 10-100 milliseconds. In each round, all decision agents execute in parallel and asynchronously: First, based on their current local selection strategy, i.e., probability distribution, they randomly select a resource node as their intended use for this round; then, all agents broadcast their intentions through a shared message channel. While sending their own intentions, each agent also receives the intentions of all other agents in this round; each agent independently checks whether its own intention conflicts with the intentions of other agents. If a conflict is detected, the relevant agents will adjust in real time according to preset negotiation rules, ultimately determining a unique occupant in this round, while other conflicting parties are considered to have failed in this attempt.

[0091] By repeatedly going through rounds, each decision agent can continuously observe the results of its own choices and the overall conflict pattern of the system; based on this feedback, the agent will use profit maximization to dynamically update the probability distribution in its local choice strategy.

[0092] For example, when multiple students simultaneously drag and drop graphics, and a teacher annotates with handwriting and provides audio explanation, the multi-round interaction and strategy convergence process of the decision agent manifests as follows: For each interaction task, such as a handwriting trajectory or a dragged object, the decision agent perceives real-time edge weights that integrate the task's rendering complexity, recognition accuracy, and other requirements, as well as the current load and power consumption of each GPU and CPU core, forming an initial resource selection tendency. When agents for multiple drag-and-drop tasks simultaneously tend to select the same high-load GPU core, a conflict occurs and triggers negotiation, prioritizing the teacher's annotation task. Agents that do not obtain resources will, in subsequent rounds, have their reward function penalized by the number of conflicts multiplied by the high-load coefficient, automatically reducing the probability of selecting busy cores and instead trying other available resources. After several rounds of rapid decision-making, the strategies of all agents will adaptively adjust to a stable state: the teacher's handwriting rendering task is bound to a dedicated GPU core with a high probability, the student's drag-and-drop operation is effectively distributed to other graphics units, and the speech recognition task is assigned to the CPU core with a lighter load. The system's resource matching relationship reaches a dynamic balance, and most interactive tasks can obtain the required resources without conflict arbitration. In actual experience, this ensures the concurrent smoothness of touch control, writing and audio-visual interaction on the smart blackboard interface.

[0093] The resource allocation equilibrium is a Nash equilibrium state: in this Nash equilibrium state, no decision-making agent can obtain a better expected return by unilaterally changing its own resource selection strategy, such as... Figure 4 As shown; Specifically, in Nash equilibrium, the probability distribution of choosing various resources remains unchanged. Therefore, no single decision-making agent can obtain higher expected returns by unilaterally and deterministically changing its current resource selection strategy.

[0094] Given the current system load, task requirements, and resource status, each agent's strategy is already the optimal response to the strategies of other agents.

[0095] The expected return is calculated by the return function. The current return of the decision agent is equal to the sum of the comprehensive weight values ​​of the directed edges corresponding to all selected resource nodes, minus the penalty value caused by resource conflicts with other agents. The penalty value is the number of conflicts × the current load coefficient L of the resource node × A. The expression for calculating the payoff function is:

[0096] The comprehensive weight value of the directed edges corresponding to each resource node occupied in this round is used as the agent. The benefit directly reflects the positive return of high demand matching, low load, and low energy consumption. The higher the weight value, the greater the benefit.

[0097] The penalty value is calculated as: Penalty value = Number of conflicts × Current load coefficient of resource node L × A. Where: The number of conflicts is the number of times the current agent needs to enter into negotiation and arbitration because it selects the same resource as other agents.

[0098] The current load factor L of a resource node represents the real-time load status of the resource node that triggered the conflict.

[0099] A is a preset penalty amplification factor, used to adjust the weight of conflict costs in total revenue.

[0100] After each round of information exchange, the decision-making agent adjusts its local selection strategy based on the actual benefit feedback of this round in order to maximize long-term expected benefits.

[0101] After each round, the agent calculates the actual profit for that round and compares the actual profit with the expected profit predicted based on the current strategy. It increases the probability of resource nodes that tend to bring higher profits and decreases the probability of those that tend to lead to low profits or high penalties.

[0102] For example, if choosing a resource node repeatedly brings high returns, the preference value for that node will increase, thus increasing the probability of choosing it in the next round; conversely, if choosing a node frequently causes conflict, the penalty will lead to negative feedback, thus reducing the probability of choosing it.

[0103] Through multiple iterations, each agent's strategy continuously learns and adapts, eventually leading to the coupling and co-evolution of all agent strategies to the Nash equilibrium point. In each round of information interaction, the decision agent maximizes the value of the payoff function by adjusting its local selection strategy.

[0104] Based on the matching relationship between each task node and resource node determined by the balanced state, the resource control module sends control commands to the smart blackboard operating system to adjust the working state of computing resources.

[0105] The decision module receives an equilibrium achievement signal and an accompanying data packet. This data packet contains a list of statistically stable task node-resource node matching relationships across multiple recent decision rounds. Each item in the list explicitly records the binding pair of a task node ID and a resource node ID. The parsing process involves reading and verifying this list, transforming it into a set of internally operable task scheduling instructions.

[0106] The resource control module parses the matching relationship between each task node and resource node determined by the equilibrium state; The resource control module generates a sequence of underlying control instructions based on the type of resource nodes and their associated hardware identifiers in the matching relationship. The resource control module generates underlying control commands based on the parsed matching relationships, specifically including: Input a matching pair (task node T, resource node R), and the feature vector of task node T, which includes operation type classification and quantified resource demand intensity I.

[0107] Instruction generation rules: If resource node R is a CPU core: generate instructions based on the operation type of task T, such as speech recognition and its quantization resource demand intensity.

[0108] If resource node R is a GPU unit: classify according to the operation type of task T, such as handwriting rendering and generation instructions. For example, allocate computing resource quotas and video memory bandwidth to a specified rendering pipeline.

[0109] If resource node R is a memory block: Generate instructions based on the memory requirements of task T. For example, allocate a specified size of physically contiguous cache space from a preset fast memory pool and lock that memory region exclusively for the use of this task.

[0110] If resource node R is a network interface card: Generate instructions based on the network requirements of task T. For example, configure quality of service policies and bandwidth reservations for specific data flows.

[0111] Output the specific, ordered sequence of underlying control instructions generated for each matching pair.

[0112] The instruction sequence includes setting the operating frequency of a specified computing unit, adjusting the priority of a rendering unit, and allocating memory cache space; The instruction sequence is sent to the kernel scheduler and hardware driver of the smart blackboard operating system; The completed instruction sequence is issued through two core paths to ensure control takes effect: For resource management instructions involving CPU / GPU thread scheduling priority, process affinity, memory policy, etc., the instructions are submitted to the operating system's kernel scheduler through system calls provided by the operating system.

[0113] Instructions involving specific hardware operating parameters, such as CPU / GPU frequency and voltage, memory controller timings, and NIC bandwidth configuration, are issued through interaction with the driver of the specific hardware device. This is typically accomplished through the ioctl interface exposed by the driver, which ultimately manipulates hardware registers or firmware.

[0114] After the instruction sequence is executed, the actual working status and real-time energy consumption of each resource node are monitored, and the actual working status and real-time energy consumption are fed back to the edge weight module to update the current load status and current power consumption status of the resource node.

[0115] In this application, a specific implementation method for a post-execution monitoring and feedback process is provided, such as... Figure 5 The following are included: Starting a short delay after instruction execution, the actual working status and real-time energy consumption of each resource node are continuously collected through kernel performance events, hardware performance counters, and power management unit interfaces.

[0116] The collected actual data is compared with the expected state before the command is issued. For example, it checks whether the actual utilization of the GPU has reached the expected level of demand intensity, or whether the actual power consumption of the CPU core at the set frequency is abnormal.

[0117] The state data is encapsulated into a state update message and actively pushed to the edge weight module. After receiving the feedback, the edge weight module immediately uses the latest L' and P' values ​​to recalculate the weights of all associated directed edges.

[0118] For example, if a resource node's actual load L' is much higher than expected after executing instructions, the weight of the relevant edge will decrease, reducing its attractiveness to future tasks and guiding the system to allocate new tasks to other more idle resources, thus achieving adaptive load balancing.

[0119] It is important to note that the constructions and arrangements of this application shown in several different exemplary embodiments are merely illustrative. Although only two embodiments are described in detail in this disclosure, those who consult this disclosure will readily understand that many modifications are possible without substantially departing from the novel teachings and advantages of the subject matter described in this application. These modifications may include, for example, changes in the size, dimensions, structure, shape, and proportions of various elements, as well as parameter values ​​(e.g., temperature, pressure, etc.), installation arrangements, the use of materials, colors, orientations, etc. For example, an element shown as integrally formed may be composed of multiple parts or elements, the position of elements may be inverted or otherwise altered, and the nature or number or position of discrete elements may be changed or altered. Therefore, all such modifications are intended to be included within the scope of this application. The order or sequence of any process or method steps may be changed or rearranged by alternative embodiments. Any "apparatus plus function" clause is intended to cover, and not only structurally equivalent but also equivalent structures, the structures performing the functions described herein. Other substitutions, modifications, alterations, and omissions may be made in the design, operation, and arrangement of the exemplary embodiments without departing from the scope of this application. Therefore, this application is not limited to a particular embodiment, but extends to various modifications that still fall within the scope of the appended claims.

[0120] Furthermore, in order to provide a concise description of exemplary embodiments, not all features of actual embodiments (i.e., those features that are not relevant to the best mode of performing this application as currently considered, or those features that are not relevant to implementing this application) may be omitted.

[0121] It should be understood that numerous specific implementation decisions can be made during the development of any practical implementation, such as in any engineering or design project. Such development efforts may be complex and time-consuming, but for those of ordinary skill in the art who benefit from this disclosure, the development effort will be a routine task in design, manufacturing, and production without requiring extensive experimentation.

[0122] It should be noted that the above embodiments are only used to illustrate the technical solutions of this application and are not intended to limit it. Although this application has been described in detail with reference to preferred embodiments, those skilled in the art should understand that modifications or equivalent substitutions can be made to the technical solutions of this application without departing from the spirit and scope of the technical solutions of this application, and all such modifications and substitutions should be covered within the scope of the claims of this application.

Claims

1. A smart blackboard interactive resource scheduling and usage optimization system, characterized in that, include: The task module instantiates each interactive task running on the smart blackboard as a task node, instantiates each physical computing resource as a resource node, and establishes directed edges from the task node to the resource node according to the real-time resource requirements of the task node, forming a dynamic interactive topology. The edge weight module calculates and dynamically updates the weight value for each directed edge in the interactive topology. The weight value is determined by the real-time demand intensity of the task node and the real-time load and energy consumption status of the resource node. The decision module transforms each task node into participation data, and calculates a local selection strategy based on the weight of the connected edges. Through multiple rounds of information interaction and conflict negotiation, the strategy of the participation data converges to a resource allocation equilibrium. Based on the matching relationship between each task node and resource node determined by the balanced state, the resource control module sends control commands to the smart blackboard operating system to adjust the working state of computing resources.

2. The interactive resource scheduling and usage optimization system for a smart blackboard as described in claim 1, characterized in that: The task module collects raw interactive data streams from touch, handwriting, voice, and images through multimodal interaction sensors on the smart blackboard; The original interactive data stream is input into a pre-trained intent recognition model, and the intent recognition model outputs the operation type classification and operation semantic vector of the current interaction. Based on the operation type classification and operation semantic vector, the resource requirement mapping table is called to parse out the combination of resource types required for the interactive task, quantify the intensity of resource requirement, and generate dynamic priority labels based on whether the interactive context is the teacher's main operation or a high-priority in-application operation to characterize the priority level of the task in resource competition. These are divided into three levels: high, medium, and low, and determined as feature vectors. Each independent and continuously occupied interaction process is instantiated as a task node carrying the aforementioned feature vector; the central processing unit core, graphics processing unit, memory block and network interface card in the smart blackboard are registered as resource nodes respectively, and each resource node is associated with its unique hardware identifier, measurable initial performance parameters and real-time availability and power consumption status provided by the system kernel.

3. The interactive resource scheduling and usage optimization system for a smart blackboard as described in claim 2, characterized in that: The task module matches the resource requirement type parsed from the feature vector with the resource capability type represented by the hardware identifier of each resource node, and creates a directed edge for each task node pointing to one or more matching candidate resource nodes. If the resource type combination includes graphics rendering, then a directed edge is created for the task node pointing to all graphics processor unit resource nodes; If the resource type combination includes general computing or speech / image recognition, then a directed edge is created for the task node pointing to all CPU core resource nodes; If the resource type combination contains data caching, then create directed edges for that task node pointing to all available memory block resource nodes; If the resource type combination includes real-time transmission, then a directed edge pointing to the network interface card resource node is created for that task node.

4. The interactive resource scheduling and usage optimization system for a smart blackboard as described in claim 3, characterized in that: The dynamic interactive topology structure uses all instantiated task nodes and resource nodes as vertices and directed edges representing real-time demand relationships in the task modules as connections to construct an initial topology graph. The dynamic interaction topology is updated in real time. When a new task node is instantiated, the current node and its directed edges are added. When the real-time performance status or real-time power consumption status of a resource node changes, its node attributes are updated. When the interaction request corresponding to a task node is completed, the current node and all its associated directed edges are removed from the dynamic interaction topology.

5. The interactive resource scheduling and usage optimization system for a smart blackboard as described in claim 2, characterized in that: The edge weight module periodically obtains the quantized resource demand intensity from the feature vector of the task node from the task module, and obtains the current load state and current power consumption state from the resource node. Based on the resource demand intensity, the current load state, and the current power consumption state, a comprehensive weight calculation is performed to obtain the current weight value of each directed edge; When a preset change in the resource demand intensity of any task node is detected, or when the current load state of any resource node exceeds the load threshold or the power consumption state exceeds the power consumption threshold, the weight value of the associated directed edge is immediately updated.

6. The interactive resource scheduling and usage optimization system for a smart blackboard as described in claim 5, characterized in that: The comprehensive weight calculation results in a weight value that is positively correlated with the intensity of resource demand and negatively correlated with the current load state and current power consumption state of the resource node.

7. The interactive resource scheduling and usage optimization system for a smart blackboard as described in claim 1, characterized in that: The decision-making module transforms each task node into participating data by creating an independent decision agent for each task node; Each decision agent reads the current weight values ​​of all directed edges connected to the task node and generates a local selection strategy based on the current weight values ​​of all directed edges connected to the task node. The local selection strategy is expressed as a selection probability distribution for each connected resource node. The selection probability is positively correlated with the weight value of the corresponding directed edge. Specifically, the selection probability of a single resource node is expressed as: the weight value of the edge corresponding to the node / the sum of the weight values ​​of all connected edges.

8. The interactive resource scheduling and usage optimization system for a smart blackboard as described in claim 7, characterized in that: In each round of information interaction and conflict negotiation, each decision agent randomly selects a resource node based on the probability distribution of the local selection strategy and broadcasts the randomly selected resource node through a shared message channel. Each decision agent simultaneously receives selection intentions broadcast by other decision agents; Each decision agent checks whether its preferred resource node conflicts with the choices of other agents, i.e., multiple agents have chosen the same resource node; If a conflict is detected, the relevant decision-making agent adjusts the selection according to the negotiation rules. The priority of the negotiation rules is as follows: first, compare the directed edge weights of the conflicting parties, and the one with the higher weight value obtains the right to occupy resources in this round; if the weight values ​​are the same, compare the dynamic priority labels of the task nodes, and the one with the higher priority obtains the right to occupy resources in this round; if the priorities are still the same, execute a random backoff mechanism to determine the right to occupy resources in this round.

9. The interactive resource scheduling and usage optimization system for a smart blackboard as described in claim 8, characterized in that: The strategies for participating in data converge to a resource allocation equilibrium through multiple rounds of information exchange and negotiation. At this point, the local selection strategies of all decision agents no longer change, achieving a stable task resource matching state. The resource allocation equilibrium is a Nash equilibrium state: in the Nash equilibrium state, no decision-making agent can obtain better expected returns by unilaterally changing its own resource selection strategy; The expected return is calculated by the return function. The current return of the decision agent is equal to the sum of the comprehensive weight values ​​of the directed edges corresponding to all selected resource nodes, minus the penalty value caused by resource conflicts with other agents. The penalty value is the number of conflicts × the current load coefficient L of the resource node × A. In each round of information interaction, the decision agent maximizes the value of the payoff function by adjusting its local selection strategy.

10. The interactive resource scheduling and usage optimization system for a smart blackboard as described in claim 1, characterized in that: The resource control module parses the matching relationship between each task node and resource node determined by the equilibrium state; The resource control module generates a sequence of underlying control instructions based on the type of resource nodes and their associated hardware identifiers in the matching relationship. The instruction sequence includes setting the operating frequency of a specified computing unit, adjusting the priority of a rendering unit, and allocating memory cache space; The instruction sequence is sent to the kernel scheduler and hardware driver of the smart blackboard operating system; After the instruction sequence is executed, the actual working status and real-time energy consumption of each resource node are monitored, and the actual working status and real-time energy consumption are fed back to the edge weight module to update the current load status and current power consumption status of the resource node.

Images