JP6740210B2 - System and method for parallel processing using dynamically configurable advance co-processing cells - Google Patents

Description

(Priority data)
This application is a continuation of US Application No. 13/750,696, filed January 25, 2013, which is incorporated herein by reference.

The present invention relates generally to parallel process computing, and more particularly to a processing architecture with an autonomous coprocessor configured to proactively read tasks from a task pool submitted by a central processing unit.

The Internet of Things (also called the Cloud of Things) refers to an ad-hoc network of uniquely recognizable embedded computing devices within an existing Internet infrastructure. The Internet of Things (IoT) predicts a high degree of device, system, and service connectivity over machine-to-machine communication (M2M). The range of things envisioned by IoT is unlimited, including, for example, cardiac monitoring implants, biochip transponders, automotive sensors, aerospace and defense operating devices, and public safety applications to assist firefighters in search and rescue operations. Device may be included. Current market examples include home-based networks with smart thermostats, light bulbs, and washers/dryers that utilize Wi-Fi for remote monitoring. It is estimated that by 2020, over 30 billion devices will be wirelessly connected to the Internet of Things due to the ubiquity of connected objects in IoT. Utilizing the processing capacity of the controller and processor associated with these devices is one of the objectives of the present invention.

Computer processors traditionally execute machine-coded instructions serially. To launch multiple applications in parallel, a single processor interleaves instructions from different programs and executes them serially, but from the user's perspective, applications are processed in parallel. It looks like True parallel or multi-core processing, on the other hand, is a computational approach that subdivides a large computational task into individual computational blocks and distributes them among two or more processors. Computing architectures that use task parallelism (parallelism) divide large computational requirements into discrete modules of executable code. The modules are then executed in parallel or sequentially based on their respective priorities.

