Edge Time Sharing across Clusters via Dynamic Task Migration

Abstract

Edge device task management is provided. When a request is received to execute a higher priority subtask of a second plurality of subtasks corresponding to a second task while a first task including a first plurality of subtasks is executing on a first cluster of edge devices, it is determined whether a subtask cancellation and migration plan exists. In response to determining that a subtask cancellation and migration plan exists, a lower priority subtask of the first plurality of subtasks is canceled from a designated edge device of the first cluster of edge devices based on the subtask cancellation and migration plan. The lower priority subtask is migrated to another edge device for execution based on the subtask cancellation and migration plan. A higher priority subtask of the second plurality of subtasks is sent to a designated edge device of the first cluster of edge devices for execution.

Description

[Technical Field]

[0001] The present disclosure relates generally to edge computing, and more particularly to time sharing across a cluster of edge devices using dynamic task migration based on task attributes. [Background technology]

[0002] Edge computing is a distributed computing framework that brings applications closer to data sources, such as Internet of Things devices, local edge servers, and the like. This proximity to data at its source can provide benefits such as improved response times and increased bandwidth availability. Summary of the Invention

[0003] According to one illustrative embodiment, a computer-implemented method for edge device task management is provided. When a request is received to execute a higher-priority subtask of a second plurality of subtasks corresponding to a second task while a first task including a first plurality of subtasks is running on a first cluster of edge devices in the edge computing framework, a determination is made as to whether a subtask cancellation and migration plan exists for the edge computing framework. In response to determining that a subtask cancellation and migration plan exists for the edge computing framework, a lower-priority subtask of the first plurality of subtasks is canceled from a designated edge device of the first cluster of edge devices designated to execute the higher-priority subtask of the second plurality of subtasks based on the subtask cancellation and migration plan. The lower-priority subtask of the first plurality of subtasks canceled from the designated edge device of the first cluster of edge devices is migrated for execution to another edge device not included in the first cluster of edge devices based on the subtask cancellation and migration plan. A higher priority subtask of the second plurality of subtasks is sent to a designated edge device of the first cluster of edge devices for execution. According to other illustrative embodiments, a computer system and computer program product for edge device task management are provided. [Brief explanation of the drawings]

[0004] [Figure 1] 1 is a pictorial representation of a network of data processing systems in which illustrative embodiments may be implemented; [Figure 2] FIG. 1 is a diagram of a data processing system in which illustrative embodiments may be implemented. [Figure 3] FIG. 1 illustrates a cloud computing environment in which illustrative embodiments may be implemented. [Figure 4] FIG. 1 illustrates an example of abstraction layers in a cloud computing environment in accordance with an illustrative embodiment. [Figure 5] FIG. 1 illustrates an example of a task management system in accordance with an illustrative embodiment. [Figure 6] FIG. 10 illustrates an example of a first task having subtasks in accordance with an illustrative embodiment. [Figure 7] FIG. 10 illustrates an example of a selection edge device cluster process for a first task, according to an illustrative embodiment. [Figure 8] FIG. 10 illustrates an example of a passing subtask result and task status process, according to an illustrative embodiment. [Figure 9] FIG. 10 is a diagram illustrating an example of a second task having subtasks, in accordance with an illustrative embodiment. [Figure 10] FIG. 10 illustrates an example of an edge device attribute table, according to an illustrative embodiment. [Figure 11] FIG. 10 illustrates an example of a subtask assignment process, in accordance with an illustrative embodiment. [Figure 12] FIG. 10 illustrates an example process for sending subtasks to an edge device, according to an illustrative embodiment. [Figure 13] FIG. 10 illustrates an example of a pending planning process, in accordance with an illustrative embodiment. [Figure 14] FIG. 10 illustrates an example of a cancellation and movement planning process, in accordance with an illustrative embodiment. [Figure 15A] 10 is a flowchart illustrating a process for edge time sharing across clusters via dynamic task migration, in accordance with an illustrative embodiment. [Figure 15B] 10 is a flowchart illustrating a process for edge time sharing across clusters via dynamic task migration, in accordance with an illustrative embodiment. DETAILED DESCRIPTION OF THE INVENTION

[0005] The present invention may be a system, method, or computer program product, or a combination thereof, at any possible level of technical detail of integration. The computer program product may include a computer-readable storage medium (or media) having computer-readable program instructions for causing a processor to carry out aspects of the present invention.

[0006] A computer-readable storage medium can be a tangible device capable of retaining and storing instructions for use by an instruction execution device. A computer-readable storage medium may be, for example, but is not limited to, an electronic storage device, a magnetic storage device, an optical storage device, an electromagnetic storage device, a semiconductor storage device, or any suitable combination of the foregoing. A non-exhaustive list of more specific examples of computer-readable storage media includes portable computer diskettes, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), static random access memory (SRAM), portable compact disk read-only memory (CD-ROM), digital versatile disks (DVDs), memory sticks, floppy disks, mechanically encoded devices such as punch cards or ridge-in-groove structures with instructions recorded on them, and any suitable combination of the foregoing. Computer-readable storage media, as used herein, should not be construed as being signals that are transitory in nature, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through a waveguide or other transmission medium (e.g., light pulses passing through fiber optic cable), or electrical signals transmitted through wires.

[0007] The computer-readable program instructions described herein can be downloaded from a computer-readable storage medium to each computing / processing device or to an external computer or external storage device over a network, such as the Internet, a local area network, a wide area network, or a wireless network, or a combination thereof. The network may comprise copper transmission cables, optical transmission fibers, wireless transmissions, routers, firewalls, switches, gateway computers, or edge servers, or a combination thereof. A network adapter card or network interface in each computing / processing device receives the computer-readable program instructions from the network and forwards the computer-readable program instructions for storage in a computer-readable storage medium in the respective computing / processing device.

[0008] Computer-readable program instructions for carrying out operations of the present invention may be either source or object code written in any combination of one or more programming languages, including assembler instructions, instruction set architecture (ISA) instructions, machine language instructions, machine-dependent instructions, microcode, firmware instructions, state setting data, configuration data for integrated circuit devices, or object-oriented programming languages ​​such as Smalltalk®, C++, or the like, and procedural programming languages ​​such as the "C" programming language or similar programming languages. The computer-readable program instructions may execute entirely on the user's computer, partially on the user's computer, as a stand-alone software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In the latter scenario, the remote computer may be connected to the user's computer through any type of network, including a local area network (LAN) or a wide area network (WAN), or the connection may be to an external computer (e.g., through the Internet using an Internet Service Provider). In some embodiments, electronic circuitry devices, including, for example, programmable logic devices, field programmable gate arrays (FPGAs), or programmable logic arrays (PLAs), can execute computer readable program instructions by utilizing state information of the computer readable program instructions to individualize the electronic circuitry devices to implement aspects of the present invention.

[0009] Aspects of the present invention are described herein with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. It will be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer-readable program instructions.

