Toward Sustainable Interconnected Metrological Networks: Synchronized Multi-Resource Coordination

Abstract

Advances in low-power electronics and wireless communication have fueled the proliferation of interconnected metrological networks, increasing the need for traceable, networked measurement systems. This expansion, however, has created a surge in heterogeneous calibration tasks, while a scarcity of qualified experts and reference standards imposes severe resource constraints on remote calibration. Existing scheduling methods, though effective in homogeneous environments, typically lack integration of high-precision time-synchronization with heterogeneous resource coordination, limiting their use in time-critical metrology. To address this gap, we propose a multi-resource synchronized scheduling framework for remote calibration. We formulate the problem as a dual-container model that concurrently optimizes task mapping and temporal dependencies between edge instruments and cloud services. A two-stage heuristic algorithm is developed to efficiently map and schedule tasks in distributed client-server architectures by leveraging critical path analysis and hierarchical scheduling strategies. Simulations across diverse workloads and scales show our method outperforms existing baselines, achieving superior scheduling efficiency, scalability, and calibration accuracy.

1. Introduction

Advances in low-power electronics, embedded controllers, and wireless communications have fueled the rapid expansion of interconnected metrological networks [1]. Representative examples such as the Internet of Things (IoT) [2,3,4] and advanced metering infrastructures have further intensified the need for traceable, networked measurement systems [5,6,7]. This rapid expansion has substantially increased maintenance demands, sparking concerns over a potential crisis in traditional metrology [8]. Consequently, remote calibration has emerged as a new metrological paradigm that decouples metrologists from instruments, reducing uncertainty propagation, enhancing resource integration, and enabling systematic calibration interval design [9,10,11].

Nevertheless, remote calibration [9,10,11], while mitigating logistical costs and environmental effects, remains dependent on high-precision reference standards and calibration performed by qualified metrologists. Operationally, the sheer volume of heterogeneous calibration tasks generated by these systems vastly exceeds the available cohort of experts possessing the requisite standards, knowledge, and practical experience [12,13]. This scarcity compels systems to function in severely resource-constrained conditions, a critical factor frequently overlooked in contemporary research that consequently constrains their accuracy and generalizability in large-scale applications [14,15]. Therefore, resolving this intricate scheduling dilemma constitutes a pivotal challenge for advancing interconnected metrological networks.

To enhance the efficiency of resource utilization in complex systems [16,17,18,19], numerous studies have employed task scheduling techniques to offer systematic decision support for resource allocation. For instance, several approaches target scheduling within isolated physical or logical systems, such as dynamic automated guided vehicle (AGV) coordination [20], elastic rescheduling in coarse-grained reconfigurable architectures (CGRAs) [21], and fault-tolerant scheduling in multiprocessor systems based on Time-Sensitive Networking (TSN) [22]. These methods generally utilize homogeneous resources and primarily focus on improving internal system efficiency. In contrast, another research direction extends to multiple entities and interconnected systems, seeking to enhance overall efficiency through the integration of heterogeneous resources and functional complementarity. Examples include coordinated truck–drone scheduling [23] and vehicle-assisted drone sensing [24], which enable efficient multimodal resource use under energy and time constraints.

Despite these advances, a critical gap remains at the intersection of three key challenges: (1) the co-scheduling of strongly heterogeneous resources (e.g., instruments, computation, and communication units), (2) the requirement for high-precision, system-wide time synchronization, and (3) the need to manage fine-grained, inter-dependent sub-tasks structured as Directed Acyclic Graphs (DAGs). While recent works like [14,15] begin to address synchronization and heterogeneous resources, they model calibration tasks as monolithic, indivisible units. This coarse-grained abstraction is a significant limitation, as it fails to capture the complex internal dependencies of real-world calibration workflows, leading to suboptimal resource allocation, synchronization inaccuracies, and ultimately, unreliable outcomes in time-critical cyber-physical systems. Thus, a new scheduling framework is needed to integrate resource heterogeneity, precise synchronization, and fine-grained task dependencies for reliable and accurate cyber-physical systems.

To bridge the aforementioned research gaps, this paper introduces a novel multi-resource synchronized and collaborative task scheduling framework designed to tackle the complex scheduling challenges inherent in remote calibration systems. The challenges are threefold: First, the distributed coordination of equipment and instruments necessitates interaction and collaboration among heterogeneous resources—such as calibration devices, metrological standards, servers, and domain experts—resulting in intricate resource allocation scenarios. Second, the limited availability of metrological standards and expert resources often leads to underutilized standards while calibration requests for pending devices remain unfulfilled, creating a supply-demand imbalance. Furthermore, dependency-aware calibration requests require concurrent processing across calibration devices, metrological standards, servers, and experts, which demands cross-layer synchronization to mitigate inter-layer resource coordination conflicts. In contrast to traditional dual-resource heterogeneous scheduling models, this study presents two key innovations: first, it reframes server-side process orchestration as a human resource scheduling problem, and second, it employs a multi-graph-based task structure. Each calibration task is defined as a directed acyclic graph capable of dynamically invoking multiple heterogeneous standard devices. This approach simultaneously captures intra-task temporal constraints and inter-task resource competition, thereby providing an accurate representation of the complex dependencies within the system. The main contributions are summarized as follows:

1.

We propose a heterogeneous task mapping and time synchronization model for remote calibration that captures resource and temporal dependencies on both the client and server sides. This dependency-aware synchronization and scheduling problem is formulated as a multi-objective constrained optimization problem.

2.

We present a two-stage heuristic algorithm, named Critical-Path-based Priority Scheduling (CP-PS), that employs critical-path analysis and hierarchical scheduling to efficiently coordinate heterogeneous tasks in distributed, multi-monitoring-point client–server architectures.

3.

Finally, extensive simulations across diverse workloads and system scales demonstrate that the proposed method consistently outperforms mainstream baselines, achieving significant and stable performance gains in terms of throughput and latency reduction.

The remainder of this paper is organized as follows: Section 2 reviews related work on remote calibration and task scheduling. Section 3 presents the mathematical model of the open networked remote calibration system. Section 4 details the proposed algorithm and its complexity analysis. Section 5 discusses and analyzes the experimental results. Finally, Section 6 concludes the paper.

2. Related Work

2.1. Remote Calibration

Remote calibration technology is an essential approach for modernizing measurement traceability. Current research mainly focuses on how to ensure the accuracy and traceability of measurement results under non-contact, long-distance conditions, showing a trend evolving from basic system construction towards intelligence. From the perspective of standardization, scholars are dedicated to standardizing standard instruments, calibration procedures, and value transfer mechanisms, ensuring that remote calibration results have legal validity and international recognition. For example, Li et al. [25] proposed an improved alternative calibration method for UAV hyperspectral sensors, providing a replicable technical solution for calibration under complex environments by combining radiative transfer models with field markers; Ershov and Stukach [26] built a hardware-software integrated remote calibration platform based on NI PXI, enhancing the consistency and reproducibility of the calibration process through programmed control; Fang et al. [27] proposed a remote comparison model for DC voltage sources based on GPS common-view method, achieving precise comparisons of remote standards using high-precision time synchronization, solving uncertainty issues introduced during transportation. These works focus on building a credible, unified foundation for remote calibration systems.

