JP6252140B2 - Task allocation program and task allocation method - Google Patents

Description

  The present application relates to a task allocation program and a task allocation method.

  Conventionally, the assignment of sockets and cores to processors can be specified only in units of syntax loops or subroutines at the maximum in a program corresponding to an application that executes each process. Therefore, more syntax (smaller than that) cannot be specified on the application side, and is determined at the level of the Operating System (OS), which limits the improvement in processing efficiency and processing performance. was there.

  For example, the concept of a task is introduced in OpenMP (registered trademark) which is a syntax of a thread parallel application used for a processor for High Performance Computing (HPC) or the like. In OpenMP, a plurality of sockets and cores can be selected on the application side.

JP 2003-6175 A JP 2008-84009 A

Stephen L. Olivier, Allan K. et al. Porterfield, Kyle B.M. Wheeler, and Jan F .; Princes, “Scheduling task parallelism on multi-socket multicore systems.”, In Proceedings of the 1st International co., S11.

  As described above, the introduction of the concept of tasks enables application programs to allocate sockets and cores for each syntax using information inside the application, thereby improving processing efficiency and processing performance. Become.

  However, in the case of a conventional algorithm such as a simple first-in first-out method or a round robin method, there is a limit to improvement in processing efficiency and processing performance due to the effect that the memory access of each task is not considered.

  In one aspect, an object of the present invention is to improve processing efficiency and processing performance.

The task allocation program in one aspect generates task-specific profile information including information indicating the presence / absence of a parent-child relationship between tasks and a memory access rate for each task from hardware monitor information obtained by executing an application, Based on the task-specific profile information, in response to a task instruction from the application, the task is assigned to a processor socket or core in the syntax unit of the task in the program that executes the application, and the task is executed. The task-specific profile information is updated based on the updated task-specific profile information, and the processing is executed on the computer, which is assigned to the processor socket or core in the syntax unit of the task executed by the next task instruction based on the updated task-specific profile information. Let

  Processing efficiency and processing performance can be improved.

It is a figure which shows the function structural example of information processing apparatus. It is a figure which shows the hardware structural example of information processing apparatus. It is a figure which shows the specific example of CPU. It is a flowchart which shows an example of a process of information processing apparatus. It is a figure which shows the specific example of the task allocation method in this embodiment. It is a figure which shows an example of the syntax contained in the application which performs a task. It is a figure which shows the schematic example of the task allocation in this embodiment. It is a flowchart which shows an example of the process in an allocation means. It is FIG. (1) which shows the example of allocation to the socket and core based on a memory access rate. It is FIG. (2) which shows the example of allocation to the socket and core based on a memory access rate. It is FIG. (1) which shows the example of allocation in 1st Example. It is FIG. (2) which shows the example of allocation in 1st Example. It is FIG. (3) which shows the example of allocation in 1st Example. It is FIG. (1) which shows the example of allocation in 2nd Example. It is FIG. (2) which shows the example of allocation in 2nd Example.

  Hereinafter, embodiments will be described in detail with reference to the accompanying drawings.

