Synchronous Remote Calibration for Electricity Meters: Application and Optimization

Abstract

Remote calibration is an advanced methodology that leverages electricity meters, intelligent detection, and computing technologies to enhance calibration efficiency and precision significantly. However, current research predominantly focuses on isolated calibration architectures tailored to single-laboratory environments. In contrast, distributed remote calibration systems that integrate multiple nodes remain in their early developmental stages, despite their considerable potential for improving scalability and operational efficiency. The purpose of this paper is to propose a multi-point collaborative distributed remote calibration model that improves scalability and operational efficiency for remote sensing devices. It addresses the challenge of resource allocation for synchronous calibration across distributed nodes by introducing a hybrid genetic algorithm that optimises scheduling and resource management. Experimental results reveal that the proposed algorithm surpasses other comparable methods in its category, highlighting its capability to improve resource efficiency in distributed remote calibration systems. Additionally, the hybrid genetic algorithm offers profound insights and effective solutions to the intricate challenges of task scheduling in dual-container synchronisation, enhancing both scheduling performance and system dependability.

1. Introduction

Calibration ensures the accuracy and reliability of electricity meters [1,2,3], which is critical for ensuring operational efficiency, minimising energy losses, and adhering to regulatory standards. The increasing adoption of electricity meters across various industries has significantly increased the demand for calibration. Traditional methods of calibration often involve moving meters to central facilities or sending technicians to remote sites. These methods require a lot of manual labour and have high operational costs, which can lead to mistakes in process control and high transportation costs. They can no longer satisfy the growing calibration demands, necessitating scalable and efficient solutions.

Advanced technology called remote calibration combines electricity meters, smart detection systems, and computer technologies to make calibration processes much more accurate and efficient [4,5]. As illustrated in Figure 1, a remote calibration system is built on three key components: the central laboratory, the detection point, and reliable internet connectivity. Standard equipment and metering devices at the detection point collect data and perform calibration tasks. Concurrently, experts at the central laboratory remotely monitor the calibration process through internet-based systems, offer real-time guidance, and issue calibration certificates. Compared to traditional on-site calibration, which required metrologists to perform operations in person, remote calibration enhances personnel efficiency through improved task management and record-keeping while also streamlining the transportation process. This area requires further research and technological development to enable remote calibration, meeting the increasing demand for calibrating various electricity measuring devices.

Many metrology laboratories, including the National Institute of Standards and Technology (NIST) [6] and the National Physical Laboratory (NPL) [7], have begun developing remote calibration systems customized to their requirements. The goal is to make open remote calibration systems that use Internet of Things (IoT) technologies and smart algorithms to let equipment talk to each other, get data, and be calibrated from afar. We anticipate these advancements to enhance the calibration efficiency of devices like frequency meters, optical frequency standards, and coordinate measuring machines. However, existing research [6,7,8,9] has predominantly focused on isolated remote calibration architectures designed for single-laboratory use. In contrast, distributed remote calibration systems—capable of integrating multiple nodes and advanced computational resources—are still in their nascent stages and require additional research and development [10].

For distributed remote calibration systems, it is essential to develop advanced task scheduling methodologies specifically designed to leverage the strengths of distributed systems. However, current research on task scheduling primarily focuses on asynchronous tasks [11,12,13]. Scheduling paradigms employed by platforms such as orderly power management [14], core-level Dynamic Voltage and Frequency Scaling (DVFS) systems [15], and similar frameworks utilize distinctive models. Similarly, methodologies in control system scheduling [16] and cloud resource task scheduling [17,18] exhibit unique characteristics but differ significantly in their approaches. These models, however, fail to adequately represent tasks requiring synchronous processing across multiple devices and do not sufficiently address the demands of distributed remote systems, which necessitate real-time coordination across geographically dispersed nodes. Although attempts such as Q. Wang et al.’s Dynamic Synchronous Scheduling (DSS) algorithm [19], which employs a multi-layered greedy approach, have been proposed to address task synchronization in remote sensor calibration systems, their effectiveness remains limited. To optimize resource utilization and operational efficiency in remote calibration systems, there is an urgent need to develop advanced and efficient scheduling mechanisms.

Motivated by these challenges, this paper investigates methodologies for synchronizing task scheduling, an extension of the traditional Parallel Machine Scheduling Problem (PMS). The goal of synchronizing task scheduling is to efficiently divide tasks between two types of devices while making sure that processes are in sync by sending data in real time. It extends PMS by incorporating the critical requirement of process synchronization.

This paper builds upon this foundation to address two primary issues in distributed remote calibration systems. The first issue is the substantial variability in calibration demands arising from the complexity and diversity of equipment, data types, and the geographical distribution of detection points and laboratories. The second issue involves the need for synchronized interactions between detection points and central laboratories, complicating scheduling strategies that depend on the specific requirements of each calibration task.

In summary, this paper makes the following contributions:

• We introduce a multi-point collaborative distributed remote calibration model to address the growing demands of remote sensing devices, focusing on current and voltage sensors. By looking at how resources behave in remote calibration situations, we change the way resource modeling works to focus on two important parts: the calibration expert as a scarce resource and the standard device.
• We decompose the synchronized task scheduling problem into two interrelated components: device-based optimization and sequence-based optimization. To address these challenges, we develop an innovative hybrid genetic algorithm that seamlessly integrates these components to ensure efficient and flexible utilization of resources.
• Experiments validate the proposed method, showcasing its superior performance in resource allocation and scheduling flexibility. Extensive experiments with varying tasks, servers, and clients confirm its adaptability and efficiency over established algorithms such as Longest Task First (LTF), Shortest Task First (STF), and the Dynamic Synchronous Scheduling (DSS) algorithm.

The rest of this article is structured as follows. Section 2 provides an overview of related work. In Section 3, the mathematical modeling framework for remote sensor calibration is explained, and the proposed algorithm is introduced. In Section 4, the performance of the proposed scheme is evaluated by comparing it to well-known baseline algorithms. Finally, Section 5 offers a concise conclusion summarizing the key findings of the study.

2. Related Work

2.1. Remote Calibration Systems

The advent of remote calibration facilitated by the Internet has significantly enhanced both the efficacy and accuracy of calibration processes, propelling it to the forefront of metrology research endeavors, as highlighted by Fang Lide’s work [4]. Numerous calibration laboratories around the world have developed specialized remote calibration systems, meticulously tailored to their respective calibration objectives.

