JP5776810B2 - Multiprocessor system, control program, and control method - Google Patents

Description

  The present invention relates to a multiprocessor system, a control program, and a control method for storing data in a memory.

  Conventionally, when a CPU (Central Processing Unit) has a cache whose access speed is faster than that of a memory, when a data write request is generated from the CPU, the data is stored in the cache. Thereby, since the CPU can read data from the cache, it is possible to speed up the data reading.

  In a multi-core processor system, the CPU to which each thread is assigned is determined according to the assignment state. Therefore, if there is data shared among a plurality of threads in the target program, the data is transferred to a plurality of CPUs. May be used. Here, the thread is assigned to the multi-core processor, for example, to the CPU having the smallest load.

  Therefore, when a multi-core processor system has a distributed cache for each CPU, a technique (first prior art) for storing the data in the distributed cache of all CPUs when a data write request occurs is known. Yes. A snoop process is performed to maintain data consistency among the distributed caches. In the snoop process, when a change in the cache line is detected in the distributed cache of one CPU, the distributed cache of the other CPU is updated via the snoop bus.

  Further, data is held in any one of the distributed caches of the multi-core processor. A technique (second prior art) is known in which a CPU that does not store data in the distributed cache reads the data by accessing the distributed cache of the CPU that holds the data ( For example, see the following Patent Document 1.)

  In addition, when a multi-core processor system has a local memory for each CPU, a technique is known in which another CPU writes data to the local memory of one CPU (see, for example, Patent Document 2 below).

JP-A-1-251250 Japanese Patent Laid-Open No. 11-39214

  However, in the second prior art, in order for another CPU that does not store data in the distributed cache to read the data, it must access one CPU that stores the data in the distributed cache. Therefore, a speed difference occurs in access to the data between one CPU and another CPU. That is, the second prior art has a problem that the CPU that does not store data in the distributed cache has a low reading speed.

  On the other hand, in the first prior art, since data is stored in the distributed cache of each CPU, the reading speed is not slow as in the second prior art, but all the CPUs of the multi-core processor are stored in the distributed cache. The read data is not always read out. That is, there is a problem in that the distributed cache area of the CPU is occupied by unread data.

  In order to solve the above-described problems caused by the first and second prior arts, the present invention provides a multiprocessor system and control capable of effectively utilizing a cache area without affecting the cache read speed. It is an object to provide a program and a control method.

  According to an aspect of the present invention, a plurality of cores that respectively execute a plurality of threads, and a plurality of caches that store data to be read for each of the plurality of cores when the plurality of threads are executed by the plurality of cores. The first core of the plurality of cores corresponds to the first core of the plurality of caches when executing the first thread of the plurality of threads. The first data is read from the first cache, and the execution of the second thread that reads the first data out of the plurality of threads is assigned to the second core of the plurality of cores, Among the caches, a multiprocessor system for writing the first data to a second cache corresponding to the second core, a control program, and To provide a control method.

  According to the multiprocessor system, the control program, and the control method, the cache area can be effectively used without affecting the cache read speed.