A typical multiprocessor system includes a central processing unit ("CPU") and one or more coprocessors. The CPU partitions the computational requirements into tasks and distributes the tasks to coprocessors. Completed threads are reported to the CPU, which keeps additional threads distributed to the coprocessor as needed. Presently known multiprocessing approaches have the disadvantage that task distribution consumes a significant amount of CPU bandwidth, waiting for tasks to complete before distributing new tasks (often the previous task When the task completes, it responds to interrupts from the coprocessor and other messages from the coprocessor. In addition, the coprocessor often remains idle, waiting for new tasks from the CPU.

Therefore, there is a need for a multiprocessor architecture that reduces CPU management overhead and more effectively utilizes and utilizes available co-processing resources.

Various embodiments of parallel computing architectures include a CPU configured to submit to a task pool and one or more CPUs configured to proactively read threads (tasks) from the task pool. Including a coprocessor. Each coprocessor notifies the task pool upon completion of the task and pings the task pool until another task is available for processing. In this way, the CPU communicates directly with the task pool and indirectly with the coprocessor through the task pool.

Coprocessors may also be capable of acting autonomously, that is, they may interact with the task pool independent of the CPU. In the preferred embodiment, each coprocessor includes an agent that queries the task pool to seek tasks to perform. As a result, coprocessors work together “in solidarity” with each other and with task pools to autonomously read and complete individual tasks, which may or may not be interrelated, to achieve aggregate computation requirements. To complete. As a non-limiting example, assume task B involves calculating an average temperature over time. By defining task A to include capturing temperature readings over time, and by defining task B to include capturing captured readings, the CPU and various coprocessors are The processors may thereby communicate a priori with each other via the task pool.

In various embodiments, coprocessors are referred to as autonomous and proactive solidarity cells. In this context, the term autonomous implies that a coprocessor may interact with a task pool without being instructed to do so by the CPU or by the task pool. The term forward-looking suggests that each coprocessor may be configured (eg, programmed) to periodically send agents and monitor the task pool for available tasks appropriate to that coprocessor. The term solidarity implies that the co-processing cells share a common purpose in monitoring and executing all available tasks in the task pool.

A solid state cell (coprocessor) may be a general purpose or special purpose processor and therefore has the same or different instruction set, architecture and microarchitecture as the CPU and other solid state cells in the system. Good. Moreover, the software programs to be executed and the data to be processed may be contained in one or more memory units. In a typical computer system, for example, a software program consists of a series of instructions that may request data to be used by the program. For example, if the program is compatible with a media player, the data contained in the memory may be compressed audio data that is read by a coprocessor and eventually played on a speaker.

Each joint cell in the system may be configured to communicate with the task pool in an ohmic or wireless manner through a crossbar switch, also known as a fabric. In the purely wireless mesh form, the wireless signals themselves may comprise the fabric. In various embodiments, the coprocessor may also be in direct communication with the CPU. The switching fabric facilitates communication between system resources. Each joint cell has its agent in the task pool when it has no processing to perform, or alternatively, when the joint cell is able to contribute to the processing cycle without disturbing its normal operation. Is forward-looking in that it obtains the task to be performed by sending it to. As a non-limiting example, in the context of the Internet of Things (discussed in more detail below), a coprocessor associated with a device, such as a light bulb, has its normal operation of being “on” and “from” a master device (such as a smartphone). Although it may be programmed to wait for an "off" command, its processing resources may also be utilized through the task pool.

In the context of the various embodiments described herein, the term agent refers to a coprocessor that interacts with a task pool, thereby obtaining an available task that is appropriate for that coprocessor cell. Refers to the associated software module that resembles a network packet. A joint cell is a task, if more than one joint cell is available, and more than one matching task is available, either continuously or for execution, when the task is conditional on the execution of a previous task. , Tasks may be executed in parallel. Tasks may be run independently or jointly, depending on the task thread limits provided by the CPU (if applicable). Interdependent tasks within a task pool may be logically combined. The task pool notifies the CPU when the task thread is complete. If the task thread consists of a single task, the task pool may notify the CPU upon completion of such task. If the task thread consists of multiple tasks, the task pool may notify the CPU upon completion of such a series of tasks. Since task threads can be logically combined, it is also envisioned that the task pool may notify the CPU after completion of the logically combined task threads.

Those skilled in the art will configure the CPU such that interoperability between the CPU and the coprocessor configures and/or builds tasks at an abstraction level independent of the instruction set architecture associated with the various coprocessors, thereby It will be appreciated that it may be facilitated by allowing components to communicate at the task level rather than at the instruction level. Thus, devices and their associated coprocessors may be added to the network on a "plug and play" basis. Another aspect of the invention provides interoperability within a heterogeneous array of CPUs with different instruction set architectures.

Various features of the present invention are applicable to, among other things, networks of Internet of Things devices and sensors, heterogeneous computing environments, high performance computing two-dimensional and three-dimensional monolithic integrated circuits, and motion control and robots.
The present invention provides, for example, the following.
(Item 1)
A processing system,
A task pool,
A controller configured to submit a first task to the task pool,
A first coprocessor configured to read ahead the first task from the task pool;
And a processing system.
(Item 2)
The processing system of item 1, wherein the first coprocessor comprises a first agent configured to read the first task from the task pool without communicating with the controller.
(Item 3)
The first task includes a first task type indicia, the first coprocessor is configured to perform the first type task, and the first agent is configured to perform the first task. The processing system of item 2, wherein the processing system is configured to search the task pool for tasks of this type.
(Item 4)
The processing system of item 1, wherein the first coprocessor is further configured to process the first one and notify the task pool upon completion of the first task.
(Item 5)
The processing system of item 1, wherein the task pool is configured to notify the controller upon completion of the first task.
(Item 6)
The processing system of item 1, wherein the controller and the first coprocessor are configured to communicate with each other only through the task pool.
(Item 7)
The processing system of item 1, wherein the controller and the first coprocessor are configured to communicate with each other directly through the task pool.
(Item 8)
Item 3. The first coprocessor is configured to determine that it has available processing capacity and to dispatch the agent to the task pool in response to the determination. Processing system.
(Item 9)
The controller is further configured to submit a second task to the task pool, and the system further includes a second agent configured to proactively read the second task from the task pool. 4. The processing system of item 3, comprising a second coprocessor having.
(Item 10)
The second task includes a second task type indicium, the second coprocessor is configured to perform the second type task, and the second agent is configured to perform the second task. The processing system of item 9, wherein the processing system is configured to search the task pool for tasks of this type.
(Item 11)
The processing system of item 1, wherein the controller and the task pool reside on a monolithic integrated circuit (IC) and the first coprocessor does not reside on the IC.
(Item 12)
10. The processing system of item 9, wherein the controller, the task pool, and the first and second coprocessors reside on a monolithic integrated circuit (IC).
(Item 13)
A method for dynamically controlling processing resources in a network of a type including a central processing unit (CPU), configured to submit a first task having a first task type to a task pool, the method comprising:
Programming a first cell to perform the first task type;
Adding the programmed first cell to the network;
Proactively sending a first agent from the first cell to the task pool;
Retrieving the task pool by the first agent for tasks of the first type;
Reading the first task from the task pool by the first agent;
Transporting the first task by the first agent to the first cell;
Processing the first task by the first cell;
Sending a notification that the first task has been completed from the first cell to the task pool;
Including the method.
(Item 14)
Marking the first task as completed by the task pool;
Sending a notification from the task pool to the CPU that the first task has been completed;
14. The method of item 13, further comprising:
(Item 15)
The method further comprises the step of configuring the first cell to determine that the first cell has available processing capacity as a predicate for sending the first agent in advance to the task pool. , The method described in item 13.
(Item 16)
14. The method of item 13, further comprising integrating the first cell with a first device prior to adding the programmed first cell to the network.
(Item 17)
Item 16. The first device comprises one of a sensor, a light bulb, a power switch, an appliance, a biometric device, a medical device, a diagnostic device, a laptop, a tablet, a smartphone, a motor controller, and a security device. The method described in.
(Item 18)
14. The method of item 13, wherein adding the programmed first cell to the network comprises establishing a communication link between the first cell and the task pool.
(Item 19)
The (CPU) is further configured to submit a second task having a second task type to a task pool,
Programming the second cell to perform the second task type;
Establishing a communication link between the second cell and the task pool;
Proactively sending a second agent from the second cell to the task pool;
Searching the task pool for the second type of task by the second agent;
Reading the second task from the task pool by the second agent;
Transporting the second task by the second agent to the second cell;
Processing the second task by the second cell;
Sending a notification that the second task is completed from the second cell to the task pool;
Marking the second task as completed by the task pool;
Sending a notification from the task pool to the CPU that the second task has been completed;
14. The method of item 13, further comprising:
(Item 20)
A system for controlling distributed processing resources within an Internet of Things (IoT) computing environment, comprising:
A CPU configured to partition the aggregate computing requirements into multiple tasks and to place the tasks in a pool;
A plurality of devices each having a unique dedicated agent configured to proactively read tasks from the pool without direct communication with the CPU;
A system comprising.

The present invention will now be described in conjunction with the accompanying drawings, wherein like numerals represent like elements.

FIG. 1 is a schematic block diagram of a parallel processing architecture including a CPU, memory, a task pool, and a plurality of coprocessors configured to communicate through a fabric, according to an embodiment.

FIG. 2 is a schematic block diagram illustrating details of an exemplary task pool, according to an embodiment.

FIG. 3 is a schematic block diagram of a network including co-processing cells and their corresponding agents that interact with a task pool, according to an embodiment.

FIG. 4 is a schematic arrangement of an Internet of Things network, including available Plug and Play devices, according to an embodiment.

FIG. 5 is a schematic layout of an exemplary Internet of Things use case illustrating dynamic utilization of nearby devices, according to an embodiment.

FIG. 6 is a flow chart illustrating the operation of an exemplary parallel computing environment, according to an embodiment.

Various embodiments include, but are not limited to, data encryption; graphics, video, and audio processing; direct memory access; mathematical calculations; data mining; game algorithms; data outside the network, for example, in the context of the Internet of Things. Ethernet packet and other network protocol processing, including building, receiving, and transmitting; financial services and business methods; search engines; Internet data streaming and other web-based applications; execution of internal or external software programs; Parallel processing computer from simple switching and control functions to complex programs and algorithms, including switching on and off and/or otherwise controlling appliances, light bulbs, consumer electronics, and the like. Wing system and environment.

Various features may be incorporated into any currently known or later developed computer architecture. For example, the issues of synchronization, data security, out-of-order execution, and parallel processing with respect to main processor interrupts may be addressed using the inventive concepts described herein.

Referring now to FIG. 1, a distributed processing system 10 is configured to communicate with a single or multi-core CPU 11 and a task pool 13 through a crossbar switching fabric 14 and one or more solidarity or co-processing cells. 12A-12. The joint cells 12 may also communicate with each other through the switching fabric 14 or through separate cell buses (not shown). The CPU 11 may communicate with the task pool 13 directly or through the switching fabric 14. One or more memory units 15 each contain data and/or instructions. In the present context, the term “instructions” includes software programs that can be compiled for execution by the CPU 11. The memory units 15, cells 12, and task pools 13 may be interconnected ohmicly or wirelessly via a switching fabric 14 to communicate with the CPU and/or with each other. In some embodiments, the CPU 11 communicates with the cell 12 only indirectly through the task pool. In other embodiments, the CPU 11 may also communicate directly with the cell 12 without using the task pool as an intermediary.

In some embodiments, system 10 may include more than one CPU 11 and more than one task pool 13, in which case a particular CPU 11 may interact exclusively with a particular task pool 13. It may act, or multiple CPUs 11 may share one or more task pools 13. Further, each solidarity cell may be configured to interact with more than one task pool 13. Alternatively, a particular cell may be configured to interact with a single designated task pool, for example in the context of high performance or high security.

In various embodiments, a cell may be dynamically paired with the task pool in an ohmic (plug and play) or wireless (on the fly) condition when the following three conditions are met.
1) It is possible for the cell to communicate with the task pool in an ohmic or wireless manner. The connection to the task pool can be through a port in the task pool itself or through a switching fabric connected to the task pool.
2) The task pool, for example, through a graphical software program running on a smartphone or tabred, through traditional Wi-Fi, Bluetooth®, or similar pairing, with or without a password. Recognize the agent sent by the cell as trusted using input from the user, either manually or by any other secure or non-secure method.
3) At least one of the available tasks in the task pool is compatible with the capabilities of the joint cell.

