Managing microarchitectural resource allocation in simultaneous multithreading core

A resource-biasing mechanism in SMT cores addresses thread monopolization by detecting or predicting memory access stalls and applying watermarks to limit resource allocation, enhancing SMT core performance by preventing resource domination and maintaining parallelism.

WO2026232366A1PCT designated stage Publication Date: 2026-11-12HUAWEI TECH CO LTD
View PDF 0 Cites 0 Cited by

Patent Information

Application Number
PCT/CN2025/093330
Authority / Receiving Office
WO · WO
Patent Type
Applications
Current Assignee / Owner
Filing Date
2025-05-08
Publication Date
2026-11-12

AI Technical Summary

Technical Problem

In simultaneous multithreading (SMT) processor cores, one thread monopolizing shared microarchitectural resources due to long-latency memory access stalls leads to performance degradation for the non-stalled thread, with existing solutions either reacting too slowly or incurring high overhead.

Method used

Implementing a per-stall resource-biasing mechanism that detects or predicts memory access stalls, marks load entries in the load-store queue, and applies watermarks to limit resource allocation for the stalled thread, preventing resource domination by inhibiting further allocations when the threshold is exceeded.

Benefits of technology

Improves overall SMT core performance by preventing resource monopolization, allowing the sibling thread to continue issuing instructions with minimal overhead, thus enhancing aggregate performance.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN2025093330_12112026_PF_FP_ABST
    Figure CN2025093330_12112026_PF_FP_ABST
Patent Text Reader

Abstract

A method for managing microarchitectural resource allocation in a simultaneous multithreading (SMT) core, the method comprising: detecting, via a long-latency memory access detection module, or predicting, via a long-latency memory access prediction module, a stall in the SMT core caused by a memory access request (101), marking a load entry corresponding to the memory access request that caused the stall in a load–store queue associated with a thread experiencing the stall (102), configuring at least one watermark for a microarchitectural resource of the SMT core, wherein the watermark specifies a preset capacity limit representing a maximum number of microarchitectural resource entries that may be allocated to the thread experiencing the stall (103), inhibiting any additional allocation of microarchitectural resource entries to the thread experiencing the stall when the allocated entries exceed the preset capacity limit, and re‐allowing allocation once the number of allocated entries falls below the preset capacity limit (104).
Need to check novelty before this filing date? Find Prior Art

Description

MANAGING MICROARCHITECTURAL RESOURCE ALLOCATION IN SIMULTANEOUS MULTITHREADING CORETECHNICAL FIELD

[0001] The present disclosure relates to resource management in simultaneous multithreading (SMT) processor cores. Aspects of the disclosure relate to detection of long-latency memory access stalls and biasing of microarchitectural resource allocation to prevent resource domination by one thread.BACKGROUND

[0002] Simultaneous multithreading (SMT) enables two or more threads to share the functional units and buffers of a single processor core, thereby improving overall resource utilisation and throughput. In modern commercial processors -such as those found in smartphones, workstations and servers -each SMT core typically supports two threads that issue instructions to shared microarchitectural structures, including issue queues, reservation stations and load–store queues.

[0003] A challenge arises when one thread incurs a long-latency memory access (for example, following a miss in the last-level cache) . While awaiting data from off-chip memory, that thread may continue to occupy entries in shared structures, effectively starving the sibling thread of resources needed to make progress. Over time, such resource domination can lead to significant performance degradation for the non-stalled thread, reducing the net performance gain of SMT.

[0004] Prior approaches to this problem fall into two main categories. One class of solutions monitors performance at a coarse granularity, tracking thread execution over extended intervals and adjusting scheduling priorities to meet broad quality-of-service goals. Such techniques may overlook individual long stalls and react too slowly to prevent transient resource imbalances. Another class of solutions addresses resource domination by flushing instructions from the pipeline, but this incurs a high performance overhead akin to the cost of flushing on branch misprediction.SUMMARY

[0005] An objective of the present disclosure is to mechanism to detect when a thread is stalled on memory, and to prevent that thread from monopolising shared microarchitectural resources during the stall, thereby improving overall SMT core performance.

