Computation Offloading Method for Large-Scale Factory Access in Edge-Edge Collaboration Mode

Large-scale manufacturing enterprises have complex business processes in their production workshops, and the edge-edge collaborative business model cannot adapt to the traditional computation offloading methods, which leads to the problem of load imbalance. For this problem, a computation offloading algorithm based on edge-edge collaboration mode for large-scale factory access is proposed, called the edge and edge collaborative computation offloading (EECCO) algorithm. First, the method partitions the directed acyclic graphs (DAGs) on edge server and terminal industrial equipment, then updates the tasks using a synchronization policy based on set theory to improve the accuracy effectively, and finally achieves load balancing through processor allocation. The experimental results show that the method shortens the processing time by improving computational resource utilization and employs a heterogeneous distributed system to achieve high computing performance when processing large-scale task sets.


INTRODUCTION
Industrial cloud-edge collaboration is the trending networking paradigm involving seamless connectivity in heterogeneous industrial environments to aggregate distributed industrial devices into a shared resource pool and mobilizes these industrial devices for local manufacturing. In the

RELATED wORK
The computation offloading problems in the actual manufacturing workshop are systematic, dynamic, and random. The goal of such problems is to identify an approach that, at each decision stage, specifies how to allocate available resources among competing task requests to optimize the system's performance. The computation offloading requirements in the actual manufacturing workshop are closely related to the complex systems in the dynamic environment, making the traditional computation offloading method unable to adapt to the business model under the cloud manufacturing scenarios, leading to the problem of load imbalance Liu et al., 2022).
In recent years, artificial intelligence has been widely developed in manufacturing, transportation, finance, medicine, and other fields. However, with machine learning and deep learning technologies in key application fields such as cloud manufacturing and self-driving, researchers explore advanced edge-edge collaboration methods to ensure real-time, precision, and high interaction efficiency. Khan et al. (2020) designed an optimal computation offloading algorithm based on integer linear optimization that allows each mobile device to dynamically select execution modes: local execution, offloading execution, and deletion of tasks, thus achieving significant energy improvements. Yang et al. (2020) designed a lightweight linear programming algorithm based on an integrated architecture that can effectively reduce industrial equipment's energy consumption and cloud computing cost by transforming the offloading problem into an energy cost minimization problem to achieve full utilization of resources in edge computing. Chen et al. (2022) proposed a composite integer nonlinear programming algorithm, which aimed at the computational offloading problem in mobile edge computing systems, using convex optimization to derive the closed-form of the resource allocation solution, transforming it into an integer linear programming problem, Therefore, it has certain effectiveness and advantages in reducing delay and energy consumption. The above solution is often only suitable for solving integer linear programming problems, which require that all or part of the decision variables are assumed to be non-negative integers. However, in the practical industry, the solution is too idealistic, and the integer solution obtained by rounding is usually inaccurate. Because of the above algorithm's limitations, Liao et al. (2021) designed a distributed offloading strategy based on a binary coded genetic algorithm that splits the multi-user multi-server problem into two phases, server selection and computational offloading, for solving the problem to obtain an adaptive offloading decision. Hussein and Mousa (2020) proposed a meta-heuristic computing offloading algorithm based on the ant colony algorithm and the particle swarm algorithm. They considered the influence of load balancing on the offloading strategy, thus significantly reducing the response time of Internet of Things applications and improving the service quality. Topcuoglu et al. (2002) presented an algorithm named Critical-Path-on-a-Processor (CPOP) for workflow scheduling over heterogeneous processors with the bounded number.  proposed a computing offloading strategy for the gene-ant colony fusion algorithm, which makes up for the shortcomings of a single heuristic algorithm applied to computing offloading, improves the efficiency of the algorithm, and realizes the efficient use of edge-side base station resources. Due to the large number of parameters involved in the ant colony algorithm, the initial value is easy to be selected improperly. The use of a single ant colony algorithm tends to fall into local optimum and has low processing efficiency when dealing with large-scale combinatorial problems, followed by not solving continuous problems well. Most of the relevant parameters, such as pheromones, are selected by personal experience without sufficient theoretical basis. Due to its limitations, Cha et al. (2021) designed a virtual edge formation algorithm by predicting the inter-vehicle link duration to efficiently utilize the sporadic free computing resources around the smart vehicles. Laroui et al. (2021) proposed a service offloading technique in virtual mobile edge computing, which utilizes the computation offloading method of deep reinforcement learning to process the IoT network accessed by large-scale industrial equipment to obtain effective offloading decisions. Zhu et al. (2018) proposed the local-based partial reasonable task schedule construction (LoPRTC) to deal with a more complex multi-heterogeneous MEC server scenario shared by multiple mobile devices to ensure time sensitivity. However, the above 4 scheme is usually only applicable to the mobile edge calculation scene. In the complex industrial scene, industrial devices are more often fixedly installed in factories, and it needs to be discussed on a case-bycase basis. Given the above algorithms' limitations, Luo et al. (2021) proposed a new architecture that automatically offloads user tasks in mobile edge computing scenarios, which utilizes drones to cache data generated IoT devices dynamically and enables flexibility in computation offloading using blockchain technology. Wang et al. (2021) proposed a joint UAV-based heuristic power and quality-of-experience algorithm that jointly optimizes the UAV offload delay, transmit power, and UAV layout, thus ensuring the quality of experience for different priorities endpoints. Guo et al. (2018) proposed a game-theoretic greedy approximation offloading algorithm (GT-GAOA) to ensure better service quality and quality of experience and other diverse requirements in multi-user ultra-dense edge server scenarios.  proposed a dual auction-based common task offloading scheme and a Stackelberg game-based mining task offloading scheme to cope with the high computational overhead of the blockchain mining process, thereby achieving efficient resource allocation. However, the above scheme only considers how mobile IoT devices' tasks in industrial scenarios are offloaded to the edge-side servers, and there is no reasonable classification of computation offloading strategies within the edge-side server clusters. For the above algorithms' limitations, Zhu et al. (2021) proposed a computational offloading algorithm based on deep reinforcement learning to accelerate the learning process by adjusting the number of candidate positions, which utilizes minimizing the offloading cost to achieve faster convergence and dynamic adjustment during the learning process, thus significantly reducing the running time. Zhang et al. (2021) proposed a distributed task-loading algorithm based on multiple intelligences and load balancing, which aims to effectively reduce the response latency of all users and improve the robustness and scalability of the system by introducing load balancing coefficients. Mekala et al. (2022) proposed a two-step service offloading method based on deep reinforcement learning to reduce the cost of edge servers through a DRL-influenced resource and ensemble analysis model, thereby achieving high resource utilization and low energy consumption. However, as another important machine learning method, deep reinforcement learning emphasizes how to take corresponding actions based on the environment to maximize the expected benefits. In this mode, the input sample data feeds back to the model, but does not directly give correct conclusions like other methods. The feedback of deep reinforcement learning only detects the model, and the model will gradually make adjustments after receiving stimuli similar to rewards or punishments. Due to inefficient data sampling, complicated reward function design, difficulty reproducing operational results, and unavoidable local optima.
The EECCO algorithm used in this paper can effectively divide the DAG by calculating the task priority, calculation offload tolerance and DAG critical path in the edge-edge cooperative mode. This step can improve the processing of large-scale combination problems in complex industrial scenarios. Efficiency makes up for the lack of theoretical basis for the selection of pheromone by Liao, Hussein and others, and cannot solve the continuous problem well. It also solves the problem that Wang et al. did not reasonably classify the computing offloading strategy in the edge server cluster. Second, in the EECCO algorithm, this paper synchronizes multiple DAGs in the edge-edge cooperative mode. This step uses CGSC and EGSC to construct, schedule and maintain the DAG, thus realizing the task flow with the change of space. Dynamic execution makes up for the lack of flexibility in the computing offloading process by Cha, Laroui and others, which greatly improves the computing offloading efficiency in any complex industrial scenario. Reasonable allocation, the proposed IHEFT algorithm process is mainly composed of three stages: weight allocation stage, task priority allocation stage, and processor selection. Through the EECCO algorithm, the efficiency of task execution is effectively improved, and the capital cost of the enterprise is greatly reduced.