In the case of a multi-processor environment with multiple task pools, the dynamic pairing conditions described above apply, provided that a given cell is locked or restricted to work with only one of the task pools. Otherwise, the cell may connect to one or more task pools using a first discovery based, round robin based, or any other selection scheme. It is also possible to assign priorities to tasks within a task pool, which allows cells to prioritize higher priority tasks and not prioritize higher priority tasks differently. Low tasks.

CPU 11 may be any single or multi-core processor, application processor, or microcontroller used to execute software programs. The system 10 may be implemented on a personal computer, smart phone, tablet, or Internet of Things device, in which case the CPU 11 is local to the Intel® Pentium® or immediate computing environment. It may be any personal computer, such as a multicore processor, that is, or is remote from, a central processor, or a processor cluster. Alternatively, system 10 may be implemented on a supercomputer and CPU 11 may be a reduced instruction set computer (“RISC”) processor, application processor, microcontroller, or equivalent.

In other embodiments, system 10 may be implemented on a series of locally connected personal computers, such as a Beowulf cluster, in which case CPU 11 may include all of the networked computers, a subset thereof, or one of them. It may include two central processors. Alternatively, system 10 may be implemented on a network of remotely connected computers, in which case CPU 11 may be a now known or later developed central processor for a server or mainframe. Good. The particular manner in which the CPU 11 implements the subject parallelism method within the system 10 described herein may be influenced by the CPU's operating system. For example, the CPU 11 recognizes the task pool 13, communicates with it, and programs it to divide computing requirements into threads, for use within the system 10, as described below. It may be configured.

