WO2018021620A1 - 병렬 프로세싱 유닛 및 이를 포함하는 컴퓨팅 디바이스, 그리고 쓰레드 그룹 스케줄링 방법 - Google Patents

병렬 프로세싱 유닛 및 이를 포함하는 컴퓨팅 디바이스, 그리고 쓰레드 그룹 스케줄링 방법 Download PDF

Info

Publication number
WO2018021620A1
WO2018021620A1 PCT/KR2016/011719 KR2016011719W WO2018021620A1 WO 2018021620 A1 WO2018021620 A1 WO 2018021620A1 KR 2016011719 W KR2016011719 W KR 2016011719W WO 2018021620 A1 WO2018021620 A1 WO 2018021620A1
Authority
WO
WIPO (PCT)
Prior art keywords
cache
warp
thread group
interference
shared memory
Prior art date
Application number
PCT/KR2016/011719
Other languages
English (en)
French (fr)
Inventor
정명수
장지에
Original Assignee
주식회사 맴레이
연세대학교 산학협력단
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Priority claimed from KR1020160119514A external-priority patent/KR20180012167A/ko
Application filed by 주식회사 맴레이, 연세대학교 산학협력단 filed Critical 주식회사 맴레이
Publication of WO2018021620A1 publication Critical patent/WO2018021620A1/ko

Links

Images

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/46—Multiprogramming arrangements
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F12/00—Accessing, addressing or allocating within memory systems or architectures
    • G06F12/02—Addressing or allocation; Relocation
    • G06F12/08—Addressing or allocation; Relocation in hierarchically structured memory systems, e.g. virtual memory systems
    • G06F12/0802—Addressing of a memory level in which the access to the desired data or data block requires associative addressing means, e.g. caches
    • G06F12/0806—Multiuser, multiprocessor or multiprocessing cache systems
    • G06F12/084—Multiuser, multiprocessor or multiprocessing cache systems with a shared cache