The National Institute of Standards and Technology (NIST) [6] has developed a remote calibration system for multifunctional electrical calibrators. This system uses a portable digital multimeter to interface with the device under calibration and a reference calibrator, utilizing internet connectivity to facilitate the dissemination of testing protocols, software, and data. The National Physical Laboratory Services (NPL) embarked on a remote calibration initiative for Vector Network Analyzers (VNAs) [7], initiating the UK’s first calibration service in February 2001, capable of attributing measurement outcomes directly to national standards via the Internet. In Italy, a team led by Carullo A [8] at the Polytechnic University of Turin developed a remote calibration system for data acquisition cards. This system is distinguished by its ability to process real-time data on the Internet, simultaneous measurements to determine precision, and the incorporation of temperature sensors to account for environmental impacts on measurement results. To improve data security, the system implements a dual backup strategy that replicates information on both the server and client platforms.

Moreover, scholars have delved into remote calibration systems tailored to specific metering devices within their respective fields of study. Kobata et al. [9] introduced a remote calibration technique designed to explore the transmission of pressure standards via the calibration of pressure sensors. This technique facilitates the transportation of pressure standard devices to remote sites, the transmission and tracking of measurements through communication technologies, and the centralized processing and calibration of data in distant laboratories. Raouf et al. [20] engineered an automated system for remote resistance calibration using the LabVIEW platform, primarily intended for routine calibrations requiring modest precision. This system exemplifies advancements in leveraging digital platforms to enhance calibration efficiency and reach.

Furthermore, researchers have integrated remote calibration systems into industrial applications and daily life, thereby enhancing productivity and product quality. Q. Wang et al. [21] investigated a remote calibration device incorporating edge intelligence for environmental monitoring. This device connects heterogeneous edge devices via network protocols to enhance the intelligence and efficiency of remote calibration, achieving identification accuracy over 90% for some instruments. Kumar et al. [22] improved remote environmental measurement systems and developed wireless environmental condition measuring devices for monitoring and recording, with their WEMMR device calibrated against national standards provided by the Indian National Physical Laboratory. In the energy sector, Kurniawan et al. [23] designed a remote measurement system to transmit battery parameters from remote areas to servers, enabling the monitoring of charging status and preventing overcharging and discharging. Jebroni et al. [24] integrated a calibration board into smart electricity meters, incorporating an integrated calibration card into the power measurement chain to enable remote value transmission and traceability, ensuring stable AC voltage output despite fluctuations in input AC voltage. L. Fang et al. [25] proposed a DC voltage source remote calibration system based on GPS common-view, installing standards in labs rather than calibration sites to avoid additional errors. W. Xia et al. [26] introduced a scheme for remote calibration of digital input meters, featuring an on-site calibration device that outputs digital sampling values to the meter under test, with signal waveforms scheduled by a remote master station. Z. Chen et al. [27] developed a remote calibration system for DC EV chargers’ metering devices, using real-time pulse comparison for verification.

Studies on remote calibration systems typically consider single calibration laboratories handling tasks in a centralized manner, which can become inefficient in large-scale operations. Distributed remote calibration [10], though potentially more efficient and scalable, remains underexplored.

2.2. Task Scheduling Systems

With advancements in technology and growing application demands, task scheduling research remains an active field, continually contributing to enhanced system performance and efficiency. To address the demands of higher collection frequency in a high-frequency power load orderly consumption management platform, J. Tao et al. [14] proposed a priority-based intelligent task scheduling strategy that considers channel capacity, concurrent tasks, collection frequency, and task execution immediacy. Similarly, F. Teng et al. [15] introduced a power allocation algorithm that assigns real-time periodic tasks to energy-efficient platforms, optimizing multi-core processor power consumption while adhering to deadline constraints.

Building on their research into communication network scheduling mechanisms and methods, as well as computation tasks in power distribution grid control systems, Z. Liang et al. [16] proposed a distributed control system scheduling strategy. This strategy aims to reduce information conflicts and congestion in power distribution control networks, thereby enhancing the operational performance of networked control systems. K. Li et al. [28] investigated the challenge of scheduling task packet applications on heterogeneous platforms under deadlines and energy consumption budget constraints. They introduced an energy-aware stochastic task scheduling algorithm named ESTS, a heuristic approach that achieves high scheduling efficiency for Bag of Tasks (BoT) applications with low time complexity. Addressing the challenge of non-periodic independent real-time task scheduling for multiple airships under emergency conditions, X. Zhu et al. [29] proposed an ABDS strategy incorporating a novel two-way announcement mechanism based on Conflict and Network-awareness (CNP). This strategy effectively improves the global optimization of airship resources and load balancing.

In the context of cloud resource task scheduling, P. Zhang and M. Zhou et al. [17] proposed a two-phase strategy that pre-creates virtual machines based on historical scheduling data by incorporating task requirements such as deadlines and costs into the scheduling considerations. They came up with a way to schedule tasks that can cut down on the time it takes to finish time-sensitive tasks while keeping the workload balanced across all cloud resources in a changing cloud environment. H. Yuan et al. [18] put forth a multi-queue scheduling approach to address temporal discrepancies in Hybrid Green Infrastructure-as-a-Service Clouds (HGICs). This study also suggested a meta-heuristic optimization method that combines particle swarm optimization, simulated annealing, and genetic algorithms to solve the problem of how to make the most money in HGICs. A. Marahatta et al. [30] presented an energy-efficient dynamic scheduling scheme for real-time tasks in virtualized cloud data centers, aimed at conserving energy and optimizing the task guarantee rate, average response time, and resource utilization of cloud data centers. Addressing the task offloading decision problem in edge computing environments, J. He et al. [31] established network and task scheduling models and defined a task scheduling methodology that reduces task latency. They created an optimization algorithm to find the best way to complete tasks while taking into account delays. This improved edge task scheduling and cut down on task execution time and latency. K. Peng et al. [32] suggest and test a two-approach algorithm that can be used to improve both the deployment of microservices and the routing of requests in order to reduce the time it takes for services to respond in a Mobile Edge Computing (MEC) setting. T. Deng et al. [33] propose and validate a novel routing and scheduling algorithm for PTS-assisted multidrone parcel delivery, optimizing distance and time costs over large areas. M. Hu et al. [34] study the widespread use of time-triggered communication protocols in vehicles and design a novel Unfixed Start Time (UST) scheduling algorithm that flexibly schedules tasks and messages to enhance schedulability, along with two methods for resolving assignment conflicts to further improve scheduling performance. In the field of logistics, the literature [35] proposes a novel hybrid genetic algorithm that supports the cooperation of a ground vehicle and multiple UAVs for efficient parcel delivery, addressing the inefficiency of single-UAV approaches in serving numerous customers and optimizing routing and scheduling through several algorithmic modules.

