Methods, systems, and programs for sharing computations between devices.

Abstract

A system for sharing efficient computation among multiple Internet of Things (IoT) devices using device operating system (OS) clustering, wherein a processor identifies an action of a first one of the IoT devices, initiates a transfer from the first device to one or more other one of the IoT devices, pauses each thread being executed by the first device and the one or more other devices, and transfers a unit from the first device to the one or more other devices.

Description

Technical Field

[0001] The present disclosure generally relates to the field of the Internet of Things (IoT), and more particularly to efficient sharing of computations among multiple IoT devices using device operating system (OS) clustering.

Background Art

[0002] Currently, there are more connected IoT devices in the world than the total number of all humans, and the number of IoT devices is further increasing. Each IoT device has specific heterogeneous computing capabilities and a specific primary purpose, i.e., a program, to execute. As a result, more devices are added, and more computing capabilities are used by more programs. However, most IoT devices usually have a single primary program that operates only for a specific period. Most of those devices do not operate at 100% of their computing capabilities, or do not operate all the time (e.g., remaining idle for the rest of the time), or both.

Summary of the Invention

[0003] Embodiments of the present disclosure include a method, a computer program product, and a system for sharing efficient computations among multiple IoT devices using device OS clustering. A processor may identify an action of a first device among the IoT devices. The processor may initiate a transfer from the first device to one or more other devices among the IoT devices. The processor may pause each thread being executed by the first device and the one or more other devices. The processor may transfer units from the first device to one or more other devices.

[0004] According to one embodiment, a system is provided for efficiently sharing computing among multiple Internet of Things (IoT) devices using device operating system (OS) clustering, comprising: memory; a processor communicating with the memory, wherein the processor is configured to perform operations, the operations of which include: identifying an action of a first device among the IoT devices; initiating a transfer from the first device to one or more other devices among the IoT devices; suspending each thread being executed by the first device and one or more other devices; and transferring a unit from the first device to one or more other devices.

[0005] In another embodiment, a method is provided for sharing efficient computing among multiple Internet of Things (IoT) devices using device operating system (OS) clustering, the method comprising: a processor identifying an action of a first device among the IoT devices; initiating a transfer from the first device to one or more other devices among the IoT devices; pausing each thread being executed by the first device and one or more other devices; and transferring a unit from the first device to one or more other devices.

[0006] In another embodiment, a computer program product is provided for sharing efficient computing among multiple Internet of Things (IoT) devices using device operating system (OS) clustering, comprising a computer-readable storage medium embodying program instructions, wherein the program instructions are executable by a processor, causing the processor to perform an operation, the operation including identifying an action of a first device among the IoT devices, initiating a transfer from the first device to one or more other IoT devices, pausing each thread being executed by the first device and one or more other devices, and transferring a unit from the first device to one or more other devices.

[0007] The above summary is not intended to describe each illustrated embodiment or all implementations of this disclosure.

[0008] Next, preferred embodiments of the present invention will be described with reference to the following drawings, merely as examples. [Brief explanation of the drawing]

[0009] [Figure 1A] This is a block diagram of an exemplary system for efficiently sharing computing across multiple IoT devices using device OS clustering in a first state, according to a preferred embodiment of the present invention. [Figure 1B] This is a block diagram of an exemplary system for efficiently sharing computing across multiple IoT devices using device OS clustering in a second state, according to a preferred embodiment of the present invention. [Figure 2] This is a flowchart illustrating an exemplary method for efficiently sharing computing across multiple IoT devices using device OS clustering, according to a preferred embodiment of the present invention. [Figure 3A] This figure shows a cloud computing environment according to a preferred embodiment of the present invention. [Figure 3B] This figure shows an abstraction model layer according to a preferred embodiment of the present invention. [Figure 4] This is a high-level block diagram of an exemplary computer system used in implementing one or more of the methods, tools, and modules described herein, as well as any related functions, according to preferred embodiments of the present invention. [Modes for carrying out the invention]

[0010] The embodiments described herein are subject to various modifications and alternative forms, the details of which are illustrated in the drawings and described in detail. However, it should be understood that the specific embodiments described herein should not be construed as restrictive. Rather, the intention is to cover all modifications, equivalents, and alternatives that fall within the spirit and scope of this disclosure.

[0011] The aspects of this disclosure generally relate to the field of IoT, and more specifically to the efficient sharing of computations among multiple IoT devices using device OS clustering. While this disclosure is not necessarily limited to such applications, various aspects of this disclosure can be understood through discussions of various examples using this context.