[0010] These computer-readable program instructions may be provided to a computer processor or other programmable data processing apparatus to produce a machine, the instructions of which execute by the computer processor or other programmable data processing apparatus to produce means for performing the functions / acts specified in one or more blocks of the flowcharts and / or block diagrams. These computer-readable program instructions may also be stored on a computer-readable storage medium such that the computer-readable storage medium comprises an article of manufacture including instructions for performing aspects of the functions / acts specified in one or more blocks of the flowcharts and / or block diagrams, and may instruct a computer, programmable data processing apparatus, or other device, or combination thereof, to function in a particular manner.

[0011] The computer-readable program instructions may also be loaded into a computer, other programmable data processing apparatus, or other device to cause the computer, other programmable apparatus, or other device to perform a series of operational steps such that the instructions executing on the computer, other programmable apparatus, or other device produce a computer-executed process to perform the functions / acts specified in one or more blocks of the flowcharts and / or block diagrams.

[0012] The flowcharts and block diagrams in the figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of the present invention. In this regard, each block in a flowchart or block diagram may represent a module, segment, or portion of instructions, including one or more executable instructions for implementing a specified logical function. In some alternative implementations, the functions noted in the blocks may occur out of the order noted in the figures. For example, two blocks shown in succession may actually be implemented as a single step that is executed concurrently, substantially concurrently, partially, or fully overlapping in time, or the blocks may sometimes be executed in the reverse order, depending on the functionality involved. It should also be noted that each block in the block diagrams and / or flowcharts, and combinations of blocks in the block diagrams and / or flowcharts, can be implemented by a dedicated hardware-based system that performs the specified functions or acts or executes a combination of dedicated hardware and computer instructions.

[0013] Referring now to the figures, and in particular to Figures 1-5, diagrams of data processing environments are provided in which illustrative embodiments may be implemented. It should be understood that Figures 1-5 are intended as examples only and are not intended to assert or imply any limitation with regard to the environments in which different embodiments may be implemented. Many modifications to the depicted environments may be made.

[0014] 1 depicts a diagrammatic representation of a network of data processing systems in which illustrative embodiments may be implemented. Network data processing system 100 is a network of computers, data processing systems, and other devices in which illustrative embodiments may be implemented. Network data processing system 100 includes network 102, which is the medium used to provide communications links between the computers, data processing systems, and other devices connected together within network data processing system 100. Network 102 may include connections such as, for example, wired communications links, wireless communications links, fiber optic cables, and the like.

[0015] In the depicted example, server 104 and server 106 connect to network 102, along with storage 108 and edge device 110. Server 104 and server 106 are server computers with high-speed connections to network 102. Additionally, server 104 and server 106 are application programming interface servers that provide task management services to edge device 110. For example, server 104 and server 106 can manage the performance of tasks by edge device 110 using dynamic task migration across a cluster of edge devices based on attributes of the subtasks that comprise the task. A task may be any type of task capable of being performed by edge device 110. Edge device 110 represents multiple different types of edge devices in an edge computing framework and may include, for example, network computers, network devices, smart devices, and the like. Also, note that server 104 and server 106 may each represent multiple computing nodes in one or more cloud environments.

[0016] Client 112, client 114, and client 116 also connect to network 102. Clients 112, 114, and 116 are clients of server 104 and server 106. In this example, clients 112, 114, and 116 are shown as desktop or personal computers with wired communication links to network 102. Nevertheless, it should be noted that clients 112, 114, and 116 are merely examples and may represent other types of data processing systems, such as laptop computers, handheld computers, mobile phones, gaming devices, and the like, with wired or wireless communication links to network 102. Users of clients 112, 114, and 116 can utilize clients 112, 114, and 116 to request performance of different types of tasks by server 104 and server 106.

[0017] Storage 108 is a network storage device capable of storing any type of data in a structured or unstructured format. Furthermore, storage 108 may represent multiple network storage devices comprising a set of data stores. Furthermore, storage 108 may store identifiers and network addresses of multiple servers, identifiers and network addresses of multiple edge devices, edge device cluster metadata, task identifiers, task attributes, and the like. Furthermore, storage 108 may store other types of data, such as authentication or credential data, which may include, for example, usernames, passwords, and biometric data associated with system administrators and users.

[0018] Additionally, it should be noted that network data processing system 100 may include any number of additional servers, edge devices, clients, storage devices, and other devices not shown. The program code within network data processing system 100 may be stored on a computer-readable storage medium and downloaded to a computer or other data processing device for use. For example, the program code may be stored on a computer-readable storage medium of server 104 and downloaded to edge device 110 via network 102 for use by edge device 110.

[0019] In the depicted example, network data processing system 100 may be implemented as a number of different types of communication networks, such as, for example, the Internet, an intranet, a wide area network, a metropolitan area network, a local area network, a telecommunications network, or any combination thereof. Figure 1 is intended as an example only and not as architectural limitations for different illustrative embodiments.

[0020] As used herein, when used in reference to items, "some" means one or more of the items. For example, "several different types of communication networks" is one or more different types of communication networks. Similarly, "set of," when used in reference to items, means one or more of the items.

[0021] Furthermore, the term "at least one of," when used in conjunction with a list of items, means that one or more different combinations of the listed items may be used, and that only one of each item in the list may be required. In other words, "at least one of" means that any combination of items and any number of items may be used from the list, but not all of the items in the list are required. An item may be a specific object, thing, or category.

[0022] For example, without limitation, "at least one of item A, item B, or item C" may include item A, item A and item B, or item B. This example may also include item A, item B, and item C, or item B and item C. Of course, any combination of these items may be present. In some illustrative examples, "at least one of" may be, for example, without limitation, two of item A, one of item B, and ten of item C, or four of item B and seven of item C, or other suitable combinations.

[0023] Referring now to Figure 2, a diagram of a data processing system according to an illustrative embodiment is depicted. Data processing system 200 is an example of a computer, such as server 104 of Figure 1, in which computer-readable program code or instructions that execute the task management process of the illustrative embodiment may be located. In this example, data processing system 200 includes a communications fabric 202 that provides communications between a processor unit 204, memory 206, persistent storage 208, a communications unit 210, an input / output (I / O) unit 212, and a display 214.

[0024] The processor unit 204 functions to execute instructions for software applications and programs that may be loaded into the memory 206. The processor unit 204 may be a set of one or more hardware processor devices or may be a multi-core processor, depending on the particular implementation.

[0025] Memory 206 and persistent storage 208 are examples of storage devices 216. As used herein, a computer-readable storage device or computer-readable storage medium is any piece of hardware capable of temporarily or permanently storing information, such as, without limitation, data, computer-readable program code in a functional form, or other suitable information, or a combination thereof. Furthermore, computer-readable storage device or computer-readable storage medium excludes propagating media, such as transitory signals. Memory 206, in these examples, may be, for example, random access memory or any other suitable volatile or non-volatile storage device, such as flash memory. Persistent storage 208 may take various forms, depending on the particular implementation. For example, persistent storage 208 may contain one or more devices. For example, persistent storage 208 may be a disk drive, a solid-state drive, a rewritable optical disk, a rewritable magnetic tape, or some combination of the above. The media used by persistent storage 208 may be removable. For example, a removable hard drive may be used for persistent storage 208.