PROMBLEM DESCRIPTION
With the rapid development of industrial intelligence technology and the explosive growth of IoT terminal data, the analysis and processing of massive data increase industrial cloud platforms' operational burden. The emergence of edge-cloud collaborative computing makes full use of all computing resources on the entire link, bringing into play the advantages of different devices and providing strong technical support for the popularization and development of intelligent manufacturing.

DAG Task Description
According to the industrial IoT environment requirements, the edge-cloud collaboration mainly consists of the cloud component composed of the remote server cluster, the edge component composed of the edge server cluster, and the terminal component composed of the terminal cluster. Figure 1 depicts the working schematic under the edge-cloud collaboration computing architecture. In terms of specific operations, the cloud component is responsible for processing non-real-time, long-period data and completes the full lifecycle management of edge-side and end-side applications. The edge-side components significantly reduce the data transmission delay and meet the real-time data requirements of low-latency services. The terminal device is mainly responsible for data collection and real-time control of industrial equipment. The "End-Edge-Cloud" collaborative computing provides greater possibilities for precise decision-making and dynamic optimization of the industrial Internet.
It is assumed that there are n factories in which k k k n 1 2 , , , ¼ DAG tasks are run on the deployed terminal devices and q q q n 1 2 , ,..., DAG tasks are run on the edge server, respectively, and they cooperate with DAG tasks running on the cloud server to form the end-to-side cloud collaborative computing architecture. When the i th factory collaborates with the cloud server, the number of tasks in the cloud server cluster is a a a . Using the edge-cloud collaborative computing model, a task cannot be interrupted when it is not scheduled, and the task cannot be split into several smaller tasks. Figure 2 depicts a multi-DAG task graph in a cloud-side collaborative computing mode. There are p DAG task graphs in cloud components, and q q q n 1 2 , ,..., task graphs in edge-end components, which run in n edge servers deployed in factories.
For simplicity, Figure 3 depicts three DAG task diagrams under the cloud-side collaborative computing architecture. DAG1 under the cloud component includes three tasks, and DAG2 under the edge component includes five tasks. DAG3 includes 2 tasks, and 3 DAG task graphs include a total of 10 tasks. The circle represents the task node, the background color of the node in the cloud component, the edge part, and the terminal part are filled with green, white, and yellow respectively, the letter in the circle represents the number of the task node, and the task node number in the cloud part and the edge part is respectively used Uppercase and lowercase letters, node numbers are not case-sensitive, for example, the letter a in the circle represents task node t t t a a A , = . The solid edge with an arrow indicates the event edge, and the number on edge indicates the event calculation overhead between the two tasks; The number on the side represents the communication delay between the two tasks. Each DAG includes 1 entry task node and 1 exit task node. Considering the communication delay of different tasks, for example, the communication delay of cloud computing is about 100ms. The communication delay of small data centers is about 10~40ms, the communication delay of routers is about 5ms, and the communication delay between terminal devices is about 5ms. It is about 1~2ms (Martinelli, 2018). We use the time instruction to obtain the event calculation overhead between the two tasks.