Definitions

  • the present invention relates to a parallel processing unit, a computing device comprising the same, and a thread group scheduling method.
  • Parallel processing units such as graphic processing units (GPUs) have shown significant performance improvements for general purpose applications through massive thread-level parallelism (TLP).
  • TLP massive thread-level parallelism
  • the current GPU architecture which consists of many stream multiprocessors (SMs), clusters multiple threads into thread groups (which can be called warps).
  • SMs stream multiprocessors
  • warps thread groups
  • each SM employs a hardware-based warp scheduler. For high performance, it is necessary to allocate as many warps as possible to each SM to maximize the usefulness of the execution pipeline.
  • This warp scheduling method is not sufficient to maximize TLP when memory intensive applications need to process large amounts of data. This is because Active Warp generates too many memory requests intensively and competes for a limited amount of on-chip cache. This cache contention can seriously degrade performance.
  • the divers cache-aware warp scheduling policies have been proposed, but these warp scheduling policies improve the L1D cache hit rate and enable the active with high data locality. It aims to improve performance by identifying warps and giving them higher scheduling priority than other warps. That is, these warp scheduling policies throttle warps with low likelihood of data locality to reduce TLP, thereby increasing the overall L1D cache hit rate and thus improving overall performance.
  • warp scheduling policy may not be sufficient for memory intensive applications involving irregular cache access patterns for the following reasons.
  • Cache accesses to active warps with high likelihood of data locality can often seriously interfere with other warps.
  • simply scheduling active warps based on the possibility of data locality can increase cache interference and negatively impact cache hit rates.
  • a parallel processing unit includes a multiprocessor.
  • the multiprocessor includes a memory unit and a thread group scheduler.
  • the memory unit includes an L1D cache and a shared memory to which a plurality of cache lines are allocated.
  • the thread group scheduler isolates the second thread group by changing the cache access of the second thread group to the shared memory when a first predetermined condition is satisfied for the first thread group in an active state.
  • the first condition may include a condition where the level of cache interference for the first thread group exceeds a first cutoff.
  • the second thread group may include a thread group that interferes most frequently among a group of threads that interfere with the first thread group.
  • the thread group scheduler may change the cache access of the second thread group back to the L1D cache.
  • the second condition may include a condition that is less than or equal to a second cutoff in which the level of cache interference for the first thread group is lower than the first cutoff.
  • the second condition may include a condition in which execution of the first thread group is completed.
  • the thread group scheduler may determine the first condition at the end of the first time period and determine the second condition at the end of the second time period.
  • the thread group scheduler may stall the isolated second thread group.
  • the second condition may include a condition where a level of cache interference for a third group of threads isolated to the shared memory exceeds a first cutoff.
  • the thread group scheduler may reactivate the stalled second thread group.
  • the third condition may include a condition that is less than or equal to a second cutoff in which the level of cache interference for the third thread group is lower than the first cutoff.
  • the second condition may include a condition in which execution of the third thread group is completed.
  • the thread group scheduler may determine the second condition at the end of the first time period and determine the third condition at the end of the second time period.
  • a computing device including a parallel processing unit, a CPU, a system memory, and a memory bridge connecting the parallel processing unit, the CPU, and the system memory according to the previous embodiment.
  • a parallel processing unit including a multiprocessor.
  • the multiprocessor includes a memory unit including an L1D cache and shared memory, and a thread group scheduler.
  • the shared memory includes a plurality of shared memory banks having a plurality of rows, and the plurality of shared memory banks are grouped into a plurality of bank groups.
  • a plurality of cache lines are allocated to a plurality of shared memory banks belonging to each bank group, and the thread group scheduler changes the cache access of some thread groups to cache lines of the shared memory.
  • the bank group to which a cache line is allocated may be assigned a number of a thread group corresponding to the tag for the certain cache line.
  • a thread group scheduling method of a parallel processing unit including a memory unit including an L1D cache and a shared memory may further include detecting a level of cache interference for a first thread group, and when the level of the cache interference exceeds a first cutoff, a predetermined group of threads causing interference with the first thread group. Changing the cache access of the second thread group that satisfies the condition to the shared memory to isolate the second thread group.
  • the thread group scheduling method may further include detecting a level of cache interference for the first thread group, and if the level of the detected cache interference is lower than a second cutoff lower than the first cutoff.
  • the method may further include changing cache access of a thread group back to the L1D cache.
  • the thread group scheduling method may further include detecting a level of cache interference for a third thread group that is isolated to the shared memory, and if the level of cache interference for the third thread group exceeds a second cutoff. And stalling the isolated second thread group.
  • the thread group scheduling method may further include detecting a level of cache interference for the third thread group, and a third cutoff in which the level of the detected cache interference for the third thread group is less than the second cutoff. If lower, the method may further include reactivating the stalled second thread group.
  • cache interference can be reduced while maintaining thread level parallelism.
  • FIG. 1 is a schematic block diagram of a computing device in accordance with one embodiment of the present invention.
  • FIG. 2 is a schematic block diagram of a parallel processing unit according to an embodiment of the present invention.
  • FIG. 3 is a diagram illustrating an example in which a cache interference deteriorates data locality in an L1D cache in a typical multiprocessor.
  • FIG. 4 is a flowchart illustrating a warp scheduling method in a parallel processing unit according to an embodiment of the present invention.
  • FIG 5, 6 and 7 are diagrams illustrating warp partitioning in a parallel processing unit according to an embodiment of the present invention, respectively.
  • FIG. 8 is a flowchart illustrating a warp scheduling method in a parallel processing unit according to another embodiment of the present invention.
  • FIG. 12 is a diagram illustrating a method of managing warps that cause interference most often in a parallel processing unit according to an embodiment of the present invention.
  • FIG. 13 is a diagram illustrating cache interference in a parallel processing unit.
  • FIG. 14 is a diagram illustrating a Victim tag array in a parallel processing unit according to an embodiment of the present invention.
  • 15 and 16 are flowcharts illustrating a warp scheduling method in a parallel processing unit according to an embodiment of the present invention, respectively.
  • 17 is a schematic block diagram of a multiprocessor in a parallel processing unit according to an embodiment of the present invention.
  • FIG. 18 is a diagram illustrating an operation of a memory unit in a parallel processing unit according to an embodiment of the present invention.
  • 19 is a diagram illustrating a structure of a memory unit in a parallel processing unit according to an embodiment.
  • 20 is a diagram illustrating an address translation in a parallel processing unit according to an embodiment.
  • 1 is a schematic block diagram of a computing device in accordance with one embodiment of the present invention. 1 is an example of a possible computing device, and may be implemented in other various structures of the computing device according to an embodiment of the present invention.
  • a computing device includes a central processing unit (CPU) 110, a system memory 120, and a parallel processing unit 130.
  • CPU central processing unit
  • system memory 120 includes a parallel processing unit 130.
  • parallel processing unit 130 includes a parallel processing unit 130.
  • the system memory 120 may communicate with the CPU 110 through the memory bridge 140.
  • the memory bridge 140 may be, for example, a northbridge.
  • the memory bridge 140 may be connected to an input / output (I / O) bridge 150 via a bus or a communication channel.
  • the I / O bridge 150 may be, for example, a southbridge, and may receive user input from a user input device (not shown) and pass it to the CPU 110 via the memory bridge 140. .
  • the parallel processing unit 130 may be connected to the memory bridge 140 via a bus or a communication channel to communicate with the CPU 110 and the system 120.
  • the parallel processing unit 130 may be, for example, a graphic processing unit (GPU).
  • a system that includes a CPU 110, a system memory 120, a memory bridge 140, and an I / O bridge 150 may be referred to as a host.
  • FIG. 2 is a schematic block diagram of a parallel processing unit according to an embodiment of the present invention.
  • a parallel processing unit includes one or more multiprocessors 200.
  • the parallel processing unit can be, for example, a GPU, and the multiprocessor 200 can be, for example, a streaming multiprocessor (SM).
  • SM streaming multiprocessor
  • a series of instructions passed to the multiprocessor 200 may form a thread.
  • a thread can be an instance of a program.
  • a certain number of threads for example, 32 are simultaneously executed in the multiprocessor 200, and the predetermined number of threads is called a thread group.
  • a thread group may be referred to as a "warp", "container” or "wavefront", and for convenience of description, the thread group is warped below.
  • a thread group may be a group of threads that concurrently run the same program for different input data.
  • a plurality of warps may be active at the same time in the multiprocessor 200, and threads of the plurality of warps may be referred to as a cooperative thread array (CTA).
  • CTA cooperative thread array
  • the multiprocessor 200 includes an instruction buffer 210, warp scheduler 220, a plurality of processing units 230, a plurality of load-store units (LSUs) 240 and memory units. 250.
  • the instruction buffer 210 stores instructions transmitted to the multiprocessor 200, and the warp scheduler 220 schedules instructions of the warp, and selects and outputs the corresponding warp instructions from the instruction buffer 210 according to the scheduling. do.
  • the multiprocessor may further include a fetch / decoder 205, which fetches / decoders 205 and then invokes and decodes the instructions passed to the multiprocessor 200, followed by an instruction buffer. Stored at 210.
  • each active warp in the instruction buffer 210 may have a dedicated set of entries.
  • multiprocessor 200 may further include a scoreboard (not shown) to identify data risks. In this case, if the scoreboard indicates that there is no risk for the warp, the warp scheduler 220 may select the decoded instruction of this warp from the instruction buffer 210.
  • Each processing unit 230 processes an instruction output from the warp scheduler 220.
  • the processing unit 230 includes a variety of computing operations, such as integer and floating point arithmetic, comparison operations, Boolean operations, bit-shifting, Can support operations such as calculating various algebraic functions.
  • processing unit 230 may be, for example, an arithmetic logic unit (ALU).
  • ALU arithmetic logic unit
  • Each load-storage unit 240 loads or stores data in the memory unit 250.
  • the memory unit 250 includes a level 1 data (L1D) cache 251 and a shared memory 252.
  • memory unit 250 may be an on-chip memory unit of multiprocessor 200.
  • L1D cache 251 and shared memory 252 may share a single on-chip memory structure including, for example, 32 banks of 512 or 256 rows. N rows may be allocated to the L1D cache 251, and the remaining (eg, (512-N) or (256-N)) rows may be allocated to the shared memory 252.
  • Shared memory 252 may be managed by software. Each CTA can request exclusive shared memory space for inter-thread communication. Thus, in some embodiments, the multiprocessor 200 may maintain an independent shared memory management table (SMMT) 261. Each CTA reserves one SMMT entry, which records the start address and size of the shared memory space for a given CTA (CTAid). Also, in some embodiments, the multiprocessor 200 may connect the load-storage unit 240 and the memory unit 250 via a crossbar network 262.
  • SMMT shared memory management table
  • the shared memory 252 is assigned a plurality of cache lines such that some warp cache accesses are changed to the shared memory 252.
  • the multiprocessor 200 may include a hardware coalescing unit to integrate a plurality of memory requests generated by a thread of warp into a smaller but larger memory request to improve the usefulness of the memory bandwidth. 263 and a miss status holding register (MSHR) 264.
  • MSHR miss status holding register
  • multiple warps share the L1D cache 251 with limited capacity, so that multiple warps may compete for the same cache line.
  • cached data of one active warp in L1D cache 251 may be evicted by cache access of another active warp requesting memory access, thus losing data locality. This phenomenon is called cache interference.
  • cache interference may worsen when the cache access pattern is irregular.
  • FIG. 3 is a diagram illustrating an example in which cache interference deteriorates data locality in an L1D cache in a typical multiprocessor.
  • warp W0 and W1 repeatedly request data D0 and D4 from the same cache set Set0 of the L1D cache.
  • the warp W0 requesting data D0 from the cycle CA then evicts the data D4 of the warp W1 from the L1D cache 270, but since the data set D0 is not in the cache set Set0, the cold miss (cold miss) occurs.
  • warp W1 requesting data D4 in cycle CB has no data D4 in cache set Set0, a miss (conflict miss) occurs, and the data request of warp W1 is warped.
  • the data D0 of (W0) is evicted from the cache set (Set0).
  • warp W0 requesting data D0 in cycle CE retires data D4 of warp W1 from cache set Set0 and warp W1 requesting data D4 in cycle CF. ) May withdraw the data D0 of the warp W0 from the cache set Set0. As a result, collision misses continue to occur.
  • warps W0 and W1 continue to generate memory requests to repeatedly obtain data D0 and D4 in cycles CA, CB, CE and CF, respectively. These memory requests should have hit the L1D cache if the data D0, D4 were not evicted by the other warps W1, W0.
  • This cache hit opportunity may be called the potential of data locality and is measured as the frequency of re-referencing the same data if cache interference has not occurred.
  • both warps W0 and W1 show a high probability of data locality, but cache interference between them results in unnecessary cache misses, which can turn regular memory access into irregular cache access.
  • interfering warps can be isolated from interfering warps.
  • the L1D cache space may be partitioned, and the partitioned cache line may be assigned to the interfering warp.
  • various techniques for partitioning shared cache space for a CPU have been proposed.
  • the number of threads sharing L1D cache lines in parallel processing units such as GPUs is very large compared to the number of CPU threads
  • the size of the L1D cache is not large enough to apply CPU-based cache partitioning techniques to parallel processing units. For example, applying a CPU-based cache partitioning technique to the L1D cache, only two or three cache lines can be assigned to each warp. The small number of cache lines per warp can then make cache thrashing worse.
  • this unused shared memory space is used to allow interfering warps to access unused shared memory space instead of the L1D cache.
  • FIGS. 5, 6 and 7 respectively illustrate warp partitioning in a parallel processing unit according to an embodiment of the present invention. warp partitioning).
  • the multiprocessor of the parallel processing unit detects a warp causing interference (for example, W3 requesting the data D3 of FIGS. 5 and 6) (S430).
  • the predetermined condition may be a condition where the strength of cache interference in the L1D cache 510 exceeds a threshold. In other words, if the strength of cache interference exceeds a threshold, the multiprocessor can detect the warp causing the interference.
  • the multiprocessor partitions the active warp into an interfering warp and an interfering warp, and changes the shared warp space 520 not using cache access of the interfering warp W3. (Redirect) to isolate the warp (W3) causing the interference (S440). This can reduce cache contention without dropping thread-level parallelism (TLP) in parallel processing units.
  • TLP thread-level parallelism
  • the multiprocessor warps causing interference as shown in FIG. Desegregate the isolation and redirect the memory request of this warp from the shared memory 520 to the L1D cache 510 again (S460).
  • another predetermined condition is one in which cache contention is significantly reduced, for example, a condition where the strength of cache interference is lower than a threshold. That is, upon detecting a significant decrease in cache contention, the multiprocessor abolishes the interfering warp's isolation policy and changes the warp's memory request back to the L1D cache 510.
  • the threshold at step S450 may be different than the threshold at step S420. For example, the threshold at step S450 may be less than the threshold at step S420. In another embodiment, the threshold at step S450 may be the same as the threshold at step S420.
  • the multiprocessor may use an interference detector (not shown) to determine the number of cache contentions, i.e., the strength of the cache interference, in steps S420 and S450.
  • the cache interference reduction method described above with reference to FIGS. 4 to 7, that is, the warp partitioning method, may be performed by the warp scheduler 220 of FIG. 2.
  • memory requests may be communicated to the L1D cache 510 or shared memory 530 via the crossbar network 530.
  • the multiprocessor changes the memory request of warp W3 that causes interference from L1D cache 510 to shared memory 520, shared memory 520 has data D3 requested by warp W3. It may not be. In this case, performance degradation and coherence problems due to a cold miss may occur with respect to the corresponding warp W3.
  • the multiprocessor as shown in FIG. Data D3 can be evicted directly from the cache 510 to a predetermined queue 540.
  • the multiprocessor may check the tag array of the L1D cache 510 to see if the target data D3 exists in the L1D cache 510. Next, the multiprocessor may fill the shared memory 520 with the data D3 retired to the predetermined queue 540 as shown in FIG. 7. Accordingly, by migrating data from the L1D cache 510 to the shared memory 520, it is possible to solve the cold cache miss and consistency problems.
  • the given queue 540 may be a response queue used to buffer data from the L2 cache and to invalidate cache lines in the L1D cache.
  • the shared memory 520 issues a fill request to the MSHR (not shown) and target data from the predetermined queue 540 to the shared memory 520 based on the entry in the MSHR. Can be filled directly.
  • the efficiency of blocking may depend on various runtime factors, such as the number of warps blocked and the unused space in shared memory. For example, it may not be possible to effectively reduce cache interference when an interfering warp thrashes shared memory. That is, the size and / or bandwidth of the unused shared memory space may not be sufficient to handle a large amount of memory requests from the warping that cause interference in a short period of time.
  • the first is that shared memory 520 has its own address space separate from global memory and there is no hardware support to translate global memory addresses into shared memory addresses.
  • the multiprocessor may further include an address translation unit (not shown) that translates the global memory address given in front of the shared memory into a local memory address in the shared memory 520.
  • shared memory 520 does not have a data path that directly accesses lower memory layers such as L2 cache and main memory.
  • the multiprocessor adjusts the data path between the L1D cache 510 and the L2 cache (not shown) so that the shared memory 520 can access the L2 cache when the shared memory space acts as a cache. Can be.
  • the multiprocessor may further include a multiplexer 550 between the memory unit 510, 520 and a queue, such as a response queue 540, which buffers data in a lower memory, such as an L2 cache.
  • the multiplexer 550 can optionally connect a queue to the L1D cache 510 or shared memory 520.
  • the multiprocessor may also store the shared memory address of the memory request passed from the address translation unit.
  • the multiprocessor may store an extended memory address by adding an extension field to each MSHR entry.
  • shared memory 520 issues a fill request after a miss, the request reserves one MSHR entry by filling the global and translated shared memory addresses. If the response from the L2 cache, i.e., the data retired to the response queue 540, matches the global memory address recorded in the corresponding MSHR entry, then the data will be stored directly in the shared memory 520 based on the translated shared memory address. Can be.
  • FIGS. 9, 10, and 11 respectively illustrate warp throttling in a parallel processing unit according to an embodiment of the present invention. (warp throttling).
  • step 920 data requested by two warps W0 and W1 are mapped from the L1D cache 910 to cache sets Set0 and Set1, respectively, and the memory request of the warp W3 is shared memory.
  • step 920 it is assumed that the data requested by the warp W3 is mapped to the cache set Set0 in the shared memory 920.
  • the memory request of the warp W2 that interferes with the cache set Set1 of the L1D cache 910 is changed to the cache set Set1 of the shared memory 920.
  • the multiprocessor monitors the strength of the shared memory interference in the warp changed to the shared memory 920, that is, the isolated warps W2, W3, and W4 (S820).
  • a predetermined condition is satisfied as a result of the monitoring (S830), as shown in FIG. 10, the multiprocessor stalls (or throttles) the selected warp (for example, W2 in FIG. 10) according to the predetermined condition. throttle)) (S840).
  • the predetermined condition may be a condition where the strength of shared memory interference exceeds a threshold.
  • the warp selected according to a given condition may be the warp causing the most cache interference.
  • stall processing S840 may continue until the strength of shared memory interference falls below a threshold.
  • another predetermined condition is a condition in which the strength of interference in the shared memory 920 is reduced, for example, a condition in which the number of cache contentions in the shared memory 920 is lower than the threshold.
  • the threshold at step S850 may be different than the threshold at step S830. For example, the threshold at step S850 may be less than the threshold at step S830. In another embodiment, the threshold at step S850 may be the same as the threshold at step S830.
  • the multiprocessor may use an interference detector (not shown) to determine the strength of the interference in steps S830 and S850.
  • the multiprocessor may use the interference detectors used in steps S420 and S450 in FIG. 4 in steps S830 and S850. This is because an isolated warp does not compete with the regular warp that accesses the L1D cache 910 and the L1D cache 910, but interferes with other isolated warps in the shared memory 920. Therefore, the interference in the L1D cache 910 and the shared memory 920 do not affect each other, so that the multiprocessors can share the interference detector.
  • the multiprocessor may use an interference detector different from the interference detector used in steps S20 and S450 in FIG. 4 in steps S830 and S850.
  • FIG. 12 is a diagram illustrating a method of managing warps that cause interference most often in a parallel processing unit according to an embodiment of the present invention
  • FIG. 13 is a diagram illustrating cache interference in a parallel processing unit.
  • n is the number of active warps in the multiprocessor.
  • a multiprocessor manages an interference list, assigns an entry in the interference list to each warp, and assigns a warp number (WID) of the warp that is most recently interfering with the currently executed warp. It can be stored in the entry corresponding to the warp.
  • the multiprocessor may track for each warp the warping that is causing the most recent interference. In one embodiment, the multiprocessor may only track the warps that have most recently interfered with each warp most recently. This reduces the cost of storage to keep track of interfering warps for each warp.
  • the multiprocessor may further include a saturation counter connected to each entry in the interference list.
  • the saturation counter may be a two bit saturation counter.
  • the warp W32 is the warp that most frequently interferes with the remaining warps W2-W4.
  • the WID of the interfering warp W32 in the interference list is warped (W34). In the entry associated with).
  • the saturation counter increments by one.
  • the saturation counter has already reached the saturation value (eg, '11') in a cycle (S1310).
  • the saturation counter decreases by one (S1320).
  • the saturation counter is increased by one (S1330).
  • the saturation counter is reduced to '00' by the interference of warps other than the warp W32 stored in the entry of the interference list for a certain warp W34, the warp W32 in the interference list is changed to another warp. Can be replaced with Thus, the most frequent cache interference may be maintained in the interference list.
  • the multiprocessor may detect the strength (level) of cache interference experienced by individual warps by an individual re-reference score (IRS). IRS (IRS i ) of warp i (Wi) may be expressed as, for example, Equation 1 below.
  • VTA victor tag tag
  • the VTA may be included in a memory unit of a multiprocessor to manage cache access history of each warp.
  • a VTA may include a plurality of entries corresponding to a plurality of warps, and a tag of a corresponding warp may be stored in a field of each entry.
  • the multiprocessor may attach the WID of the warp corresponding to the cache line of the L1D cache.
  • the WID attached to the cache line can be used to track which active warp brought the current data to the cache line.
  • the multiprocessor retrieves the WID from the retired cache line and stores the tag of the retired cache line in the VTA entry associated with that WID.
  • the multiprocessor can observe the VTA. In this case, if a tag is found in the VTA entry of the corresponding warp, the multiprocessor can count the VTA hits. That is, if a multiprocessor sees a warp repeatedly placing memory requests on the same cache line (ie, observing a VTA hit) through the VTA, the multiprocessor may determine that the warp shows the possibility of data locality.
  • IRS i indicates the warp i VTA hit per instruction (ie, the strength of the VTA hit).
  • a high IRS i may indicate that warp i undergoes severe cache interference for a given epoch.
  • N executed - inst and N active-warp As it may change over time, in one embodiment, the IRS i may be updated periodically to take into account (N executed - inst / N active-warp ) for a given time.
  • the warp scheduler can either (1) partition (i.e. isolate) the warping that interferes with warp i, (2) stall the warping that interferes, or (3) stall before It is possible to determine whether to reactivate the warp.
  • two thresholds are used: (1) high cutoff and (2) low cutoff.
  • IRS i higher than the high cutoff may indicate that warp i suffers from a high level of cache interference.
  • the warp scheduler may partition or stall the warp that most recently interferes with warp i.
  • An IRS i lower than a low cutoff may indicate that warp i has experienced a low level of cache interference or has completed execution.
  • the warp scheduler may reactivate the previously stalled warp or withdraw the isolation of the previously isolated warp (change the memory request of the previously isolated warp to the L1D cache).
  • the warp scheduler may periodically compare the high and low cutoffs with the IRS to determine exactly whether the warps need to be partitioned, stalled, or reactivated. To this end, in some embodiments, the warp scheduler may divide the execution time into a high cutoff time and a low cutoff time. At the end of each high cutoff period, the warp scheduler can compare the IRS to the high cutoff, and at the end of each low cutoff period, the warp scheduler can compare the IRS to the low cutoff period. .
  • the low cutoff timing may be shorter than the high cutoff timing. If this low cutoff period is shorter than the high cutoff period, as soon as the previously stalled warps begin to not significantly interfere with other warps at run time, reactivating these warps can minimize the negative effects of the stalling warps. . Accordingly, high TLP can be maintained.
  • the evaluation of the divers memory intensive application shows that, for example, the lengths of the high and low cutoff periods can be set to approximately 5000 and 100 instructions, respectively.
  • 15 and 16 are flowcharts illustrating a warp scheduling method in a parallel processing unit according to an embodiment of the present invention, respectively.
  • the multiprocessor of the parallel processing unit detects a level of cache interference with respect to the active warp i (S1510).
  • the multiprocessor may detect the cache interference level when the high cutoff timing ends.
  • the cache interference level of the warp i satisfies a predetermined condition (S1520)
  • the multiprocessor detects warp j that most frequently interferes with warp i (S1530).
  • the predetermined condition may be a condition where the cache interference level, eg, ISR i, is higher than the high cutoff. Accordingly, the multiprocessor isolates the cache access of warp j into the shared memory (S1540).
  • the multiprocessor may record the warp number of warp i which isolated warp j.
  • the multiprocessor detects the cache interference level with respect to the warp (that is, warp i) in which warp j is isolated (S1550). In some embodiments, the multiprocessor may detect the cache interference level when the low cutoff timing ends. If the cache interference level of warp i satisfies a predetermined other condition (S1560), the multiprocessor withdraws the isolation of warp j (S1570). Warp j can thus access the L1D cache again.
  • some other condition may be a condition where the warp i's cache interference level, eg, ISR i, is lower than the low cutoff. In other embodiments, any other condition may be a condition in which warp i has completed execution. On the contrary, when a predetermined other condition is not satisfied (S1560), the multiprocessor continuously isolates the cache access of warp j (S1570).
  • the multiprocessor of the parallel processing unit detects a level of cache interference with respect to warp i (S1610).
  • Warp i may be a warp that accesses the L1D cache or a warp that accesses shared memory.
  • the multiprocessor may detect the cache interference level when the high cutoff timing ends.
  • the cache interference level of warp i satisfies a predetermined condition (S1620)
  • the multiprocessor detects warp j that causes interference most frequently with warp i (S1630).
  • the predetermined condition may be a condition where the cache interference level, eg, ISR i, is higher than the high cutoff.
  • the multiprocessor determines whether the state of warp j is in isolation (S1640). If warp j is in an isolated state (S1640), the multiprocessor stalls warp j (S1642). In some embodiments, the multiprocessor may record the warp number of warp i which stalled warp j. If warp j is not in an isolation state, that is, if warp j is in an active state (S1640), the multiprocessor isolates warp j's cache access to shared memory (S1644). In some embodiments, the multiprocessor may record the warp number of warp i which isolated warp j.
  • the multiprocessor detects the cache interference level with respect to the warp (that is, warp i) that isolated warp j (S1650). In some embodiments, the multiprocessor may detect the cache interference level when the low cutoff timing ends. If the cache interference level of warp i satisfies some other condition (S1660), the multiprocessor withdraws the isolation of warp j (S1670). Warp j can thus access the L1D cache again.
  • some other condition may be a condition where the warp i's cache interference level, eg, ISR i, is lower than the low cutoff. In other embodiments, any other condition may be a condition in which warp i has completed execution. On the contrary, when certain other conditions are not satisfied (S1660), the multiprocessor continues to isolate the cache access of warp j.
  • the multiprocessor detects the cache interference level with respect to the warp (that is, warp i) which stalled warp j (S1680). In some embodiments, the multiprocessor may detect the cache interference level when the low cutoff timing ends. If the cache interference level of warp i satisfies a predetermined other condition (S1690), the multiprocessor reactivates warp j (S1695). In one embodiment, some other condition may be a condition where the warp i's cache interference level, eg, ISR i, is lower than the low cutoff. In other embodiments, any other condition may be a condition in which warp i has completed execution. On the contrary, if a predetermined other condition is not satisfied (S1690), the multiprocessor continues to stall the cache access of warp j.
  • a predetermined other condition is not satisfied (S1690)
  • the cache interference may be reduced by stalling the isolated warp j.
  • the TLP may be maintained by reactivating the stalled warp j.
  • 17 is a schematic block diagram of a multiprocessor in a parallel processing unit according to an embodiment of the present invention. 17 illustrates a warp scheduler and a memory unit in a multiprocessor.
  • a warp scheduler 1710 of a multiprocessor includes a counter 1711 for detecting the level of cache interference.
  • the counter 1711 may include a plurality of VTA hit counters (VTACount0-VTACountk) and an overall instruction counter (Inst-total).
  • VTA hit counter may be provided per warp.
  • Each VTA hit counter (VTACounti) records the number of VTA hits (F i VTA -hits ) for the corresponding warp (Wi), and the total instruction counter (Inst-total) is the total number of instructions executed by that multiprocessor. Record (N executed-inst ).
  • the multiprocessor can detect the level of cache interference experienced by an individual warp through a plurality of VTA hit counters (VTACount0-VTACountk) and an overall instruction counter (Inst-total).
  • VTACount0-VTACountk VTA hit counters
  • Inst-total overall instruction counter
  • the level of cache interference may be represented by an IRS.
  • Warp scheduler 1710 may further include a cutoff check unit 1712 to compare the level of cache interference with a threshold.
  • the level of cache interference is an IRS
  • the threshold may include a high cutoff and a low cutoff.
  • the cutoff inspection unit 1712 then compares the IRS with the high and low cutoffs.
  • the cutoff check unit 1712 can be implemented using registers, shifting units, and comparison logic.
  • the warp scheduler may further include a sampler 1713, which counts the number of instructions executed to determine whether the high cutoff timing or the low cutoff timing has ended.
  • Warp scheduler 1710 includes a list for managing warps that cause interference.
  • the list may include a warp list 1714, an interference list 1715, and a pair list 1716.
  • Interference list 1714 can be used to manage information related to tracking warps that cause interference.
  • Interference list 1714 includes a plurality of entries, each assigned to a plurality of warps. Each entry is indexed by the assigned warp's WID and stores the interfering warp's WID and saturation counter (C). Each time a VTA hit occurs, the corresponding entry in the interference list may be updated. For example, each time the same warp as the WID stored in the entry interferes, the saturation counter C increases by one, and each time the WID stored in the entry and another warp interferes, the saturation counter C decreases by one. can do.
  • the saturation counter C reaches the saturation value (for example, '11'), it does not increase further, and if the saturation counter C reaches the predetermined value (for example, '00'), The WID of the entry can be updated with the WID of another warp.
  • the interference list 1714 may be checked whenever it is necessary to partition the warp causing the interference based on the ISR.
  • a warp list 1715 that includes a plurality of ready warp entries includes a status flag associated with each ready warp entry.
  • the warp scheduler may use the state flag to identify the state of a given warp, that is, whether the given warp is active or isolated.
  • the warp scheduler may further manage stall status.
  • the interference list 1714 may be checked whenever it is necessary to partition or stall the warp causing the interference based on the ISR.
  • the state flag may include an active flag (V) and an isolation flag (I).
  • the active flag and the isolation flag may each be 1 bit.
  • Pair list 1716 includes a plurality of entries each assigned to a plurality of warps, each entry indexed by the WID of the assigned warp. Each entry records which interfered warp has caused warp partitioning in the past. To that end, in some embodiments, each entry may include a field for recording the WID of the interfering warp that caused warp partitioning. Based on the WID of the field of the entry corresponding to warp i, the warp scheduler identifies the ISR (ISR k ) of the interfering warp k that previously caused partitioning of warp i. For example, as warp W0 is severely interfered by warp W1, the warp scheduler may decide to partition warp W1 to isolate its cache access. Then, as shown in Fig.
  • Warp W1 begins to access shared memory after being partitioned. Later, when the warp scheduler needs to withdraw the isolation of warp W1, the field of the pair list entry corresponding to warp W1 and the isolation flag I of the interference list entry corresponding to warp W1 will be cleared. Can be.
  • each entry in the pair list 1716 may further record which interfering warps have caused warp stalling in the past.
  • each entry may include two fields. The first field may record the WID of the interfered warp that caused warp partitioning, and the second field may record the WID of the interfered warp that caused warp stalling. Based on the WIDs of the two fields of the entry corresponding to warp i, the warp scheduler identifies the ISR (ISR k ) of the interfered warp k that previously caused partitioning or stalling of warp i. For example, as warp W0 is severely interfered by warp W1, the warp scheduler may decide to partition warp W1 to isolate its cache access.
  • Warp W1 begins to access shared memory after being partitioned. In this case, if the warp scheduler determines that the warp W1 severely interferes with another warp W3 that is being accessed by the shared memory, the warp W1 can be stalled. As the warp scheduler decides to stall the warp W1, the WID of the warp W3 is recorded in the second field of the pair list entry corresponding to the warp W1, and the interference list entry corresponding to the warp W1 The active flag V may be cleared.
  • the warp scheduler needs to reactivate the warp W1
  • the second field of the pair list entry corresponding to the warp W1 and the active flag V of the interference list entry corresponding to the warp W1 are cleared. Can be.
  • the warp scheduler needs to withdraw the isolation of warp W1
  • the first field of the pair list entry corresponding to warp W1 and the isolation flag I of the interference list entry corresponding to warp W1 Can be cleared.
  • the memory unit 1720 of the multiprocessor includes an L1D cache 1721 and a shared memory 1722.
  • the cache line of the L1D cache 1721 stores data and a tag, and a WID of a corresponding warp may be attached.
  • the unused space in the shared memory 1722 is used as a cache, and data and a tag may be stored in a cache line of the space used as the cache, and a tag may be attached with a WID of a corresponding warp.
  • the memory unit 1720 may further include a VTA 1730 for writing a tag to the entry of the warp corresponding to a miss of the cache line.
  • the warp scheduler 1710 and the memory unit 1720 may be connected through the load-storage unit 1730.
  • FIG. 18 is a view illustrating an operation of a memory unit in a parallel processing unit according to an embodiment of the present invention.
  • FIG. 19 is a diagram illustrating a structure of a memory unit in a parallel processing unit according to an embodiment.
  • the multiprocessor includes a memory unit 1810, a control logic 1820, a multiplexer 1830, and a queue 1840, wherein the memory unit 1810 includes an L1D cache 1811 and a shared memory 1812. ).
  • the shared memory 1812 When using shared memory 1812 as a cache, the shared memory 1812 is logically separated from global memory, so the multiprocessor establishes a data path between the shared memory 1812 and the L2 cache. To this end, the multiplexer 1830 selectively connects the queue 1840 and the L1D cache 1811 or the shared memory 1812 to buffer data from the global memory or the L2 cache.
  • This queue 1840 may include a write queue 1841 and a response queue 1882.
  • Control logic 1820 controls multiplexer 1830 based on the state of a given warp. If the state of a given warp is in isolation (eg, if isolation flag I in FIG. 17 is '1'), control logic 1820 may establish a data path between shared memory 1812 and queue 1840. The multiplexer 1830 may be controlled to make it possible. The control logic 1820 may further refer to the result (hit / miss) of checking the cache tag when controlling the multiplexer 1830.
  • the multiprocessor may also store the shared memory address SHM Addr of the memory request from the address translation unit.
  • the multiprocessor may add an extension field to each MSHR entry to store the shared memory address of the memory request from the address translation unit.
  • Each MSHR entry may further include an address valid flag (V), an instruction ID (eg, a program counter, PC), and a global memory address (Gl Addr).
  • the request reserves one MSHR entry by filling the global and translated shared memory addresses. If the response from the L2 cache matches the global memory address recorded in the corresponding MSHR entry, then that data may be stored directly in the shared memory 1812 based on the translated shared memory address.
  • the shared memory 1812 does not have a separate memory structure for accepting cache tags.
  • an additional tag array may be employed to accommodate cache tags in shared memory 1812.
  • a plurality of cache data blocks may be placed in shared memory 1812.
  • the cache data block may be a 128 byte cache data block.
  • the change of the on-chip memory unit 1810 including the L1D cache 1811 and the shared memory 1812 can be minimized.
  • a plurality of shared memory banks (for example, 32 shared memory banks) included in the shared memory 1812 are divided into two or more bank groups. In one embodiment, the number of divided bank groups may be two.
  • the cache data blocks are striped in the row direction for a plurality of banks (for example, 16 banks) in one bank group.
  • each shared memory bank allows 64-bit access, so that cache data blocks, for example 128 byte cache data blocks, can be accessed in parallel.
  • a tag and its WID require a limited bit, for example 31 bits if the tag uses 25 bits and the warp number (WID) uses 6 bits, so the cache of shared memory 1812 with limited shared memory space. You can provide a tag for the line. For example, if a shared memory bank allows 64-bit access and the tag and WID use 31 bits, two tags may be formed in each shared memory bank. In one embodiment, the bank in which the two tags are placed may be a different bank than the bank that stores the corresponding data block (eg, 128-byte data block). That is, the bank group to which the bank on which the tag is placed may belong may be a bank group different from the bank group to which the banks storing the corresponding data blocks belong.
  • the bank in which the two tags are placed may be a different bank than the bank that stores the corresponding data block (eg, 128-byte data block). That is, the bank group to which the bank on which the tag is placed may belong may be a bank group different from the bank group to which the banks storing the corresponding
  • the multiprocessor may maintain a shared memory management table (SMMT) (not shown) to manage the shared memory space.
  • the SMMT includes a plurality of entries, each of which may correspond to a CTA.
  • Each CTA reserves one SMMT entry, which records the starting address and size of the shared memory space used by a given CTA.
  • each entry in the SMMT may correspond to a thread of warp or a thread of warp group.
  • the multiprocessor can check the corresponding SMMT entry to determine the amount of shared memory not used by the CTA. The multiprocessor can then put the starting address and size of unused shared memory into a new entry in SMMT to make room for storing cache lines and tags.
  • the multiprocessor may place the hardware address translation unit 1910 in front of the shared memory 1812 to determine where the target cache line and its tag are present in the shared memory 1812.
  • the address translation unit 1910 translates a global memory address into a shared memory address.
  • the global memory address may be decomposed into a tag T, a block index L, and a byte offset F in the order of the LSB to the MSB.
  • the global memory address may be divided into a 16-bit tag (T), a 9-bit block index (L), and a 7-bit byte offset (F).
  • the shared memory address may include a cache block address indicating a target cache data block and a tag address indicating a target tag.
  • the cache block address includes four fields, and the four fields may correspond to byte offset F, bank index B, bank group index G, and row index R in the order of LSB to MSB.
  • the shared memory 1812 uses 8 byte rows per bank, 16 banks per bank group, two bank groups, and 256 rows, the byte offset (F), bank index (B), bank group index (G) and row index R may be 3, 4, 1 and 8 bits, respectively.
  • the bits remaining after translating the global memory address into a cache block address may be used as part of a tag of the target cache data block. Since the number of cache data blocks required is greater than the number of rows, the tag of shared memory 1812 may include a warp number (WID) and a cache block index.
  • the warp number (WID) and the cache block index may be 6 bits and 9 bits, respectively.
  • the address translation unit 1910 may convert the block index L of the global memory address into a row index R indicating the position of the row in the shared memory 1812 using an N bit mask. For example, if the shared memory 1812 has 256 rows, the address translation unit 1910 may use an 8 bit mask. In some embodiments, the address translation unit 1910 may generate the row index R by computing the upper N bits and the N bit mask of the block index L of the global memory address. In one embodiment, the address translation unit 1910 may generate a row index R with an exclusive OR (XOR) of the upper N bits of the block index L of the global memory address and the N bit mask. The address translation unit 1910 may convert the lower M bits of the block index L of the global memory address into a bank index B indicating a bank group in the shared memory 1812. For example, when the lower 8 bits are converted from the 9-bit block index L to the row index R, and there are two bank groups of the shared memory 1812, the LSB of the block index L is the bank index ( B) can be used.
  • the address translation unit 1910 converts some bits of the byte offset F of the global memory address into a bank index B indicating a bank of the shared memory 1812, and stores some remaining bits of the byte offset F into a cache block address. Can be converted into a byte offset (F) of.
  • some bits of the byte offset F of the global memory address may be bank index B, and some of the remaining bits of the byte offset F may be byte offset F of the cache block address.
  • the upper L bits of the byte offset F of the global memory address may be the bank index B, and the lower K bits of the byte offset F may be the byte offset F of the cache block address. .
  • the shared memory 1812 has 16 banks, the upper four bits of the 7 bit byte offset F of the global memory address become the bank index B, and the lower three bits of the byte offset F. May be the byte offset F of the cache block address.
  • the tag address includes four fields, and the four fields may correspond to byte offset (F), bank index (B), bank group index (/ G), and row index (R) in the order of LSB to MSB.
  • F byte offset
  • B bank index
  • R row index
  • the address translation unit 1910 converts the lower P bits of the row index R of the cache block address into the byte offset F of the tag address, and the remaining lower Q bits of the row index R into the bank index of the tag address. B) can be translated.
  • the lower P bits of the row index R of the cache block address may be the byte offset F and the remaining some bits of the byte offset F may be the byte offset F of the cache block address.
  • the LSB of the row index R of the cache block address may be the byte offset F of the tag address, and the remaining lower 4 bits of the row index R may be the bank index B of the tag address. have.
  • the address translation unit 1910 may translate the remaining bits of the row index R of the cache block address into the row index R of the tag address in order to indicate the row index R of the tag.
  • the remaining bits of the row index R of the cache block address may be the row index R of the tag address.
  • the upper three bits of the row index R of the cache block address may be the row index R of the tag address.
  • the address translation unit 1910 translates the bank group index G of the cache block address into the bank group index / G of the tag address.
  • the bank group index G of the cache block address in order to access the tag corresponding to the cache data block in parallel, the bank group index G of the cache block address may be flipped to become the bank group index / G of the tag address.
  • the address translation unit 1910 may rearrange the starting position of the index for the cache block and the tag in consideration of the cache offset register and the tag offset register.
  • the cache offset register and the tag offset register can be used to capture the varying size of the cache in unused shared memory space.
  • i indicates the warp number of the warp to be scheduled and may be obtained through, for example, the getWarpToBeScheduled () function.
  • InstNo is the total number of instructions executed and can be obtained through, for example, the getNumInstructions () function.
  • ActiveWarpNo indicates the number of active warps operating on the multiprocessor and can be obtained through, for example, the getNumActiveWarp () function.
  • warp i For warp i (Warp (i)), if active flag V is '0' and the low cutoff timing is over, it is determined whether warp i is reactivated in the stall state. For this purpose, the warp number k of warp k (Warp (k)) which caused the stall of warp i is obtained from the second field Pair_List [i] [1] of the pair list entry corresponding to warp i. In this case, if the level of cache interference of warp k (ISR k ) is higher than the low cutoff and warp k (Warp (k)) needs to be executed continuously, the stall state of warp i is maintained. Otherwise warp i is reactivated. Accordingly, the active flag of warp i is set to '1', and the second field Pair_List [i] [1] of the pair list entry is cleared (for example, set to '-1').
  • the warp number k of warp k (Warp (k)) which caused the partition of warp i is obtained from the first field Pair_List [i] [0] of the pair list entry corresponding to warp i.
  • the warp i's isolation state is maintained. Otherwise, isolation of warp i is withdrawn. Accordingly, the isolation flag of warp i is set to '0', and the first field Pair_List [i] [0] of the pair list entry is cleared (for example, set to '-1').
  • warp i For warp i, if the active flag V is '1' and the high cutoff timing is over, it is determined whether to partition warp j that interferes with warp i in the active state. To this end, the warp number j of warp j which interferes with warp i is obtained from the interference list entry Interference_List [i] corresponding to warp i. If the level of cache interference of warp i (ISR i ) is higher than the high cutoff and warp j is a warp different from warp i, if warp j is in isolation (ie, if warp j's isolation flag (I) is '1') Warp j is stalled.
  • ISR i the level of cache interference of warp i
  • the active flag V of warp j is set to '0', and the second field Pair_List [j] [1] of the pair list entry corresponding to warp j is set to i. Otherwise, if warp j is active (that is, if isolation flag I of warp j is '0'), warp j is isolated. That is, the isolation flag I of warp j is set to '1', and the first field Pair_List [j] [0] of the pair list entry corresponding to warp j is set to i.
  • Warp (i) is deactivated * /
  • Warp (i) redirects to access shared memory * /
  • Warp (i) is active * /
  • SM multiprocessors
  • up to 1536 threads are created per SM and two warp schedulers are used.
  • a 16 KB cache supporting 4-way with a 128 byte cache line as a L1D cache or a 48 KB cache supporting 6-way with a 128 byte cache line is used.
  • the warp scheduling method using only warp partitioning can improve the performance by 32% over the conventional warp scheduling. Also, warp scheduling using warp partitioning and warp throttling can improve performance by 54% over conventional warp scheduling.

Landscapes

  • Engineering & Computer Science (AREA)
  • Theoretical Computer Science (AREA)
  • Physics & Mathematics (AREA)
  • General Engineering & Computer Science (AREA)
  • General Physics & Mathematics (AREA)
  • Software Systems (AREA)
  • Memory System Of A Hierarchy Structure (AREA)

Abstract

멀티프로세서를 포함하는 병렬 프로세싱 유닛에서, 멀티프로세서는, L1D 캐시 및 복수의 캐시 라인이 할당되는 공유 메모리를 포함하는 메모리 유닛을 포함한다. 쓰레드 그룹 스케줄러는, 액티브 상태의 제1 쓰레드 그룹에 대해서 소정의 제1 조건을 만족하는 경우에, 제2 쓰레드 그룹의 캐시 액세스를 공유 메모리로 변경하여 제2 쓰레드 그룹을 격리한다.

Description

병렬 프로세싱 유닛 및 이를 포함하는 컴퓨팅 디바이스, 그리고 쓰레드 그룹 스케줄링 방법
본 발명은 병렬 프로세싱 유닛 및 이를 포함하는 컴퓨팅 디바이스, 그리고 쓰레드 그룹 스케줄링 방법에 관한 것이다.
그래픽 프로세싱 유닛(graphic processing unit, GPU)와 같은 병렬 프로세싱 유닛(parallel processing unit)은 방대한 쓰레드 레벨 병렬화(thread-level parallelism, TLP)를 통해, 범용 어플리케이션에 대해서 많은 성능 향상을 보여주었다. 많은 스트림 멀티프로세서(stream multiprocessors, SMs)로 이루어지는 현재의 GPU 아키텍처는 복수의 쓰레드를 쓰레드 그룹[워프(warp)로 불릴 수 있음]으로 클러스터화한다. 많은 워프를 효과적으로 관리하기 위해서, 각 SM은 하드웨어 기반의 워프 스케줄러를 채용하고 있다. 고성능을 위해서 가능한 많은 워프를 각 SM에 할당하여서 실행 파이프라인의 유용성을 최대화하는 것이 필요하다.
이러한 워프 스케줄링 방법은 메모리 집약적 어플리케이션은 많은 양의 데이터를 프로세싱할 필요가 있을 때, TLP를 최대화하는데 충분하지 않다. 이는 액티브 워프가 너무 많은 메모리 요청을 집약적으로 생성하고 한정된 용량의 온칩(on-chip) 캐시에 대해서 경쟁하기 때문이다. 이러한 캐시 경쟁으로 성능이 심각하게 열화될 수 있다. 이러한 문제를 해결하기 위해서 다이버스 캐시 인식 워프 스케줄링 정책(diverse cache-aware warp scheduling policies)이 제안되었지만, 이들 워프 스케줄링 정책은 L1D 캐시 히트율(hit rate)을 향상시키고, 높은 가능성의 데이터 지역성을 가지는 액티브 워프를 식별해서 이들 워프에서 다른 워프보다 높은 스케줄링 우선 순위를 부여함으로써 성능을 향상시키는 것을 목표로 한다. 즉, 이들 워프 스케줄링 정책은 낮은 가능성의 데이터 지역성을 가지는 워프를 스로틀(throttle)하여 TLP를 감소시킴으로써, 전체 L1D 캐시 히트율을 증가시키고 이에 따라 전체 성능을 향상시키고 있다. 그러나 이러한 워프 스케줄링 정책은 다음 이유 때문에 불규칙적인 캐시 액세스 패턴을 수반하는 메모리 집약적 어플리케이션에 대해서는 충분하지 않을 수 있다. 높은 가능성의 데이터 지역성을 가지는 액티브 워프의 캐시 액세스가 종종 다른 워프와 심각하게 간섭을 일으킬 수 있다. 결과적으로 데이터 지역성의 가능성에 기초해서 단순히 액티브 워프를 스케줄링하면 캐시 간섭을 증가시키고 캐시 히트율 향상에 부정적인 영향을 줄 수 있다. 또한 캐시 히트율 향상을 대가로 TLP를 열화시키는 것은 바람직하지 않다. 즉, 액티브 워프를 스로틀하는 것이 캐시 히트율을 향상시킬 수 있지만, 전체 성능은 열화될 수 있다.
본 발명이 이루고자 하는 과제는 쓰레드 레벨 병렬화를 떨어뜨리지 않으면서 캐시 간섭을 줄일 수 있는 병렬 프로세싱 유닛 및 이를 포함하는 컴퓨팅 디바이스, 그리고 워프 스케줄링 방법을 제공하는 것이다.
본 발명의 한 실시예에 따르면, 멀티프로세서를 포함하는 병렬 프로세싱 유닛이 제공된다. 상기 멀티프로세서는 메모리 유닛과 쓰레드 그룹 스케줄러를 포함한다. 상기 메모리 유닛은 L1D 캐시 및 복수의 캐시 라인이 할당되는 공유 메모리를 포함한다. 상기 쓰레드 그룹 스케줄러는, 액티브 상태의 제1 쓰레드 그룹에 대해서 소정의 제1 조건을 만족하는 경우에, 제2 쓰레드 그룹의 캐시 액세스를 상기 공유 메모리로 변경하여 상기 제2 쓰레드 그룹을 격리한다.
상기 제1 조건은 상기 제1 쓰레드 그룹에 대한 캐시 간섭의 레벨이 제1 컷오프를 넘는 조건을 포함할 수 있다.
상기 제2 쓰레드 그룹은 상기 제1 쓰레드 그룹에 간섭을 일으키는 쓰레드 그룹 중에서 가장 자주 간섭을 일으키는 쓰레드 그룹을 포함할 수 있다.
소정의 제2 조건을 만족하는 경우에, 상기 쓰레드 그룹 스케줄러는 상기 제2 쓰레드 그룹의 캐시 액세스를 상기 L1D 캐시로 다시 변경할 수 있다.
상기 제2 조건은 상기 제1 쓰레드 그룹에 대한 캐시 간섭의 레벨이 상기 제1 컷오프보다 낮은 제2 컷오프보나 낮은 조건을 포함할 수 있다.
상기 제2 조건은 상기 제1 쓰레드 그룹의 실행이 완료되는 조건을 포함할 수 있다.
제1 시기와 제2 시기로 이루어지는 사이클에서, 상기 쓰레드 그룹 스케줄러는 제1 시기의 종료 시에 상기 제1 조건을 판단하고, 상기 제2 시기의 종료 시에 상기 제2 조건을 판단할 수 있다.
소정의 제2 조건을 만족하는 경우에, 상기 쓰레드 그룹 스케줄러는 상기 격리된 제2 쓰레드 그룹을 스톨(stall)할 수 있다.
상기 제2 조건은 상기 공유 메모리로 격리된 제3 쓰레드 그룹에 대한 캐시 간섭의 레벨이 제1 컷오프를 넘는 조건을 포함할 수 있다.
소정의 제3 조건을 만족하는 경우에, 상기 쓰레드 그룹 스케줄러는 상기 스톨된 제2 쓰레드 그룹을 재활성화할 수 있다.
상기 제3 조건은 상기 제3 쓰레드 그룹에 대한 캐시 간섭의 레벨이 상기 제1 컷오프보다 낮은 제2 컷오프보나 낮은 조건을 포함할 수 있다.
상기 제2 조건은 상기 제3 쓰레드 그룹의 실행이 완료되는 조건을 포함할 수 있다.
제1 시기와 제2 시기로 이루어지는 사이클에서, 상기 쓰레드 그룹 스케줄러는 제1 시기의 종료 시에 상기 제2 조건을 판단하고, 상기 제2 시기의 종료 시에 상기 제3 조건을 판단할 수 있다.
본 발명의 다른 실시예에 따르면, 앞의 실시예에 따른 병렬 프로세싱 유닛, CPU, 시스템 메모리, 그리고 상기 병렬 프로세싱 유닛, 상기 CPU 및 상기 시스템 메모리를 연결하는 메모리 브릿지를 포함하는 컴퓨팅 디바이스가 제공된다.
본 발명의 또 다른 실시예에 따르면, 멀티프로세서를 포함하는 병렬 프로세싱 유닛이 제공된다. 상기 멀티프로세서는, L1D 캐시 및 공유 메모리를 포함하는 메모리 유닛, 그리고 쓰레드 그룹 스케줄러를 포함한다. 상기 공유 메모리는, 복수의 행을 가진 복수의 공유 메모리 뱅크를 포함하며, 상기 복수의 공유 메모리 뱅크는 복수의 뱅크 그룹으로 그룹화되어 있다. 각 뱅크 그룹에 속한 복수의 공유 메모리 뱅크에 대해서 복수의 캐시 라인이 할당되어 있으며, 상기 쓰레드 그룹 스케줄러는 일부 쓰레드 그룹의 캐시 접근을 상기 공유 메모리의 캐시 라인으로 변경한다.
어떤 캐시 라인이 할당되는 뱅크 그룹과 다른 뱅크 그룹에 상기 어떤 캐시 라인을 위한 태그와 대응하는 쓰레드 그룹의 번호가 할당될 수 있다.
본 발명의 또 다른 실시예에 따르면, L1D 캐시와 공유 메모리를 포함하는 메모리 유닛을 포함하는 병렬 프로세싱 유닛의 쓰레드 그룹 스케줄링 방법이 제공된다. 상기 쓰레드 그룹 스케줄링 방법은, 제1 쓰레드 그룹에 대해서 캐시 간섭의 레벨을 검출하는 단계, 그리고 상기 캐시 간섭의 레벨이 제1 컷오프를 넘는 경우, 상기 제1 쓰레드 그룹에 간섭을 일으키는 쓰레드 그룹 중 소정의 조건을 만족하는 제2 쓰레드 그룹의 캐시 액세스를 상기 공유 메모리로 변경하여 상기 제2 쓰레드 그룹을 격리하는 단계를 포함한다.
상기 쓰레드 그룹 스케줄링 방법은, 상기 제1 쓰레드 그룹에 대해서 캐시 간섭의 레벨을 다시 검출하는 단계, 그리고 상기 다시 검출한 캐시 간섭의 레벨이 상기 제1 컷오프보다 낮은 제2 컷오프보다 낮은 경우, 상기 제2 쓰레드 그룹의 캐시 액세스를 상기 L1D 캐시로 다시 변경하는 단계를 더 포함할 수 있다.
상기 쓰레드 그룹 스케줄링 방법은, 상기 공유 메모리로 격리된 제3 쓰레드 그룹에 대해서 캐시 간섭의 레벨을 검출하는 단계, 그리고 상기 제3 쓰레드 그룹에 대한 상기 캐시 간섭의 레벨이 제2 컷오프를 넘는 경우, 상기 격리된 제2 쓰레드 그룹을 스톨하는 단계를 더 포함할 수 있다.
상기 쓰레드 그룹 스케줄링 방법은, 상기 제3 쓰레드 그룹에 대해서 캐시 간섭의 레벨을 다시 검출하는 단계, 그리고 상기 제3 쓰레드 그룹에 대해서 상기 다시 검출한 캐시 간섭의 레벨이 상기 제2 컷오프보나 낮은 제3 컷오프보다 낮은 경우, 상기 스톨한 제2 쓰레드 그룹을 재활성화하는 단계를 더 포함할 수 있다.
본 발명의 한 실시예에 따르면, 쓰레드 레벨 병렬화를 유지하면서 캐시 간섭을 줄일 수 있다.
도 1은 본 발명의 한 실시예에 따른 컴퓨팅 디바이스의 개략적인 블록도이다.
도 2는 본 발명의 한 실시예에 따른 병렬 프로세싱 유닛의 개략적인 블록도이다.
도 3은 전형적인 멀티프로세서에서 캐시 간섭이 L1D 캐시에서 데이터 지역성을 악화시키는 예를 나타내는 도면이다.
도 4는 본 발명의 한 실시예에 따른 병렬 프로세싱 유닛에서의 워프 스케줄링 방법을 나타내는 흐름도이다.
도 5, 도 6 및 도 7은 각각 본 발명의 한 실시예에 따른 병렬 프로세싱 유닛에서의 워프 파티셔닝을 설명하는 도면이다.
도 8은 본 발명의 다른 실시예에 따른 병렬 프로세싱 유닛에서의 워프 스케줄링 방법을 나타내는 흐름도이다.
도 9, 도 10 및 도 11은 각각 본 발명의 한 실시예에 따른 병렬 프로세싱 유닛에서의 워프 스로틀링을 설명하는 도면이다.
도 12는 본 발명의 한 실시예에 따른 병렬 프로세싱 유닛에서 가장 자주 간섭을 일으키는 워프를 관리하는 방법을 설명하는 도면이다.
도 13은 병렬 프로세싱 유닛에서의 캐시 간섭을 설명하는 도면이다.
도 14는 본 발명의 한 실시예에 따른 병렬 프로세싱 유닛에서 빅팀 태그 어레이를 설명하는 도면이다.
도 15 및 도 16은 각각 본 발명의 실시예에 따른 병렬 프로세싱 유닛에서의 워프 스케줄링 방법을 나타내는 흐름도이다.
도 17은 본 발명의 한 실시예에 따른 병렬 프로세싱 유닛에서 멀티프로세서의 개략적인 블록도이다.
도 18은 본 발명의 한 실시예에 따른 병렬 프로세싱 유닛에서 메모리 유닛의 동작을 설명하는 도면이다.
도 19는 한 실시예에 따른 병렬 프로세싱 유닛에서 메모리 유닛의 구조를 설명하는 도면이다.
도 20은 한 실시예에 따른 병렬 프로세싱 유닛에서 어드레스 번역을 설명하는 도면이다.
아래에서는 첨부한 도면을 참고로 하여 본 발명의 실시예에 대하여 본 발명이 속하는 기술 분야에서 통상의 지식을 가진 자가 용이하게 실시할 수 있도록 상세히 설명한다. 그러나 본 발명은 여러 가지 상이한 형태로 구현될 수 있으며 여기에서 설명하는 실시예에 한정되지 않는다. 그리고 도면에서 본 발명을 명확하게 설명하기 위해서 설명과 관계없는 부분은 생략하였으며, 명세서 전체를 통하여 유사한 부분에 대해서는 유사한 도면 부호를 붙였다.
도 1은 본 발명의 한 실시예에 따른 컴퓨팅 디바이스의 개략적인 블록도이다. 도 1은 가능한 컴퓨팅 디바이스의 한 예이며, 본 발명의 실시예에 따른 컴퓨팅 디바이스의 다른 다양한 구조로 구현될 수 있다.
도 1을 참고하면, 본 발명의 한 실시예에 따른 컴퓨팅 디바이스는 중앙 프로세싱 유닛(central processing unit, CPU)(110), 시스템 메모리(120) 및 병렬 프로세싱 유닛(130)을 포함한다.
시스템 메모리(120)는 메모리 브릿지(140)를 통해 CPU(110)와 통신할 수 있다. 메모리 브릿지(140)는 예를 들면 노스브릿지(northbridge)일 수 있다. 또한 메모리 브릿지(140)는 버스 또는 통신 채널을 거쳐 입출력(input/output, I/O) 브릿지(150)에 연결될 수 있다. I/O 브릿지(150)는 예를 들면 사우스브릿지(southbridge)일 수 있으며, 사용자 입력 장치(도시하지 않음)로부터 사용자 입력을 수신하고 이를 메모리 브릿지(140)를 거쳐 CPU(110)로 전달할 수 있다.
병렬 프로세싱 유닛(130)은 버스 또는 통신 채널을 거쳐 메모리 브릿지(140)에 연결되어 CPU(110) 및 시스템(120)와 통신할 수 있다. 병렬 프로세싱 유닛(130)은 예를 들면 그래픽 프로세싱 유닛(graphic processing unit, GPU)일 수 있다.
어떤 실시예에서, CPU(110), 시스템 메모리(120), 메모리 브릿지(140) 및 I/O 브릿지(150)를 포함하는 시스템을 호스트(host)라 할 수 있다.
도 2는 본 발명의 한 실시예에 따른 병렬 프로세싱 유닛의 개략적인 블록도이다.
도 2를 참고하면, 병렬 프로세싱 유닛은 하나 이상의 멀티프로세서(200)를 포함한다. 병렬 프로세싱 유닛은 예를 들면 GPU일 수 있으며, 멀티프로세서(200)는 예를 들면 스트리밍 멀티프로세서(streaming multiprocessor, SM)일 수 있다.
멀티프로세서(200)로 전달된 일련의 명령어가 쓰레드(thread)를 형성할 수 있다. 이러한 쓰레드는 프로그램의 인스턴스(instance)일 수 있다. 또한 멀티프로세서(200)에서 일정 개수(예를 들면, 32개)의 쓰레드가 동시에 실행되며, 이러한 일정 개수의 쓰레드를 쓰레드 그룹이라 한다. 예를 들면, 이러한 쓰레드 그룹을 "워프(warp)", "컨테이너(container)" 또는 "웨이브프론트(wavefront)"라 할 수 있으며, 아래에서는 설명의 편의상 쓰레드 그룹을 워프라 한다. 어떤 실시예에서, 쓰레드 그룹은 서로 다른 입력 데이터에 대해서 동일한 프로그램을 동시에 실행하는 쓰레드의 그룹일 수 있다. 또한 멀티프로세서(200) 내에서 복수의 워프가 동시에 액티브 상태일 수 있으며, 이러한 복수의 워프의 쓰레드를 CTA(cooperative thread array)라 할 수 있다.
멀티프로세서(200)는 명령어 버퍼(210), 워프 스케줄러(220), 복수의 프로세싱 유닛(processing unit)(230), 복수의 로드-저장 유닛(load-store unit, LSU)(240) 및 메모리 유닛(250)을 포함한다.
명령어 버퍼(210)는 멀티프로세서(200)로 전달된 명령어를 저장하며, 워프 스케줄러(220)는 워프의 명령어를 스케줄링하고, 스케줄링에 따라 명령어 버퍼(210)로부터 해당하는 워프의 명령어를 선택해서 출력한다. 어떤 실시예에서, 멀티프로세서는 펫치/디코더(fetch/decoder)(205)를 더 포함할 수 있으며, 펫치/디코더(205)는 멀티프로세서(200)로 전달된 명령어를 불러서 디코딩한 다음에 명령어 버퍼(210)에 저장된다. 어떤 실시예에서, 명령어 버퍼(210)에서 각 액티브 워프는 전용 엔트리 세트를 가질 수 있다. 어떤 실시예에서, 멀티프로세서(200)는 데이터 위험성을 확인하기 위해서 스코어보드(scoreboard)(도시하지 않음)를 더 포함할 수 있다. 이 경우, 스코어보드가 워프에 대해서 위험성이 없다고 지시하면, 워프 스케줄러(220)가 명령어 버퍼(210)로부터 이 워프의 디코딩된 명령어를 선택할 수 있다.
각 프로세싱 유닛(230)은 워프 스케줄러(220)에서 출력되는 명령어를 처리한다. 프로세싱 유닛(230)은 다양한 컴퓨팅 연산, 예를 들면 정수 및 부동 소수점 연산(integer and floating point arithmetic), 비교 연산(comparison operation), 논리형 연산(Boolean operation), 비트 시프팅(bit-shifting), 다양한 대수 함수의 계산 등의 연산을 지원할 수 있다. 어떤 실시예에서, 프로세싱 유닛(230)은 예를 들면 산술 논리 유닛(arithmetic logic unit, ALU)일 수 있다. 각 로드-저장 유닛(240)은 메모리 유닛(250)으로부터 데이터를 로드하거나 메모리(250)에 저장한다.
메모리 유닛(250)은 L1D(level 1 data) 캐시(251)와 공유 메모리(shared memory)(252)를 포함한다. 어떤 실시예에서, 메모리 유닛(250)은 멀티프로세서(200)의 온칩 메모리 유닛(on-chip memory unit)일 수 있다. L1D 캐시(251)와 공유 메모리(252)는 예를 들면 512개 또는 256개의 행을 가진 32개의 뱅크를 포함하는 단일 온칩 메모리 구조를 공유할 수 있다. N개의 행이 L1D 캐시(251)에 할당되고, 나머지(예를 들면, (512-N) 또는 (256-N)개의) 행이 공유 메모리(252)에 할당될 수 있다. 예를 들면, 각 멀티프로세서(200)는 16KB (N=128) 또는 48KB (N=384)가 L1D 캐시(251)에 할당될 수 있는 64KB 온칩 메모리 구조를 지원할 수 있다.
공유 메모리(252)는 소프트웨어에 의해 관리될 수 있다. 각 CTA는 쓰레드간(inter-thread) 통신을 위해 배타적인 공유 메모리 공간을 요청할 수 있다. 따라서 어떤 실시예에서 멀티프로세서(200)는 독립적인 공유 메모리 관리 테이블(shared memory management table, SMMT)(261)을 보유할 수 있다. 각 CTA는 하나의 SMMT 엔트리를 예약하고 있으며, 엔트리는 주어진 CTA(CTAid)에 대해서 공유 메모리 공간의 시작 어드레스와 크기를 기록한다. 또한 어떤 실시예에서 멀티프로세서(200)는 크로스바(crossbar) 네트워크(262)를 통해 로드-저장 유닛(240)과 메모리 유닛(250)을 연결할 수 있다.
본 발명의 한 실시예에서, 공유 메모리(252)에는 복수의 캐시 라인이 할당되어 있어서, 일부 워프의 캐시 액세스가 공유 메모리(252)로 변경된다.
어떤 실시예에서, 멀티프로세서(200)는, 워프의 쓰레드에 의해 생성된 복수의 메모리 요청을 메모리 대역폭의 유용성을 향상시키기 위해서 적지만 더 큰 메모리 요청으로 통합하기 위해서 하드웨어 복합 유닛(coalescing unit)(263) 및 미스 상태 홀딩 레지스터(miss status holding register, MSHR)(264)를 더 포함할 수 있다.
이러한 멀티프로세서(200)에서, 복수의 워프가 제한된 용량을 가지는 L1D 캐시(251)를 공유하므로, 복수의 워프는 동일한 캐시 라인(cache line)에 대해서 경쟁할 수 있다. 따라서 L1D 캐시(251)에서 어떤 액티브 워프의 캐시된 데이터는 메모리 액세스를 요청하는 다른 액티브 워프의 캐시 액세스에 의해 퇴거(evict)될 수 있으며, 이에 따라 데이터 지역성(data locality)를 잃어버릴 수 있다. 이러한 현상을 캐시 간섭(cache interference)이라 한다. 특히 캐시 액세스 패턴이 불규칙적일 때 캐시 간섭이 악화될 수 있다.
도 3은 전형적인 멀티프로세서에서 캐시 간섭이 L1D 캐시에서 데이터 지역성을 악화시키는 예를 나타내는 도면이다.
도 3에 도시한 것처럼, 예를 들면 두 워프(W0, W1)가 L1D 캐시의 동일한 캐시 세트(Set0)에서 각각 데이터(D0, D4)를 반복적으로 요청하는 것으로 가정한다. 그러면 사이클 CA에서 데이터(D0)를 요청하는 워프(W0)는 워프(W1)가 가진 데이터(D4)를 L1D 캐시(270)에서 퇴거시키지만, 캐시 세트(Set0)에 데이터(D0)가 없으므로 콜드 미스(cold miss)가 발생한다. 사이클 CB에서 데이터(D4)를 요청하는 워프(W1)는 캐시 세트(Set0)에 데이터(D4)가 없으므로 미스(충돌 미스)(conflict miss)가 발생하며, 또한 워프(W1)의 데이터 요청은 워프(W0)가 가진 데이터(D0)를 캐시 세트(Set0)에서 퇴거시킨다. 마찬가지로, 사이클 CE에서 데이터(D0)를 요청하는 워프(W0)는 워프(W1)가 가진 데이터(D4)를 캐시 세트(Set0)에서 퇴거시키고, 사이클 CF에서 데이터(D4)를 요청하는 워프(W1)는 워프(W0)가 가진 데이터(D0)를 캐시 세트(Set0)에서 퇴거시킬 수 있다. 이에 따라 계속 충돌 미스가 발생한다.
한편, 어플리케이션, 즉 커널의 실행 동안, 동일한 데이터가 여러 번 참조되면 데이터 지역성이 존재한다. 도 3에서 워프(W0, W1)는 사이클 CA, CB, CE, CF에서 각각 데이터(D0, D4)를 반복적으로 얻기 위해서 메모리 요청을 계속 생성한다. 이들 메모리 요청은 데이터(D0, D4)가 다른 워프(W1, W0)에 의해 퇴거되지 않았다면 L1D 캐시에 히트했어야 한다. 이러한 캐시 히트 기회(cache hit opportunity)는 데이터 지역성의 가능성(potential)으로 불릴 수 있으며, 캐시 간섭이 발생하지 않은 경우 동일한 데이터를 재참조하는 빈도로서 측정된다. 도 3에서 두 워프(W0, W1)는 높은 가능성의 데이터 지역성을 보이지만, 이들 사이의 캐시 간섭이 불필요한 캐시 미스를 초래하고, 이는 규칙적인 메모리 액세스를 비규칙적인 캐시 액세스로 바꿀 수 있다.
이러한 캐시 간섭을 줄이기 위해서, 간섭을 일으키는 워프(interfering warps)를 간섭을 받는 워프(interfered warps)로부터 격리(isolation)할 수 있다. 이를 위해, 어떤 실시예에서 L1D 캐시 공간을 파티션하고, 파티션된 캐시 라인을 간섭을 일으키는 워프에 할당할 수 있다. 현재 CPU를 위해 공유된 캐시 공간을 파티션하는 다양한 기술이 제안되어 있다. 그러나 GPU와 같은 병렬 프로세싱 유닛에서 L1D 캐시 라인을 공유하는 쓰레드의 수가 CPU 쓰레드의 수에 비해서 매우 많은 반면, L1D 캐시의 크기가 CPU 기반 캐시 파티셔닝 기술을 병렬 프로세싱 유닛에 적용할 만큼 크지 않다. 예를 들면, CPU 기반 캐시 파티셔닝 기술을 L1D 캐시에 적용하면, 단지 두 개 또는 세 개의 캐시 라인만이 각 워프에 할당될 수 있다. 그러면 워프당 작은 수의 캐시 라인으로 인해 캐시 스래싱(cache thrashing)이 악화될 수 있다.
한편, PolyBench, Mars, Rodinia 등의 벤치마크 방법으로 21개의 어플리케이션에 대한 공유 메모리의 사용 공간을 분석하였을 때, 평균적으로 공유 메모리의 75%가 사용되지 않고 있었다. 본 발명의 한 실시예에서는, 이러한 사용되지 않은 공유 메모리 공간을 이용해서, 간섭을 일으키는 워프가 L1D 캐시 대신에 사용하지 않는 공유 메모리 공간에 액세스하도록 한다.
아래에서는 본 발명의 한 실시예에 따른 병렬 프로세싱 유닛에서 캐시 간섭을 줄이기 위한 워프 스케줄링 방법에 대해서 설명한다.
도 4는 본 발명의 한 실시예에 따른 병렬 프로세싱 유닛에서의 워프 스케줄링 방법을 나타내는 흐름도이고, 도 5, 도 6 및 도 7은 각각 본 발명의 한 실시예에 따른 병렬 프로세싱 유닛에서의 워프 파티셔닝(warp partitioning)을 설명하는 도면이다.
도 4 및 도 5를 참고하면, 커널 실행의 초기에는 캐시 간섭이 없으므로, 모든 워프(W0, W1, W2, W3)의 메모리 요청은 L1D 캐시(510)로 향한다(S410). 커널 실행이 진행됨에 따라, 일부 워프가 L1D 캐시(510)에서 특정 캐시 라인을 획득하기 위해서 서로 경쟁하기 시작할 수 있다.
소정의 조건을 만족하는 경우에(S420), 병렬 프로세싱 유닛의 멀티프로세서는 간섭을 일으키는 워프(예를 들면 도 5 및 도 6의 데이터(D3)를 요청하는 W3)를 검출한다(S430). 어떤 실시예에서, 소정의 조건은 L1D 캐시(510)에서의 캐시 간섭의 강도가 임계치를 넘는 조건일 수 있다. 즉, 캐시 간섭의 강도가 임계치를 넘어가면, 멀티프로세서는 간섭을 일으키는 워프를 검출할 수 있다. 다음, 도 6에 도시한 것처럼, 멀티프로세서는 액티브 워프를 간섭을 일으키는 워프와 간섭을 받는 워프로 파티션하고, 간섭을 일으키는 워프(W3)의 캐시 액세스를 사용하지 않는 공유 메모리 공간(520)으로 변경(redirect)하여서 간섭을 일으키는 워프(W3)를 격리(isolation)한다(S440). 이로 인해 병렬 프로세싱 유닛에서 쓰레드 레벨 병렬화(thread-level parallelism, TLP)를 떨어뜨리지 않으면서 캐시 경쟁이 줄어들 수 있다.
캐시 액세스 패턴의 변화나 일부 워프(예를 들면, 간섭을 받는 워프)의 실행 완료 등으로 인해 다른 소정의 조건이 만족되는 경우에(S450), 도 7에 도시한 것처럼 멀티프로세서는 간섭을 일으키는 워프의 격리를 철회(desegregate)하고, 이 워프의 메모리 요청을 다시 공유 메모리(520)에서 L1D 캐시(510)로 변경(redirect)한다(S460). 어떤 실시예에서, 다른 소정의 조건은 캐시 경쟁이 의미 있게 줄어드는 조건으로, 예를 들면 캐시 간섭의 강도가 임계치보다 낮은 조건일 수 있다. 즉, 캐시 경쟁이 의미 있게 줄어드는 것을 검출하면, 멀티프로세서는 간섭을 일으키는 워프의 격리 정책을 철폐하고 이 워프의 메모리 요청을 다시 L1D 캐시(510)로 변경한다. 한 실시예에서, 단계 S450에서의 임계치는 단계 S420에서의 임계치와 다를 수 있다. 예를 들면, 단계 S450에서의 임계치는 단계 S420에서의 임계치보다 작을 수 있다. 다른 실시예에서, 단계 S450에서의 임계치는 단계 S420에서의 임계치와 동일할 수 있다.
어떤 실시예에서, 단계 S420 및 단계 S450에서의 캐시 경쟁의 수, 즉 캐시 간섭의 강도를 판단하기 위해서, 멀티프로세서는 간섭 검출기(도시하지 않음)를 사용할 수 있다.
도 4 내지 도 7을 참고로 하여 설명한 캐시 간섭 감소 방법, 즉 워프 파티셔닝 방법은 멀티프로세서의 워프 스케줄러(도 2의 220)에 의해서 수행될 수 있다.
어떤 실시예에서, 메모리 요청(즉, 캐시 액세스 요청)은 크로스바 네트워크(530)를 통해 L1D 캐시(510) 또는 공유 메모리(530)로 전달될 수 있다.
한편, 멀티프로세서가 간섭을 일으키는 워프(W3)의 메모리 요청을 L1D 캐시(510)에서 공유 메모리(520)로 변경할 때, 공유 메모리(520)는 워프(W3)가 요청하는 데이터(D3)를 가지고 있지 않을 수 있다. 이 경우, 해당 워프(W3)에 대해서 콜드 미스(cold miss)에 따른 성능 열화 및 일관성(coherence) 문제가 발생할 수 있다. 이러한 문제를 해결하기 위해서, 어떤 실시예에서, 공유 메모리(520)에 액세스할 필요가 있을 때, 타깃 데이터(D3)가 L1D 캐시(510)에 존재하면, 도 6에 도시한 것처럼 멀티프로세서는 L1D 캐시(510)로부터 데이터(D3)를 소정의 큐(540)로 직접 퇴거시킬 수 있다. 한 실시예에서, 공유 메모리(520)에 액세스할 필요가 있을 때, 멀티프로세서는 L1D 캐시(510)의 태그 어레이를 체크해서 L1D 캐시(510)에 타깃 데이터(D3)가 존재하는지 확인할 수 있다. 다음 멀티프로세서는 도 7에 도시한 것처럼 소정의 큐(540)로 퇴거된 데이터(D3)를 공유 메모리(520)에 채울 수 있다. 이에 따라, L1D 캐시(510)로부터 공유 메모리(520)에 데이터를 이주시켜서 콜드 캐시 미스와 일관성 문제를 해결할 수 있다.
어떤 실시예에서, 소정의 큐(540)는 L2 캐시로부터 가지고 온 데이터를 버퍼링하고 L1D 캐시에서의 캐시 라인을 무효화시키는데 사용되는 응답 큐(response queue)일 수 있다.
어떤 실시예에서, 공유 메모리(520)는 채움 요청(fill request)을 MSHR(도시하지 않음)로 발행하고, MSHR의 엔트리에 기초해서 타깃 데이터가 소정의 큐(540)로부터 공유 메모리(520)로 직접 채워질 수 있다.
위에서 설명한 실시예에 따르면, 사용하지 않는 공유 메모리 공간을 L1D 캐시로 사용함으로써, 간섭을 일으키는 워프를 간섭 받는 워프로부터 효과적으로 차단할 수 있다. 한편, 차단하는 효율은 차단된 워프의 수 및 공유 메모리에서 사용되지 않는 공간 등의 다양한 런타임 요소에 달려 있을 수 있다. 예를 들면, 간섭을 일으키는 워프가 공유 메모리를 스래시(thrash)하게 될 때 캐시 간섭을 효과적으로 줄일 수 없을 수도 있다. 즉, 사용하지 않는 공유 메모리 공간의 크기 및/또는 대역폭이 간섭을 일으키는 워프로부터의 많은 양의 메모리 요청을 짧은 기간 내에 처리하기에 충분하지 않을 수도 있다.
한편, 사용하지 않는 공유 메모리 공간(520)을 L1D 캐시(510)로 사용하는 데는 두 가지 주요한 문제점이 있을 수 있다.
첫 번째는 공유 메모리(520)가 글로벌 메모리와 분리된 자신의 어드레스 공간을 가지고, 글로벌 메모리 어드레스를 공유 메모리 어드레스로 번역하는 하드웨어 지원이 없다는 점이다. 이를 위해, 어떤 실시예에서 멀티프로세서는 공유 메모리 앞에 주어진 글로벌 메모리 어드레스를 공유 메모리(520)에서의 로컬 메모리 어드레스로 번역하는 어드레스 번역 유닛(도시하지 않음)을 더 포함할 수 있다.
두 번째는 공유 메모리(520)는 L2 캐시와 메인 메모리와 같은 하위 메모리 계층에 직접 액세스하는 데이터 경로를 가지지 않는다는 점이다. 이를 위해 어떤 실시예에서 멀티프로세서는 공유 메모리 공간이 캐시로 동작할 때 공유 메모리(520)가 L2 캐시에 액세스할 수 있도록 L1D 캐시(510)와 L2 캐시(도시하지 않음) 사이의 데이터 경로를 조정할 수 있다. 한 실시예에서, 멀티프로세서는 L2 캐시와 같은 하위 메모리의 데이터를 버퍼링하는 응답 큐(540) 등의 큐와 메모리 유닛(510, 520) 사이에 멀티플렉서(550)를 더 포함할 수 있다. 멀티플렉서(550)는 큐를 L1D 캐시(510) 또는 공유 메모리(520)에 선택적으로 연결할 수 있다. 또한 멀티프로세서는 어드레스 번역 유닛으로부터 전달되는 메모리 요청의 공유 메모리 어드레스를 저장할 수 있다. 한 실시예에서, 멀티프로세서는 각 MSHR 엔트리에 확장 필드를 추가하여서 공유 메모리 어드레스를 저장할 수 있다. 이 경우, 공유 메모리(520)가 미스(miss) 이후에 채움 요청(fill request)을 발행하면, 요청은 글로벌 및 번역된 공유 메모리 어드레스를 채움으로써 하나의 MSHR 엔트리를 예약한다. L2 캐시로부터의 응답, 즉 응답 큐(540)로 퇴거된 데이터가 대응하는 MSHR 엔트리에 기록된 글로벌 메모리 어드레스와 일치하면, 데이터는 번역된 공유 메모리 어드레스에 기초해서 공유 메모리(520)에 직접 저장될 수 있다.
도 8은 본 발명의 다른 실시예에 따른 병렬 프로세싱 유닛에서의 워프 스케줄링 방법을 나타내는 흐름도이고, 도 9, 도 10 및 도 11은 각각 본 발명의 한 실시예에 따른 병렬 프로세싱 유닛에서의 워프 스로틀링(warp throttling)을 설명하는 도면이다.
도 8 및 도 9를 참고하면, 두 워프(W0, W1)가 요청하는 데이터가 L1D 캐시(910)에서 캐시 세트(Set0, Set1)에 각각 매핑되어 있으며, 워프(W3)의 메모리 요청이 공유 메모리(920)로 변경되어서 워프(W3)가 요청하는 데이터가 공유 메모리(920)에서 캐시 세트(Set0)에 매핑되어 있는 것으로 가정한다. 또한 L1D 캐시(910)의 캐시 세트(Set1)에 대해서 간섭을 일으키는 워프(W2)의 메모리 요청이 공유 메모리(920)의 캐시 세트(Set1)로 변경된 것으로 가정한다. 이 경우, 워프(W4)의 메모리 요청이 공유 메모리(920)의 캐시 세트(Set1)로 변경되면, 두 워프(W2, W4)가 공유 메모리(920)의 캐시 세트(Set1)에 반복적으로 액세스하여서 캐시 간섭이 발생한다(S810). 따라서 캐시 간섭을 일으키는 워프(W2, W4)가 공유 메모리(920)를 결국 스래시(thrash)할 수 있다.
멀티프로세서는 공유 메모리(920)로 변경된 워프, 즉 격리된 워프(W2, W3, W4)에서 공유 메모리 간섭의 강도를 모니터링한다(S820). 모니터링의 결과 소정의 조건이 만족되는 경우에(S830), 도 10에 도시한 것처럼 멀티프로세서는 소정의 조건에 따라 선택된 워프(예를 들면, 도 10의 W2)를 스톨(stall)(또는 스로틀(throttle))한다(S840). 어떤 실시예에서, 소정의 조건은 공유 메모리 간섭의 강도가 임계치를 넘는 조건일 수 있다. 어떤 실시예에서, 소정의 조건에 따라 선택된 워프는 가장 많은 캐시 간섭을 일으키는 워프일 수 있다. 어떤 실시예에서, 스톨 처리(S840)는 공유 메모리 간섭의 강도가 임계치 아래로 떨어질 때까지 계속 진행될 수 있다.
캐시 액세스 패턴의 변화나 일부 워프의 실행 완료 등으로 인해 다른 소정의 조건이 만족되는 경우에(S850), 도 11에 도시한 것처럼 멀티프로세서는 스톨된 워프(W2)를 재활성화한다(S860). 재활성화된 워프(W2)는 다시 공유 메모리(920)의 해당 캐시 세트(Set1)에 액세스할 수 있다. 이에 따라, 병렬 프로세싱 유닛에서 높은 TLP를 유지하고, 공유 메모리(920)의 활용성을 최대화할 수 있다. 어떤 실시예에서, 다른 소정의 조건은 공유 메모리(920)에서의 간섭의 강도가 줄어드는 조건으로, 예를 들면 공유 메모리(920)에서의 캐시 경쟁의 수가 임계치보다 낮은 조건일 수 있다. 한 실시예에서, 단계 S850에서의 임계치는 단계 S830에서의 임계치와 다를 수 있다. 예를 들면, 단계 S850에서의 임계치는 단계 S830에서의 임계치보다 작을 수 있다. 다른 실시예에서, 단계 S850에서의 임계치는 단계 S830에서의 임계치와 동일할 수 있다.
어떤 실시예에서, 단계 S830 및 단계 S850에서의 간섭의 강도를 판단하기 위해서, 멀티프로세서는 간섭 검출기(도시하지 않음)를 사용할 수 있다. 한 실시예에서, 멀티프로세서는 도 4에서의 단계 S420 및 S450에 사용하는 간섭 검출기를 단계 S830 및 단계 S850에서 사용할 수 있다. 이는 격리된 워프는 L1D 캐시(910)에 액세스하는 정기적인 워프와 L1D 캐시(910)를 경쟁하지 않고, 공유 메모리(920)에서 다른 격리된 워프와 간섭을 일으키기 때문이다. 그러므로 L1D 캐시(910)와 공유 메모리(920)에서의 간섭은 서로에게 영향을 미치지 않고, 이에 따라 멀티프로세서는 간섭 검출기를 공유할 수 있다. 다른 실시예에서, 멀티프로세서는 도 4에서의 단계 S20 및 S450에 사용하는 간섭 검출기와 다른 간섭 검출기를 단계 S830 및 단계 S850에서 사용할 수 있다.
위에서 설명한 실시예에 따르면, 공유 메모리(920)에서 캐시 간섭의 강도가 높은 경우에 공유 메모리(920)로 설정된 일부 워프를 스톨함으로써, 간섭을 일으키는 워프가 공유 메모리를 스래시하는 것을 방지할 수 있다.
다음 본 발명의 한 실시예에 따른 병렬 프로세싱 유닛에서의 간섭 검출에 대해서 설명한다.
도 12는 본 발명의 한 실시예에 따른 병렬 프로세싱 유닛에서 가장 자주 간섭을 일으키는 워프를 관리하는 방법을 설명하는 도면이며, 도 13은 병렬 프로세싱 유닛에서의 캐시 간섭을 설명하는 도면이다.
일부 워프의 캐시 액세스가 다른 워프의 캐시 액세스를 심각하게 간섭하여서 비균일한 캐시 간섭을 초래할 수 있다. 그러나 비규칙적인 캐시 액세스 패턴을 가지는 어플리케이션에 대해서 단순히 어플리케이션 코드나 캐시 대체 정책(cache replacement policy)을 검사함으로써 이러한 비균일 캐시 간섭 정보를 포착하는 것은 어렵다. 어떤 실시예에서, 각 워프에 대해서 모든 다른 워프에 의해 발생하는 캐시 미스를 추적해서 간섭을 검출할 수 있다. 이 경우 n(n-1)개의 엔트리 스토리지 구조가 요구되므로, 높은 스토리지 비용이 발생할 수 있다. 여기서 n은 멀티프로세서에서 액티브 워프의 개수이다.
도 12를 참고하면, 멀티프로세서는 간섭 리스트를 관리하고, 간섭 리스트의 한 엔트리를 각 워프에 할당하고, 현재 실행되는 워프와 최근에 가장 자주 간섭을 일으키는 워프의 워프 번호(WID)를 현재 실행되는 워프에 해당하는 엔트리에 저장할 수 있다. 어떤 실시예에서, 멀티프로세서는 각 워프에 대해서 최근에 가장 자주 간섭을 일으키는 워프를 추적할 수 있다. 한 실시예에서, 멀티프로세서는 각 워프에 대해서 최근에 가장 자주 간섭을 일으키는 워프만 추적할 수 있다. 그러면 각 워프에서 대해서 간섭을 일으키는 워프를 추적하기 위한 스토리지 비용을 줄일 수 있다.
주어진 워프에 대해서 최근에 가장 자주 간섭을 일으키는 워프를 추적하기 위해서, 멀티프로세서는 간섭 리스트의 각 엔트리에 연결된 포화(saturation) 카운터를 더 포함할 수 있다. 한 실시예에서, 포화 카운터는 2 비트 포화 카운터일 수 있다.
도 13에 도시한 것처럼, 워프(W34)에 대해서 최근에 간섭을 일으키는 워프(W32, W36, W38, W40, W42) 중에서 워프(W32)가 가장 자주 간섭을 일으키는 워프이며, 나머지 워프(W2-W4)는 워프(W34)에 전혀 간섭하지 않는 워프로 가정한다. 멀티프로세서가 전에 실행된 워프(W32)가 현재 실행되는 워프(W34)와 가장 자주 간섭을 일으키는 것으로 결정하면, 도 12에 도시한 것처럼 간섭을 일으키는 워프(W32)의 WID를 간섭 리스트에서 워프(W34)와 관련된 엔트리에 저장한다. 워프(W32)가 워프(W34)와 간섭을 일으킬 때마다, 포화 카운터는 1씩 증가한다. 포화 카운터가 어떤 사이클에서 포화값(예를 들면 '11')에 이미 도달했다고 가정한다(S1310). 이어지는 사이클에서 다른 워프(W42)가 워프(W34)와 간섭을 일으킬 때, 포화 카운터는 1만큼 감소한다(S1320). 다음 워프(W32)가 워프(W34)에 다시 간섭을 일으키면, 포화 카운터는 1만큼 증가한다(S1330). 이와 같이, 어떤 워프(W34)에 대해서 간섭 리스트의 엔트리에 저장된 워프(W32) 이외의 다른 워프의 간섭에 의해 포화 카운터가 감소해서 '00'으로 되면, 간섭 리스트에서의 워프(W32)는 다른 워프로 대체될 수 있다. 이에 따라 가장 빈번한 캐시 간섭이 간섭 리스트에 유지될 수 있다.
어떤 실시예에서, 멀티프로세서는 개별 워프가 경험하는 캐시 간섭의 강도(레벨)를 개별 재참조 스코어(individual re-reference score, IRS)에 의해 검출할 수 있다. 워프 i(Wi)의 IRS(IRSi)는 예를 들면 아래의 수학식 1처럼 표현될 수 있다.
Figure PCTKR2016011719-appb-M000001
여기서, i는 액티브 워프의 번호이고, Fi VTA -hits는 워프 i에 대한 빅팀 태그 어레이(victim tag array, VTA) 히트의 개수이며, Nexecuted - inst는 실행된 명령어의 총 개수이고, Nactive -warp는 멀티프로세서 상에서 동작하는 액티브 워프의 개수이다.
한 실시예에서, VTA는 각 워프의 캐시 액세스 이력을 관리하기 위해서 멀티프로세서의 메모리 유닛에 포함될 수 있다. 도 14를 참고하면, VTA는 복수의 워프에 각각 대응하는 복수의 엔트리를 포함하며, 각 엔트리의 필드에는 대응하는 워프의 태그가 저장될 수 있다.
멀티프로세서는 L1D 캐시의 캐시 라인에 대응하는 워프의 WID를 부착할 수 있다. 캐시 라인에 부착된 WID는 어느 액티브 워프가 현재의 데이터를 캐시 라인에 가지고 왔는지를 추적하는데 사용될 수 있다. 캐시 라인이 퇴거될 때, 멀티프로세서는 WID를 퇴거된 캐시 라인으로부터 회수하고, 퇴거된 캐시 라인의 태그를 해당 WID와 결합된 VTA 엔트리에 저장한다. 따라서 L1D 캐시에서 미스가 있을 때마다, 멀티프로세서는 VTA를 관찰할 수 있다. 이 경우, 해당하는 워프의 VTA 엔트리에 태그가 발견되면, 멀티프로세서는 VTA 히트를 카운트할 수 있다. 즉, 멀티프로세서는 VTA를 통해 워프가 메모리 요청을 동일한 캐시 라인에 반복적으로 놓는 것을 관찰하면(즉, VTA 히트를 관찰하면), 해당 워프가 데이터 지역성의 가능성을 보인다고 판단할 수 있다.
다시 수학식 1을 참고하면, IRSi는 워프 i에 대해서 명령어마다의 VTA 히트(즉, VTA 히트의 강도)를 지시한다. 따라서 높은 IRSi는 워프 i가 주어진 시기(epoch) 동안 심한 캐시 간섭을 겪는다는 것을 지시할 수 있다. Nexecuted - inst와 Nactive-warp는 시간에 따라 변할 수 있으므로, 한 실시예에서 IRSi는 주어진 시기에 대한 (Nexecuted - inst/Nactive-warp)를 고려하기 위해서 주기적으로 갱신될 수 있다. 주어진 시간에 대한 IRSi에 기초해서, 워프 스케줄러는 (1) 워프 i와 간섭을 일으키는 워프를 파티션할지(즉, 격리할지), (2) 간섭을 일으키는 워프를 스톨할지 또는 (3) 이전에 스톨된 워프를 재활성화할지를 결정할 수 있다.
어떤 실시예에서, 워프 스케줄러가 간섭을 일으키는 워프를 파티션할지, 스톨할지 또는 재활성화할지를 결정하기 위해서, 두 가지 임계치, 즉 (1) 높은 컷오프(high cutoff)와 (2) 낮은 컷오프(low cutoff)를 사용할 수 있다. 높은 컷오프보다 높은 IRSi는 워프 i가 높은 레벨의 캐시 간섭을 겪는다는 것을 지시할 수 있다. 따라서 IRSi가 높은 컷오프보다 높으면, 워프 스케줄러는 워프 i에 대해서 최근에 가장 자주 간섭을 일으키는 워프를 파티션하거나 스톨할 수 있다. 낮은 컷오프보다 낮은 IRSi는 워프 i는 낮은 레벨의 캐시 간섭을 겪거나 실행을 완료하였다는 것을 지시할 수 있다. 따라서 IRSi가 낮은 IRS보다 낮으면, 워프 스케줄러는 이전에 스톨된 워프를 재활성화하거나 이전에 격리된 워프의 격리를 철회(이전에 격리된 워프의 메모리 요청을 L1D 캐시로 변경)할 수 있다.
아래 표 1에서 예시한 조건에서, 다이버스 메모리 집약적 어플리케이션을 평가한 결과, 예를 들면 높은 컷오프와 낮은 컷오프를 각각 대략 1%와 0.5%로 설정할 수 있다.
IRS가 시간에 따라 변함에 따라, 워프 스케줄러는 워프가 파티션, 스톨 또는 재활성화될 필요가 있는지 정확하게 결정하기 위해서, 높은 컷오프와 낮은 컷오프와 IRS를 주기적으로 비교할 수 있다. 이를 위해, 어떤 실시예에서 워프 스케줄러는 실행 시간을 높은 컷오프 시기와 낮은 컷오프 시기로 분할할 수 있다. 높은 컷오프 시기와 낮은 컷오프 시기로 이루어지는 사이클이 반복될 때, 각 높은 컷오프 시기의 끝에 워프 스케줄러는 IRS를 높은 컷오프와 비교할 수 있으며, 각 낮은 컷오프 시기의 끝에 워프 스케줄러는 IRS를 낮은 컷오프와 비교할 수 있다.
한 실시예에서, 낮은 컷오프 시기는 높은 컷오프 시기보다 짧을 수 있다. 이와 같이 낮은 컷오프 시기는 높은 컷오프 시기보다 짧으면, 이전에 스톨된 워프가 런타임에서 다른 워프와 현저하게 간섭을 일으키지 않기 시작하자마자, 이들 워프를 재활성화시킴으로써 스톨하고 있는 워프의 부정적 영향을 최소화할 수 있다. 이에 따라 높은 TLP를 유지할 수 있다.
아래 표 1에서 예시한 조건에서, 다이버스 메모리 집약적 어플리케이션을 평가한 결과, 예를 들면 높은 컷오프 시기와 낮은 컷오프 시기의 길이를 각각 대략 5000 및 100 명령어로 설정할 수 있다.
다음 높은 컷오프와 낮은 컷오프를 사용하는 워프 스케줄링 방법에 대해서 도 15 및 도 16을 참고로 하여 설명한다.
도 15 및 도 16은 각각 본 발명의 실시예에 따른 병렬 프로세싱 유닛에서의 워프 스케줄링 방법을 나타내는 흐름도이다.
도 15을 참고하면, 병렬 프로세싱 유닛의 멀티프로세서는 액티브 워프 i에 대해서 캐시 간섭의 레벨을 검출한다(S1510). 어떤 실시예에서, 멀티프로세서는 높은 컷오프 시기가 종료할 때 캐시 간섭 레벨을 검출할 수 있다. 워프 i의 캐시 간섭 레벨이 소정의 조건을 만족하는 경우(S1520), 멀티프로세서는 워프 i에 대해서 가장 자주 간섭을 일으키는 워프 j를 검출한다(S1530). 어떤 실시예에서, 소정의 조건은 캐시 간섭 레벨, 예를 들면 ISRi가 높은 컷오프보다 높은 조건일 수 있다. 이에 따라, 멀티프로세서는 워프 j의 캐시 액세스를 공유 메모리로 격리한다(S1540). 어떤 실시예에서, 멀티프로세서는 워프 j를 격리한 워프 i의 워프 번호를 기록할 수 있다.
다음, 멀티프로세서는 워프 j를 격리시킨 워프(즉, 워프 i)에 대해서 캐시 간섭 레벨을 검출한다(S1550). 어떤 실시예에서, 멀티프로세서는 낮은 컷오프 시기가 종료할 때 캐시 간섭 레벨을 검출할 수 있다. 워프 i의 캐시 간섭 레벨이 소정의 다른 조건을 만족하는 경우(S1560), 멀티프로세서는 워프 j의 격리를 철회한다(S1570). 이에 따라 워프 j는 다시 L1D 캐시로 액세스할 수 있다. 한 실시예에서, 소정의 다른 조건은 워프 i의 캐시 간섭 레벨, 예를 들면 ISRi가 낮은 컷오프보다 낮은 조건일 수 있다. 다른 실시예에서, 소정의 다른 조건은 워프 i의 실행이 완료된 조건일 수 있다. 이와는 달리, 소정의 다른 조건을 만족하지 않는 경우(S1560), 멀티프로세서는 워프 j의 캐시 액세스를 계속 격리한다(S1570).
이와 같이, 워프 i에 대해서 간섭을 자주 일으키는 워프 j를 격리함으로써, 캐시 간섭을 줄일 수 있으면서 TLP를 유지할 수도 있다.
도 16을 참고하면, 병렬 프로세싱 유닛의 멀티프로세서는 워프 i에 대해서 캐시 간섭의 레벨을 검출한다(S1610). 워프 i는 L1D 캐시로 액세스하는 워프이거나 공유 메모리로 액세스하는 워프일 수 있다. 어떤 실시예에서, 멀티프로세서는 높은 컷오프 시기가 종료할 때 캐시 간섭 레벨을 검출할 수 있다. 워프 i의 캐시 간섭 레벨이 소정의 조건을 만족하는 경우(S1620), 멀티프로세서는 워프 i에 대해서 가장 자주 간섭을 일으키는 워프 j를 검출한다(S1630). 어떤 실시예에서, 소정의 조건은 캐시 간섭 레벨, 예를 들면 ISRi가 높은 컷오프보다 높은 조건일 수 있다.
멀티프로세서는 워프 j의 상태가 격리 상태인지를 판단한다(S1640). 워프 j가 격리 상태이면(S1640), 멀티프로세서는 워프 j를 스톨한다(S1642). 어떤 실시예에서, 멀티프로세서는 워프 j를 스톨한 워프 i의 워프 번호를 기록할 수 있다. 워프 j가 격리 상태가 아니면, 즉 워프 j가 액티브 상태이면(S1640), 멀티프로세서는 워프 j의 캐시 액세스를 공유 메모리로 격리한다(S1644). 어떤 실시예에서, 멀티프로세서는 워프 j를 격리한 워프 i의 워프 번호를 기록할 수 있다.
다음, 멀티프로세서는 워프 j를 격리시킨 워프(즉, 워프 i)에 대해서 캐시 간섭 레벨을 검출한다(S1650). 어떤 실시예에서, 멀티프로세서는 낮은 컷오프 시기가 종료할 때 캐시 간섭 레벨을 검출할 수 있다. 워프 i의 캐시 간섭 레벨이 소정의 다른 조건을 만족하는 경우(S1660), 멀티프로세서는 워프 j의 격리를 철회한다(S1670). 이에 따라 워프 j는 다시 L1D 캐시로 액세스할 수 있다. 한 실시예에서, 소정의 다른 조건은 워프 i의 캐시 간섭 레벨, 예를 들면 ISRi가 낮은 컷오프보다 낮은 조건일 수 있다. 다른 실시예에서, 소정의 다른 조건은 워프 i의 실행이 완료된 조건일 수 있다. 이와는 달리, 소정의 다른 조건을 만족하지 않는 경우(S1660), 멀티프로세서는 워프 j의 캐시 액세스를 계속 격리한다.
또는 멀티프로세서는 워프 j를 스톨시킨 워프(즉, 워프 i)에 대해서 캐시 간섭 레벨을 검출한다(S1680). 어떤 실시예에서, 멀티프로세서는 낮은 컷오프 시기가 종료할 때 캐시 간섭 레벨을 검출할 수 있다. 워프 i의 캐시 간섭 레벨이 소정의 다른 조건을 만족하는 경우(S1690), 멀티프로세서는 워프 j를 재활성화한다(S1695). 한 실시예에서, 소정의 다른 조건은 워프 i의 캐시 간섭 레벨, 예를 들면 ISRi가 낮은 컷오프보다 낮은 조건일 수 있다. 다른 실시예에서, 소정의 다른 조건은 워프 i의 실행이 완료된 조건일 수 있다. 이와는 달리, 소정의 다른 조건을 만족하지 않는 경우(S1690), 멀티프로세서는 워프 j의 캐시 액세스를 계속 스톨한다.
이와 같이, 격리된 워프 j가 다시 캐시 간섭을 일으키는 경우 격리된 워프 j를 스톨함으로써 캐시 간섭을 줄일 수 있다. 또한 캐시 간섭이 줄어드는 경우, 스톨한 워프 j를 재활성화함으로써 TLP를 유지할 수 있다.
다음, 본 발명의 한 실시예에 따른 병렬 프로세싱 유닛에서 멀티프로세서의 구조에 대해서 설명한다.
도 17은 본 발명의 한 실시예에 따른 병렬 프로세싱 유닛에서 멀티프로세서의 개략적인 블록도이다. 도 17에서는 멀티프로세서에서 워프 스케줄러와 메모리 유닛을 도시하였다.
도 17을 참고하면, 멀티프로세서의 워프 스케줄러(1710)는 캐시 간섭의 레벨을 검출하는 카운터(1711)를 포함한다. 어떤 실시예에서, 카운터(1711)는 복수의 VTA 히트 카운터(VTACount0-VTACountk)와 전체 명령어 카운터(Inst-total)를 포함할 수 있다. 이 경우, VTA 히트 카운터는 워프별로 제공될 수 있다. 각 VTA 히트 카운터(VTACounti)는 대응하는 워프(Wi)에 대해서 VTA 히트 수(Fi VTA -hits)를 기록하고, 전체 명령어 카운터(Inst-total)는 해당 멀티프로세서에 의해 실행된 명령어의 총 수(Nexecuted-inst)를 기록한다. 멀티프로세서는 복수의 VTA 히트 카운터(VTACount0-VTACountk)와 전체 명령어 카운터(Inst-total)를 통해 개별 워프가 겪는 캐시 간섭의 레벨을 검출할 수 있다. 어떤 실시예에서 캐시 간섭의 레벨은 IRS로 표현될 수 있다.
워프 스케줄러(1710)는 캐시 간섭의 레벨과 임계치를 비교하기 위해서 컷오프 검사 유닛(1712)을 더 포함할 수 있다. 어떤 실시예에서, 캐시 간섭의 레벨은 IRS이고, 임계치는 높은 컷오프와 낮은 컷오프를 포함할 수 있다. 그러면 컷오프 검사 유닛(1712)은 IRS와 높은 컷오프 및 낮은 컷오프를 비교한다. 한 실시예에서, 컷오프 검사 유닛(1712)은 레지스터, 시프팅 유닛 및 비교 로직을 사용해서 구현될 수 있다. 워프 스케줄러는 샘플러(1713)를 더 포함할 수 있으며, 샘플러(1713)는 실행된 명령어의 수를 카운트하여서 높은 컷오프 시기 또는 낮은 컷오프 시기가 종료되었는지를 결정한다.
워프 스케줄러(1710)는 간섭을 일으키는 워프를 관리하기 위한 리스트를 포함한다. 어떤 실시예에서, 리스트는 워프 리스트(1714), 간섭 리스트(1715) 및 페어 리스트(pair list)(1716)를 포함할 수 있다.
간섭 리스트(1714)는 간섭을 일으키는 워프를 추적하는데 관련된 정보를 관리하는데 사용될 수 있다. 간섭 리스트(1714)는 복수의 워프에 각각 할당된 복수의 엔트리를 포함한다. 각 엔트리는 할당된 워프의 WID에 의해 인덱스되어 있으며, 간섭을 일으키는 워프의 WID와 포화 카운터(C)를 저장한다. VTA 히트가 발생할 때마다, 간섭 리스트의 해당하는 엔트리가 갱신될 수 있다. 예를 들면, 엔트리에 저장된 WID와 동일한 워프가 간섭을 일으킬 때마다 포화 카운터(C)는 1씩 증가하고, 엔트리에 저장된 WID와 다른 워프가 간섭을 일으킬 때마다 포화 카운터(C)는 1씩 감소할 수 있다. 이 경우, 포화 카운터(C)가 포화값(예를 들면, '11')에 도달하면 추가로 증가하지 않고, 포화 카운터(C)가 소정값(예를 들면, '00')에 도달하면 해당 엔트리의 WID는 다른 워프의 WID로 갱신될 수 있다.
간섭 리스트(1714)는 ISR에 기초해서 간섭을 일으키는 워프를 파티션할 필요가 있을 때마다 체크될 수 있다. 이를 위해, 복수의 준비(ready) 워프 엔트리를 포함하는 워프 리스트(1715)는 각 준비 워프 엔트리에 연결된 상태 플래그를 포함한다. 워프 스케줄러는 상태 플래그를 이용해서 주어진 워프의 상태, 즉 주어진 워프가 액티브 상태인지 또는 격리 상태인지를 식별할 수 있다. 예를 들면, 상태 플래그는 격리 플래그(I)를 포함하고, 격리 플래그(I)가 0인 경우가 액티브 상태(I=0)로, 격리 플래그(I)가 1인 경우가 격리 상태(=1)로 식별될 수 있다.
다른 실시예에서, 워프 스케줄러가 스톨 상태를 추가로 관리할 수 있다. 이 경우, 간섭 리스트(1714)는 ISR에 기초해서 간섭을 일으키는 워프를 파티션 또는 스톨할 필요가 있을 때마다 체크될 수 있다. 어떤 실시예에서, 상태 플래그는 액티브 플래그(V)와 격리 플래그(I)를 포함할 수 있다. 한 실시예에서 액티브 플래그와 격리 플래그는 각각 1 비트일 수 있다. 워프 스케줄러는 상태 플래그(V, I)를 이용해서 주어진 워프의 상태, 즉 주어진 워프가 액티브 상태인지, 격리 상태인지 또는 스톨 상태인지를 식별할 수 있다. 예를 들면, 액티브 플래그가 1이고 격리 플래그가 0인 경우가 액티브 상태(V=1, I=0)로, 액티브 플래그와 격리 플래그가 모두 1인 경우가 격리 상태(V=1, I=1)로, 액티브 플래그가 0인 경우가 스톨 상태(V=0)로 식별될 수 있다.
페어 리스트(1716)는 복수의 워프에 각각 할당된 복수의 엔트리를 포함하며, 각 엔트리는 할당된 워프의 WID에 의해 인덱스되어 있다. 각 엔트리는 어느 간섭받는 워프가 과거에 워프 파티셔닝을 일으켰는지를 기록한다. 이를 위해, 어떤 실시예에서 각 엔트리는 워프 파티셔닝을 일으킨 간섭받는 워프의 WID를 기록하기 위한 필드를 포함할 수 있다. 워프 i에 해당하는 엔트리의 필드의 WID에 기초해서, 워프 스케줄러는 이전에 워프 i의 파티셔닝을 일으킨 간섭받는 워프 k의 ISR(ISRk)을 확인한다. 예를 들면, 워프(W0)가 워프(W1)에 의해 심하게 간섭을 받음에 따라, 워프 스케줄러는 워프(W1)를 파티션하여 그 캐시 액세스를 격리하는 것으로 결정할 수 있다. 그러면 도 17에 도시한 것처럼 워프(W0)의 WID가 워프(W1)에 대응하는 페어 리스트 엔트리의 필드에 기록되고, 워프(W1)에 대응하는 간섭 리스트 엔트리의 격리 플래그(I)가 설정될 수 있다. 워프(W1)는 파티션된 후에 공유 메모리로 액세스하기 시작한다. 나중에 워프 스케줄러가 워프(W1)의 격리를 철회할 필요가 있을 때, 워프(W1)에 대응하는 페어 리스트 엔트리의 필드와 워프(W1)에 대응하는 간섭 리스트 엔트리의 격리 플래그(I)가 클리어될 수 있다.
다른 실시예에서, 페어 리스트(1716)의 각 엔트리는 어느 간섭받는 워프가 과거에 워프 스톨링을 일으켰는지를 추가로 기록할 수 있다. 이를 위해, 어떤 실시예에서 각 엔트리는 두 필드를 포함할 수 있다. 제1 필드는 워프 파티셔닝을 일으킨 간섭받는 워프의 WID를 기록하고, 제2 필드는 워프 스톨링을 일으킨 간섭받는 워프의 WID를 기록할 수 있다. 워프 i에 해당하는 엔트리의 두 필드의 WID에 기초해서, 워프 스케줄러는 이전에 워프 i의 파티셔닝 또는 스톨을 일으킨 간섭받는 워프 k의 ISR(ISRk)을 확인한다. 예를 들면, 워프(W0)가 워프(W1)에 의해 심하게 간섭을 받음에 따라, 워프 스케줄러는 워프(W1)를 파티션하여 그 캐시 액세스를 격리하는 것으로 결정할 수 있다. 그러면 도 17에 도시한 것처럼 워프(W0)의 WID가 워프(W1)에 대응하는 페어 리스트 엔트리의 제1 필드에 기록되고, 워프(W1)에 대응하는 간섭 리스트 엔트리의 격리 플래그(I)가 설정될 수 있다. 워프(W1)는 파티션된 후에 공유 메모리로 액세스하기 시작한다. 이 경우, 워프 스케줄러가 워프(W1)가 공유 메모리로 액세스하고 있는 다른 워프(W3)에 심하게 간섭을 일으키는 것으로 판단하면, 워프(W1)를 스톨할 수 있다. 워프 스케줄러가 워프(W1)를 스톨하기로 결정함에 따라, 워프(W3)의 WID가 워프(W1)에 대응하는 페어 리스트 엔트리의 제2 필드에 기록되고, 워프(W1)에 대응하는 간섭 리스트 엔트리의 액티브 플래그(V)가 클리어될 수 있다. 나중에 워프 스케줄러가 워프(W1)를 재활성화할 필요가 있을 때, 워프(W1)에 대응하는 페어 리스트 엔트리의 제2 필드와 워프(W1)에 대응하는 간섭 리스트 엔트리의 액티브 플래그(V)가 클리어될 수 있다. 또한 워프 스케줄러가 워프(W1)의 격리를 철회할 필요가 있을 때, 워프(W1)에 대응하는 페어 리스트 엔트리의 제1 필드와 워프(W1)에 대응하는 간섭 리스트 엔트리의 격리 플래그(I)가 클리어될 수 있다.
멀티프로세서의 메모리 유닛(1720)은 L1D 캐시(1721)와 공유 메모리(1722)를 포함한다. L1D 캐시(1721)의 캐시 라인에는 데이터와 태그가 저장되고, 대응하는 워프의 WID가 부착될 수 있다. 공유 메모리(1722)에서 사용하지 않는 공간은 캐시로서 사용되고, 캐시로 사용되는 공간의 캐시 라인에는 데이터와 태그가 저장될 수 있으며, 태그에는 대응하는 워프의 WID가 부착될 수 있다. 어떤 실시예에서 메모리 유닛(1720)는 캐시 라인의 미스 시에 대응하는 워프의 엔트리에 태그를 기록하기 위한 VTA(1730)를 더 포함할 수 있다.
워프 스케줄러(1710)와 메모리 유닛(1720)은 로드-저장 유닛(1730)을 통해 연결될 수 있다.
도 18은 본 발명의 한 실시예에 따른 병렬 프로세싱 유닛에서 메모리 유닛의 동작을 설명하는 도면이며, 도 19는 한 실시예에 따른 병렬 프로세싱 유닛에서 메모리 유닛의 구조를 설명하는 도면이며, 도 20은 한 실시예에 따른 병렬 프로세싱 유닛에서 어드레스 번역을 설명하는 도면이다.
도 18을 참고하면, 멀티프로세서는 메모리 유닛(1810), 제어 로직(1820) 및 멀티플렉서(1830) 및 큐(1840)를 포함하며, 메모리 유닛(1810)은 L1D 캐시(1811)와 공유 메모리(1812)를 포함한다.
공유 메모리(1812)를 캐시로 사용할 때, 공유 메모리(1812)는 글로벌 메모리로부터 논리적으로 분리되어 있으므로, 멀티프로세서는 공유 메모리(1812)와 L2 캐시 사이의 데이터 경로를 설정한다. 이를 위해, 멀티플렉서(1830)가 글로벌 메모리 또는 L2 캐시로부터 가지고 온 데이터를 버퍼링하는 큐(1840)와 L1D 캐시(1811) 또는 공유 메모리(1812)를 선택적으로 연결한다. 이러한 큐(1840)는 쓰기 큐(1841)와 응답 큐(1842)를 포함할 수 있다.
제어 로직(1820)은 주어진 워프의 상태에 기초하여서 멀티플렉서(1830)를 제어한다. 주어진 워프의 상태가 격리 상태이면(예를 들면, 도 17의 격리 플래그(I)가 '1'이면), 제어 로직(1820)은 공유 메모리(1812)와 큐(1840) 사이에 데이터 경로가 형성되도록 멀티플렉서(1830)를 제어할 수 있다. 제어 로직(1820)은 멀티플렉서(1830)를 제어할 때 캐시 태그를 체크한 결과(히트/미스)를 더 참조할 수도 있다.
또한 멀티프로세서는 어드레스 번역 유닛으로부터의 메모리 요청의 공유 메모리 어드레스(SHM Addr)를 저장할 수 있다. 어떤 실시예에서, 멀티프로세서는 각 MSHR 엔트리에 확장 필드를 추가하여서 어드레스 번역 유닛으로부터의 메모리 요청의 공유 메모리 어드레스를 저장할 수 있다. 각 MSHR 엔트리는 어드레스 유효 플래그(V), 명령 ID(예를 들면 프로그램 카운터(program counter, PC)) 및 글로벌 메모리 어드레스(Gl Addr)를 더 포함할 수 있다.
공유 메모리(1812)가 미스 이후에 채움(fill) 요청을 발행하면, 요청은 글로벌 및 번역된 공유 메모리 어드레스를 채움으로써 하나의 MSHR 엔트리를 예약한다. L2 캐시로부터의 응답이 대응하는 MSHR 엔트리에 기록된 글로벌 메모리 어드레스와 일치하면, 해당 데이터는 번역된 공유 메모리 어드레스에 기초해서 공유 메모리(1812)에 직접 저장될 수 있다.
LID 캐시(1811)와 비교해서, 공유 메모리(1812)는 캐시 태그를 수용하기 위한 개별 메모리 구조를 가지지 않는다. 한 실시예에서 공유 메모리(1812)의 캐시 태그를 수용하기 위해 추가적인 태그 어레이를 채용할 수 있다.
어떤 실시예에서, 추가적인 태그 어레이 대신에 공유 메모리(1812)에 복수의 캐시 데이터 블록(즉, 캐시 라인)과 이들 각각의 태그를 둘 수 있다. 예를 들면 캐시 데이터 블록은 128 바이트 캐시 데이터 블록일 수 있다. 이에 따라 L1D 캐시(1811)와 공유 메모리(1812)로 구성된 온칩 메모리 유닛(1810)의 변경을 최소화할 수 있다. 이를 위해, 도 19에 도시한 것처럼, 공유 메모리(1812)에 포함된 복수의 공유 메모리 뱅크(예를 들면 32개의 공유 메모리 뱅크)를 두 개 이상의 뱅크 그룹으로 분할한다. 한 실시예에서, 분할된 뱅크 그룹의 개수는 두 개일 수 있다. 그리고 하나의 뱅크 그룹 내에서 복수의 뱅크(예를 들면 16개의 뱅크)에 대해서 캐시 데이터 블록을 행 방향으로 스트라이프한다. 전형적인 병렬 프로세싱 유닛에서 각 공유 메모리 뱅크는 64 비트 액세스를 허용하므로, 캐시 데이터 블록, 예를 들면 128 바이트 캐시 데이터 블록은 병렬로 액세스될 수 있다.
하나의 태그와 그 WID는 제한된 비트, 예를 들면 태그가 25 비트를 사용하고 워프 번호(WID)가 6 비트를 사용하는 경우 31 비트를 요구하므로, 제한된 공유 메모리 공간으로 공유 메모리(1812)의 캐시 라인을 위한 태그를 제공할 수 있다. 예를 들면, 공유 메모리 뱅크는 64 비트 액세스를 허용하고 태그와 WID가 31 비트를 사용하는 경우, 두 개의 태그가 각 공유 메모리 뱅크에 형성될 수 있다. 한 실시예에서 두 개의 태그가 놓이는 뱅크는 대응하는 데이터 블록(예를 들면 128 바이트 데이터 블록)를 저장하는 뱅크와 다른 뱅크일 수 있다. 즉, 태그가 놓인 뱅크가 속한 뱅크 그룹은 대응하는 데이터 블록을 저장하는 뱅크들이 속한 뱅크 그룹과 다른 뱅크 그룹일 수 있다. 이와 같이 태그와 대응하는 데이터 블록을 서로 다른 뱅크 그룹에 두어서 뱅크 충돌을 피할 수 있으며, 이에 따라 태그와 데이터 블록의 병렬 액세스를 가능하게 할 수 있다. 또한 사용하지 않는 공유 메모리 공간을 직접 매핑된 캐시(direct mapped cache)로 사용해서, 데이터 블록과 대응하는 태그의 쌍이 단일 공유 메모리 액세스로 액세스될 수 있다.
한편, 공유 메모리(1812)의 사용하지 않는 공간은 커널의 구현에 따라 변할 수 있다. 또한 각 CTA가 서로 다른 양의 공유 메모리(1812)를 요구함에 따라, 공유 메모리(1812)의 사용이 커널의 실행에 따라 변할 수 있다. 멀티프로세서는 공유 메모리 공간을 관리하기 위해서 공유 메모리 관리 테이블(shared memory management table, SMMT)(도시하지 않음)을 보유할 수 있다. SMMT는 복수의 엔트리를 포함하며, 각 엔트리는 CTA에 대응할 수 있다. 각 CTA는 하나의 SMMT 엔트리를 예약하고 있으며, 엔트리는 주어진 CTA가 사용하는 공유 메모리 공간의 시작 어드레스와 크기를 기록하고 있다. 어떤 실시예에서, SMMT의 각 엔트리는 워프의 쓰레드 또는 워프 그룹의 쓰레드에 대응할 수 있다.
멀티프로세서는 CTA가 론치될 때, 대응하는 SMMT 엔트리를 체크하여서 CTA가 사용하지 않는 공유 메모리의 양을 판단할 수 있다. 그러면 멀티프로세서는 캐시 라인과 태그를 저장하기 위한 공간을 확보하기 위해서 사용하지 않는 공유 메모리의 시작 어드레스와 크기를 SMMT의 새로운 엔트리에 넣을 수 있다.
도 19에 도시한 것처럼, 멀티프로세서는 하드웨어 어드레스 번역 유닛(1910)을 공유 메모리(1812) 앞에 두어서 공유 메모리(1812)에서 타깃 캐시 라인과 그 태그가 어디에 존재하는지를 판단할 수 있다.
도 19를 참고하면, 어드레스 번역 유닛(1910)은 글로벌 메모리 어드레스를 공유 메모리 어드레스로 번역한다. 글로벌 메모리 어드레스는 LSB에서 MSB 순으로 태그(T), 블록 인덱스(L) 및 바이트 옵셋(F)으로 분할(decompose)될 수 있다. 예를 들면, 글로벌 메모리 어드레스는 16 비트의 태그(T), 9 비트의 블록 인덱스(L) 및 7 비트의 바이트 옵셋(F)으로 분할될 수 있다. 공유 메모리 어드레스는 타깃 캐시 데이터 블록을 지시하는 캐시 블록 어드레스와 타깃 태그를 지시하는 태그 어드레스를 포함할 수 있다. 캐시 블록 어드레스는 네 개의 필드를 포함하며, 네 필드는 LSB에서 MSB 순으로 바이트 옵셋(F), 뱅크 인덱스(B), 뱅크 그룹 인덱스(G) 및 행 인덱스(R)에 해당할 수 있다. 예를 들면, 공유 메모리(1812)가 뱅크당 8 바이트 행, 뱅크 그룹당 16개의 뱅크, 두 개의 뱅크 그룹 및 256개의 행을 사용하는 경우, 바이트 옵셋(F), 뱅크 인덱스(B), 뱅크 그룹 인덱스(G) 및 행 인덱스(R)는 각각 3, 4, 1 및 8 비트일 수 있다.
어떤 실시예에서, 글로벌 메모리 어드레스를 캐시 블록 어드레스로 번역한 후에 남은 비트(예를 들면 태그(T)의 16 비트)는 타깃 캐시 데이터 블록의 태그의 일부로 사용될 수 있다. 요구되는 캐시 데이터 블록의 수가 행의 수보다 많으므로, 공유 메모리(1812)의 태그는 워프 번호(WID)와 캐시 블록 인덱스를 포함할 수 있다. 워프 번호(WID)와 캐시 블록 인덱스는 예를 들면 각각 6 비트와 9 비트일 수 있다.
어드레스 번역 유닛(1910)은 N 비트 마스크를 사용해서 글로벌 메모리 어드레스의 블록 인덱스(L)를 공유 메모리(1812)에서의 행의 위치를 지시하는 행 인덱스(R)로 변환할 수 있다. 예를 들면, 공유 메모리(1812)가 256개의 행을 가지는 경우, 어드레스 번역 유닛(1910)은 8 비트 마스크를 사용할 수 있다. 어떤 실시예에서, 어드레스 번역 유닛(1910)은 글로벌 메모리 어드레스의 블록 인덱스(L)의 상위 N 비트와 N 비트 마스크를 연산해서 행 인덱스(R)를 생성할 수 있다. 한 실시예에서, 어드레스 번역 유닛(1910)은 글로벌 메모리 어드레스의 블록 인덱스(L)의 상위 N 비트와 N 비트 마스크의 배타적 논리합(XOR)으로 행 인덱스(R)를 생성할 수 있다. 어드레스 번역 유닛(1910)은 글로벌 메모리 어드레스의 블록 인덱스(L)의 하위 M 비트를 공유 메모리(1812)에서의 뱅크 그룹을 지시하는 뱅크 인덱스(B)로 변환할 수 있다. 예를 들면, 9 비트의 블록 인덱스(L)에서 하위 8 비트가 행 인덱스(R)로 변환되고, 공유 메모리(1812)의 뱅크 그룹이 두 개인 경우, 블록 인덱스(L)의 LSB가 뱅크 인덱스(B)로 사용될 수 있다.
어드레스 번역 유닛(1910)은 글로벌 메모리 어드레스의 바이트 옵셋(F)의 일부 비트를 공유 메모리(1812)의 뱅크를 지시하는 뱅크 인덱스(B)로, 바이트 옵셋(F)의 나머지 일부 비트를 캐시 블록 어드레스의 바이트 옵셋(F)으로 변환할 수 있다. 어떤 실시예에서, 글로벌 메모리 어드레스의 바이트 옵셋(F)의 일부 비트를 뱅크 인덱스(B)로 되고, 바이트 옵셋(F)의 나머지 일부 비트를 캐시 블록 어드레스의 바이트 옵셋(F)으로 될 수 있다. 한 실시예에서, 글로벌 메모리 어드레스의 바이트 옵셋(F)의 상위 L 비트를 뱅크 인덱스(B)로 되고, 바이트 옵셋(F)의 하위 K 비트를 캐시 블록 어드레스의 바이트 옵셋(F)으로 될 수 있다. 예를 들면, 공유 메모리(1812)가 16개의 뱅크를 가지는 경우, 글로벌 메모리 어드레스의 7 비트 바이트 옵셋(F)의 상위 4 비트가 뱅크 인덱스(B)가 되고, 바이트 옵셋(F)의 하위 3 비트가 캐시 블록 어드레스의 바이트 옵셋(F)이 될 수 있다.
태그 어드레스는 네 개의 필드를 포함하며, 네 필드는 LSB에서 MSB 순으로 바이트 옵셋(F), 뱅크 인덱스(B), 뱅크 그룹 인덱스(/G) 및 행 인덱스(R)에 해당할 수 있다. 예를 들면, 뱅크마다 물리적인 행이 두 개의 태그를 저장하여서 뱅크 그룹의 하나의 행이 32개의 태그를 보유하는 경우, 태그의 실제 위치는 5 비트, 즉 1 비트의 바이트 옵셋(F)과 4 비트의 뱅크 인덱스(B)에 의해 지시될 수 있다. 이를 위해서 어드레스 번역 유닛(1910)은 캐시 블록 어드레스의 행 인덱스(R)의 하위 P 비트를 태그 어드레스의 바이트 옵셋(F)으로, 행 인덱스(R)의 나머지 하위 Q 비트를 태그 어드레스의 뱅크 인덱스(B)로 번역할 수 있다. 어떤 실시예에서, 캐시 블록 어드레스의 행 인덱스(R)의 하위 P 비트가 바이트 옵셋(F)으로 되고, 바이트 옵셋(F)의 나머지 일부 비트를 캐시 블록 어드레스의 바이트 옵셋(F)으로 될 수 있다. 앞서 설명한 예에서, 캐시 블록 어드레스의 행 인덱스(R)의 LSB가 태그 어드레스의 바이트 옵셋(F)이 되고, 행 인덱스(R)의 나머지 하위 4 비트가 태그 어드레스의 뱅크 인덱스(B)로 될 수 있다.
또한 어드레스 번역 유닛(1910)은 태그의 행 인덱스(R)를 지시하기 위해서, 캐시 블록 어드레스의 행 인덱스(R)의 나머지 비트를 태그 어드레스의 행 인덱스(R)로 번역할 수 있다. 어떤 실시예에서, 캐시 블록 어드레스의 행 인덱스(R)의 나머지 비트가 태그 어드레스의 행 인덱스(R)로 될 수 있다. 앞서 설명한 예에서, 캐시 블록 어드레스의 행 인덱스(R)의 상위 3 비트가 태그 어드레스의 행 인덱스(R)로 될 수 있다. 어드레스 번역 유닛(1910)은 캐시 블록 어드레스의 뱅크 그룹 인덱스(G)를 태그 어드레스의 뱅크 그룹 인덱스(/G)로 번역한다. 어떤 실시예에서, 캐시 데이터 블록과 대응하는 태그에 병렬로 액세스하기 위해서, 캐시 블록 어드레스의 뱅크 그룹 인덱스(G)가 플립(flip)되어 태그 어드레스의 뱅크 그룹 인덱스(/G)가 될 수 있다.
어떤 실시예에서, 어드레스 번역 유닛(1910)은 캐시 블록과 태그에 대한 인덱스의 시작 위치를 캐시 옵셋 레지스터와 태그 옵셋 레지스터를 고려해서 재정렬할 수 있다. 캐시 옵셋 레지스터와 태그 옵셋 레지스터는 사용하지 않는 공유 메모리 공간에서 캐시의 변하는 크기를 포착하는데 사용될 수 있다.
다음 본 발명의 한 실시예에 따른 병렬 프로세싱 유닛에서의 워프 스케줄링 방법을 구현하는 알고리즘의 한 예에 대해서 설명한다.
알고리즘 1에서 i는 스케줄링될 워프의 워프 번호를 지시하며, 예를 들면 getWarpToBeScheduled() 함수를 통해서 획득될 수 있다. InstNo는 실행된 명령어의 총 개수이며, 예를 들면 getNumInstructions() 함수를 통해 획득될 수 있다. ActiveWarpNo는 멀티프로세서 상에서 동작하는 액티브 워프의 개수를 지시하며, 예를 들면 getNumActiveWarp() 함수를 통해 획득될 수 있다.
워프 i(Warp(i))에 대해서, 액티브 플래그(V)가 '0'이고 낮은 컷오프 시기가 종료되었으면, 워프 i를 스톨 상태에서 재활성화할지가 결정된다. 이를 위해서 워프 i의 스톨을 일으킨 워프 k(Warp(k))의 워프 번호(k)가 워프 i에 해당하는 페어 리스트 엔트리의 제2 필드(Pair_List[i][1])로부터 획득된다. 이 경우, 워프 k의 캐시 간섭의 레벨(ISRk)이 낮은 컷오프보다 높고 워프 k(Warp(k))가 계속 실행될 것을 필요로 하면, 워프 i의 스톨 상태는 계속 유지된다. 그렇지 않으면, 워프 i가 재활성화된다. 이에 따라, 워프 i의 액티브 플래그가 '1'로 설정되고, 페어 리스트 엔트리의 제2 필드(Pair_List[i][1])가 클리어된다(예를 들면, '-1'로 설정된다).
워프 i에 대해서, 격리 플래그(I)가 '1'이고 낮은 컷오프 시기가 종료되었으면, 워프 i를 격리 상태를 철회할지가 결정된다. 이를 위해서 워프 i의 파티션을 일으킨 워프 k(Warp(k))의 워프 번호(k)가 워프 i에 해당하는 페어 리스트 엔트리의 제1 필드(Pair_List[i][0])로부터 획득된다. 이 경우, 워프 k의 캐시 간섭의 레벨(ISRk)이 낮은 컷오프보다 높고 워프 k가 계속 실행될 것을 필요로 하면, 워프 i의 격리 상태는 계속 유지된다. 그렇지 않으면, 워프 i의 격리가 철회된다. 이에 따라, 워프 i의 격리 플래그가 '0'으로 설정되고, 페어 리스트 엔트리의 제1 필드(Pair_List[i][0])가 클리어된다(예를 들면, '-1'로 설정된다).
워프 i에 대해서, 액티브 플래그(V)가 '1'이고 높은 컷오프 시기가 종료되었으면, 액티브 상태의 워프 i에 간섭을 일으키는 워프 j를 파티션할지가 결정된다. 이를 위해서 워프 i에 간섭을 일으키는 워프 j의 워프 번호(j)가 워프 i에 해당하는 간섭 리스트 엔트리(Interference_List[i])로부터 획득된다. 워프 i의 캐시 간섭의 레벨(ISRi)가 높은 컷오프보다 높고 워프 j가 워프 i와 다른 워프인 경우, 워프 j가 격리 상태이면(즉, 워프 j의 격리 플래그(I)가 '1'이면), 워프 j가 스톨된다. 즉, 워프 j의 액티브 플래그(V)가 '0'으로 설정되고, 워프 j에 해당하는 페어 리스트 엔트리의 제2 필드(Pair_List[j][1])가 i로 설정된다. 그렇지 않고, 워프 j가 액티브 상태이면(즉, 워프 j의 격리 플래그(I)가 '0'이면), 워프 j가 격리된다. 즉, 워프 j의 격리 플래그(I)가 '1'로 설정되고, 워프 j에 해당하는 페어 리스트 엔트리의 제1 필드(Pair_List[j][0])가 i로 설정된다.
[알고리즘 1]
1 i := getWarpToBeScheduled()
2 InstNo := getNumInstructions()
3 ActiveWarpNo := getNumActiveWarp()
4 if Warp(i).V == 0 and end of low cut-off epoch then
/* Warp(i) is deactivated */
5 k := Pair_List[i][1]
6 IRSk := VTAHit[k]/(InstNo/ActiveWarpNo)
7 if IRSk > low-cutoff and Warp(k) needs executing then
8 continue
9 else
10 Warp(i).V := 1
11 Pair_List[i][1] := -1 // cleared
12 else if Warp(i).I == 1 and end of low cut-off epoch then
/* Warp(i) redirects to access shared memory */
13 k := Pair_List[i][0]
14 IRSk := VTAHit[k]/(InstNo/ActiveWarpNo)
15 if IRSk > low-cutoff and Warp(k) needs executing then
16 continue
17 else
18 Warp(i).I := 0
19 Pair_List[i][0] := -1 // cleared
20 if Warp(i).V == 1 and end of high cut-off epoch then
/* Warp(i) is active */
21 IRSi := VTAHit[i]/(InstNo/ActiveWarpNo)
22 j := Interference_List[i]
23 if IRSi > high-cutoff and j != i then
24 if Warp(j).I == 1 then
25 Warp(j).V := 0
26 Pair_List[j][1] := i
27 else if Warp(j).I == 0 then
28 Warp(j).I := 1
29 Pair_List[j][0] := i
한편, 본 발명의 한 실시예에 따른 병렬 프로세싱 유닛을 실제 하드웨어에 구현하여서 성능을 측정한 결과에 대해서 설명한다.
아래 표 1에 나타낸 것처럼, 성능 측정에서 15개의 멀티프로세서(Streaming multiprocessors, SM)를 포함하는 병렬 프로세싱 유닛이 사용된다. 또한 SM당 최대 1536개의 쓰레드가 생성되고, 2개의 워프 스케줄러가 사용된다. 또한 L1D 캐시로 128 바이트 캐시 라인을 가지고 4-웨이(way)를 지원하는 16KB의 캐시 또는 128 바이트 캐시 라인을 가지고 6-웨이(way)를 지원하는 48KB의 캐시가 사용된다.
# of SMs 15
# of threads Max 1536 per SM
# of war schedulers 2 per SM
L1D cache 16KB w/ 128B lines, and 4 ways48KB w/ 128B lines, and 6 ways
L1D policy Write no-allocate, local write-back, global write-through, and pseudo LRU
L2 cache 768KB w/ 128B lines, and 8 ways
L2 policy Allocate on miss, write-back, and pseudo LRU
DRAM GDDR5 w/ 16 banks, tCL=12, tRCD-12, and tRAS=28
Victim Tag Array 8 tags per set, 48 sets, and FIFO
이 경우, 워프 파티셔닝만을 사용하는 워프 스케줄링 방법은 기존의 워프 스케줄링에 비해서 32%만큼 성능을 향상시킬 수 있었다. 또한 워프 파티셔닝과 워프 스로틀링을 사용하는 워프 스케줄링 방법은 기존의 워프 스케줄링에 비해서 54%만큼 성능을 향상시킬 수 있었다.
이상에서 본 발명의 실시예에 대하여 상세하게 설명하였지만 본 발명의 권리범위는 이에 한정되는 것은 아니고 다음의 청구범위에서 정의하고 있는 본 발명의 기본 개념을 이용한 당업자의 여러 변형 및 개량 형태 또한 본 발명의 권리범위에 속하는 것이다.

Claims (20)

  1. 멀티프로세서를 포함하며,
    상기 멀티프로세서는,
    L1D(level 1 data) 캐시 및 복수의 캐시 라인이 할당되는 공유 메모리를 포함하는 메모리 유닛, 그리고
    액티브 상태의 제1 쓰레드 그룹에 대해서 소정의 제1 조건을 만족하는 경우에, 제2 쓰레드 그룹의 캐시 액세스를 상기 공유 메모리로 변경하여 상기 제2 쓰레드 그룹을 격리하는 쓰레드 그룹 스케줄러
    를 포함하는 병렬 프로세싱 유닛.
  2. 제1항에서,
    상기 제1 조건은 상기 제1 쓰레드 그룹에 대한 캐시 간섭의 레벨이 제1 컷오프를 넘는 조건을 포함하는 병렬 프로세싱 유닛.
  3. 제2항에서,
    상기 제2 쓰레드 그룹은 상기 제1 쓰레드 그룹에 간섭을 일으키는 쓰레드 그룹 중에서 가장 자주 간섭을 일으키는 쓰레드 그룹을 포함하는 병렬 프로세싱 유닛.
  4. 제2항에서,
    소정의 제2 조건을 만족하는 경우에, 상기 쓰레드 그룹 스케줄러는 상기 제2 쓰레드 그룹의 캐시 액세스를 상기 L1D 캐시로 다시 변경하는, 병렬 프로세싱 유닛.
  5. 제4항에서,
    상기 제2 조건은 상기 제1 쓰레드 그룹에 대한 캐시 간섭의 레벨이 상기 제1 컷오프보다 낮은 제2 컷오프보나 낮은 조건을 포함하는 병렬 프로세싱 유닛.
  6. 제4항에서,
    상기 제2 조건은 상기 제1 쓰레드 그룹의 실행이 완료되는 조건을 포함하는 병렬 프로세싱 유닛.
  7. 제4항에서,
    제1 시기와 제2 시기로 이루어지는 사이클에서, 상기 쓰레드 그룹 스케줄러는 제1 시기의 종료 시에 상기 제1 조건을 판단하고, 상기 제2 시기의 종료 시에 상기 제2 조건을 판단하는, 병렬 프로세싱 유닛.
  8. 제1항에서,
    소정의 제2 조건을 만족하는 경우에, 상기 쓰레드 그룹 스케줄러는 상기 격리된 제2 쓰레드 그룹을 스톨(stall)하는, 병렬 프로세싱 유닛.
  9. 제8항에서,
    상기 제2 조건은 상기 공유 메모리로 격리된 제3 쓰레드 그룹에 대한 캐시 간섭의 레벨이 제1 컷오프를 넘는 조건을 포함하는 병렬 프로세싱 유닛.
  10. 제9항에서,
    소정의 제3 조건을 만족하는 경우에, 상기 쓰레드 그룹 스케줄러는 상기 스톨된 제2 쓰레드 그룹을 재활성화하는, 병렬 프로세싱 유닛.
  11. 제10항에서,
    상기 제3 조건은 상기 제3 쓰레드 그룹에 대한 캐시 간섭의 레벨이 상기 제1 컷오프보다 낮은 제2 컷오프보나 낮은 조건을 포함하는 병렬 프로세싱 유닛.
  12. 제10항에서,
    상기 제2 조건은 상기 제3 쓰레드 그룹의 실행이 완료되는 조건을 포함하는 병렬 프로세싱 유닛.
  13. 제10항에서,
    제1 시기와 제2 시기로 이루어지는 사이클에서, 상기 쓰레드 그룹 스케줄러는 제1 시기의 종료 시에 상기 제2 조건을 판단하고, 상기 제2 시기의 종료 시에 상기 제3 조건을 판단하는, 병렬 프로세싱 유닛.
  14. 제1항에 따른 병렬 프로세싱 유닛,
    중앙 프로세싱 유닛(central processing unit, CPU),
    시스템 메모리, 그리고
    상기 병렬 프로세싱 유닛, 상기 CPU 및 상기 시스템 메모리를 연결하는 메모리 브릿지
    를 포함하는 컴퓨팅 디바이스.
  15. 멀티프로세서를 포함하며,
    상기 멀티프로세서는,
    L1D(level 1 data) 캐시 및 공유 메모리를 포함하는 메모리 유닛, 그리고
    쓰레드 그룹 스케줄러를 포함하고,
    상기 공유 메모리는, 복수의 행을 가진 복수의 공유 메모리 뱅크를 포함하며,
    상기 복수의 공유 메모리 뱅크는 복수의 뱅크 그룹으로 그룹화되고,
    각 뱅크 그룹에 속한 복수의 공유 메모리 뱅크에 대해서 복수의 캐시 라인이 할당되어 있으며,
    상기 쓰레드 그룹 스케줄러는 일부 쓰레드 그룹의 캐시 접근을 상기 공유 메모리의 캐시 라인으로 변경하는
    병렬 프로세싱 유닛.
  16. 제16항에서,
    어떤 캐시 라인이 할당되는 뱅크 그룹과 다른 뱅크 그룹에 상기 어떤 캐시 라인을 위한 태그와 대응하는 쓰레드 그룹의 번호가 할당되는, 병렬 프로세싱 유닛.
  17. L1D(level 1 data) 캐시와 공유 메모리를 포함하는 메모리 유닛을 포함하는 병렬 프로세싱 유닛의 쓰레드 그룹 스케줄링 방법으로서,
    제1 쓰레드 그룹에 대해서 캐시 간섭의 레벨을 검출하는 단계, 그리고
    상기 캐시 간섭의 레벨이 제1 컷오프를 넘는 경우, 상기 제1 쓰레드 그룹에 간섭을 일으키는 쓰레드 그룹 중 소정의 조건을 만족하는 제2 쓰레드 그룹의 캐시 액세스를 상기 공유 메모리로 변경하여 상기 제2 쓰레드 그룹을 격리하는 단계
    를 포함하는 쓰레드 그룹 스케줄링 방법.
  18. 제17항에서,
    상기 제1 쓰레드 그룹에 대해서 캐시 간섭의 레벨을 다시 검출하는 단계, 그리고
    상기 다시 검출한 캐시 간섭의 레벨이 상기 제1 컷오프보다 낮은 제2 컷오프보다 낮은 경우, 상기 제2 쓰레드 그룹의 캐시 액세스를 상기 L1D 캐시로 다시 변경하는 단계를 더 포함하는 쓰레드 그룹 스케줄링 방법.
  19. 제17항에서,
    상기 공유 메모리로 격리된 제3 쓰레드 그룹에 대해서 캐시 간섭의 레벨을 검출하는 단계, 그리고
    상기 제3 쓰레드 그룹에 대한 상기 캐시 간섭의 레벨이 제2 컷오프를 넘는 경우, 상기 격리된 제2 쓰레드 그룹을 스톨(stall)하는 단계
    를 더 포함하는 쓰레드 그룹 스케줄링 방법.
  20. 제19항에서,
    상기 제3 쓰레드 그룹에 대해서 캐시 간섭의 레벨을 다시 검출하는 단계, 그리고
    상기 제3 쓰레드 그룹에 대해서 상기 다시 검출한 캐시 간섭의 레벨이 상기 제2 컷오프보나 낮은 제3 컷오프보다 낮은 경우, 상기 스톨한 제2 쓰레드 그룹을 재활성화하는 단계
    를 더 포함하는 쓰레드 그룹 스케줄링 방법.
PCT/KR2016/011719 2016-07-26 2016-10-19 병렬 프로세싱 유닛 및 이를 포함하는 컴퓨팅 디바이스, 그리고 쓰레드 그룹 스케줄링 방법 WO2018021620A1 (ko)

Applications Claiming Priority (4)

Application Number Priority Date Filing Date Title
US201662366672P 2016-07-26 2016-07-26
US62/366,672 2016-07-26
KR10-2016-0119514 2016-09-19
KR1020160119514A KR20180012167A (ko) 2016-07-26 2016-09-19 병렬 프로세싱 유닛 및 이를 포함하는 컴퓨팅 디바이스, 그리고 쓰레드 그룹 스케줄링 방법

Publications (1)

Publication Number Publication Date
WO2018021620A1 true WO2018021620A1 (ko) 2018-02-01

Family

ID=61016746

Family Applications (1)

Application Number Title Priority Date Filing Date
PCT/KR2016/011719 WO2018021620A1 (ko) 2016-07-26 2016-10-19 병렬 프로세싱 유닛 및 이를 포함하는 컴퓨팅 디바이스, 그리고 쓰레드 그룹 스케줄링 방법

Country Status (1)

Country Link
WO (1) WO2018021620A1 (ko)

Cited By (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN113176911A (zh) * 2021-04-29 2021-07-27 上海阵量智能科技有限公司 一种配置方法、数据处理方法、芯片和电子设备

Citations (5)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20020138717A1 (en) * 1999-05-11 2002-09-26 Joy William N. Multiple-thread processor with single-thread interface shared among threads
US20040162951A1 (en) * 2003-02-13 2004-08-19 Jacobson Quinn A. Method and apparatus for delaying interfering accesses from other threads during transactional program execution
US20080195849A1 (en) * 2007-02-14 2008-08-14 Antonio Gonzalez Cache sharing based thread control
US20110225372A1 (en) * 2009-04-27 2011-09-15 Lsi Corporation Concurrent, coherent cache access for multiple threads in a multi-core, multi-thread network processor
US20110246995A1 (en) * 2010-04-05 2011-10-06 Oracle International Corporation Cache-aware thread scheduling in multi-threaded systems

Patent Citations (5)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20020138717A1 (en) * 1999-05-11 2002-09-26 Joy William N. Multiple-thread processor with single-thread interface shared among threads
US20040162951A1 (en) * 2003-02-13 2004-08-19 Jacobson Quinn A. Method and apparatus for delaying interfering accesses from other threads during transactional program execution
US20080195849A1 (en) * 2007-02-14 2008-08-14 Antonio Gonzalez Cache sharing based thread control
US20110225372A1 (en) * 2009-04-27 2011-09-15 Lsi Corporation Concurrent, coherent cache access for multiple threads in a multi-core, multi-thread network processor
US20110246995A1 (en) * 2010-04-05 2011-10-06 Oracle International Corporation Cache-aware thread scheduling in multi-threaded systems

Cited By (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN113176911A (zh) * 2021-04-29 2021-07-27 上海阵量智能科技有限公司 一种配置方法、数据处理方法、芯片和电子设备

Similar Documents

Publication Publication Date Title
US10725992B2 (en) Indexing entries of a storage structure shared between multiple threads
WO2017196132A1 (en) Cache self-clean engine
US9141553B2 (en) High-performance cache system and method
US6470437B1 (en) Updating and invalidating store data and removing stale cache lines in a prevalidated tag cache design
US6496902B1 (en) Vector and scalar data cache for a vector multiprocessor
US10296465B2 (en) Processor using a level 3 translation lookaside buffer implemented in off-chip or die-stacked dynamic random-access memory
US6438671B1 (en) Generating partition corresponding real address in partitioned mode supporting system
US10007614B2 (en) Method and apparatus for determining metric for selective caching
US20110185125A1 (en) Resource sharing to reduce implementation costs in a multicore processor
JPH04232551A (ja) 多重仮想アドレス変換方法及び装置
EP1202180A1 (en) Scalar data cache for a vector processor
WO2014185652A1 (ko) 쓰기 트래픽이 적은 캐시 메모리 블록 교체 방법 및 이를 이용한 캐시 서브시스템을 가지는 정보 처리 장치
WO2014000624A1 (en) High-performance instruction cache system and method
JP2001195303A (ja) 機能が並列に分散された変換索引バッファ
WO2013071868A1 (en) Low-miss-rate and low-miss-penalty cache system and method
US8271732B2 (en) System and method to reduce power consumption by partially disabling cache memory
WO2018021620A1 (ko) 병렬 프로세싱 유닛 및 이를 포함하는 컴퓨팅 디바이스, 그리고 쓰레드 그룹 스케줄링 방법
Hameed et al. Adaptive cache management for a combined SRAM and DRAM cache hierarchy for multi-cores
WO2014000626A1 (en) High-performance data cache system and method
WO2017073957A1 (ko) 전자 장치 및 이의 메모리 관리 방법
WO2015024532A9 (zh) 高性能指令缓存系统和方法
KR20230119669A (ko) 패킷 메타데이터를 사용한 데이터 배치
US20090157968A1 (en) Cache Memory with Extended Set-associativity of Partner Sets
US10649786B2 (en) Reduced stack usage in a multithreaded processor
KR20180012167A (ko) 병렬 프로세싱 유닛 및 이를 포함하는 컴퓨팅 디바이스, 그리고 쓰레드 그룹 스케줄링 방법

Legal Events

Date Code Title Description
121 Ep: the epo has been informed by wipo that ep was designated in this application

Ref document number: 16910641

Country of ref document: EP

Kind code of ref document: A1

NENP Non-entry into the national phase

Ref country code: DE

32PN Ep: public notification in the ep bulletin as address of the adressee cannot be established

Free format text: NOTING OF LOSS OF RIGHTS PURSUANT TO RULE 112(1) EPC (EPO FORM 1205A DATED 31.05.2019)

122 Ep: pct application non-entry in european phase

Ref document number: 16910641

Country of ref document: EP

Kind code of ref document: A1