Memory bandwidth allocation software controller(mba_sc)
Subsystems (2)
v2 cover Memory bandwidth allocation software controller(mba_sc)
Sending the second version of MBA software controller which addresses the feedback on V1. Thanks to the feedback from Thomas on the V1. Thomas was unhappy about the bad structure and english in the documentation and comments explaining the changes and also about duct taping of data structure which saves the throttle MSRs. Also issues were pointed out in the mounting and other init code.
This series also changed the counting
and feedback loop patches with some improvements to not do any division and take care of hierarchy and some l2 -> l3 traffic scenarios.
The patches are based on 4.16.
Background:
Intel RDT memory bandwidth allocation (MBA) currently uses the resctrl interface and uses the schemata file in each rdtgroup to specify the max "bandwidth percentage" that is allowed to be used by the "threads" and "cpus" in the rdtgroup. These values are specified "per package" in each rdtgroup in the schemata file as below:
$ cat /sys/fs/resctrl/p1/schemata
L3:0=7ff;1=7ff
MB:0=100;1=50In the above example the MB is the memory bandwidth percentage and "0" and "1" specify the package/socket ids. The threads in rdtgroup "p1" would get 100% memory bandwidth on socket0 and 50% bandwidth on socket1.
Problem:
However there are confusions in specifying the MBA in "percentage":
1. In some scenarios, when user increases bandwidth percentage values he does not not see any raw bandwidth increase in "MBps"
2. Same bandwidth "percentage values" may mean different raw bandwidth in "MBps".
3. This interface may also end up unnecessarily controlling the L2 <-> L3 traffic which has no or very minimal L3 external traffic.
Proposed solution:
In short, we let user specify the bandwidth in "MBps" and we introduce a software feedback loop which measures the bandwidth using MBM and restricts the bandwidth "percentage" internally.
The fact that Memory bandwidth allocation(MBA) is a core specific mechanism where as memory bandwidth monitoring(MBM) is done at the package level is what leads to confusion when users try to apply control via the MBA and then monitor the bandwidth to see if the controls are effective. Below are details on such scenarios:
1. User may *not* see increase in actual bandwidth when bandwidth percentage values are increased:
This can occur when aggregate L2 external bandwidth is more than L3 external bandwidth. Consider an SKL SKU with 24 cores on a package and where L2 external is 10GBps (hence aggregate L2 external bandwidth is 240GBps) and L3 external bandwidth is 100GBps. Now a workload with '20 threads, having 50% bandwidth, each consuming 5GBps' consumes the max L3 bandwidth of 100GBps although the percentage value specified is only 50% << 100%. Hence increasing the bandwidth percentage will not yield any more bandwidth. This is because although the L2 external bandwidth still has capacity, the L3 external bandwidth is fully used. Also note that this would be dependent on number of cores the benchmark is run on.
2. Same bandwidth percentage may mean different actual bandwidth depending on # of threads:
For the same SKU in #1, a 'single thread, with 10% bandwidth' and '4 thread, with 10% bandwidth' can consume upto 10GBps and 40GBps although they have same percentage bandwidth of 10%. This is simply because as threads start using more cores in an rdtgroup, the actual bandwidth may increase or vary although user specified bandwidth percentage is same.
In order to mitigate this and make the interface more user friendly, resctrl added support for specifying the bandwidth in "MBps" as well. The kernel underneath would use a software feedback mechanism or a "Software Controller" which reads the actual bandwidth using MBM counters and adjust the memory bandwidth percentages to ensure
"actual bandwidth < user specified bandwidth".
By default, the schemata would take the bandwidth percentage values where as user can switch to the "MBA software controller" mode using a mount option 'mba_MBps'. The schemata format is specified in the below.
To use the feature mount the file system using mba_MBps option:
$ mount -t resctrl resctrl -o mba_MBps /sys/fs/resctrl
If the MBA is specified in MBps then user can enter the max bandwidth in MBps rather than the percentage values. The default value when mounted is max_u32.
$ echo "L3:0=3;1=c\nMB:0=1024;1=500" > /sys/fs/resctrl/p0/schemata $ echo "L3:0=3;1=3\nMB:0=1024;1=500" > /sys/fs/resctrl/p1/schemata
In the above example the tasks in "p1" and "p0" rdtgroup would use a max bandwidth of 1024MBps on socket0 and 500MBps on socket1.
Vikas Shivappa (6):
x86/intel_rdt/mba_sc: Documentation for MBA software
controller(mba_sc)
x86/intel_rdt/mba_sc: Enable/disable MBA software controller(mba_sc) x86/intel_rdt/mba_sc: Add initialization support x86/intel_rdt/mba_sc: Add schemata support x86/intel_rdt/mba_sc: Prepare for feedback loop x86/intel_rdt/mba_sc: Feedback loop to dynamically update mem
bandwidth
Documentation/x86/intel_rdt_ui.txt | 75 +++++++++++-- arch/x86/kernel/cpu/intel_rdt.c | 50 ++++++--- arch/x86/kernel/cpu/intel_rdt.h | 18 +++ arch/x86/kernel/cpu/intel_rdt_ctrlmondata.c | 24 +++- arch/x86/kernel/cpu/intel_rdt_monitor.c | 166 ++++++++++++++++++++++++++-- arch/x86/kernel/cpu/intel_rdt_rdtgroup.c | 33 ++++++ 6 files changed, 333 insertions(+), 33 deletions(-)
Signature · 1 line
1.9.1
PATCH v2 1/6 x86/intel_rdt/mba_sc: Documentation for MBA software controller(mba_sc)
Add documentation about the feedback loop mechanism (MBA software controller) which lets the user specify the memory bandwidth allocation in MBps. This includes some changes to "schemata" formati with examples.
--- Documentation/x86/intel_rdt_ui.txt | 75 ++++++++++++++++++++++++++++++++++---- 1 file changed, 67 insertions(+), 8 deletions(-)
Documentation/x86/intel_rdt_ui.txt +67 -8
@@ -17,12 +17,14 @@ MBA (Memory Bandwidth Allocation) - "mba" To use the feature mount the file system: - # mount -t resctrl resctrl [-o cdp[,cdpl2]] /sys/fs/resctrl + # mount -t resctrl resctrl [-o cdp[,cdpl2][,mba_MBps]] /sys/fs/resctrl mount options are: "cdp": Enable code/data prioritization in L3 cache allocations. "cdpl2": Enable code/data prioritization in L2 cache allocations. +"mba_MBps": Enable the MBA Software Controller(mba_sc) to specify MBA + bandwidth in MBps L2 and L3 CDP are controlled seperately.
@@ -270,10 +272,11 @@ and 0xA are not. On a system with a 20-bit mask each bit represents 5% of the capacity of the cache. You could partition the cache into four equal parts with masks: 0x1f, 0x3e0, 0x7c00, 0xf8000. -Memory bandwidth(b/w) percentage --------------------------------- -For Memory b/w resource, user controls the resource by indicating the -percentage of total memory b/w. +Memory bandwidth Allocation and monitoring +------------------------------------------ + +For Memory bandwidth resource, by default the user controls the resource +by indicating the percentage of total memory bandwidth. The minimum bandwidth percentage value for each cpu model is predefined and can be looked up through "info/MB/min_bandwidth". The bandwidth
@@ -285,7 +288,47 @@ to the next control step available on the hardware. The bandwidth throttling is a core specific mechanism on some of Intel SKUs. Using a high bandwidth and a low bandwidth setting on two threads sharing a core will result in both threads being throttled to use the -low bandwidth. +low bandwidth. The fact that Memory bandwidth allocation(MBA) is a core +specific mechanism where as memory bandwidth monitoring(MBM) is done at +the package level may lead to confusion when users try to apply control +via the MBA and then monitor the bandwidth to see if the controls are +effective. Below are such scenarios: + +1. User may *not* see increase in actual bandwidth when percentage + values are increased: + +This can occur when aggregate L2 external bandwidth is more than L3 +external bandwidth. Consider an SKL SKU with 24 cores on a package and +where L2 external is 10GBps (hence aggregate L2 external bandwidth is +240GBps) and L3 external bandwidth is 100GBps. Now a workload with '20 +threads, having 50% bandwidth, each consuming 5GBps' consumes the max L3 +bandwidth of 100GBps although the percentage value specified is only 50% +<< 100%. Hence increasing the bandwidth percentage will not yeild any +more bandwidth. This is because although the L2 external bandwidth still +has capacity, the L3 external bandwidth is fully used. Also note that +this would be dependent on number of cores the benchmark is run on. + +2. Same bandwidth percentage may mean different actual bandwidth + depending on # of threads: + +For the same SKU in #1, a 'single thread, with 10% bandwidth' and '4 +thread, with 10% bandwidth' can consume upto 10GBps and 40GBps although +they have same percentage bandwidth of 10%. This is simply because as +threads start using more cores in an rdtgroup, the actual bandwidth may +increase or vary although user specified bandwidth percentage is same. + +In order to mitigate this and make the interface more user friendly, +resctrl added support for specifying the bandwidth in MBps as well. The +kernel underneath would use a software feedback mechanism or a "Software +Controller(mba_sc)" which reads the actual bandwidth using MBM counters +and adjust the memowy bandwidth percentages to ensure + + "actual bandwidth < user specified bandwidth". + +By default, the schemata would take the bandwidth percentage values +where as user can switch to the "MBA software controller" mode using +a mount option 'mba_MBps'. The schemata format is specified in the below +sections. L3 schemata file details (code and data prioritization disabled) ----------------------------------------------------------------
@@ -308,13 +351,20 @@ schemata format is always: L2:<cache_id0>=<cbm>;<cache_id1>=<cbm>;... -Memory b/w Allocation details ------------------------------ +Memory bandwidth Allocation (default mode) +------------------------------------------ Memory b/w domain is L3 cache. MB:<cache_id0>=bandwidth0;<cache_id1>=bandwidth1;... +Memory bandwidth Allocation specified in MBps +--------------------------------------------- + +Memory bandwidth domain is L3 cache. + + MB:<cache_id0>=bw_MBps0;<cache_id1>=bw_MBps1;... + Reading/writing the schemata file --------------------------------- Reading the schemata file will show the state of all resources
@@ -358,6 +408,15 @@ allocations can overlap or not. The allocations specifies the maximum b/w that the group may be able to use and the system admin can configure the b/w accordingly. +If the MBA is specified in MB(megabytes) then user can enter the max b/w in MB +rather than the percentage values. + +# echo "L3:0=3;1=c\nMB:0=1024;1=500" > /sys/fs/resctrl/p0/schemata +# echo "L3:0=3;1=3\nMB:0=1024;1=500" > /sys/fs/resctrl/p1/schemata + +In the above example the tasks in "p1" and "p0" on socket 0 would use a max b/w +of 1024MB where as on socket 1 they would use 500MB. + Example 2 --------- Again two sockets, but this time with a more realistic 20-bit mask.
Signature · 1 line
1.9.1
tip-bot for Vikas Shivappa
merge bot[tip:x86/cache] x86/intel_rdt/mba_sc: Documentation for MBA software controller(mba_sc)
x86/intel_rdt/mba_sc: Documentation for MBA software controller(mba_sc)
Commit-ID: d6c64a4f49fdea0ae79addc3282ae8eb8581bdfc Gitweb: https://git.kernel.org/tip/d6c64a4f49fdea0ae79addc3282ae8eb8581bdfc Author: Vikas Shivappa <[email protected]> AuthorDate: Fri, 20 Apr 2018 15:36:16 -0700 Committer: Thomas Gleixner <[email protected]> CommitDate: Sat, 19 May 2018 13:16:42 +0200
x86/intel_rdt/mba_sc: Documentation for MBA software controller(mba_sc)
Add documentation about the feedback loop mechanism (MBA software controller) which lets the user specify the memory bandwidth allocation in MBps. This includes some changes to "schemata" formati with examples.
--- Documentation/x86/intel_rdt_ui.txt | 75 ++++++++++++++++++++++++++++++++++---- 1 file changed, 67 insertions(+), 8 deletions(-)
Documentation/x86/intel_rdt_ui.txt +67 -8
@@ -17,12 +17,14 @@ MBA (Memory Bandwidth Allocation) - "mba" To use the feature mount the file system: - # mount -t resctrl resctrl [-o cdp[,cdpl2]] /sys/fs/resctrl + # mount -t resctrl resctrl [-o cdp[,cdpl2][,mba_MBps]] /sys/fs/resctrl mount options are: "cdp": Enable code/data prioritization in L3 cache allocations. "cdpl2": Enable code/data prioritization in L2 cache allocations. +"mba_MBps": Enable the MBA Software Controller(mba_sc) to specify MBA + bandwidth in MBps L2 and L3 CDP are controlled seperately.
@@ -270,10 +272,11 @@ and 0xA are not. On a system with a 20-bit mask each bit represents 5% of the capacity of the cache. You could partition the cache into four equal parts with masks: 0x1f, 0x3e0, 0x7c00, 0xf8000. -Memory bandwidth(b/w) percentage --------------------------------- -For Memory b/w resource, user controls the resource by indicating the -percentage of total memory b/w. +Memory bandwidth Allocation and monitoring +------------------------------------------ + +For Memory bandwidth resource, by default the user controls the resource +by indicating the percentage of total memory bandwidth. The minimum bandwidth percentage value for each cpu model is predefined and can be looked up through "info/MB/min_bandwidth". The bandwidth
@@ -285,7 +288,47 @@ to the next control step available on the hardware. The bandwidth throttling is a core specific mechanism on some of Intel SKUs. Using a high bandwidth and a low bandwidth setting on two threads sharing a core will result in both threads being throttled to use the -low bandwidth. +low bandwidth. The fact that Memory bandwidth allocation(MBA) is a core +specific mechanism where as memory bandwidth monitoring(MBM) is done at +the package level may lead to confusion when users try to apply control +via the MBA and then monitor the bandwidth to see if the controls are +effective. Below are such scenarios: + +1. User may *not* see increase in actual bandwidth when percentage + values are increased: + +This can occur when aggregate L2 external bandwidth is more than L3 +external bandwidth. Consider an SKL SKU with 24 cores on a package and +where L2 external is 10GBps (hence aggregate L2 external bandwidth is +240GBps) and L3 external bandwidth is 100GBps. Now a workload with '20 +threads, having 50% bandwidth, each consuming 5GBps' consumes the max L3 +bandwidth of 100GBps although the percentage value specified is only 50% +<< 100%. Hence increasing the bandwidth percentage will not yeild any +more bandwidth. This is because although the L2 external bandwidth still +has capacity, the L3 external bandwidth is fully used. Also note that +this would be dependent on number of cores the benchmark is run on. + +2. Same bandwidth percentage may mean different actual bandwidth + depending on # of threads: + +For the same SKU in #1, a 'single thread, with 10% bandwidth' and '4 +thread, with 10% bandwidth' can consume upto 10GBps and 40GBps although +they have same percentage bandwidth of 10%. This is simply because as +threads start using more cores in an rdtgroup, the actual bandwidth may +increase or vary although user specified bandwidth percentage is same. + +In order to mitigate this and make the interface more user friendly, +resctrl added support for specifying the bandwidth in MBps as well. The +kernel underneath would use a software feedback mechanism or a "Software +Controller(mba_sc)" which reads the actual bandwidth using MBM counters +and adjust the memowy bandwidth percentages to ensure + + "actual bandwidth < user specified bandwidth". + +By default, the schemata would take the bandwidth percentage values +where as user can switch to the "MBA software controller" mode using +a mount option 'mba_MBps'. The schemata format is specified in the below +sections. L3 schemata file details (code and data prioritization disabled) ----------------------------------------------------------------
@@ -308,13 +351,20 @@ schemata format is always: L2:<cache_id0>=<cbm>;<cache_id1>=<cbm>;... -Memory b/w Allocation details ------------------------------ +Memory bandwidth Allocation (default mode) +------------------------------------------ Memory b/w domain is L3 cache. MB:<cache_id0>=bandwidth0;<cache_id1>=bandwidth1;... +Memory bandwidth Allocation specified in MBps +--------------------------------------------- + +Memory bandwidth domain is L3 cache. + + MB:<cache_id0>=bw_MBps0;<cache_id1>=bw_MBps1;... + Reading/writing the schemata file --------------------------------- Reading the schemata file will show the state of all resources
@@ -358,6 +408,15 @@ allocations can overlap or not. The allocations specifies the maximum b/w that the group may be able to use and the system admin can configure the b/w accordingly. +If the MBA is specified in MB(megabytes) then user can enter the max b/w in MB +rather than the percentage values. + +# echo "L3:0=3;1=c\nMB:0=1024;1=500" > /sys/fs/resctrl/p0/schemata +# echo "L3:0=3;1=3\nMB:0=1024;1=500" > /sys/fs/resctrl/p1/schemata + +In the above example the tasks in "p1" and "p0" on socket 0 would use a max b/w +of 1024MB where as on socket 1 they would use 500MB. + Example 2 --------- Again two sockets, but this time with a more realistic 20-bit mask.
PATCH v2 2/6 x86/intel_rdt/mba_sc: Enable/disable MBA software controller
In reply to Vikas ShivappaCurrently user does memory bandwidth allocation(MBA) by specifying the bandwidth in percentage via the resctrl schemata file:
"/sys/fs/resctrl/schemata"
Add a new mount option "mba_MBps" to enable the user to specify MBA in MBps:
$mount -t resctrl resctrl [-o cdp[,cdpl2][mba_MBps]] /sys/fs/resctrl
--- arch/x86/kernel/cpu/intel_rdt.c | 8 ++++++++ arch/x86/kernel/cpu/intel_rdt.h | 3 +++ arch/x86/kernel/cpu/intel_rdt_rdtgroup.c | 30 ++++++++++++++++++++++++++++++ 3 files changed, 41 insertions(+)
arch/x86/kernel/cpu/intel_rdt.c +8 -0
@@ -230,6 +230,14 @@ static inline void cache_alloc_hsw_probe(void) rdt_alloc_capable = true; } +bool is_mba_sc (struct rdt_resource *r) +{ +if (!r) +return rdt_resources_all[RDT_RESOURCE_MBA ].membw.mba_sc; + +return r->membw.mba_sc; +} +/* * rdt_get_mb_table() - get a mapping of bandwidth(b/w) percentage values * exposed to user interface and the h/w understandable delay values.
arch/x86/kernel/cpu/intel_rdt.h +3 -0
@@ -259,6 +259,7 @@ struct rdt_cache {* @min_bw: Minimum memory bandwidth percentage user can request * @bw_gran: Granularity at which the memory bandwidth is allocated * @delay_linear: True if memory B/W delay is in linear scale +* @mba_sc: True if MBA software controller(mba_sc) is enabled * @mb_map: Mapping of memory B/W percentage to memory B/W delay */ struct rdt_membw {
@@ -266,6 +267,7 @@ struct rdt_membw {u32 min_bw;u32 bw_gran;u32 delay_linear; +bool mba_sc;u32 *mb_map; };
@@ -445,6 +447,7 @@ void mon_event_read(struct rmid_read *rr, struct rdt_domain *d,void mbm_setup_overflow_handler (struct rdt_domain *dom,unsigned long delay_ms);void mbm_handle_overflow (struct work_struct *work); +bool is_mba_sc (struct rdt_resource *r);void cqm_setup_limbo_handler (struct rdt_domain *dom,unsigned long delay_ms);void cqm_handle_limbo (struct work_struct *work);bool has_busy_rmid (struct rdt_resource *r,struct rdt_domain *d);
arch/x86/kernel/cpu/intel_rdt_rdtgroup.c +30 -0
@@ -1005,6 +1005,11 @@ static void l2_qos_cfg_update(void *arg)wrmsrl (IA32_L2_QOS_CFG , *enable ?L2_QOS_CDP_ENABLE :0ULL ); } +static inline bool is_mba_linear (void ) +{ +return rdt_resources_all[RDT_RESOURCE_MBA ].membw.delay_linear; +} +static int set_cache_qos_cfg (int level,bool enable) {void (*update)(void *arg);
@@ -1041,6 +1046,25 @@ static int set_cache_qos_cfg(int level, bool enable)return 0 ; } +/* +* Enable or disable the MBA software controller +* which helps user specify bandwidth in MBps. +* MBA software controller is supported only if +* MBM is supported and MBA is in linear scale. +*/ +static int set_mba_sc (bool mba_sc) +{ +struct rdt_resource *r = &rdt_resources_all[RDT_RESOURCE_MBA ]; + +if (!is_mbm_enabled () || !is_mba_linear () || + mba_sc ==is_mba_sc (r)) +return -1 ; + + r->membw.mba_sc = mba_sc; + +return 0 ; +} +static int cdp_enable (int level,int data_type,int code_type) {struct rdt_resource *r_ldata = &rdt_resources_all[data_type];
@@ -1123,6 +1147,10 @@ static int parse_rdtgroupfs_options(char *data) ret =cdpl2_enable ();if (ret) goto out; + }else if (!strcmp (token,"mba_MBps" )) { + ret =set_mba_sc (true); +if (ret) + goto out; }else { ret = -EINVAL ; goto out;
@@ -1445,6 +1473,8 @@ static void rdt_kill_sb(struct super_block *sb)cpus_read_lock ();mutex_lock (&rdtgroup_mutex); +set_mba_sc (false); +/*Put everything back to default values. */ for_each_alloc_enabled_rdt_resource (r)reset_all_ctrls (r);
Signature · 1 line
1.9.1
Re: [PATCH 2/6] x86/intel_rdt/mba_sc: Enable/disable MBA software controller
arch/x86/kernel/cpu/intel_rdt_rdtgroup.c static int set_cache_qos_cfg(int level, bool enable) · line 1061
Quoted 13 lines · Vikas Shivappa
arch/x86/kernel/cpu/intel_rdt_rdtgroup.c +13
-0+/* +* Enable or disable the MBA software controller +* which helps user specify bandwidth in MBps. +* MBA software controller is supported only if +* MBM is supported and MBA is in linear scale. +*/ +static int set_mba_sc (bool mba_sc) +{ +struct rdt_resource *r = &rdt_resources_all[RDT_RESOURCE_MBA ]; + +if (!is_mbm_enabled () || !is_mba_linear () || + mba_sc ==is_mba_sc (r)) +return -1 ;
Please use a proper return value as this gets propagated.
Thanks,
tglx
Re: [PATCH 2/6] x86/intel_rdt/mba_sc: Enable/disable MBA software controller
Quoted 16 lines · Thomas Gleixner
arch/x86/kernel/cpu/intel_rdt_rdtgroup.c static int set_cache_qos_cfg(int level, bool enable) · line 1061
Quoted 13 lines · Vikas Shivappa
arch/x86/kernel/cpu/intel_rdt_rdtgroup.c +13
-0+/* +* Enable or disable the MBA software controller +* which helps user specify bandwidth in MBps. +* MBA software controller is supported only if +* MBM is supported and MBA is in linear scale. +*/ +static int set_mba_sc (bool mba_sc) +{ +struct rdt_resource *r = &rdt_resources_all[RDT_RESOURCE_MBA ]; + +if (!is_mbm_enabled () || !is_mba_linear () || + mba_sc ==is_mba_sc (r)) +return -1 ;Please use a proper return value as this gets propagated.
Will fix. -EINVAL should be better.
Thanks,
Vikas
Quoted 5 lines
Thanks,
tglx
tip-bot for Vikas Shivappa
merge bot[tip:x86/cache] x86/intel_rdt/mba_sc: Enable/disable MBA software controller
In reply to Vikas Shivappax86/intel_rdt/mba_sc: Enable/disable MBA software controller
Commit-ID: 19c635ab24a1e94a759e82bfb34554a6a0db215e Gitweb: https://git.kernel.org/tip/19c635ab24a1e94a759e82bfb34554a6a0db215e Author: Vikas Shivappa <[email protected]> AuthorDate: Fri, 20 Apr 2018 15:36:17 -0700 Committer: Thomas Gleixner <[email protected]> CommitDate: Sat, 19 May 2018 13:16:43 +0200
x86/intel_rdt/mba_sc: Enable/disable MBA software controller
Currently user does memory bandwidth allocation(MBA) by specifying the bandwidth in percentage via the resctrl schemata file:
"/sys/fs/resctrl/schemata"
Add a new mount option "mba_MBps" to enable the user to specify MBA in MBps:
$mount -t resctrl resctrl [-o cdp[,cdpl2][mba_MBps]] /sys/fs/resctrl
--- arch/x86/kernel/cpu/intel_rdt.c | 8 ++++++++ arch/x86/kernel/cpu/intel_rdt.h | 3 +++ arch/x86/kernel/cpu/intel_rdt_rdtgroup.c | 30 ++++++++++++++++++++++++++++++ 3 files changed, 41 insertions(+)
arch/x86/kernel/cpu/intel_rdt.c +8 -0
@@ -230,6 +230,14 @@ static inline void cache_alloc_hsw_probe(void) rdt_alloc_capable = true; } +bool is_mba_sc (struct rdt_resource *r) +{ +if (!r) +return rdt_resources_all[RDT_RESOURCE_MBA ].membw.mba_sc; + +return r->membw.mba_sc; +} +/* * rdt_get_mb_table() - get a mapping of bandwidth(b/w) percentage values * exposed to user interface and the h/w understandable delay values.
arch/x86/kernel/cpu/intel_rdt.h +3 -0
@@ -259,6 +259,7 @@ struct rdt_cache {* @min_bw: Minimum memory bandwidth percentage user can request * @bw_gran: Granularity at which the memory bandwidth is allocated * @delay_linear: True if memory B/W delay is in linear scale +* @mba_sc: True if MBA software controller(mba_sc) is enabled * @mb_map: Mapping of memory B/W percentage to memory B/W delay */ struct rdt_membw {
@@ -266,6 +267,7 @@ struct rdt_membw {u32 min_bw;u32 bw_gran;u32 delay_linear; +bool mba_sc;u32 *mb_map; };
@@ -445,6 +447,7 @@ void mon_event_read(struct rmid_read *rr, struct rdt_domain *d,void mbm_setup_overflow_handler (struct rdt_domain *dom,unsigned long delay_ms);void mbm_handle_overflow (struct work_struct *work); +bool is_mba_sc (struct rdt_resource *r);void cqm_setup_limbo_handler (struct rdt_domain *dom,unsigned long delay_ms);void cqm_handle_limbo (struct work_struct *work);bool has_busy_rmid (struct rdt_resource *r,struct rdt_domain *d);
arch/x86/kernel/cpu/intel_rdt_rdtgroup.c +30 -0
@@ -1005,6 +1005,11 @@ static void l2_qos_cfg_update(void *arg)wrmsrl (IA32_L2_QOS_CFG , *enable ?L2_QOS_CDP_ENABLE :0ULL ); } +static inline bool is_mba_linear (void ) +{ +return rdt_resources_all[RDT_RESOURCE_MBA ].membw.delay_linear; +} +static int set_cache_qos_cfg (int level,bool enable) {void (*update)(void *arg);
@@ -1041,6 +1046,25 @@ static int set_cache_qos_cfg(int level, bool enable)return 0 ; } +/* +* Enable or disable the MBA software controller +* which helps user specify bandwidth in MBps. +* MBA software controller is supported only if +* MBM is supported and MBA is in linear scale. +*/ +static int set_mba_sc (bool mba_sc) +{ +struct rdt_resource *r = &rdt_resources_all[RDT_RESOURCE_MBA ]; + +if (!is_mbm_enabled () || !is_mba_linear () || + mba_sc ==is_mba_sc (r)) +return -EINVAL ; + + r->membw.mba_sc = mba_sc; + +return 0 ; +} +static int cdp_enable (int level,int data_type,int code_type) {struct rdt_resource *r_ldata = &rdt_resources_all[data_type];
@@ -1123,6 +1147,10 @@ static int parse_rdtgroupfs_options(char *data) ret =cdpl2_enable ();if (ret) goto out; + }else if (!strcmp (token,"mba_MBps" )) { + ret =set_mba_sc (true); +if (ret) + goto out; }else { ret = -EINVAL ; goto out;
@@ -1445,6 +1473,8 @@ static void rdt_kill_sb(struct super_block *sb)cpus_read_lock ();mutex_lock (&rdtgroup_mutex); +set_mba_sc (false); +/*Put everything back to default values. */ for_each_alloc_enabled_rdt_resource (r)reset_all_ctrls (r);
PATCH v2 3/6 x86/intel_rdt/mba_sc: Add initialization support
In reply to Vikas ShivappaWhen MBA software controller is enabled, we need a per domain storage for user specified bandwidth in "MBps" and the "percentage" values which are programmed into the IA32_MBA_THRTL_MSR. Add support for these data structures and initialization.
The MBA percentage values have a default max value of 100 but however the max value in MBps is not available from the hardware and we keep it just at U32_MAX. This simply says that user can use all bandwidth by default but does not say what is the actual max bandwidth available. The actual bandwidth that is available may depend on lot of factors like QPI link, number of memory channels, memory channel frequency, its width and memory speed, how many channels are configured and also if memory interleaving is enabled.
--- arch/x86/kernel/cpu/intel_rdt.c | 37 +++++++++++++++++++++++--------- arch/x86/kernel/cpu/intel_rdt.h | 3 +++ arch/x86/kernel/cpu/intel_rdt_rdtgroup.c | 3 +++ 3 files changed, 33 insertions(+), 10 deletions(-)
arch/x86/kernel/cpu/intel_rdt.c +27 -10
@@ -35,6 +35,7 @@#define MAX_MBA_BW 100u#define MBA_IS_LINEAR 0x4 +#define MBA_MAX_MBPS U32_MAX/* Mutex to protect rdtgroup access. */ DEFINE_MUTEX (rdtgroup_mutex);
@@ -439,25 +440,40 @@ struct rdt_domain *rdt_find_domain(struct rdt_resource *r, int id,return NULL ; } +void setup_default_ctrlval (struct rdt_resource *r,u32 *dc,u32 *dm) +{ +int i; + +/* +* Initialize the Control MSRs to having no control. +* For Cache Allocation: Set all bits in cbm +* For Memory Allocation: Set b/w requested to 100% +* and the bandwidth in MBps to U32_MAX +*/ +for (i =0 ; i < r->num_closid; i++, dc++, dm++) { + *dc = r->default_ctrl; + *dm =MBA_MAX_MBPS ; + } +} +static int domain_setup_ctrlval (struct rdt_resource *r,struct rdt_domain *d) {struct msr_param m; -u32 *dc; -int i; +u32 *dc, *dm; dc =kmalloc_array (r->num_closid,sizeof (*d->ctrl_val),GFP_KERNEL );if (!dc)return -ENOMEM ; - d->ctrl_val = dc; + dm =kmalloc_array (r->num_closid,sizeof (*d->mbps_val),GFP_KERNEL ); +if (!dm) { +kfree (dc); +return -ENOMEM ; + } -/* -* Initialize the Control MSRs to having no control. -* For Cache Allocation: Set all bits in cbm -* For Memory Allocation: Set b/w requested to 100 -*/ -for (i =0 ; i < r->num_closid; i++, dc++) - *dc = r->default_ctrl; + d->ctrl_val = dc; + d->mbps_val = dm; +setup_default_ctrlval (r, dc, dm); m.low =0 ; m.high = r->num_closid;
@@ -596,6 +612,7 @@ static void domain_remove_cpu(int cpu, struct rdt_resource *r) }kfree (d->ctrl_val); +kfree (d->mbps_val);kfree (d->rmid_busy_llc);kfree (d->mbm_total);kfree (d->mbm_local);
arch/x86/kernel/cpu/intel_rdt.h +3 -0
@@ -202,6 +202,7 @@ struct mbm_state {* @cqm_work_cpu: * worker cpu for CQM h/w counters * @ctrl_val: array of cache or mem ctrl values (indexed by CLOSID) +* @mbps_val: When mba_sc is enabled, this holds the bandwidth in MBps * @new_ctrl: new ctrl value to be loaded * @have_new_ctrl: did user provide new_ctrl for this domain */
@@ -217,6 +218,7 @@ struct rdt_domain {int mbm_work_cpu;int cqm_work_cpu;u32 *ctrl_val; +u32 *mbps_val;u32 new_ctrl;bool have_new_ctrl; };
@@ -448,6 +450,7 @@ void mbm_setup_overflow_handler(struct rdt_domain *dom, unsigned long delay_ms);void mbm_handle_overflow (struct work_struct *work);bool is_mba_sc (struct rdt_resource *r); +void setup_default_ctrlval (struct rdt_resource *r,u32 *dc,u32 *dm);void cqm_setup_limbo_handler (struct rdt_domain *dom,unsigned long delay_ms);void cqm_handle_limbo (struct work_struct *work);bool has_busy_rmid (struct rdt_resource *r,struct rdt_domain *d);
arch/x86/kernel/cpu/intel_rdt_rdtgroup.c +3 -0
@@ -1055,12 +1055,15 @@ static int set_cache_qos_cfg(int level, bool enable)static int set_mba_sc (bool mba_sc) {struct rdt_resource *r = &rdt_resources_all[RDT_RESOURCE_MBA ]; +struct rdt_domain *d;if (!is_mbm_enabled () || !is_mba_linear () || mba_sc ==is_mba_sc (r))return -1 ; r->membw.mba_sc = mba_sc; +list_for_each_entry (d, &r->domains, list) +setup_default_ctrlval (r, d->ctrl_val, d->mbps_val);return 0 ; }
Signature · 1 line
1.9.1
tip-bot for Vikas Shivappa
merge bot[tip:x86/cache] x86/intel_rdt/mba_sc: Add initialization support
x86/intel_rdt/mba_sc: Add initialization support
Commit-ID: 1bd2a63b4f0deefe745aa0fd969c07b2eb9ee99e Gitweb: https://git.kernel.org/tip/1bd2a63b4f0deefe745aa0fd969c07b2eb9ee99e Author: Vikas Shivappa <[email protected]> AuthorDate: Fri, 20 Apr 2018 15:36:18 -0700 Committer: Thomas Gleixner <[email protected]> CommitDate: Sat, 19 May 2018 13:16:43 +0200
x86/intel_rdt/mba_sc: Add initialization support
When MBA software controller is enabled, a per domain storage is required for user specified bandwidth in "MBps" and the "percentage" values which are programmed into the IA32_MBA_THRTL_MSR. Add support for these data structures and initialization.
The MBA percentage values have a default max value of 100 but however the max value in MBps is not available from the hardware so it's set to U32_MAX.
This simply says that the control group can use all bandwidth by default but does not say what is the actual max bandwidth available. The actual bandwidth that is available may depend on lot of factors like QPI link, number of memory channels, memory channel frequency, its width and memory speed, how many channels are configured and also if memory interleaving is enabled. So there is no way to determine the maximum at runtime reliably.
--- arch/x86/kernel/cpu/intel_rdt.c | 37 +++++++++++++++++++++++--------- arch/x86/kernel/cpu/intel_rdt.h | 3 +++ arch/x86/kernel/cpu/intel_rdt_rdtgroup.c | 3 +++ 3 files changed, 33 insertions(+), 10 deletions(-)
arch/x86/kernel/cpu/intel_rdt.c +27 -10
@@ -35,6 +35,7 @@#define MAX_MBA_BW 100u#define MBA_IS_LINEAR 0x4 +#define MBA_MAX_MBPS U32_MAX/* Mutex to protect rdtgroup access. */ DEFINE_MUTEX (rdtgroup_mutex);
@@ -439,25 +440,40 @@ struct rdt_domain *rdt_find_domain(struct rdt_resource *r, int id,return NULL ; } +void setup_default_ctrlval (struct rdt_resource *r,u32 *dc,u32 *dm) +{ +int i; + +/* +* Initialize the Control MSRs to having no control. +* For Cache Allocation: Set all bits in cbm +* For Memory Allocation: Set b/w requested to 100% +* and the bandwidth in MBps to U32_MAX +*/ +for (i =0 ; i < r->num_closid; i++, dc++, dm++) { + *dc = r->default_ctrl; + *dm =MBA_MAX_MBPS ; + } +} +static int domain_setup_ctrlval (struct rdt_resource *r,struct rdt_domain *d) {struct msr_param m; -u32 *dc; -int i; +u32 *dc, *dm; dc =kmalloc_array (r->num_closid,sizeof (*d->ctrl_val),GFP_KERNEL );if (!dc)return -ENOMEM ; - d->ctrl_val = dc; + dm =kmalloc_array (r->num_closid,sizeof (*d->mbps_val),GFP_KERNEL ); +if (!dm) { +kfree (dc); +return -ENOMEM ; + } -/* -* Initialize the Control MSRs to having no control. -* For Cache Allocation: Set all bits in cbm -* For Memory Allocation: Set b/w requested to 100 -*/ -for (i =0 ; i < r->num_closid; i++, dc++) - *dc = r->default_ctrl; + d->ctrl_val = dc; + d->mbps_val = dm; +setup_default_ctrlval (r, dc, dm); m.low =0 ; m.high = r->num_closid;
@@ -596,6 +612,7 @@ static void domain_remove_cpu(int cpu, struct rdt_resource *r) }kfree (d->ctrl_val); +kfree (d->mbps_val);kfree (d->rmid_busy_llc);kfree (d->mbm_total);kfree (d->mbm_local);
arch/x86/kernel/cpu/intel_rdt.h +3 -0
@@ -202,6 +202,7 @@ struct mbm_state {* @cqm_work_cpu: * worker cpu for CQM h/w counters * @ctrl_val: array of cache or mem ctrl values (indexed by CLOSID) +* @mbps_val: When mba_sc is enabled, this holds the bandwidth in MBps * @new_ctrl: new ctrl value to be loaded * @have_new_ctrl: did user provide new_ctrl for this domain */
@@ -217,6 +218,7 @@ struct rdt_domain {int mbm_work_cpu;int cqm_work_cpu;u32 *ctrl_val; +u32 *mbps_val;u32 new_ctrl;bool have_new_ctrl; };
@@ -448,6 +450,7 @@ void mbm_setup_overflow_handler(struct rdt_domain *dom, unsigned long delay_ms);void mbm_handle_overflow (struct work_struct *work);bool is_mba_sc (struct rdt_resource *r); +void setup_default_ctrlval (struct rdt_resource *r,u32 *dc,u32 *dm);void cqm_setup_limbo_handler (struct rdt_domain *dom,unsigned long delay_ms);void cqm_handle_limbo (struct work_struct *work);bool has_busy_rmid (struct rdt_resource *r,struct rdt_domain *d);
arch/x86/kernel/cpu/intel_rdt_rdtgroup.c +3 -0
@@ -1055,12 +1055,15 @@ static int set_cache_qos_cfg(int level, bool enable)static int set_mba_sc (bool mba_sc) {struct rdt_resource *r = &rdt_resources_all[RDT_RESOURCE_MBA ]; +struct rdt_domain *d;if (!is_mbm_enabled () || !is_mba_linear () || mba_sc ==is_mba_sc (r))return -EINVAL ; r->membw.mba_sc = mba_sc; +list_for_each_entry (d, &r->domains, list) +setup_default_ctrlval (r, d->ctrl_val, d->mbps_val);return 0 ; }
PATCH v2 4/6 x86/intel_rdt/mba_sc: Add schemata support
In reply to Vikas ShivappaCurrently when user updates the "schemata" with new MBA percentage values, kernel writes the corresponding bandwidth percentage values to the IA32_MBA_THRTL_MSR.
When MBA is expressed in MBps, the schemata format is changed to have the per package memory bandwidth in MBps instead of being specified in percentage. We do not write the IA32_MBA_THRTL_MSRs when the schemata is updated as that is handled separately.
--- arch/x86/kernel/cpu/intel_rdt.c | 2 +- arch/x86/kernel/cpu/intel_rdt_ctrlmondata.c | 24 +++++++++++++++++++----- 2 files changed, 20 insertions(+), 6 deletions(-)
arch/x86/kernel/cpu/intel_rdt.c +1 -1
@@ -179,7 +179,7 @@ struct rdt_resource rdt_resources_all[] = { .msr_update = mba_wrmsr, .cache_level = 3, .parse_ctrlval = parse_bw, - .format_str = "%d=%*d", + .format_str = "%d=%*u", .fflags = RFTYPE_RES_MB, }, };
arch/x86/kernel/cpu/intel_rdt_ctrlmondata.c +19 -5
@@ -53,7 +53,8 @@ static bool bw_validate(char *buf, unsigned long *data, struct rdt_resource *r)return false; } -if (bw < r->membw.min_bw || bw > r->default_ctrl) { +if ((bw < r->membw.min_bw || bw > r->default_ctrl) && + !is_mba_sc (r)) {rdt_last_cmd_printf ("MB value %ld out of range [%d,%d]\n" , bw, r->membw.min_bw, r->default_ctrl);return false;
@@ -179,6 +180,8 @@ static int update_domains(struct rdt_resource *r, int closid)struct msr_param msr_param;cpumask_var_t cpu_mask;struct rdt_domain *d; +bool mba_sc; +u32 *dc;int cpu;if (!zalloc_cpumask_var (&cpu_mask,GFP_KERNEL ))
@@ -188,13 +191,20 @@ static int update_domains(struct rdt_resource *r, int closid) msr_param.high = msr_param.low +1 ; msr_param.res = r; + mba_sc =is_mba_sc (r);list_for_each_entry (d, &r->domains, list) { -if (d->have_new_ctrl && d->new_ctrl != d->ctrl_val[closid]) { + dc = !mba_sc ? d->ctrl_val : d->mbps_val; +if (d->have_new_ctrl && d->new_ctrl != dc[closid]) {cpumask_set_cpu (cpumask_any (&d->cpu_mask), cpu_mask); - d->ctrl_val[closid] = d->new_ctrl; + dc[closid] = d->new_ctrl; } } -if (cpumask_empty (cpu_mask)) + +/* +* Avoid writing the control msr with control values when +* MBA software controller is enabled +*/ +if (cpumask_empty (cpu_mask) || mba_sc) goto done; cpu =get_cpu ();/* Update CBM on this cpu if it's in cpu_mask. */
@@ -282,13 +292,17 @@ static void show_doms(struct seq_file *s, struct rdt_resource *r, int closid) {struct rdt_domain *dom;bool sep = false; +u32 ctrl_val;seq_printf (s,"%*s:" , max_name_width, r->name);list_for_each_entry (dom, &r->domains, list) {if (sep)seq_puts (s,";" ); + + ctrl_val = (!is_mba_sc (r) ? dom->ctrl_val[closid] : + dom->mbps_val[closid]);seq_printf (s, r->format_str, dom->id, max_data_width, - dom->ctrl_val[closid]); + ctrl_val); sep = true; }seq_puts (s,"\n" );
Signature · 1 line
1.9.1
tip-bot for Vikas Shivappa
merge bot[tip:x86/cache] x86/intel_rdt/mba_sc: Add schemata support
x86/intel_rdt/mba_sc: Add schemata support
Commit-ID: 8205a078ba7819c23558e31af4b3bda04d9b3bae Gitweb: https://git.kernel.org/tip/8205a078ba7819c23558e31af4b3bda04d9b3bae Author: Vikas Shivappa <[email protected]> AuthorDate: Fri, 20 Apr 2018 15:36:19 -0700 Committer: Thomas Gleixner <[email protected]> CommitDate: Sat, 19 May 2018 13:16:44 +0200
x86/intel_rdt/mba_sc: Add schemata support
Currently when user updates the "schemata" with new MBA percentage values, kernel writes the corresponding bandwidth percentage values to the IA32_MBA_THRTL_MSR.
When MBA is expressed in MBps, the schemata format is changed to have the per package memory bandwidth in MBps instead of being specified in percentage. Do not write the IA32_MBA_THRTL_MSRs when the schemata is updated as that is handled separately.
--- arch/x86/kernel/cpu/intel_rdt.c | 2 +- arch/x86/kernel/cpu/intel_rdt_ctrlmondata.c | 24 +++++++++++++++++++----- 2 files changed, 20 insertions(+), 6 deletions(-)
arch/x86/kernel/cpu/intel_rdt.c +1 -1
@@ -179,7 +179,7 @@ struct rdt_resource rdt_resources_all[] = { .msr_update = mba_wrmsr, .cache_level = 3, .parse_ctrlval = parse_bw, - .format_str = "%d=%*d", + .format_str = "%d=%*u", .fflags = RFTYPE_RES_MB, }, };
arch/x86/kernel/cpu/intel_rdt_ctrlmondata.c +19 -5
@@ -53,7 +53,8 @@ static bool bw_validate(char *buf, unsigned long *data, struct rdt_resource *r)return false; } -if (bw < r->membw.min_bw || bw > r->default_ctrl) { +if ((bw < r->membw.min_bw || bw > r->default_ctrl) && + !is_mba_sc (r)) {rdt_last_cmd_printf ("MB value %ld out of range [%d,%d]\n" , bw, r->membw.min_bw, r->default_ctrl);return false;
@@ -179,6 +180,8 @@ static int update_domains(struct rdt_resource *r, int closid)struct msr_param msr_param;cpumask_var_t cpu_mask;struct rdt_domain *d; +bool mba_sc; +u32 *dc;int cpu;if (!zalloc_cpumask_var (&cpu_mask,GFP_KERNEL ))
@@ -188,13 +191,20 @@ static int update_domains(struct rdt_resource *r, int closid) msr_param.high = msr_param.low +1 ; msr_param.res = r; + mba_sc =is_mba_sc (r);list_for_each_entry (d, &r->domains, list) { -if (d->have_new_ctrl && d->new_ctrl != d->ctrl_val[closid]) { + dc = !mba_sc ? d->ctrl_val : d->mbps_val; +if (d->have_new_ctrl && d->new_ctrl != dc[closid]) {cpumask_set_cpu (cpumask_any (&d->cpu_mask), cpu_mask); - d->ctrl_val[closid] = d->new_ctrl; + dc[closid] = d->new_ctrl; } } -if (cpumask_empty (cpu_mask)) + +/* +* Avoid writing the control msr with control values when +* MBA software controller is enabled +*/ +if (cpumask_empty (cpu_mask) || mba_sc) goto done; cpu =get_cpu ();/* Update CBM on this cpu if it's in cpu_mask. */
@@ -282,13 +292,17 @@ static void show_doms(struct seq_file *s, struct rdt_resource *r, int closid) {struct rdt_domain *dom;bool sep = false; +u32 ctrl_val;seq_printf (s,"%*s:" , max_name_width, r->name);list_for_each_entry (dom, &r->domains, list) {if (sep)seq_puts (s,";" ); + + ctrl_val = (!is_mba_sc (r) ? dom->ctrl_val[closid] : + dom->mbps_val[closid]);seq_printf (s, r->format_str, dom->id, max_data_width, - dom->ctrl_val[closid]); + ctrl_val); sep = true; }seq_puts (s,"\n" );
PATCH v2 5/6 x86/intel_rdt/mba_sc: Prepare for feedback loop
In reply to Vikas ShivappaThis is a preparatory patch for the mba feedback loop. We add support to measure the "bandwidth in MBps" and the "delta bandwidth". We measure it reading the MBM IA32_QM_CTR MSRs and calculating the amount of "bytes" moved. There is no user interface for this and will only be used by the feedback loop patch.
--- arch/x86/kernel/cpu/intel_rdt.h | 10 ++++++++ arch/x86/kernel/cpu/intel_rdt_monitor.c | 45 ++++++++++++++++++++++++++++----- 2 files changed, 49 insertions(+), 6 deletions(-)
arch/x86/kernel/cpu/intel_rdt.h +10 -0
@@ -180,10 +180,20 @@ struct rftype {* struct mbm_state - status for each MBM counter in each domain * @chunks: Total data moved (multiply by rdt_group.mon_scale to get bytes) * @prev_msr Value of IA32_QM_CTR for this RMID last time we read it +* @chunks_bw Total local data moved. Used for bandwidth calculation +* @prev_bw_msr:Value of previous IA32_QM_CTR for bandwidth counting +* @prev_bw The most recent bandwidth in MBps +* @delta_bw Difference between the current and previous bandwidth +* @delta_comp Indicates whether to compute the delta_bw */ struct mbm_state {u64 chunks;u64 prev_msr; +u64 chunks_bw; +u64 prev_bw_msr; +u32 prev_bw; +u32 delta_bw; +bool delta_comp; };/**
arch/x86/kernel/cpu/intel_rdt_monitor.c +39 -6
69 lines not on this page · raw message
Signature · 1 line
1.9.1
tip-bot for Vikas Shivappa
merge bot[tip:x86/cache] x86/intel_rdt/mba_sc: Prepare for feedback loop
x86/intel_rdt/mba_sc: Prepare for feedback loop
Commit-ID: ba0f26d8529c2dfc9aa6d9e8a338180737f8c1be Gitweb: https://git.kernel.org/tip/ba0f26d8529c2dfc9aa6d9e8a338180737f8c1be Author: Vikas Shivappa <[email protected]> AuthorDate: Fri, 20 Apr 2018 15:36:20 -0700 Committer: Thomas Gleixner <[email protected]> CommitDate: Sat, 19 May 2018 13:16:44 +0200
x86/intel_rdt/mba_sc: Prepare for feedback loop
This is a preparatory patch for the mba feedback loop. Add support to measure the "bandwidth in MBps" and the "delta bandwidth". Measure it by reading the MBM IA32_QM_CTR MSRs and calculating the amount of "bytes" moved. There is no user space interface for this and will only be used by the feedback loop patch.
--- arch/x86/kernel/cpu/intel_rdt.h | 10 ++++++++ arch/x86/kernel/cpu/intel_rdt_monitor.c | 44 ++++++++++++++++++++++++++++----- 2 files changed, 48 insertions(+), 6 deletions(-)
arch/x86/kernel/cpu/intel_rdt.h +10 -0
@@ -180,10 +180,20 @@ struct rftype {* struct mbm_state - status for each MBM counter in each domain * @chunks: Total data moved (multiply by rdt_group.mon_scale to get bytes) * @prev_msr Value of IA32_QM_CTR for this RMID last time we read it +* @chunks_bw Total local data moved. Used for bandwidth calculation +* @prev_bw_msr:Value of previous IA32_QM_CTR for bandwidth counting +* @prev_bw The most recent bandwidth in MBps +* @delta_bw Difference between the current and previous bandwidth +* @delta_comp Indicates whether to compute the delta_bw */ struct mbm_state {u64 chunks;u64 prev_msr; +u64 chunks_bw; +u64 prev_bw_msr; +u32 prev_bw; +u32 delta_bw; +bool delta_comp; };/**
arch/x86/kernel/cpu/intel_rdt_monitor.c +38 -6
68 lines not on this page · raw message
PATCH v2 6/6 x86/intel_rdt/mba_sc: Feedback loop to dynamically update mem bandwidth
In reply to Vikas Shivappamba_sc is a feedback loop where we periodically read MBM counters and try to restrict the bandwidth below a max value so the below is always true:
"current bandwidth(cur_bw) < user specified bandwidth(user_bw)"
The frequency of these checks is currently 1s and we just tag along the MBM overflow timer to do the updates. Doing it once in a second also makes the calculation of bandwidth easy. The steps of increase or decrease of bandwidth is the minimum granularity specified by the hardware.
Although the MBA's goal is to restrict the bandwidth below a maximum, there may be a need to even increase the bandwidth. Since MBA controls the L2 external bandwidth where as MBM measures the L3 external bandwidth, we may end up restricting some rdtgroups unnecessarily. This may happen in the sequence where rdtgroup (set of jobs) had high "L3 <-> memory traffic" in initial phases -> mba_sc kicks in and reduced bandwidth percentage values -> but after some it has mostly "L2 <-> L3" traffic. In this scenario mba_sc increases the bandwidth percentage when there is lesser memory traffic.
--- arch/x86/kernel/cpu/intel_rdt.c | 3 +- arch/x86/kernel/cpu/intel_rdt.h | 2 + arch/x86/kernel/cpu/intel_rdt_monitor.c | 121 +++++++++++++++++++++++++++++++- 3 files changed, 123 insertions(+), 3 deletions(-)
arch/x86/kernel/cpu/intel_rdt.c +1 -2
@@ -33,7 +33,6 @@#include <asm/intel_rdt_sched.h> #include "intel_rdt.h" -#define MAX_MBA_BW 100u#define MBA_IS_LINEAR 0x4#define MBA_MAX_MBPS U32_MAX
@@ -350,7 +349,7 @@ static int get_cache_id(int cpu, int level)* that can be written to QOS_MSRs. * There are currently no SKUs which support non linear delay values. */ -static u32 delay_bw_map (unsigned long bw,struct rdt_resource *r) +u32 delay_bw_map (unsigned long bw,struct rdt_resource *r) {if (r->membw.delay_linear)return MAX_MBA_BW - bw;
arch/x86/kernel/cpu/intel_rdt.h +2 -0
@@ -28,6 +28,7 @@#define MBM_CNTR_WIDTH 24#define MBM_OVERFLOW_INTERVAL 1000 +#define MAX_MBA_BW 100u#define RMID_VAL_ERROR BIT_ULL(63)#define RMID_VAL_UNAVAIL BIT_ULL(62)
@@ -461,6 +462,7 @@ void mbm_setup_overflow_handler(struct rdt_domain *dom,void mbm_handle_overflow (struct work_struct *work);bool is_mba_sc (struct rdt_resource *r);void setup_default_ctrlval (struct rdt_resource *r,u32 *dc,u32 *dm); +u32 delay_bw_map (unsigned long bw,struct rdt_resource *r);void cqm_setup_limbo_handler (struct rdt_domain *dom,unsigned long delay_ms);void cqm_handle_limbo (struct work_struct *work);bool has_busy_rmid (struct rdt_resource *r,struct rdt_domain *d);
arch/x86/kernel/cpu/intel_rdt_monitor.c +120 -1
139 lines not on this page · raw message
Signature · 1 line
1.9.1
tip-bot for Vikas Shivappa
merge bot[tip:x86/cache] x86/intel_rdt/mba_sc: Feedback loop to dynamically update mem bandwidth
x86/intel_rdt/mba_sc: Feedback loop to dynamically update mem bandwidth
Commit-ID: de73f38f768021610bd305cf74ef3702fcf6a1eb Gitweb: https://git.kernel.org/tip/de73f38f768021610bd305cf74ef3702fcf6a1eb Author: Vikas Shivappa <[email protected]> AuthorDate: Fri, 20 Apr 2018 15:36:21 -0700 Committer: Thomas Gleixner <[email protected]> CommitDate: Sat, 19 May 2018 13:16:44 +0200
x86/intel_rdt/mba_sc: Feedback loop to dynamically update mem bandwidth
mba_sc is a feedback loop where we periodically read MBM counters and try to restrict the bandwidth below a max value so the below is always true:
"current bandwidth(cur_bw) < user specified bandwidth(user_bw)"
The frequency of these checks is currently 1s and we just tag along the MBM overflow timer to do the updates. Doing it once in a second also makes the calculation of bandwidth easy. The steps of increase or decrease of bandwidth is the minimum granularity specified by the hardware.
Although the MBA's goal is to restrict the bandwidth below a maximum, there may be a need to even increase the bandwidth. Since MBA controls the L2 external bandwidth where as MBM measures the L3 external bandwidth, we may end up restricting some rdtgroups unnecessarily. This may happen in the sequence where rdtgroup (set of jobs) had high "L3 <-> memory traffic" in initial phases -> mba_sc kicks in and reduced bandwidth percentage values -> but after some it has mostly "L2 <-> L3" traffic. In this scenario mba_sc increases the bandwidth percentage when there is lesser memory traffic.
--- arch/x86/kernel/cpu/intel_rdt.c | 3 +- arch/x86/kernel/cpu/intel_rdt.h | 2 + arch/x86/kernel/cpu/intel_rdt_monitor.c | 126 +++++++++++++++++++++++++++++++- 3 files changed, 128 insertions(+), 3 deletions(-)
arch/x86/kernel/cpu/intel_rdt.c +1 -2
@@ -33,7 +33,6 @@#include <asm/intel_rdt_sched.h> #include "intel_rdt.h" -#define MAX_MBA_BW 100u#define MBA_IS_LINEAR 0x4#define MBA_MAX_MBPS U32_MAX
@@ -350,7 +349,7 @@ static int get_cache_id(int cpu, int level)* that can be written to QOS_MSRs. * There are currently no SKUs which support non linear delay values. */ -static u32 delay_bw_map (unsigned long bw,struct rdt_resource *r) +u32 delay_bw_map (unsigned long bw,struct rdt_resource *r) {if (r->membw.delay_linear)return MAX_MBA_BW - bw;
arch/x86/kernel/cpu/intel_rdt.h +2 -0
@@ -28,6 +28,7 @@#define MBM_CNTR_WIDTH 24#define MBM_OVERFLOW_INTERVAL 1000 +#define MAX_MBA_BW 100u#define RMID_VAL_ERROR BIT_ULL(63)#define RMID_VAL_UNAVAIL BIT_ULL(62)
@@ -461,6 +462,7 @@ void mbm_setup_overflow_handler(struct rdt_domain *dom,void mbm_handle_overflow (struct work_struct *work);bool is_mba_sc (struct rdt_resource *r);void setup_default_ctrlval (struct rdt_resource *r,u32 *dc,u32 *dm); +u32 delay_bw_map (unsigned long bw,struct rdt_resource *r);void cqm_setup_limbo_handler (struct rdt_domain *dom,unsigned long delay_ms);void cqm_handle_limbo (struct work_struct *work);bool has_busy_rmid (struct rdt_resource *r,struct rdt_domain *d);
arch/x86/kernel/cpu/intel_rdt_monitor.c +125 -1
144 lines not on this page · raw message
Hello Thomas,
I have sent a new version trying to address your feedback. Made this more cleaner also. Would be great if you could let me know any feedback.
Regards,
Vikas
Quoted 123 lines · Vikas Shivappa
Sending the second version of MBA software controller which addresses the feedback on V1. Thanks to the feedback from Thomas on the V1. Thomas was unhappy about the bad structure and english in the documentation and comments explaining the changes and also about duct taping of data structure which saves the throttle MSRs. Also issues were pointed out in the mounting and other init code.
This series also changed the counting
and feedback loop patches with some improvements to not do any division and take care of hierarchy and some l2 -> l3 traffic scenarios.The patches are based on 4.16.
Background:
Intel RDT memory bandwidth allocation (MBA) currently uses the resctrl interface and uses the schemata file in each rdtgroup to specify the max "bandwidth percentage" that is allowed to be used by the "threads" and "cpus" in the rdtgroup. These values are specified "per package" in each rdtgroup in the schemata file as below:
$ cat /sys/fs/resctrl/p1/schemata L3:0=7ff;1=7ff MB:0=100;1=50In the above example the MB is the memory bandwidth percentage and "0" and "1" specify the package/socket ids. The threads in rdtgroup "p1" would get 100% memory bandwidth on socket0 and 50% bandwidth on socket1.
Problem:
However there are confusions in specifying the MBA in "percentage":
1. In some scenarios, when user increases bandwidth percentage values he does not not see any raw bandwidth increase in "MBps"
2. Same bandwidth "percentage values" may mean different raw bandwidth in "MBps".
3. This interface may also end up unnecessarily controlling the L2 <-> L3 traffic which has no or very minimal L3 external traffic.Proposed solution:
In short, we let user specify the bandwidth in "MBps" and we introduce a software feedback loop which measures the bandwidth using MBM and restricts the bandwidth "percentage" internally.
The fact that Memory bandwidth allocation(MBA) is a core specific mechanism where as memory bandwidth monitoring(MBM) is done at the package level is what leads to confusion when users try to apply control via the MBA and then monitor the bandwidth to see if the controls are effective. Below are details on such scenarios:
1. User may *not* see increase in actual bandwidth when bandwidth percentage values are increased:
This can occur when aggregate L2 external bandwidth is more than L3 external bandwidth. Consider an SKL SKU with 24 cores on a package and where L2 external is 10GBps (hence aggregate L2 external bandwidth is 240GBps) and L3 external bandwidth is 100GBps. Now a workload with '20 threads, having 50% bandwidth, each consuming 5GBps' consumes the max L3 bandwidth of 100GBps although the percentage value specified is only 50% << 100%. Hence increasing the bandwidth percentage will not yield any more bandwidth. This is because although the L2 external bandwidth still has capacity, the L3 external bandwidth is fully used. Also note that this would be dependent on number of cores the benchmark is run on.
2. Same bandwidth percentage may mean different actual bandwidth depending on # of threads:
For the same SKU in #1, a 'single thread, with 10% bandwidth' and '4 thread, with 10% bandwidth' can consume upto 10GBps and 40GBps although they have same percentage bandwidth of 10%. This is simply because as threads start using more cores in an rdtgroup, the actual bandwidth may increase or vary although user specified bandwidth percentage is same.
In order to mitigate this and make the interface more user friendly, resctrl added support for specifying the bandwidth in "MBps" as well. The kernel underneath would use a software feedback mechanism or a "Software Controller" which reads the actual bandwidth using MBM counters and adjust the memory bandwidth percentages to ensure
"actual bandwidth < user specified bandwidth".
By default, the schemata would take the bandwidth percentage values where as user can switch to the "MBA software controller" mode using a mount option '
mba_MBps'. The schemata format is specified in the below.To use the feature mount the file system using
mba_MBpsoption:$ mount -t resctrl resctrl -o mba_MBps /sys/fs/resctrlIf the MBA is specified in MBps then user can enter the max bandwidth in MBps rather than the percentage values. The default value when mounted is
max_u32.$ echo "L3:0=3;1=c\nMB:0=1024;1=500" > /sys/fs/resctrl/p0/schemata $ echo "L3:0=3;1=3\nMB:0=1024;1=500" > /sys/fs/resctrl/p1/schemataIn the above example the tasks in "p1" and "p0" rdtgroup would use a max bandwidth of 1024MBps on socket0 and 500MBps on socket1.
Vikas Shivappa (6):
x86/intel_rdt/mba_sc: Documentation for MBA software
controller(mba_sc)
x86/intel_rdt/mba_sc: Enable/disable MBA softwarecontroller(mba_sc)x86/intel_rdt/mba_sc: Add initialization support x86/intel_rdt/mba_sc: Add schemata support x86/intel_rdt/mba_sc: Prepare for feedback loop x86/intel_rdt/mba_sc: Feedback loop to dynamically update mem
bandwidthDocumentation/x86/intel_rdt_ui.txt | 75 +++++++++++-- arch/x86/kernel/cpu/intel_rdt.c | 50 ++++++--- arch/x86/kernel/cpu/intel_rdt.h | 18 +++ arch/x86/kernel/cpu/intel_rdt_ctrlmondata.c | 24 +++- arch/x86/kernel/cpu/intel_rdt_monitor.c | 166 ++++++++++++++++++++++++++-- arch/x86/kernel/cpu/intel_rdt_rdtgroup.c | 33 ++++++ 6 files changed, 333 insertions(+), 33 deletions(-)Signature · 1 line
1.9.1
Quoted 2 lines · Shivappa Vikas
I have sent a new version trying to address your feedback. Made this more cleaner also. Would be great if you could let me know any feedback.
It's on my todo list ...