It is explanatory drawing which shows an example of this Embodiment. It is explanatory drawing which shows the example of thread allocation. 2 is a block diagram illustrating an example of hardware of a multi-core processor system 100. FIG. It is explanatory drawing which shows an example of the conversion table. 3 is an explanatory diagram illustrating a detailed example of a distributed cache 111. FIG. 3 is an explanatory diagram illustrating a detailed example of a snoop bus 103. FIG. It is explanatory drawing which shows an example of the list group 700 regarding a dependency. 5 is an explanatory diagram illustrating an example of a thread management table 800. FIG. 2 is a functional block diagram of a multi-core processor system 100. FIG. It is explanatory drawing which shows the example of allocation of the thread | sled 1. FIG. 6 is an explanatory diagram illustrating an example of assignment of a thread 2; FIG. It is explanatory drawing which shows the example in which the variable x is stored. 5 is a flowchart (part 1) illustrating an update processing procedure by the OS 191. 12 is a flowchart (part 2) illustrating an update processing procedure by the OS 191. FIG. 15 is a flowchart showing a detailed description of the conversion table update processing (step S1305 or step S1312) shown in FIGS. 13 and 14. FIG. It is a flowchart which shows the specific process sequence by each MMU. It is a flowchart which shows the storage processing procedure (write request from the snoop bus | bath 103) by a distributed cache controller. It is a flowchart which shows the storage processing procedure (write request from MMU) by a distributed cache controller. It is explanatory drawing which shows an example of an application. It is explanatory drawing which shows the example of storage of a decoding result. It is explanatory drawing which shows the example of storage of a PCM result.

  DESCRIPTION OF EMBODIMENTS Preferred embodiments of a multiprocessor system, a control program, and a control method according to the present invention will be described in detail. In the multi-core processor system according to the present embodiment, the multi-core processor is a processor in which a plurality of cores are mounted. If a plurality of cores are mounted, a single processor having a plurality of cores may be used, or a processor group in which single core processors are arranged in parallel may be used. In the present embodiment, in order to simplify the explanation, a processor group in which single-core processors are arranged in parallel will be described as an example.

  FIG. 1 is an explanatory diagram showing an example of the present embodiment. Each coding example is described in {...} Of thread 1 {...} And thread 2 {.

  In thread 1, 5 is assigned to variable z and 10 is assigned to variable x. Thereafter, in the thread 1, the addition result of the variables z and 10 is substituted into the variable w. Therefore, in thread 1, variable x, variable z, and variable w are output data, and in thread 1, variable z is input data.

  In the thread 2, the variable x is substituted into the variable y, and the multiplication result of the variables z and 100 is substituted into the variable a. Therefore, in thread 2, variable y and variable a are output data, and variable x and variable z are input data.

  The input destination thread for variable x is thread 2, and the input destination threads for variable z are thread 1 and thread 2. The table includes an output data item, an input destination thread item, and an assignment destination CPU identification information item. The output data input destination thread and the assignment destination CPU of the input destination thread are described for each output data. Has been.

  When developing a program having the thread 1 and the thread 2, the developer of the program can specify the output data and the input destination thread of the output data by using a compiler. Further, the assignment destination CPU of the input destination thread changes according to the assignment state of the thread 1 and the thread 2.

  Since the thread 1 is assigned to the CPU 101, when the output data item information is the variable z and the input destination thread identification information item information is the thread 1, the assignment destination CPU identification information item information Is the CPU 101.

  First, when an OS (Operating System) 191 assigns (1) the thread 2 to the CPU, the OS 191 indicates that the output data item information is the variable z and the input destination thread identification information item information is the thread 2 information. In this case, the CPU 102 updates the information of the identification information item of the assignment destination CPU.

  Further, the OS 191 notifies the CPU 102 of information on the identification information item of the assignment destination CPU when the information of the item of output data is the variable x and the information of the identification information item of the input destination thread is the thread 2. Update. Here, it is assumed that the OS 191 detects the assignment of the thread 2 by assigning the thread 2 to the CPU 102.

  Then, when the OS 191 detects (3) a write request for the variable x, the OS 191 searches the information held in the identification information item of the allocation destination CPU from the table based on (4) the variable x. The identification information of the assignment destination CPU is specified. Next, the OS 191 stores the variable x in the distributed cache 112 of the CPU 102 because (5) the identification information of the specified assignment destination CPU indicates the CPU 102.

  Therefore, the target data can be held only in the cache of the CPU to which the thread that uses the target data as an input is allocated among the CPU caches of the multi-core processor. That is, since the target data is not stored in the CPU cache that does not require reading of the target data, each cache area can be effectively used without affecting the read speed at which the input destination thread reads the target data. .

  Further, as described above, since the assignment of the input destination thread is determined according to the assignment state of the CPU as described above, the CPU cache in which the target data is stored also changes according to the assignment state of the input destination thread. .

  FIG. 2 is an explanatory diagram showing an example of thread allocation. (A) In the allocation example 1, the thread 1 is allocated to the CPU 101 and the thread 2 is allocated to the CPU 102 as in the example shown in FIG. (B) In the allocation example 2, both the thread 1 and the thread 2 are allocated to the CPU 101.

  In the allocation example 1 in this embodiment, among the distributed cache 111 and the distributed cache 112, the variable x is stored only in the distributed cache 112, and the variable z is stored in the distributed cache 111 and the distributed cache 112. On the other hand, in the allocation example 2 in the present embodiment, among the distributed cache 111 and the distributed cache 112, the variable x is stored only in the distributed cache 111, and the variable z is also stored only in the distributed cache 111. In the present embodiment, the distributed cache of the CPU that stores the output data is determined by storing and updating the assignment destination CPU of the input destination thread of each output data.

  Next, in the present embodiment, an example is shown in which an allocation destination CPU of an input destination thread for each output data is managed using an MMU (Memory Management Unit) and a thread management table.

(Hardware of the multi-core processor system 100)
FIG. 3 is a block diagram illustrating an example of hardware of the multi-core processor system 100. In FIG. 3, the multi-core processor system 100 includes, for example, a CPU 101 and a CPU 102, an MMU 141 and an MMU 142, a distributed cache 111 and a distributed cache 112, and a shared memory 104. In the present embodiment, the CPU 101 and the CPU 102 are collectively referred to as a multi-core processor.

  Although not shown, the multi-core processor system 100 includes, for example, an I / F (Interface) connected to a network such as the Internet, a display, and a keyboard 109 as input / output devices for users and other devices. I have.

  Here, the CPU 101 and the MMU 141 are connected via the I / F 181, and the MMU 141 and the distributed cache 111 (specifically, the distributed cache controller 121) are connected via the I / F 171. The CPU 102 and the MMU 142 are connected via the I / F 182, and the MMU 142 and the distributed cache 112 (specifically, the distributed cache controller 122) are connected via the I / F 172. The distributed cache controller of each distributed cache and the shared memory 104 are connected via the snoop bus 103.

  The CPU 101 and the CPU 102 each have a core and a register. Specifically, the core is a circuit that realizes an arithmetic function of the CPU. The CPU 101 is a master CPU, executes the OS 191, and controls the entire multi-core processor system 100. The OS 191 has a function of controlling which CPU is assigned to each thread of software, and has a function of controlling switching of threads assigned to the CPU 101. The CPU 102 is a slave CPU and executes the OS 192. The OS 192 has a function of controlling switching of threads assigned to the CPU 102.

  When the MMU 141 and the MMU 142 receive access requests from the CPU 101 and the CPU 102, respectively, the MMU 141 and the MMU 142 have a function of converting from a logical address attached to the access request to a physical address using the conversion table 400. The MMU 141 and the MMU 142 may be included in the CPU 101 and the CPU 102, respectively. Further, although the MMU 141 and the MMU 142 are hardware in the multi-core processor system 100, they may be part of the functions of the OS 191 and the OS 192, respectively, using the MMU 141 and the MMU 142 as software.

(Example of conversion table 400)
FIG. 4 is an explanatory diagram illustrating an example of the conversion table 400. A logical address is an address on a virtual memory space defined in the coding of a program, and a physical address is an address on a shared memory. The conversion table 400 has a physical address obtained by mapping the logical address on the shared memory for each logical address. The conversion table 400 includes a logical address item 401, a physical address item 402, and an area information item 403.

  Since an access request notified from each CPU is accompanied by a logical address, a physical address is obtained by searching the logical address of the access request from information held in the logical address item 401 in the conversion table 400. Can be specified. Further, the area information item 403 holds information that can determine the assignment destination CPU of the input destination thread of the target data arranged in the virtual memory space indicated by each logical address. The area information item 403 has a CPU flag corresponding to each CPU. The area information item 403 includes a CPU 101 flag corresponding to the CPU 101 and a CPU 102 flag corresponding to the CPU 102.

  For example, in the area information item 403, if the CPU 101 flag is 1 and the CPU 102 flag is 0, the assignment destination CPU of the target data input destination thread is the CPU 101. For example, in the area information item 403, if the CPU 101 flag is 0 and the CPU 102 flag is 1, the CPU 101 is the assignment destination CPU of the target data input destination thread.

  Among the area information items 403, for the CPU 101 flag and the CPU 102 flag, the OS 191 determines which flag to set (set to 1) according to the thread allocation state.

  Returning to FIG. 3, the distributed cache 111 includes a distributed cache controller 121 and a distributed cache memory 131. The distributed cache controller 121 controls writing to and reading from the distributed cache memory 131. The distributed cache 112 includes a distributed cache controller 122 and a distributed cache memory 132. The distributed cache controller 122 controls writing to and reading from the distributed cache memory 132.

  The distributed cache controller 121 of the distributed cache 111 passes the physical address, data, and command information to the snoop bus 103 via the master I / F 151. The distributed cache controller 121 receives a physical address, data, and command information from the snoop bus 103 via the slave I / F 161. The distributed cache controller 122 of the distributed cache 112 passes the physical address, data, and command information to the snoop bus 103 via the master I / F 152. The distributed cache controller 121 receives a physical address, data, and command information from the snoop bus 103 via the slave I / F 162.

(Detailed example of distributed cache 111)
FIG. 5 is an explanatory diagram showing a detailed example of the distributed cache 111. As described above, the distributed cache 111 includes the distributed cache controller 121 and the distributed cache memory 131. In the distributed cache memory 131, a physical address, STATE, and data are stored for each data.

  In the distributed cache memory 131, the physical address and STATE are collectively referred to as tag information, and the tag information and data are collectively referred to as a cache line. The distributed cache controller 121 can determine whether or not the target data is stored in the distributed cache memory 131 based on the physical address accompanying the access request for the target data from the MMU 141 or the snoop bus 103.

Here, STATE will be described. STATE is 2-bit information, and the state that each cache line can take is determined by the value of STATE. Although the state differs depending on the protocol that implements the snoop method, the following four states are typical.
-M (Modified) state: a state indicating that the cache line exists only in the cache and has been changed-E (Exclusive) state: a state in which the cache line exists only in the cache and has not been changed -S (Shared) state: a state indicating that a cache line exists in a plurality of caches-I (Invalid) state: a state indicating that the cache line is invalid

  The distributed cache controller 121 operates corresponding to the four states. The operation of the distributed cache controller 121 will be described later with reference to the flowcharts of FIGS. Further, since the distributed cache 112 has the same function as the distributed cache 111, detailed description thereof is omitted.

  Returning to FIG. 3, the snoop bus 103 connects the shared memory 104 and the distributed cache and is a bus corresponding to the snoop process.

(Detailed example of snoop bus 103)
FIG. 6 is an explanatory diagram showing a detailed example of the snoop bus 103. A line in FIG. 6 is one physical signal line, and a black circle represents a connection between the signal lines. The snoop bus 103 includes an address signal line, a command signal line, a data signal line, a controller 601, and a select signal line. Snoop bus 103 receives signals from master I / F 151 and master I / F 152, and slave I / F 161 and slave I / F 162.

  For example, the master I / F 151 and the master I / F 152 send a physical address to the address signal line and command information indicating whether it is a read request or a write request to the command signal line. Then, the controller 601 receives the transmitted physical address.

  The controller 601 outputs a select signal to the select signal line to the corresponding slave I / F based on the physical address and mapping information registered in the controller 601 in advance. The slave I / F that has received the select signal receives the physical address and command information from the master I / F 151 and the master I / F 152, and the slave I / F exchanges data according to the command information.

  Further, the snoop bus 103 has, for example, three functions of broadcast, block, and invalidate. Broadcasting is a function for sending a request for a combination of command information and data information from the master I / F to all slave I / Fs set in advance as broadcast destinations. The block is a function for forcibly releasing the current bus connection. Invalidation is a function for invalidating a cache line corresponding to a target physical address for each distributed cache memory. By using these functions, the snoop bus 103 satisfies the functions required as a cache coherency mechanism.

  Returning to FIG. 3, the shared memory 104 is a memory shared by the CPU 101 and the CPU 102. The shared memory 104 includes, for example, a ROM (Read Only Memory), a RAM (Random Access Memory), a flash ROM, and the like. The shared memory 104 stores, for example, a thread management table 800, a boot program of the OS 191 and OS 192, a control program and application program described later, and a list group 700 related to dependencies.

  For example, the ROM or flash ROM stores the program and the like, and the RAM is used as a work area for the CPU 101 and the CPU 102. The OS 191 and the OS 192 stored in the shared memory 104 are loaded on the CPU 101 and the CPU 102, respectively, thereby causing each CPU to execute a coded process.

(An example of the list group 700 regarding the dependency)
FIG. 7 is an explanatory diagram showing an example of a list group 700 regarding the dependency relationship. In the list group 700 relating to the dependency relationship, output data in the thread and information regarding an input destination thread of the output data for each thread, input data in the thread and information regarding an output source thread of the input data for each thread are displayed. Have.

  The list 701 related to the thread 1 includes an output table 711 and an input table 721, and the list 702 related to the thread 2 includes an output table 712 and an input table 722. The output table 711 includes an output data item and an input destination thread item. In the output table 711, for each piece of data held in the output data item, the input destination thread of the data is held in the input destination thread item. The input table 721 has an input data item and an output source thread item. In the input table 721, for each piece of data held in the input data item, an output source thread of the data is held in the output source thread item.

  The output table 712 includes an output data item and an input destination thread item. In the output table 712, for each piece of data held in the output data item, the input destination thread of the data is held in the input destination thread item. The input table 722 has input data items and output source thread items. In the input table 722, for each data held in the input data item, the output source thread of the data is held in the output source thread item.

  The list relating to the dependency of each thread can be created by, for example, a program designer analyzing each data in the program using a compiler.

(Example of thread management table 800)
FIG. 8 is an explanatory diagram showing an example of the thread management table 800. The thread management table 800 describes the allocation state of the thread and the execution state of the thread for each thread. The thread management table 800 includes a thread identification information item 801, an assignment destination CPU identification information item 802, and an execution state item 803.

  For example, when the OS 191 receives a program start instruction, the OS 191 registers the identification information of all threads in the program in the thread identification information item 801 in the thread management table 800. For example, when the OS 191 determines the assignment destination CPU of each thread for each thread, the OS 191 registers the identification information of the assignment destination CPU in the identification information item 802 of the assignment destination CPU in the thread management table 800. A thread whose identification information of the assignment destination CPU is “−” indicates a state in which the assignment destination CPU is not determined.

  The execution state indicates, for example, whether it is being executed, unallocated (indicated by “−” in the figure), or waiting for execution registered in the ready queue. For example, when the OS 191 or OS 192 performs a task switch, it rewrites the execution state of the execution state item 803 relating to the thread switched by the task switch. In FIG. 8, the identification information of the assignment destination CPU held in the identification information item 802 of the assignment destination CPU regarding the thread 1 and the thread 2 is “−”, and the execution state held in the execution state item 803 is It is “−”.

  Further, the thread management table 800 is stored in each distributed cache memory in addition to the shared memory 104. If there is a change in the thread management table 800 in any of the distributed cache memories, a snoop process is performed via the snoop bus 103. Also good.

  Returning to FIG. 3, the I / F and keyboard connected to the above-described display and network will be described. The display displays data such as a document, an image, and function information as well as a cursor, an icon, or a tool box. As the display, for example, a TFT liquid crystal display can be adopted.

  The I / F is connected to a network such as a LAN (Local Area Network), a WAN (Wide Area Network), and the Internet through a communication line, and is connected to another device via the network. For example, a modem or a LAN adapter may be employed as the I / F. The keyboard has keys for inputting numbers, various instructions, etc., and inputs data. The keyboard may be a touch panel type input pad or a numeric keypad.

  FIG. 9 is a functional block diagram of the multi-core processor system 100. The multi-core processor system 100 includes a storage unit 901, an update unit 902, a detection unit 903, a specification unit 904, a storage unit 905, a determination unit 906, and an erasure unit 907.

  The storage unit 901 is realized by the MMU storing the conversion table 400 and the shared memory 104 storing the thread management table 800, for example. The update unit 902 is defined using, for example, a programming language in the control program, and incorporates the control program in the OS 191. Then, the CPU 101 loads the OS 191 stored in the shared memory 104, and the CPU 101 executes the process coded in the control program in the OS 191 to implement the update unit 902.

  Further, for example, the detection unit 903 and the identification unit 904 are functionally defined by the HDL description, and the HDL description is logically synthesized and combined with elements such as a logic circuit, so that the detection unit 903 and the identification unit 904 Can be realized. For example, the detection unit 903 and the specifying unit 904 are stored in the shared memory 104 as control programs. Then, for example, an MMU having a function capable of executing a program such as the CPU 101 or the CPU 102 may load the control program and execute the process coded in the control program. The storage unit 905, the determination unit 906, and the deletion unit 907 are realized by the distributed cache 111 and the distributed cache 112.

  The storage unit 901 stores the identification information of the assignment destination CPU of the input destination thread for each input destination thread defined as the input destination of the target data.

  When the assignment of the input destination thread to the multi-core processor is detected, the update unit 902 updates the identification information of the assignment destination CPU of the thread stored in the storage unit 901.

  The detection unit 903 detects a write request for target data.

  The identifying unit 904 identifies identification information updated by the updating unit 902 from the storage unit 901 based on the target data for which the writing request is detected by the detecting unit 903.

  The storage unit 905 stores the target data in the distributed cache memory of the assignment destination CPU of the input destination thread for which the identification information after update is specified by the specification unit 904 among the multi-core processors.

  When the request source CPU of the write request is not included in the assignment destination CPU of the input destination thread, the determination unit 906 includes whether the target data is stored in the distributed cache memory of the request source CPU. Judgment based on address information. In the present embodiment, specifically, for example, a physical address is attached to a write request, and a physical address is stored in each cache line in the distributed cache memory. For example, it is determined whether or not the target data is stored based on a match between the physical address of the write request and the physical address of the cache line.

  When the determining unit 906 determines that the target data is stored in the distributed cache memory of the requesting CPU, the deleting unit 907 deletes the target data in the distributed cache memory of the requesting CPU. Specifically, erasing the target data in the distributed cache memory is, for example, invalidating the target data.

  The storage unit 905 stores the target data in the distributed cache memory of the CPU that requested the write request when the identification information after the update is not specified by the specifying unit 904. The case where the identification information after the update is not specified by the specifying unit 904 is specifically, for example, a case where the input destination thread is not assigned.

  Based on the above, a detailed description will be given using examples.

  FIG. 10 is an explanatory diagram illustrating an example of assignment of the thread 1. First, when the OS 191 receives a thread 1 assignment instruction, the OS 191 checks the assignment state of each CPU by referring to the thread management table 800 and assigns the thread 1 to any one of the CPU 101 and the CPU 102. The OS 191 detects (1) the allocation of the thread 1 to the multi-core processor by allocating the thread 1 to the CPU 101.

  Next, the OS 191 searches for the identification information matching the thread 1 from the thread identification information item 801 in the thread management table 800. The OS 191 uses the update unit 902 to update the CPU 101 with the identification information of the assignment destination CPU held in the item 802 of (2) identification information of the assignment destination CPU. Furthermore, the OS 191 updates the execution state held in the execution state item 803 during execution.

  Furthermore, the OS 191 searches the output table 711 for information held in the input destination thread item in the order of the data held in the output data item. In the case of the variable x, the information held in the input destination thread item is the thread 2. The OS 191 searches for the identification information matching the thread 2 from the thread identification information item 801 in the thread management table 800, and assigns the assignment destination CPU stored in the assignment destination CPU identification information item 802 related to the thread 2. Search for identification information. Here, “-” is searched for the identification information of the CPU to which the thread is assigned.

  Since the thread 2 that is the input destination thread of the variable x is unallocated, the OS 191 updates (3) the CPU 101 flag in the conversion table 400 to 1. That is, when the target data input destination thread is unallocated, the target data is stored in the memory of the requesting CPU of the write request. Thereby, the target data can be stored in the distributed cache of at least one CPU, and the area of the distributed cache of another CPU can be effectively used.

  Further, in this embodiment, when the assignment destination CPU of the input destination thread is unknown (when the input destination thread is not assigned), the CPU 101 flag of the output source thread of the variable x is set. All CPU flags may be set. Alternatively, for example, the variable x may be set to be written directly to the shared memory 104 without setting any CPU flag. The OS 191 updates the CPU 101 flag of the record related to the variable z in the conversion table 400 to 1 for the variable z as well as the process related to the variable x described above.

  In the example of FIG. 10, the OS 191 updates the CPU flag in the conversion table 400 every time a thread allocation occurs. However, the present invention is not limited to this. For example, the OS 191 converts the conversion table when a write request occurs. The CPU flag in 400 may be updated.

  FIG. 11 is an explanatory diagram illustrating an example of assignment of the thread 2. First, when the OS 191 receives a thread 2 allocation instruction, the OS 191 checks the allocation state of each thread by referring to the thread management table 800 and allocates the thread 2 to one of the CPU 101 and the CPU 102. The OS 191 detects (1) the allocation of the thread 2 by allocating the thread 2 to the CPU.

  Next, the OS 191 searches for the identification information matching the thread 2 from the thread identification information item 801 in the thread management table 800. The OS 191 updates the identification information of the assignment destination CPU held in the identification information item 802 of the assignment destination CPU whose identification information in the item 801 of the thread identification information is the thread 2 to the CPU 102. Furthermore, the OS 191 updates the execution state held in the execution state item 803 in which the identification information of the item 801 of the thread identification information 801 is the thread 2 during execution.

  Subsequently, the OS 191 acquires the output table 712 from the list 702 related to the thread 2. Then, the OS 191 searches the output table 712 for the input destination thread identification information held in the input destination thread item in the order of the output data held in the output data item. Here, the update process of the conversion table 400 related to the variable y and the variable a that are output data in the thread 2 is the same as the update process of the variable x described in FIG.

  Next, the OS 191 acquires the input table 722 from the list 702 related to the thread 2. Then, the OS 191 searches the input table 722 for the output source thread identification information held in the output source thread item in the order of the input data held in the input data item. Here, since the output source thread of the variable x and the variable z that are input data of the thread 2 is the thread 1, the search result is the thread 1. Then, the OS 191 acquires the output table of the searched output source thread. That is, the output table 711 is acquired from the list 701 related to the thread 1.

  The OS 191 searches the input destination thread identification information held in the input destination thread item in the order of the output data held in the output data item from the output table 711. Here, the update process of the conversion table 400 related to the variable x and the variable z that are output data in the thread 1 is the same as the update process of the variable x described in FIG. As a result, (3) the CPU flag of the record relating to the variable x in the conversion table 400 is updated.

  FIG. 12 is an explanatory diagram illustrating an example in which the variable x is stored. Next, when a write request for the variable x occurs in the thread 1, the OS 191 detects the write request, and (1) notifies the MMU 141 of the write request accompanied by the logical address and the write data. The MMU 141 uses the detection unit 903 to search for a logical address held in the logical address item 401 in the same translation table 400 as the logical address associated with the received write request. Then, the MMU 141 converts the logical address to the physical address by searching for the physical address held in the physical address item 402 corresponding to the searched logical address.

  Then, the MMU 141 reads the CPU flag corresponding to the searched logical address in the conversion table 400 by the specifying unit 904, and (3) specifies the assignment destination CPU of the input destination thread of the variable x. The CPU flag corresponding to the searched logical address is a CPU flag on a record including the searched logical address. The MMU 141 associates the physical address, write data, and each CPU flag with the write request, and notifies the distributed cache controller 121 of the write request.

  When the distributed cache controller 121 receives the write request, the distributed cache controller 121 refers to each CPU flag and stores the write data in the CPU indicated by the CPU flag being 1. Here, since the CPU flag is 0 and the CPU flag is 1, the distributed cache controller 121 does not store the write data in the distributed cache memory 131 of the CPU 101 (5) the CPU 102 by the storage unit 905. Write data is stored in the distributed cache memory 132.

(Update processing procedure by OS 191)
13 and 14 are flowcharts showing the update processing procedure by the OS 191. FIG. First, the OS 191 determines whether a thread activation instruction has been received (step S1301). When the OS 191 determines that a thread activation instruction has not been received (step S1301: No), the process returns to step S1301. When the OS 191 determines that a thread activation instruction has been received (step S1301: Yes), it determines an assignment destination CPU of the thread (target thread) that has received the activation instruction (step S1302).

  Next, the OS 191 causes the update unit 902 to update the thread management table 800 based on the determination result (step S1303). Then, the OS 191 acquires an output table in which the output destination thread of the output data is described for each output data of the target thread (step S1304), and the update unit 902 executes update processing of the conversion table 400 (step S1305). ).

  Then, the OS 191 acquires an input table describing the output source thread of the input data for each input data of the target thread (step S1306), and whether there is unselected input data among the input data in the target thread. It is determined whether or not (step S1307). When the OS 191 determines that there is unselected input data (step S1307: Yes), one input data (selected input data) is selected from the unselected input data (step S1308).

  Then, the OS 191 sets a flag corresponding to the assignment destination CPU of the target thread in the area information regarding the selected input data to 1 (step S1309). The OS 191 searches for the output source thread of the selected input data based on the input table (step S1310), and acquires an output table in which the output destination thread of the output data is described for each output data in the searched output source thread. (Step S1311). Then, the OS 191 executes the update process of the conversion table 400 by the update unit 902 (step S1312), and returns to step S1307.

  In step S1307, when the OS 191 determines that there is no unselected input data among the input data in the target thread (step S1307: No), the process returns to step S1301.

  FIG. 15 is a flowchart showing a detailed description of the conversion table update processing (step S1305 or step S1312) shown in FIGS. First, the OS 191 determines whether there is unselected output data among the output data in the acquired output table (step S1501). When the OS 191 determines that there is unselected output data among the output data in the acquired output table (step S1501: Yes), one output data (selected output data) is selected from the unselected output data. Select (step S1502).

  The OS 191 searches for the input destination thread of the selected output data based on the output table (step S1503), and specifies the allocation destination CPU of the searched input destination thread based on the thread management table 800 (step S1504). Next, the OS 191 sets the CPU flag corresponding to the specified assignment destination CPU among the CPU flags related to the selected output data to 1 (step S1505).

  Then, the OS 191 sets the CPU flags corresponding to the CPUs excluding the specified allocation destination CPU among the CPU flags related to the selected output data to 0 (step S1506), and determines whether the allocation destination CPUs of all the input destination threads have been specified. Is determined (step S1507). When the OS 191 determines that the assignment destination CPUs of all input destination threads have been specified (step S1507: Yes), the process returns to step S1501.

  When the OS 191 determines that the assignment destination CPUs of all input destination threads have not been specified (step S1507: No), the flag corresponding to the assignment destination CPU of the target thread is set to 1 among the CPU flags related to the selected output data. (Step S1508). Thereby, the target data can be stored in the distributed cache of at least one CPU, and the area of the distributed cache of another CPU can be effectively used. Then, the OS 191 returns to step S1501 after step S1508.

  If the OS 191 determines that there is no unselected output data among the output data in the acquired output table (step S1501: No), the process proceeds to step S1306 (step S1307).