Resources and Environment
Compute offloading can efficiently compute resources and speed up computation for resourceconstrained end devices or single edge-side servers running compute-intensive applications. The offloading algorithm is to find a set of offloading schemes that allow the application's processing speed to be efficiently increased based on the task's deadlines and resource requirements.  a network. On each physical machine, task execution and communication can be executed at the same time, the communication overhead between tasks allocated to virtual machines is 0, and task execution is non-preemptive.

Computing Offloading Target
DAG computation offloading is to offload the tasks in a single edge server or offload the terminal device calculations to the processor in the edge server for execution in the edge-side collaboration mode. The goal of computation offloading includes the following aspects: 1. The execution time of the entire task set on the processor makespan as small as possible; 2. Design a flat uninstall strategy for the edge server, instead of unified management through the cloud server; of all tasks in the entire task set from the arrival time AT i to the start execution time ST i should be as small as possible; 4. Slack is a measure of a computation offloading algorithm's robustness, reflecting the degree of uncertainty in the processing time of a task generated by a computation offloading algorithm (Yuan et al., 2022). The definition of Slack is shown in Equation 1. Where M represents the span of the DAG makespan, n represents the number of tasks, b level represents the length of the longest path from task t i to the exit, and t level represents the length of the longest path from the entry node to the task t i .