These studies provide valuable insights into task scheduling in remote calibration systems. However, existing research on task scheduling mainly focuses on asynchronous tasks and does not sufficiently address the adaptability challenges of decentralized and synchronous tasks in distributed remote calibration systems. Although Q. Wang et al. [19] addressed the issue of task synchronization and scheduling within remote sensor calibration systems, proposing a Dynamic Synchronous Scheduling (DSS) methodology, this approach, which is grounded in a multi-layered greedy algorithm, does not demonstrate particularly high efficiency. Consequently, we have explored further optimized solutions for synchronous task scheduling.

3. Methods

3.1. System Model

This section describes the architecture of the remote calibration system, including the system model, task model, and overall optimization objectives.

3.1.1. Network Model

In the remote calibration process, the central laboratories and detection points are key components, with calibration tasks scheduled between them using remote technology. We model this process as a distributed remote calibration system, which facilitates task allocation between the server end and the client end.

• Server End: It comprises metrology experts and essential communication facilities. Given that each expert’s specialization and skill level vary, leading to differences in the types and quantities of calibration equipment they can handle, this variation is a key consideration in the scheduling process. Communication devices ensure real-time information exchange between the server and client ends, supporting online calibration operations. Although minimal transmission delays occur during this communication, their impact on the overall calibration process is negligible and can be largely disregarded.
• Client End: It integrates electricity metering devices (the devices requiring calibration), standard equipment, operating personnel for the procedures, and communication technologies. The system’s core components, the electricity metering devices and standard equipment, jointly execute the calibration process. Operating personnel follow remote guidance from experts to execute the actual calibration steps. This role has modest technical requirements and ample human resources, thus not posing a significant constraint in the scheduling strategy. Communication devices once again play a pivotal role in maintaining real-time communication between both ends, with minor delays having little effect on the overall smoothness of calibration activities and can be disregarded.

Some parameters of the distributed remote calibration system are shown in

Table 1. Parameters for remote calibration system.

Symbols	Explanations
${\mathcal{N}}_K$	The set of detection points
${\mathcal{N}}_G$	The set of central laboratories
$i,j$	The index of detection points, central laboratories
$G_i^r$	The coverage restriction of central laboratory
$D_{g_i,k_j}$	The distance between two points $\left(x_{k_i},y_{k_i}\right)$ and $\left(x_{g_j},y_{g_j}\right)$
${\mathbf{D}}_{\mathbf{KG}}$	The distance matrix of detection points and central laboratories
${\mathcal{N}}_C$	The set of clients
${\mathcal{N}}_S$	The set of servers
$m,n$	The index of clients, servers
$CT{Y}_{m,ty}$	Indicates whether client $c_m$ can process tasks of type $Q_{ty}$
$ST{Y}_{n,ty}$	Indicates whether server $s_n$ can process tasks of type $Q_{ty}$
${\mathcal{N}}_X$	The set of tasks
t	The index of tasks
$X_t^{Q_{ty}}$	The task type of $X_t$
$X_t^{\tau }$	The processing time of task $X_t$
$X_t^{st}$	The start time of task $X_t$
$X_t^{et}$	The end time of task $X_t$
$X_t^{C_m}$	The client assigned to task $X_t$
$X_t^{K_i}$	The detection point assigned to task $X_t$
$X_t^{S_n}$	The server assigned to task $X_t$
$X_t^{G_j}$	The central laboratory assigned to task $X_t$

. A distributed remote calibration network is depicted in Figure 2, where detection points are located within the overlapping coverage areas of several laboratory stations. The distributed remote calibration network model is described as $\mathcal{I}=({\mathcal{N}}_K,N_G)$, where ${\mathcal{N}}_K$ and ${\mathcal{N}}_G$ represent the set of detection points and the set of central laboratories, respectively. Specifically, the set ${\mathcal{N}}_K=\left\{K_1,K_2,\dots ,K_i\right\}$ denotes the detection points. Each detection point $K_i\in {\mathcal{N}}_K$ hosts multiple clients (standard equipments) and has a two-dimensional coordinate $\left(x_{k_i},y_{k_i}\right)$. Similarly, the set ${\mathcal{N}}_G=\left\{G_1,G_2,\dots ,G_j\right\}$ denotes the central laboratories. Each central laboratory $G_j\in {\mathcal{N}}_G$ accommodates several servers (metrology experts) and is assigned a two-dimensional coordinate $\left(x_{G_j},y_{G_j}\right)$. Additionally, each central laboratory has a coverage restriction denoted by $G_j^r$.

By combining the coordinates of the detection points and central laboratories, the matrix ${\mathbf{D}}_{\mathbf{KG}}$ represents the distances between them. These distances are calculated using the Euclidean distance Formula (1).

$$D_{K_i,G_j}=\sqrt{{(x_{K_i}-x_{G_j})}^2+{(y_{K_i}-y_{G_j})}^2}$$

(1)

The scheduling infrastructure encompasses a distributed network of sensors at various detection points and servers situated within central laboratories. We designate the diverse standard equipments as clients, differentiating them by their geographical placement and the specific tasks they are capable of executing. Let ${\mathcal{N}}_C=\{C_1,C_2,\dots ,c_{|{\mathcal{N}}_C|}\}$ denote the ensemble of heterogeneous standard equipment deployed across an array of detection points, where each element $C_m$ signifies a distinct client (i.e., sensor). The cardinality of the set ${\mathcal{N}}_C$, denoted by $|{\mathcal{N}}_C|$, represents the aggregate number of such clients. ${\mathcal{N}}_C^K=\left\{C_1^{K_i},C_2^{K_{i^{\prime }}},\dots ,C_{|{\mathcal{N}}_C|}^{K_{i^{\prime }}}\right\}$ expresses the relationship between clients and detection points, where $C_m^{K_i}$ indicates that client $C_m$ is situated at detection point $K_i$; for instance, $C_4^{K_1}$ indicates client $C_4$ situated at detection point $K_1$.