[0026] Communications unit 210 provides for communication with other computers, data processing systems, and devices over a network, such as network 102 in FIG. 1 in this example. Communications unit 210 may provide for communication through the use of both physical and wireless communications links. The physical communications links may utilize, for example, wires, cables, universal serial buses, or any other physical technology to establish a physical communications link for data processing system 200. The wireless communications links may utilize, for example, short wave, radio frequency, very high frequency, microwave, Wireless Fidelity (Wi-Fi), Bluetooth® technology, Global System for Mobile Communications (GSM), Code Division Multiple Access (CDMA), second generation (2G), third generation (3G), fourth generation (4G), 4G Long Term Evolution (LTE), LTE Advanced, fifth generation (5G), or any other wireless communications technology or standard to establish a wireless communications link for data processing system 200.

[0027] Input / output unit 212 allows for the input and output of data with other devices that may be connected to data processing system 200. For example, input / output unit 212 may provide a connection for user input through a keypad, keyboard, mouse, microphone, or some other suitable input device, or combination thereof. Display 214 provides a mechanism for displaying information to a user and may include, for example, touch screen functionality to allow a user to make on-screen selections through a user interface or input data.

[0028] Instructions for the operating system, applications, and / or programs may be located in storage device 216, which is in communication with processor unit 204 through communications fabric 202. In this illustrative example, the instructions are in functional form on persistent storage 208. These instructions may be loaded into memory 206 for execution by processor unit 204. The processes of the different embodiments may be performed by processor unit 204 using computer-implemented instructions, which may be located in a memory, such as memory 206. These program instructions are referred to as program code, computer-usable program code, or computer-readable program code, and may be read and executed by the processor of processor unit 204. The program instructions may be contained in different physical computer-readable storage devices, such as memory 206 or persistent storage 208, in different embodiments.

[0029] Program code 218 may be located in a functional form on selectively removable computer readable media 220 and loaded onto or transferred to data processing system 200 for execution by processor unit 204. Program code 218 and computer readable media 220 form computer program product 222. In one example, computer readable media 220 may be computer readable storage medium 224 or computer readable signal medium 226.

[0030] In these illustrative examples, computer-readable storage medium 224 is not a medium for propagating or transmitting program code 218, but rather a physical or tangible storage device used to store program code 218. Computer-readable storage medium 224 may include, for example, an optical or magnetic disk inserted into or placed into a drive or other device that is part of persistent storage 208 for transfer to a storage device such as a hard drive that is part of persistent storage 208. Computer-readable storage medium 224 may also be a form of persistent storage, such as a hard drive, thumb drive, or flash memory connected to data processing system 200.

[0031] Alternatively, program code 218 may be transferred to data processing system 200 using computer readable signal media 226. Computer readable signal media 226 may be, for example, a propagated data signal embodied with program code 218. For example, computer readable signal media 226 may be an electromagnetic signal, an optical signal, or any other suitable type of signal. These signals may be transmitted over communications links, such as wireless communications links, fiber optic cable, coaxial cable, a wire, or any other suitable type of communications link.

[0032] Additionally, as used herein, "computer-readable medium 220" may be singular or plural. For example, program code 218 may reside on computer-readable medium 220 in a single storage device or system. In another example, program code 218 may reside on computer-readable medium 220 distributed among multiple data processing systems. In other words, some instructions in program code 218 may reside in one data processing system, while other instructions in program code 218 may reside in one or more other data processing systems. For example, part of program code 218 may reside on computer-readable medium 220 of a server computer, while another part of program code 218 may reside on computer-readable medium 220 within a set of client computers.

[0033] The different components illustrated for data processing system 200 are not intended to provide architectural limitations to the manner in which different embodiments may be implemented. In some illustrative examples, one or more of the components may be incorporated into or otherwise form a part of another component. For example, in some illustrative examples, memory 206, or portions thereof, may be incorporated within processor unit 204. Different illustrative embodiments may be implemented in a data processing system including components other than or in place of those illustrated for data processing system 200. Other components illustrated in FIG. 2 may vary from the illustrated illustrative example. Different embodiments may be implemented using any hardware device or system capable of executing program code 218.

[0034] In another example, a bus system may be used to implement communications fabric 202 and may be comprised of one or more buses, such as a system bus or an input / output bus. Of course, the bus system may be implemented using any suitable type of architecture that provides for a transfer of data between different components or devices attached to the bus system.

[0035] While this disclosure includes a detailed description of cloud computing, it is understood that implementation of the teachings recited herein is not limited to a cloud computing environment. Rather, the illustrative embodiments may be implemented in conjunction with any other type of computing environment, now known or later developed. Cloud computing is a service delivery model that enables convenient, on-demand network access to a shared pool of configurable computing resources, such as networks, network bandwidth, servers, processing, memory, storage, applications, virtual machines, and services, that can be rapidly provisioned and published with minimal administrative effort or service provider interaction. This cloud model may include at least five characteristics, at least three service models, and at least four deployment models.

[0036] Characteristics may include, for example, on-demand self-service, broad network access, resource pooling, rapid elasticity, and measured service. On-demand self-service allows cloud consumers to automatically and unilaterally provision computing capacity, such as server time and network storage, as needed without human interaction with the service provider. Broad network access provides capabilities available over the network and accessed through standard mechanisms that facilitate use by heterogeneous thin or thick client platforms, such as mobile phones, laptops, and personal digital assistants. Resource pooling enables providers to pool their computing resources to serve multiple consumers using a multi-tenant model, with different physical and virtual resources dynamically allocated and reallocated according to demand. Location independence is meaningful in that consumers typically have no control or knowledge of the exact location of the resources provided, but may be able to identify the location at a higher level of abstraction, such as a country, state, or data center. Rapid elasticity provides capacity that can be rapidly elastically provisioned, sometimes automatically, to quickly scale out, and rapidly exposed to quickly scale in. To consumers, the capacity available for provisioning often appears unlimited and can be purchased at any time in any amount. Measured services enable cloud systems to automatically control and optimize resource usage by leveraging metering capabilities at several levels of abstraction appropriate to the type of service, for example, storage, processing, bandwidth, and active user accounts. Resource utilization can be monitored, controlled, and reported, providing transparency to both providers and consumers of the services being used.