EDGw-EDGE COLLABORATIVE COMPUTATION OFFLOADING MODEL
In practical industrial application scenarios, tasks mainly consist of the static class known tasks and dynamic class unknown tasks. The priority of the static class of known tasks is determined at design time. Its priority varies with the dynamic class of unknown tasks. The tasks in this class satisfy the resource and latency requirements, i.e., the tasks can be successfully offloaded. The priority of the dynamic class of unknown tasks is determined during the runtime and changes continuously. There is some risk in the computational offloading strategy for this class of tasks. Both known tasks with static classes and unknown tasks with dynamic classes need to design corresponding computing offloading strategies to ensure efficient execution of tasks and full utilization of resources. Figure 5 shows the computing offload architecture in the edge-edge collaboration mode: As can be seen from Figure 5, the edge-edge collaboration mode includes three central bodies: cloud component, edge component, and terminal component. The cloud component is mainly responsible for updating and synchronizing information states, such as computing offloading and task execution. The edge end components mainly include internal computing offloading and inter-computing offloading. The efficient utilization of resources can be achieved by coordinating

DAG Segmentation in Edge-Edge Collaboration Mode
Currently, heterogeneous computing systems play an increasingly important role in dealing with complex industrial production problems. Heterogeneous computer clusters support the execution of parallel applications to achieve the goal of completing tasks quickly. The Improved Critical Path on a Processor (ICPOP) algorithm proposed in this paper comprises three stages: computing task priority, computing offload tolerance, and computing DAG critical path.

Task Priority
The computation offloading strategy in the edge-edge collaboration mode includes task offloading in edge components and task offloading in terminal components. Assume that an edge component δ is composed of m edge servers, and each edge server virtualizes k virtual machines. Each virtual machine runs τ DAG Edge , and each DAG Edge is composed of φ edge tasks. The end task will interact with ¢ t and DAG Terminal in the terminal part, and the adjacency matrix M corresponding to the DAG in the edge end part and the terminal part is shown in Formula 3: From the adjacency matrix M, the sum of the weight values of the incoming edges of each task node v i can be calculated and inserted into the set S, as shown in Formula 4: In the industrial application scenario, due to the particularity of the industrial equipment itself, taking the aircraft as an example, there are many gears, bearings, blades, and other key mechanical components in the aircraft's powertrain. The parameter rights are obtained by analyzing the collected data through machine learning. Value W, so that each type of task's importance can be determined in advance (Wang & Leelapatra, 2022). Assume that each virtual machine may have operational failures and thus cannot complete the task. Assuming that these failures occur independently with probability p, Formula 5 indicates that the benefits of task processing are maximized: Combining Formula 3 and Formula 4, the priority P i of each task node v i of the DAG in the edge end part and the terminal part is given, as shown in Formula 6: w represents the weight of each parameter. It can be seen from Formula 6 that when the value of P i Edge Terminal / is larger, the task node needs to be allocated more computing resources in time, thereby increasing the speed of task processing.

Task Offload Tolerance
Before performing task uninstallation, it is necessary to evaluate the currently available resources fully, the uninstall task's size, and the energy consumed by executing local applications. Assuming that the communication delay between edge components is q 1 ; the communication delay between edge servers in the edge component is q 2 ; the communication delay between virtual machines in the edge server is q 3 ; the communication delays of the edge component and the terminal component is o Edge server time time The same server refers to the edge task set t i Edge can only uninstall tasks on virtual machines in the same edge server, and the other server refers to the edge task set t i Edge that can be other parts of the same edge. Uninstall tasks in the edge server. Edge server refers to the terminal task set t i Terminal that can uninstall tasks to the virtual machine in the edge component for execution, and 0 means that the task set is recommended to be executed locally. For the dynamic unknown task t i ' , where the size of the input data of the task set is s, the average unit processing time of the data is c, and num is the number of tasks in the task set, then the internal task offloading tolerance of the dynamic unknown task is ¢ o As shown in Formula 9 and 10: In smart manufacturing production scenarios, industrial equipment is required to have the ability to self-organize and collaborate to meet flexible production. However, it also puts forward higher requirements for the flexible mobility and differentiated business processing capabilities of industrial equipment. Suppose that the residence time of a mobile device in a factory near the edge part is J , and its pre-stay time is J 0 , and m is the amount of data calculation. Then the inter-task offloading tolerance Where M1 is the size of the remaining resources of the edge-end component, M2 is the size of the remaining resources of the components adjacent to the edge-end component, T1 is the communication delay between the mobile device and the edge-end component, and T2 is the mobile device and the edge-end component. The communication delay of the adjacent components of the component, T1 and T2, will change with the mobile device's location.