In a similar vein, we characterize the various metrology experts as servers, distinguishing them based on their location and the range of tasks they can undertake. Specifically, the total number of servers across different central laboratories is denoted by $|{\mathcal{N}}_S|$, where ${\mathcal{N}}_S=\{S_1,S_2,\dots ,S_{|{\mathcal{N}}_S|}\}$ symbolizes the set of service providers (i.e., servers). The relationship between these metrology experts and their respective central laboratories is expressed as ${\mathcal{N}}_S^G=\left\{S_1^{G_j},S_2^{G_{j^{\prime }}},\dots ,S_{|{\mathcal{N}}_S|}^{G_{j^{″}}}\right\}$, with $S_n^{G_j}$ signifying server $S_n$ located at central laboratory $G_j$; for instance, $S_2^{G_2}$ indicates server $S_2$ stationed at central laboratory $G_2$.

3.1.2. Task Model

In remote calibration systems, the number of devices requiring calibration often exceeds the available standard equipment. Therefore, it is crucial to allocate the large number of calibration requests to appropriate standard equipment and expert terminals. Each calibration request is abstracted as a task unit. Let the task set be denoted as ${\mathcal{N}}_X=\left\{X_1,X_2,\dots ,X_t\right\}$, where each task is defined as $X_t=\left(X_t^{C_m},X_t^{S_n},X_t^{Q_{ty}},X_t^{\tau },X_t^{st},X_t^{et},X_t^{pr}\right)$, indexed by $t\in \left\{1,2,\dots ,|{\mathcal{N}}_X|\right\}$.

(a)

Task Assignment Model

The task scheduling problem involves assigning multiple independent tasks to clients and servers, considering task types and system capabilities. The tasks are executed synchronously, and the allocation follows constraints based on task type, client, server, and detection point capacities, as follows:

$$X_t^{ty}=Q_{ty}·O_t^{Q_{ty}},O_t^{Q_{ty}}\in \{0,1\},\forall X_t\in {\mathcal{N}}_X$$

(2)

$$X_t^{C_m}=C_m·O_t^{C_m},O_t^{C_m}\in \{0,1\},\forall X_t\in {\mathcal{N}}_X$$

(3)

$$X_t^{K_i}=K_i·O_t^{K_i},O_t^{K_i}\in \{0,1\},\forall X_t\in {\mathcal{N}}_X$$

(4)

$$O_t^{K_i}=O_t^{C_m}·C_m^{K_i},\forall C_m^{K_i}\in {\mathcal{N}}_C^K$$

(5)

$$X_t^{S_n}=S_n·O_t^{S_n},O_t^{S_n}\in \{0,1\},\forall X_t\in {\mathcal{N}}_X$$

(6)

$$X_t^{G_j}=G_j·O_t^{G_j},O_t^{G_j}\in \{0,1\},\forall X_t\in {\mathcal{N}}_X$$

(7)

$$O_t^{G_j}=O_t^{S_n}·S_n^{G_j},\forall S_n^{G_j}\in {\mathcal{N}}_S^G$$

(8)

where $X_t^{ty}$ denotes the type of task $X_t$, $Q_{ty}$ is the task type identifier, and $O_t^{Q_{ty}}$ is a binary decision variable indicating which type the task is; $X_t^{C_m}$ and $X_t^{K_i}$ indicate the client and detection point assigned to task $X_t$, respectively; the binary variable $O_t^{C_m}$ represents whether client $C_m$ is selected, and $O_t^{K_i}$ indicates whether detection point $K_i$ is selected for task $X_t$; similarly, $X_t^{S_n}$ and $X_t^{G_j}$ represent the server and central laboratory assigned to task $X_t$.

Based on the above equations, we now derive the constraints governing the task assignment process. Once a task is assigned to a client and a server, we must ensure that the assigned client can handle the specific task type, and that the server is capable of processing the corresponding task types:

$$\sum _{m=1}^{|{\mathcal{N}}_C|}\sum _{ty=1}^{|{\mathcal{N}}_Q|}{O}_t^{Q_{ty}}·O_t^{C_m}·CT{Y}_{m,ty}=1,\forall t\in {\mathcal{N}}_X$$

(9)

$$\sum _{n=1}^{|{\mathcal{N}}_S|}\sum _{ty=1}^{|{\mathcal{N}}_Q|}{O}_t^{Q_{ty}}·O_t^{S_n}·ST{Y}_{n,ty}=1,\forall t\in {\mathcal{N}}_X$$

(10)

In these constraints, $CT{Y}_{m,ty}$ represents the capability of client $C_m$ to handle task type $Q_{ty}$, and $ST{Y}_{n,ty}$ indicates the capability of server $S_n$ to manage task type $Q_{ty}$. The summations ensure that each task is assigned to a compatible client and server.

Additionally, tasks are generated at specific detection points, which are denoted by $X_t^{pr}$. A calibration task is initiated by the equipment at its corresponding detection point:

$$X_t^{pr}=X_t^{K_i},\forall X_t\in {\mathcal{N}}_X$$

(11)

Finally, we introduce a spatial constraint: the assigned client’s location must be within the service coverage area of the corresponding central laboratory to ensure task feasibility.

$$D_{K_i,G_j}\le G_j^r,\forall X_t\in {\mathcal{N}}_X$$

(12)

In this equation, $D_{K_i,G_j}$ represents the distance between detection point $K_i$ and central laboratory $G_j$, and $G_j^r$ denotes the coverage radius of the laboratory. This constraint ensures that the client assigned to a task is within the operational range of the central laboratory.

(b)

Task Time Scheduling

In remote calibration systems, the Internet is employed to transmit data and maintain real-time connections between detection points and central laboratories for synchronized calibration. To ensure successful task execution, both clients and servers must be scheduled simultaneously, as shown in Figure 3.

The synchronization of task start and end times between clients and servers is defined by the following equations:

$${\mathit{Time}}^{st}(C_m,X_t)={\mathit{Time}}^{st}(S_n,X_t),\forall X_t\in {\mathcal{N}}_X,\forall C_m\in {\mathcal{N}}_C,\forall S_n\in {\mathcal{N}}_S$$

(13)

$${\mathit{Time}}^{ed}(C_m,X_t)={\mathit{Time}}^{ed}(S_n,X_t),\forall X_t\in {\mathcal{N}}_X,\forall C_m\in {\mathcal{N}}_C,\forall S_n\in {\mathcal{N}}_S$$

(14)

Here, ${\mathit{Time}}^{st}(\ast ,X_t)$ and ${\mathit{Time}}^{ed}(\ast ,X_t)$ denote the start and end times of a task $X_t$ for a given assignment ∗ (client or server).

To simplify, let $X_t^{\tau }$ represent the processing time of task $X_t$, $X_t^{st}$ the start time, and $X_t^{et}$ the end time:

$$X_t^{\tau }=X_t^{et}-X_t^{st}$$

(15)

Each client or server can only handle one task at a time, implying that subsequent tasks must wait for the previous ones to finish. The relationship between task start times can be expressed as:

$$X_a^{st}\le X_b^{st}\le \cdots \le X_d^{st},\forall X_a,X_b,\dots ,X_d\in {\mathcal{N}}_X$$

(16)

This inequality ensures that task $X_a$ starts no later than task $X_b$, which in turn starts no later than task $X_d$. The execution order of tasks is then represented by the sequence:

$$P=\{a,b,\dots ,d\},\mathrm{where}{X}_a^{st}\le X_b^{st}\le \cdots \le X_d^{st}$$

(17)

The sequence set P defines the ordered sequence of tasks, ensuring that each task starts after or at the same time as the preceding one.

3.1.3. Optimization

In order to optimize the use of the client and expert side and improve efficiency, our primary objective is to minimize the maximum completion time, which indicates the moment when all tasks are finished. As shown in Figure 3, the execution sequence of tasks can significantly impact the overall performance, as demonstrated in Figure 3a,b. Moreover, different allocation strategies lead to varying results, as depicted in Figure 3b,c. The optimal scheduling strategy is illustrated in Figure 3c, achieving a maximum completion time of 90.

Optimization Objective 1: Minimize the Maximum Completion Time.

$$T_1=max{X}_t^{et},\forall X_t\in {\mathcal{N}}_X$$

(18)

To avoid the scenario illustrated in Figure 4, where the schedule in Figure 4b is superior to that in Figure 4a even with the same maximum completion time, we also aim to reduce the average completion time $T_2$ to improve the overall efficiency. While minimizing the maximum completion time $T_1$ is our main goal, reducing the average completion time $T_2$ is an auxiliary target.

Optimization Objective 2: Minimize the Average Completion Time.

$$T_2=max\left(\overline{C^{et}},\overline{S^{et}}\right)$$

(19)

where $\overline{C^{et}}$ and $\overline{S^{et}}$ are the average completion times for clients and servers, respectively:

$$\overline{C^{et}}={\displaystyle \frac{1}{|{\mathcal{N}}_C|}}\sum _{i=1}^{|{\mathcal{N}}_C|}max{\mathit{Time}}^{et}(C_m,X_t),\forall X_t\in {\mathcal{N}}_X$$

(20)

$$\overline{S^{et}}={\displaystyle \frac{1}{|{\mathcal{N}}_S|}}\sum _{i=1}^{|{\mathcal{N}}_S|}max{\mathit{Time}}^{et}(S_n,X_t),\forall X_t\in {\mathcal{N}}_X$$

(21)

In order to balance these two objectives during optimization, a parameter $\gamma \in [0,1]$ is introduced to ensure that one objective $T_2$ does not dominate the other $T_1$. Thus, the optimization problem is defined as follows:

$$min\left(T_1+\gamma T_2\right)$$

(22)

subject to constraints (2)–(16).

3.2. Algorithm

In this section, we propose a new Hybrid Genetic Algorithm (HGA) to address the aforementioned problem. The HGA simulates the evolutionary process of “survival of the fittest” observed in nature, thereby aiding in obtaining the optimal solution.

3.2.1. Structure of HGA

The HGA begins by generating an initial solution and subsequently creates multiple populations, as populations M, derived from this initial solution. It then iteratively applies device-based and sequence-based optimizations to refine and update the population, aiming to identify the optimal solution. The algorithm framework is illustrated in Figure 5.

3.2.2. Structure of Solution

To utilize the Hybrid Genetic Algorithm (HGA) for solving the task scheduling problem presented in this paper, it is first necessary to elucidate the process of mapping the solution space to the coding space.

Considering both the client and server, it is possible to determine whether the server’s deployment location falls within the service range of the corresponding central laboratory. Accordingly, client-side encoding and server-side encoding based on device allocation can be obtained. The client-side coding sequence is represented as ${\mathrm{X}}^C=\left[X_1^{C_m},X_2^{C_{m^{\prime }}},\dots ,X_{|{\mathcal{N}}_X|}^{C_{m^{″}}}\right]$, where $C_m\in {\mathcal{N}}_C$. The server-side coding sequence is represented as ${\mathrm{X}}^S=\left[X_1^{S_n},X_2^{S_{n^{\prime }}},\dots ,X_{|{\mathcal{N}}_X|}^{S_{n^{″}}}\right]$, where $S_n\in {\mathcal{N}}_S$.

In addition, the synchronous scheduling problem should satisfy some time constraints, including that the server or client can only process one calibration task at the same time, and the tasks in the later order must be executed after the completion of the tasks in the previous order. These constraints can be expressed in the form of arranging the order of execution of the tasks, which is described in more detail above. Accordingly, the sequential node can be obtained. The sequential node is $\left[a,b,\dots ,d\right]$ based on the order of task execution $P=\{a,b,\dots ,d\},\mathrm{where}{X}_a^{st}\le X_b^{st}\le \cdots \le X_d^{st},\forall X_a,X_b,\dots ,X_d\in {\mathcal{N}}_X.$

In summary, in order to map the solution space to the encoding space, we use the following chromosome to represent a decision scheme:

$$chormosome=\left\{node\left(X^C\right) \& node\left(X^S\right) \& node\left(P\right)\right\}$$

(23)

3.2.3. Strategy Comparison

In order to achieve our optimisation goal, we require a method for evaluating scheduling strategies. This section outlines the specific process of translating decision solutions, comprised of client queues, server queues, and sequential queues, into a scheduling strategy. During this scheduling process, the algorithm also optimises the target task completion times and the fitness of individuals within the population. The pseudo-code for this algorithm is as follows:

Initially, completion times are set to zero; that is, without any task allocation, the execution completion times for all clients $C_m^{et}$ and servers $S_n^{et}$ are initialized to 0. Thereafter, task allocation begins based on a sequential allocation principle. The first task $X_t$ is retrieved from the set $P=\{X_t,X_{t^{\prime }},\dots ,X_{t^{″}}\}$, and the assigned client $C_m$ and server $S_n$ are determined, along with their respective execution completion times $C_m^{et}$ and $S_n^{et}$. By comparing these two times, the start time of the task $X_t^{st}$ is set as the maximum of the two, $\max (C_m^{et},S_n^{et})$, ensuring that the task’s start time does not precede the end time of the previous task on either the corresponding client or server. Following this, the task completion time is calculated as $X_t^{st}+X_t^{\tau }$. The client execution completion time $C_m^{et}$ and server execution completion time $S_n^{et}$ are also updated to $X_t^{st}+X_t^{\tau }$, facilitating subsequent calculations. Once a task is allocated, the next task in sequence from set P is selected and allocated following the same steps until all tasks are allocated. Ultimately, by comparing the completion times of all tasks, the maximum task completion time $T_1$ and the average completion time of all tasks $T_2$ are obtained.

