Systems and methods for benchmarking distributed and / or multiprocessor computational processes

Abstract

The systems and methods for benchmarking runtime performance of distributed and / or multiprocessor computational processes involve receiving a logical representation of a plurality of computational tasks with a plurality of dependencies therebetween. One or more customized kernels are received to process one or more computational tasks of the plurality of computational tasks. One or more runtime optimization parameters are received. A machine-implementation is generated with the logical representation, the customized kernel (s), and the runtime optimization parameter (s). The machine-implementation is deployed to a computational platform having two or more computational nodes. The machine-implementation is executed on the computational platform according to the runtime optimization parameter (s) and one or more performance metrics are collected from the computational platform.

Description

SYSTEMS AND METHODS FOR BENCHMARKING DISTRIBUTED AND / OR MULTIPROCESSOR COMPUTATIONAL PROCESSESTECHNICAL FIELD

[0001] The description herein relates generally to benchmarking performance of software or hardware systems. More particularly, the description relates to systems and methods for benchmarking runtime performance of distributed and / or multiprocessor computational processes particularly in artificial intelligence engines, such as large language models (LLMs) .BACKGROUND

[0002] Task benchmarking in a multiprocessor or distributed computing environment is a process for evaluating performance and efficiency of various tasks or algorithms. This involves running a set of predefined tasks under controlled conditions and measuring performance metrics such as execution time, resource utilization, and throughput. By systematically analyzing these metrics, developers can identify bottlenecks, optimize task scheduling, and improve overall system performance. Benchmarking provides a quantitative basis for comparing different algorithms or configurations to determine the most effective approaches for specific applications.

[0003] In a multiprocessor environment, task benchmarking focuses on how well tasks are distributed across multiple processors and how efficiently these processors are utilized. This includes assessing the load balancing among processors, the overhead of task communication and synchronization, and the impact of different scheduling algorithms.

[0004] In a distributed computing environment, task benchmarking considers the performance implications of network communication between nodes. This includes measuring latency and bandwidth of data transfers, reliability of communication protocols, and scalability of the system as more nodes are added. Benchmarking in this context identifies the optimal configuration for distributing tasks across a network of computers.SUMMARY

[0005] Any and / or all aspects as described herein in any and / or all combinations are provided.

[0006] The aspects herein may support developer-specified task graph definitions that enable developers to create and benchmark custom task graphs that accurately represent dependencies and / or execution flow of the applications. The aspects herein may enable the developer to create and benchmark task graphs having dependencies on nodes that are more than one-step behind and / or dependencies on one or more nodes. The aspects herein may support developer-specified computational kernels thereby resolving any mismatch between expected behavior of the applications and the non-customizable computational kernels typically used in benchmarking systems. The aspects herein may provide an automated or semi-automated benchmarking process, such as automating workload adjustments, data collection, and / or result plotting. The aspects herein may provide intuitive visualization of the performance data thereby enabling developers to identify bottlenecks and / or inefficiencies in the applications.

[0007] According to an aspect, there is provided a computer-implemented method for benchmarking a multiprocessor or distributed runtime environment. The computer-implemented method may comprise: receiving a logical representation of a plurality of computational tasks with a plurality of dependencies therebetween; receiving at least one customized kernel to process at least one computational task of the plurality of computational tasks; receiving at least one runtime optimization parameter; converting the logical representation, the at least one customized kernel, and the at least one runtime optimization parameter to a machine-implementation; deploying the machine-implementation to a computational platform having at least two computational nodes; executing the machine-implementation on the computational platform according to the at least one runtime optimization parameter; and collecting at least one performance metric from the computational platform. The computer-implemented method may further comprise generating the logical representation and the plurality of dependencies with a graph builder. The computer-implemented method may further comprise customizing the at least one customized kernel with a kernel editor. The computer-implemented method may further comprise selecting the at least one runtime optimization parameter with a runtime optimization interface. The at least one runtime optimization parameter may be selected from a scheduling policy, an affinity, and a task placement. The computer-implemented method may further comprise verifying the at least one customized kernel satisfies at least one condition of the computational platform.

[0008] According to another aspect, the computer-implemented method may further comprise rendering a visualization of the at least one performance metric. The at least one performance metric may be a data movement between the at least two computational nodes of the computational platform. The visualization of the data movement between the at least two computational nodes of the computational platform may comprise a conical representation. The conical representation may have an axis representing a data transfer velocity and a circumference representing the at least two computational nodes.

[0009] According to yet another aspect, there is provided a system comprising: a processor executing a plurality of instructions from a computer-readable memory. The instructions may configure the processor to: receive a logical representation of a plurality of computational tasks with a plurality of dependencies therebetween; receiving at least one customized kernel to process at least one computational task of the plurality of computational tasks; receive at least one runtime optimization parameter; convert the logical representation, the at least one customized kernel, and the at least one runtime optimization parameter to a machine-implementation; deploy the machine-implementation to a computational platform having at least two computational nodes; execute the machine-implementation on the computational platform according to the at least one runtime optimization parameter; and collect at least one performance metric from the computational platform.

[0010] The instructions may further configure the processor to: generate the logical representation and the plurality of dependencies with a graph builder. The instructions may further configure the processor to: customize the at least one customized kernel with a kernel editor. The instructions may further configure the processor to: select the at least one runtime optimization parameter with a runtime optimization interface. The at least one runtime optimization parameter may be selected from a scheduling policy, an affinity, and a task placement. The instructions may further configure the processor to: verify the at least one customized kernel satisfies at least one condition of the computational platform.

[0011] According to another aspect, the instructions may further configure the processor to: visualize the at least one performance metric. The at least one performance metric may be a data movement between the at least two computational nodes of the computational platform. A visual representation of the data movement between the at least two computational nodes of the computational platform may comprise a conical representation. The conical representation may have an axis representing a data transfer velocity and a circumference representing the at least two computational nodes.

[0012] According to an aspect, there is provided a device comprising a processor executing a plurality of instructions from a computer-readable memory, the instructions to configure the processor to perform any of the methods described herein.

[0013] According to an aspect, there is provided a computer-readable medium (or computer program product) storing computer-executable instructions that, when executed by one or more processors, cause the one or more processors to perform any of the methods described herein.

[0014] In another aspect, embodiments of this disclosure provide a non-transitory computer-readable medium storing instruction the instructions causing a processor in a device to implement any of the methods disclosed herein.

[0015] In another aspect, embodiments of this disclosure provide a processor, configured to execute instructions to cause a device to perform any of the methods disclosed herein.

[0016] In another aspect, embodiments of this disclosure provide an integrated circuit configure to perform any of the methods disclosed herein.

[0017] According to one aspect of this disclosure, there is provided a module comprising: one or more circuits for performing any of the methods disclosed herein.

[0018] According to one aspect of this disclosure, there is provided an apparatus comprising: one or more processors functionally connected to one or more memories for performing any of the methods disclosed herein.

[0019] According to one aspect of this disclosure, there is provided an apparatus configured to perform any of the methods disclosed herein.

[0020] In some embodiments the apparatus comprises one or more units configured to perform the above-described method.

[0021] According to one aspect of this disclosure, there is provided one or more non-transitory, computer-readable storage media comprising computer-executable instructions, wherein the instructions, when executed, cause at least one processing unit, at least one processor, or at least one circuits to perform any of the methods disclosed herein.