DAG Critical Path
The earliest possible start time of a task j is represented by t j ES ( ) , and any task can only start after all its predecessor tasks are completed. The earliest completion time of the task t i is represented by t j EF ( ) . It represents the completion time that the task can reach according to the earliest start time, and its calculation Formula is: The latest start time of a task j is represented by t j LS ( ) , which represents the latest time that task j must start without affecting the completion of the entire task on schedule. The latest completion time of task j is represented by t j LF ( ) , which represents the completion time that the task can start at the latest time and its calculation formula is: Formula 11 is a recursive process from the starting point to the endpoint; Formula 12 is a systematic process from the endpoint to the starting point. This paper uses Formula 11 and Formula 12 to implement the critical path algorithm to find the critical path The DAG task's critical path is the longest path from entering the task to the exit node. Each task on this path provides the lowest cost for all critical paths. According to Formula 11, the edge end part and the DAG in the end part shown in Figure 3 are segmented in this paper. Figure 6 shows the segmentation diagram of the DAG in the edge-side collaboration mode. The path formed by the red arrow is the critical path of the DAG. The degree of each subgraph is {2,0,0,1}.

Multi-DAG Synchronization in Edge-To-Side Collaboration Mode
The edge-side collaboration mode adopted in this paper is responsible for the construction, scheduling, and maintenance of DAG through Cloud Global State Controller (CGSC) and Edge Global State Controller (EGSC). CGSC is responsible for cloud components and edge components; EGSC is responsible for tasks in edge components and terminal components. Figure 7 shows the multi-DAG synchronization method in the edge-side collaboration mode. Aiming at 5G+ industrial intelligence integration to broaden the application scenarios, the data-driven optimized closed loop is used as the key to real-time decision-making through EGSC; for the actual scenarios of high-speed mobile industrial production lines, through CGSC regards decision-driven optimization closed loop as the key to real-time data processing (Darwish, 2022).
Due to the high computational complexity of the algorithm, multiple task links, and extended business processes are some of the most complex problems in the industrial field. The task running status includes successful execution, execution blockage, and execution failure.
Since there is data interaction between the edge part and the terminal part that the EGSC is responsible for, its task execution state Where C Cloud represents the union of the latest task completed in each edge component in CGSC. DAG update is realized by data collaboration between tasks in C Cloud and B Edge of the edge end component so that the task flow can be dynamically executed as the space changes.