[0037] Service models can include, for example, Software as a Service (SaaS), Platform as a Service (PaaS), and Infrastructure as a Service (IaaS). Software as a service is the ability offered to consumers to use provider applications running on a cloud infrastructure. The applications are accessible from a variety of client devices through a thin-client interface, such as a web browser (e.g., web-based email). Consumers do not manage or control the underlying cloud infrastructure, including the network, servers, operating systems, storage, or possibly individual application capabilities, with the possible exception of limited user-specific application configuration settings. Platform as a service is the ability offered to consumers to deploy consumer-created or acquired applications, created using programming languages ​​and tools supported by the provider, onto the cloud infrastructure. Consumers do not manage or control the underlying cloud infrastructure, including the network, servers, operating systems, or storage, but they do have control over the deployed applications and, in some cases, the configuration of the environment hosting the applications. Infrastructure as a Service is the capability offered to customers to provide processing, storage, networking, and other basic computing resources on which they can deploy and run any software, which may include operating systems and applications. Customers do not manage or control the underlying cloud infrastructure, but they do have control over the operating systems, storage, deployed applications, and in some cases, limited control over the selection of networking components, such as host firewalls.

[0038] Deployment models can include, for example, private cloud, community cloud, public cloud, and hybrid cloud. A private cloud is cloud infrastructure operated solely for an organization. A private cloud can be managed by an organization or a third party and can exist on-premises or off-premises. A community cloud is cloud infrastructure shared by several organizations to support a unique community with shared concerns, such as mission, security requirements, policies, and compliance considerations. A community cloud can be managed by an organization or a third party and can exist on-premises or off-premises. A public cloud is cloud infrastructure made available to the general public or large industry groups and is owned by an organization that sells cloud services. A hybrid cloud is cloud infrastructure consisting of two or more clouds, such as private, community, and public clouds, that remain unique entities but are joined together by standard or proprietary technologies that enable data and application portability, such as cloud bursting for load balancing between clouds.

[0039] A cloud computing environment is service-oriented, with a focus on statelessness, loose coupling, modularity, and semantic interoperability. At the heart of cloud computing is an infrastructure that comprises a network of interconnected nodes.

[0040] Referring now to FIG. 3, a diagram illustrating a cloud computing environment in which illustrative embodiments may be implemented is depicted. In this illustrative example, cloud computing environment 300 includes a set of one or more cloud computing nodes 310 with which local computing devices used by cloud users, such as, for example, personal digital assistant or smartphone 320A, desktop computer 320B, laptop computer 320C, or automobile computer system 320N, or combinations thereof, may communicate. Cloud computing node 310 may be, for example, server 104 and server 106 of FIG. 1. Local computing devices 320A-320N may be, for example, edge device 110 and clients 112-116 of FIG. 1.

[0041] Cloud computing nodes 310 may communicate with each other and may be physically or virtually grouped into one or more networks, such as private, community, public, or hybrid clouds, or combinations thereof, as described above. This allows cloud computing environment 300 to provide infrastructure, platform, and / or software as a service without requiring cloud consumers to maintain resources on local computing devices, such as local computing devices 320A-320N. The types of local computing devices 320A-320N are intended to be illustrative only, and it is understood that cloud computing nodes 310 and cloud computing environment 300 can communicate with any type of computerized device over any type of network and / or network-addressable connection, for example, using a web browser.

[0042] Referring now to Figure 4, a diagram illustrating abstraction model layers according to an illustrative embodiment is depicted. The set of functional abstraction layers illustrated in this illustrative example may be provided by a cloud computing environment, such as cloud computing environment 300 of Figure 3. It should be understood in advance that the components, layers, and functions illustrated in Figure 4 are intended to be merely illustrative, and embodiments of the present invention are not limited thereto. As depicted, the following layers and corresponding functions are provided:

[0043] Cloud computing environment abstraction layer 400 includes hardware and software layer 402, virtualization layer 404, management layer 406, and workload layer 408. Hardware and software layer 402 includes the hardware and software components of the cloud computing environment. The hardware components may include, for example, mainframe 410, reduced instruction set computer (RISC) architecture-based servers 412, servers 414, blade servers 416, storage devices 418, and network and networking components 420. In some demonstrative embodiments, the software components may include, for example, network application server software 422 and database software 424.

[0044] The virtualization layer 404 provides an abstraction layer within which instances of virtual entities such as virtual servers 426, virtual storage 428, virtual networks including virtual private networks 430, virtual applications and operating systems 432, and virtual clients 434 may be provided.

[0045] In one example, management layer 406 may provide the functions described below. Resource provisioning 436 dynamically procures computing and other resources utilized to perform tasks within the cloud computing environment. Metering and pricing 438 tracks costs as resources are utilized within the cloud computing environment and bills or invoices for the utilization of these resources. In one example, these resources may include application software licenses. Security validates cloud users and tasks and protects data and other resources. User portal 440 provides users and system administrators with access to the cloud computing environment. Service level management 442 allocates and manages cloud computing resources to meet required service levels. Service level agreement (SLA) planning and fulfillment 444 pre-provisions and procures cloud computing resources to anticipate future requirements according to SLAs.

[0046] The workload tier 408 provides examples of functions for which a cloud computing environment may be utilized. Example workloads and functions may be provided by the workload tier 408 and may include mapping and navigation 446, software development and lifecycle management 448, virtual classroom instruction delivery 450, data analytics processing 452, transaction processing 454, and edge device task management 456.

[0047] The increasing number of Internet of Things devices at the edge of the network is generating large amounts of data to be computed in data centers, pushing network bandwidth requirements to their limits. Despite improvements in network technology, data centers are unable to guarantee acceptable transfer speeds and response times, which can be critical requirements for many applications. Furthermore, Internet of Things devices at the edge are constantly consuming data coming from the cloud, forcing entities such as enterprises, companies, institutions, agencies, and the like to build content delivery networks to decentralize data and service delivery by leveraging physical proximity to end users.

[0048] Edge computing moves computation from data centers to the edge of the network, leveraging Internet of Things devices, such as smart devices (e.g., smart phones, smart TVs, smart watches, smart glasses, smart vehicles, smart appliances, smart sensors, and the like), mobile phones, network gateways and devices, and the like, to perform tasks and provide services instead of the cloud. Moving tasks and services to the edge can provide better response times and bandwidth availability.

[0049] With the development and proliferation of cloud computing, the Internet of Things, and business models, edge computing has become the next emerging technology for providing greater computing power. Edge computing, assisted by artificial intelligence edge controllers, is now being widely adopted in many industries, including dedicated programming and control of edge devices. An increasing number of different types of tasks or workloads will run on these edge devices. Considering the cost factor, some edge devices are expensive, have limited functionality, and can be shared among different tasks. Time sharing of edge devices improves resource utilization and reduces costs. Time sharing is the allocation of computing resources among multiple tasks.

[0050] On a single edge computing framework including multiple edge devices, various different tasks may run simultaneously (i.e., at the same time). Furthermore, collaboration, interaction, or conflicts (e.g., task preemption on the same edge device) may exist between these different types of tasks. Furthermore, the priority and resource consumption of each task may vary. An edge computing platform must ensure that important tasks are appropriately prioritized and run smoothly while appropriately scheduling resources to improve utilization of the edge computing platform. Under limited resource conditions, illustrative embodiments enable moderate scheduling and utilization of edge devices to ensure that lower-priority tasks continue to run, minimizing the potential impact on task execution. In other words, illustrative embodiments enable edge device time sharing across a cluster of edge devices via dynamic task migration.