<Functional configuration example of information processing apparatus>
FIG. 1 is a diagram illustrating a functional configuration example of the information processing apparatus. The information processing apparatus 10 illustrated in FIG. 1 executes a parallel process by assigning a task to a socket, a core, or the like of a processor corresponding to a predetermined application, for example. The information processing apparatus 10 shown in the example of FIG. 1 includes an input unit 11, an output unit 12, a storage unit 13, an allocation unit 14, a process execution unit 15, a profile information measurement unit 16, a calculation unit 17, The update unit 18, the communication unit 19, and the control unit 20 are included.

  The input unit 11 accepts various inputs such as start and end of various instructions and input of settings from a user or the like. For example, the input unit 11 accepts instructions such as task assignment instructions to sockets and cores, processing execution instructions, profile information measurement instructions, calculation instructions, update instructions, and communication instructions in this embodiment. The input unit 11 may be, for example, a keyboard or a mouse, or may be a touch panel type using a screen, a microphone, or the like, but is not limited thereto.

  The output unit 12 outputs the content input by the input unit 11 and the content executed based on the input content. For example, the output unit 12 may be a display unit such as a display or a monitor when outputting by screen display, and may be an audio output unit such as a speaker when outputting by sound, but is not limited thereto. It is not a thing.

  The storage unit 13 stores various information necessary in the present embodiment. For example, the storage unit 13 includes each instruction information obtained from the input unit 11, one or more tasks set in correspondence with various applications, assignment contents of tasks to sockets and cores, hardware monitor information, profile information Memorize etc. The information stored in the storage unit 13 is not limited to the information described above.

  The storage unit 13 reads and writes various stored information at a predetermined timing as necessary. The storage means 13 is, for example, a hard disk or a memory, but is not limited thereto. The storage unit 13 may be provided as a storage device (disk device) connected in a state where data can be transmitted and received via the communication unit 19.

  The allocation unit 14 acquires the degree of memory access for each task (memory access rate) from the past profile information, and allocates sockets, cores, and the like to which tasks are allocated in units of tasks. Note that a task is, for example, a block surrounded by a task (task) syntax of an application program (source code) using OpenMP. Therefore, the task unit corresponds to, for example, a task syntax unit, but is not limited to this.

  For example, the allocating unit 14 allocates a processor socket or core in units of a task syntax in a program that executes an application in response to a task instruction from the application based on, for example, a memory access rate. The allocation unit 14 can also perform task allocation based on the profile information updated by the update unit 18. The task assignment can be performed at the timing when the profile information is updated (for example, the end of execution in a loop unit or a subroutine unit), but is not limited to this, and may be performed in an application unit, for example.

  The processing execution means 15 executes processing (parallel processing or the like) of tasks assigned by the assignment means 14 to the core or socket of the processor. The process execution unit 15 executes an internal task process by executing an executable file corresponding to an application programmed using a task syntax defined in, for example, OpenMP Application Program Interface (API) Version 3.0. Let

  The profile information measuring unit 16 measures the task-specific profile information using the hardware monitor information obtained by executing the process by the process executing unit 15. The hardware monitor information is information obtained by monitoring the operation status of hardware during application execution, for example. The hardware monitor information can output information in units of tasks, loops, subroutines, applications, etc., but is not limited to this.

  The measurement information of the hardware monitor information includes, for example, “elapsed time”, “Million Floating-point Operations Per Second (MFLOPS)”, “MFLOPS Peak Performance Ratio”, “Million Instructions Per Second (MIPS)”, “MIPS Peak Performance”. Ratio ”,“ memory access throughput (chip unit) ”,“ memory access throughput peak performance ratio (chip unit) ”,“ single instruction multiple data (SIMD) instruction rate ”, etc., but are not limited thereto. . For example, the hardware monitor information may include memory access waiting time, cache miss information, and the like.

  “Elapsed time” is, for example, the time required to execute an instruction such as a task in the elapsed time measurement range. “MFLOPS” is, for example, the floating-point arithmetic execution efficiency (the average number of floating-point arithmetic executions per second). The “MFLOPS peak performance ratio” is, for example, a ratio of an actual measurement value to a logical peak value of MFLOPS. “MIPS” is instruction execution efficiency (average number of instruction executions per second). The “MIPS peak performance ratio” is, for example, a ratio of an actual measurement value to a logical peak value of MIPS.

  “Memory access throughput (chip unit)” is an average data transfer amount per second between a memory and a central processing unit (CPU) chip. The “memory access throughput peak performance ratio (chip unit)” is the ratio of the actually measured value to the logical peak value of the memory access throughput (chip unit).

  The “SIMD instruction rate” is, for example, the ratio of the number of SIMD instructions to the number of instruction executions. The SIMD instruction is an instruction that processes a plurality of operands with one instruction, for example.

  The hardware monitor information can confirm the execution performance of the program. For example, the closer the MIPS value and the MFLOPS value are to the respective peak values, the higher the execution performance and the calculation performance are.

  The calculation means 17 calculates the memory access rate of each task from the hardware monitor information described above. A specific example of the calculation method in the calculation means 17 will be described later.

  The update unit 18 updates the task-specific profile information based on the memory access rate calculated by the calculation unit 17. As a result, the allocating unit 14 can appropriately allocate a socket and a core to which a task is allocated from a history such as a memory access rate of the task on the spot during execution.

  The communication unit 19 transmits / receives various information to / from an external device via a communication network represented by the Internet, a local area network (LAN), and the like. The communication means 19 can receive various information already stored in the external device or the like, and can transmit the result processed by the information processing device 10 to the external device or the like via a communication network or the like. it can.

  The control unit 20 controls the entire configuration of the information processing apparatus 10. Specifically, the control means 20 performs each control regarding a task allocation process based on the instruction | indication from the input means 11 by a user etc., for example. Here, each control means, for example, assigning sockets and cores to tasks by the assigning means 14 described above, causing the process executing means 15 to execute task processing, etc., causing the profile information measuring means 16 to measure profile information, and calculating means 17 The memory access rate is calculated by the above, and the task-specific profile information is updated by the updating means 18, but is not limited thereto. Each process in the allocation unit 14, the process execution unit 15, the profile information measurement unit 16, the calculation unit 17, and the update unit 18 described above is realized by executing, for example, at least one preset application (program). can do.

  In the present embodiment, the information processing apparatus 10 described above can control task assignment destinations in real time using, for example, profile information at the time of task assignment. Therefore, in parallel processing using an HPC processor or the like, it is possible to improve processing efficiency and processing performance.

  The information processing apparatus 10 includes, for example, a personal computer (PC), a server, and the like, but is not limited thereto, and can be applied to a computer having a multiprocessor such as an HPC processor.