It is further envisioned that system 10 may be retrospectively implemented on any computer or computer network having an operating system that may be modified or otherwise configured to implement the functionality described herein. It As is known in the art, the data to be processed may be, for example, random access or read-only memory, cache memory for CPU 11, or addresses of other forms of data storage such as flash memory and magnetic storage. Contained within the memory unit 15 in the context of the addressable area or partition. The memory unit 15 contains not only the data to be processed, but also a place to put the result of the processed data. For example, all tasks may access the memory unit 15 as in the case of smart meters and vehicle instruments that may return data to the system 10, or as in the case of robots and motor controllers that may operate certain mechanisms. It is not required.

Each cell 12 is a conceptually or logically independent computing unit capable of executing one or more tasks/threads. The cell 12 may be a stand-alone computer such as a microcontroller, microprocessor, application processor, "dumb" switch, or machine in a Beowulf cluster.

The cell 12 is configured to complement, perform all of, or perform a limited range of functions of the CPU, or functions unrelated to the CPU 11, such as ambient monitoring and robot actuators, for example. It may be a general or special purpose coprocessor. A dedicated processor may be a dedicated hardware module designed, programmed, or otherwise configured to perform a specialized task, or it may be a graphics processing, floating point arithmetic, or data encryption, etc. A general-purpose processor configured to perform the specialized tasks of

In one embodiment, any cell 12, which is a dedicated processor, is also configured to access memory, write to it, execute descriptors, as well as execute other software programs, as described below. May be.

Further, any number of cells 12 may include a heterogeneous computing environment, that is, a system using more than one type of processor, such as AMD-based and/or Intel-based processors, or a mixture of 32-bit and 64-bit processors. ..

Each cell 12 is configured to perform one or more specialization tasks, as illustrated by the sequence of events below. During the polling phase, each cell periodically sends agents to the task pool until a matching task is found. To facilitate this alignment, both the cell and task pool may include transceivers. In the case of task pools, the transceiver may be located in the task pool itself or in the switching fabric to which the task pool is connected. If a task match is found in the task pool, the task pool sends an acknowledgment to the cell. The next step is the "communication channel" phase. During the communication channel phase, the cell receives a task and begins executing that task. In one implementation, once the first task is complete, the communication channel is maintained so that the joint cell can fetch another task without having to repeat the "polling" and "acknowledgement" phases.

System 10 may include multiple cells, some of which may perform the same task type as other cells, thereby providing redundancy within system 10. The set of task types performed by a given cell 12 may be a subset of the set of task types performed by another cell. For example, in FIG. 1, the system 10 may divide the aggregate calculation problem into a group of tasks and put the tasks of the first type, the second type, and the third type into the task pool 13. The first cell 12A may be capable of performing only the first type of task, the second cell 12B may be capable of performing the second type of task, and the third Cell 12C may be capable of performing a third type of task, fourth cell 12D may be capable of performing a second or third type of task, and a fifth cell 12N may be able to perform all three task types. System 10 works with this redundancy so that if a given cell is removed from system 10 (or is currently busy or otherwise unavailable), system 10 can continue to function seamlessly. It may be configured. Further, if cells are dynamically added to system 10, system 10 may continue to function seamlessly with the benefit of performance improvements.

Referring now to FIGS. 1 and 2, task pool 13 may occupy an area of physical memory that is accessible by CPU 11. Alternatively, the task pool 13 may be accessible by MAC address or IP address. Embodiments are envisioned for the task pool 13, which may be physically located with the CPU in the same 2D or 3D monolithic IC, or it may be implemented as a stand-alone IC, a computer board, It may be physically interconnected with a smartphone, tablet, router, or Internet of Things device. In a further alternative embodiment, the task pool may be a stand-alone multi-port, wired, and/or wirelessly connected device that may be shared between multiple CPU 11 systems or dedicated to a given CPU 11. Good. The task pool 13 may also be addressable by the cell 12. The task pool 13 may be located in dedicated hardware blocks to provide maximum access speed by the CPU 11 and cells 12. Alternatively, the task pool 13 may be software-based, and the content of the task pool 13 is stored in memory, similar to hardware-based embodiments, but represented by a data structure.

When submitted by the CPU 11, the task pool 13 contains one or more task threads 21. Each task thread 21 represents a calculation task that may be a component or a subset of a larger aggregate calculation requirement given to the CPU 11. In one embodiment, the CPU 11 may initialize a task pool 13 with threads 21 that can execute in parallel and then populate it. Each thread 21 may include one or more discrete tasks 22. The task 22 may have a task type and a descriptor. The task type indicates which cell 12 is capable of performing the task 22. The task pool 13 may also use task types to prioritize tasks 22 that have the same type. In one embodiment, the task pool 13 records the joint cells 12 that are present in the system 10, the types of tasks 22 each cell can perform, and whether each cell is currently processing the task 22. , A priority table (not shown) may be maintained. The task pool 13 may use the priority table to determine which of the eligible tasks 22 to assign to the requesting cell, as described below.

In some embodiments, the CPU 11 may read a task or thread from the task pool and execute it. Further, the CPU 11 may suspend any task that is determined to be outdated, broken, stalled, or erroneous. In such a case, the CPU 11 may refresh the task and make it available for subsequent processing. For example, nothing prevents CPU 11 from implementing adaptive task management, as may be required by artificial intelligence, after which CPU 11 adds, removes, or modifies tasks within an existing unfinished thread 21. Good.