[0051] Thus, illustrative embodiments improve the capabilities of the edge layer by providing dynamic task migration based on attributes, such as priority and tags, corresponding to each task. Furthermore, illustrative embodiments increase the efficiency of the entire edge layer through a novel dynamic task migration process. Moreover, illustrative embodiments enable faster response times for edge device task execution, improving the user experience.

[0052] Accordingly, illustrative embodiments provide one or more technical solutions that overcome technical challenges associated with moving tasks across a cluster of edge devices. As a result, these one or more technical solutions provide technical effects and practical applications in the field of edge computing by using dynamic task migration based on task attributes to improve task performance and reduce response times.

[0053] Referring now to Figure 5, a diagram illustrating an example task management system is depicted, according to an illustrative embodiment. Task management system 500 may be implemented in a network of data processing systems, such as network data processing system 100 of Figure 1, or in a cloud computing environment, such as cloud computing environment 300 of Figure 3. Task management system 500 is a system of hardware and software components for time sharing across a cluster of edge devices using dynamic task migration based on task attributes.

[0054] In this example, the task management system 500 includes a cloud tier 502, an edge tier 504, and edge devices 506. The cloud tier 502 may be, for example, the cloud computing environment 300 of FIG. 3. The cloud tier 502 includes a data store 508, an application programming interface server 510, and an edge controller 512. The data store 508 may be, for example, the storage 108 of FIG. 1 and may include, for example, edge device task management data. The application programming interface server 510 may be, for example, the server 104 of FIG. 1, the data processing system 200 of FIG. 2, or one of the cloud computing nodes 310 of FIG. 3. The application programming interface server 510 receives user requests from client devices over a network to perform tasks. The application programming interface server 510 interacts with and manages the edge devices 506 to perform the requested tasks. The edge controller 512 is responsible for connecting to all network gateways and edge devices 506 within the edge computing framework. Additionally, the edge controller 512 collects and collates data from the edge devices 506, transmits the data to the application programming interface server 510, and accepts instructions from the application programming interface server 510 to run across all or a cluster of edge devices 506.

[0055] The edge layer 504 is responsible for connecting devices locally. Additionally, the edge layer 504 manages data collection and connections to the application programming interface server 510. The edge layer 504 is also responsible for outage handling and data storage and forwarding. The edge layer 504 includes a synchronization service 514, a metadata store 516, and an edge agent 518. The synchronization service 514 is responsible for synchronizing data to the application programming interface server 510. The metadata store 516 includes metadata that defines different clusters of edge devices included in the edge device 506. The metadata store 516 may retrieve edge device cluster metadata from the data store 508. The edge agent 518 communicates with the edge device 506 using a cluster definer 520, a task sender 522, and a task result receiver 524. The cluster definer 520 uses information in the metadata store 516 to define different clusters of edge devices. The cluster definer 520 also refines clusters of edge devices in response to task migration between edge devices. The task sender 522 assigns and sends tasks to each edge device based on corresponding task attributes, such as priority and tag. Furthermore, the task sender 522 cancels and migrates tasks on edge devices based on a task cancellation and migration plan, or restarts tasks on edge devices based on a task pending plan. The task result receiver 524 receives task status and task execution results on the edge device 506.

[0056] The edge devices 506 may be, for example, edge devices 110 of FIG. 1 and may include any type and combination of edge devices. In this example, the edge devices 506 include edge device "A" 526, edge device "B" 528, edge device "C" 530, edge device "D" 532, and edge device "E" 534. Nevertheless, it should be noted that the edge devices 506 may include any number of edge devices. Also, edge device A 526, edge device B 528, edge device C 530, edge device D 532, and edge device E 534 include proxies 536, 538, 540, 542, and 544, respectively. Proxies 536-544 provide communication between the edge devices 506. Additionally, edge device A 526, edge device B 528, edge device C 530, edge device D 532, and edge device E 534 each include a container 546, a container 548, a container 550, a container 552, and a container 554. Containers 546-554 execute tasks sent to the corresponding edge device 506.

[0057] 6, a diagram illustrating an example of a first task with subtasks is depicted, in accordance with an illustrative embodiment. The first task with subtasks 600 may be implemented in a task management system, such as, for example, task management system 500 of FIG.

[0058] In this example, the first task 600 with subtasks is task_1 602, which includes subtask_1_1 604, subtask_1_2 606, and subtask_1_3 608. Nevertheless, it should be noted that task_1 602 is merely an example and is not intended as a limitation on the illustrative embodiment. In other words, task_1 602 may include any number of subtasks.

[0059] The task definition 610 for task_1 602 indicates subtask identifiers with corresponding next subtask identifiers. In this example, subtask_1_1 has a corresponding next subtask called subtask_1_2, which has a corresponding next subtask called subtask_1_3. The subtask attributes 612 for task_1 602 indicate subtask identifiers with corresponding tags and priorities. In this example, subtask_1_1 has a corresponding tag_1 and priority_3, subtask_1_2 has a corresponding tag_2, tag_4, and priority_2, and subtask_1_3 has a corresponding tag_3 and priority_3. The tags indicate on which particular edge device the corresponding subtask is to run. For example, tag_1 may indicate that the corresponding subtask is intended to run on edge device A, tag_2 may indicate that the corresponding subtask is intended to run on edge device B, tag_3 may indicate that the corresponding subtask is intended to run on edge device C, tag_4 may indicate that the corresponding subtask is intended to run on edge device D, and tag_5 may indicate that the corresponding subtask is intended to run on edge device E. Priority indicates the relative importance of running a particular subtask. For example, a higher priority subtask will run before a lower priority subtask.

[0060] 7, a diagram illustrating an example of a select edge device cluster process for a first task is depicted, according to an illustrative embodiment. The select edge device cluster process for a first task 700 may be implemented in a task management system, such as, for example, task management system 500 of FIG.

[0061] In this example, an edge agent 702, such as edge agent 518 of FIG. 5, utilizes a cluster definer, such as cluster definer 520 of FIG. 5, to define cluster_1, which includes edge devices 704, for task_1 706. The edge devices 704 include edge device A, edge device B, and edge device C, such as edge device A 526, edge device B 528, and edge device C 530 of FIG. 5. Task_1 706 includes subtask_1_1, subtask_1_2, and subtask_1_3, such as task_1 602, which includes subtask_1_1 604, subtask_1_2 606, and subtask_1_3 608 of FIG. 6. Edge agent 702 utilizes a task sender, such as task sender 522 of FIG. 5, to send subtask_1_1, subtask_1_2, and subtask_1_3 to edge device A, edge device B, and edge device C, respectively, based on the corresponding tags included in the subtask attributes, such as subtask attribute 612 of FIG. 6, and the cluster metadata from the cluster definer.