(Specific processing procedure by each MMU)
FIG. 16 is a flowchart showing a specific processing procedure by each MMU. First, the MMU determines whether or not the detection unit 903 has detected a write request for target data (step S1601). When the MMU determines that the write request for the target data has not been detected (step S1601: No), the process returns to step S1601.

  When the MMU determines that the write request for the target data has been detected (step S1601: Yes), the identifying unit 904 searches the conversion table 400 for a record related to the target data based on the logical address associated with the detected write request. (Step S1602). Then, the MMU associates the physical address in the retrieved record instead of the logical address with the write request (step S1603).

  Next, the MMU causes the identification unit 904 to associate the CPU flag from the retrieved record with the write request (step S1604), notifies the distributed cache controller of the write request (step S1605), and returns to step S1601.

(Storage processing procedure by each distributed cache controller)
FIG. 17 is a flowchart showing a storage processing procedure (write request from the snoop bus 103) by the distributed cache controller. First, the distributed cache controller determines whether a write request from the snoop bus 103 has been received (step S1701). If the distributed cache controller determines that it has not accepted a write request from the snoop bus 103 (step S1701: No), the process returns to step S1701.

  On the other hand, when the distributed cache controller determines that a write request from the snoop bus 103 has been received (step S1701: Yes), the process proceeds to step S1702. In step S1702, the distributed cache controller determines whether or not the target cache line is on the distributed cache memory corresponding to the distributed cache controller (step S1702). When the distributed cache controller determines that the target cache line is not on the distributed cache memory corresponding to the distributed cache controller (step S1702: No), it determines whether there is only one output destination CPU (step S1703). .

  When the distributed cache controller determines that there is only one output destination CPU (step S1703: Yes), the target cache line is fetched in the M state (step S1704). Fetching the target cache line in the M state indicates that the tag information STATE is set to the M state and fetched. When the distributed cache controller determines that there is not only one output destination CPU (step S1703: No), the target cache line is fetched in the S state (step S1705). Fetching the target cache line in the S state indicates that the tag information STATE is set to the S state and fetched.

  After step S1704 or step S1705, the distributed cache controller updates data on the target cache line in the distributed cache memory corresponding to the distributed cache controller (step S1706), and the process returns to step S1701. When the distributed cache controller determines that the target cache line is on the distributed cache memory corresponding to the distributed cache controller (step S1702: Yes), the process proceeds to step S1706.

  FIG. 18 is a flowchart showing a storage processing procedure (write request from the MMU) by the distributed cache controller. First, the distributed cache controller determines whether a write request from the MMU has been received (step S1801). If the distributed cache controller determines that it has not accepted a write request from the MMU (step S1801: No), the process returns to step S1801.

  On the other hand, if the distributed cache controller determines that a write request from the MMU has been received (step S1801: Yes), it determines whether a CPU flag is attached to the write request (step S1802). When the distributed cache controller determines that the CPU flag is not attached to the write request (step S1802: No), it operates as a normal snoop-compatible cache controller (step S1803) and returns to step S1801.

  In the normal operation as a snoop-compatible cache controller, whether or not the target cache line is stored in the distributed cache memory is determined based on the tag information, and if it is stored, the target cache line is updated. On the other hand, when the target cache line is not stored in the distributed cache memory, the target cache line is fetched onto the distributed cache memory. Then, storage of the target cache line is notified to the distributed cache controllers of all CPUs.

  When the distributed cache controller determines in step S1802 that the CPU flag is attached to the write request (step S1802: Yes), the determination unit 906 determines whether the CPU flag corresponding to the requesting CPU of the write request is 1 or not. Is determined (step S1804). When the distributed cache controller determines that the CPU flag corresponding to the requesting CPU of the write request is 1 (step S1804: Yes), it determines whether or not the target cache line is on the distributed cache memory (step S1805). ).

  When the distributed cache controller determines that the target cache line is not on the distributed cache memory (step S1805: No), it determines whether there is one output destination CPU (step S1806). When the distributed cache controller determines that there is one output destination CPU (step S1806: Yes), the target cache line is fetched in the M state (step S1807).

  When the distributed cache controller determines that the number of output destination CPUs is not one (step S1806: No), the target cache line is fetched in the S state (step S1808). After step S1807 or step S1808, the distributed cache controller updates data on the target cache line in the distributed cache memory (step S1809).

  If the distributed cache controller determines in step S1805 that the target cache line is on the distributed cache memory (step S1805: YES), the process proceeds to step S1809.

  In step S1804, when the distributed cache controller determines that the CPU flag corresponding to the requesting CPU of the write request is not 1 (step S1804: No), it determines whether the target cache line is on the distributed cache memory. (Step S1810).

  First, when the distributed cache controller determines that the target cache line is on the distributed cache memory (step S1810: Yes), the data of the target cache line is written back to the shared memory 104 (step S1811). Then, the distributed cache controller invalidates the target cache line by the erasing unit 907 (step S1812). To invalidate the target cache line is to set the STATE of the target cache line to the I state. Setting STATE to the I state indicates erasing the target cache line.

  If the distributed cache controller determines in step S1810 that the target cache line is not on the distributed cache memory (step S1810: No), the process proceeds to step S1813. In the case of step S1809, step S1810: No, or after step S1812, a write request is notified to the distributed cache specified by the CPU flag (step S1813), and the process returns to step S1801.