Task Allocation in the Edge-Edge Collaboration Mode
The Improved Heterogeneous Earliest Finish Time (IHEFT) algorithm process proposed in this paper comprises three stages: weight distribution stage, task priority distribution stage, and processor selection stage. Assume that R is used to represent the collection of processor resources: R CPUs GPUs FPGAs . GPUs are the most widely used accelerators, and FPGAs can provide better performance-to-power ratios. They are used in multiple applications, including high-performance computing. They deliver superior performance for a wide range of applications, including highperformance computing (Bobda et al., 2022;Mendes et al., 2022).
In the task priority assignment stage, its primary purpose is to solve the problem of establishing task priority lists in multi-source heterogeneous scenarios. In actual industrial scenarios, both edge tasks and terminal tasks have the characteristics of multiple task types, large scales, and strong associations. Therefore, the original weights of the edges between tasks cannot accurately reflect the priority of tasks in the edge-side collaboration mode. The task graph's priority in the edge-side collaboration mode needs to be determined according to the sum of the weights of the DAG merged graph's critical paths. According to the priority value, the DAG in the edge-side collaboration mode is sorted in descending order to form a task graph list, which is convenient for calculation and offloading in the later stage. The priority rank D k ( ) of the task graph D k in the edge-side collaboration mode is shown in Formula 19: The priority rank D k ( ) of the task graph D k in the edge-edge collaboration mode is equal to the sum of the weights of all event edges on the graph's critical path. In the subsequent computation offloading operation, the processor resources will be allocated first from the task graph with the higher priority in the task graph list. The corresponding path list is constructed according to the task graph list, and the priority rank p k ( ) of path p k is shown in Formula 20: Due to the high computational complexity of the algorithm, multiple task links, and extended business processes are some of the most complex problems in the industrial field. The task running status includes successful execution, execution blockage, and execution failure.
In the DAG segmentation graph in the edge-side collaboration mode, there are edge terminal After the segmentation operation and the resource collection type determination, the processor allocation stage starts to allocate resources to the task based on the resource collection type identified by each segmentation (Azhar et al., 2022;Yang & Deyu, 2017). The task set after DAG segmentation and synchronization selects and schedules processors according to the computation offloading strategy in the IHEFT algorithm.

EDGE-EDGE COLLABORATIVE COMPUTATION OFFLOADING ALGORITHM
The EECCO algorithm proposed in this paper is to make full use of the edge and terminal resources to achieve efficient task calculation by dividing the edge DAG task set and the terminal DAG task set through DAG; DAG synchronization; The processor allocates three steps to achieve. Among them, DAG synchronization reduces the time overhead caused by processing redundant tasks.

DAG Segmentation Algorithm
Assuming that the k-th factory under the edge-side collaboration mode is adopted, where the deployed edge server and terminal components perform N and M tasks, respectively, then the DAG segmentation algorithm is shown in Algorithm 1: The second line of the algorithm traverses the DAG in the edge part and the terminal part of obtaining the number of task nodes. The fourth line obtains the priority of each task node in the edge part and the terminal part. Lines 5-16 perform DAG in the segmentation process, tasks belonging to the critical path are placed in the critical task set, and tasks not belonging to the critical path are placed in the non-critical task set. The time complexity of running the algorithm in each factory is O(n), and the space complexity of the algorithm is O(1). As tasks increase, their advantages become more apparent.

DAG Synchronization Algorithm
We use set theory to synchronize the state information of the DAG segmentation graph obtained above. The tasks after synchronization are divided into two categories: critical task set and non-critical task set. The synchronization principle is shown in Algorithm 2: The second line of the algorithm traverses each DAG segmentation graph's task nodes and calculates each task's average computing performance on the processor. Lines 3-5 calculate the execution status of each DAG in the edge part, and the fourth line is based on each. Each task's execution status is synchronized with the corresponding strategy, and the 8th line performs a merge update operation for the DAG in the cloud component. The algorithm's time complexity is O(n), and the space complexity of the algorithm is O(1). As tasks increase, their advantages become more obvious.

Processor Allocation Algorithm
We use the IHEFT algorithm to perform processor allocation operations on the DAG segmentationsynchronization graph obtained above and sort the DAG task graph according to the critical path weight rank D k ( ) , to obtain the priority list of different tasks in the edge-side collaboration mode;  The tasks in each edge part are sorted by rank p k ( ) and the tasks are distributed to v processors.
The processor allocation algorithm is shown in Algorithm 3: The algorithm starts the function from the first line, the second line traverses each DAG splitsynchronization graph's task nodes and calculates each task's average computing performance on the processor. The third line calculates the sum of the weights of the edges of the critical path of the DAG merged graph. Lines 4-8 calculate the priority of the DAG segmentation-synchronization graph path. Line 9 is sorted in descending order according to the priority of the task graph. The 10th line is sorted according to the descending order of the path priority. The 11th line assigns the task to the best on the processor. Line 12 returns related information such as the mapping task's processor set, and line 13 ends the function. The algorithm's time complexity is O(1), and the space complexity of the algorithm is O(1). With the increase of tasks, its advantages become more evident.

Purpose
In order to verify the EECCO algorithm proposed in this paper, the performance of the proposed EECCO algorithm was compared with similar offloading algorithms Local-Based Partial Reasonable