<Hardware Configuration Example of Information Processing Apparatus 10>
FIG. 2 is a diagram illustrating a hardware configuration example of the information processing apparatus. The information processing apparatus 10 illustrated in FIG. 2 includes an input device 31, an output device 32, a drive device 33, an auxiliary storage device 34, a main storage device 35, a CPU 36 that performs various controls, and a network connection device 37. These are connected to each other by a system bus B.

  The input device 31 includes a pointing device such as a keyboard and a mouse operated by a user, and a voice input device such as a microphone. The input device 31 activates a program execution instruction, various operation information, software, and the like from the user. The input of the information etc. is received.

  The output device 32 includes a display that displays various windows, data, and the like necessary for operating the computer main body (the information processing device 10) for performing processing in the present embodiment. The output device 32 can display program execution progress, results, and the like by a control program of the CPU 36.

  Here, in the present embodiment, for example, an execution program installed in the computer main body is provided by the recording medium 38 or the like. The recording medium 38 can be set in the drive device 33. Based on the control signal from the CPU 36, the execution program stored in the recording medium 38 is installed from the recording medium 38 into the auxiliary storage device 34 via the drive device 33.

  The auxiliary storage device 34 is storage means such as a hard disk drive (HDD) and a solid state drive (SSD). The auxiliary storage device 34 stores an execution program (task allocation program) in this embodiment, a control program provided in a computer, and the like based on a control signal from the CPU 36, and performs input / output as necessary. The auxiliary storage device 34 can read and write necessary information from each stored information based on a control signal from the CPU 36.

  The main storage device 35 stores an execution program read from the auxiliary storage device 34 by the CPU 36. The main storage device 35 is a Read Only Memory (ROM), a Random Access Memory (RAM), or the like.

  Based on a control program such as an OS and an execution program stored in the main storage device 35, the CPU 36 controls various processes of the entire computer, such as various operations and data input / output with each hardware component, and controls each processing. Realize processing. Various information necessary during the execution of the program can be acquired from the auxiliary storage device 34, and the execution result and the like can also be stored. In addition, the CPU 36 has a multiprocessor, and executes parallel processing by specifying a socket or core to the processor in task syntax units using a task instruction from an application or the like.

  Specifically, the CPU 36 executes processing corresponding to the program on the main storage device 35 by executing the program installed in the auxiliary storage device 34 based on, for example, an instruction to execute the program obtained from the input device 31. Do. For example, by executing a task allocation program, the CPU 36 allocates sockets or cores by the allocation unit 14 described above, executes processing by the process execution unit 15, measures profile information by the profile information measurement unit 16, and calculates by the calculation unit 17. Processing such as calculation of the memory access rate and updating of profile information by the updating means 18 is performed. In addition, the processing content in CPU36 is not limited to this. The contents executed by the CPU 36 are stored in the auxiliary storage device 34 as necessary.

  The network connection device 37 communicates with other external devices via the communication network described above. The network connection device 37 acquires an execution program, software, setting information, and the like from an external device or the like by connecting to a communication network or the like based on a control signal from the CPU 36. The network connection device 37 may provide an execution result obtained by executing the program to an external device, or may provide the execution program itself in the present embodiment to an external device or the like.

  The recording medium 38 is a computer-readable recording medium that stores an execution program and the like as described above. The recording medium 38 is, for example, a semiconductor memory such as a flash memory, or a portable recording medium such as a CD-ROM or DVD, but is not limited thereto.

  By installing an execution program (for example, a task allocation program) in the hardware configuration shown in FIG. 2, the task allocation processing and the like in this embodiment can be realized in cooperation with hardware resources and software.