In the context of digitalization and Industry 4.0, the development of emerging technologies drives remote calibration systems towards data-driven approaches and process automation, aiming to break down information silos. Zhou et al. [28] designed a remote calibration system for electric energy meters based on sampled value (SV) networks and GPRS communication, enabling remote playback analysis of digital standard meters in laboratories; Quan et al. [29] constructed a remote calibration architecture for power equipment based on TCP/IP protocol, promoting network deployment of calibration systems through OPNET simulation verification of communication reliability; Zhao et al. [30] further proposed a low-power, unattended terminal-cloud collaborative architecture supporting long-term online monitoring and remote error calculation for electric energy meters. Yang et al. [31] innovatively combined the SIS epidemic model with TCN-Attention neural networks for dynamic assessment of electric vehicle charger performance, simulating the diffusion process of errors in networks, achieving remote status identification and trend prediction for large-scale device groups; De Vito et al. [32] explored iterative calibration strategies for low-cost air quality sensors, utilizing open-source data streams from reference stations for continuous parameter updates, demonstrating the potential of lightweight adaptive calibration. Such digitally driven remote calibration studies focusing on “digital space management” significantly enhance the efficiency and coverage of remote calibration.

Smart metrology is based on digitalization, with its core being the use of existing measurement data to build virtual models [12], establishing mapping relationships between real and virtual instruments to achieve dynamic assessment and prediction of real device states. However, current research primarily focuses on the standardization of remote calibration [26,27], the construction of digital systems [28,29], and the development of state prediction models [31,32], generally overlooking the reality constraint of scarce high-precision standard equipment and metrology expert resources. Regarding the collaborative scheduling mechanism between calibration tasks and limited resources, especially how to determine the optimal calibration timing and provide scientific decision support for maintenance cycles, systematic research is still lacking [33].

2.2. Job Scheduling

Task scheduling is a fundamental mechanism for enhancing resource utilization efficiency and has seen substantial progress in fields such as smart manufacturing and edge computing [34,35,36,37]. Research on intra-system scheduling concentrates on performance optimization within specific, bounded domains. For instance, Li et al. [20] proposed a dynamic scheduling model for Automated Guided Vehicles to improve robustness in manufacturing environments. Chen et al. [21] designed an elastic scheduling mechanism for Coarse-Grained Reconfigurable Architectures to alleviate the low resource utilization caused by static approaches. Xu et al. [22] introduced a task conflict metric for Time-Sensitive Networking to optimize joint scheduling, while Hu et al. [38,39] developed adaptive algorithms to enhance fault tolerance in multiprocessor and real-time in-vehicle systems. These approaches primarily optimize homogeneous resources within single systems to maximize internal efficiency.

Conversely, a separate research thread emphasizes cross-platform integration and functional synergy. Wang et al. [23] formulated a hybrid truck-drone delivery algorithm to leverage the complementary advantages of multimodal transportation. Similarly, Hu et al. [24] introduced a vehicle-assisted multi-drone sensing problem addressed through a nested optimization framework. Li [40] investigated task offloading in fog computing, devising a scheduling strategy that balances performance and cost under dual constraints.

Nevertheless, these cross-domain studies have largely overlooked the critical requirement for high-precision time synchronization, thereby limiting their applicability in metrology. Recent work by Wang [14] and Zha [15] has begun to address this gap by proposing synchronous calibration scheduling models that integrate heterogeneous collaboration with synchronization mechanisms. However, a key limitation persists, as both models treat calibration as a monolithic task, disregarding the complex dependencies among subtasks that typify real-world scenarios. This oversight of intrinsic task-level heterogeneity results in resource mismatches and cumulative synchronization errors, which ultimately compromise calibration accuracy.

In summary, while scheduling research has evolved from single-system optimization to multi-platform paradigms with emerging synchronization awareness, no existing framework adequately addresses the triple challenge of resource, temporal, and task-structure heterogeneity. For large-scale smart metrology applications, this gap necessitates a novel scheduling paradigm that holistically manages all three dimensions to fulfill rigorous real-world precision requirements.

3. Problem Formulation

The architecture of the Open Networked Remote Calibration System (ONRCS) is illustrated in the Figure 1. The architecture is broadly divided into edge-side instruments and sensors, and a cloud-based server. The edge side is responsible for collecting calibration and environmental data, and transmitting them over a network to a remote server. The cloud serves as the central node in the remote calibration system, responsible for receiving the calibration and environmental data from the edge side, executing the calibration algorithms, and feeding the calibration results back to the client. The system constructed in this paper integrates various heterogeneous resources such as calibrated equipment, standard devices, and experts. The core of the calibration process lies in achieving real-time data synchronization and comparison between the calibrated equipment and the standard devices, while experts are required to monitor the entire synchronization process. Therefore, the term “synchronization” as defined in this paper carries a dual meaning: on one hand, it refers to the physical synchronization of measured values between the calibrated equipment and the standard devices; on the other hand, it denotes the perceptual synchronization between the experts’ cognition and the on-site physical equipment status. The cornerstone for maintaining this multi-level synchronization is precisely what sets remote calibration apart from traditional models—a stable, low-latency real-time communication link. Our system relies on the following modeling assumptions:

• Network and Clock Assumptions: In the remote calibration system under study, the duration of a single calibration task typically ranges from 5 to 30 min. In contrast, the network delays experienced during actual system operation are generally on the order of seconds or milliseconds. Since the timescale of the calibration process is significantly larger than the communication delays (by more than two orders of magnitude), we assume that network delays and clock synchronization errors are negligible in our modeling and analysis, ensuring the focus remains on the core issues of the calibration process itself.
• Communication Reliability Assumption: We assume that the communication between metrology agents and devices in the system is highly reliable and deterministic. This assumption is grounded in the actual system design, which employs a dual-camera collaboration mechanism—one camera identifies and uploads meter data, while the other captures and transmits a real-time video stream. Furthermore, the system integrates various devices, including environmental sensors, which collectively participate in data acquisition and uploading. Through this multi-device collaboration and redundant design, the system effectively controls communication errors in practice, justifying our treatment of the communication environment as reliable and deterministic.
• Task Arrival and Queuing Assumption: Our model is based on the operational practices of China’s national metrology system. Within this framework, calibration tasks are typically assigned in advance by higher-level authorities, which results in a known arrival pattern of calibration requests prior to system operation, rather than a stochastic, dynamic process. Given this context, the queuing model adopted in this work primarily captures the waiting times caused by the occupancy of standard instruments or the unavailability of expert resources. Thus, the core assumption is that task queuing is based on a pre-determined schedule.

3.1. System Model

The equipment in power systems (such as transformers, circuit breakers, sensors, etc.) is diverse. When test samples approach their service life, their calibration tasks need to acquire real-time operational status and environmental data, and respond and adjust quickly to calibration results. In such cases, there exists a precedence relationship among these calibration tasks. Dependent task scheduling algorithms are more complex than independent task scheduling algorithms; although they can solve independent task scheduling problems, they are less targeted and poorly compatible with independent task scheduling schemes. Therefore, this paper adopts a Multi-type Directed Acyclic Graph (Multi-type DAG) as the core model for task scheduling. In this model, nodes in the DAG represent individual task units, while directed edges capture data or control dependencies between tasks. The heterogeneous task scheduling problem can be formally represented as a quadruple: $\mathcal{G}=\{\mathcal{V},\mathcal{E},\mathrm{\Theta },\mathrm{\Gamma }\}$, where $\mathcal{V}=\{V_1,V_2,\dots ,V_m\}$ denotes the set of task nodes, $m=\left|\mathcal{V}\right|$ is the total number of tasks in the initial DAG; each node $V_i\in \mathcal{V}$ corresponds to an executable computational task. The set $\mathcal{E}\subseteq \mathcal{V}\times \mathcal{V}$ represents the dependency edge set among tasks, where each directed edge $e_{ij}=(v_i,v_j)\in \mathcal{E}$ indicates that task $v_i$ is a predecessor of task $v_j$, meaning $v_j$ must wait until $v_i$ completes before it can start. The edge set $\mathcal{E}$ can be represented by a two-dimensional adjacency matrix, where element $e_{ij}=k$ ($k\in {\mathbb{N}}^{+}$) denotes a directed edge from $v_i$ to $v_j$ with communication volume k, used to quantify the data transmission cost between tasks. All symbol variables are defined in

Table 1. Summary of Key Notations.