[0062] The edge device attribute table 708 includes an edge device identifier 710, a tag 712, a CPU usage 714, a current subtask 716, a current subtask status 718, and a current task 720. The edge device attribute table 708 shows the attributes of the edge device 704 before task_1 706 was sent to the edge device 704. The edge device cluster table 722 includes a task identifier 724, a cluster identifier 726, a subtask identifier 728, an edge device identifier 730, and a coordinator proxy 732. The edge device cluster table 722 shows the selection of edge devices 704 (i.e., edge devices A, B, and C) as cluster_1 for task_1 706, which includes subtask_1_1, subtask_1_2, and subtask_1_3. The edge device cluster table 722 also indicates that a proxy on edge device A, such as proxy 536 on edge device A 526, is designated as the coordinator proxy for cluster_1. The coordinator proxy controls network traffic (e.g., task results and task status) between edge devices 704 in cluster_1 based on cluster metadata.

[0063] 8, a diagram illustrating an example of a passing subtask result and task status process is depicted, in accordance with an illustrative embodiment. Passing subtask result and task status process 800 may be implemented in a task management system, such as, for example, task management system 500 of FIG.

[0064] In this example, the passing subtask results and task status process 800 utilizes a subtask result passing table 802 and a task status table 804. The subtask result passing table 802 includes an edge device identifier 806, a subtask identifier 808, a task identifier 810, a cluster identifier 812, a next subtask identifier 814, a next edge device identifier 816, and a coordinator 818. The subtask result passing table 802 indicates that the coordinator proxy on edge device A receives the results of each subtask and that the results of each subtask are sent to the next subtask (i.e., the next proxy on the next edge device) based on the cluster metadata. The task status table 804 includes an edge device identifier 820, a subtask identifier 822, a subtask status 824, a cluster identifier 826, a task identifier 828, and a task status 830. Task status table 804 indicates that the current status of task_1 is running on cluster_1, which includes edge devices A, B, and C. Additionally, task status table 804 indicates the current status of each subtask of task_1 on its corresponding edge device. For example, subtask_1_1 has finished running on edge device A, subtask_1_2 is running on edge device B, and subtask_1_3 is pending on edge device C.

[0065] 9, a diagram illustrating an example of a second task with subtasks is depicted, in accordance with an illustrative embodiment. The second task with subtasks 900 may be implemented in a task management system, such as, for example, task management system 500 of FIG.

[0066] In this example, the second task 900 having subtasks is task_2 902, which includes subtask_2_1 904 and subtask_2_2 906. Nevertheless, it should be noted that task_2 902 is merely an example and is not intended as a limitation on the illustrative embodiment. In other words, task_2 902 may include any number of subtasks.

[0067] Task definition 908 for task_2 902 indicates a subtask identifier with a corresponding next subtask identifier. In this example, subtask_2_1 has a corresponding next subtask called subtask_2_2. Subtask attributes 910 for task_2 902 indicate a subtask identifier with a corresponding tag and priority. In this example, subtask_2_1 has a corresponding tag_2 and priority_1, and subtask_2_2 has a corresponding tag_3 and priority_3. The tag indicates on which particular edge device the corresponding subtask is intended to run. For example, tag_2 indicates that subtask_2_1 is intended to run on edge device B, and tag_5 indicates that subtask_2_2 is intended to run on edge device E. The priority indicates the relative importance of a particular subtask to run. For example, priority_1 indicates that subtask_2_1 is a high-priority subtask that will run before lower-priority subtasks.

[0068] Referring now to FIG. 10 , a diagram illustrating an example of an edge device attribute table is depicted, according to an illustrative embodiment. The edge device attribute table 1000 may be implemented in a task management system, such as the task management system 500 of FIG. 5 . In this example, the edge device attribute table 1000 includes an edge device identifier 1002, a tag 1004, a CPU usage 1006, a current subtask 1008, a current subtask status 1010, and a current task 1012. The edge device attribute table 1000 is similar to the edge device attribute table 708 of FIG. 7 . Nevertheless, the edge device attribute table 1000 shows the attributes of edge devices A-E after subtask1_1, subtask1_2, and subtask1_3 of task_1 have been sent to edge devices A, B, and C, respectively, and before subtask2_1 and 2_2 have been sent to selected edge devices.

[0069] 11, a diagram illustrating an example of a subtask assignment process is depicted, in accordance with an illustrative embodiment. The subtask assignment process 1100 may be implemented in a task management system, such as, for example, task management system 500 of FIG.

[0070] 5 to define cluster_1 including edge devices A, D, and C of edge devices 1104 for task_1 1106, and cluster_2 including edge devices B and E of edge devices 1104 for task_2 1108. Further, note that when a user request to perform task_2 1108 is received, edge device A is performing subtask_1_1 of task_1 1106, subtask_1_2 is pending on edge device B, and subtask_1_3 is pending on edge device C. Because subtask_2_1 of task_2 1108 must run on edge device B of edge device 1104 based on the tag and priority subtask attributes, e.g., tag_2 and priority_1 of subtask attributes 910 of FIG. 9, that correspond to subtask_2_1, a task sender, e.g., task sender 522 of edge agent 1102 of FIG. 5, assigns subtask_1_2 of task_1 1106 to run on edge device D of edge device 1104 based on the tag and priority subtask attributes, e.g., tag_2, tag_4, and priority_2 of subtask attributes 612 of FIG. 6, that correspond to subtask_1_2. Further, the task transmitter assigns subtask_2_2 to be executed on edge device E of edge devices 1104 based on the tag and priority subtask attributes, such as tag_5 and priority_3 in subtask attributes 910 of FIG. 9, corresponding to subtask_2_2.

[0071] Edge device cluster table 1110 includes a task identifier 1112, a cluster identifier 1114, a subtask identifier 1116, an edge device identifier 1118, and a coordinator proxy 1120. Edge device cluster table 1110 is similar to edge device cluster table 722 of FIG. 7, except that edge device cluster table 1110 now includes information about cluster_2, which corresponds to task_2 1108. Furthermore, edge device cluster table 1110 indicates that edge device D, rather than edge device B, is now included in cluster_1. Edge device cluster table 1110 also indicates that a proxy on edge device E, such as proxy 544 on edge device E 534, is designated as the coordinator proxy for cluster_2.

[0072] 12, a diagram illustrating an example process for sending subtasks to an edge device is depicted, according to an illustrative embodiment. Process 1200 for sending subtasks to an edge device may be implemented in a task management system, such as, for example, task management system 500 of FIG.

[0073] In this example, edge agent 1202 utilizes a task transmitter, such as task transmitter 522 of FIG. 5, to send tasks to edge devices 1204. The tasks, in this example, are task_1 1206, which includes subtask_1_1, subtask_1_2, and subtask_1_3, and task_2 1208, which includes subtask_2_1 and subtask_2_2. The task transmitter utilizes information in subtask transmission table 1210 to send each subtask to the appropriate edge device of edge devices 1204.