<Specific Example of CPU 36 in the Present Embodiment>
Next, a specific example of the CPU 36 in the present embodiment will be described. FIG. 3 is a diagram illustrating a specific example of the CPU. The CPU 36 shown in the example of FIG. 3 is a multi-core processor, and has a plurality of cores in one processor package. For example, the CPU 36 includes a memory 41 and one or a plurality of sockets 42 (two sockets # 1 and # 2 in the example of FIG. 3). Each socket 42 is a package including one or more cores 43 (four cores # 0 to # 3 in the example of FIG. 3). The number of sockets and the number of cores are not limited to the example of FIG. The CPU 36 improves the performance by parallel processing by a multi-core processor as shown in FIG.

  The memory 41 is a high-speed storage device (for example, a primary cache) provided in the microprocessor. By accumulating frequently used data in the memory 41, access to the low-speed main memory can be reduced and the processing can be speeded up. For example, if the CPU 36 is equipped with a two-stage cache memory, the first data read is the primary cache with a higher speed and smaller capacity, and there is no data in the primary cache. Go to the slower, larger secondary cache. The primary cache and the secondary cache of the memory 41 may be the main storage device 35 and the auxiliary storage device 34 described above.

  The socket 42 is an area for storing a plurality of cores 43. For example, in the case of a task having a parent-child relationship, these tasks are arranged in the same socket in order to maintain locality (locality) such as memory. As a result, access is closed in one socket, so that processing efficiency and processing performance are improved.

  The core 43 is a part that performs computer arithmetic processing. In the present embodiment, for example, one task is assigned to one core 43 in syntactic units.

<Example of Processing in Information Processing Device 10>
Next, an example of processing (task allocation processing) in the information processing apparatus 10 according to the present embodiment will be described using a flowchart. FIG. 4 is a flowchart illustrating an example of processing of the information processing apparatus.

  In the example of FIG. 4, the allocating unit 14 of the information processing apparatus 10 allocates tasks to be executed to cores according to task instructions of application programs (S01). In the processing of S01, the allocating unit 14 acquires the degree of memory access for each task using the past task profile information, and allocates each task to the core in syntactic units. In the process of S01, when there are a plurality of sockets as shown in FIG. 3, for example, an assignment as to which socket is used may be performed.

  Next, the process execution means 15 of the information processing apparatus 10 executes the process of the task assigned to the core (S02). The profile information measurement unit 16 of the information processing apparatus 10 acquires hardware monitor information during execution (S03), and calculates a memory access rate for each task from the acquired hardware monitor information (S04).

  Next, the updating unit 18 of the information processing apparatus 10 updates the task-specific profile information based on the memory access rate for each task calculated by the process of S04 (S05).

  Next, the information processing apparatus 10 determines, for example, whether or not the processing of all tasks included in the application has been completed (S06). If the processing of all tasks has not been completed (NO in S06), The process returns to S01. In this case, in the process of S01, assignment of each task to the core is performed using the task-specific profile information updated in the process of S06. Further, the information processing apparatus 10 ends the process when the processes of all tasks are completed (YES in S06).

<About task assignment in this embodiment>
Here, a specific example of task assignment in the present embodiment will be described. FIG. 5 is a diagram showing a specific example of the task assignment method in the present embodiment. In the example of FIG. 5, the CPU 36, which is an example of a multi-core processor as shown in FIG. 3, executes an executable file corresponding to a predetermined application. Here, the CPU 36 acquires task-specific profile information when performing allocation to a core in a syntax unit of a task.

  Examples of the items of the task-specific profile information shown in the example of FIG. 5 include “task”, “level”, “memory access rate”, and the like, but are not limited thereto. “Task” is information for identifying a task. The “level” is information indicating a task hierarchy (for example, a parent-child relationship). For example, in the example of FIG. 5, the task A has three levels 0, 1 and 2. The “memory access rate” is a memory access rate for each task and level.

  In addition, the CPU 36 acquires the allocation status of the task being executed to the socket and the core by using software components (modules) required when executing the computer program included in the runtime library or the like. Examples of the task allocation status items include “socket”, “core”, “task identification”, “level”, “memory access rate”, and the like, but are not limited thereto. “Socket” is information for identifying a socket in the CPU 36. “Core” is information for identifying a core for each socket. In the example of FIG. 5, it is shown that one core # 0 has four cores # 0 to # 3. “Task” is information of a task assigned to each core of each socket. “Level” is a diagram showing a hierarchy for a task. The “memory access rate” indicates the result of calculating the memory access rate of each task by the calculation means 17 from the acquired task assignment status.

  The CPU 36 newly allocates sockets and cores in syntactic units using the calculated memory access rate. The syntax unit is, for example, a task syntax unit, but is not limited thereto, and may be an application unit or a thread (parallel processing) unit, but is not limited thereto.

  As described above, in the present embodiment, the actual memory access rate is calculated on the application side, and the next socket and core allocation can be performed through the task instruction based on the calculated memory access rate.

<About task syntax>
Next, the task syntax in this embodiment will be described. For example, in the task execution in the conventional method, in the configuration of the processor (CPU 36) as shown in FIG. 3, the task is assigned to an appropriate socket by the OS level simple first-in first-out method, round robin method, or the like. Therefore, the conventional method has a limit in improving the processing efficiency and processing performance. Therefore, in this embodiment, OpenMP tasks are divided up to the nesting level of syntax and assigned to the core. Therefore, for example, it is possible to perform allocation control using operation specification for each nesting level of an OpenMP task.

  Here, FIG. 6 is a diagram illustrating an example of syntax included in an application that executes a task. FIG. 7 is a diagram showing a schematic example of task assignment in the present embodiment.

  In the example of FIG. 6, a syntax example corresponding to OpenMP API Version 3.0 is shown. When an application for executing a task is operated by a program as shown in the example of FIG. 6, conventionally, the memory access rate in the traverse in the task (task) syntax is not known. Therefore, to which socket is allocated, the cores are allocated from the top, regardless of the instruction in the traverse, or are allocated in a round robin manner.

  For example, when there are five tasks A to E as shown in FIG. 7A, in the conventional assignment of tasks A to E, for example, from socket # 0 as shown in FIG. The top of the core (core # 0) was packed and assigned. Further, as another conventional method, as shown in FIG. 7B (b), the load is allocated in a round robin manner to equalize the load. For this reason, allocation to an appropriate socket was not performed.

  Therefore, in the present embodiment, for the tasks A to E, the hardware monitor information is used to manage the history of information such as the memory access rate of the task in the middle of execution, and FIG. Measure task-specific profile information as shown. Next, using this task-specific profile information, it is determined whether the task to be operated is a task with a high memory access rate. Based on this information, as shown in (c) of FIG. Assign to sockets and cores every time. As a result, the processing efficiency and processing performance of the processor can be improved.

<Example of core assignment>
Next, an example of core allocation in the above-described allocation unit 14 will be described with reference to the drawings. FIG. 8 is a flowchart illustrating an example of processing in the allocation unit. In the example of FIG. 8, the allocation unit 14 first determines whether there is past task-specific profile information (S11). The past task-specific profile information is preferably, for example, task-specific profile information obtained from hardware monitor information for an application executed in the same program (task group), but is not limited thereto. Absent.

  If there is past task-specific profile information in the processing of S11 (YES in S11), the allocating unit 14 acquires the degree of memory access or the like (for example, memory access rate) of the task based on the past profile information. (S12). Next, the assigning means 14 selects a core to which a task is assigned by appropriate control (S13). For example, a task with a high memory access rate is assigned to a socket core where a task with a low memory access rate exists, and a task with a low memory access rate is assigned to a socket core with a task with a high memory access. And so on. That is, the allocation is performed so that the degree of memory access in each socket is equal. In addition, about appropriate control, it is not limited to this, For example, the task which has a parent-child relationship may perform the process of assigning to the same socket.

  Further, when there is no past task-specific profile information (NO in S11), the assigning means 14 is assigned by a conventional method such as assigning from the top of the core, or assigning in a round-robin manner to equalize the load. A core to which a task is assigned is selected (S14).

<Examples of allocation to sockets and cores based on memory access rate>
Next, an example of allocation to sockets and cores based on the memory access rate in this embodiment will be described with reference to the drawings. FIGS. 9 and 10 are diagrams (part 1 and part 2) showing examples of allocation to sockets and cores based on the memory access rate. The example in FIG. 9 shows a case where the task to be executed has a parent-child relationship, and the example in FIG. 10 shows a case where the task to be executed does not have a parent-child relationship. The parent-child relationship of tasks is, for example, a case where the execution result of a parent (level 0) task is used as input data in a child (level 1) task, but is not limited thereto.

  FIG. 9A shows an example of the contents of a task executed in a two-thread parallel program (level: two stages) and hardware monitor information after execution of the process. FIG. 9B shows an example of task-specific profile information measured using the hardware monitor information of FIG. FIG. 9C shows an example in which tasks are allocated to the sockets and cores of the CPU 36 in correspondence with the task-specific profile information of FIG. 9B. FIG. 9D shows an example of task assignment status.

  The items of the two-thread parallel program shown in FIG. 9A include, for example, “task name (level)”, “number of threads”, “elapsed time (seconds)”, “memory access waiting (seconds)”, “task type” However, it is not limited to this. The “task type” in FIG. 9A is named “task name + level + number of threads”, for example, to distinguish the tasks, but is not limited to this.

  In the example of FIG. 9, the task to be executed (task_A) is in a parent-child relationship (level 0, level 1). In such a case, when a task assignment destination core is selected, it is arranged in the same socket in order to maintain the locality (locality) of the cache (memory 41). Therefore, as shown in FIG. 9B, tasks A00, A01, A10, and A11 are assigned to the cores # 0 to # 3 of the socket # 0, respectively.

  Note that the memory access rate shown in FIG. 9B is obtained by using the memory access waiting time and elapsed time shown in FIG. 9A, “memory access rate (%) = memory access waiting (seconds) / elapsed time ( Second) × 100 ”, but is not limited to this.

  On the other hand, in the example of FIG. 10, FIG. 10A shows an example of the contents of a task executed in a two-thread parallel program (level: 1 stage) and hardware monitor information after execution of processing. FIG. 10B shows an example of task-specific profile information measured using the hardware monitor information of FIG. FIG. 10C shows an example in which tasks are assigned to the sockets and cores of the CPU 36 in correspondence with the task-specific profile information of FIG. 10B. FIG. 10D shows an example of task assignment status.

  In the example of FIG. 10, the execution tasks (task_B, task_C) are tasks that are not in a parent-child relationship. In such a case, when determining an appropriate task allocation core, allocation is performed so that the memory access rate of each socket is equal depending on the memory access rate and task allocation status. For example, the assigning unit 14 assigns a task having a high memory access rate to a socket having a task having a low memory access rate, and assigns a task having a low memory access rate to a socket having a task having a high memory access rate.

  In the allocation shown in the example of FIG. 10, since tasks B00, C01, and C01 are allocated to socket # 0, the memory access rate of socket # 0 is 20 + 20 + 5 = 45% based on the profile information for each task. Since task B01 is assigned to socket # 1, the memory access rate of socket # 0 is 50% from the profile information by task.

  When performing the above allocation, for example, it is preferable to adjust so that the total memory access rate of tasks allocated in the socket does not exceed a predetermined value (for example, 80% to 100%, etc.). It is not limited to.

  As described above, in this embodiment, the assignment of tasks to sockets and cores can be changed as shown in FIGS. 9 and 10 depending on whether or not a plurality of tasks to be executed have a parent-child relationship. Thereby, it is possible to improve processing efficiency and processing performance.

<Processing contents from start to end of task processing>
Next, processing contents from the start to the end of task processing in the profile information measuring means 16 will be described. First, the assigning means 14 assigns a task to a preset socket or core by appropriate control in the core selection process described above. The process execution means 15 starts (executes) the task process assigned to the core by the assignment means 14 in units of tasks. At this time, the profile information measuring unit 16 also starts measuring task profile information using the hardware monitor information in order to update the task-specific profile information. In the first execution of a task, there is no task-specific profile information, so, for example, cores are allocated by a conventional method (for example, a simple first-in first-out method or round robin method). Which conventional method is used can be set in advance by a user or the like, for example.

  During the execution of the process, the profile information and the like may be updated at the end of a predetermined task syntax such as a loop unit or a subroutine unit or at a predetermined time interval. At the end of task processing, measurement of profile information is also ended.

<About processing in the updating means 18>
Next, processing in the updating unit 18 will be described. The updating unit 18 updates the task-specific profile information using the above-described profile information measurement result. For example, in this embodiment, allocation to sockets and cores can be controlled in units of task syntax during program execution.

  For example, in one application program, the same function (task) is executed many times by loop processing, subroutine processing, or the like. For this reason, in the present embodiment, the task-specific profiler information is always acquired by the profiler, so that allocation to sockets and cores in the next task processing is appropriately performed. For example, each time a task is executed by the same task, the processing contents are different and the load is different depending on the behavior of the program (for example, conditional branching such as an if statement). However, as in the present embodiment, by obtaining task-specific profiler information with the regular profiler and using it as a prediction material for the next task assignment, it is possible to cope with different loads. Also, in this embodiment, in task execution, the task execution load can be reduced and task performance can be improved by allocating tasks to appropriate sockets and cores using hardware monitor information.

<Next task assignment example>
Next, an example of assigning the next task to a socket or core (each example) will be described with reference to the drawings.

<First embodiment>
FIGS. 11 to 13 are diagrams (Nos. 1 to 3) showing examples of allocation in the first embodiment. In the example of FIG. 11A, an example of the task allocation N-1th task content and hardware monitor information after the process execution is shown. Further, in the example of FIG. 11B, an example of the task allocation N-th task content and hardware monitor information after the process execution is shown.

  In the first embodiment, when a two-thread parallel program (level: 1 layer) has no parent-child relationship with a task, and the socket and core are occupied and executed (the core is always unused at the time of task allocation) An example is shown.

  In the first embodiment, as shown in the example of FIG. 12A, the total of the memory access rates immediately before the Nth task allocation of each socket is socket # 0 = 0% (unused), and socket # 1 = Assume 0% (unused).

  Here, when a program (application) including tasks B00, B01, C00, and C01 is executed, each task is assigned to a core. Therefore, the allocating unit 14 uses the past task-specific profile information acquired from the past hardware monitor information shown in FIG. 11A (for example, the first to N-1th statistics history or the N-1th history only). Referring to (information) (FIG. 12B), the memory access rate is acquired. Further, the allocation means 14 allocates tasks as shown in FIG. 12C based on the acquired memory access rate. In the example of FIG. 12C, allocation is performed so that the memory access rate is equalized for each socket, and the total memory access rate of each socket is 45% for socket # 0 and 50% for socket # 1. Become. Therefore, processing is executed by assigning tasks to sockets and cores shown in FIG. In the first embodiment, as shown in FIG. 11B, the hardware monitor information being processed is acquired, and the task-specific profile information is updated using the acquired hardware monitor information.

  Next, in the first embodiment, as shown in the example of FIG. 12D, the total of the memory access rates immediately before the N + 1th task allocation of each socket is socket # 0 = 0% (unused), and the socket Assume that # 1 = 0% (unused).

  Here, when executing a program including tasks B00, B01, C00, and C01, the allocating unit 14 updates the updated task-specific profile information (for example, the statistical history from the first to the Nth time or N The memory access rate is acquired by referring to the history information only for the first time). Further, the allocation means 14 allocates tasks as shown in FIG. 12 (F) based on the acquired memory access rate. In the example of FIG. 12 (F), the allocation is performed so that the memory access rate is equal for each socket, and the total memory access rate of each socket is 70% for socket # 0 and 60% for socket # 1. Become. Therefore, processing is executed by assigning tasks to sockets and cores shown in FIG. In the first embodiment, the task-specific profile information is updated using the hardware monitor information being processed. Therefore, sockets and cores can be specified in units of task syntax using task-specific profile information that is similarly updated in the N + 2 and subsequent task assignments.

<Second embodiment>
FIGS. 14 and 15 are diagrams (No. 1 and No. 2) showing an allocation example in the second embodiment. The second embodiment is the same as the first embodiment described above in that it is a case of a two-thread parallel program (level: one layer) and the task has no parent-child relationship. Furthermore, the second embodiment shows a case where a socket or core is shared with another application program and executed (for example, another program is always assigned to an arbitrary core at the time of task assignment). In the second embodiment, as in the first embodiment, an example of the task contents and the hardware monitor information after the process shown in FIG. 11 is used.

  In the second embodiment, as shown in FIG. 14A, tasks X, Y, and Z other than the task to be executed exist in a part of the core. Therefore, the total of the memory access rates immediately before the Nth task allocation is socket # 0 = 40% and socket # 1 = 40%.

  Here, when executing a program (application) including tasks B00, B01, C00, and C01, in order to assign each task to the core, the allocating unit 14 includes past task-specific profile information (for example, FIG. 14B). , 1 to N-1th statistical history) to obtain the memory access rate. Further, the allocation unit 14 allocates tasks as shown in FIG. 14C based on the acquired memory access rate. In the example of FIG. 14C, the allocation is performed so that the memory access rate is uniform for each socket. In the example of FIG. 14C, since tasks X, B00, C00, and Y are assigned to socket # 0, all cores # 0 to # 3 in socket # 0 are used. Task C01 is assigned to socket # 1. Therefore, finally, the total memory access rate of each socket is 85% for socket # 0 and 95% for socket # 1.

  Therefore, processing is executed by assigning tasks to sockets and cores shown in FIG. In the second embodiment, the hardware monitor information being processed is acquired, and the task-specific profile information is updated using the acquired hardware monitor information.

  Next, in the second embodiment, when the N + 1th allocation is performed, as shown in FIG. 14D, tasks U, V, and W other than the task to be executed exist in a part of the core. Therefore, the total of the memory access rates immediately before the task allocation N + 1th time is socket # 0 = 20% and socket # 1 = 15%.

  Here, when executing a program including tasks B00, B01, C00, and C01, the allocating means 14 uses the updated task-specific profile information (for example, statistical history from 1 to N times) shown in FIG. Refer to and obtain the memory access rate. Further, the allocation unit 14 allocates tasks as shown in FIG. 14F based on the acquired memory access rate. In the example of FIG. 14F, allocation is performed so that the memory access rate is uniform for each socket, and the total memory access rate of each socket is 80% for socket # 0 and 85% for socket # 1. Become. Therefore, processing is executed by assigning tasks to sockets and cores shown in FIG. In the second embodiment, the task-specific profile information is updated using the hardware monitor information being processed. Therefore, sockets and cores can be specified in units of task syntax using task-specific profile information that is similarly updated in the N + 2 and subsequent task assignments.

  As described above, in the present embodiment, the next allocation can be feedback-controlled in real time, and appropriate correspondence can be taken using the task-specific profile information.

  In the above-described embodiment, the memory access rate is calculated using the memory access waiting time and the elapsed time of the hardware monitor information. However, the present invention is not limited to this, and for example, the cache miss rate and the elapsed time are calculated. Based on this, the memory access rate may be calculated. Cache miss information can be collected from hardware monitor information. The cache miss information is when no data exists even when the CPU 36 searches the cache memory (memory 41). In the case of a cache miss, it takes time to access data because it does not exist on the cache memory (necessary data is at a short distance) and the necessary data exists on a main memory at a long distance. The time required for this access is the memory access waiting time. Therefore, when there are many cache misses, the memory access wait time also increases, so that the memory access rate can be calculated using the cache miss rate instead of the memory access wait time described above. Therefore, in this embodiment, when the memory access is large and the cache miss of the task is extremely large or small, the task execution efficiency is greatly improved by changing the task execution allocation socket or core. be able to.

  As described above, according to the present embodiment, it is possible to specify a socket and a core on a syntax basis through a task instruction on the application side based on an actual memory access rate. Therefore, it is possible to improve processing efficiency and processing performance.

  Further, according to the present embodiment, for example, an application having a task syntax such as OpenMP is executed, and a socket or a core to which a task is allocated is appropriately selected from a history such as a memory access rate of the task in the middle of execution. be able to. Also, for example, using hardware monitor information, history management of information such as the memory access rate of the task in the middle of execution is performed, and whether a task to be operated using such information is a task with a high memory access rate. It is possible to determine whether or not and appropriately select a socket or core to which a task is assigned based on the information. Further, according to the present embodiment, the processing time per socket can be shortened because the memory access rate is allocated to the sockets and cores with appropriate load distribution.

  Although the embodiments have been described in detail above, the invention is not limited to the specific embodiments, and various modifications and changes can be made within the scope described in the claims. Moreover, it is also possible to combine a part or all of each Example mentioned above.