The descriptor, if present, is one or more of the specific instruction to be executed, the mode of execution, the location (eg, address) of the data to be processed, and the location to place the task result. You may contain a thing. The place for placing the results is often optional, such as in the case of animation and multimedia tasks, where the results are presented on a display rather than stored in memory. Furthermore, task descriptors may be chained together, like linked lists, so that the data to be processed may be accessed with fewer memory calls than if the descriptors were not chained together. In one embodiment, the descriptor is a data structure that contains a header and a plurality of reference pointers to memory locations, and task 22 includes the memory address of the data structure. The header defines the function or instruction to be performed. The first pointer references the location of the data to be processed. A second optional pointer references a place to put the processed data. If the descriptor is linked to another descriptor that is to be executed sequentially, the descriptor may include a third pointer that references the next descriptor. In an alternative embodiment where the descriptor is a data structure, task 22 may include the complete data structure.

Thread 21 may further comprise a "recipe" that describes any conditions that affect the order in which tasks 22 may be performed and the order of performance. According to the recipe, task 22 may be performed sequentially, in parallel, out of order, interdependently, or conditionally according to a Boolean operation. For example, in FIG. 2, thread 21A comprises four tasks, 22A, 22B, 22C, and 22D. In the illustrated embodiment, the first task 22A must be completed before either the second task 22B or the third task 22C can begin. According to the recipe, once either the second task 22B or the third task 22C has completed, the fourth task 22D can begin.

Threads 21 may also be interdependent. For example, as shown in FIG. 2, a completed task 22C may allow the tasks in thread 21B to continue processing due to Boolean operations in thread 21B. Task pool 13 may lock task 22 while task 22 is waiting for the completion of another task 22 on which it depends. Once task 22 is locked, it cannot be acquired by the cell. When the task 22 of the thread 21 is completed, the task pool 13 may notify the CPU 11 of the completion. The CPU may then proceed beyond the completed thread 21.

The cells advantageously maintain solidarity with each other and with the CPU 11, so that the system 10 autonomously and proactively reads tasks from the task pool 13 to perform complex calculations. Be useful. The cells 12 act autonomously in that they may act independently of the CPU 11 or any other coprocessor. Alternatively, the cell may act on or be commanded directly by the CPU. Each cell acts proactively in that it seeks task 22 from task pool 13 as soon as the cell is available for further processing.

More specifically, in one embodiment, the cell 12 sends an agent 30, queries (searches) a task pool, requests completion, is unlocked, and has a task type that can be performed by the cell. A task is obtained from the task pool by reading the possible tasks 22. Typically, system 10 has as many agents as there are joint co-processing cells. In this context, an agent is generally similar to a data frame in the sense of the network in that the agent may comprise a source address, a destination address and a payload. In one embodiment, the destination address is the address of the task pool 13 when the agent 30 is seeking the task 22, and the destination address corresponds when the agent 30 is returning to its cell with the task 22. This is the address of the cell 12. Correspondingly, the source address is the address of the cell 12 when the agent 30 is seeking the task 22, and the source address of the task pool 13 when the agent 30 is returning to that cell with the task 22. Address.

In addition, the source and destination addresses can facilitate frame synchronization. That is, the system 10 may be configured to clearly distinguish the address from the payload data, so that when the content of the agent 30 is read, the destination address indicates the beginning of the frame and the source address indicates the frame. Indicates end and vice versa. This allows the payload to vary in size when placed between addresses. In another embodiment of a variable size payload, the agent 30 may include a header that indicates the payload size. The header information may be compared with the payload to verify data integrity. In yet another embodiment, the payload may be fixed length. When the agent 30 is dispatched by its coprocessor cell to the task pool 13, the payload contains identification of the type of task that the cell 12 may perform. When the agent 30 returns from the task pool 13, the payload contains the descriptor for the task 22, either in the form of a memory location or a complete descriptor data structure.

In other embodiments, some or all of agents 30 are autonomous representatives of their respective corresponding cells 12. That is, each agent 30 may read task 22 whenever dispatched by its corresponding cell 12 and the cell is idle or capable of performing additional processing. In this way, the processing capacity of the joint cell 12 can be more fully utilized unless the cell has to idle and wait for commands from the CPU 11. This approach also has the additional benefit of reducing CPU overhead by freeing the CPU from having to send a request to the cell to read the task from the task pool. These advantages make system 10 more efficient than traditional computer architectures where auxiliary modules and coprocessors rely on instructions from the main CPU.

Moreover, the solidarity cells 12A-12n are ambiguous with respect to the particular composition of the thread itself. Rather, the agent is only involved in finding a match between the capabilities of its corresponding cell and the available tasks 22 in the task pool 13 to be completed. That is, as long as there are available tasks 22 in the task pool 13 and the available tasks 22 match the capacity of the cell, the present system can effectively use the processing capacity of the cell.

Some or all of the joint cells 12A-12n may function independently of each other, or may communicate directly with each other, either through the switching fabric 14, through the task pool 13, or according to commands or requests from the CPU. May be invoked to assist in processing, moving, or transmitting data. In one embodiment, agent 30A may search for a match between the task type of ready task 22 and the types of tasks cell 12A is capable of performing. The architecture may involve hard coding of the type of task the CPU 11 is configured to generate. Thus, if the task pool 13 contains three types of tasks 22 and the large computational requirement includes a fourth type of task, this fourth type of task implements the fourth type of task. Even if possible cells are included in or added to the system 10, they may not be placed in the task pool 13. As a result, the CPU 11 may be configured to "learn" or be taught how to generate a fourth type of task in order to more fully utilize the available processing resources.