[0012] Currently, there are more connected IoT devices worldwide than all of humanity combined, and the number of IoT devices is still increasing. Each IoT device has a specific type of computing power and a specific primary purpose, or program, to perform (e.g., mobile phones, televisions, refrigerators, smartwatches, etc.). As a result, more devices are being added, and more programs are using more computing power. However, most IoT devices typically have a single primary program that runs only for a specific period of time. Most of these devices do not operate at 100% of their computing power, or, more importantly, are not constantly running (e.g., remaining idle the rest of the time), or both.

[0013] Therefore, at a high level, removing dependencies on specific hardware computing for computation brings significant benefits to the system. This disclosure discusses a solution that brings this significant benefit to the system. We propose a solution that provides a way for a system / network to share collective computing power by utilizing the computing power of idle devices by creating a cluster of operating systems of multiple IoT (e.g., computing) devices. This solution manages processes on multiple IoT devices and moves / locates / transfers / rebalances active processes to other member devices of the cluster based on the overall resource utilization of the IoT devices in the cluster.

[0014] In some embodiments, the proposed solution provides clustering of operating systems for one or more computing devices. The computing devices behave like cluster members and are controlled by a cluster manager program to efficiently distribute and transfer computations among the devices. In such embodiments, each (IoT) device runs the proposed OS program, which controls, moves, stops, or starts any program on the device, or a combination thereof, and works with a manager program (e.g., a cluster manager) on the same or other devices to share / manage computing loads.

[0015] In some embodiments, the operating systems of all participating devices behave like members of a cluster coordinated by the cluster manager in the following manner:

[0016] The cluster manager program runs on any member IoT device that has the option of high availability (HA) on one or more additional devices (for example, a quorum of IoT devices running the cluster manager).

[0017] The cluster manager program controls, adds, removes, and updates devices related to the cluster in terms of computing. In some embodiments, a user may manually authorize the addition of a new member to the cluster in a home environment. Alternatively, in a public environment, devices may join an organized service that automatically joins and leaves (and in some cases receive payment for their processing usage over time (e.g., cars in an indoor parking garage clustered together for a temporary supercomputer during the day)).

[0018] The cluster manager program controls increases or decreases or both in memory and computational footprint without interfering with the execution of any device's / main program on any device.

[0019] The cluster manager program establishes a trust relationship between devices within a cluster, enabling safe direct transfer of processes between devices using the network.

[0020] The cluster manager program manages the transfer of in - operation processes between member devices based on load, policy, priority, efficiency, processor architecture, etc.

[0021] The cluster manager program can support the HA function for running any critical program on multiple devices, which includes synchronously replicating memory and storage while the process is running so that operation can continue in parallel on other devices even if a device's plug is removed.

[0022] In some embodiments, in the proposed OS on an IoT device, the proposed OS includes the main algorithms of device functions and secondary programs assigned by the cluster manager, and the proposed OS tracks the exact instruction (code) lines within each thread being executed at any given time along with each variable and its value. In this way, it is possible to jump directly to any code line and start execution using its pre - conditions such as variable data and libraries.

[0023] In some embodiments, a component (program: transfer unit) transfers one or more computations from one computing unit to another using code line information and variable data. The receiving device's system / computing unit can use that information and continue processing from the subsequent lines remaining from the previous computing unit.

[0024] Therefore, the component identifies the current processing line in the code by / with the algorithm, along with the variable, and the component transfers that line and the variable to the next other device that takes over and starts the execution of the process. This solution enables the automatic transfer of the calculation of any algorithm in progress from one IoT device to another IoT device. Each time the calculation moves to another new system, the calculation accurately picks up where it stopped in the previous system, so there is no repetition.

[0025] Note that many IoT computing devices are collecting data for various purposes, and this data needs to be processed in real time and used for various purposes. Specifically, in next-generation devices, there can be clusters of many types of devices, such as idle laptops, smartphones, TVs, refrigerators, washing machines, or many types of sensor devices that capture data and have computing capabilities. Regardless of which device captured the data, the data can be processed by other nearby devices to immediately generate an output, without interfering with the primary purpose of any device and reducing the dependence on an external, distant computing system with latency.