[0006] The foregoing and other objectives are achieved by the features of the independent claims.

[0007] Further implementation forms are apparent from the dependent claims, the description and the figures.

[0008] A first aspect of the present disclosure provides a method for managing microarchitectural resource allocation in a simultaneous multithreading (SMT) core, the method comprising detecting, via a long-latency memory access detection module, or predicting, via a long-latency memory access prediction module, a stall in the SMT core caused by a memory access request, marking a load entry corresponding to the memory access request that caused the stall in a load–store queue associated with a thread experiencing the stall, and configuring at least one watermark for a microarchitectural resource of the SMT core, wherein the watermark specifies a preset capacity limit representing a maximum number of microarchitectural resource entries that may be allocated to the thread experiencing the stall, wherein the method further comprises inhibiting any additional allocation of microarchitectural resource entries to the thread experiencing the stall when the allocated entries exceed the preset capacity limit, and re‐allowing allocation once the number of allocated entries falls below the preset capacity limit.

[0009] The detecting may further comprise receiving a notification from a first cache, wherein the first cache comprises a cache at any level in a cache and memory hierarchy upon a cache miss.

[0010] The predicting may further comprise implementing a predictor at a second cache, wherein the second cache comprises a cache at any level in a cache and memory hierarchy to forecast whether a stall in the SMT core will occur, and generating a notification to the SMT core based on the prediction.

[0011] The method may further comprise recording the detection or prediction event along with an identifier of a load instruction that caused the memory access request.

[0012] Configuring the watermark may comprise dynamically setting the preset capacity limit via a software‐controlled interface.

[0013] Inhibiting additional allocation of microarchitectural resource entries to the thread experiencing the stall when the allocated entries exceed the preset capacity limit may comprise halting issuance of further microarchitectural resource requests from the thread experiencing the stall.

[0014] The method may further comprise monitoring the number of microarchitectural resource entries allocated to the thread experiencing the stall, and automatically re-allowing the allocation based on the monitoring.

[0015] A second aspect of the present disclosure provides a non‐transitory computer‐readable medium storing programme instructions which, when executed by a processor, cause the processor to perform the method described herein.

[0016] A third aspect of the present disclosure provides an apparatus for managing microarchitectural resource allocation in a simultaneous multithreading (SMT) core, the apparatus comprising a detection / prediction module configured to detect, via a long‐latency memory access detection module, or to predict, via a long‐latency memory access prediction module, a stall in the SMT core caused by a memory access request, a marking module configured to mark a load entry corresponding to the memory access request that caused the stall in a load–store queue associated with a thread experiencing the stall, a configuration module configured to set at least one watermark for a microarchitectural resource of the SMT core, the watermark specifying a preset capacity limit representing a maximum number of microarchitectural resource entries that may be allocated to the thread experiencing the stall, and an inhibition module configured to inhibit any additional allocation of microarchitectural resource entries to the thread experiencing the stall when the allocated entries exceed the preset capacity limit, and to re‐allow allocation once the number of allocated entries falls below the preset capacity limit.

[0017] The detection / prediction module may be further configured to receive a notification from a first cache, wherein the first cache comprises a cache at any level in a cache and memory hierarchy upon a cache miss.

[0018] The detection / prediction module may comprise a predictor implemented at a second cache, wherein the second cache comprises a cache at any level in a cache and memory hierarchy, the predictor being configured to forecast whether the stall in the SMT core will occur, and to generate a corresponding notification to the SMT core.

[0019] The apparatus may further comprise a recording module configured to record the detection or prediction event along with an identifier of the load instruction that caused the memory access request.

[0020] The configuration module may be further configured to dynamically adjust the preset capacity limit via a software‐controlled interface.

[0021] The apparatus may further comprise a control unit configured to communicate with the software‐controlled interface to modify the watermark configuration in response to changes in system load.

[0022] The marking module may be further configured to associate the marked load entry with a unique identifier corresponding to the memory access request.

[0023] These and other aspects of the invention will be apparent from the embodiment (s) described below.BRIEF DESCRIPTION OF THE DRAWINGS