In another embodiment, the agent 30A searches for a task 22 descriptor for an executable instruction that matches one of the instructions that the cell 12A can implement. Once the match task 22 is found, the agent 30A delivers the match task 22 descriptor to the cell 12A, after which the cell 12A begins processing the task 22. In particular, agent 30A may deliver the memory address of the descriptor to cell 12A, which reads the data structure from memory. Alternatively, if the descriptor's entire data structure is contained within task 22, agent 30A may deliver the complete data structure to cell 12A for processing. The descriptor tells the cell 12A which instruction to execute, where in the memory unit 15 the data to be processed can be found, and where in the memory 15 the result should be placed. Upon completion of the task 22, the cell 12A notifies the task pool 13 to change the status of the selected task 22 from “should be completed” to “completed”. Further, once cell 12A completes task 22, the cell may dispatch its agent 30A to task pool 13 to explore another task 22.

Some or all of the agents 30A-30n may be, for example, a Wi-Fi network, a wireless Ethernet, a wireless USB, a wireless bridge, a wireless relay device, a wireless router, depending on the particular architecture and/or implementation of the system 10. Zigbee(R), ANT+(R), or Bluetooth(R) pairing may be used to proceed through the system 10 in a wired or wireless manner. In some embodiments, the agent 30 may be wirelessly directed to the task pool 13 by including a receptor feature in the task pool 13 and further by including a transmitter feature in the cell 12. Similarly, a task pool may wirelessly respond to a cell by providing the task pool with a transmitter and the joint cell with a receiver. In this manner, cells can communicate wirelessly with the task pool with or without the use of switching fabrics.

However, in the preferred embodiment, some form of switching fabric 14 is used. The switching fabric 14 facilitates connections for data transfer and arbitration between system resources. The switching fabric 14 may be a router or crossbar switch that provides connectivity between various cells and task pools. The switching fabric 14 further includes each solid state cell 12A-12n, CPU 11, memory unit 15, and, but not limited to, direct memory access units, transmitters, hard disks and their controllers, displays and other input/output devices, and Connectivity may be provided to and from system resources, such as traditional system components, including other coprocessors. The cells 12A-12n may be physically connected to the switching fabric 14, or the cells may be wirelessly connected.

The wireless connection of cells to system 10 facilitates the dynamic addition and/or removal of cells for use within system 10. For example, the CPU 11 may replenish cells from other cell systems to allow dynamic expansion and performance improvements. In this manner, two or more cell systems (eg, networks) may share a joint cell. In one embodiment, the idle cell has a need for additional processing resources, ie, has available processing tasks that need to be completed, and seeks and/or is replenished by another system. May be done. Similarly, system 10 may scale performance by incorporating additional clusters of cells for particular tasks. For example, system 10 may enhance the performance of encryption/decryption functions, or processing of audio and/or video data, by incorporating neighbor cells that are capable of performing these tasks.

To prevent undesired connections, the CPU 11 may also provide the task pool 13 with trusted and/or untrusted cells, as well as a list of authentication requirements or protocols, or alternatively criteria for identifying them. Good. Further, the task pool itself may exclude certain cells based on low performance, unreliable connections, poor data throughput, or suspected malicious or otherwise inappropriate activity. .. In various embodiments, cells 12 may be added to or removed from task pool 13 by the user through the use of smartphones, tablets, or other devices or applications. In one embodiment, the graphical application interface provides useful statistics and/or icon information such as locations of available cells and other devices, performance enhancements, or performance penalties as a result of adding or removing particular cells from the network. It may be provided to the user.

In alternative embodiments, some or all of the co-processing cells may be directly connected to the task pool 13, such as by a wired configuration that does not require the switching fabric 14 for communication. The wired connection of the cells further facilitates dynamic expansion and contraction of the system 10 similar to the wireless configuration discussed above, although the wired connection may be physical (eg, manual) integration and extraction of peripheral devices. May be. In any case, the scalability of the present system is greatly enhanced over conventional parallel processing schemes, as coprocessors can be added and removed without reprogramming the CPU 11 to account for changes in the system 10. ..

Referring now to FIG. 3, the network 300 is configured to perform (execute) a CPU 302, a first memory 304, a second memory 306, a task pool 308, a switching fabric 310, and a type A task. A first co-processing cell 312 configured, a second cell 314 configured to perform a Type B task, a third cell 316 configured to perform a Type C task, and a type A And a fourth cell 318 configured to perform both Type B tasks. As shown, task pool 308 populates task type A tasks (or task threads) 330 and 332 (eg, by CPU 302), task type B tasks 334 and 336, and task type C tasks 340 and 342. To be done. In some embodiments, each cell preferably has a unique dedicated agent. In particular, cell 312 includes agent 320, cell 314 includes agent 322, cell 316 includes agent 324, and cell 318 includes agent 326. Each agent preferably includes an information field or header that identifies the type of task that its associated cell is configured to perform, eg, a single task or a combination of tasks A, B, C.

During operation, when a cell is either idle or otherwise has available processing capacity, its agent proactively queries the task pool and any that are appropriate for that particular cell. Determines whether the task is in the task queue. For example, cell 312 may dispatch its agent 320 and read one or both of tasks 330 and 332 corresponding to task type A. Similarly, cell 314 may dispatch its agent 322 and read either task 334 or 336 (depending on their relative priority) corresponding to task type B, and so on. For cells that are capable of performing more than one task type, such as cell 318 that is configured to perform task types A and B, agent 326 may include tasks 330, 332, 334, and/or 336. Any one of them may be read.