[0026] For ease of understanding, prior to moving to the figures, various use cases regarding how the proposed solution can be implemented and utilized are discussed below. For example, a user may want to play a game on a tablet (e.g., if the game requires heavy calculations), run a prediction algorithm based on real-time data on a laptop, or implement an edge computing application where an immediate result is expected without latency, without a cloud or a slow internet, i.e., without an internet. With the proposed solution provided herein, the computing power in the idle state of the surrounding cluster devices can be used.

[0027] Furthermore, the proposed solutions could be applied to healthcare systems, automobiles, manufacturing, and even household appliances. As another example, sensors in a next-generation home refrigerator could collect data that needs processing (e.g., to run analytical algorithms to generate future predictions and report a list of upcoming purchases). In this case, historical data would need to be processed. The refrigerator would utilize the computing power within the home (e.g., home network, WiFi, etc.) of an idle laptop or game console (e.g., one with high computing power), a mobile device, or any other device in the home.

[0028] In other examples, most next-generation cars will have a computing unit that includes an operating system. This allows parking lots (indoor, outdoor, etc.) to be used as hubs of massive computing power, with hundreds of cars working together. A temporary supercomputer could be created using cars in an indoor parking lot during working hours, and individual cars could be paid for their daily usage.

[0029] Further examples include next-generation devices with very little computing power that constantly rely on external computing for advanced use, such as modular sensor equipment in factories, kitchen appliances like microwave ovens, timer-based stoves, and wireless meter readers.

[0030] In some embodiments, regardless of whether an in-home or external example is implemented, the user may opt in to allowing their device to communicate with other devices. Furthermore, the implementation may be secured on a private network (e.g., blockchain, cloud, etc.) where encryption can be used.

[0031] Referring now to Figures 1A and 1B, these figures show block diagrams of an exemplary system for efficiently sharing computations among multiple IoT devices (devices 102A-D) using device OS clustering in a first state 100A and a second state 100B according to embodiments of the present invention. As shown in the figures, system 100A includes devices 102A-D, which are member IoT devices connected to network 120, through which devices 102A-D can communicate, share computations, or both.

[0032] Furthermore, each of devices 102A to D includes at least secondary programs 104A to B, a cluster manager 106, primary programs 108A to D, or operating systems 110A to D, or a combination thereof. Each of devices 102A to D may be loaded with operating systems 110A to D that enable devices 102A to D to share computations.

[0033] In some embodiments, network 100A utilizes a group of devices 102A-D, which are collectively managed by a cluster manager 106. The cluster manager 106 tracks the exact instructions (e.g., lines of code) of each process running at any given time (e.g., sub-programs 104A-B or main programs 108A-D or both), along with the memory contents associated with that process. This allows any device 102A-D to jump directly to any line of code and begin execution using its prerequisites, including associated memory (e.g., variable data) and dependent libraries. In this way, a running process (e.g., sub-program 104B, or one of sub-program 104B) can be moved from one device (e.g., device 102B) to another device (e.g., device 102D) if it goes offline, has main IoT (e.g., main program 108B) work to be performed and can no longer share its resources, or is offline in an HA setup as described above. In this way, the system transitions from the first state 100A to the second state 100B, and the secondary program 104B is efficiently shared / transferred between devices 102B and 102D.

[0034] Therefore, the ability to perform HA to run any important program (e.g., main programs 108A-D or secondary programs 104A-D or both) on multiple devices 102A-D, specifically, for example, synchronously replicating memory and storage (e.g., including the exact location of instruction processing) while a process is running so that it can continue to run in parallel on other devices 102A-D even if a device is unplugged, is a novel aspect of the system of this disclosure.

[0035] Furthermore, a further novel aspect of the system of this disclosure is the ability, based on instructions from the cluster manager 106, to manage the transfer of running processes (e.g., sub-program 104B, its own) and associated memory contents between member devices 102B and 102D based on load, policy, priority, efficiency, processor architecture, etc.

[0036] Another unique advantage of the disclosed system is that by establishing trust relationships between devices 102A-D in the cluster, it becomes possible to securely and directly transfer processes at specific processing locations in memory and the contents of memory between devices (e.g., 102B and 102D) using the network 120.

[0037] Finally, a feature unique to the disclosed system is that a user can manually request authorization for other IoT devices to join the processing cluster, for the purpose of creating trust relationships that allow live workloads to be executed and migrated between devices 102A-D. Alternatively, in some embodiments, a user in a public environment can enroll other devices in an organized service, which can automatically join and leave, and in some cases receive payment for its processing usage over time (for example, cars in an indoor parking lot clustered together for a temporary supercomputer during the day).