[0022] According to one aspect of this disclosure, there is provided one or more computer-readable storage media storing a computer program, wherein, when the computer program is executed by an apparatus, the apparatus is enabled to implement any of the methods disclosed herein.

[0023] According to one aspect of this disclosure, there is provided a computer program product including one or more instructions, wherein, when the instructions are executed by an apparatus, the apparatus is enabled to implement any of the methods disclosed herein.

[0024] According to one aspect of this disclosure, there is provided a computer program, wherein, when the computer program is executed by a computer, an apparatus is enabled to implement any of the methods disclosed herein.

[0025] According to one aspect of this disclosure, there is provided a system comprising a node for performing any of the methods disclosed herein.BRIEF DESCRIPTION OF THE DRAWINGS

[0026] The aspects will now be described, by way of example, with reference to the attached Figures, wherein:

[0027] Figure 1A is a block diagram of a computing structure;

[0028] Figure 1B is a block diagram of a process stack executing on the computing structure;

[0029] Figure 2 is a block diagram of a distributed and / or multiprocessor computational platform;

[0030] Figure 3 illustrates a block diagram of a benchmarking system;

[0031] Figure 4 illustrates a user interface for a benchmarking process;

[0032] Figure 5 is a block diagram of a benchmarking engine;

[0033] Figures 6A and 6B illustrate example task graphs processed as described herein and limitations of another benchmarking engine to process the example task graph respectively;

[0034] Figure 7 is a block diagram demonstrating a runtime benchmarking workflow; and

[0035] Figure 8 is a graphical representation of a performance metric.DETAILED DESCRIPTION

[0036] Distributed and / or multiprocessor computational processes are becoming increasingly complex and the variety of runtimes and programming models available to developers continues to increase. For example, some of the runtimes may include, but are not limited to, Message Passing Interface (MPI) , Open Multi-Processing (OpenMP) , Compute Unified Device Architecture (CUDA) , Open Computing Language (OpenCL) , Legion, Charm++, and High-Performance ParalleX (HPX) . These runtimes offer distinct paradigms, abstractions, and / or optimizations to leverage multi-core processors, graphical processing units (GPUs) and / or distributed systems effectively.

[0037] The abundance of these runtimes presents a challenge in selecting a suitable runtime for a given application workload. The suitability may depend on the nature of the workload, such as whether the workload is compute bound, memory bound, input / output (I / O) bound and / or involves complex communication patterns. One or more characteristics of a runtime (e.g., scheduling policies) may affect a computational process’s efficiency, scalability, and / or resource utilization. Selecting an optimal runtime and / or runtime configuration may affect the performance and / or cost-effectiveness for parallel and / or distributed applications. Even once a runtime has been selected, continuously optimizing the computational processes may involve significant time and effort to profile the computational processes, tune runtime parameters, and / or modify kernel code to harness the full potential of the selected runtime.

[0038] Benchmarking software is a tool that enables developers to conduct performance tests and collect data for analysis. Benchmarking refers to the process of using such tools to collect data for a specific process, program, or the like. Benchmarking tools may be a solution to navigate the complex landscape of parallel runtimes and programming models. The benchmarking tools may provide empirical performance data that can guide decision-making in selecting the runtime for a given application workload. By systematically measuring and comparing the performance of different runtimes under various conditions, benchmarking tools may provide insights into the performance by offering quantitative data on how different runtimes perform with specific workloads. The benchmarking tools may enable side-by-side comparisons of runtimes thereby simplifying identifying which runtime provides the best performance for a particular task.