[0074] In this example, subtask transmission table 1210 includes edge device identifier 1212, subtask identifier 1214, task identifier 1216, cluster identifier 1218, next subtask identifier 1220, next edge device identifier 1222, and coordinator 1224. Because edge devices 1204 include edge device D, which is capable of executing subtask_1_2, the task transmitter will send subtask_1_2 to run on edge device D rather than edge device B. As a result, subtask_1_1 will run on edge device A, subtask_2_1 will run on edge device B, subtask_1_3 will run on edge device C, subtask_1_2 will run on edge device D, and subtask_2_2 will run on edge device E.

[0075] 13, a diagram illustrating an example of a pending plan process is depicted, in accordance with an illustrative embodiment. The pending plan process 1300 may be implemented in a task management system, such as, for example, task management system 500 of FIG.

[0076] 5 to define cluster_1 including edge devices A, B, and C of edge devices 1304 for task_1 1306, and cluster_2 including edge devices B and E of edge devices 1304 for task_2 1308. Further, note that edge device A is executing subtask_1_1 of task_1 1306 when a user request to execute task_2 1308 is received. Because subtask_2_1 of task_2 1308 must execute on edge device B of edge device 1304 based on its tag_2 and priority_1 attributes, and edge device 1304 does not include an edge device capable of executing subtask_1_2 in this example, a task sender of edge agent 1302, such as task sender 522 of FIG. 5, creates a pending plan (i.e., pending plan table 1322) for subtask_1_2 to execute on edge device B when subtask_2_1 finishes executing, based on subtask_1_2 having a lower priority attribute (i.e., priority_2).

[0077] The edge device cluster table 1310 includes a task identifier 1312, a cluster identifier 1314, a subtask identifier 1316, an edge device identifier 1318, and a coordinator proxy 1320. The edge device cluster table 1310 is similar to the edge device cluster table 1110 of FIG. 11 except that the edge device cluster table 1310 indicates that subtask_1_2 is pending on edge device B, and edge device B is included in both cluster_1 and cluster_2. The pending plan table 1322 includes a task identifier 1324, a cluster identifier 1326, a subtask identifier 1328, an edge device identifier 1330, a dependent subtask identifier 1332, and a dependent task identifier 1334.

[0078] 14, a diagram illustrating an example of a cancellation and movement planning process is depicted, in accordance with an illustrative embodiment. The cancellation and movement planning process 1400 may be implemented in a task management system, such as, for example, task management system 500 of FIG.

[0079] 5 to define cluster_1 including edge devices A, D, and C of edge devices 1404 for task_1 1406, and cluster_2 including edge devices B and E of edge devices 1404 for task_2 1408. Further, note that edge device A is executing subtask_1_1 of task_1 1406 when a user request to execute task_2 1408 is received. Because subtask_2_1 of task_2 1408 must be executed on edge device B of edge devices 1404 based on its tag_2 and priority_1 attributes, and edge devices 1304 include edge device D, which is capable of executing subtask_1_2 in this example, a task sender, such as task sender 522 of FIG. 5, of edge agent 1302 creates a cancellation and movement plan (i.e., cancellation and movement plan table 1422) for subtask_1_2 to cancel subtask_1_2 on edge device B and move subtask_1_2 to edge device D based on subtask_1_2 having a lower priority_2 attribute.

[0080] The edge device cluster table 1410 includes a task identifier 1412, a cluster identifier 1414, a subtask identifier 1416, an edge device identifier 1418, and a coordinator proxy 1420. The edge device cluster table 1410 is similar to the edge device cluster table 1110 of Figure 11. The cancellation and movement plan table 1422 includes a task identifier 1424, a cluster identifier 1426, a subtask identifier 1428, a cancellation edge device identifier 1430, and a movement edge device identifier 1432.

[0081] 15A-15B, a flowchart illustrating a process for edge time sharing across clusters via dynamic task migration is shown, according to an illustrative embodiment. The process illustrated in Figures 15A-15B may be implemented in a computer system, such as, for example, network data processing system 100 of Figure 1, cloud computing environment 300 of Figure 3, or task management system 500 of Figure 5.

[0082] The process begins when a computer system receives a first task including a first plurality of subtasks for execution (step 1502). In response to receiving the first task, the computer system selects a first cluster of edge devices from a plurality of edge devices included in an edge computing framework to execute the respective subtasks based on attributes of each respective subtask of the first plurality of subtasks corresponding to the first task (step 1504). The computer system then sends each respective subtask of the first plurality of subtasks to a corresponding edge device in the first cluster of edge devices for execution (step 1506).

[0083] The computer system then uses a proxy component included in each of the first cluster of edge devices to send results of the execution of the subtask on the corresponding edge device to other edge devices included in the first cluster of edge devices based on the cluster metadata corresponding to the first cluster of edge devices (step 1508). The computer system then sends a status of the first task to a designated coordinator proxy of the first cluster of edge devices (step 1510). The computer system then synchronizes the status of the first task with a task result receiver using the designated coordinator proxy of the first cluster of edge devices (step 1512).

[0084] The computer system then receives a second task including a second plurality of subtasks for execution while the first task is still executing on the first cluster of edge devices (step 1514). In response to receiving the second task, the computer system selects a second cluster of edge devices from the plurality of edge devices for executing each subtask of the second plurality of subtasks corresponding to the second task, including a designated edge device from the first cluster of edge devices for executing the higher priority subtask, based on attributes of the higher priority subtasks of the second plurality of subtasks (step 1516).

[0085] The computer system determines whether a subtask cancellation and migration plan exists (step 1518). If the computer system determines that a subtask cancellation and migration plan exists, which is a "yes" output of step 1518, the computer system cancels a lower-priority subtask of the first plurality of subtasks from a designated edge device of the first cluster of edge devices designated to execute a higher-priority subtask of the second plurality of subtasks based on the subtask cancellation and migration plan (step 1520). Then, the computer system moves the canceled lower-priority subtask of the first plurality of subtasks from a designated edge device of the first cluster of edge devices to another edge device within the plurality of edge devices that is not included in either the first cluster of edge devices or the second cluster of edge devices for execution based on the subtask cancellation and migration plan (step 1522). Furthermore, the computer system sends the higher-priority subtask of the second plurality of subtasks to the designated edge device of the first cluster of edge devices for execution (step 1524). The process then ends.

[0086] Returning again to step 1518, if the computer system determines that there is no subtask cancellation and movement plan, which is a NO output of step 1518, the computer system suspends lower priority subtasks of the first plurality of subtasks on designated edge devices of the first cluster of edge devices designated to execute higher priority subtasks of the second plurality of subtasks based on the subtask pending plan (step 1526). Furthermore, the computer system sends the higher priority subtasks of the second plurality of subtasks to the designated edge device of the first cluster of edge devices for execution (step 1528). Thereafter, the computer system launches the suspended lower priority subtasks of the first plurality of subtasks for execution on the designated edge device of the first cluster of edge devices when the higher priority subtasks of the second plurality of subtasks finishes execution on the designated edge device (step 1530). The process then terminates.