(Example of application)
Here, a multi-channel audio decoder is taken as an example as a specific application. The multi-channel audio decoder is a process for decoding and outputting audio data.

  First, compressed audio data is decoded for one unit. The decoding result is 4 KB (Byte) size from 1 to 7 channels. The decoding result is subjected to filter processing and processing / synthesis (PCM (Pulse Code Modulation)) processing for each channel.

  The audio data that has been subjected to the filter processing and PCM processing is aggregated for all channels, and the audio data after aggregation is subjected to downmix processing in accordance with the number of channels of a playback device (speaker) installed in the device. The audio data after the downmix process is output to the playback device. Since one unit of audio data is about several tens of ms, the multi-channel audio decoder reproduces long-time audio data by repeatedly performing decoding processing, filtering processing, and PCM processing of the next audio data while outputting to the playback device. doing.

  Since the filtering process and the PCM process can be executed for each channel, it is possible to execute the filtering process and the PCM process for each channel in a multi-core processor in parallel with multi-channel audio data.

  FIG. 19 is an explanatory diagram illustrating an example of an application. Here, as shown in FIG. 19, an example in which the processing is divided into threads of decoding processing, filter processing and PCM processing of each channel, and downmix and output processing will be described. The thread that performs the decoding process is the thread DEC, the threads that perform the filtering process and the PCM process are the threads CH1 to CH7 and the thread CH7.1, and the thread that performs the filtering process and the PCM process is the thread DM.

  First, the thread DEC outputs decoded audio data (decoding result) for all channels. Each of the threads CH1 to CH7 and the thread CH7.1 inputs the decoded audio data (decode result) for one channel and outputs the processed audio data (PCM result) for one channel. In the thread DM, processed audio data for all channels is input.

  FIG. 20 is an explanatory diagram of an example of storing the decoding result. In FIG. 20, a thread CH1 and a thread CH2 are assigned to the CPU 2001, and a thread CH3 and a thread CH4 are assigned to the CPU 2002. A thread CH5 and a thread CH6 are assigned to the CPU 2003, and a thread CH7, a thread CH7.1, a thread DEC, and a thread DM are assigned to the CPU 2004. Here, only the thread DEC is being executed (solid line thread in the figure), and all other threads are waiting to be executed (threads in broken line in the figure).

  When the multi-core processor system shown in FIG. 20 includes the storage unit 901 to the storage unit 905, the decoding result that is an input to the thread CH1 and the thread CH2 among the decoding results of the thread DEC is only in the distributed cache 2011 of the CPU 2001. Is output. Of the decoding results of the thread DEC, the decoding results that are input to the threads CH3 and CH4 are output only to the distributed cache 2012 of the CPU 2002.

  Further, among the decoding results of the thread DEC, the decoding results that are input to the threads CH5 and CH6 are output only to the distributed cache 2013 of the CPU 2003. Of the decoding results of the thread DEC, the decoding results that are input to the threads CH7 and CH7.1 are stored only in the distributed cache 2014 of the CPU 2004.

  In FIG. 20, arrows appear from the thread DEC to the decoding results in the distributed cache 2013, the distributed cache 2012, and the distributed cache 2011. Actually, the decoding result is stored in each distributed cache via the MMU of the CPU 2004, the distributed cache controller in the distributed cache 2014, and the snoop bus.

  FIG. 21 is an explanatory diagram of an example of storing PCM results. The threads CH1 to CH7 and the thread CH7.1 are being executed (the solid line thread in the figure), and the thread DEC and the thread DM are waiting to be executed (the broken line thread in the figure). When the multi-core processor system shown in FIG. 21 includes the storage unit 901 to the storage unit 905, the result of each PCM is used in the thread DM. Therefore, the result of each PCM is the distributed cache of the CPU to which the thread DM is assigned. Stored only in.

  In FIG. 21, an arrow appears from the thread of each channel to the result of each PCM in the distributed cache 2014. Actually, the result of each PCM is stored in the distributed cache 2014 via the MMU of the CPU to which the thread of each channel is allocated, the distributed cache controller in the distributed cache of the CPU, and the snoop bus.

  As described above, according to the multiprocessor system, the control program, and the control method, the target data is stored only in the distributed cache of the allocation destination CPU of the input destination thread that uses the target data as an input among the multicore processors. As a result, the target data is not stored in the distributed cache of the CPU that does not require reading of the target data. Therefore, each distributed cache area can be used effectively without affecting the read speed at which the input destination thread reads the target data.

  Further, when the request source CPU of the target data write request is not included in the assignment destination CPU of the input destination thread, when the target data is already stored in the distributed cache of the request source CPU, the distribution of the request source CPU The target data is already deleted in the cache. As a result, the area of the data that is not read can be erased, and the area of the distributed cache of the CPU that does not read the target data can be used effectively.

  When the target data input destination thread is not assigned to the multi-core processor, the target data is stored in the memory of the requesting CPU of the write request. Thereby, the target data can be stored in the distributed cache of at least one CPU, and the area of the distributed cache of another CPU can be effectively used.