After determining the maximum task completion time, the fitness of the decision solution can be computed. This fitness calculation aims at two objectives, which are specifically:

$$\mathrm{Fitness}={\displaystyle \frac{1}{T_1+\gamma T_2}}$$

(24)

As previously mentioned, our decision solution must adhere to specific equipment and time constraints. The above scheduling solution satisfies the time constraints. However, further assessment is necessary to satisfy other optimization criteria. This involves verifying whether the assigned client can handle the task type (Line 15), whether the server is capable of handling the task type (Line 17), whether the task is running at the designated detection point (Line 19), and whether the server’s deployment location meets the required conditions (Line 21). If all these conditions are met, the solution is deemed feasible, with the fitness set to:

$$\mathrm{Fitness}={\displaystyle \frac{\alpha }{T_1+\gamma T_2}}$$

(25)

Otherwise, the fitness is set to:

$$\mathrm{Fitness}={\displaystyle \frac{\beta }{T_1+\gamma T_2}}$$

(26)

where $\alpha \gg \beta$. This setup facilitates the elimination of solutions that fail to meet the conditions. The details are outlined in Algorithm 1.

Algorithm 1 Fitness Calculation Algorithm

Require:  ${\mathcal{N}}_K$: Set of detection points, ${\mathcal{N}}_G$: Set of central laboratory nodes, ${\mathcal{N}}_X$: Set of all tasks Ensure:  Fitness value $fitness$   1: for $m=1$ to $|{\mathcal{N}}_C|$ do   2:       $C_m^{et}\leftarrow 0$   3: for $n=1$ to $|{\mathcal{N}}_S|$ do   4:       $S_n^{et}\leftarrow 0$   5: while P do   6:       Select task $X_t$ from set P   7:       Identify corresponding client $X_t^{C_m}$ and server $X_t^{S_n}$   8:       $X_t^{st}\leftarrow max(C_m^{et},S_n^{et})$   9:       Update $C_m^{et},S_n^{et},X_t^{et}\leftarrow X_t^{st}+X_t^{\tau }$ 10: $T_1\leftarrow max\left(X_t^{et}\right)$ 11: $T_2\leftarrow max(\overline{C^{et}},\overline{S^{et}})$ 12: Initialize: $succ\leftarrow 0$ 13: for $X_t=1$ to $|{\mathcal{N}}_X|$ do 14:       Initialize: $pr\_succ,cty\_succ,sty\_succ,d\_succ\leftarrow 0$ 15:       if client $X_t^{C_m}$ can process task type $X_t^{Q_{ty}}$ then 16:             $cty\_succ\leftarrow 1$ 17:       if $sever{X}_t^{S_n}$ can process task type $X_t^{Q_{ty}}$ then 18:             $sty\_succ\leftarrow 1$ 19:       if $X_t^{C_m}$ is within detection points of $X_t^{Pr}$ then 20:             $pr\_succ\leftarrow 1$ 21:       if $\mathrm{distance}(X_t^{C_m},X_t^{S_n})<\mathrm{cover}\left(X_t^{S_n}\right)$ then 22:             $d\_succ\leftarrow 1$ 23:       if $pr\_succ\wedge cty\_succ\wedge sty\_succ\wedge d\_succ$ then 24:             $succ\leftarrow 1$ 25:       else 26:             $succ\leftarrow 0$ 27:             break 28: if $succ$ then 29:       $fitness\leftarrow {\displaystyle \frac{\alpha }{T_1+\gamma T_2}}$ 30: else 31:       $fitness\leftarrow {\displaystyle \frac{\beta }{T_1+\gamma T_2}}$ 32: return $fitness$

3.2.4. Description of the Hybrid Gene Algorithm

The Algorithm 2 first obtains a feasible task scheduling scheme, encoded into the initial individual P and the initial optimal solution $P_0$. Subsequently, a number of different solutions are obtained by randomly changing the individuals to form the initial population M. Thereafter, the client-side and server-side queues are altered to produce a wide range of solutions while avoiding local convergence by means of a device-based optimization, which will be described in a later section. Further, the local search algorithm is used to optimize each sub-solution to find the optimal task scheduling order for each sub-solution. Finally, the fitness of the individual populations is calculated, the populations are ranked and updated using a population management approach, and the solution with the highest fitness is set as the optimal solution $P_0$.

The table (Lines 4–11) describes the device-based optimization, where the required tuning parts are the client device and the server device, and the tuning process is designed to generate as many different solutions as possible to avoid local convergence. The strategy consists of two parts: chromosome crossover and mutation. The number of individuals in the population to be processed is NUM(M), where NUM(M) is even. The solution is expanded using various crossover techniques. On the one hand, select from population M two adjacent feasible solutions $P_i$ and $P_{i+1}$, randomly exchanging the gene segments at corresponding positions in the client cohort (Lines 4–5). On the other hand, select from population M two feasible solutions $P_i$ and $P_{i+NUM\left(M\right)/2}$ separated by NUM(M)/2 (Lines 6–8), randomly exchanging the gene segments at corresponding positions in the server-side queue. Furthermore, chromosome mutation is applied to both the client and server sides. To reduce execution time while obtaining a more reasonable solution, the mutation range is limited to servers and clients capable of performing the task type.

Algorithm 2 Hybrid Genetic Algorithm

Require:  Detection points set ${\mathcal{N}}_K$, Central laboratory nodes set ${\mathcal{N}}_G$, All tasks set ${\mathcal{N}}_X$ Ensure:  Minimum task completion time   1: Generate initial feasible solution and convert it into chromosome individuals, set as initial best solution $P_0$   2: Initialize population M   3: for $j=0$ to $I{T}_{\max }$ do   4:       for $k=0$ to $NUM\left(M\right)-1$ by 2 do   5:             Swap client gene segments between $Chrom\left[k\right]$ and $Chrom[k+1]$   6:       for $k=0$ to $NUM\left(M\right)/2-1$ do   7:             Swap server gene segments between $Chrom\left[k\right]$ and $Chrom[k+NUM(M)/2]$   8:       for $k=0$ to $NUM\left(M\right)-1$ do   9:             Randomly mutate genes in $Chrom\left[k\right]$ 10:       for $k=0$ to $NUM\left(M\right)-1$ do 11:             Initialize task order queue 12:             for $i=0$ to $I{P}_{\max }$ do 13:                  Alter order queue P 14:                  Obtain fitness using Algorithm 1 15:                  if the fitness is higher then 16:                        Update the individual solution 17:             Sort population individuals by fitness 18:             if Fittest individual is better than the best solution then 19:                  Update the best solution 20:       return Solution in population M with the minimum completion time