13: end function
Task Schedule Construction (LoPRTC) and Game-theoretic Greedy Approximation Offloading Algorithm (GT-GAOA) under the same experimental conditions (Hussain et al., 2020;Xu et al., 2019), mainly comparing task span Makespan, task average waiting for time AWT and average Slack value.

Simulated Environment
Based on the simulator toolkit provided by SimGrid, a simulation environment for heterogeneous multi-core processors is built (Cornebize & Legrand, 2022). The computer used in the experiment is configured as Intel Core i5-7200U CPU @ 2.5GHz 2.7GHZ Dual-core processor, 8GB of RAM.

Analysis of Calculation and Offloading Process
The edge-edge collaboration mode is adopted. Assuming the tasks running in the edge server and terminal industrial equipment are shown in Figure 8, the following will analyze the segmentation, synchronization, and resource scheduling process of the multi-DAG task graph realized by the EECCO algorithm under the distributed and heterogeneous computing environment. Figure 8 shows the DAG task diagram in the edge-edge collaboration mode. The edge server performs 10 tasks; Terminal industrial equipment performs 1 task. Table 1 and Table 2 respectively show the calculation events of tasks in DAG1 on terminal industrial equipment and DAG2 on edge parts on different processors, in which the unit of communication cost and execution time is s.
According to the division principle, the DAG task division diagram can be obtained according to Algorithm 1, as shown in Figure 9; the processor allocation principle can be obtained according to algorithm 3 to obtain the processor set of the mapping task, as shown in

Analysis of Results
The time complexity of the EECCO algorithm is O(n), and the actual data collected on the site of a blower is taken as the analysis target. Compared with the traditional centralized traversal method, the EECCO algorithm has a good advantage. Figure 10 shows the impact of an increase in the number of edge servers on the computation time overhead. According to Equation 13, the DAG task segmentation graph's subgraph has a degree of {5,3,1}. In the edge-edge collaboration mode, edge tasks are allocated to 5 processors and terminal tasks to 1 processor. After the task set is unloaded by the EECCO algorithm, the corresponding relationship between the task and the processor is shown in Figure 12. Figure 11(b) shows that the same task set uses a naive CPOP algorithm as a computational offload strategy. Figure 12(a) and 12(b) respectively represent the offloading of tasks by LoPRTC and GT-GAOA algorithms for the same task set. As shown in Figure 11, the average task execution time of the EECCO algorithm is 42s, and that of the simple CPP algorithm is 57s. At the same time, it can be seen that the EECCO algorithm can reduce the number of processors when the task execution time is reduced. In Figure 11(a), the number of processors used at the edge is 6. In Figure 11(b), the number of edge processors used is 3.As can be seen from Figure 12, the average task execution time of the LoPRTC algorithm is 53s, and that of the GT-GAOA algorithm is 48s.In Figure 12(a), the number of edge end processors used is 6; In Figure  12(b), the number of edge processors used is 4. System processor utilization is an essential indicator of real-time system performance, representing the system's time characteristics and task status (Wu et al., 2022). Table 3 shows the average utilization rate of processor resources of the three algorithms. It can be seen from the figure that the EECCO algorithm has the highest average utilization rate of processors, which can give full play to the internal resources of the processor.
The three algorithms were used to schedule 10 DAG task graphs, respectively. Table 4 shows the comparison of three algorithms' Slack values in the case of 3-core processors. Three algorithms were adopted to schedule DAG tasks, and scheduling was carried out for the different number of DAG task models. The span Makespan values, average waiting time AWT and average Slack values of all tasks were obtained, as shown in Figure 13(a),13(b), and 13(c). According to the experimental data, both will increase correspondingly with the DAG number increase in terms of the span of task offloading and average Slack. In general, the EECCO algorithm's performance is the best, followed by the LoPRTC and GT-GAOA algorithm, and the CPOP algorithm's performance is the worst. The EECCO algorithm reduces task offloading span by 26.6% on average compared with the CPOP algorithm from the experimental data. EECCO algorithm is 21.4% lower than the LoPRTC algorithm on average. Compared with GT-GAOA, the EECCO algorithm reduces by 10.91% on average. In terms of average Slack, the EECCO algorithm is 23.5% lower than the CPOP algorithm. EECCO algorithm is 11.13% lower than the LOPRTC algorithm on average. The EECCO algorithm reduces by 10.90% on average compared with the GT-GAOA algorithm. The average waiting time of the EECCO algorithm is reduced by 58.9% compared with that of the CPOP algorithm. EECCO algorithm is 57.1% lower than the LoPRTC algorithm on average. EECCO algorithm is 65.7% lower than the GT-GAOA algorithm on average. The offloading algorithm's fairness indicates the reliability of multiple DAG task offloading algorithms and is an important indicator that reflects whether the algorithm can reasonably handle tasks with different priority levels. Figure 14 shows the degree of fairness of the EECCO, CPOP, LoPRTC, and GT-GAOA algorithms.
The EECCO algorithm is superior to CPOP and GT-GAOA algorithm in terms of average task waiting time and average Slack value through the above experimental analysis. Simultaneously, in terms of algorithm fairness, the EECCO algorithm has high fairness and maintains an excellent steady-state with the increase of DAG number.