[0038] Referring here to Figure 2, a flowchart of exemplary method 100 for efficiently sharing computing across multiple IoT devices using device OS clustering is shown according to a preferred embodiment of the present invention. In some embodiments, method 200 may be performed by a processor (for example, the system, network 120, computing device, etc., shown in Figures 1A-B).

[0039] In some embodiments, method 200 begins with operation 202, in which the (IoT) devices in the cluster are identified. In some embodiments, an action is identified on a first device among those devices (for example, a primary process requires more computing power, the device is shutting down, or a secondary program needs to be stopped / transferred), and method 200 may proceed to operation 204, initiating a transfer from the first device to one or more other IoT devices.

[0040] In some embodiments, method 200 may proceed to operation 204 after the cluster manager (program) manages the device in 232 and recommends the start of transfer 204. In some embodiments, after operation 204, method 200 proceeds to operation 206, in which each thread of the process in the OS is identified and thread metadata is collected. Note that an execution thread is the smallest sequence of programmed instructions that can be managed independently by a scheduler, which is typically part of the OS.

[0041] In some embodiments, method 200 proceeds to operation 208, in which each thread running by the first device and one or more other devices is suspended. In some embodiments, suspending each thread includes collecting the current pointer, associated variables, and metadata associated with each thread, respectively.

[0042] In some embodiments, method 200 may proceed (simultaneously) to operation 210, in which memory variable data is identified, and operation 212, in which the last pointer associated with the details of the executed code is identified. In some embodiments, method 200 proceeds to operation 214, in which the (computation) unit (OS) is transferred from the first device to one or more other devices.

[0043] In some embodiments, method 200 proceeds to operation 216, in which data related to one or more other devices is collected for transmission. In some embodiments, method 200 proceeds to operation 218, in which the (compute) unit (OS) is transferred from the second device. In some embodiments, method 200 proceeds to operation 220, in which data from transmission 216 is collected by the second device.

[0044] In some embodiments, method 200 proceeds to operation 222, in which data is loaded into the memory of one of one or more other devices (for example, the second device looks for the position of the thread / process / calculation before transfer). In some embodiments, method 200 proceeds to operation 224, in which each thread is triggered in the new memory space in one of one or more other devices (for example, the second device).

[0045] In some embodiments, method 200 proceeds to operation 226, in which one or more variables are created and one or more variables are loaded into runtime scope. Variables are used to store information that is referenced and manipulated within a computer program, and it should be noted that scope refers to the association of names with entities such as variables. This is the part of the program in which name bindings are valid and names can be used to refer to entities. The term scope can also be used to refer to all name bindings that are valid within a part of the program or at a given point in the program, which is more precisely called context or environment. In some embodiments, method 200 proceeds to operation 230, in which each thread is resumed (at the point in time that the thread was transferred during execution). In some embodiments, after operation 230, method 200 may terminate.

[0046] In some embodiments, method 200 proceeds to operation 228 (simultaneously with operation 226), where a cursor is created and inserted into the thread, pointing to a subsequent step within the thread. In some embodiments, method 200 proceeds to operation 230, where each thread is resumed (at the point to which the thread was transferred during execution, as indicated by the cursor). In some embodiments, after operation 230, method 200 may terminate.

[0047] While this disclosure includes a detailed description of cloud computing, it should be understood that implementations of the teachings enumerated herein are not limited to cloud computing environments. Rather, embodiments of this disclosure can be implemented with any other type of computing environment that is currently known or may be developed in the future.

[0048] Cloud computing is a service delivery model that enables convenient, on-demand network access to a shared pool of configurable computing resources (e.g., networks, network bandwidth, servers, processing, memory, storage, applications, virtual machines, and services) that can be rapidly provisioned and released with minimal administrative effort or interaction with service providers. This cloud model may include at least five features, at least three service models, and at least four deployment models.

[0049] The features are as follows:

[0050] On-demand self-service: Cloud consumers can unilaterally provision computing power, such as server time and network storage, automatically as needed, without requiring human interaction with service providers.

[0051] Broad network access: Capabilities can be made available over a network and accessed through standard mechanisms that facilitate use by heterogeneous thin or thick client platforms (e.g., mobile phones, laptops, and PDAs).

[0052] Resource pooling: A provider pools its computing resources to serve multiple consumers using a multi-tenant model where various physical and virtual resources are dynamically allocated and reallocated as needed. Generally, consumers have a sense of partial independence in that they can't do anything about and don't know the exact parts of the resources provided, but they may be able to identify those parts at a higher level of abstraction (e.g., country, state, or data center).