[0024] In order that the present invention may be more readily understood, embodiments of the invention will now be described, by way of example, with reference to the accompanying drawings, in which:

[0025] FIG. 1 is a flow chart of a method according to an example;

[0026] FIG. 2 is a schematic representation of an apparatus according to an example; and

[0027] FIG. 3 is a flow chart of a detection and biasing workflow according to an example.DETAILED DESCRIPTION

[0028] Example embodiments are described below in sufficient detail to enable those of ordinary skill in the art to embody and implement the systems and processes herein described. It is important to understand that embodiments can be provided in many alternate forms and should not be construed as limited to the examples set forth herein.

[0029] Accordingly, while embodiments can be modified in various ways and take on various alternative forms, specific embodiments thereof are shown in the drawings and described in detail below as examples. There is no intent to limit to the particular forms disclosed. On the contrary, all modifications, equivalents, and alternatives falling within the scope of the appended claims should be included. Elements of the example embodiments are consistently denoted by the same reference numerals throughout the drawings and detailed description where appropriate.

[0030] The terminology used herein to describe embodiments is not intended to limit the scope. The articles “a, ” “an, ” and “the” are singular in that they have a single referent, however the use of the singular form in the present document should not preclude the presence of more than one referent. In other words, elements referred to in the singular can number one or more, unless the context clearly indicates otherwise. It will be further understood that the terms “comprises, ” “comprising, ” “includes, ” and / or “including, ” when used herein, specify the presence of stated features, items, steps, operations, elements, and / or components, but do not preclude the presence or addition of one or more other features, items, steps, operations, elements, components, and / or groups thereof.

[0031] Unless otherwise defined, all terms (including technical and scientific terms) used herein are to be interpreted as is customary in the art. It will be further understood that terms in common usage should also be interpreted as is customary in the relevant art and not in an idealized or overly formal sense unless expressly so defined herein.

[0032] In modern processor architectures, simultaneous multithreading cores allow two or more hardware threads to share the same execution engine, improving overall throughput and resource utilisation. However, when one thread incurs a long-latency memory access -such as a miss in the last-level cache followed by an off-chip memory fetch -it may continue to occupy entries in shared microarchitectural structures (e.g. issue queues, reservation stations or load–store queues) while awaiting data. This can starve the sibling thread of resources, leading to reduced parallelism and degraded total core performance. Existing solutions typically operate at a coarse granularity, monitoring thread behaviour over long intervals to adjust scheduling priorities or quality-of-service parameters. Although such approaches can rebalance resource use over time, they react too slowly to prevent transient stalls from causing resource domination. Alternatively, some techniques flush in-flight instructions to free resources, but incur high performance penalties akin to those seen on branch misprediction.

[0033] The present invention provides a per-stall resource-biasing mechanism for SMT cores. When a long-latency memory access stall is detected (or predicted at an intermediary cache level) a corresponding load entry is marked in the load–store queue of the stalled thread. One or more watermarks are then applied to the affected microarchitectural resource, each watermark defining the maximum number of entries that the stalled thread may occupy. Should the stalled thread exceed its watermark, further requests to that resource are temporarily inhibited until its usage falls back below the threshold. By operating at the granularity of individual memory stalls, this approach prevents one thread from monopolising shared structures, enabling the sibling thread to continue issuing instructions and improving aggregate performance. Because the mechanism simply limits resource allocation rather than flushing instructions or overhauling thread priorities, it imposes minimal overhead on both the stalled and non-stalled threads.

[0034] Examples in the present disclosure can be provided as methods, systems or machine-readable instructions, such as any combination of software, hardware, firmware or the like. Such machine-readable instructions may be included on a computer readable storage medium (including but not limited to disc storage, CD-ROM, optical storage, etc. ) having computer readable program codes therein or thereon.

[0035] The present disclosure is described with reference to flow charts and / or block diagrams of the method, devices and systems according to examples of the present disclosure. Although the flow diagrams described above show a specific order of execution, the order of execution may differ from that which is depicted. Blocks described in relation to one flow chart may be combined with those of another flow chart. In some examples, some blocks of the flow diagrams may not be necessary and / or additional blocks may be added. It shall be understood that each flow and / or block in the flow charts and / or block diagrams, as well as combinations of the flows and / or diagrams in the flow charts and / or block diagrams can be realized by machine readable instructions.