Symbol	Description
$\mathcal{V}$	Set of task nodes: $\{V_1,V_2,\dots ,V_m\}$
$\mathcal{E}$	Dependency edge set: $\mathcal{E}\subseteq \mathcal{V}\times \mathcal{V}$
$\mathcal{H}$	Set of inspection points: $\{{\mathcal{H}}_1,\dots ,{\mathcal{H}}_N\}$
$\mathcal{C}$	Set of all metrological standard devices
$\mathcal{S}$	Set of all metrology experts
$\mathcal{M}$	Set of all calibration task types
${\mathcal{C}}_i$	Metrological standard device i at inspection point ${\mathcal{H}}_i$
${\mathcal{S}}_r$	Metrology expert r supervising tasks
$\mathcal{G}$	Multi-type DAG representing the task scheduling problem
$\mathcal{M}\left(v_n\right)$	Task type of task $v_n$, e.g., $\mathcal{M}\left(v_n\right)=m_a$
$\mathcal{M}\left(\mathcal{C}\right)$	Set of task types that device $\mathcal{C}$ can handle
$\mathcal{M}\left(\mathcal{S}\right)$	Set of task types that expert $\mathcal{S}$ can handle
$Q_{v_n}^{c_i}$	Compatibility: 1 if device $c_i$ can process $v_n$, else 0
$x_{v_n}^{c_i}$	Assignment: 1 if task $v_n$ is assigned to device $c_i$, else 0
$P_{v_n}^{s_r}$	Expert capability: 1 if expert $s_r$ can handle $v_n$, else 0
$y_{v_n}^{s_r}$	Assignment: 1 if task $v_n$ is supervised by expert $s_r$, else 0
$D_{v_n}^{v_{n^{\prime }}}$	Precedence: 1 if $v_n$ is a predecessor of $v_{n^{\prime }}$, else 0
$T_s^{c_i,v_n}$	Start time of device $c_i$ executing task $v_n$
$T_e^{c_i,v_n}$	End time of device $c_i$ executing task $v_n$
$T_s^{s_r,v_n}$	Start time of expert $s_r$ supervising task $v_n$
$T_e^{s_r,v_n}$	End time of expert $s_r$ supervising task $v_n$
$T_{\tau }\left(v_n\right)$	Processing time of task $v_n$ (typically 5–30 min)
$max\left\{T_e\left(v_n\right)\right\}$	Makespan: maximum completion time across all tasks

.

3.2. Device Correspondence Model

To characterize the execution characteristics of heterogeneous remote calibration tasks under the dual-container architecture, we introduce a type mapping function $\mathrm{\Theta }:\mathcal{V}\to \mathcal{C}\times \mathcal{S}$, which maps each task node $V_i$ to the set of metrological standard devices ${\mathcal{C}}_i$ and the set of metrology experts ${\mathcal{S}}_r$ available at its eligible inspection point $\mathcal{H}=\{{\mathcal{H}}_1,{\mathcal{H}}_2,\dots ,{\mathcal{H}}_N\}$. In this system, each inspection point is equipped with on-site operators, metrological standard devices, and test samples, and the same sample may involve multiple types of calibration tasks. We define $\mathcal{H}=\{{\mathcal{H}}_1,{\mathcal{H}}_2,\dots ,{\mathcal{H}}_N\}$ as the set of inspection points distributed across different geographical locations, where $N=\left|\mathcal{H}\right|$ denotes the total number of inspection points covered by the network. The set of all metrological standard devices across all inspection points is denoted by $\mathcal{C}=\{{\mathcal{C}}_1,{\mathcal{C}}_2,\dots ,{\mathcal{C}}_{\left|\mathcal{C}\right|}\}$ where $\left|\mathcal{C}\right|$ represents the total number of metrological standard devices in the system. Let $\mathcal{M}$ denote the set of all task types, and let $\mathcal{M}\left(v_n\right)=m_a$ indicate that task $v_n$ belongs to type $m_a$. The set of task types that a metrological standard device can handle is denoted by $\mathcal{M}\left(\mathcal{C}\right)=\{m_a,m_b,\dots ,m_c\}$. To express the compatibility between $\mathcal{M}\left(v_n\right)$ and $\mathcal{M}\left(\mathcal{C}\right)$, we define a binary variable $Q_{v_n}^{c_i}$ to indicate whether device $c_i$ is capable of processing calibration task $v_n$, where $Q_{v_n}^{c_i}=1$ if capable, and 0 otherwise, as defined in Equation (1). Additionally, we define a binary assignment variable $x_{v_n}^{c_i}\in \{0,1\}$ indicating whether task $v_n$ is assigned to device $c_i$, where 1 means assigned and 0 otherwise. For the mapping $\mathcal{T}:\mathcal{V}\to \mathcal{C}$, the device assignment must satisfy the following constraints: each metrological standard device can execute at most one compatible calibration task at a time, and each task must be assigned exactly once. These constraints are formalized in Equations  (1) and (3).