[0039] For example, of a benchmarking tool is TaskBench. The TaskBench tool has been described in in Slaughter et al. ; “Task bench: a parameterized benchmark for evaluating parallel runtime performance. ” In Proceedings of the International Conference for High Performance Computing, Networking, Storage and Analysis (SC '20) . IEEE Press, Article 62, 1–15 (https:  / / arxiv. org / abs / 1908.05790v2) as well as in Shen et al. ; “TaskBench: Benchmarking Large Language Models for Task Automation. ” Nov 30, 2023 (https:  / / doi. org / 10.48550 / arXiv. 2311.18760) , both of which are incorporated herein by reference in their entirety. However, TaskBench has several disadvantages that limit its effectiveness for developers seeking to optimize performance for specific applications including, lack of support of customized graphs, limited kernel options, no support for runtime configuration optimization and insufficient information to determine which runtime is best suited for a developers applications. For these reasons, TaskBench is not convenient for application developers to select, for example, the best runtime for specific applications and the best runtime configuration for those applications.

[0040] . Technical drawbacks in existing parallel runtime benchmarking tools, such as TaskBench, may hinder developers from effectively optimizing their applications and selecting the suitable runtime and configuration for their specific needs. The technical problems may include: (a) Inability to benchmark customized task graphs: Existing benchmarking tools only support predefined task graphs with restricted dependency patterns. Hence, developers cannot model and benchmark their applications’ unique and complex task graphs, which typically include intricate dependency patterns; (b) Lack of support for developer-specified computational kernels: Current benchmarking tools provide a limited set of non-customizable kernels, such as basic compute or memory bound operations. Consequently, developers are unable to benchmark their actual computational kernels, creating a mismatch between the benchmark setup and the expected application behavior. This mismatch may ultimately lead to an inaccurate representation of the application’s execution profile; (c) No support for runtime configuration optimization: Existing tools do not support the exploration and benchmarking of different configurations within a runtime (e.g., varying scheduling policies) . Therefore, developers may miss optimization opportunities because they cannot assess how different in-runtime configurations impact the performance; and (d) User-unfriendly and insight-limited benchmarking experience: Existing tools require manual adjustments and scripting because the raw output from these tool does not provide immediate insights. This lack of automation, aggregation and visualization hinders benchmarking efforts, making them time-consuming and inefficient for developers to optimize their applications effectively.

[0041] As described herein, referring to FIG. 3, a benchmarking system 300 may provide a comprehensive benchmarking platform. The benchmarking system 300 may support developer-specified task graph definitions 316 that enable developers 302 to create and benchmark custom task graphs that accurately represent dependencies and / or execution flow of the applications 156a…n. Dependencies may be task dependencies when one task relies on the output or completion of another task before it can start; data dependencies involving sharing of data between tasks; resource dependencies when tasks access the same resources, such as memory, processors, or I / O devices; and / or communication dependencies where tasks communicate with each other over a network.

[0042] In some aspects, the task graph definitions 316 of the benchmarking system 300 may enable the developer 302 to create and benchmark task graphs having dependencies on nodes that are more than one-step behind and / or dependencies on one or more nodes. The benchmarking system 300 may support developer-specified computational kernels 318 (e.g. a customized kernel where the developer has altered the instructions performed from a standard kernel to improve performance, provide special features, etc. ) thereby resolving any mismatch between expected behavior of the applications 156a…n and the non-customizable computational kernels typically used in benchmarking systems. The benchmarking system 300 may provide support for one or more runtime optimization parameters, such as varying scheduling policies, affinity, scheduling policy, and / or task placement strategies. The benchmarking system 300 may provide an automated or semi-automated benchmarking process, such as automating workload adjustments, data collection, and / or result plotting. The data collection may collect a wide range of performance metrics, such as resource utilization and / or data movement statistics. The benchmarking system 300 may provide intuitive visualization of the performance data thereby enabling developers 302 to identify bottlenecks and / or inefficiencies in the applications 156a…n.

[0043] With reference to FIG. 1A, a computing structure 100 (e.g. a computing device) may comprise one or more processors 102 retrieving and executing one or more instructions from memory 104 (e.g. non-transitory computer-readable medium) and / or processing data. The processor 102 may be a single-core processor, a multi-core processor, digital signal processor, etc. The processor 102 may comprise an arithmetic logic unit (ALU) , which performs arithmetic and logical operations, and a control unit (CU) , which directs the operation of the processor 102 by fetching, decoding, and executing instructions. The processor 102 may have one or more registers for temporarily holding data and instructions during processing. The processor 102 may have multiple levels of cache memory 104 (e.g. L1, L2, and / or L3) to store frequently accessed data. The instructions of executed by the processor 102 may be performed based on a clock.

[0044] The memory 104 may be configured to store at least a part of the corresponding computer program instructions and / or data. In an example, the one or more processors 102 execute the computer program instructions stored in the memory 104 to implement related operations (for example, inputting, outputting, receiving, and / or transmitting) in the methods disclosed herein. In some implementations, the memory 104 may be configured to store the corresponding computer program instructions and / or data may mean that the memory 104 may be configured to store all the corresponding computer program instructions and / or data for execution by the one or more processors 102. In some aspects, the memory 104 may be configured to store the corresponding computer program instructions and / or data may mean that the memory 104 may be configured to store a part of the corresponding computer program instructions and / or data. For example, the part of the corresponding computer program instructions and / or data may include computer program instructions and / or data that are being currently executed by the one or more processors 102. Thus, the memory 104 may store different parts of computer program instructions and / or data for a plurality of times for the one or more processors 102 to perform related operations in the methods disclosed herein.

[0045] The processor 102 may retrieve and / or store data to a storage 110, such as a hard drive, solid-state drive, etc. The processor 102 may prepare the data by converting the data into a suitable format and organizing the data into blocks or sectors. The processor 102 executes instructions to initiate a data transfer, temporarily holding the data in a buffer to manage a speed difference between the processor 102 and the storage 110. The processor 102 may communicate with the storage 110 through an interface, such as SATA or NVMe, facilitating the data transfer. A storage controller (not shown to improve clarity of drawing) manages a writing process, placing the data on a storage medium and performing verification steps to ensure accuracy. Once the data is successfully written and verified, the storage controller sends a completion signal back to the processor 102, indicating the operation is complete. Generally, retrieval of the data from the storage 110 involves a reverse process of reading the blocks from the storage 110 into the buffer and subsequently into the memory 104.

[0046] The processor 102 may communicate using a transceiver 108 over a network 120 to other computing structures 100. The processor 102 may organize the data into packets according to a network protocol, such as TCP / IP. The processor 102 may encapsulate each packet with headers governing a transmission of the packet over the network. For example, the headers may contain a source address, a destination address, error-checking codes, and / or sequencing details. The processor 102 may sends these packets to the transceiver 108, such as a network interface controller (NIC) , which handles a physical transmission of the packets over a network medium, such as Ethernet,  and / or Wi-Fi. The transceiver 108 may convert the data packets into an electrical signal, an optical signal, and / or a radio signal and transmit the signals over the network. When the transceiver 108 receives the signals, the transceiver 108 converts the signals into the packets, reorders the packets into their original order, extracts the data, and may verify the data using the error-checking codes. The transceiver 108 may provide the data to the processor 102 for processing.

[0047] In some aspects, the transceivers 108 may be wired or wireless. In the wireless aspects, the transceivers 108 may be coupled to one or more antennas. For clarity, no antennas are illustrated. In some implementations, the transceivers 108 may be separate transmitters and receivers. The transceivers 108 may be configured to modulate data or other content for transmission by one or more antennas, the NIC, or the bus. The transceivers 108 may also be configured to demodulate data or other content received by the one or more antennas, NIC, and / or bus. A transceiver may include any suitable structure for generating signals for wireless or wired transmission and / or for processing signals received through wireless or wired communication. Each antenna includes any suitable structure for transmitting and / or receiving wireless or wired signals. The transceivers 108 may be configured to process signals and execute one or more communication protocols.

[0048] As a communication interface, the transceivers 108 may be configured to implement communication with another component. For example, the transceivers 108 may communicate a signal with other apparatus / system such as a radio frequency processing apparatus, or processor system. The communication includes transmitting signal (or data, information) to another component or device, or receiving signal from another component or device. “Transmitting” includes outputting the signal to a component or device that is directly or indirectly coupled to the interface circuit (transmitting unit) . “Receiving” includes inputting or obtaining a signal from a component or device that is directly or indirectly couped to the interface circuit (receiving unit) . In some aspects, to reduce the load of the one or more processors 102, a baseband signal processing circuit may be also disposed to implement processing of at least a part of baseband signals, including signal demodulation, modulation, encoding, decoding, or the like.

[0049] The processor 102 may interface with a user with a user interface 106. The user interface 106 may comprise one or more output devices, such as a display, projector, speaker, printer, etc. The user interface 106 may comprise a graphical user interface provided on the display for the user to interact with one or more processes executing on the processor 102. The user interface 106 may comprise one or more input devices, such as a keyboard, a mouse, a touchscreen, a scanner, a microphone, a camera, a game controller, a stylus, etc. The keyboard may be used for typing text, entering commands, etc. The mouse may be used for interacting with graphical elements of the graphical user interface. The touchscreen may enable users to interact directly with the display through contact. The scanner may convert physical documents and / or images into a digital format for processing. The microphone may capture audio input for voice commands, recording, and / or communication. The camera may capture video input, such as gestures, motion, etc. The game controller may be used to provide input through buttons, joysticks, etc. The stylus may provide precise input on the touchscreen. These user interfaces 106 are merely demonstrative and not intended to be an exhaustive list.

[0050] For clarity and to avoid overcrowding the illustration, only one of the transceiver 108, storage 110, processor 102, and memory 104 are illustrated for simplicity, but the computing structure 100 may include one or more other components. In some aspects, the processor 102, the memory 104, the transceiver 108, and the storage 110 may for a single integrated unit that may perform all of these functions.

[0051] Turning to FIG. 1B, a process stack 150 for executing by the computing structure 100 and / or the distributed and / or multiprocessor computational platform 200 may comprise a driver layer 152, an operating system 154, and an application layer 156. As described herein, all or portions of executing processes may be performed by one or more of the layers of the process stack 150. The driver layer 152 may comprise one or more drivers 152a…n that provide an interface for the operating system 154 to issue commands and / or retrieve data from one or more hardware devices. The hardware devices may include firmware to operate and initialize the hardware devices. The operating system 154 (OS) may manage hardware resources and provides a platform for one or more applications 156a…n to run. The operating system 154 may perform memory management, process scheduling, and / or file systems. The operating system 154 may include  etc. In some aspects, the operating system 154 may include common services (not shown for clarity) and / or runtime environments (not shown for clarity) to the application layer 156. The common services may include database management systems, web servers, messaging systems, etc. The runtime environments may include the Java Runtime Environment (JRE) , . NET Framework, etc. The application layer 156 may comprise one or more applications 156a…n for performing specific tasks.

[0052] Turning to FIG. 2, a distributed and / or multiprocessor computational platform 200 may comprise a multiprocessor or distributed layer 202 and a high-bandwidth memory layer 204. The multiprocessor layer 202 may comprise a plurality of graphical processing units 202a…n (GPUs) . Other aspects may have different processors within the multiprocessor layer 202, such as central processing units (CPUs) , field-programmable gate arrays (FPGAs) , application-specific integrated circuits (ASICs) , digital signal processors (DSPs) , and / or tensor processing units (TPUs) . In some aspects, the multiprocessor layer 202 may be a plurality of homogeneous processors. In other aspects, the multiprocessor layer 202 may be a plurality of heterogeneous processors. The computational platform 200 may comprise hardware and / or software components that support execution of applications. In some aspects, the computational platform 200 may include virtual machines or cloud services.

[0053] In this aspect, the GPUs 202a…n may be suitable for computationally intensive applications, such as machine learning, deep learning, scientific simulations, graphics rendering, cryptocurrency mining, data analytics, artificial intelligence, medical imaging, and / or large-scale data analysis. The workload for the application may be distributed across multiple GPUs 202a…n to accelerate processing times and / or handle larger datasets than would be possible with a single GPU 202a…n and / or processor 102 alone. A computational process may be broken into one or more replicas (e.g., computational nodes) and each replica may be executed on a respective GPU 202a…n. A computational node may be a computing unit within a distributed computing system or a multiprocessor computing system. The computational node may include a processor, memory, and network interfaces, enabling the computational node to perform computations and communicate with other nodes. Each node may operate semi-independently but collaborates to achieve a common goal. In some aspects as described herein, the replicas may be customized for a multiprocessor or distributed runtime environment.

[0054] As described herein, a multiprocessor runtime environment refers to a system where multiple processors (or cores) work together within a single computer to execute multiple tasks simultaneously. A distributed runtime environment refers to multiple computers connected over a network, working together to perform tasks.

[0055] Each of the GPUs 202a…n may have a corresponding high-bandwidth memory 204a…n (e.g. HBM, HBM2, GDDR) . Although not depicted in FIG. 3, other computer-readable memories may be available to the GPUs 202a…n. For example, the GPUs 202a…n may have a global memory pool that is accessible by all threads in the GPUs 202a…n. In another example, the GPUs 202a…n may have a shared memory pool that may be shared by threads within the same thread block and may be used for inter-thread communication and storing data to be reused by multiple threads within a block to reduce memory latency. Each of the GPUs 202a…n may have local memory used as a cache for storing temporary variables and registers within the GPUs 202a…n for local variables and intermediate results. In other aspects, the GPUs 202a…n may have access to a texture memory optimized for 2D or 3D texture fetches.

[0056] The GPU memory 204a…n may be configured to store at least a part of corresponding computer program instructions and / or data. In an example, the GPUs 202a…n execute the computer program instructions stored in the memory 204a…n to implement related operations (for example, inputting, outputting, receiving, and transmitting) in the method embodiments disclosed herein. In some implementations, the memory 204a…n may be configured to store the corresponding computer program instructions and / or data may mean that the memory 204a…n is configured to store the entire corresponding computer program instructions and / or data for execution by the one or more GPUs 202a…n. In some implementations, the memory 204a…n may be configured to store the corresponding computer program instructions and / or data may mean that the memory 204a…n is configured to store a part of the corresponding computer program instructions and / or data. For example, the part of the corresponding computer program instructions and / or data may include computer program instructions and / or data that need to be currently executed by the one or more GPUs 202a…n. Thus, the memory 204a…n may store different parts of computer program instructions and / or data for a plurality of times for the one or more GPUs 202a…n to perform related operations in the methods disclosed herein.

[0057] In some aspects, each of the GPUs 202a…n may have a network transceiver (not shown for clarity) for communication over the network 120 with the computing structure 100 as previously described with reference to FIG. 1A. In other aspects, the GPUs 202a…n may communicate directly with the processor 102 via a serial and / or parallel bus. In some aspects, the processor 102 may manage the replicas executing on the GPUs 202a…n as described herein.

[0058] In some aspects, the computational platform 200 may comprise a computing structure 100. The computing structure 100 may be configured to perform management of the computational platform 200, such as network operations, allocating processes to the GPUs 202a…n, configuring one or more parameters of the computational platform 200. The computing structure 100 within the computational platform 200 may include a memory 104 that is configured to store instructions for performing the operations described herein. The memory 104 may also store data that is used, generated, or collected by the processor 102 within the computational platform 200. For example, the memory 104 can store software instructions or modules configured to implement some or all of the functionalities and / or implementations described herein and that which are executed by the processor 102.

[0059] For clarity and to avoid overcrowding the illustration, only one of the transceiver 108, storage 110, processor 102, and memory 104 are illustrated for simplicity, but the computing structure 100 may include one or more other components. Likewise, the illustration of the distributed and / or multiprocessor computational platform 200 is illustrated for simplicity and may omit other components solely for ease of illustration.

[0060] Turning to FIG. 3, a benchmarking system 300 may comprise a benchmark specification interface 310 and an automated benchmarking engine 330. The benchmark specification interface 310 may include one or more development applications 312 executing on the processor 102 of the computing structure 100. The development applications 312 may comprise a user interface 106 displayed on a display to facilitate the developer 302 generating a computational process. The computational process may be applicable to high-performance computing (HPC) and / or distributed computing scenarios where developers 302 may optimize one or more performance metrics of parallel and / or distributed computational applications.

[0061] The computational process may include one or more task graph definitions 316. The task graph definitions 316 may be a logical representation of a plurality of computational tasks and may include one or more computational nodes connected to each other to accomplish the computational process. Each computational node may receive one or more data inputs and provide one or more data outputs to other nodes in the task graph definitions 316. The task graph definitions 316 may implement parallel and / or heterogeneous decomposition strategies. The task graph definitions 316 may represent both regular and / or irregular computational structures and may provide a graphical interface for optimizing performance across multiple processors or GPUs 202a…n.

[0062] The development applications 312 may include a kernel editor 406 for specifying the computational kernels 318 in which the developer 302 may produce kernel code for the computational nodes. The kernel code may process the data inputs to the computational node to produce the data outputs. Those data outputs may become data inputs to other computational nodes as specified by the developer 302 with the task graph definitions 316. In some aspects, the kernel code may have been previously written and stored in a library of kernel code. The developer 302 may select the kernel code from the library for the computational nodes.

[0063] In some aspects, the benchmark specification interface 310 may provide a benchmark configuration interface 320. The benchmark configuration interface 320 may provide a runtime optimization interface 322 for selection of one or more candidate runtimes to benchmark and / or selection of a hardware and / or environment 324. For example, the runtime optimization interface 322 may permit selection of runtimes to benchmark that may be, for example, Open Multi-Processing (OpenMP) , TaskFlow, Legion, Threading Building Blocks (TBB) , Compute Unified Device Architecture (CUDA) , Open Computing Language (OpenCL) , C++ Accelerated Massive Parallelism (C++ AMP) , Python Library for Multithreading and Parallel Computing (KoMPy) , Boost, Open-source Message Passing Interface (OpenMPI) , RaftLib, OmpSs, and / or Standard Template Adaptive Parallel Library (STAPL) . The selection of hardware and / or environment 324 involves a selection of a processor architecture.

[0064] Once the developer 302 provides a benchmark specification 502 comprising the task graph 316, the computational kernels 318, the runtime optimization interface 322, and / or the hardware and environment 324, the automated benchmarking engine 330 may generate, deploy, and benchmark the computational engine based on the benchmark specification 502. The automated benchmarking engine 330 may include a synthesis model 332. The synthesis model 332 may interpret the benchmark specification 502 and generate one or more low-level configuration files 334. The low-level configuration files 334 may be software specifications (e.g., kernel code binaries) and hardware specifications (e.g., cluster node assignments and processor affinity settings) . In some aspects, the synthesis model 332 may compile the kernel code into executable binaries (e.g. a machine-implementation for executing on hardware) optimized for the selected hardware and / or environment 324 and / or create one or more detailed hardware configuration files. The hardware configuration files may specify cluster node assignments, processor affinity settings, and / or other resource allocations (e.g., memory) .

[0065] The automated benchmarking engine 330 may include a deployer 336 that processes the low-level configuration files 334. For example, the deployer 336 may process the hardware specifications to set up a benchmark environment and move the software specifications to one or more of the computational nodes, such as the GPUs 202a…n. The deployer 336 may allocate the computational nodes, apply the processor affinity settings for the computational nodes, and / or ensure the allocated hardware resources align with the specified hardware configuration.

[0066] In some aspects, the deployer 336 may comprise a monitoring component to detect and address any configuration errors. The monitoring component may verify that the compiled kernels and hardware specifications are valid and satisfies conditions of the computational platform 200, such as ensuring there are no oversubscriptions (e.g., requesting more GPUs 202a…n than available) and that the task affinity settings is feasible. The monitoring component may monitor an execution of the evaluator 338 to identify runtime failures, provide early alerts if benchmarks cannot proceed due to incorrect configurations and / or operational issues.

[0067] Once the benchmark environment is prepared by the deployer 336, an evaluator 338 may initiate an execution of one or more benchmarking tasks across all or a portion of the distributed and / or multiprocessor computational platform 200 as previously described. The software specifications, which include the compiled kernel code binaries, may be executed according to the task graph 316 defined by the developer 302. During execution, the evaluator 338 may monitor a performance of the benchmark environment. The performance metrics may include one or more of: execution time (e.g. a total time to run the benchmark task, such as seconds) , a processor utilization (e.g. processor utilization recorded every second as a percentage) , a memory usage (e.g. memory utilization in gigabytes) , data transfer (e.g. number of bytes of data transferred between computational nodes, such as bytes per second) , and / or FLOPS / s (e.g. number of floating point operations per second for each task in the task graph 316) . The evaluator 338 may aggregate one or more of the performance metrics over several executions of the benchmarking tasks (e.g. 100 executions) .

[0068] After the benchmarking tasks are completed, a reporter 340 may generate one or more reports and / or visualizations based on the performance metrics. The reports and / or visualizations may illustrate the performance metrics, data movement patterns, and / or resource utilization across the computational nodes. The benchmark reports may be provided to the development application 312 via a runtime benchmark interface 350. The runtime benchmark interface 350 may provide the benchmark reports and visualizations to enable the developer 302 to understand how the computational process performs with the specified hardware and / or software configurations.

[0069] Turning to FIG. 4, an example of a user interface 400 for the benchmarking process is shown. The user interface 400 may include a graph builder 402 in which the developer 302 may lay out the task graph definitions 316. In some aspects, the graph builder 402 may export or save the task graph definitions 316 as one or more DOT files. The DOT file is a plain text file that describes the task graph definitions 316 in the DOT language. The nodes represent one or more tasks and the edges represent dependencies between the tasks. In some aspects, the user interface 400 may include an interface to upload a DOT file that specifies the task graph definitions 316. The DOT file may have been previously generated using the user interface 400 or may be generated outside of the benchmarking system 300 using the Graphviz software suite, that was originally initiated by AT&T Labs Research and is now an open-source project.

[0070] The user interface 400 may include a kernel editor 406 for the developer 302 to enter kernel code for the computational nodes. In this aspect, the developer 302 has entered three kernels into the kernel editor 406 labelled kernel_1, kernel_2, and kernel_3. Other aspects may have more kernels or less kernels. In this example, the code for all the kernels is entered in the kernel editor 406. Other aspects may have a kernel editor 406 for each of the kernels. The kernels may be associated with one or more nodes in the task graph definitions 316. The developer 302 may save the kernel code by activating a save kernels button 408 and may load the kernel code by activating a load kernels button 410. The loaded kernels may be displayed within the kernel editor 406 enabling the developer 302 to modify the kernel code.

[0071] The user interface 400 may have a runtime optimization interface where the developer 302 may select one or more runtime optimization parameters for one or more runtime environments. The runtime environments may include memory management, one or more input operations, one or more output operations, and / or one or more system calls. The runtime environment may include libraries and / or frameworks that the computational nodes may use to perform various functions. The runtime environments may include garbage collection, such as Java and Python, for automatically managing memory allocation and deallocation. The runtime environments may include error handling for any errors and / or exceptions that occur during the execution of the computational nodes. Although the example shown in FIG. 4 includes the parameters of an affinity / scheduler and a built-in control flow mechanism, other aspects may have more parameters or less parameters specifying any or all of the runtime parameters.

[0072] As shown in FIG. 4, three example runtime environments are an OpenMP runtime 412, a TaskFlow runtime 422, and a Legion runtime 432. For the OpenMP runtime 412, the developer 302 specifies that the affinity is 0-15 and not to use the built-in control flow mechanism. For the TaskFlow runtime 422, the developer 302 specifies a default affinity and to use the built-in control flow mechanism. For the Legion runtime 432, the developer 302 specifies the default affinity and not to use the built-in control flow mechanism. The developer 302 may specify more runtime environments by activating the add runtime button 414, which when activated, may add an additional row for another runtime environment. In some aspects, the affinity and built-in control flow may be populated with default parameters for the runtime environment.

[0073] The developer 302 may select additional benchmark configurations 416, such as a problem start size, a problem end size, and / or a processor architecture. The problem start size and problem end size may provide a range of input sizes or workloads used to evaluate the performance of the runtime environments in executing the task graph definitions 316 and / or computational kernels 318. The problem start size may specify an initial size of the input or workload used in the benchmark. The problem end size is a maximum size of the input or workload used in the benchmark. By varying the problem size from start to end, the benchmark may provide insights into how the performance of the runtime environments executing the task graph definitions 316 and / or computational kernels 318 is affected across different problem sizes. This varying problem size may identify performance trends, bottlenecks, and / or scalability issues. The processor architecture may be selected based on the expected processors executing the nodes, such as a type of GPU 202a…n. In this aspect, the developer 302 has selected an x86 architecture.

[0074] Once all the parameters have been selected in the user interface 400, the check configuration button 418 may be activated. The check configuration button 418 may initiate processing of a benchmark specification 502 from the user interface 400 by the automated benchmarking engine 330 as described with reference to FIG. 5. In particular, the check configuration button 418 may initiate the synthesis model 332 to generate the low-level configuration files 334 specifying the benchmark configurations as previously described. When the synthesis model 332 identifies errors in the benchmark specification 502, the errors may be returned to user interface 400 for correction by the developer 302. The errors may include identifying kernel code that does not compile, malicious kernel code, improper task graph definitions 316, etc. When no errors in the benchmark specification 502 are identified, the user interface 400 may be notified that the benchmark specification 502 complies and the benchmark specification 502 is suitable for benchmarking. The user interface 400 may wait at this point for the developer 302 to initiate the benchmarking.

[0075] In some aspects, once all the parameters have been selected in the user interface 400, the developer 302 may activate the check configuration and start benchmark button 420. The activation of the start benchmark button 420 may perform the operations of the check configuration button 418 as previously described but the processing does not wait after the benchmark specification 502 complies but continues to perform the benchmarking. In some aspects, the benchmark button 420 may initiate the benchmarking and may not be activated until the check configuration process has been completed using the check configuration button 418.

[0076] With reference to FIG. 5, when the one or more low-level configuration files 334 are generated for each runtime environment to be benchmarked, an iterative automated benchmarking engine 504 may be executed. In this aspect, the deployer 336 may start by retrieving the low-level configuration files 334 associated with a first runtime environment 412. Based on the low-level configuration files 334, the deployer 336 may select the computational kernels 318 that have been compiled for the first runtime environment 412 and assign the computational kernels 318 to one or more of the computational nodes, such as the GPUs 202a…n. The deployer 336 may allocate the computational nodes, apply the processor affinity settings for the computational nodes, and / or ensure the allocated hardware resources align with the specified hardware configuration for the first runtime environment 412.

[0077] Once deployed, the evaluator 338 may execute the computational process across the problem start size to the problem end size. During execution of the first runtime environment 412, the evaluator 338 may monitor a performance of the first runtime environment 412. The performance metrics may include one or more of: execution time (e.g. a total time to run the benchmark task, such as seconds) , a processor utilization (e.g. processor utilization recorded every second as a percentage) , a memory usage (e.g. memory utilization in gigabytes) , data transfer (e.g. number of bytes of data transferred between computational nodes, such as bytes per second) , and / or FLOPS / s (e.g. number of floating point operations per second for each task in the task graph 316) . The performance metrics may be saved to a log file associated with the first runtime environment 412.

[0078] When complete the benchmarking of the first runtime environment 412, the deployer 336 may retrieve the low-level configuration files 334 associated with the second runtime environment 422. Based on the low-level configuration files 334, the deployer 336 may select the computational kernels 318 that have been compiled for the second runtime environment 422 and assign the computational kernels 318 to one or more of the computational nodes, such as the GPUs 202a…n. The deployer 336 may allocate the computational nodes, apply the processor affinity settings for the computational nodes, and / or ensure the allocated hardware resources align with the specified hardware configuration for the second runtime environment 422.

[0079] Once deployed, the evaluator 338 may execute the computational process across the problem start size to the problem end size. During execution of the second runtime environment 422, the evaluator 338 may monitor a performance of the second runtime environment 422. As for the first runtime environment 412, the same performance metrics may be recorded. The performance metrics may be saved to a log file associated with the second runtime environment 422.

[0080] The iterative automated benchmarking engine 504 continues executing the deployer 336 and the evaluator 338 in this manner until all the runtime environments have been benchmarked. In this manner, the iterative automated benchmarking engine 504 may benchmark many different runtime environments to determine the runtime environment with the desired performance characteristics for the particular task graph definition 316 and / or computational kernels 318. While the iterative automated benchmarking engine 504 benchmarks the runtime environments, a process monitor 506 may continuously monitor the deployer 336 and / or the evaluator 338 for errors and / or other events. The events and / or errors may be saved to an error-log file. In some aspects, the process monitor 506 may forward any errors for review by the developer 302 in a live console and / or via text message, email, etc. When the process monitor 506 determines that the error is unrecoverable (e.g. the runtime environment, the computational kernel 318 and / or the task graph definition 316 has halted, hung, and / or crashed) , the process monitor 506 may provide instructions to the distributed and / or multiprocessor computational platform 200 to reset the computational platform 200. The process monitor 506 may instruct the iterative automated benchmarking engine 504 to proceed to the next runtime environment.

[0081] In another aspect, the iterative automated benchmarking engine 504 may include the synthesis model 332. In this aspect, the synthesis model 332 retrieves the benchmark specification 502. The synthesis model 332 may iteratively generate the low-level configuration files 334 corresponding to the runtime environments and provides these low-level configuration files 334 to the deployer 336 as previously described. In this aspect, the process monitor 506 may monitor the synthesis model 332 and log any errors to the error-log file and / or forward the errors for review by the developer 302 in the live console and / or via text message, email, etc.

[0082] When the iterative automated benchmarking engine 504 completes the benchmarking of the benchmark specification, the reporter 340 may retrieve, process, and / or visualize the benchmark results. The reporter 340 may display the benchmark results along with or in addition to a benchmark report that recommends one of the runtime environments to the developer 302.

[0083] Turning to FIGS. 6A and 6B, an example task graph 600 has five computational nodes A, B, C, D, E. The computational nodes B and C depend on computational node A. The computational node D depends on the computational node B and computational node E depends on the computational nodes C and D. As described herein, the developer 302 may provide these computational nodes and dependencies in the graph builder 402. The kernel code may be provided to the kernel editor 406. The benchmarking system 300 herein may benchmark the example task graph 600 as shown in FIG. 6A due to the synthesis model 332 and / or deployer 336 adapting the task graph definition 316 into one or more low-level configuration files 334.

[0084] Other benchmarking software may be unable to benchmark the example task graph 600. For example, some benchmarking software may only allow computational kernels to depend on other computational kernels from an immediate step as shown in FIG. 6B. In the example shown in FIG. 6B, the computational node D can depend on the computational node B since the node B is one time-step behind. The benchmarking software may experience problems with computational node E as the node E depends on the computational node C, which is two time-steps behind. Other benchmarking software may be limited to a few predefined kernels (e.g. compute-bound kernel and / or memory-bound kernel) without the ability to customize and / or use different kernels. The other benchmarking software may also limit each computational node to homogeneous kernels. Other benchmarking software may be limited to static runtime configurations.

[0085] Turning to FIG. 7, a runtime benchmarking workflow 700 of the iterative automated benchmarking engine 504 is shown. Each of the candidate runtimes 704 as specified by the benchmark specification 502 may be provided with a workload 702. The iterative automated benchmarking engine 504 may iteratively select and benchmark each of the candidate runtimes 704 with the workload 702 to process. The deployer 336 may allocate the computational nodes, apply any runtime specific settings for the computational nodes and the evaluator 338 collects performance metrics for each of the candidate runtimes 704 as previously described. The runtime benchmark interface 350 may display the performance metrics for each of the candidate runtimes 704 for comparison.

[0086] As shown in FIG. 8, a visual representation 800 of a performance metric is shown. In this aspect, the performance metric is data movement across tiers of a memory hierarchy and among different machines (e.g. GPUs 202a…n) . The tiers of the memory hierarchy are shown in a conical representation 820 having the faster memory 104 towards a vertex of the conical representation 820. In this aspect, the cache memory layer 802 is located closest to the vertex followed by a memory layer 804 and a disk layer 806 being progressively further from the vertex. The placement of these layers is due to cache memory being faster than the memory and the memory being faster than the disk storage. Other aspects may have multiple cache memory layers 802 (e.g. a layer for each of L1, L2, and / or L3) represented on the conical representation 820. Similarly, when the computational platform 200 has multiple speeds of memory, these multiple memories may be represented as multiple memory layers 804. Similarly, when the computational platform 200 has multiple speeds of storage 110 (e.g. SSD, RAID, conventional hard disk drive) , the different speeds of storage 110 may be represented as multiple disk layers 806 based on their respective transfer speeds (e.g. data transfer velocity) . In some aspects, two conical representations 820 may be provided with one conical representation 820 representing read transfer rates and one conical representation 820 representing write transfer rates.

[0087] In each of the layers 802, 804, 806, one or more machines (e.g. computational nodes) may be represented as arcs around the circumference of the conical representation 820. Each of the arcs corresponds to a computational node having data transfers for the respective layers 802, 804, 806. In this aspect, the cache memory layer 802 includes two computational nodes 810, 812. Similarly, the memory layer 804 includes two computational nodes 810, 812. The disk layer 806 includes three computational nodes 810, 812, 814. As can be seen by the example, the computational node 814 does not include any transfers within the cache memory layer 802 or the memory layer 804.

[0088] Data transfer within memory levels of a computational node may be represented as vertical transfers along an axis of the conical representation 820. In the example, the computational node 810 performs a data transfer 824 from the storage 110 to the memory 104 and a data transfer 822 from the memory 104 to the cache memory. As can be seen, the data transfer 824 from the storage 110 to the memory 104 may be performed by a PCIe bus. The data transfer 822 from the memory 104 to the cache memory may be performed by a DDR bus. The direction of the arrow represents a direction of the data transfer. In some aspects, a data transfer may be performed for a computational node within the same memory 104. For example, data transfer 840 demonstrates transfer of data within the same memory 104 of computational node 812. This may indicate that the computational node 812 was moving data around in memory 104 to free a single contiguous block of memory 104.

[0089] Any cross-node data transfers 826 may be represented by solid arrow lines connecting the arcs. The cross-node data transfers 826 may be more easily observed with a sectional cross-section of the particular layer 804, 806. In some aspects, the cross-node data transfers 826 may provide an amount of data transferred and / or received between the computational nodes. For example, the computational node 810 has received 20-GB of data and transmitted 10-GB of data within memory 104. Likewise, the computational node 812 has received 10-GB of data and transmitted 30-GB of data within memory 104.

[0090] Similarly for the storage 110, the computational nodes 810, 812, and 814 have received 0-GB, 5-GB, and 1-GB respectively and have transmitted 10-GB, 0-GB, and 0-GB respectively. The developer 302 may identify a potential bottleneck as computational node 810 may be responsible for distributing 10-GB of data equally between the computational nodes 812, 814. The computational node 812 appears to have received the allocated share of data. The computational node 814 lags behind by 4-GB, indicating a potential network bandwidth limitation and / or communication issue between the computational node 810 and the computational node 814.

[0091] The aspects herein describe a generally self-contained benchmarking application 156a…n that may be installed locally to benchmark workloads on local infrastructure. Other aspects may provide an online platform for benchmarking. The online platform may provide a web-based service where developers may upload their workloads. The techniques described herein may be performed by the web-based server in conjunction with an online distributed and / or multiprocessor platform.

[0092] Although the distributed and / or multiprocessor computational platform 200 is described herein as a GPU cluster, the techniques herein may apply equally well to other distributed, multiprocessor, and / or parallel architectures. For example, the techniques may apply equally well to cloud computing, Internet of Things (IoT) , and / or edge computing. For example, in cloud computing, the techniques herein may optimize cloud-based applications by modeling service interactions and deployment configurations.

[0093] As described herein, it may be understood that the units in the computing structure 100 may be logical or functional. Each function may correspond to one functional unit, or two or more functions may be integrated into a single functional unit. In actual implementation, all or some of the units may be integrated into a single physical entity or may be distributed across different physical entities. In addition, the functional units may be implemented in the form of hardware, software, or a combination of hardware and software. Whether a function is implemented in the form of hardware or software depends on applications and design constraint conditions of the technical solutions. A person skilled in the art may use different methods to implement the described functions for specific applications, but it should not be considered that the implementation goes beyond the scope of this disclosure. The computing structure or the computing device may comprise means to perform the computer-implemented method (s) as described herein.

[0094] In an example, a functional unit in any one of the computing structure 100 may be configured as one or more integrated circuits for implementing the methods disclosed herein, for example, as one or more application-specific integrated circuits (application-specific integrated circuits, ASICs) , one or more central processing units (CPUs) , one or more microprocessors or microprocessor units (MPUs) , one or more microcontrollers or microcontroller units (MCUs) , one or more digital signal processors (DSPs) , one or more field programmable gate arrays (FPGAs) , or a combination of these.

[0095] A processor 102 or GPU 202a…n may be referred to as a processor system, an application processor, a baseband processor, a processor circuit, or a processor core. The processor 102 or GPU 202a…n may include one or a combination of one or more central processing units (CPUs) , one or more digital signal processors (DSPs) , one or more microprocessors (microprocessor units, MPUs) , one or more microcontrollers (microcontroller units, MCUs) , one or more graphics processing units (GPUs) , one or more field programmable gate arrays (FPGAs) , one or more artificial intelligence processors (AI processors) , or one or more neural network processing units (NPUs) .

[0096] Memory 104, 204a…n may include one or more of the following storage media: a random access memory (RAM) , a static random access memory (static RAM, SRAM) , a dynamic random access memory (dynamic RAM, DRAM) , a phase-change memory (PCM) , a resistive random access memory (resistive RAM, ReRAM) , a magneto-resistive random access memory (magneto-resistive RAM, MRAM) , a ferroelectric random access memory (ferroelectric RAM, FRAM) , a cache, a register, a read-only memory (ROM) , a flash memory (flash memory) , an erasable programmable read-only memory (erasable programmable ROM, EPROM) , a hard disk, and the like. In an example, computer program instructions used to execute embodiments may be stored in a non-volatile memory, for example, at least a part of a memory or storage unit (for example, one or more of a ROM, a flash memory, an EPROM, or a hard disk) . When a terminal runs, a part or all of corresponding computer program instructions may be loaded to a memory that has a higher transmission speed with the processor, for example, at least a part of a memory or a storage unit (for example, one or more of a RAM, an SRAM, a DRAM, a PCM, a RERAM, an MRAM, a FRAM, a cache, or a register) , so that the processor executes the computer program instructions to perform the steps in the method embodiments disclosed herein.

[0097] In the present disclosure, the terms “a” or “an” are defined to mean “at least one” , that is, these terms do not exclude a plural number of items, unless stated otherwise.

[0098] In the present disclosure, terms such as “substantially” , “generally” and “about” , which modify a value, condition, or characteristic of a feature of an example aspect, should be understood to mean that the value, condition, or characteristic is defined within tolerances that are acceptable for the proper operation of the example aspect for its intended application.

[0099] In the present disclosure, unless stated otherwise, the terms “connected” and “coupled” , and derivatives and variants thereof, refer herein to any structural or functional connection or coupling, either direct or indirect, between two or more elements. For example, the connection or coupling between the elements can be acoustical, mechanical, optical, electrical, thermal, logical, or any combinations thereof.

[0100] In the present disclosure, expressions such as “match” , “matching” and “matched” , including variants and derivatives thereof, are intended to refer herein to a condition in which two or more elements are either the same or within some predetermined tolerance of each other. That is, these terms are meant to encompass not only “exactly” or “identically” matching the two elements but also “substantially” , “approximately” or “subjectively” matching the two or more elements, as well as providing a higher or best match among a plurality of matching possibilities.

[0101] In the present disclosure, the expression “based on” is intended to mean “based at least partly on” , that is, this expression can mean “based solely on” or “based partially on” , and so should not be interpreted in a limited manner. More particularly, the expression “based on” could also be understood as meaning “depending on” , “representative of” , “indicative of” , “associated with” or similar expressions.

[0102] In the present disclosure, the terms "system" and "network" may be used interchangeably in different embodiments of this application. "At least one" means one or more, and "a plurality of" means two or more. The term "and / or" describes an association relationship of associated objects and indicates that three relationships may exist. For example, A and / or B may indicate the following three cases: Only A exists, both A and B exists, and only B exists, where A and B may be singular or plural. The character " / " indicates an "or" relationship between associated objects. "At least one of the following items (pieces) " or a similar expression thereof indicates any combination of these items, including a single item (piece) or any combination of a plurality of items (pieces) . For example, "at least one of A, B, or C" includes: only A; only B; only C; A and B; A and C; B and C; or A, B, and C, and "at least one of A, B, and C" may also be understood as including: only A; only B; only C; A and B; A and C; B and C; or A, B, and C. In addition, unless otherwise specified, ordinal numbers such as "first" and "second" in embodiments of this application are used to distinguish between a plurality of objects, and are not used to limit a sequence, a time sequence, priorities, or importance of the plurality of objects.

[0103] A person skilled in the art should understand that embodiments of this application may be provided as a method, an apparatus (or system) , computer-readable storage medium, or a computer program product. Therefore, this application may use a form of a hardware-only aspect, a software-only aspect, or an aspect with a combination of software and hardware. Moreover, this application may use a form of a computer program product that is implemented on one or more computer-usable storage media (including but not limited to a disk memory, an optical memory, and the like) that include computer-usable program code.

[0104] This application is described with reference to the flowcharts and / or block diagrams of the method, the device (system) , and the computer program product according to this application. Computer program instructions may be used to implement each process and / or each block in the flowcharts and / or the block diagrams and a combination of a process and / or a block in the flowcharts and / or the block diagrams. The computer program instructions may be provided for a general-purpose computer, a dedicated computer, an embedded processor, or a processor of another programmable data processing device and enable a machine to execute the instructions. When executed by any computer or the processor of a programmable data processing device, the instructions cause the apparatus to implement specific functions as described in one or more procedures in the flowcharts and / or one or more blocks in the block diagrams. The computer program instructions may alternatively be stored in a computer-readable memory that can indicate a computer or another programmable data processing device to work in a specific manner, so that the instructions stored in the computer-readable memory generate an artifact that includes an instruction apparatus. The instruction apparatus implements a specific function in one or more procedures in the flowcharts and / or one or more blocks in the block diagrams.

[0105] The computer program instructions may alternatively be loaded onto a computer or another programmable data processing device, so that a series of operations and steps are performed on the computer or another programmable device, so that computer-implemented processing is generated. Therefore, the instructions executed on the computer or on another programmable device provide steps for implementing specific functions as described in one or more procedures in the flowcharts and / or one or more blocks in the block diagrams.

[0106] A person skilled in the art can make various modifications and variations to this application without departing from the scope of this disclosure. This disclosure is intended to cover these modifications and variations of this application if they fall within the scope of protection defined by the following claims and their equivalent technologies.

Claims

1.A computer-implemented method for benchmarking a multiprocessor or distributed runtime environment, the computer-implemented method comprising:receiving a logical representation of a plurality of computational tasks with a plurality of dependencies therebetween;receiving at least one customized kernel to process at least one computational task of the plurality of computational tasks;receiving at least one runtime optimization parameter;converting the logical representation, the at least one customized kernel, and the at least one runtime optimization parameter to a machine-implementation;deploying the machine-implementation to a computational platform having at least two computational nodes;executing the machine-implementation on the computational platform according to the at least one runtime optimization parameter; andcollecting at least one performance metric from the computational platform.2.The computer-implemented method according to claim 1, further comprising generating the logical representation and the plurality of dependencies with a graph builder.3.The computer-implemented method according to any one of claims 1 to 2, further comprising customizing the at least one customized kernel with a kernel editor.4.The computer-implemented method according to any one of claims 1 to 3, further comprising selecting the at least one runtime optimization parameter with a runtime optimization interface.5.The computer-implemented method according to any one of claims 1 to 4, wherein the at least one runtime optimization parameter is selected from a scheduling policy, an affinity, and a task placement.6.The computer-implemented method according to any one of claims 1 to 5, further comprising verifying the at least one customized kernel satisfies at least one condition of the computational platform.7.The computer-implemented method according to any one of claims 1 to 6, further comprising rendering a visualization of the at least one performance metric.8.The computer-implemented method according to claim 7, wherein the at least one performance metric is a data movement between the at least two computational nodes of the computational platform.9.The computer-implemented method according to any one of claims 7 to 8, wherein the visualization of the data movement between the at least two computational nodes of the computational platform comprise a conical representation.10.The computer-implemented method according to claim 9, wherein the conical representation has an axis representing a data transfer velocity and a circumference representing the at least two computational nodes.11.A system comprising:a processor executing a plurality of instructions from a computer-readable memory, the instructions to configure the processor to:receive a logical representation of a plurality of computational tasks with a plurality of dependencies therebetween;receiving at least one customized kernel to process at least one computational task of the plurality of computational tasks;receive at least one runtime optimization parameter;convert the logical representation, the at least one customized kernel, and the at least one runtime optimization parameter to a machine-implementation;deploy the machine-implementation to a computational platform having at least two computational nodes;execute the machine-implementation on the computational platform according to the at least one runtime optimization parameter; andcollect at least one performance metric from the computational platform.12.The system according to claim 11, further comprising the instructions to configure the processor to: generate the logical representation and the plurality of dependencies with a graph builder.13.The system according to any one of claims 11 to 12, further comprising the instructions to configure the processor to:customize the at least one customized kernel with a kernel editor.14.The system according to any one of claims 11 to 13, further comprising the instructions to configure the processor to:select the at least one runtime optimization parameter with a runtime optimization interface.15.The system according to any one of claims 11 to 14, wherein the at least one runtime optimization parameter is selected from a scheduling policy, an affinity, and a task placement.16.The system according to any one of claims 11 to 15, further comprising the instructions to configure the processor to:verify the at least one customized kernel satisfies at least one condition of the computational platform.17.The system according to any one of claims 11 to 16, further comprising the instructions to configure the processor to:visualize the at least one performance metric.18.The system according to claim 17, wherein the at least one performance metric is a data movement between the at least two computational nodes of the computational platform.19.The system according to any one of claims 17 to 18, wherein a visual representation of the data movement between the at least two computational nodes of the computational platform comprise a conical representation.20.The system according to claim 19, wherein the conical representation has an axis representing a data transfer velocity and a circumference representing the at least two computational nodes.21.A computing device, comprising:a processor; anda memory coupled to the processor, the memory storing computer-executable instructions for detecting input via a user interface, wherein the instructions, when executed by the processor, are to configure the processor to execute the computer-implemented method claimed in any one of claims 1 to 10.22.A non-transitory computer-readable medium storing computer-executable instructions that, when executed by one or more processors, are to cause the one or more processors to execute the computer-implemented method of any one of claims 1 to 10.23.A computer program comprising instructions which, when executed by a computing device, are to cause the computing device to execute the computer-implemented method of any one of claims 1 to 10.24.A computing device comprising means to perform the computer-implemented method of any one of claims 1 to 10.

Images