[0036] The machine-readable instructions may, for example, be executed by a machine such as a general-purpose computer, user equipment such as a smart device, e.g., a smart phone, a special purpose computer, an embedded processor or processors of other programmable data processing devices to realize the functions described in the description and diagrams. In particular, a processor or processing apparatus may execute the machine-readable instructions. Thus, modules of apparatus (for example, a module implementing a comparator unit, or a firewall structure and so on) may be implemented by a processor executing machine readable instructions stored in a memory, or a processor operating in accordance with instructions embedded in logic circuitry. The term 'processor'is to be interpreted broadly to include a CPU, processing unit, ASIC, logic unit, or programmable gate set etc. The methods and modules may all be performed by a single processor or divided amongst several processors.

[0037] Such machine-readable instructions may also be stored in a computer readable storage that can guide the computer or other programmable data processing devices to operate in a specific mode. For example, the instructions may be provided on a non-transitory computer readable storage medium encoded with instructions, executable by a processor.

[0038] FIG. 1 is a flow chart of a method according to an example. The method comprises, in block 101, detecting, via a long-latency memory access detection module, or predicting, via a long-latency memory access prediction module, a stall in the SMT core caused by a memory access request. A “stall” in the SMT core refers to a condition where a thread is prevented from issuing further instructions because its requested data is not yet available (for example, when a load instruction misses in the last-level cache and must fetch data from off-chip memory) , leading to a prolonged wait state.

[0039] Detecting the stall may comprise receiving a notification from a first cache upon a cache miss. Predicting, on the other hand, may be achieved by implementing a predictor at a second cache to forecast whether a stall in the SMT core will occur. The first cache and the second cache may each comprise a cache at any level in the cache and memory hierarchy. The detection and / or the prediction event, along with an identifier of a load instruction that caused the memory access request, may be recorded in memory.

[0040] In block 102, the method comprises marking a load entry corresponding to the memory access request that caused the stall in a load–store queue associated with a thread experiencing the stall. As used herein, the term “load-store queue” refers to a microarchitectural buffer that tracks in-flight load and store operations in program order. A load entry corresponding to the memory access request may refer to the LSQ slot allocated for the stalled load instruction; “marking” that entry may refer to setting a flag or metadata bit in the LSQ so that downstream modules recognise this entry as stalled.

[0041] In block 103, the method comprises configuring at least one watermark for a microarchitectural resource of the SMT core, wherein the watermark specifies a preset capacity limit representing a maximum number of microarchitectural resource entries that may be allocated to the thread experiencing the stall. A “watermark” in this context is a threshold value applied to shared hardware structures (such as issue queues, reservation stations or reorder buffers) defining how many “entries” (i.e., slots for instructions or micro-ops) the stalled thread is permitted to occupy. The watermark may be configured by dynamically setting the preset capacity limit via a software-controlled interface. For example, the interface may comprise model-specific registers (MSRs) or memory-mapped control registers that an operating system or firmware can write to in order to adjust the watermark value at runtime.

[0042] The method comprises, in block 104, inhibiting any additional allocation of microarchitectural resource entries to the thread experiencing the stall when the allocated entries exceed the preset capacity limit, and re‐allowing allocation once the number of allocated entries falls below the preset capacity limit. Allocation of microarchitectural resource entries to the thread refers to granting slots in shared structures (e.g., IQ entries) to that thread’s instructions. To “inhibit” allocation is to prevent any new slots from being assigned, effectively throttling the thread. If such inhibition did not occur, the stalled thread could continue filling the structure, thus starving the sibling thread and degrading overall SMT performance.

[0043] For example, the additional allocation may be inhibited by halting the issuance of further microarchitectural resource requests from the thread experiencing the stall. In practice, this may involve gating the dispatch logic so that no new micro-ops from the stalled thread are sent to the issue queue until its in-flight entries drop below the watermark.