$$Q_{v_n}^{c_i}=\left\{\begin{array}{cc}1,\hfill & \mathcal{M}\left(v_n\right)\subseteq \mathcal{M}\left(\mathcal{C}\right)\hfill \\ 0,\hfill & \mathcal{M}\left(v_n\right)\not\subset \mathcal{M}\left(\mathcal{C}\right)\hfill \end{array}\right.,\forall v_n\in \mathcal{V},\forall c_i\in \mathcal{C}$$

(1)

$$\sum _{i=1}^{\left|\mathcal{C}\right|}{x}_{v_n}^{c_i}=1,\forall v_n\in \mathcal{V}$$

(2)

$$\sum _{i=1}^{\left|\mathcal{C}\right|}{x}_{v_n}^{c_i}{Q}_{v_n}^{c_i}=1,\forall v_n\in \mathcal{V}$$

(3)

Additionally, the central laboratory is responsible for reasonably arranging metrology experts to supervise and guide each calibration task, and determining the start time of the task, ensuring all tasks are completed successfully. The set of experienced metrology experts within the system is denoted by $\mathcal{S}=\{{\mathcal{S}}_1,{\mathcal{S}}_2,\dots ,{\mathcal{S}}_{\left|\mathcal{S}\right|}\}$ where $\left|\mathcal{S}\right|$ represents the number of metrology experts. The set of calibration task types that an expert can handle is denoted by $\mathcal{M}\left(\mathcal{S}\right)=\{m_h,m_j,\dots ,m_k\}$. Similarly to metrological standard devices, to express the relationship between $\mathcal{M}\left(v_n\right)$ and $\mathcal{M}\left(\mathcal{S}\right)$, a binary variable $P_{v_n}^{s_r}$ is defined to indicate whether metrology expert $s_r$ is capable of handling calibration task $v_n$, where 0 means no and 1 means yes. A binary variable $y_{v_n}^{s_r}\in \{0,1\}$ is defined to indicate whether calibration task $v_n$ is executed by metrology expert $s_r$, where 0 means no and 1 means yes. As shown in Equations (4)–(6), for the mapping relation $\mathcal{T}:\mathcal{V}\to \mathcal{S}$, the assignment of metrology experts must satisfy the following constraint: each calibration task must be assigned to exactly one qualified metrology expert.

$$P_{v_n}^{s_r}=\left\{\begin{array}{cc}1,\hfill & \mathcal{M}\left(v_n\right)\subseteq \mathcal{M}\left(\mathcal{S}\right)\hfill \\ 0,\hfill & \mathcal{M}\left(v_n\right)\not\subset \mathcal{M}\left(\mathcal{S}\right)\hfill \end{array}\right.,\forall v_n\in \mathcal{V},\forall s_r\in \mathcal{S}$$

(4)

$$\sum _{r=1}^{\left|\mathcal{S}\right|}{y}_{v_n}^{s_r}=1,\forall v_n\in \mathcal{V}$$

(5)

$$\sum _{r=1}^{\left|\mathcal{S}\right|}{y}_{v_n}^{s_r}{P}_{v_n}^{s_r}=1,\forall v_n\in \mathcal{V}$$

(6)

3.3. Temporal Synchronization Model

This paper models the remote calibration tasks as a dual-container synchronized scheduling problem. The core of this problem lies in the coordinated scheduling of metrological standard devices at the edge side and expert services in the cloud, ensuring strict time synchronization constraints are satisfied during task execution. To this end, we introduce a time mapping function $\mathrm{\Gamma }:\mathcal{V}\to \mathcal{C}\times \mathcal{S}$ to characterize the synchronized execution behavior of remote calibration tasks under the dual-container architecture. Specifically, for any task $v_n\in \mathcal{V}$ and its assigned metrological standard device $c_i\in \mathcal{C}$ and metrology expert $s_r\in \mathcal{S}$, define $T_s^{c_i,v_n}$ and $T_s^{s_r,v_n}$ as the start times of device $c_i$ and expert $s_r$ executing task $v_n$, respectively; correspondingly, $T_e^{c_i,v_n}$ and $T_e^{s_r,v_n}$ denote their respective task end times. The processing time required for each task $v_n$, denoted $T_{\tau }\left(v_n\right)$, is generally between 5 and 30 min. First, to ensure continuous execution, the difference between the start and end times must be exactly equal to the total processing time of the task, as shown in Equations (7) and (8).

$$T_e^{c_i,v_n}-T_s^{c_i,v_n}=T_{\tau }\left(v_n\right),\forall v_n\in \mathcal{V}$$

(7)

$$T_e^{s_r,v_n}-T_s^{s_r,v_n}=T_{\tau }\left(v_n\right),\forall v_n\in \mathcal{V}$$

(8)

Meanwhile, due to physical resource limitations, each metrological standard device and each metrology expert can execute only one task at a time; these resource constraints are expressed in Formulas (9)–(12). $x_{v_n}^{c_i}{x}_{v_{n^{\prime }}}^{c_i}$ indicates that both tasks $v_n$ and $v_{n^{\prime }}$ are allocated to the measurement standard device $c_i$ for execution. Since a standard device can only process one task at a time, it is essential to ensure that the processing times of different tasks do not overlap. Specifically, there are two cases: Equation (9) indicates that task $v_n$ completes before task $v_{n^{\prime }}$, while Equation (10) indicates that $v_{n^{\prime }}$ completes before $v_n$.

To express the temporal relationship between tasks more clearly, we subtract $T_e^{c_i,v_n}$ and $T_s^{c_i,v_{n^{\prime }}}$ from both sides of Equation (9), respectively, obtaining Equation (11). Similarly, we process Equation (10) to obtain Equation (12).

$$\begin{array}{cc}\hfill T_s^{c_i,v_n}& <T_e^{c_i,v_n}\le T_s^{c_i,v_{n^{\prime }}}<T_e^{c_i,v_{n^{\prime }}}\hfill \end{array}$$

(9)

$$\begin{array}{cc}\hfill T_s^{c_i,v_{n^{\prime }}}& <T_e^{c_i,v_{n^{\prime }}}\le T_s^{c_i,v_n}<T_e^{c_i,v_n}\hfill \end{array}$$

(10)

$$\begin{array}{cc}\hfill T_e^{c_i,v_n}-T_s^{c_i,v_{n^{\prime }}}& \le 0; T_e^{c_i,v_{n^{\prime }}}-T_s^{c_i,v_n}\ge 0\hfill \end{array}$$

(11)

$$\begin{array}{cc}\hfill T_e^{c_i,v_{n^{\prime }}}-T_s^{c_i,v_n}& \le 0; T_e^{c_i,v_n}-T_s^{c_i,v_{n^{\prime }}}\ge 0\hfill \end{array}$$

(12)

Combining Equations (11) and (12), we obtain the following relationship:

$$(T_e^{c_i,v_n}-T_s^{c_i,v_{n^{\prime }}})(T_e^{c_i,v_{n^{\prime }}}-T_s^{c_i,v_n})\le 0$$

(13)

This constraint only needs to be considered when both tasks $v_n$ and $v_{n^{\prime }}$ are scheduled to the same measurement standard device $c_i$. Therefore, after introducing the indicator variables, the constraint can be expressed as:

$$x_{v_n}^{c_i}{x}_{v_{n^{\prime }}}^{c_i}(T_e^{c_i,v_n}-T_s^{c_i,v_{n^{\prime }}})(T_e^{c_i,v_{n^{\prime }}}-T_s^{c_i,v_n})\le 0,\forall c_i\in \mathcal{C},\forall v_n,v_{n^{\prime }}\in \mathcal{V},v_n\ne v_{n^{\prime }}$$

(14)

Similarly, for other resources $s_r$, we have:

$$y_{v_n}^{s_r}{y}_{v_{n^{\prime }}}^{s_r}(T_e^{s_r,v_n}-T_s^{s_r,v_{n^{\prime }}})(T_e^{s_r,v_{n^{\prime }}}-T_s^{s_r,v_n})\le 0,\forall s_r\in \mathcal{S},\forall v_n,v_{n^{\prime }}\in \mathcal{V},v_n\ne v_{n^{\prime }}$$

(15)

Throughout the process, the so-called synchronization constraint means that for the same calibration task $v_n$, the assigned metrological standard device and metrology expert must be fully time-synchronized, i.e., their start times and end times must be identical, as shown in Equations (16) and (17). It is worth noting that when a test sample is approaching its service life limit, a complete calibration procedure is required. In such cases, there exist precedence relationships among these calibration subtasks. Dependent task scheduling algorithms are more complex than independent task scheduling algorithms; although they can solve independent task scheduling problems, they are less targeted and poorly compatible with independent task scheduling schemes. Therefore, a calibration task composed of multiple subtasks is represented by a Directed Acyclic Graph (DAG). A binary variable $D_{v_n}^{v_{n^{\prime }}}$ is defined to indicate whether calibration task $v_n$ is a predecessor of task $v_{n^{\prime }}$: 1 if yes, 0 otherwise. Two calibration tasks $v_n$ and $v_{n^{\prime }}$ with a dependency relationship must satisfy a temporal order, where the start time of $v_{n^{\prime }}$ cannot be earlier than the end time of $v_n$, as formalized in Equations (18) and (19).

$$T_s^{s_r,v_n}=T_s^{c_i,v_n},\forall v_n\in \mathcal{V}$$

(16)

$$T_e^{s_r,v_n}=T_e^{c_i,v_n},\forall v_n\in \mathcal{V}$$

(17)

$$D_{v_n}^{v_{n^{\prime }}}\left(T_e^{s_r,v_{n^{\prime }}}-T_s^{s_r,v_n}\right)\ge 0,\forall v_n\in \mathcal{V},\forall v_{n^{\prime }}\in \mathcal{V}$$

(18)

$$D_{v_n}^{v_{n^{\prime }}}\left(T_e^{c_i,v_{n^{\prime }}}-T_s^{c_i,v_n}\right)\ge 0,\forall v_n\in \mathcal{V},\forall v_{n^{\prime }}\in \mathcal{V}$$

(19)

However, experienced calibration experts are very limited, causing the system to operate under severe resource constraints for an extended period. Given this, the core objective of this chapter is to minimize the makespan, defined as the maximum completion time of all tasks—i.e., the total duration from the start of the first task to the completion of the last task. The task scheduling process is shown in Figure 2. This objective is formulated in Equation (20).

$$\begin{array}{cc}\hfill min& max\left\{T_e\left(v_1\right),\dots ,T_e\left(v_n\right)\right\},\forall v_n\in \mathcal{V}\hfill \\ \hfill \mathrm{s}.\mathrm{t}.& \mathrm{Constraints}\left(1\right)–\left(19\right)\hfill \end{array}$$

(20)

4. Algorithm

To address hierarchical task scheduling in a distributed multi–monitoring-point–client–server architecture, this paper presents a two-stage heuristic algorithm named Critical-Path-based Priority Scheduling (CP-PS). CP-PS employs critical-path analysis to dynamically determine task priorities and separates scheduling into client-side assignment and server-side execution. In the client phase, task sizes are estimated using average execution efficiency, and a global priority is established based on task criticality within the DAG to generate an initial queue. The server phase then refines this queue by incorporating real-time processing capabilities, producing a feasible and efficient schedule. This hierarchical framework achieves coarse-grained, rapid decision-making at the client and fine-grained optimization at the server, balancing global task criticality with system heterogeneity. Consequently, CP-PS enhances scheduling efficiency and adaptability in dynamic distributed environments.

For the task scheduling problem in a distributed environment, the proposed algorithm in this paper performs key parameter calculations and initialization at the beginning, laying the foundation for the subsequent two-stage scheduling. As detailed in Algorithm 1 (Lines 1–9), the system first computes the average efficiency coefficient $\overline{ϵ}=\{{\overline{ϵ}}_1,{\overline{ϵ}}_2,\dots ,{\overline{ϵ}}_{\mathcal{M}}\}$ for each task type across all servers based on the efficiency vectors of the servers, which serves as the normalization reference for the client-side phase. The algorithm then normalizes the computational workload of each task using the average efficiency coefficients, yielding the converted task execution time. Based on this, a dynamic programming approach (Lines 10–13 of Algorithms 1 and 2) is applied to recursively compute the critical path length $\mathcal{L}\left[v\right]$ for each task $v_n$, defined as the cumulative execution time of the longest path from task $v_n$ to any leaf node. For leaf nodes, the critical path length equals the normalized size of the task; for non-leaf nodes, it is the sum of the normalized size and the maximum critical path length among all its immediate successors. This process is formally expressed in Equation (21).

$$\begin{array}{c}\hfill \mathcal{L}\left[v\right]:={\mathrm{size}}^{\prime }\left(v\right)+\left\{\begin{array}{cc}0,\hfill & \mathrm{if}v\mathrm{is}\mathrm{a}\mathrm{leaf}\hfill \\ \underset{(v,u)\in \mathcal{E}}{max}\mathcal{L}\left[u\right],\hfill & \mathrm{otherwise}\hfill \end{array}\right.\end{array}$$

(21)

Algorithm 1 CP-PS

Require: Server set $\mathcal{S}$, monitoring point set $\mathcal{H}=\{{\mathcal{H}}_1,{\mathcal{H}}_2,\dots ,{\mathcal{H}}_N\}$, metering device set $\mathcal{C}$, and corresponding task set $\mathcal{V}=\{V_1,V_2,\dots ,V_m\}$, forming an initial task dependency graph Ensure: Task scheduling arrangement  1: for each task type $k\in [1,M]$ do  2:       Initialize the valid server set ${\mathcal{S}}_{valid}\leftarrow \varnothing$ and the average efficiency value ${\overline{ϵ}}_k$  3:       for each server $s_r\in \mathcal{S}$ do  4:             if $P_{j_n}^{s_r}>0$ then  5:                  ${\mathcal{S}}_{valid}\leftarrow {\mathcal{S}}_{valid}\cup \left\{s_r\right\}$  6:             end if  7:       end for  8:       Compute the average efficiency value ${\overline{ϵ}}_k$ from the valid server set $|{\mathcal{S}}_{valid}|>0$  9: end for 10: Initialize memoization dictionary $\mathcal{L}\leftarrow \left\{\right\}$ 11: for each $v\in \mathcal{V}$ do 12:       $\mathcal{L}\left[v\right]\leftarrow$ FIND_LONGEST_PATH$(v,\mathcal{L},\overline{ϵ})$                                    ▷ Call Algorithm 2 13: end for 14: if dynamic deadline mode then 15:       $deadline\leftarrow max\left\{\mathrm{est}\right(v)+\mathrm{size}(v)\mid v\in \mathcal{V}\}$ 16: else 17:       $deadline\leftarrow \mathrm{preset}\mathrm{value}$ 18: end if 19: Initialize $\mathcal{U}\leftarrow \mathcal{V}$ and construct $G=(V,E)$ 20: while $\mathcal{U}\ne \varnothing$ do 21:       Calculate the earliest start time $\mathrm{est}\left(v\right)$ for each task $v\in R$ 22:       For each task-client pair $(v,c)$ where $v\in R$ and $c\in \mathcal{C}$ is compatible, compute the heuristic cost $\mathrm{\Phi }(v,c)$ 23:       $(v^{*},c^{*})\leftarrow argmin\left\{\mathrm{\Phi }(v,c)\right\}$ 24:       Schedule $v^{*}$ on $c^{*}$ with converted size ${\mathrm{size}}_1\left(v^{*}\right)$ 25:       Update $\mathcal{U}$ and resource availability 26: end while 27: Update DAG with client-side dependencies 28: Reset $\mathcal{U}\leftarrow \mathcal{V}$ and recompute $\mathcal{L}\left[v\right]$, $\mathrm{est}\left(v\right)$, $\mathrm{lst}\left(v\right)$ 29: while $\mathcal{U}\ne \varnothing$ do 30:       Calculate the earliest start time $\mathrm{est}\left(v\right)$ for each task $v\in R$ 31:       For each task-server pair $(v,s)$ where $v\in R$ and $s\in \mathcal{S}$ is compatible, compute the heuristic cost $\mathrm{\Phi }(v,s)$ 32:       $(v^{*},s^{*})\leftarrow argmin\left\{\mathrm{\Phi }(v,s)\right\}$ 33:       Schedule $v^{*}$ on $s^{*}$ with actual size $\mathrm{size}\left(v^{*}\right)$ 34:       Update $\mathcal{U}$ and resource availability 35: end while 36: Update DAG with server-side dependencies 37: Validate schedule legality and compute performance metrics 38: $T_{total}\leftarrow max\left\{finish\left(v\right)\right\}$, $\rho \leftarrow \left\{\mathrm{utilization}\mathrm{rates}\right\}$

In the final step of the initialization phase (Lines 14–18 of Algorithm 1), the system determines the global deadline based on the configured mode. If the fixed mode is adopted, the externally predefined value is directly used as the deadline. If the dynamic mode is enabled, the deadline is computed as the maximum sum of the earliest start time and execution duration across all tasks. The earliest start time (EST) of a task is defined in Equation (22).

$$est(v_n,\vartheta )=max\left\{es{t}^{\mathcal{G}}\left(v_n\right),es{t}^L(v_n,\vartheta )\right\}$$

(22)

where $es{t}^{\mathcal{G}}\left(v_n\right)$ denotes the earliest start time of task $v_n$ constrained by its predecessor tasks, and $es{t}^L(v_n,\vartheta )$ denotes the earliest start time of task $v_n$ on a metrological standard device or metrology expert $\vartheta$, constrained by the previous task scheduled on the same resource $\vartheta$.

The term $es{t}^{\mathcal{G}}\left(v_n\right)$ is defined in Equation (23).

$$es{t}^{\mathcal{G}}\left(v_n\right)=\underset{1\le g\le \left|\mathcal{G}\right|}{max}\left\{est\left(v_n^g\right)+w\left(v_n^g\right)\right\}$$

(23)

where $\left|\mathcal{G}\right|$ represents the number of immediate predecessor tasks of $v_n$, and $w\left(v_n^g\right)$ denotes the execution time of the g-th predecessor task. If $v_n$ is an entry subtask (i.e., has no predecessors), then $es{t}^{\mathcal{G}}\left(v_n\right)=0$.

The term $es{t}^L(v_n,\vartheta )$ is defined in Equation (24):

$$es{t}^L(v_n,\vartheta )=est\left(prev(v_n,\vartheta )\right)+w\left(prev(v_n,\vartheta )\right)$$

(24)

where $prev(v_n,\vartheta )$ denotes the last task previously scheduled on resource $\vartheta$ (i.e., the immediate predecessor of $v_n$ on $\vartheta$). If $v_n$ is the first subtask assigned to the resource $\vartheta$, then $es{t}^L(v_n,\vartheta )=0$. If $v_n$ has not yet been assigned to any resource, $es{t}^L(v_n,\vartheta )$ is considered undefined or set to 0 for initialization purposes.

Algorithm 2 Longest Path Calculation

1: function FIND_LONGEST_PATH(v, $\mathcal{L}$, $\overline{ϵ}$)  2:       if $v\in \mathcal{L}$ then                           ▷ Check if already computed  3:             return $\mathcal{L}\left[v\right]$                 ▷ Return cached value  4:       end if  5:       Compute converted size: ${\mathrm{size}}_v\leftarrow \lfloor \mathrm{size}\left(v\right)\times \overline{ϵ}\left[\mathrm{type}\left(v\right)\right]\rfloor$  6:       if node v has no child nodes then  7:             $\mathcal{L}\left[v\right]\leftarrow {\mathrm{size}}_v$  8:             return ${\mathrm{size}}_v$  9:       else 10:             ${\mathrm{size}}_{maxchild}\leftarrow 0$ 11:             for each child node $v_{child}$ of v do 12:                  $\mathrm{child\_size}\leftarrow$FIND_LONGEST_PATH$(v_{child},\mathcal{L},\overline{ϵ})$ 13:                  if $\mathrm{child\_size}>{\mathrm{size}}_{maxchild}$ then 14:                     ${\mathrm{size}}_{maxchild}\leftarrow \mathrm{child\_size}$ 15:                  end if 16:             end for 17:             $\mathcal{L}\left[v\right]\leftarrow {\mathrm{size}}_v+{\mathrm{size}}_{maxchild}$ 18:             return $\mathcal{L}\left[v\right]$ 19:       end if 20: end function

In the client queuing phase (Lines 19–27), the system aims to determine the internal execution order of tasks at the client side. First, all tasks are initialized as unscheduled, ensuring they can uniformly enter the scheduling loop. In each iteration, the system selects tasks whose parent tasks have all been completed, forming the ready set R, thus ensuring that precedence constraints are preserved. For each ready task $v_n$, the system computes its Earliest Start Time (EST), denoted as $est\left(v_n\right)$. If the task has predecessors, $est\left(v_n\right)$ is set to the maximum completion time among all its immediate predecessors; otherwise, it is set to 0. Next, for each (task–client) pair, the system evaluates a unified heuristic function $\mathrm{\Phi }(v,c)$ that holistically balances the task’s start time, urgency, and criticality within a single framework. The function is formally defined in Equation (25):

$$\mathrm{\Phi }(v,c)=t_{\mathrm{current}}+\alpha ·{\displaystyle \frac{D-t_{\mathrm{current}}}{\mathcal{L}\left[v\right]}},$$

(25)

where $t_{\mathrm{current}}=max\{est\left(v\right),avail\left(c\right)\}$ represents the earliest time at which task v can be executed, considering both data readiness and resource availability; $\mathit{\alpha }\in [0,1]$ is an empirically tuned weighting parameter; D is the global deadline; and $\mathcal{L}\left[v\right]$ is the critical path length of task v as defined in Equation (21). Based on this evaluation, the algorithm selects the task-client pair $(v^{*},c^{*})$ with the minimum cost for scheduling. Task $v^{*}$ is then assigned to the execution queue of client $c^{*}$, and its normalized execution time $siz{e}^{\prime }\left(v^{*}\right)$ is computed based on the average efficiency coefficient. Subsequently, the system updates the task status and the availability time of client $c^{*}$ to maintain scheduling consistency. Once all tasks are assigned to clients, the algorithm updates the task dependency graph to reflect the intra-client execution sequence.

To handle situations where immediate scheduling is infeasible due to resource constraints (e.g., resource busy or type mismatch), our algorithm employs a delayed execution policy. Specifically, if a task cannot be scheduled in the current iteration, it is temporarily skipped and will be reconsidered in subsequent iterations. In each iteration, the scheduler only considers ready tasks (i.e., those whose parent tasks have been completed) and available resources (with matching types and known idle slots). By dynamically updating the next available time of resources and the earliest start time ($est$) of tasks, the algorithm ensures that all tasks are eventually scheduled onto suitable resources. For dependency constraints, our approach prevents violations through the calculation of $est$ and latest start time ($lst$). A post-scheduling validation is also performed; if any dependency conflict is detected, the algorithm reports an error and terminates. Thus, the algorithm guarantees that all tasks are scheduled while satisfying all dependency and resource constraints, though they may experience delays due to resource contention.

In the server scheduling phase (Lines 28–36), the system reassigns tasks to specific servers based on the updated DAG. This phase begins with resetting task states and recomputing key parameters. Given the additional precedence constraints introduced during the client scheduling phase, the system re-evaluates the critical path length $\mathcal{L}\left[v\right]$, as well as the timing constraints $est\left(v\right)$ (Earliest Start Time) and $lst\left(v\right)$ (Latest Start Time), ensuring that task criticality and time windows remain consistent with the modified dependency structure. In each iteration, the system selects tasks whose parent tasks have all been completed and adds them to the ready set R. Unlike the client phase, this ready set must respect not only the original task dependencies but also the new sequential edges introduced by the intra-client execution order. In other words, the server scheduler must honor the pre-determined task sequence within each client, ensuring that tasks assigned to the same client are not scheduled out of order. Subsequently, the Earliest Start Time $est\left(v\right)$ is computed based on the actual completion times of the task’s predecessors. Then, for each (task–server) pair, the system evaluates a heuristic cost function and selects the pair $(v^{*},s^{*})$ with the minimum cost for scheduling. The selected task $v^{*}$ is assigned to the execution queue of server $s^{*}$, and its execution duration is adjusted to $siz{e}^{\prime }\left(v^{*}\right)$, which is calculated using the actual efficiency coefficient of server $s^{*}$. This normalized execution time accurately reflects the heterogeneity of server resources. The system then updates the status of task $v^{*}$ and the next available time of server $s^{*}$, ensuring correct temporal ordering within the server’s execution queue. This process iterates until all tasks are scheduled. Finally, sequential edges are inserted between adjacent tasks within each server’s queue, resulting in the final DAG that fully encodes both inter-task dependencies and resource-level execution orders.

After completing the two-stage scheduling, the system performs a comprehensive feasibility verification and performance evaluation (Lines 37–38). The verification process ensures that all temporal and precedence constraints are strictly satisfied, including: (1) every predecessor task completes before its successor starts; (2) no task starts earlier than its $est\left(v\right)$ or later than its $lst\left(v\right)$; and (3) intra-client and intra-server execution orders are preserved. These checks guarantee that the final schedule is both logically and temporally feasible. Finally, the system computes the overall makespan (i.e., the completion time of the last task), and measures the resource utilization of both clients and servers, providing quantitative metrics for performance assessment.

The algorithm achieves dynamic optimization of task selection through a two-stage coordination mechanism. The first stage establishes an initial task sequence at the client level, while the second stage performs fine-grained adjustments at the server level based on actual resource efficiencies. This hierarchical optimization architecture preserves a global scheduling perspective while fully accommodating resource heterogeneity, and demonstrates favorable scalability in terms of computational complexity.

Regarding time complexity, the critical path computation phase employs a memoized recursive strategy, where each task node is processed exactly once. Its time complexity is $O\left(\right|\mathcal{V}|+|\mathcal{E}\left|\right)$, where $\left|\mathcal{V}\right|$ denotes the total number of tasks and $\left|\mathcal{E}\right|$ represents the number of precedence edges between tasks. In the client scheduling phase, a greedy strategy is adopted; in the worst case, each task must be evaluated across all compatible client resources, resulting in a time complexity of $O\left(\right|\mathcal{V}{|}^2\times \left|\mathcal{C}\right|)$, where $\left|\mathcal{C}\right|$ is the number of clients. Similarly, the server scheduling phase has a time complexity of $O\left(\right|\mathcal{V}{|}^2\times \left|\mathcal{S}\right|)$, with $\left|\mathcal{S}\right|$ denoting the number of servers. The verification and evaluation phase involves dependency checking and performance metric computation, which runs in $O\left(\right|\mathcal{V}|+|\mathcal{E}\left|\right)$. In summary, the overall time complexity of the algorithm is $O\left({\left|\mathcal{V}\right|}^2\times \left(\right|\mathcal{C}|+\left|\mathcal{S}\right|)+\left|\mathcal{V}\right|+\left|\mathcal{E}\right|\right)$, which falls within the class of polynomial-time solvable problems and is suitable for medium-scale distributed scheduling scenarios. In terms of space complexity, the algorithm primarily stores the task dependency graph, critical path lengths, resource state information, and efficiency vectors. The dependency graph requires $O\left(\right|\mathcal{V}|+|\mathcal{E}\left|\right)$ space, the dictionary for critical path lengths occupies $O\left(\right|\mathcal{V}\left|\right)$, resource state information takes $O\left(\right|\mathcal{C}|+|\mathcal{S}\left|\right)$, and the storage for efficiency vectors is $O\left(\mathcal{M}\right)$, where $\mathcal{M}$ is the number of task types. Therefore, the total space complexity is $O\left(\right|\mathcal{V}|+|\mathcal{E}|+|\mathcal{C}|+|\mathcal{S}|+\mathcal{M})$, which grows linearly with the problem scale, indicating good spatial efficiency. While the theoretical time complexity suggests challenges for extremely large-scale problems (e.g., those with 10,000 tasks), several mitigating factors are present in practice. The size of the ready task set is typically much smaller than the total task set |V|. Furthermore, constraints on resource types significantly limit the scheduling choices at each step, and the critical-path-based heuristic effectively prunes the search space. These factors collectively ensure that the algorithm maintains practical efficiency for the problem scales targeted in this work.

5. Performance Evaluation

5.1. Experimental Setup

This study employs a simulation-based approach to evaluate the performance of the proposed algorithm, using simulation scenarios constructed following the methodology of Wang et al. [14]. First, a baseline scenario is established to represent a medium-scale metrology service. The specific parameter settings are detailed in the following subsection. Subsequently, key parameters in the baseline scenario are systematically varied to assess the algorithm’s performance under a wider range of conditions. For each experimental setting, 20 independent problem instances are randomly generated. All reported performance metrics represent the average values calculated over these instances. The simulation experiments were conducted on a laptop computer equipped with an Intel^® Core^TM Ultra5 CPU and 32 GB of RAM.

The experimental data are derived from our team’s operational distributed remote calibration system [13], with parameters grounded in its application to electromagnetic transformer calibration. As outlined in

Table 2. Default Simulation Parameters for Distributed Workflow System.

Category	Parameter	Default Value
	Experts	24
Resource Configuration	Client Sites	3
	Devices	24
	Task Types	10
Task Configuration	Tasks per Workflow	20
	Samples per Job	20
Capability Limits	Max Types per Expert	6
	Max Types per Device	3

, the baseline scenario simulates a metrology service with 24 experts serving 3 customer sites, each equipped with 24 standard devices. The calibration workload at each site comprises 20 samples, with the calibration process for each sample defined by a directed acyclic graph (DAG) of 20 interdependent tasks. Parameters for tasks, resources, and uncertainties are randomly generated. The scenario incorporates 10 distinct task types. The standard execution time for each task is sampled from a uniform distribution $U(15,100)$ (unit: minutes). Regarding resource capabilities, each expert is capable of handling up to 6 task types. Each device is configured to support up to 3 task types.

To validate the performance of the proposed algorithm, we compare it against four baseline methods. These methods are selected to enable a comprehensive comparison across different categories of scheduling strategies: CP-PS, the Random First-Come-First-Served algorithm (R-FCFS), the Dual-Resource-Constrained Genetic Algorithm (DRC-GA), and the Largest Gap First Scheduling algorithm (LGF-S). All baseline algorithms are configured with parameters as specified in their original publications.

1.

R-FCFS serves as a naive baseline, which assigns tasks randomly to available resources. It embodies minimal optimization logic, providing a benchmark to quantify the performance gains of more sophisticated methods.

2.

DRC-GA represents a metaheuristic approach, providing a contrast between global search capabilities and problem-specific heuristics. It adapts standard genetic operators (crossover and mutation) to the dual-resource constrained environment. Through iterative evolution, it searches for a near-optimal schedule that satisfies task dependencies and resource constraints.

3.

LGF-S implements a greedy heuristic that schedules tasks into the largest available idle blocks across client and server resources, aiming to minimize fragmentation. As a locally optimizing heuristic, it is well-suited for real-time scheduling and provides a contrast to global search methods like DRC-GA.

5.2. Scalability Evaluation

To evaluate the scalability of the proposed algorithm under problem instances of different scales, this paper examines its performance trends by adjusting the scale of system resources and workload complexity. As shown in Figure 3a, to analyze the impact of the number of client devices on the experimental results, this paper adjusts the number of devices at each site from the baseline value of 24 to the range of 8 to 40. The results show that as the number of clients increases, the task completion time decreases, indicating that the proposed algorithm has good scalability and stability. Moreover, under all tested scales, the proposed algorithm achieves the optimal performance, with an average performance improvement of about 9.37%, and the improvement margin remains stable. The above results indicate that the proposed algorithm is more efficient in optimizing resource allocation under different scale scenarios.

Furthermore, to evaluate the impact of the number of expert servers on the experimental results, as shown in Figure 3b, this paper adjusts the number of servers at each site from the baseline value of 24 to the range of 8 to 40. Similar to the impact of the number of clients, the task completion time decreases as the number of expert servers increases; under all tested scales, the average performance improvement of the proposed algorithm is about 8.05%. It is worth noting that compared to the number of clients, the number of expert servers has a more significant impact on the task completion time, and the rate of decrease gradually slows down as the number of servers increases. This is attributed to the improvement in resource availability alleviating the system resource bottleneck, thereby reducing the potential space for further optimizing resource utilization. Therefore, in scenarios with abundant resources, the algorithm performance tends to stabilize, and the marginal benefit of further increasing resources on task completion time gradually diminishes.

Figure 3a,b evaluate the impact of the number of clients and expert servers on system performance in the baseline scenario. However, in actual deployment, device distribution is often difficult to achieve complete uniformity. To this end, this paper further evaluates the performance trend of the algorithm under non-uniform distribution scenarios. As shown in Figure 3c, to analyze the impact of the number of clients under non-uniform distribution, this paper sets the number of devices at each site to 0.8 to 1.2 times the baseline value. As shown in Figure 3d, to further analyze the impact of non-uniform distribution conditions, a benchmark scenario is selected, and the number of client devices is varied by around 20%. The results show that as the number of clients increases, the task completion time decreases, indicating that the proposed algorithm still maintains good scalability and stability under non-uniform distribution scenarios. Moreover, under all tested scales, the proposed algorithm achieves the optimal performance, with an average performance improvement of about 8.26%, and the improvement margin remains stable, close to the optimization results in the uniform scenario. The above results indicate that the proposed algorithm can still efficiently optimize resource allocation under non-uniform distribution scenarios of different scales.

5.3. Utilization Evaluation

As shown in Figure 4, to evaluate the impact of different resource configurations on the performance of task scheduling algorithms, we adjusted the number of experts and clients, respectively, and analyzed the performance of four algorithms in terms of server and client resource utilization. The experimental results show that algorithm performance is significantly influenced by changes in resource scale. When the number of experts increases from 8 to 40, the CP-PS algorithm maintains optimal performance in server resource utilization, achieving high server resource utilization, while client resource utilization shows a stable growth trend, reflecting its excellent resource adaptability. In contrast, the LGF-S algorithm performs the worst in server resource utilization, and its client resource utilization grows slowly. When the number of clients increases from 8 to 40, the server resource utilization of the CP-PS algorithm improves rapidly and remains stable at a high level, while client resource utilization declines due to intensified resource competition. The DRC-GA and LGF-S algorithms perform moderately in both scenarios, particularly when the number of clients increases, the client resource utilization of LGF-S drops to 10%, reflecting its limitations in resource allocation efficiency. Overall, the CP-PS algorithm demonstrates the best resource utilization efficiency under different resource configurations, validating its adaptability in various resource environments.

As shown in Figure 5, to evaluate the impact of parameter $\alpha$ in the heuristic algorithm on scheduling performance, we systematically tested the algorithm’s performance as $\alpha$ varied from 0 to 0.8. As shown in Figure 5a, the increase in $\alpha$ value has a certain impact on scheduling performance. As $\alpha$ increases, the task completion time shows an increasing trend. This phenomenon indicates that larger $\alpha$ values tend to assign higher weight to critical path length, causing the algorithm to be more conservative in task selection, thereby extending the overall scheduling time. As shown in Figure 5b–d, the increase in $\alpha$ also brings negative impacts on resource utilization. Although excessively large $\alpha$ values can ensure priority processing of critical tasks, they sacrifice the overall resource utilization efficiency of the system. Comprehensive analysis shows that parameter $\alpha$ establishes an important trade-off relationship between task criticality and system efficiency. Smaller $\alpha$ values can maintain reasonable task completion times while sustaining high resource utilization, making them more suitable for resource-constrained practical application scenarios. While larger $\alpha$ values can improve the responsiveness of critical tasks, they reduce overall system efficiency. In conclusion, $\alpha$ was set to 0.2 in the experiments.

Figure 6 shows the boxplots of server resource utilization and client resource utilization, which reflect the impact of parameter $\alpha$ on task scheduling and resource allocation strategies. Parameter $\alpha$ establishes an important trade-off relationship between task criticality and system efficiency. When $\alpha$ is at a moderate value, the scheduling algorithm can more effectively balance task dependencies and resource competition, resulting in higher client resource utilization with relatively concentrated distribution. Larger $\alpha$ values tend to assign higher weight to critical path length, causing the algorithm to be more conservative in task selection, thereby reducing resource utilization. This phenomenon demonstrates the role of parameter $\alpha$ in distributed task scheduling, where moderate $\alpha$ values can optimize resource utilization efficiency, while extreme values may lead to resource waste or performance instability.

5.4. Performance Under Resource Heterogeneity

In addition to the number of clients, servers, and tasks, device resource configurations and expert capabilities also affect system performance.

Figure 7a shows the variation in device-supported types, where the experiment adjusts the number of device resource configurations from the baseline value of 3 to the range of 1 to 5. The experimental results show that as the device resource configuration increases, the task completion time decreases. Figure 7b shows the variation in expert skill breadth, where the experiment adjusts the expert capability from the baseline value of 6 to the range of 2 to 10. The experimental results show that as the expert capability increases, the task completion time decreases. The experimental results for varying device resource configurations and expert capabilities are quite similar, both showing a decreasing trend, with a significant decline at the beginning and then the completion time stabilizes.

In the description of experimental results, Figure 7a,b evaluate the impact of device resource configurations and expert capabilities on system performance in the baseline scenario. Considering that completely uniform distribution is uncommon in actual deployment, this paper further explores the performance trend of the algorithm under non-uniform distribution scenarios. As shown in Figure 7c, to analyze the impact of device resource configurations under non-uniform distribution, the experiment sets them to 0.8 to 1.2 times the baseline value. The results show that as the resource configuration increases, the task completion time gradually decreases. Similarly, Figure 7d shows the impact of expert capability under the same non-uniform distribution conditions. The experiment sets the expert capability to 0.8 to 1.2 times the baseline value, and the results also show a trend of decreasing task completion time as expert capability enhances. Across all tested scales, the proposed algorithm consistently achieves optimal performance, and its trend is similar to the optimization results in the uniform scenario. In summary, these results verify that the proposed algorithm can effectively optimize resource allocation even under non-uniform distribution scenarios of different scales.

5.5. Calibration Task Characteristics and Workload Impact

The power system involves a wide variety of equipment types, and different equipment have diverse requirements for calibration data. For example, transformers require monitoring of temperature and humidity, while circuit breakers may need to capture mechanical motion states and electrical parameters. To evaluate the impact of calibration requirements generated by sensors and instruments on the entire calibration scenario, this paper tests the influence of the number of calibration requirement types (task_type_num) and the number of calibration tasks (task_num) on the experimental results.

Figure 8a shows the variation in the number of calibration requirement types, where the experiment adjusts this number from the baseline value of 10 to the range of 6 to 14. The experimental results show that, except for the DRC-GA algorithm which initially decreases rapidly, the completion time does not change significantly with variations in the number of calibration requirement types. Figure 8b shows the variation in the number of calibration tasks, where the experiment adjusts this number from the baseline value of 20 to the range of 12 to 28. The experimental results show that as the number of calibration tasks increases, the task completion time exhibits an approximately linear growth trend.

To evaluate the robustness of the algorithm under different task dependency structures, this study tested four structures (random graph, intra-tree structure, extra-tree structure, and chain structure) with five scales (7, 11, 15, 23, and 31 calibration tasks). As shown in Figure 9a–d, despite differences in structure and scale, the relative performance differences among the algorithms remain stable without significant fluctuations. Although the performance improvement of the CP-PS algorithm compared to other algorithms slightly diminishes as the scale increases, its overall performance remains significantly superior to other comparative algorithms.

6. Conclusions

This paper introduced a novel multi-resource synchronized collaborative scheduling framework specifically designed to address the complex coordination challenges in large-scale remote calibration systems. By formulating the scheduling problem as a dual-container synchronized optimization model, the proposed framework effectively bridged the gap between heterogeneous task requirements and distributed resource capabilities, while ensuring precise temporal synchronization across edge devices and cloud-based expert services. The developed two-phase heuristic algorithm demonstrated remarkable efficiency in jointly optimizing task allocation and sequencing under various constraints, including resource heterogeneity, workload diversity, and task dependency structures.

Comprehensive experimental evaluations validated the superior performance of the proposed method across multiple critical dimensions. The framework exhibited exceptional scalability, maintaining stable performance improvements averaging 9.37% under varying client device quantities and 8.05% under different expert server configurations. Notably, the algorithm preserved its optimization effectiveness even under non-uniform resource distribution scenarios, achieving consistent performance enhancements of approximately 8.26%. Furthermore, the solution demonstrated robust adaptability to diverse calibration task characteristics and maintained stable performance superiority across different task dependency structures, including random graphs, tree-based structures, and chain configurations.

The research contributions presented in this work paved the way for several promising directions in future research. Immediate extensions will focus on developing adaptive real-time scheduling mechanisms capable of handling dynamic resource availability and fluctuating workload conditions. Additionally, we plan to explore the application of this framework in broader cyber-physical metrology networks, particularly in smart grid systems and industrial IoT environments where precise synchronization and resource coordination are paramount. The integration of machine learning techniques for predictive resource management and task scheduling represents another compelling direction for enhancing the framework’s intelligence and practical applicability.