[0053] Rapid resilience: Capabilities can be provisioned quickly and resiliently, sometimes automatically, to scale out rapidly and release quickly to scale in rapidly. To consumers, provisionable capacity often appears unlimited and can be purchased in any quantity at any time.

[0054] Measured Services: Cloud systems leverage metric capabilities at a level of abstraction appropriate to the type of service (e.g., storage, processing, bandwidth, and active user accounts) to automatically control and optimize resource usage. Resource usage can be monitored, managed, and reported to provide transparency to both service providers and consumers.

[0055] The service model is as follows:

[0056] Software as a Service (SaaS): The ability offered to consumers is the use of a provider's applications running on cloud infrastructure. These applications are accessible from various client devices via thin-client interfaces, such as web browsers (e.g., web-based email). Consumers do not manage or control the underlying cloud infrastructure, including networks, servers, operating systems, storage, or even individual application functionalities, with the possible exception of limited, user-specific application configuration settings.

[0057] Platform as a Service (PaaS): The ability offered to consumers is the ability to deploy applications they have created or acquired, written using programming languages ​​and tools supported by the provider, onto a cloud infrastructure. Consumers do not manage or control the underlying cloud infrastructure, including networks, servers, operating systems, or storage, but they do control the deployed applications and, in some cases, the configuration of the application hosting environment.

[0058] Infrastructure as a Service (IaaS): The capability offered to consumers is the provisioning of processing, storage, networking, and other fundamental computing resources that enable consumers to deploy and run any software, including operating systems and applications. Consumers do not manage or control the underlying cloud infrastructure, but they do control the operating system, storage, deployed applications, and, in some cases, select networking components (e.g., host firewalls).

[0059] The deployment model is as follows:

[0060] Private Cloud: Cloud infrastructure is operated exclusively for an organization. It is managed by the organization or a third party and may reside on-premises or off-premises.

[0061] Community Cloud: Cloud infrastructure is shared by several organizations to support a specific community with common concerns (e.g., mission, security requirements, policies, and compliance considerations). It can be managed by the organization or a third party and may reside on-premises or off-premises.

[0062] Public Cloud: Cloud infrastructure is made available to the general public or large industry groups and is owned by organizations that sell cloud services.

[0063] Hybrid Cloud: A cloud infrastructure is a combination of two or more clouds (private, community, or public) that remain separate entities but are joined together by standardized or proprietary technologies (e.g., cloud bursting for load balancing between clouds) that enable data and application portability.

[0064] Cloud computing environments are service-oriented, emphasizing statelessness, low coupling, modularity, and semantic interoperability. At the core of cloud computing is infrastructure, including a network of interconnected nodes.

[0065] Figure 3A shows an exemplary cloud computing environment 310. As shown, the cloud computing environment 310 includes one or more cloud computing nodes 300 that can be used to communicate with local computing devices used by cloud consumers, such as a personal digital assistant (PDA) or mobile phone 300A, a desktop computer 300B, a laptop computer 300C, or an automotive computer system 300N, or a combination thereof. The nodes 300 can communicate with each other. They can be grouped physically or virtually in one or more networks, such as the private, community, public, or hybrid clouds, or a combination thereof, as described above (not shown).

[0066] This enables the cloud computing environment 310 to provide infrastructure-as-a-service, platform-as-a-service, or software-as-a-service, or a combination thereof, without requiring cloud consumers to maintain resources on their local computing devices. It should be understood that the types of computing devices 300A-N shown in Figure 3A are illustrative only, and that the computing node 300 and the cloud computing environment 310 can communicate with any type of computerized device via any type of network or network addressable connection (e.g., using a web browser) or both.

[0067] Figure 3B shows a set of functional abstraction layers provided by the cloud computing environment 310 (Figure 3A). It should be understood in advance that the components, layers, and functionalities shown in Figure 3B are illustrative and not limited to embodiments of this disclosure. The following layers and corresponding functionalities are provided, as shown below:

[0068] The hardware and software layer 315 includes hardware and software components. Examples of hardware components include a mainframe 302, RISC (Reduced Instruction Set Computer) architecture-based servers 304, 306, blade servers 308, storage devices 311, and network and networking components 312. In some embodiments, software components include network application server software 314 and database software 316.

[0069] The virtualization layer 320 provides an abstraction layer, from which the following examples of virtual entities may be provided: a virtual server 322, virtual storage 324, a virtual network 326 including a virtual private network, a virtual application and operating system 328, and a virtual client 330.