[0044] The method may further comprise monitoring the number of microarchitectural resource entries allocated to the thread experiencing the stall, and automatically re-allowing the allocation based on the monitoring. In other words, the system may continually count how many slots the stalled thread occupies; once that count “drains” under the configured watermark threshold, the inhibition may be lifted and normal dispatch resumes.

[0045] FIG. 2 is a schematic representation of an apparatus according to an example. The apparatus 200 comprises a detection / prediction module 201 configured to detect, via a long‐latency memory access detection module, or to predict, via a long‐latency memory access prediction module, a stall in the SMT core caused by a memory access request. The apparatus 200 also comprises a marking module 202 configured to mark a load entry corresponding to the memory access request that caused the stall in a load–store queue associated with a thread experiencing the stall. The apparatus 200 comprises a configuration module 203 configured to set at least one watermark for a microarchitectural resource of the SMT core, the watermark specifying a preset capacity limit representing a maximum number of microarchitectural resource entries that may be allocated to the thread experiencing the stall. The apparatus 200 further comprises an inhibition module 204 configured to inhibit any additional allocation of microarchitectural resource entries to the thread experiencing the stall when the allocated entries exceed the preset capacity limit, and to re‐allow allocation once the number of allocated entries falls below the preset capacity limit. In other words, the apparatus 200 is configured to perform the method described above in relation to FIG. 1 (and described below in relation to FIG. 3) .

[0046] It will be appreciated that, while the apparatus 200 is illustrated with distinct modules 201–204, each “module” may be realised wholly or in part by any combination of hardware circuitry, programmable logic, or one or more general-purpose processors executing suitable program instructions. Accordingly, the functionality attributed to each module need not be embodied as separate, dedicated physical components, but may be provided by a single device or distributed across multiple devices arranged to perform the described operations.

[0047] To aid understanding of the invention, reference will now be made to FIG. 3, which is a flow chart of a detection and biasing workflow according to an example. In the figure, notifications are denoted using a dashed arrow, whereas requests are denoted using a solid arrow.

[0048] In step 301, the processor front end may dispatch a load instruction on behalf of Thread 0, which enters an issue queue (IQ) . The processor may then issue a memory access request into the cache hierarchy. The detection module may monitor this request as it probes the level 1 data cache (L1D) . At this point, no watermark is yet in effect, and the load entry has not yet been marked in the load-store queue (LSQ) .

[0049] In step 302, upon failing to find the requested cache line in L1 D, the memory access request may be forwarded to the L2 cache. The detection / prediction module may continue to track the request at L2, but still no notification is generated because the request has not yet missed at the last‐level cache.

[0050] In step 303, if the L2 cache lookup also misses, the same request may be propagated to the last‐level cache (LLC) . While, in this example, actual detection of the long‐latency stall is described, it will be appreciated that, at each cache level, the prediction sub-module may also optionally predict a future LLC miss, rather than it being detected; this will be described in more detail further below.

[0051] In steps 304 and 305, when the LLC lookup also misses, the LLC control logic may issue a request to off-chip memory. In parallel, the detection module in the LLC may generate a stall notification indicating that this load will incur a long‐latency memory access. That notification is sent upstream towards the core.

[0052] In step 306, the LLC may forward its stall notification to L2, which in turn may forward it to L1D. The notification may arrives back at the core’s LSQ interface, alerting the detection module that the tagged load entry has now entered a long stall.

[0053] In step 307, upon receiving the notification, the detection module may mark the specific load entry in the LSQ for Thread 0. This marking may identify the “stalled thread” and load instruction that caused the long‐latency memory access. The configuration module may then apply the pre-configured watermark to all subsequent resource‐allocation decisions for this thread.

[0054] In step 308, due to the fact that Thread 0 is now marked as stalled, the resource‐allocation module may consult the watermark for the IQ. If Thread 0 has already allocated more IQ entries than its preset capacity limit, the inhibition module may halt any further dispatch of Thread 0’s instructions into the IQ. Meanwhile, Thread 1 can continue to allocate IQ entries up to its own limit. Once Thread 0’s occupied entries drain below the watermark threshold, the halt may be lifted and normal allocation resumes. Advantageously, this mechanism may prevent Thread 0 from dominating shared microarchitectural resources during its long‐latency memory stall.