[0087] Thus, illustrative embodiments of the present invention provide a computer-implemented method, computer system, and computer program product for time sharing across a cluster of edge devices using dynamic task migration based on subtask attributes. The description of various embodiments of the present invention has been presented for illustrative purposes, but is not intended to be exhaustive or limited to the disclosed embodiments. Many modifications and variations will be apparent to those skilled in the art without departing from the scope of the described embodiments. The terminology used herein has been chosen to best explain the principles of the embodiments, practical applications, or technical improvements over technology found in the market, or to enable those skilled in the art to understand the embodiments disclosed herein.

Claims

1. 1. A computer-implemented method for edge device task management, comprising: The computer determining whether a subtask cancellation and movement plan exists for an edge computing framework when a request is received to execute a higher priority subtask of a second plurality of subtasks corresponding to a second task while a first task including a first plurality of subtasks is running on a first cluster of edge devices in the edge computing framework; responsive to determining that the subtask cancellation and movement plan exists for the edge computing framework, canceling lower priority subtasks of the first plurality of subtasks from designated edge devices of the first cluster of edge devices designated to perform the higher priority subtasks of the second plurality of subtasks based on the subtask cancellation and movement plan; moving the lower priority subtasks of the first plurality of subtasks that were canceled from the designated edge device of the first cluster of edge devices to another edge device not included in the first cluster of edge devices for execution based on the subtask cancellation and migration plan; sending the higher priority subtasks of the second plurality of subtasks to the designated edge device of the first cluster of edge devices for execution; 11. A computer-implemented method comprising:

2. The computer in response to determining that the subtask cancellation and movement plan for the edge computing framework does not exist, suspending the lower priority subtasks of the first plurality of subtasks on the designated edge device of the first cluster of edge devices designated to perform the higher priority subtasks of the second plurality of subtasks based on a subtask pending plan for the edge computing framework; sending the higher priority subtasks of the second plurality of subtasks to the designated edge device of the first cluster of edge devices for execution; activating the suspended lower priority subtasks of the first plurality of subtasks on the designated edge device of the first cluster of edge devices for execution when the higher priority subtasks of the second plurality of subtasks finish execution on the designated edge device; The computer-implemented method of claim 1 , further comprising:

3. The computer receiving the first task including the first plurality of subtasks for execution; selecting a first cluster of edge devices from a plurality of edge devices included in the edge computing framework for performing the respective subtasks based on attributes of each respective subtask of the first plurality of subtasks corresponding to the first task; sending each respective subtask of the first plurality of subtasks to a corresponding edge device in a first cluster of edge devices for execution; The computer-implemented method of claim 1 , further comprising:

4. The computer using a proxy component included in each of the first cluster of edge devices to send results of executing the subtasks on the corresponding edge device to other edge devices included in the first cluster of edge devices based on cluster metadata corresponding to the first cluster of edge devices; The computer-implemented method of claim 1 , further comprising:

5. The computer sending a status of the first task to a designated coordinator proxy of a first cluster of the edge devices; The computer-implemented method of claim 1 , further comprising:

6. The computer synchronizing the status of the first task with a task result receiver using the designated coordinator proxy of the first cluster of edge devices. The computer-implemented method of claim 5 further comprising:

7. The computer receiving the second task including the second plurality of subtasks for execution while the first task is executing on the first cluster of edge devices; and selecting a second cluster of edge devices from a plurality of edge devices in the edge computing framework for executing each subtask of the second plurality of subtasks corresponding to the second task including the designated edge device of the first cluster of edge devices for executing the higher priority subtask based on attributes of the higher priority subtasks of the second plurality of subtasks, wherein the other edge device for executing the lower priority subtask of the first plurality of subtasks that has been moved from the designated edge device of the first cluster of edge devices is not also included in the second cluster of edge devices; The computer-implemented method of claim 1 , further comprising:

8. A computer system for edge device task management, comprising: a bus system; a set of storage devices connected to said bus system, said set of storage devices storing program instructions; a set of processors connected to the bus system, determining whether a subtask cancellation and movement plan exists for an edge computing framework when a request is received to execute a higher priority subtask of a second plurality of subtasks corresponding to a second task while a first task including a first plurality of subtasks is executing on a first cluster of edge devices in the edge computing framework; responsive to determining that the subtask cancellation and movement plan exists for the edge computing framework, canceling lower priority subtasks of the first plurality of subtasks from designated edge devices of the first cluster of edge devices designated to perform the higher priority subtasks of the second plurality of subtasks based on the subtask cancellation and movement plan; moving the lower priority subtasks of the first plurality of subtasks that were canceled from the designated edge device of the first cluster of edge devices to another edge device not included in the first cluster of edge devices for execution based on the subtask cancellation and migration plan; and sending the higher priority subtasks of the second plurality of subtasks to the designated edge device of the first cluster of edge devices for execution. a set of processors that execute the program instructions to perform the steps of A computer system comprising:

9. the set of processors in response to determining that the subtask cancellation and movement plan for the edge computing framework does not exist, suspending the lower priority subtasks of the first plurality of subtasks on the designated edge device of the first cluster of edge devices designated to perform the higher priority subtasks of the second plurality of subtasks based on a subtask pending plan for the edge computing framework; sending the higher priority subtasks of the second plurality of subtasks to the designated edge device of the first cluster of edge devices for execution; activating the suspended lower priority subtasks of the first plurality of subtasks on the designated edge device of the first cluster of edge devices for execution when the higher priority subtasks of the second plurality of subtasks finish execution on the designated edge device; 9. The computer system of claim 8, further executing the program instructions to:

10. the set of processors receiving the first task including the first plurality of subtasks for execution; selecting a first cluster of edge devices from a plurality of edge devices included in the edge computing framework for performing the respective subtasks based on attributes of each respective subtask of the first plurality of subtasks corresponding to the first task; sending each respective subtask of the first plurality of subtasks to a corresponding edge device in a first cluster of edge devices for execution; 9. The computer system of claim 8, further executing the program instructions to:

11. the set of processors using a proxy component included in each of the first cluster of edge devices to send results of executing the subtasks on the corresponding edge device to other edge devices included in the first cluster of edge devices based on cluster metadata corresponding to the first cluster of edge devices; 9. The computer system of claim 8, further executing the program instructions to:

12. the set of processors sending a status of the first task to a designated coordinator proxy of a first cluster of the edge devices; 9. The computer system of claim 8, further executing the program instructions to:

13. the set of processors synchronizing the status of the first task with a task result receiver using the designated coordinator proxy of the first cluster of edge devices.

13. The computer system of claim 12, further executing the program instructions to:

14. A computer program product that causes a computer to carry out the method according to any one of claims 1 to 7.

Images