[0070] For example, the management layer 340 may provide the following functions: Resource provisioning 342 provides dynamic procurement of computing resources and other resources used to perform tasks within the cloud computing environment. Measurement and pricing 344 provides cost tracking when resources are used within the cloud computing environment and accounting or billing for the consumption of these resources. For example, these resources may include application software licenses. Security provides identity verification of cloud consumers and tasks, as well as protection for data and other resources. The user portal 346 provides consumers and system administrators with access to the cloud computing environment. Service level management 348 provides allocation and management of cloud computing resources so that requested service levels are met. Service Level Agreement (SLA) planning and execution 350 provides pre-arrangement and procurement of cloud computing resources that are expected to be required in the future in accordance with the SLA.

[0071] Workload Layer 360 provides examples of functionality that leverages cloud computing environments. Examples of workloads and functions provided by this layer include mapping and navigation 362, software development and lifecycle management 364, virtual classroom education delivery 366, data analytics processing 368, transaction processing 370, and efficient computing sharing across multiple IoT devices using device OS clustering 372.

[0072] Figure 4 shows a high-level block diagram of an exemplary computer system 401 used in implementing one or more of the methods, tools, and modules described herein, and any related functions, according to embodiments of the present disclosure (for example, using one or more processor circuits or computer processors of a computer). In some embodiments, the main components of the computer system 401 may include one or more CPUs 402, a memory subsystem 404, a terminal interface 412, a storage interface 416, an I / O (input / output) device interface 414, and a network interface 418, all of which may be directly or indirectly coupled to communicate with each other for intercomponent communication via a memory bus 403, an I / O bus 408, and an I / O bus interface unit 410.

[0073] The computer system 401 may include one or more general-purpose programmable central processing units (CPUs) 402A, 402B, 402C, and 402D, collectively referred to herein as CPUs 402. In some embodiments, the computer system 401 may include multiple processors, which is common in relatively large systems, while in other embodiments, the computer system 401 may instead be a single CPU system. Each CPU 402 may execute instructions stored in the memory subsystem 404 and may include one or more levels of onboard cache.

[0074] System memory 404 may include computer system-readable media in the form of volatile memory, such as random access memory (RAM) 422 or cache memory 424. Computer system 401 may further include other removable / non-removable volatile / non-volatile computer system storage media. As just one example, a storage system 426 for reading and writing to non-removable non-volatile magnetic media such as a “hard drive” may be provided. Not shown, a magnetic disk drive for reading and writing to removable non-volatile magnetic disks (e.g., “flexible disks”), or an optical disk drive for reading and writing to removable non-volatile magnetic disks such as CD-ROMs, DVD-ROMs, or other optical media may be provided. Furthermore, memory 404 may include flash memory, such as a flash memory stick drive or flash drive. Memory devices may be connected to the memory bus 403 by one or more data media interfaces. The memory 404 may include at least one program product having a set of program modules (for example, at least one) configured to perform functions of various embodiments.

[0075] One or more programs / utilities 428, each having at least one set of program modules 430, may be stored in memory 404. A program / utility 428 may include a hypervisor (also called a virtual machine monitor), one or more operating systems, one or more application programs, other program modules, and program data. Each of the operating systems, one or more application programs, other program modules, and program data, or any combination thereof, may include an implementation of a networking environment. A program 428 or a program module 430, or both, generally performs functions or methodologies of various embodiments.

[0076] Although the memory bus 403 is shown in Figure 4 as a single bus structure providing a direct communication path between the CPU 402, the memory subsystem 404, and the I / O bus interface 410, the memory bus 403 may, in some embodiments, comprise multiple different buses or communication paths, which can be arranged in any of various forms, such as hierarchical, star or web-configured point-to-point links, multiple hierarchical buses, parallel and redundant paths, or any other suitable type of configuration. Furthermore, although the I / O bus interface 410 and I / O bus 408 are shown as single units, the computer system 401 may, in some embodiments, comprise multiple I / O bus interface units 410, multiple I / O buses 408, or both. Additionally, although multiple I / O interface units are shown to isolate the I / O bus 408 from various communication paths leading to various I / O devices, in other embodiments, some or all of the I / O devices may be directly connected to one or more system I / O buses.