[0055] In an alternative embodiment, the apparatus may employ long-latency memory access prediction in place of, or in addition to, actual detection at the last-level cache. After the processor front end dispatches a load instruction for Thread 0 and the corresponding memory access request has missed in the L1 D and L2 caches, an L2-resident prediction sub-module may forecast whether the request will also miss in the last-level cache. This predictor may leverage historical miss statistics, tag-history information, or other heuristics to anticipate an impending long-latency memory access. If the predictor indicates that the last-level cache will miss, the sub-module may immediately generate and forward a stall notification upstream-first to L1D and then to the core’s LSQ interface -before the final lookup in the last-level cache has completed.

[0056] Upon receipt of this early notification, the core’s detection module may mark the corresponding load entry in the load–store queue for the stalled thread, and the configuration module may apply the pre-configured watermark to subsequent resource-allocation decisions for that thread. Thereafter, the inhibition module may prevent further allocation of microarchitectural resource entries to the stalled thread if its usage exceeds the preset capacity limit, and re-allow allocation once usage falls below the threshold, in exactly the same manner as described for the detection embodiment.

[0057] Once the last-level cache lookup does complete, the processor may send a confirmation message back to the L2 prediction sub-module indicating whether the prediction was correct. The apparatus may record this confirmation (for example, via a dedicated recording module) to refine future prediction accuracy, but this confirmation need not alter the resource-allocation biasing already applied in response to the predicted stall.

[0058] It will be appreciated that the cache hierarchy (L1D, L2, LLC) , load–store queue, issue queue and the various modules (detection / prediction, marking, configuration and inhibition) collectively form part of the apparatus 200 as claimed herein. These elements may be realised in dedicated hardware circuitry, by one or more programmable logic devices, by one or more processors executing suitable program instructions, or by any combination thereof, such that the operations described in steps 301–308 are performed by the claimed apparatus.

[0059] According to an example, machine-readable instructions can be loaded onto a computer or other programmable data processing devices, so that the computer or other programmable data processing devices perform a series of operations to produce computer-implemented processing, thus the instructions executed on the computer or other programmable devices provide an operation for realizing functions specified by flow (s) in the flow charts and / or block (s) in the block diagrams.

[0060] Further, the teachings herein may be implemented in the form of a computer or software product, such as a non-transitory machine-readable storage medium, the computer software or product being stored in a storage medium and comprising a plurality of instructions, e.g., machine readable instructions, for making a computer device implement the methods recited in the examples of the present disclosure.

[0061] In some examples, some methods can be performed in a cloud-computing or network-based environment. Cloud-computing environments may provide various services and applications via the Internet. These cloud-based services (e.g., software as a service, platform as a service, infrastructure as a service, etc. ) may be accessible through a web browser or other remote interface of the user equipment for example. Various functions described herein may be provided through a remote desktop environment or any other cloud-based computing environment.

[0062] While various embodiments have been described and / or illustrated herein in the context of fully functional computing systems, one or more of these exemplary embodiments may be distributed as a program product in a variety of forms, regardless of the particular type of computer-readable-storage media used to actually carry out the distribution. The embodiments disclosed herein may also be implemented using software modules that perform certain tasks. These software modules may include script, batch, or other executable files that may be stored on a computer-readable storage medium or in a computing system. In some embodiments, these software modules may configure a computing system to perform one or more of the exemplary embodiments disclosed herein. In addition, one or more of the modules described herein may transform data, physical devices, and / or representations of physical devices from one form to another.

[0063] The preceding description has been provided to enable others skilled in the art to best utilize various aspects of the exemplary embodiments disclosed herein. This exemplary description is not intended to be exhaustive or to be limited to any precise form disclosed. Many modifications and variations are possible without departing from the spirit and scope of the instant disclosure. The embodiments disclosed herein should be considered in all respects illustrative and not restrictive. Reference should be made to the appended claims and their equivalents in determining the scope of the instant disclosure.

Claims