Following the device-based optimization, a solution consisting of different client and server assignments is obtained. However, for specific client and server assignments, variations in the task execution order lead to differences in task completion time, necessitating the identification of the optimal task execution order through a local search strategy. If a solution has optimization potential, i.e., if the theoretical minimum completion time (excluding task conflicts) is less than the current best solution, a sequence-based optimization is employed to adjust the task execution order. The search strategy first establishes the initial execution order based on task types and then cross-orders tasks of different types as the starting execution order. Subsequently, a new execution order is generated through random swapping. By comparing the fitness values, the most suitable task execution order within the search range is identified.

After obtaining the appropriate task execution method for each solution, the population is sorted and updated using the population management method, and the solution with the highest fitness is set as the optimal solution $P_0$. Subsequently, this process is repeated for the population, and the optimal solution is determined after several iterations.

4. Results and Discussions

This section presents the performance evaluation of the hybrid genetic algorithm.

4.1. Experimental Results Overview

A comprehensive evaluation and detailed analysis were conducted to assess the overall performance of the hybrid genetic algorithm. Figure 6 and Figure 7 depict the visualization results of synchronous task scheduling. Different symbols in the figures represent various task types, with the numbers following the symbols indicating task generation checkpoints and the numbers after the colons denoting task execution times. The x-axis shows the start and completion times of task execution, while the y-axis represents the servers and clients to which the tasks are assigned. The figures illustrate that tasks are executed synchronously across all servers and clients, with consistent start and completion times.

Figure 6 and Figure 7 also compare the results of the Dynamic Synchronous Scheduling algorithm with those of the hybrid genetic algorithm. The depicted scenario includes a central laboratory, five distributed servers, and two detection points, with three clients at point 1 and four clients at point 2. In this setup, the hybrid genetic algorithm achieves a minimum completion time of 612, compared to 810 for the Dynamic Synchronous Scheduling (DSS) algorithm, clearly demonstrating the superior performance of the hybrid genetic algorithm. Further analysis reveals that the hybrid genetic algorithm allows tasks to be executed seamlessly on the server with the longest occupancy time, leading to a near-optimal solution for this allocation method.

The previous experiment demonstrated the outcomes of synchronous task scheduling and highlighted the optimization capabilities of the hybrid genetic algorithm. To further validate its performance, we extended our tests across different scenarios. These scenarios included a small-scale setting with a random distribution of 4 servers and 4 clients, a medium-scale setting with 8 servers and 15 clients, and a large-scale setting with 12 servers and 18 clients, handling 100, 180, and 300 tasks, respectively. Each scenario was tested nine times, with the results summarized in Figure 8. The initial data points in the figure represent randomly generated feasible solutions.

By comparing the results across these three scenarios, it is evident that the hybrid genetic algorithm consistently produces stable solutions in various settings. Moreover, the optimization process is noticeably quicker in the small-scale scenario, suggesting that the algorithm scales effectively and performs efficiently even as the complexity of the task distribution increases.

4.2. Experiment Comparison Analysis

To further evaluate the performance of the parameters affecting the Hybrid Genetic Algorithm (HGA), we conducted experiments by varying the number of tasks, servers, and clients. The outcomes were compared against those obtained using the Longest Task First (LTF) algorithm, the Shortest Task First (STF) algorithm, and the Dynamic Synchronous Scheduling (DSS) algorithm, all of which are designed for synchronous scheduling scenarios. Each experiment was averaged over multiple runs to ensure reliability. The key performance metric used was the maximum completion time of the scheduling strategies derived by the algorithms. A shorter maximum completion time indicates a more efficient scheduling strategy and, consequently, better algorithm performance.

4.3. Experimental Scenario Settings

Below is an overview of the parameter settings for different scale scenarios, including small-scale, medium-scale, and large-scale environments. The settings cover map size, the configuration of detection points and central laboratories, default configurations for servers and clients, and the number of task types. These parameters are designed to simulate environments of varying complexity and requirements, allowing for the testing and evaluation of system performance and adaptability across different scales. The parameters are shown in

Table 2. Parameter settings for different scale scenarios.

Scale	Central Lab	Total Servers	Detection Points	Total Clients	Task Types	Task Number
Small Scale	2	4	1	5	4	100
Medium Scale	2	8	2	10	6	200
Large Scale	3	12	3	18	10	300

.

• Small-Scale Parameter Settings: For the small-scale scenario, the map size is set to 15 × 15 units. The coordinates for the detection point and the central laboratories are randomly assigned without repetition. This scenario includes one detection point and two central laboratories. The default configuration consists of four servers and five clients. Additionally, there are eight distinct task types.
• Medium-Scale Parameter Settings: In the medium-scale scenario, the map size is expanded to 20 × 20 units. As in the small-scale scenario, the coordinates for detection points and central laboratories are randomly and non-repetitively chosen. This scenario features two detection points and two central laboratories, with a default setup of 8 servers and 10 clients. There are six task types in this scenario.
• Large-Scale Parameter Settings: For the large-scale scenario, the map size increases to 30 × 30 units. The selection of coordinates for detection points and central laboratories remains random and non-repetitive. This scenario includes three detection points and three central laboratories. The default configuration includes 12 servers and 18 clients, managing a total of 10 task types.

4.3.1. Impact of Task Quantity on Total Execution Time

To assess the impact of the number of tasks on the maximum task completion time, we kept all parameters constant except for the number of tasks. These tasks were randomly generated, with specific quantities defined as follows: for small-scale task scenarios, the quantities were set at [10, 20, 30, 40, 50]; for medium-scale scenarios, the quantities were [20, 40, 60, 80, 100]; and for large-scale scenarios, the quantities were [60, 120, 180, 240, 300]. After conducting multiple simulation experiments, the results for the small-scale experiments are presented in Figure 9a, for the medium-scale experiments in Figure 9b, and for the large-scale experiments in Figure 9c.