[0077] In some embodiments, the computer system 401 may be a multi-user mainframe computer system, a single-user system, or a server computer or similar device that receives requests from other computer systems (clients) but has little to no direct user interface. Furthermore, in some embodiments, the computer system 401 may be implemented as a desktop computer, a portable computer, a laptop or notebook computer, a tablet computer, a pocket computer, a telephone, a smartphone, a network switch or router, or any other suitable type of electronic device.

[0078] It should be noted that Figure 4 is intended to depict typical key components of an exemplary computer system 401. However, in some embodiments, individual components may have a higher or lower degree of complexity than shown in Figure 4, and there may be other or additional components not shown in Figure 4, and the number, type, and configuration of such components may vary.

[0079] As will be discussed in more detail herein, some or all of the operations of some embodiments of the methods described herein may be performed in a different order or not at all, and furthermore, multiple operations may be performed simultaneously or as internal parts of a larger process.

[0080] This disclosure may be a system, method, or computer program product, or a combination thereof, in an integration of any possible level of technical detail. A computer program product may include a computer-readable storage medium (or more) having computer-readable program instructions thereon for causing a processor to execute aspects of this disclosure.

[0081] Computer-readable storage media can be tangible devices capable of holding and storing instructions for use by instruction-executing devices. Computer-readable storage media may include, for example, but are not limited to, electronic storage devices, magnetic storage devices, optical storage devices, electromagnetic storage devices, semiconductor storage devices, or any suitable combination thereof. 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), compact disc read-only memory (CD-ROM), digital versatile disk (DVD), Memory Stick(R), flexible disk, mechanically coded devices such as punched cards or grooved structures on which instructions are recorded, and any suitable combination thereof. When used herein, computer-readable storage media should not be construed as transient signals themselves, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through waveguides or other transmission media (e.g., light pulses passing through optical fiber cables), or electrical signals transmitted via wires.

[0082] 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 via 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 include copper transmission cables, optical transmission fibers, wireless transmission, routers, firewalls, switches, gateway computers, or edge servers, or a combination thereof. The network adapter card or network interface of each computing / processing device receives computer-readable program instructions from the network, transfers the instructions, and stores them in a computer-readable storage medium within the respective computing / processing device.

[0083] Computer-readable program instructions for performing the operations of the Disclosure may be assembler instructions, instruction set architecture (ISA) instructions, machine instructions, machine-dependent instructions, microcode, firmware instructions, state setting data, integrated circuit configuration data, or source code or object code written in any combination of one or more programming languages, including object-oriented programming languages ​​such as Smalltalk(R) and C++, and procedural programming languages ​​such as the C programming language or similar programming languages. Computer-readable program instructions may be executed entirely on the user's computer, partially on the user's computer, as a standalone software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In the last scenario, the remote computer is connected to the user's computer via any type of network, including a local area network (LAN) or a wide area network (WAN), or is connected to an external computer (for example, via the Internet using an Internet service provider). In some embodiments, electronic circuits including, for example, programmable logic circuits, field-programmable gate arrays (FPGAs), or programmable logic arrays (PLAs) can be made personal by executing computer-readable program instructions using state information of computer-readable program instructions in order to perform aspects of the present disclosure.

[0084] Aspects of the present disclosure are described herein by reference to flowcharts or block diagrams, or both, of methods, apparatus (systems), and computer program products according to embodiments of the present disclosure. It will be understood that each block in a flowchart or block diagram, or both, and any combination of blocks in a flowchart or block diagram, or both, can be implemented by computer-readable program instructions.

[0085] These computer-readable program instructions can be provided to a processor of a computer or other programmable data processing device to generate a machine such that, when those instructions are executed via the processor of the computer or other programmable data processing device, means are generated to implement one or more blocks specified in a flowchart or block diagram, or both. Alternatively, these computer-readable program instructions can be stored in a computer-readable storage medium capable of instructing a computer, programmable data processing device, or other device, or a combination thereof, to function in a particular way, so that the computer-readable storage medium containing the instructions constitutes a product containing instructions that implement one or more blocks of a flowchart or block diagram, or both.

[0086] Furthermore, by loading computer-readable program instructions into a computer, other programmable data processing device, or other device, and causing the computer, other programmable device, or other device to execute a series of operational steps, a computer implementation process can be generated such that when those instructions are executed on the computer, other programmable device, or other device, the functions / actions specified in one or more blocks of a flowchart or block diagram, or both, are implemented.

[0087] The flowcharts and block diagrams in the figures illustrate the architecture, functionality, and operation of possible implementations of the systems, methods, and computer program products according to various embodiments of the present disclosure. In this regard, each block in a flowchart or block diagram may represent a module, segment, or part of an instruction containing one or more executable instructions for implementing a specified logical function. In some alternative implementations, the functions described in a block may be performed in an order other than that shown. For example, depending on the functions involved, two consecutively shown blocks may actually be implemented as a single step, executed simultaneously, substantially simultaneously, partially or completely overlapping in time, or those blocks may be executed in reverse order. You will also notice that each block in a block diagram or flowchart, or both, and any combination of blocks in a block diagram or flowchart, or both, can be implemented by a dedicated hardware-based system that performs a specified function or action, or a combination of dedicated hardware and computer instructions.

[0088] The descriptions of the various embodiments of this disclosure are presented for illustrative purposes only and are not intended to be exhaustive or limitful to the embodiments disclosed. Many modifications and variations will be apparent to those skilled in the art without departing from the scope and concept of the embodiments described. The terminology used herein has been chosen to best describe the principles, practical applications, or technical improvements to the technologies available on the market, or to enable those skilled in the art to understand the embodiments disclosed herein.

[0089] While this disclosure has described specific embodiments, it is expected that changes and modifications thereto will be obvious to those skilled in the art. Therefore, the following claims should be construed to cover all such changes and modifications that fall within the true spirit and scope of this disclosure.

Claims

1. A system for efficiently sharing computing across multiple Internet of Things (IoT) devices using device operating system (OS) clustering, Memory and A processor that communicates with the aforementioned memory, The processor is configured to perform an operation, and the operation is Identifying the action of the first device among the IoT devices, Initiating transfer from the first device to one or more other IoT devices, Suspending each thread being executed by the first device and the one or more other devices, During the pause, the current pointer, associated variables, and metadata of each thread are collected, and the collected information is loaded onto the destination device so that processing can continue from the paused position. Transferring a unit from the first device to one or more other devices, A system that includes this.

2. The collected information includes the current pointer, the associated variables, and metadata associated with the thread. The system according to claim 1, including the following:

3. The collected information includes memory variable data and the last instruction pointer associated with the executable code. The system according to claim 2, further comprising:

4. The processor is further configured to perform an operation, the operation being: Transferring the unit OS of one of the one or more other devices, Collecting data related to one of the one or more other devices, Loading the data into the memory of one of the one or more other devices, The system according to claim 2, including the above.

5. The processor is further configured to perform an operation, the operation being: Triggering each thread in the new memory space of one of the one or more other devices The system according to claim 4, including the system described in claim 4.

6. The processor is further configured to perform an operation, the operation being: To generate one or more variables, Loading one or more of the aforementioned variables into runtime scope, To restart each thread, The system according to claim 5, including the system described in claim 5.

7. The processor is further configured to perform an operation, the operation being: Creating a cursor, Inserting the aforementioned cursor into a thread, wherein the cursor points to a subsequent step within the thread, To restart each thread, The system according to claim 5, including the system described in claim 5.

8. A method for efficiently sharing computing across multiple Internet of Things (IoT) devices using device operating system (OS) clustering, The processor identifies the action of the first device among the IoT devices, Initiating transfer from the first device to one or more other IoT devices, Suspending each thread being executed by the first device and the one or more other devices, During the pause, the current pointer, associated variables, and metadata of each thread are collected, and the collected information is loaded onto the destination device to enable processing to resume from the paused position. Transferring a unit from the first device to one or more other devices, Methods that include...

9. The collected information includes the current pointer, the associated variables, and metadata associated with the thread. The method according to claim 8, including the method described in claim 8.

10. The collected information includes memory variable data and the last instruction pointer associated with the executable code. The method according to claim 9, further comprising:

11. Transferring the unit OS of one of the one or more other devices, Collecting data related to one of the one or more other devices, Loading the data into the memory of one of the one or more other devices, The method according to claim 9, further comprising:

12. Triggering each thread in the new memory space of one of the one or more other devices The method according to claim 11, further comprising:

13. To generate one or more variables, Loading one or more of the aforementioned variables into runtime scope, To restart each thread, The method according to claim 12, further comprising:

14. Creating a cursor, Inserting the aforementioned cursor into a thread, wherein the cursor points to a subsequent step within the thread, To restart each thread, The method according to claim 12, further comprising:

15. A computer program that causes a computer to perform the method described in any one of claims 8 to 14.

16. A computer-readable storage medium recording the computer program described in Claim 15.

Images