1.A method for managing microarchitectural resource allocation in a simultaneous multithreading, SMT, core, the method comprising:detecting, via a long-latency memory access detection module, or predicting, via a long-latency memory access prediction module, a stall in the SMT core caused by a memory access request (101) ;marking a load entry corresponding to the memory access request that caused the stall in a load–store queue associated with a thread experiencing the stall (102) ; andconfiguring at least one watermark for a microarchitectural resource of the SMT core, wherein the watermark specifies a preset capacity limit representing a maximum number of microarchitectural resource entries that may be allocated to the thread experiencing the stall (103) ,wherein the method further comprises: inhibiting any additional allocation of microarchitectural resource entries to the thread experiencing the stall when the allocated entries exceed the preset capacity limit, and re‐allowing allocation once the number of allocated entries falls below the preset capacity limit (104) .2.The method of claim 1, wherein the detecting (101) further comprises receiving a notification from a first cache, wherein the first cache comprises a cache at any level in a cache and memory hierarchy, upon a cache miss.3.The method of claim 1 or 2, wherein the predicting (101) further comprises:implementing a predictor at a second cache, wherein the second cache comprises a cache at any level in a cache and memory hierarchy to forecast whether a stall in the SMT core will occur; andgenerating a notification to the SMT core based on the prediction.4.The method of claim 1, 2 or 3, further comprising recording the detection or prediction event along with an identifier of a load instruction that caused the memory access request.5.The method of any one of claims 1 to 4, wherein configuring the watermark (103) comprises dynamically setting the preset capacity limit via a software‐controlled interface.6.The method of any one of claims 1 to 5, wherein inhibiting additional allocation (104) comprises halting issuance of further microarchitectural resource requests from the thread experiencing the stall.7.The method of any one of claims 1 to 6, further comprising monitoring the number of microarchitectural resource entries allocated to the thread experiencing the stall, and automatically re-allowing the allocation based on the monitoring.8.A non‐transitory computer‐readable medium storing programme instructions which, when executed by a processor, cause the processor to perform the method of any one of claims 1 to 7.9.An apparatus (200) for managing microarchitectural resource allocation in a simultaneous multithreading, SMT, core, the apparatus comprising:a detection / prediction module (201) configured to detect, via a long‐latency memory access detection module, or to predict, via a long‐latency memory access prediction module, a stall in the SMT core caused by a memory access request;a marking module (202) configured to mark a load entry corresponding to the memory access request that caused the stall in a load–store queue associated with a thread experiencing the stall;a configuration module (203) configured to set at least one watermark for a microarchitectural resource of the SMT core, the watermark specifying a preset capacity limit representing a maximum number of microarchitectural resource entries that may be allocated to the thread experiencing the stall; andan inhibition module (204) configured to inhibit any additional allocation of microarchitectural resource entries to the thread experiencing the stall when the allocated entries exceed the preset capacity limit, and to re‐allow allocation once the number of allocated entries falls below the preset capacity limit.10.The apparatus (200) of claim 9, wherein the detection / prediction module (201) is further configured to receive a notification from a first cache, wherein the first cache comprises a cache at any level in a cache and memory hierarchy, upon a cache miss.11.The apparatus (200) of claim 9 or 10, wherein the detection / prediction module (201) comprises a predictor implemented at a second cache, wherein the second cache comprises a cache at any level in a cache and memory hierarchy, the predictor being configured to forecast whether the stall in the SMT core will occur, and to generate a corresponding notification to the SMT core.12.The apparatus (200) of claim 9, 10 or 11, further comprising a recording module configured to record the detection or prediction event along with an identifier of the load instruction that caused the memory access request.13.The apparatus (200) of any one of claims 9 to 12, wherein the configuration module (203) is further configured to dynamically adjust the preset capacity limit via a software‐controlled interface.14.The apparatus (200) of claim 13, further comprising a control unit configured to communicate with the software‐controlled interface to modify the watermark configuration in response to changes in system load.15.The apparatus (200) of any one of claims 9 to 14, wherein the marking module (202) is further configured to associate the marked load entry with a unique identifier corresponding to the memory access request.