100 multi-core processor system 101, 102, 2001, 2002, 2003, 2004 CPU
121, 122 Distributed cache controller 131, 132 Distributed cache memory 901 Storage unit 902 Update unit 903 Detection unit 904 Identification unit 905 Storage unit 906 Judgment unit 907 Erasing unit

Claims (4)

Multiple cores each running multiple threads,
And a plurality of caches that store data to be read for each of the plurality of cores when the plurality of threads are executed by the plurality of cores, wherein a first core of the plurality of cores includes:
When executing a first thread of the plurality of threads, a first data write request corresponding to the first thread is detected, and the first data is read from the plurality of threads. Assigning the execution of two threads to a second core of the plurality of cores, and writing the first data to a first cache corresponding to the first core of the plurality of caches , A multiprocessor system for writing the first data to a second cache corresponding to a second core. 2. The multiprocessor system according to claim 1, wherein the first core deletes the first data from the first cache when the first data is included in the first cache. 3. A control method for a multiprocessor system, comprising: a plurality of cores that respectively execute a plurality of threads; and a plurality of caches that store data to be read for each of the plurality of cores when the plurality of threads are executed by the plurality of cores. And a first core of the plurality of cores is
Detecting a first data write request corresponding to the first thread when executing a first thread of the plurality of threads;
Of the plurality of threads, assigns execution of a second thread that reads the first data to a second core of the plurality of cores,
Write the first data to the second cache corresponding to the second core without writing the first data to the first cache corresponding to the first core among the plurality of caches.
A control method of a multiprocessor system for executing processing. A control program for a multiprocessor system, comprising: a plurality of cores that respectively execute a plurality of threads; and a plurality of caches that store data to be read for each of the plurality of cores when the plurality of threads are executed by the plurality of cores. In the first core among the plurality of cores,
Detecting a first data write request corresponding to the first thread when executing a first thread of the plurality of threads;
Of the plurality of threads, assigns execution of a second thread that reads the first data to a second core of the plurality of cores,
Write the first data to the second cache corresponding to the second core without writing the first data to the first cache corresponding to the first core among the plurality of caches.
A control program for a multiprocessor system that executes processing.

Images