Upon reading a task from the task pool, the cell then typically reads data from a particular location in the first memory 304, processes the data, and processes the processed data in the second memory 306. The task may be handled by storing it in a specific location in the. When the task is completed, the cell notifies the task pool, the task pool marks the task as completed, and the task pool notifies the CPU that the task is completed. Alternatively, the task pool may notify the CPU when a task thread completes, as long as the task thread can include a single task, a series of tasks, or a Boolean combination of tasks. Significantly, reading tasks and processing data by cells can occur without direct communication between the CPU and the various cells.

Referring now to FIG. 4, an Internet of Things network 400 includes a controller (CPU) 402, a task pool 408, and various devices 410-422, some or all of which embody processing capacity. , Associated or embedded microcontrollers such as integrated circuit (IC) chips or other components. As a non-limiting example, the device can interface with a light bulb 410, a thermostat 412, an electrical receptacle 414, a power switch 416, an appliance (eg, toaster) 418, a vehicle 420, a keyboard 422, and a network. It may include virtually any other Plug and Play device or application.

In the illustrated embodiment, the controller 402 may include a display 404 and a user interface (eg, keypad) 406 to facilitate user interaction with various devices on a smartphone, tablet, laptop, or network. It may be another device. To the extent that the processing capacity (eg, bandwidth) of the controller 402 may be insufficient to properly support the network, the controller may be configured from peripheral devices, eg, as described below in conjunction with FIG. Through the task pool, processing resources may be effectively harvested or replenished.

Referring now to FIG. 5, a use case for the Internet of Things network 500 illustrates the dynamic utilization of nearby (or otherwise available) devices. The network 500 includes a main control unit 502 (eg, laptop, tablet, or gaming device), a task pool 504, a first coprocessor device 506, and a second coprocessor device 508. Exemplary use cases in the context of network 500 are described herein.

Suppose a user is playing a video game on his laptop computer 502. Video games require detailed computer-generated images, and perhaps the processing power on laptop 502 is sufficient to render a single photorealistic character, but a second character is introduced on the screen. If so, the image quality is degraded and the character movement is no longer continuous. The present invention proposes a method of utilizing the processing power of underutilized computer resources that are located in the vicinity of the user or otherwise available to the user.

To address the need for additional processing power, laptop 502 connects to task pool 504. In this regard, the laptop itself may comprise a task pool, or the task pool may be in the form of an external device or application located within wireless range from laptop 502. In the case of an external task pool, the task pool itself may act as a switching fabric with ports, allowing connections to multiple co-processing cells. The laptop 502 submits the computationally intensive task to the task pool 504. Nearby underutilized devices, such as smartphones 508, continue to connect to task pool 504 and send their agents to fetch matching task types. As a result, smartphone 508 becomes a coprocessor that seamlessly assists laptop 502, thereby enhancing the video game experience. The same method may be repeated when other under-utilized processing resources exist and are needed. In fact, even the available light bulb 506 processing power can be a coprocessor to a laptop.

FIG. 6 is a flow chart illustrating the operation of an exemplary parallel computing environment. In particular, method 600 includes the steps of submitting a task to a task pool (step 602) and dispatching one or more agents proactively to the task pool from one or more corresponding cells (step 602). 604), reading and processing the task (step 606), and notifying the task pool and the CPU that the task thread has been performed (step 608). Method 600 further includes dynamically incorporating additional devices into the network (step 610), if desired.

Therefore, a task pool, a controller configured to submit the first task to the task pool, and a first coprocessor configured to proactively read the first task from the task pool. A processing system including is provided.

In certain embodiments, the first coprocessor comprises a first agent configured to read the first task from the task pool without communicating with the controller.

In an embodiment, the first task includes a first task type indicia, the first coprocessor is configured to perform the first type of task, and the first agent is configured to perform the first task. Configured to search the task pool for tasks of this type.

In certain embodiments, the first coprocessor is further configured to process the first one and notify the task pool upon completion of the first task, the task pool of the first task. Configured to notify the controller upon completion.

In some embodiments, the controller and the first coprocessor are configured to communicate with each other only through the task pool.

In one embodiment, the controller and the first coprocessor are configured to communicate with each other directly through the task pool.

In one embodiment, the first coprocessor is configured to determine that it has available processing capacity and dispatch the agent to the task pool in response to the determination.

In an embodiment, the controller is further configured to submit the second task to the task pool, and the system is further configured to secondarily read the second task from the task pool. With a second coprocessor.

In some embodiments, the second task includes a second task type indicia, the second coprocessor is configured to perform the second type of task, and the second agent is configured to perform the second task. Configured to search the task pool for tasks of this type.

In some embodiments, the controller and task pool reside on a monolithic integrated circuit (IC) and the first coprocessor does not reside on the IC.

In another embodiment, the controller, task pool, and first and second coprocessors reside on a monolithic integrated circuit (IC).

A method for dynamically controlling processing resources in a network of a type including a central processing unit (CPU), configured to submit a first task having a first task type to a task pool is also provided. It The method comprises the steps of programming a first cell to perform a first task type, adding the programmed first cell to a network, and from the first cell to a task pool. Sending the agent in advance, retrieving the task pool by the first agent for tasks of the first type, and retrieving the first task from the task pool by the first agent, Transporting a first task by a first agent to a first cell; processing a first task by a first cell; and sending a first task from the first cell to a task pool, Sending a notification that the task has been completed.