DISCUSSION
With the continuous development of network information technology, the new industrial model led by smart manufacturing has started to be widely used. The existing computing offloading methods tend to lead to congestion caused by heavy load on an edge server. Meanwhile, the existing studies assume that each task is independent of each other, without considering the possible dependency between tasks. As a result, a large amount of idle computing time is not fully utilized on the computing nodes, which wastes the computing resources of the nodes and increases the task execution delay. In this paper, a computation offloading method for large-scale factory access in edge-edge collaboration mode is given for cloud manufacturing scenarios. The computation offloading problem in complex scenarios is solved by three steps, task graph partitioning, synchronization, and processor scheduling. Simulation results show that the EECCO algorithm proposed in this paper can reduce the time overhead of processing complex tasks compared to other offloading algorithms and enable an edgeedge collaborative approach to offload tasks to the appropriate processor in an overall increase in the speed of task processing. Associated tasks can be processed more efficiently in the case of resource-constrained large-scale edge-side servers. It solves the problem of difficult unloading due to the difference of actual scenarios and the high response delay caused by the increase of terminal industrial equipment.

CONCLUSION
China has now become an industrial power. Most of the methods used in manufacturing workshops are to provide dedicated production lines or rigid assembly lines. This solidified production method can cope with a certain amount of production, but in the face of large-scale production. For the production demand of the manufacturing workshop, the traditional production method is far from enough. Therefore, the method of computing offloading of large-scale factory access in the edgeedge collaborative mode in this paper is based on the fact that the demand of the manufacturing factory is greater than the actual production volume. For the manufacturing industry of large-scale manufacturing production mode, the problem of resource layout and allocation is indispensable. In order to solve the problem of collaborative operation between edge servers deployed in large-scale manufacturing workshops, a side-by-side collaborative computing architecture is proposed. The task scheduling method of large-scale factory access realizes the effective allocation of resources. In fact, the machine tools and equipment seen in ordinary workshops work in a discrete form, but in order to combine the needs of the task, this simple configuration cannot be realized. The EECCO algorithm divides the equipment and equipment into more levels. It has realized multi-level resource allocation, and changed the discrete working state into a multi-dynamic process working state. At present, many large-scale manufacturing workshops have an increasing demand for production flexibility, which is basically through the production process. Various methods to increase the flexibility of mass manufacturing production, such as the cluster layout of traditional manufacturing workshops, etc. Considering the existence of specific requirements, unexpected events during equipment operation, and the impact of unknown users on the system, the next step will be to improve and refine the requirements analysis model, evaluate the effectiveness of the scheme in this paper after obtaining actual data, and further improve the performance of the algorithm. In the future, the task offloading scheme for multi-intelligence collaborative operation will be studied in depth to complement the work in this paper. At the same time, the next stage can start to carry out the technical landing, to realize the computing unloading platform. At present, due to the limitations of hardware and software and other factors, it is difficult to achieve the implementation of technology.

ACKNOwLEDGMENT
This work was supported in part by the National

CONFLICTS OF INTEREST
The authors declare no conflict of interest.