In addition, the following additional remarks are disclosed regarding the above Example.
(Appendix 1)
Calculate the memory access rate for each task from the hardware monitor information obtained by executing the application,
Based on the calculated memory access rate, in response to a task instruction from the application, the processor executes a process of allocating to a socket or core of a processor in a syntax unit of the task in a program executing the application. Task assignment program for.
(Appendix 2)
The socket 1 to which the task is assigned is selected based on the memory access rate for the task obtained from the hardware monitor information and the memory access rate of the task already assigned to the socket. The task assignment program described.
(Appendix 3)
The task 2 having a high memory access rate is assigned to a socket having a task with a low memory access rate, and the task having a low memory access rate is assigned to a socket having a task having a high memory access rate. The task assignment program described.
(Appendix 4)
The memory access rate is calculated using memory access waiting time or cache miss information included in the hardware monitor information and an elapsed time required to execute the instruction of the task. The task assignment program according to any one of the above items.
(Appendix 5)
The task assignment program according to any one of appendices 1 to 4, wherein assignment to the socket or the core is performed according to the presence or absence of a parent-child relationship of the task.
(Appendix 6)
When the task has a parent-child relationship, a plurality of tasks having the parent-child relationship are allocated to the same socket, and when the task does not have a parent-child relationship, the socket is set so that the memory access rate is uniform in each socket. The task allocation program according to appendix 5, wherein the task allocation program is allocated to
(Appendix 7)
Information processing device
Calculate the memory access rate for each task from the hardware monitor information obtained by executing the application,
Based on the calculated memory access rate, task allocation is performed by assigning a processor socket or core in units of syntax of the task in a program that executes the application in response to a task instruction from the application. Method.
(Appendix 8)
A calculation means for calculating a memory access rate for each task from hardware monitor information obtained by executing the application;
Allocating means for allocating to a processor socket or core in a unit of syntax of the task in a program executing the application in response to a task instruction from the application based on the memory access rate calculated by the calculating means; An information processing apparatus comprising:

DESCRIPTION OF SYMBOLS 10 Information processing apparatus 11 Input means 12 Output means 13 Storage means 14 Allocation means 15 Process execution means 16 Profile information measurement means 17 Calculation means 18 Update means 19 Communication means 20 Control means 31 Input device 32 Output device 33 Drive device 34 Auxiliary storage device 35 Main memory 36 CPU
37 Network connection device 38 Recording medium 41 Memory 42 Socket 43 Core

Claims (5)

For each task, from the hardware monitor information obtained by executing the application, information indicating the presence or absence of the parent-child relationship of the task, and the memory access rate, the task-specific profile information is generated,
Based on the task-specific profile information, in response to a task instruction from the application, a result of executing the task by allocating to a processor socket or core in a syntax unit of the task in a program executing the application Update the task-specific profile information based on
Based on the updated the task-specific profile information, the syntax units of tasks performed by the next task instruction, task allocation program for executing attached Ri allocate to the processor socket or core, the process to the computer. The task assignment program according to claim 1 , wherein a socket to which the task is assigned is selected based on a memory access rate included in the updated profile information for each task.   3. The task having a high memory access rate is assigned to a socket having a task having a low memory access rate, and the task having a low memory access rate is assigned to a socket having a task having a high memory access rate. Task assignment program described in 1.   The task assignment program according to any one of claims 1 to 3, wherein assignment to the socket or the core is performed in accordance with the presence or absence of a parent-child relationship of the task. Information processing device
For each task, from the hardware monitor information obtained by executing the application, information indicating the presence or absence of the parent-child relationship of the task, and the memory access rate, the task-specific profile information is generated,
Based on the task-specific profile information, in response to a task instruction from the application, a result of executing the task by allocating to a processor socket or core in a syntax unit of the task in a program executing the application Update the task-specific profile information based on
A task allocation method comprising: allocating to a processor socket or core in a syntax unit of a task executed by a next task instruction based on the updated task-specific profile information.

Images