Analysis of these figures reveals that the performance differences between the Longest Task First (LTF), Shortest Task First (STF), and the Dynamic Synchronous Scheduling (DSS) algorithm are minimal. Moreover, the Hybrid Genetic Algorithm (HGA) consistently outperforms these three algorithms across different task quantities. Specifically, in small-scale scenarios, the HGA achieves an improvement of approximately 30%. In medium-scale scenarios, the enhancement is up to 9%, and in large-scale scenarios, the improvement reaches up to 10%. These results clearly demonstrate that the HGA exhibits optimal performance in smaller-scale applications.

4.3.2. Impact of Server Quantity on Total Execution Time

To assess the impact of the number of servers on the maximum task completion time, we maintained the parameters for the Central Lab, Detection Points, Total Clients, and Task Number according to the Parameter Settings for Different Scale Scenarios, while setting the Task Types to 10. The total number of servers varied across different scenarios. In the small-scale scenario, the total number of servers was set to 2, 4, 6, 8, and 10. In the medium-scale scenario, the total number of servers was set to 2, 4, 6, 8, and 10. In the large-scale scenario, the total number of servers was adjusted to 3, 6, 9, 12, and 15.

Figure 10a, Figure 10b and Figure 10c, respectively, show the impact of the number of servers on the maximum task completion time under three different scale scenarios. From the figures, it can be observed that initially, as the number of servers increases, the task completion time decreases. This occurs because the increase in the number of servers reduces the average workload per server, enabling more efficient handling of tasks at each detection point and leading to better utilization of server resources, thereby reducing the maximum task completion time. However, in later stages, although the number of servers continues to increase, the reduction in the maximum task completion time becomes limited and shows fluctuating changes. This is because the number of clients remains constant; therefore, despite the increase in the number of servers, their impact on the maximum task completion time gradually diminishes. Furthermore, regardless of the scenario or the number of servers, the maximum task completion time for the Hybrid Genetic Algorithm (HGA) is consistently lower than that of similar algorithms, demonstrating its superior performance.

4.3.3. Impact of Client Quantity on Total Execution Time

Finally, we assess the impact of the number of clients on the maximum task completion time. Similar to the previous section, we kept the number of task types constant at 10, and all other parameters, except for the number of clients, were set as shown in Table 2. The number of clients varied across different scenarios. In the small-scale scenario, the total number of clients was set to 2, 3, 4, 5, and 6. In the medium-scale scenario, the total number of clients was set to 4, 6, 8, 10, and 12. In the large-scale scenario, the total number of clients was adjusted to 6, 9, 12, 15, and 18. Figure 11a–c illustrate the impact of the number of clients on the maximum task completion time under three different scale scenarios.

As shown in the figures, during the initial stage, as the number of clients increases, the task completion time decreases. This is because increasing the number of clients reduces the average number of tasks that each client needs to handle. Additionally, tasks are more evenly distributed among the detection points, allowing for more efficient utilisation of server resources, thus reducing the maximum task completion time. However, in subsequent stages, as the number of clients continues to increase, the reduction in the maximum task completion time becomes smaller and exhibits fluctuations. This is due to the fact that the number of servers remains constant; hence, despite the increase in the number of clients, the impact on the maximum task completion time diminishes. Furthermore, regardless of the scenario or the number of clients, the maximum task completion time for the Hybrid Genetic Algorithm (HGA) is consistently lower than that of similar algorithms, demonstrating its superior performance.

4.4. Discussions

Based on the preceding experiments, it is clear that the proposed algorithm outperforms others across various scenarios. To gain deeper insights, additional analysis is presented in this paper.

Remote synchronization tasks are executed synchronously between the client and server, with key parameters such as client deployment, server deployment, and timeline arrangement. Traditional algorithms, including Longest Task First (LTF) and Shortest Task First (STF), can achieve favorable results in specific one-dimensional deployment task scenarios. However, when applying these methods to synchronous task scheduling, challenges arise regarding whether to prioritize server-side or client-side deployment, as well as resolving conflicts that may emerge after one side’s deployment is completed. Furthermore, these algorithms fail to adequately account for the interdependence between the client and server.This limitation can compromise efficiency, especially in scenarios where task synchronization between the client and server is critical.

Recent research has proposed the Dynamic Synchronous Scheduling (DSS) algorithm [19], which employs a greedy three-tier strategy and a dynamic priority adjustment mechanism to synchronize remote calibration tasks between the client and the server. This algorithm prioritizes tasks with the least flexibility and the largest data volume from the pool of schedulable tasks, assigning them to the least busy server and client. While this approach improves synchronization efficiency between the server and client, certain limitations remain, such as the lack of timeline arrangement and the absence of rollback adjustment strategies. However, in practical remote calibration scenarios where tasks are scheduled one day in advance through instructions, the arrangement of each task has a substantial impact on overall efficiency.

In contrast, this paper decomposes the dual-container synchronization scheduling problem into two steps: first, the collaborative deployment problem for the client and server, and second, the collaborative optimization problem for synchronized tasks. This method optimizes scheduling efficiency while ensuring task effectiveness by considering both task attributes and timeline arrangements. It provides a more systematic and scalable solution to task scheduling, addressing the limitations of existing methods and contributing to enhanced synchronization efficiency and reliability in remote calibration systems.

5. Conclusions

This paper introduces a collaborative distributed remote calibration model designed to address the increasing calibration demands of electricity meters, particularly for current and voltage sensors. Leveraging synchronization, we decompose the synchronized task scheduling problem within two containers into two interdependent aspects: device-based and sequence-based optimization, subsequently developing a hybrid genetic algorithm that integrates these components to ensure efficient and flexible resource utilization.

Experimental evidence demonstrates that our algorithm outperforms comparable algorithms within its category, further emphasizing its potential to enhance resource efficiency in distributed remote calibration systems. Furthermore, the analysis of the hybrid genetic algorithm provides valuable insights and practical solutions to the complex task scheduling challenges in dual-container synchronization, optimizing both execution time and system reliability.

Future research could investigate methods for effectively handling task dependencies by enhancing the algorithm’s capacity to dynamically adjust execution order, ensuring efficient resource utilization while minimizing conflicts and delays. Furthermore, examining heterogeneous task scheduling and prioritization could further enhance the algorithm’s efficiency and adaptability, particularly in environments with varying resource availability and task complexities. In addition, incorporating real-time data and feedback mechanisms could enable the algorithm to adapt more effectively to changing conditions, further optimizing performance.