In an embodiment, the method also includes marking the first task as completed by the task pool and sending a notification from the task pool to the CPU that the first task is complete. Including.

In an embodiment, the method also uses the first cell as a predicate to proactively send the first agent to the task pool to determine that the first cell has available processing capacity. Including configuring steps.

In certain embodiments, the method also includes integrating the first cell into the first device prior to adding the programmed first cell to the network.

In some embodiments, the first device comprises one of a sensor, light bulb, power switch, appliance, biometric device, medical device, diagnostic device, laptop, tablet, smartphone, motor controller, and security device. Including.

In one embodiment, adding the programmed first cell to the network comprises establishing a communication link between the first cell and the task pool.

In an embodiment, the (CPU) is further configured to submit a second task to the task pool having a second task type, the method further comprising: performing the second task type. Programming the second cell, establishing a communication link between the second cell and the task pool, and proactively sending a second agent from the second cell to the task pool; Retrieving a task pool for a second type of task by a second agent, retrieving a second task from the task pool by a second agent, and retrieving a second cell by a second agent. Transporting the second task, processing the second task by the second cell, sending a notification from the second cell to the task pool that the second task has been completed, The task pool includes marking the second task as complete and sending from the task pool to the CPU a notification that the second task is complete.

A system for controlling distributed processing resources within an Internet of Things (IoT) computing environment is also provided, configured to partition aggregate computing requirements into multiple tasks and place the tasks in a pool. A CPU and a plurality of devices each having a unique dedicated agent configured to proactively read tasks from the pool without direct communication with the CPU.

While the description, which allows for various embodiments, including the best mode known to the inventor, has been illustrated, various changes and modifications may be made and equivalents without departing from the scope of the invention. It will be appreciated by those skilled in the art that can be substituted for various elements. Accordingly, the invention disclosed herein is not limited to the particular embodiments disclosed, the invention including all embodiments falling within the literal and equivalent scope of the appended claims. Is intended to be.

Claims (10)

A device for parallel processing of large scale computing requirements, said device comprising:
A central processing unit (“CPU”),
A task pool in electronic communication with the CPU,
A first joint cell in electronic communication with the task pool, the first joint cell performing a matching task processed by the joint cell from the task pool without requiring an instruction from the CPU. A first solidarity cell, comprising a first agent configured to read ahead,
The CPU submits to the task pool by dividing the requirement into one or more threads and placing the threads in the task pool, each thread comprising one or more tasks, The matching task is one of the above tasks,
Each task comprises a descriptor, said descriptor
The function to be performed,
At least a memory location of data on which the function should be performed,
The first agent is a data frame comprising a source address, a destination address and a payload,
The first agent is
The first agent is dispatched to the task pool by the first joint cell, during which the source address is the address of the first joint cell and the destination address is the An address of a task pool, the payload comprising a list of functions that the first joint cell is configured to perform, and
The first agent searching the task pool for a task that is in a state that can be processed and that has a function that the first joint cell can perform;
The first agent returning to the first joint cell, during which the source address is the task pool address and the destination address is the first joint cell address. The payload comprises the descriptor of the matching task, thereby reading the matching task. The device according to claim 1, wherein the task pool notifies the CPU when a task of the thread is completed. The tasks each include a task type selected from a set of task types, and the first joint cell is configured to perform one or more tasks of the task types. The apparatus according to Item 1. 4. The apparatus of claim 3, wherein the matching task is a task that is in a state that can be processed and that has a task type that the first joint cell is capable of performing. A task pool,
A controller configured to submit a plurality of first tasks and a plurality of second tasks to the task pool,
A first coprocessor, the first coprocessor continuously reading a first task from the task pool without any communication between the first coprocessor and the controller. A first coprocessor configured to process the first task, generate first result data, and update the task pool to reflect completion of the first task;
A second coprocessor, wherein the second coprocessor continuously reads the second task from the task pool without any communication between the second coprocessor and the controller. A second coprocessor configured to process the second task, generate second result data, and update the task pool to reflect completion of the second task. A processing system comprising:
The processing system dynamically accepts the first coprocessor, the second coprocessor, and additional coprocessors on a plug and play basis into the processing system without communicating with the controller. Processing system configured as. The first task includes a first task type indicia, the first coprocessor is configured to perform the first type task, and the first agent is configured to perform the first task. Configured to search the task pool for a type of task,
The second task includes a second task type indicia, the second coprocessor is configured to perform the second type of task, and the second agent is configured to perform the second task. The processing system of claim 5, wherein the processing system is configured to search the task pool for a type of task. The first coprocessor is configured to determine when it has available processing capacity and, in response to the determination, dispatch the first agent to the task pool. Item 7. The processing system according to Item 6. 7. The processing system of claim 6, wherein the controller and the task pool reside on a monolithic integrated circuit (IC) and the first coprocessor and the second coprocessor do not reside on the IC. The processing system of claim 6, wherein the controller, the task pool, and the first coprocessor and the second coprocessor reside on a monolithic integrated circuit (IC). A first device associated with the first coprocessor;
A second device associated with the second coprocessor,
The first device and the second device are a sensor, a light bulb, a power switch, an electric appliance, a biometric device, a medical device, a diagnostic device, a laptop, a tablet, a smartphone, a motor controller, and a security device, respectively. 7. The processing system of claim 6, including one of: