Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]

Groups > linux.kernel > #1505287 > unrolled thread

[PATCH v6 0/9] Support Intel® Turbo Boost Max Technology 3.0

Back to article view | Back to linux.kernel

Contents

  [PATCH v6 0/9] Support Intel® Turbo Boost Max Technology 3.0 Tim Chen <tim.c.chen@linux.intel.com> - 2016-10-21 00:10 +0200
    [PATCH v6 8/9] acpi: bus: Set _OSC for diverse core support Tim Chen <tim.c.chen@linux.intel.com> - 2016-10-21 00:10 +0200
    [PATCH v6 2/9] x86/topology: Provide topology_num_packages() Tim Chen <tim.c.chen@linux.intel.com> - 2016-10-21 00:10 +0200
    [PATCH v6 4/9] x86: Enable Intel Turbo Boost Max Technology 3.0 Tim Chen <tim.c.chen@linux.intel.com> - 2016-10-21 00:10 +0200
    [PATCH v6 3/9] x86/topology: Define x86's arch_update_cpu_topology Tim Chen <tim.c.chen@linux.intel.com> - 2016-10-21 00:10 +0200
    [PATCH v6 5/9] x86/sysctl: Add sysctl for ITMT scheduling feature Tim Chen <tim.c.chen@linux.intel.com> - 2016-10-21 00:10 +0200
      Re: [PATCH v6 5/9] x86/sysctl: Add sysctl for ITMT scheduling  feature Thomas Gleixner <tglx@linutronix.de> - 2016-10-26 13:00 +0200
        Re: [PATCH v6 5/9] x86/sysctl: Add sysctl for ITMT scheduling  feature Tim Chen <tim.c.chen@linux.intel.com> - 2016-10-26 20:10 +0200
          Re: [PATCH v6 5/9] x86/sysctl: Add sysctl for ITMT scheduling  feature Thomas Gleixner <tglx@linutronix.de> - 2016-10-26 20:20 +0200
            Re: [PATCH v6 5/9] x86/sysctl: Add sysctl for ITMT scheduling  feature Tim Chen <tim.c.chen@linux.intel.com> - 2016-10-26 21:40 +0200
      Re: [PATCH v6 5/9] x86/sysctl: Add sysctl for ITMT scheduling  feature Thomas Gleixner <tglx@linutronix.de> - 2016-10-26 13:00 +0200
        Re: [PATCH v6 5/9] x86/sysctl: Add sysctl for ITMT scheduling  feature Thomas Gleixner <tglx@linutronix.de> - 2016-10-26 13:30 +0200
          Re: [PATCH v6 5/9] x86/sysctl: Add sysctl for ITMT scheduling  feature Tim Chen <tim.c.chen@linux.intel.com> - 2016-10-26 19:30 +0200
            Re: [PATCH v6 5/9] x86/sysctl: Add sysctl for ITMT scheduling  feature Thomas Gleixner <tglx@linutronix.de> - 2016-10-26 20:20 +0200
        Re: [PATCH v6 5/9] x86/sysctl: Add sysctl for ITMT scheduling feature Peter Zijlstra <peterz@infradead.org> - 2016-10-26 13:30 +0200
        Re: [PATCH v6 5/9] x86/sysctl: Add sysctl for ITMT scheduling  feature Tim Chen <tim.c.chen@linux.intel.com> - 2016-10-26 20:10 +0200
    [PATCH v6 1/9] sched: Extend scheduler's asym packing Tim Chen <tim.c.chen@linux.intel.com> - 2016-10-21 00:10 +0200
      Re: [PATCH v6 1/9] sched: Extend scheduler's asym packing Thomas Gleixner <tglx@linutronix.de> - 2016-10-26 12:40 +0200
        Re: [PATCH v6 1/9] sched: Extend scheduler's asym packing Tim Chen <tim.c.chen@linux.intel.com> - 2016-10-26 20:20 +0200
          Re: [PATCH v6 1/9] sched: Extend scheduler's asym packing Thomas Gleixner <tglx@linutronix.de> - 2016-10-26 20:30 +0200
    [PATCH v6 7/9] acpi: bus: Enable HWP CPPC objects Tim Chen <tim.c.chen@linux.intel.com> - 2016-10-21 00:10 +0200
    [PATCH v6 9/9] cpufreq: intel_pstate: Use CPPC to get max performance Tim Chen <tim.c.chen@linux.intel.com> - 2016-10-21 00:10 +0200
    [PATCH v6 6/9] x86/sched: Add SD_ASYM_PACKING flags to x86 ITMT CPU Tim Chen <tim.c.chen@linux.intel.com> - 2016-10-21 00:10 +0200

Page 1 of 2  [1] 2  Next page →

#1505287 — [PATCH v6 0/9] Support Intel® Turbo Boost Max Technology 3.0

With Intel Turbo Boost Max Technology 3.0 (ITMT), single-threaded performance is
optimized by identifying processor's fastest core and running critical workloads
on it.
Refer to:
http://www.intel.com/content/www/us/en/architecture-and-technology/turbo-boost/turbo-boost-max-technology.html

This patchset consist of all changes required to support ITMT feature:
- Use CPPC information in Intel P-State driver to get performance information
- Scheduler enhancements
- cppc lib patches (split in to a seprate series)

This featured can be enabled by writing at runtime
# echo 1 > /proc/sys/kernel/sched_itmt_enabled
This featured can be disabled by writing at runtime
# echo 0 > /proc/sys/kernel/sched_itmt_enabled

Change Log:
v6:
- Split ITMT support control by OS into sched_set_itmt_support and
sched_clear_itmt_support functions.
- Return error when we set sysctl_sched_itmt_enabled, if system
does not support ITMT, or when we cannot create sysctl table entry.
- Minor code clean up and moving definition of sched_core_priority
to top of file.
- Rebase on v4.9-rc1

v5:
- Simplify intel_pstate for enabling ITMT feature
- Put x86_sched_itmt_flags related functions under proper
CONFIG_SCHED_MC/SMT flags
- Comment to note that rebuild_sched_domain is not needed after updating
CPU priorities.
- Define sysctl_sched_itmt_enabled to 0 when ITMT is not used in
arch/x86/include/asm/topology.h
- Dropped patch "Fix numa in package topology bug", as this is
already applied

v4:
- Split x86 multi-node numa topology bug fix and setting
of SD_ASYM flag for ITMT topology into 2 patches
- Split the sysctl changes for ITMT enablement and setting of ITMT
capability/core priorities into 2 patches.
- Avoid unnecessary rebuild of sched domains when ITMT sysctl or
capabilities are updated.
- Fix missing stub function for topology_max_packages for !SMP case.
- Rename set_sched_itmt() to sched_set_itmt_support().
- Various updates to itmt.c to eliminate goto and make logic tighter.
- Various change logs and comments update.
- intel_pstate: Split function to process cppc and enable ITMT
- intel_pstate: Just keep the cppc_perf information till we use CPPC for HWP

v3:
- Fix race clash when more than one program are enabling/disabling ITMT
- Remove group_priority_cpu macro to simplify code.
- Error reported by 0-day for compile issue on ARM

v2
- The patchset is split into two parts so that CPPC changes can be merged first
 1. Only ACPI CPPC changes (It is posted separately)
 2. ITMT changes (scheduler and Intel P-State)

- Changes in patch: sched,x86: Enable Turbo Boost Max Technology
 1. Use arch_update_cpu_topology to indicate need to completely
    rebuild sched domain when ITMT related sched domain flags change
 2. Enable client (single node) platform capable of ITMT with ITMT
    scheduling by default
 3. Implement arch_asym_cpu_priority to provide the cpu priority
    value to scheduler for asym packing.
 4. Fix a compile bug for i386 architecture.

- Changes in patch: sched: Extend scheduler's asym packing
 1. Use arch_asym_cpu_priority() to provide cpu priority
    value used for asym packing to the scheduler.

- Changes in acpi: bus: Enable HWP CPPC objects and
  acpi: bus: Set _OSC for diverse core support
  Minor code cleanup by removing #ifdef
- Changes in Kconfig for Intel P-State
  Avoid building CPPC lib for i386 for issue reported by 0-day

- Feature is enabled by default for single socket systems


Rafael J. Wysocki (1):
  cpufreq: intel_pstate: Use CPPC to get max performance

Srinivas Pandruvada (2):
  acpi: bus: Enable HWP CPPC objects
  acpi: bus: Set _OSC for diverse core support

Tim Chen (6):
  sched: Extend scheduler's asym packing
  x86/topology: Provide topology_num_packages()
  x86/topology: Define x86's arch_update_cpu_topology
  x86: Enable Intel Turbo Boost Max Technology 3.0
  x86/sysctl: Add sysctl for ITMT scheduling feature
  x86/sched: Add SD_ASYM_PACKING flags to x86 ITMT CPU

 arch/x86/Kconfig                |   9 ++
 arch/x86/include/asm/topology.h |  35 +++++++
 arch/x86/kernel/Makefile        |   1 +
 arch/x86/kernel/itmt.c          | 217 ++++++++++++++++++++++++++++++++++++++++
 arch/x86/kernel/smpboot.c       |  44 +++++++-
 drivers/acpi/bus.c              |  10 ++
 drivers/cpufreq/Kconfig.x86     |   1 +
 drivers/cpufreq/intel_pstate.c  |  56 ++++++++++-
 include/linux/acpi.h            |   1 +
 include/linux/sched.h           |   2 +
 kernel/sched/core.c             |  15 +++
 kernel/sched/fair.c             |  35 +++++--
 kernel/sched/sched.h            |   6 ++
 13 files changed, 416 insertions(+), 16 deletions(-)
 create mode 100644 arch/x86/kernel/itmt.c

-- 
2.5.5


Rafael J. Wysocki (1):
  cpufreq: intel_pstate: Use CPPC to get max performance

Srinivas Pandruvada (2):
  acpi: bus: Enable HWP CPPC objects
  acpi: bus: Set _OSC for diverse core support

Tim Chen (6):
  sched: Extend scheduler's asym packing
  x86/topology: Provide topology_num_packages()
  x86/topology: Define x86's arch_update_cpu_topology
  x86: Enable Intel Turbo Boost Max Technology 3.0
  x86/sysctl: Add sysctl for ITMT scheduling feature
  x86/sched: Add SD_ASYM_PACKING flags to x86 ITMT CPU

 arch/x86/Kconfig                |   9 ++
 arch/x86/include/asm/topology.h |  35 +++++++
 arch/x86/kernel/Makefile        |   1 +
 arch/x86/kernel/itmt.c          | 217 ++++++++++++++++++++++++++++++++++++++++
 arch/x86/kernel/smpboot.c       |  44 +++++++-
 drivers/acpi/bus.c              |  10 ++
 drivers/cpufreq/Kconfig.x86     |   1 +
 drivers/cpufreq/intel_pstate.c  |  56 ++++++++++-
 include/linux/acpi.h            |   1 +
 include/linux/sched.h           |   2 +
 kernel/sched/core.c             |  15 +++
 kernel/sched/fair.c             |  35 +++++--
 kernel/sched/sched.h            |   6 ++
 13 files changed, 416 insertions(+), 16 deletions(-)
 create mode 100644 arch/x86/kernel/itmt.c

-- 
2.5.5

[toc] | [next] | [standalone]

#1505288 — [PATCH v6 8/9] acpi: bus: Set _OSC for diverse core support

From: Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>

From: Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>

Set the OSC_SB_CPC_DIVERSE_HIGH_SUPPORT (bit 12) to enable diverse
core support.

This is required to inform BIOS the support of Intel Turbo Boost Max
Technology 3.0 feature.

Signed-off-by: Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>
Signed-off-by: Tim Chen <tim.c.chen@linux.intel.com>
---
 drivers/acpi/bus.c   | 3 +++
 include/linux/acpi.h | 1 +
 2 files changed, 4 insertions(+)

diff --git a/drivers/acpi/bus.c b/drivers/acpi/bus.c
index 2f381ba..806db0d 100644
--- a/drivers/acpi/bus.c
+++ b/drivers/acpi/bus.c
@@ -338,6 +338,9 @@ static void acpi_bus_osc_support(void)
 	}
 #endif
 
+	if (IS_ENABLED(CONFIG_SCHED_ITMT))
+		capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_CPC_DIVERSE_HIGH_SUPPORT;
+
 	if (!ghes_disable)
 		capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_APEI_SUPPORT;
 	if (ACPI_FAILURE(acpi_get_handle(NULL, "\\_SB", &handle)))
diff --git a/include/linux/acpi.h b/include/linux/acpi.h
index ddbeda6..f5da63e 100644
--- a/include/linux/acpi.h
+++ b/include/linux/acpi.h
@@ -468,6 +468,7 @@ acpi_status acpi_run_osc(acpi_handle handle, struct acpi_osc_context *context);
 #define OSC_SB_CPCV2_SUPPORT			0x00000040
 #define OSC_SB_PCLPI_SUPPORT			0x00000080
 #define OSC_SB_OSLPI_SUPPORT			0x00000100
+#define OSC_SB_CPC_DIVERSE_HIGH_SUPPORT		0x00001000
 
 extern bool osc_sb_apei_support_acked;
 extern bool osc_pc_lpi_support_confirmed;
-- 
2.5.5

[toc] | [prev] | [next] | [standalone]

#1505290 — [PATCH v6 2/9] x86/topology: Provide topology_num_packages()

Returns number of cpu packages discovered.

This information is needed to determine the size of the platform and
decide if the Intel Turbo Boost Max Technology 3.0 (ITMT) feature
should be turned on by default.  The ITMT feature is more effective on
single socket client like system that uses small number of cores most
of the time.

Signed-off-by: Tim Chen <tim.c.chen@linux.intel.com>
Signed-off-by: Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>
---
 arch/x86/include/asm/topology.h | 3 +++
 arch/x86/kernel/smpboot.c       | 5 +++++
 2 files changed, 8 insertions(+)

diff --git a/arch/x86/include/asm/topology.h b/arch/x86/include/asm/topology.h
index cf75871..3e95dfc 100644
--- a/arch/x86/include/asm/topology.h
+++ b/arch/x86/include/asm/topology.h
@@ -129,10 +129,13 @@ static inline int topology_max_smt_threads(void)
 }
 
 int topology_update_package_map(unsigned int apicid, unsigned int cpu);
+extern int topology_num_packages(void);
 extern int topology_phys_to_logical_pkg(unsigned int pkg);
 #else
 #define topology_max_packages()			(1)
 static inline int
+topology_num_packages(void) { return 1; }
+static inline int
 topology_update_package_map(unsigned int apicid, unsigned int cpu) { return 0; }
 static inline int topology_phys_to_logical_pkg(unsigned int pkg) { return 0; }
 static inline int topology_max_smt_threads(void) { return 1; }
diff --git a/arch/x86/kernel/smpboot.c b/arch/x86/kernel/smpboot.c
index 951f093..4234e52 100644
--- a/arch/x86/kernel/smpboot.c
+++ b/arch/x86/kernel/smpboot.c
@@ -295,6 +295,11 @@ int topology_update_package_map(unsigned int apicid, unsigned int cpu)
 	return 0;
 }
 
+int topology_num_packages(void)
+{
+	return logical_packages;
+}
+
 /**
  * topology_phys_to_logical_pkg - Map a physical package id to a logical
  *
-- 
2.5.5

[toc] | [prev] | [next] | [standalone]

#1505291 — [PATCH v6 4/9] x86: Enable Intel Turbo Boost Max Technology 3.0

On platforms supporting Intel Turbo Boost Max Technology 3.0, the maximum
turbo frequencies of some cores in a CPU package may be higher than for
the other cores in the same package.  In that case, better performance
(and possibly lower energy consumption as well) can be achieved by
making the scheduler prefer to run tasks on the CPUs with higher max
turbo frequencies.

To that end, set up a core priority metric to abstract the core
preferences based on the maximum turbo frequency.  In that metric,
the cores with higher maximum turbo frequencies are higher-priority
than the other cores in the same package and that causes the scheduler
to favor them when making load-balancing decisions using the asymmertic
packing approach.  At the same time, the priority of SMT threads with a
higher CPU number is reduced so as to avoid scheduling tasks on all of
the threads that belong to a favored core before all of the other cores
have been given a task to run.

The priority metric will be initialized by the P-state driver with the
help of the sched_set_itmt_core_prio() function.  The P-state driver
will also determine whether or not ITMT is supported by the platform
and will call sched_set_itmt_support() to indicate that.

Signed-off-by: Tim Chen <tim.c.chen@linux.intel.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Signed-off-by: Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>
---
 arch/x86/Kconfig                |   9 ++++
 arch/x86/include/asm/topology.h |  28 +++++++++++
 arch/x86/kernel/Makefile        |   1 +
 arch/x86/kernel/itmt.c          | 109 ++++++++++++++++++++++++++++++++++++++++
 4 files changed, 147 insertions(+)
 create mode 100644 arch/x86/kernel/itmt.c

diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig
index bada636..25950f0 100644
--- a/arch/x86/Kconfig
+++ b/arch/x86/Kconfig
@@ -939,6 +939,15 @@ config SCHED_MC
 	  making when dealing with multi-core CPU chips at a cost of slightly
 	  increased overhead in some places. If unsure say N here.
 
+config SCHED_ITMT
+	bool "Intel Turbo Boost Max Technology (ITMT) scheduler support"
+	depends on SCHED_MC && CPU_SUP_INTEL && X86_INTEL_PSTATE
+	---help---
+	  ITMT enabled scheduler support improves the CPU scheduler's decision
+	  to move tasks to cpu core that can be boosted to a higher frequency
+	  than others. It will have better performance at a cost of slightly
+	  increased overhead in task migrations. If unsure say N here.
+
 source "kernel/Kconfig.preempt"
 
 config UP_LATE_INIT
diff --git a/arch/x86/include/asm/topology.h b/arch/x86/include/asm/topology.h
index 323f61f..a73fb80 100644
--- a/arch/x86/include/asm/topology.h
+++ b/arch/x86/include/asm/topology.h
@@ -150,4 +150,32 @@ int x86_pci_root_bus_node(int bus);
 void x86_pci_root_bus_resources(int bus, struct list_head *resources);
 
 extern bool x86_topology_update;
+
+#ifdef CONFIG_SCHED_ITMT
+#include <asm/percpu.h>
+
+DECLARE_PER_CPU_READ_MOSTLY(int, sched_core_priority);
+
+/* Interface to set priority of a cpu */
+void sched_set_itmt_core_prio(int prio, int core_cpu);
+
+/* Interface to notify scheduler that system supports ITMT */
+void sched_set_itmt_support(void);
+
+/* Interface to notify scheduler that system revokes ITMT support */
+void sched_clear_itmt_support(void);
+
+#else /* CONFIG_SCHED_ITMT */
+
+static inline void sched_set_itmt_core_prio(int prio, int core_cpu)
+{
+}
+static inline void sched_set_itmt_support(void)
+{
+}
+static inline void sched_clear_itmt_support(void)
+{
+}
+#endif /* CONFIG_SCHED_ITMT */
+
 #endif /* _ASM_X86_TOPOLOGY_H */
diff --git a/arch/x86/kernel/Makefile b/arch/x86/kernel/Makefile
index 79076d7..bbd0ebc 100644
--- a/arch/x86/kernel/Makefile
+++ b/arch/x86/kernel/Makefile
@@ -123,6 +123,7 @@ obj-$(CONFIG_EFI)			+= sysfb_efi.o
 
 obj-$(CONFIG_PERF_EVENTS)		+= perf_regs.o
 obj-$(CONFIG_TRACING)			+= tracepoint.o
+obj-$(CONFIG_SCHED_ITMT)		+= itmt.o
 
 ifdef CONFIG_FRAME_POINTER
 obj-y					+= unwind_frame.o
diff --git a/arch/x86/kernel/itmt.c b/arch/x86/kernel/itmt.c
new file mode 100644
index 0000000..63c9b3e
--- /dev/null
+++ b/arch/x86/kernel/itmt.c
@@ -0,0 +1,109 @@
+/*
+ * itmt.c: Support Intel Turbo Boost Max Technology 3.0
+ *
+ * (C) Copyright 2016 Intel Corporation
+ * Author: Tim Chen <tim.c.chen@linux.intel.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; version 2
+ * of the License.
+ *
+ * On platforms supporting Intel Turbo Boost Max Technology 3.0, (ITMT),
+ * the maximum turbo frequencies of some cores in a CPU package may be
+ * higher than for the other cores in the same package.  In that case,
+ * better performance can be achieved by making the scheduler prefer
+ * to run tasks on the CPUs with higher max turbo frequencies.
+ *
+ * This file provides functions and data structures for enabling the
+ * scheduler to favor scheduling on cores can be boosted to a higher
+ * frequency under ITMT.
+ */
+
+#include <linux/sched.h>
+#include <linux/cpumask.h>
+#include <linux/cpuset.h>
+#include <asm/mutex.h>
+#include <linux/sched.h>
+#include <linux/sysctl.h>
+#include <linux/nodemask.h>
+
+static DEFINE_MUTEX(itmt_update_mutex);
+DEFINE_PER_CPU_READ_MOSTLY(int, sched_core_priority);
+
+/* Boolean to track if system has ITMT capabilities */
+static bool __read_mostly sched_itmt_capable;
+
+/**
+ * sched_set_itmt_support() - Indicate platform supports ITMT
+ *
+ * This function is used by the OS to indicate to scheduler that the platform
+ * is capable of supporting the ITMT feature.
+ *
+ * The current scheme has the pstate driver detects if the system
+ * is ITMT capable and call sched_set_itmt_support.
+ *
+ * This must be done only after sched_set_itmt_core_prio
+ * has been called to set the cpus' priorities.
+ */
+void sched_set_itmt_support(void)
+{
+	mutex_lock(&itmt_update_mutex);
+
+	sched_itmt_capable = true;
+
+	mutex_unlock(&itmt_update_mutex);
+}
+
+/**
+ * sched_clear_itmt_support() - Revoke platform's support of ITMT
+ *
+ * This function is used by the OS to indicate that it has
+ * revoked the platform's support of ITMT feature.
+ *
+ */
+void sched_clear_itmt_support(void)
+{
+	mutex_lock(&itmt_update_mutex);
+
+	sched_itmt_capable = false;
+
+	mutex_unlock(&itmt_update_mutex);
+}
+
+int arch_asym_cpu_priority(int cpu)
+{
+	return per_cpu(sched_core_priority, cpu);
+}
+
+/**
+ * sched_set_itmt_core_prio() - Set CPU priority based on ITMT
+ * @prio:	Priority of cpu core
+ * @core_cpu:	The cpu number associated with the core
+ *
+ * The pstate driver will find out the max boost frequency
+ * and call this function to set a priority proportional
+ * to the max boost frequency. CPU with higher boost
+ * frequency will receive higher priority.
+ *
+ * No need to rebuild sched domain after updating
+ * the CPU priorities. The sched domains have no
+ * dependency on CPU priorities.
+ */
+void sched_set_itmt_core_prio(int prio, int core_cpu)
+{
+	int cpu, i = 1;
+
+	for_each_cpu(cpu, topology_sibling_cpumask(core_cpu)) {
+		int smt_prio;
+
+		/*
+		 * Ensure that the siblings are moved to the end
+		 * of the priority chain and only used when
+		 * all other high priority cpus are out of capacity.
+		 */
+		smt_prio = prio * smp_num_siblings / i;
+		per_cpu(sched_core_priority, cpu) = smt_prio;
+		i++;
+	}
+}
-- 
2.5.5

[toc] | [prev] | [next] | [standalone]

#1505292 — [PATCH v6 3/9] x86/topology: Define x86's arch_update_cpu_topology

The scheduler calls arch_update_cpu_topology() to check whether the
scheduler domains have to be rebuilt.

So far x86 has no requirement for this, but the upcoming ITMT support
makes this necessary.

Request the rebuild when the x86 internal update flag is set.

Suggested-by: Morten Rasmussen <morten.rasmussen@arm.com>
Signed-off-by: Tim Chen <tim.c.chen@linux.intel.com>
Signed-off-by: Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>
---
 arch/x86/include/asm/topology.h |  1 +
 arch/x86/kernel/smpboot.c       | 11 +++++++++++
 2 files changed, 12 insertions(+)

diff --git a/arch/x86/include/asm/topology.h b/arch/x86/include/asm/topology.h
index 3e95dfc..323f61f 100644
--- a/arch/x86/include/asm/topology.h
+++ b/arch/x86/include/asm/topology.h
@@ -149,4 +149,5 @@ struct pci_bus;
 int x86_pci_root_bus_node(int bus);
 void x86_pci_root_bus_resources(int bus, struct list_head *resources);
 
+extern bool x86_topology_update;
 #endif /* _ASM_X86_TOPOLOGY_H */
diff --git a/arch/x86/kernel/smpboot.c b/arch/x86/kernel/smpboot.c
index 4234e52..ebd2655 100644
--- a/arch/x86/kernel/smpboot.c
+++ b/arch/x86/kernel/smpboot.c
@@ -109,6 +109,17 @@ static bool logical_packages_frozen __read_mostly;
 /* Maximum number of SMT threads on any online core */
 int __max_smt_threads __read_mostly;
 
+/* Flag to indicate if a complete sched domain rebuild is required */
+bool x86_topology_update;
+
+int arch_update_cpu_topology(void)
+{
+	int retval = x86_topology_update;
+
+	x86_topology_update = false;
+	return retval;
+}
+
 static inline void smpboot_setup_warm_reset_vector(unsigned long start_eip)
 {
 	unsigned long flags;
-- 
2.5.5

[toc] | [prev] | [next] | [standalone]

#1505293 — [PATCH v6 5/9] x86/sysctl: Add sysctl for ITMT scheduling feature

Intel Turbo Boost Max Technology 3.0 (ITMT) feature
allows some cores to be boosted to higher turbo
frequency than others.

Add /proc/sys/kernel/sched_itmt_enabled so operator
can enable/disable scheduling of tasks that favor cores
with higher turbo boost frequency potential.

By default, system that is ITMT capable and single
socket has this feature turned on.  It is more likely
to be lightly loaded and operates in Turbo range.

When there is a change in the ITMT scheduling operation
desired, a rebuild of the sched domain is initiated
so the scheduler can set up sched domains with appropriate
flag to enable/disable ITMT scheduling operations.

Signed-off-by: Tim Chen <tim.c.chen@linux.intel.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Signed-off-by: Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>
---
 arch/x86/include/asm/topology.h |   7 ++-
 arch/x86/kernel/itmt.c          | 110 +++++++++++++++++++++++++++++++++++++++-
 2 files changed, 114 insertions(+), 3 deletions(-)

diff --git a/arch/x86/include/asm/topology.h b/arch/x86/include/asm/topology.h
index a73fb80..46ebdd1 100644
--- a/arch/x86/include/asm/topology.h
+++ b/arch/x86/include/asm/topology.h
@@ -155,23 +155,26 @@ extern bool x86_topology_update;
 #include <asm/percpu.h>
 
 DECLARE_PER_CPU_READ_MOSTLY(int, sched_core_priority);
+extern unsigned int __read_mostly sysctl_sched_itmt_enabled;
 
 /* Interface to set priority of a cpu */
 void sched_set_itmt_core_prio(int prio, int core_cpu);
 
 /* Interface to notify scheduler that system supports ITMT */
-void sched_set_itmt_support(void);
+int sched_set_itmt_support(void);
 
 /* Interface to notify scheduler that system revokes ITMT support */
 void sched_clear_itmt_support(void);
 
 #else /* CONFIG_SCHED_ITMT */
 
+#define sysctl_sched_itmt_enabled	0
 static inline void sched_set_itmt_core_prio(int prio, int core_cpu)
 {
 }
-static inline void sched_set_itmt_support(void)
+static inline int sched_set_itmt_support(void)
 {
+	return 0;
 }
 static inline void sched_clear_itmt_support(void)
 {
diff --git a/arch/x86/kernel/itmt.c b/arch/x86/kernel/itmt.c
index 63c9b3e..e999e6e 100644
--- a/arch/x86/kernel/itmt.c
+++ b/arch/x86/kernel/itmt.c
@@ -34,6 +34,67 @@ DEFINE_PER_CPU_READ_MOSTLY(int, sched_core_priority);
 /* Boolean to track if system has ITMT capabilities */
 static bool __read_mostly sched_itmt_capable;
 
+/*
+ * Boolean to control whether we want to move processes to cpu capable
+ * of higher turbo frequency for cpus supporting Intel Turbo Boost Max
+ * Technology 3.0.
+ *
+ * It can be set via /proc/sys/kernel/sched_itmt_enabled
+ */
+unsigned int __read_mostly sysctl_sched_itmt_enabled;
+
+static int sched_itmt_update_handler(struct ctl_table *table, int write,
+			      void __user *buffer, size_t *lenp, loff_t *ppos)
+{
+	int ret;
+	unsigned int old_sysctl;
+
+	mutex_lock(&itmt_update_mutex);
+
+	if (!sched_itmt_capable) {
+		mutex_unlock(&itmt_update_mutex);
+		return -EINVAL;
+	}
+
+	old_sysctl = sysctl_sched_itmt_enabled;
+	ret = proc_dointvec_minmax(table, write, buffer, lenp, ppos);
+
+	if (!ret && write && old_sysctl != sysctl_sched_itmt_enabled) {
+		x86_topology_update = true;
+		rebuild_sched_domains();
+	}
+
+	mutex_unlock(&itmt_update_mutex);
+
+	return ret;
+}
+
+static unsigned int zero;
+static unsigned int one = 1;
+static struct ctl_table itmt_kern_table[] = {
+	{
+		.procname	= "sched_itmt_enabled",
+		.data		= &sysctl_sched_itmt_enabled,
+		.maxlen		= sizeof(unsigned int),
+		.mode		= 0644,
+		.proc_handler	= sched_itmt_update_handler,
+		.extra1		= &zero,
+		.extra2		= &one,
+	},
+	{}
+};
+
+static struct ctl_table itmt_root_table[] = {
+	{
+		.procname	= "kernel",
+		.mode		= 0555,
+		.child		= itmt_kern_table,
+	},
+	{}
+};
+
+static struct ctl_table_header *itmt_sysctl_header;
+
 /**
  * sched_set_itmt_support() - Indicate platform supports ITMT
  *
@@ -45,14 +106,44 @@ static bool __read_mostly sched_itmt_capable;
  *
  * This must be done only after sched_set_itmt_core_prio
  * has been called to set the cpus' priorities.
+ * It must not be called with cpu hot plug lock
+ * held as we need to acquire the lock to rebuild sched domains
+ * later.
+ *
+ * Return: 0 on success
  */
-void sched_set_itmt_support(void)
+int sched_set_itmt_support(void)
 {
 	mutex_lock(&itmt_update_mutex);
 
+	if (sched_itmt_capable) {
+		mutex_unlock(&itmt_update_mutex);
+		return 0;
+	}
+
+	itmt_sysctl_header = register_sysctl_table(itmt_root_table);
+	if (!itmt_sysctl_header) {
+		mutex_unlock(&itmt_update_mutex);
+		return -ENOMEM;
+	}
+
 	sched_itmt_capable = true;
 
+	/*
+	 * ITMT capability automatically enables ITMT
+	 * scheduling for small systems (single node).
+	 */
+	if (topology_num_packages() == 1)
+		sysctl_sched_itmt_enabled = 1;
+
+	if (sysctl_sched_itmt_enabled) {
+		x86_topology_update = true;
+		rebuild_sched_domains();
+	}
+
 	mutex_unlock(&itmt_update_mutex);
+
+	return 0;
 }
 
 /**
@@ -61,13 +152,30 @@ void sched_set_itmt_support(void)
  * This function is used by the OS to indicate that it has
  * revoked the platform's support of ITMT feature.
  *
+ * It must not be called with cpu hot plug lock
+ * held as we need to acquire the lock to rebuild sched domains
+ * later.
  */
 void sched_clear_itmt_support(void)
 {
 	mutex_lock(&itmt_update_mutex);
 
+	if (!sched_itmt_capable) {
+		mutex_unlock(&itmt_update_mutex);
+		return;
+	}
 	sched_itmt_capable = false;
 
+	if (itmt_sysctl_header)
+		unregister_sysctl_table(itmt_sysctl_header);
+
+	if (sysctl_sched_itmt_enabled) {
+		/* disable sched_itmt if we are no longer ITMT capable */
+		sysctl_sched_itmt_enabled = 0;
+		x86_topology_update = true;
+		rebuild_sched_domains();
+	}
+
 	mutex_unlock(&itmt_update_mutex);
 }
 
-- 
2.5.5

[toc] | [prev] | [next] | [standalone]

#1509057 — Re: [PATCH v6 5/9] x86/sysctl: Add sysctl for ITMT scheduling feature

On Thu, 20 Oct 2016, Tim Chen wrote:
>  
> +	if (itmt_sysctl_header)
> +		unregister_sysctl_table(itmt_sysctl_header);

What sets itmt_sysctl_header to NULL?

Thanks,

	tglx

[toc] | [prev] | [next] | [standalone]

#1509675 — Re: [PATCH v6 5/9] x86/sysctl: Add sysctl for ITMT scheduling feature

On Wed, 2016-10-26 at 12:52 +0200, Thomas Gleixner wrote:
> On Thu, 20 Oct 2016, Tim Chen wrote:
> > 
> >  
> > +	if (itmt_sysctl_header)
> > +		unregister_sysctl_table(itmt_sysctl_header);
> What sets itmt_sysctl_header to NULL?
> 

If the registration of the itmt sysctl table has failed, it will
be NULL.

Tim

[toc] | [prev] | [next] | [standalone]

#1509688 — Re: [PATCH v6 5/9] x86/sysctl: Add sysctl for ITMT scheduling feature

[Multipart message — attachments visible in raw view] — view raw

On Wed, 26 Oct 2016, Tim Chen wrote:

> On Wed, 2016-10-26 at 12:52 +0200, Thomas Gleixner wrote:
> > On Thu, 20 Oct 2016, Tim Chen wrote:
> > > 
> > >  
> > > +	if (itmt_sysctl_header)
> > > +		unregister_sysctl_table(itmt_sysctl_header);
> > What sets itmt_sysctl_header to NULL?
> > 
> 
> If the registration of the itmt sysctl table has failed, it will
> be NULL.

And what clears it _AFTER_ the deregistration? Nothing, AFAICT.

[toc] | [prev] | [next] | [standalone]

#1509734 — Re: [PATCH v6 5/9] x86/sysctl: Add sysctl for ITMT scheduling feature

On Wed, 2016-10-26 at 20:11 +0200, Thomas Gleixner wrote:
> On Wed, 26 Oct 2016, Tim Chen wrote:
> 
> > 
> > On Wed, 2016-10-26 at 12:52 +0200, Thomas Gleixner wrote:
> > > 
> > > On Thu, 20 Oct 2016, Tim Chen wrote:
> > > > 
> > > > 
> > > >  
> > > > +	if (itmt_sysctl_header)
> > > > +		unregister_sysctl_table(itmt_sysctl_header);
> > > What sets itmt_sysctl_header to NULL?
> > > 
> > If the registration of the itmt sysctl table has failed, it will
> > be NULL.
> And what clears it _AFTER_ the deregistration? Nothing, AFAICT.

Ok. I'll clear itmt_sysctl_header here.

Thanks.

Tim

[toc] | [prev] | [next] | [standalone]

#1509060 — Re: [PATCH v6 5/9] x86/sysctl: Add sysctl for ITMT scheduling feature

On Thu, 20 Oct 2016, Tim Chen wrote:
> +static int sched_itmt_update_handler(struct ctl_table *table, int write,
> +			      void __user *buffer, size_t *lenp, loff_t *ppos)

Please align the arguments proper

static int
sched_itmt_update_handler(struct ctl_table *table, int write,
			  void __user *buffer, size_t *lenp, loff_t *ppos)

> +{
> +	int ret;
> +	unsigned int old_sysctl;

	unsigned int old_sysctl;
	int ret;

Please. It's way simpler to read.

> -void sched_set_itmt_support(void)
> +int sched_set_itmt_support(void)
>  {
>  	mutex_lock(&itmt_update_mutex);
>  
> +	if (sched_itmt_capable) {
> +		mutex_unlock(&itmt_update_mutex);
> +		return 0;
> +	}
> +
> +	itmt_sysctl_header = register_sysctl_table(itmt_root_table);
> +	if (!itmt_sysctl_header) {
> +		mutex_unlock(&itmt_update_mutex);
> +		return -ENOMEM;
> +	}
> +
>  	sched_itmt_capable = true;
>  
> +	/*
> +	 * ITMT capability automatically enables ITMT
> +	 * scheduling for small systems (single node).
> +	 */
> +	if (topology_num_packages() == 1)
> +		sysctl_sched_itmt_enabled = 1;

I really hate this. This is policy and the kernel should not impose
policy. Why would I like to have this enforced on my single socket XEON
server?

> +	if (sysctl_sched_itmt_enabled) {

Why would sysctl_sched_itmt_enabled be true at this point, aside of the
above policy imposement?

Thanks,

	tglx

[toc] | [prev] | [next] | [standalone]

#1509094 — Re: [PATCH v6 5/9] x86/sysctl: Add sysctl for ITMT scheduling feature

On Wed, 26 Oct 2016, Peter Zijlstra wrote:
> On Wed, Oct 26, 2016 at 12:49:36PM +0200, Thomas Gleixner wrote:
> 
> > > +	/*
> > > +	 * ITMT capability automatically enables ITMT
> > > +	 * scheduling for small systems (single node).
> > > +	 */
> > > +	if (topology_num_packages() == 1)
> > > +		sysctl_sched_itmt_enabled = 1;
> > 
> > I really hate this. This is policy and the kernel should not impose
> > policy. Why would I like to have this enforced on my single socket XEON
> > server?
> 
> So this really wants to be enabled by default; otherwise nobody will use
> this, and it really does help single threaded workloads.

Fair enough. Then this wants to be documented.
 
> There were reservations on the multi-socket case of ITMT, maybe it would
> help to spell those out in great detail here. That is, have the comment
> explain the policy instead of simply stating what the code does (which
> is always bad comment policy, you can read the code just fine).

What is the objection for multi sockets? If it improves the behaviour then
why would this be a bad thing for multi sockets?

Thanks,

	tglx

[toc] | [prev] | [next] | [standalone]

#1509625 — Re: [PATCH v6 5/9] x86/sysctl: Add sysctl for ITMT scheduling feature

On Wed, 2016-10-26 at 13:24 +0200, Thomas Gleixner wrote:
> On Wed, 26 Oct 2016, Peter Zijlstra wrote:
> > 
> > On Wed, Oct 26, 2016 at 12:49:36PM +0200, Thomas Gleixner wrote:
> > 
> > > 
> > > > 
> > > > +	/*
> > > > +	 * ITMT capability automatically enables ITMT
> > > > +	 * scheduling for small systems (single node).
> > > > +	 */
> > > > +	if (topology_num_packages() == 1)
> > > > +		sysctl_sched_itmt_enabled = 1;
> > > I really hate this. This is policy and the kernel should not impose
> > > policy. Why would I like to have this enforced on my single socket XEON
> > > server?
> > So this really wants to be enabled by default; otherwise nobody will use
> > this, and it really does help single threaded workloads.
> Fair enough. Then this wants to be documented.
>  
> > 
> > There were reservations on the multi-socket case of ITMT, maybe it would
> > help to spell those out in great detail here. That is, have the comment
> > explain the policy instead of simply stating what the code does (which
> > is always bad comment policy, you can read the code just fine).
> What is the objection for multi sockets? If it improves the behaviour then
> why would this be a bad thing for multi sockets?

For multi-socket (server system), it is much more likely that they will
have multiple cpus in a socket busy and not run in turbo mode. So the extra
work in migrating the workload to the one with extra headroom will
not make use of those headroom in that scenario.  I will update the comment
to reflect this policy.

See also our previous discussions: http://lkml.iu.edu/hypermail/linux/kernel/1609.1/03381.html

Tim

[toc] | [prev] | [next] | [standalone]

#1509677 — Re: [PATCH v6 5/9] x86/sysctl: Add sysctl for ITMT scheduling feature

[Multipart message — attachments visible in raw view] — view raw

On Wed, 26 Oct 2016, Tim Chen wrote:
> On Wed, 2016-10-26 at 13:24 +0200, Thomas Gleixner wrote:
> > > There were reservations on the multi-socket case of ITMT, maybe it would
> > > help to spell those out in great detail here. That is, have the comment
> > > explain the policy instead of simply stating what the code does (which
> > > is always bad comment policy, you can read the code just fine).
> > What is the objection for multi sockets? If it improves the behaviour then
> > why would this be a bad thing for multi sockets?
> 
> For multi-socket (server system), it is much more likely that they will
> have multiple cpus in a socket busy and not run in turbo mode. So the extra
> work in migrating the workload to the one with extra headroom will
> not make use of those headroom in that scenario.  I will update the comment
> to reflect this policy.

So on a single socket server system the extra work does not matter, right?
Don't tell me that single socket server systems are irrelevant. Intel is
actively promoting single socket CPUs, like XEON D, for high densitiy
servers...

Instead of handwaving arguments I prefer a proper analysis of what the
overhead is and why it is not a good thing for loaded servers in general.

Then instead of slapping half baken heuristics into the code, we should sit
down and think a bit harder about it.

Thanks,

	tglx

[toc] | [prev] | [next] | [standalone]

#1509101 — Re: [PATCH v6 5/9] x86/sysctl: Add sysctl for ITMT scheduling feature

On Wed, Oct 26, 2016 at 12:49:36PM +0200, Thomas Gleixner wrote:

> > +	/*
> > +	 * ITMT capability automatically enables ITMT
> > +	 * scheduling for small systems (single node).
> > +	 */
> > +	if (topology_num_packages() == 1)
> > +		sysctl_sched_itmt_enabled = 1;
> 
> I really hate this. This is policy and the kernel should not impose
> policy. Why would I like to have this enforced on my single socket XEON
> server?

So this really wants to be enabled by default; otherwise nobody will use
this, and it really does help single threaded workloads.

There were reservations on the multi-socket case of ITMT, maybe it would
help to spell those out in great detail here. That is, have the comment
explain the policy instead of simply stating what the code does (which
is always bad comment policy, you can read the code just fine).

[toc] | [prev] | [next] | [standalone]

#1509666 — Re: [PATCH v6 5/9] x86/sysctl: Add sysctl for ITMT scheduling feature

On Wed, 2016-10-26 at 12:49 +0200, Thomas Gleixner wrote:
> On Thu, 20 Oct 2016, Tim Chen wrote:
> > 
> > +static int sched_itmt_update_handler(struct ctl_table *table, int write,
> > +			      void __user *buffer, size_t *lenp, loff_t *ppos)
> Please align the arguments proper
> 
> static int
> sched_itmt_update_handler(struct ctl_table *table, int write,
> 			  void __user *buffer, size_t *lenp, loff_t *ppos)
> 

Okay.

> > 
> > +{
> > +	int ret;
> > +	unsigned int old_sysctl;
> 	unsigned int old_sysctl;
> 	int ret;
> 
> Please. It's way simpler to read.

Sure.

> 
> > 
> > -void sched_set_itmt_support(void)
> > +int sched_set_itmt_support(void)
> >  {
> >  	mutex_lock(&itmt_update_mutex);
> >  
> > +	if (sched_itmt_capable) {
> > +		mutex_unlock(&itmt_update_mutex);
> > +		return 0;
> > +	}
> > +
> > +	itmt_sysctl_header = register_sysctl_table(itmt_root_table);
> > +	if (!itmt_sysctl_header) {
> > +		mutex_unlock(&itmt_update_mutex);
> > +		return -ENOMEM;
> > +	}
> > +
> >  	sched_itmt_capable = true;
> >  
> > +	/*
> > +	 * ITMT capability automatically enables ITMT
> > +	 * scheduling for small systems (single node).
> > +	 */
> > +	if (topology_num_packages() == 1)
> > +		sysctl_sched_itmt_enabled = 1;
> I really hate this. This is policy and the kernel should not impose
> policy. Why would I like to have this enforced on my single socket XEON
> server?
> 
> > 
> > +	if (sysctl_sched_itmt_enabled) {
> Why would sysctl_sched_itmt_enabled be true at this point, aside of the
> above policy imposement?

That's true, it will only be enabled for the above case.  I can merge
it into the if check above.


Tim

[toc] | [prev] | [next] | [standalone]

#1505294 — [PATCH v6 1/9] sched: Extend scheduler's asym packing

We generalize the scheduler's asym packing to provide an ordering
of the cpu beyond just the cpu number.  This allows the use of the
ASYM_PACKING scheduler machinery to move loads to preferred CPU in a
sched domain. The preference is defined with the cpu priority
given by arch_asym_cpu_priority(cpu).

We also record the most preferred cpu in a sched group when
we build the cpu's capacity for fast lookup of preferred cpu
during load balancing.

Signed-off-by: Tim Chen <tim.c.chen@linux.intel.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Signed-off-by: Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>
---
 include/linux/sched.h |  2 ++
 kernel/sched/core.c   | 15 +++++++++++++++
 kernel/sched/fair.c   | 35 ++++++++++++++++++++++++-----------
 kernel/sched/sched.h  |  6 ++++++
 4 files changed, 47 insertions(+), 11 deletions(-)

diff --git a/include/linux/sched.h b/include/linux/sched.h
index 348f51b..75d96d6 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -1057,6 +1057,8 @@ static inline int cpu_numa_flags(void)
 }
 #endif
 
+int arch_asym_cpu_priority(int cpu);
+
 struct sched_domain_attr {
 	int relax_domain_level;
 };
diff --git a/kernel/sched/core.c b/kernel/sched/core.c
index 94732d1..4465410 100644
--- a/kernel/sched/core.c
+++ b/kernel/sched/core.c
@@ -6307,7 +6307,22 @@ static void init_sched_groups_capacity(int cpu, struct sched_domain *sd)
 	WARN_ON(!sg);
 
 	do {
+		int cpu, max_cpu = -1;
+
 		sg->group_weight = cpumask_weight(sched_group_cpus(sg));
+
+		if (!(sd->flags & SD_ASYM_PACKING))
+			goto next;
+
+		for_each_cpu(cpu, sched_group_cpus(sg)) {
+			if (max_cpu < 0)
+				max_cpu = cpu;
+			else if (sched_asym_prefer(cpu, max_cpu))
+				max_cpu = cpu;
+		}
+		sg->asym_prefer_cpu = max_cpu;
+
+next:
 		sg = sg->next;
 	} while (sg != sd->groups);
 
diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
index 2d4ad72..f50e4d7 100644
--- a/kernel/sched/fair.c
+++ b/kernel/sched/fair.c
@@ -100,6 +100,16 @@ const_debug unsigned int sysctl_sched_migration_cost = 500000UL;
  */
 unsigned int __read_mostly sysctl_sched_shares_window = 10000000UL;
 
+#ifdef CONFIG_SMP
+/*
+ * For asym packing, by default the lower numbered cpu has higher priority.
+ */
+int __weak arch_asym_cpu_priority(int cpu)
+{
+	return -cpu;
+}
+#endif
+
 #ifdef CONFIG_CFS_BANDWIDTH
 /*
  * Amount of runtime to allocate from global (tg) to local (per-cfs_rq) pool
@@ -7101,16 +7111,18 @@ static bool update_sd_pick_busiest(struct lb_env *env,
 	if (env->idle == CPU_NOT_IDLE)
 		return true;
 	/*
-	 * ASYM_PACKING needs to move all the work to the lowest
-	 * numbered CPUs in the group, therefore mark all groups
-	 * higher than ourself as busy.
+	 * ASYM_PACKING needs to move all the work to the highest
+	 * prority CPUs in the group, therefore mark all groups
+	 * of lower priority than ourself as busy.
 	 */
-	if (sgs->sum_nr_running && env->dst_cpu < group_first_cpu(sg)) {
+	if (sgs->sum_nr_running &&
+	    sched_asym_prefer(env->dst_cpu, sg->asym_prefer_cpu)) {
 		if (!sds->busiest)
 			return true;
 
-		/* Prefer to move from highest possible cpu's work */
-		if (group_first_cpu(sds->busiest) < group_first_cpu(sg))
+		/* Prefer to move from lowest priority cpu's work */
+		if (sched_asym_prefer(sds->busiest->asym_prefer_cpu,
+				      sg->asym_prefer_cpu))
 			return true;
 	}
 
@@ -7262,8 +7274,8 @@ static int check_asym_packing(struct lb_env *env, struct sd_lb_stats *sds)
 	if (!sds->busiest)
 		return 0;
 
-	busiest_cpu = group_first_cpu(sds->busiest);
-	if (env->dst_cpu > busiest_cpu)
+	busiest_cpu = sds->busiest->asym_prefer_cpu;
+	if (sched_asym_prefer(busiest_cpu, env->dst_cpu))
 		return 0;
 
 	env->imbalance = DIV_ROUND_CLOSEST(
@@ -7601,10 +7613,11 @@ static int need_active_balance(struct lb_env *env)
 
 		/*
 		 * ASYM_PACKING needs to force migrate tasks from busy but
-		 * higher numbered CPUs in order to pack all tasks in the
-		 * lowest numbered CPUs.
+		 * lower priority CPUs in order to pack all tasks in the
+		 * highest priority CPUs.
 		 */
-		if ((sd->flags & SD_ASYM_PACKING) && env->src_cpu > env->dst_cpu)
+		if ((sd->flags & SD_ASYM_PACKING) &&
+		    sched_asym_prefer(env->dst_cpu, env->src_cpu))
 			return 1;
 	}
 
diff --git a/kernel/sched/sched.h b/kernel/sched/sched.h
index 055f935..cd3d413 100644
--- a/kernel/sched/sched.h
+++ b/kernel/sched/sched.h
@@ -539,6 +539,11 @@ struct dl_rq {
 
 #ifdef CONFIG_SMP
 
+static inline bool sched_asym_prefer(int a, int b)
+{
+	return arch_asym_cpu_priority(a) > arch_asym_cpu_priority(b);
+}
+
 /*
  * We add the notion of a root-domain which will be used to define per-domain
  * variables. Each exclusive cpuset essentially defines an island domain by
@@ -905,6 +910,7 @@ struct sched_group {
 
 	unsigned int group_weight;
 	struct sched_group_capacity *sgc;
+	int asym_prefer_cpu;		/* cpu of highest priority in group */
 
 	/*
 	 * The CPUs this group covers.
-- 
2.5.5

[toc] | [prev] | [next] | [standalone]

#1509043 — Re: [PATCH v6 1/9] sched: Extend scheduler's asym packing

On Thu, 20 Oct 2016, Tim Chen wrote:

> We generalize the scheduler's asym packing to provide an ordering
> of the cpu beyond just the cpu number.  This allows the use of the
> ASYM_PACKING scheduler machinery to move loads to preferred CPU in a
> sched domain. The preference is defined with the cpu priority
> given by arch_asym_cpu_priority(cpu).
> 
> We also record the most preferred cpu in a sched group when
> we build the cpu's capacity for fast lookup of preferred cpu
> during load balancing.
> 
> Signed-off-by: Tim Chen <tim.c.chen@linux.intel.com>
> Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
> Signed-off-by: Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>

This SOB-chain is bogus. Same for all other patches.

Thanks,

	tglx

[toc] | [prev] | [next] | [standalone]

#1509681 — Re: [PATCH v6 1/9] sched: Extend scheduler's asym packing

On Wed, 2016-10-26 at 12:27 +0200, Thomas Gleixner wrote:
> On Thu, 20 Oct 2016, Tim Chen wrote:
> 
> > 
> > We generalize the scheduler's asym packing to provide an ordering
> > of the cpu beyond just the cpu number.  This allows the use of the
> > ASYM_PACKING scheduler machinery to move loads to preferred CPU in a
> > sched domain. The preference is defined with the cpu priority
> > given by arch_asym_cpu_priority(cpu).
> > 
> > We also record the most preferred cpu in a sched group when
> > we build the cpu's capacity for fast lookup of preferred cpu
> > during load balancing.
> > 
> > Signed-off-by: Tim Chen <tim.c.chen@linux.intel.com>
> > Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
> > Signed-off-by: Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>
> This SOB-chain is bogus. Same for all other patches.
> 

I am the primary author of the patch so I have my sign-off on top.  There
were also much internal discussions/reviews between myself, Peter and Srinivas,
before we post the first version of this patch.
I incorporated their inputs into the patch and added their sign-offs.  

Can you be more explicit on why you think the sign-offs here are bogus?

Thanks.

Tim

  

[toc] | [prev] | [next] | [standalone]

#1509691 — Re: [PATCH v6 1/9] sched: Extend scheduler's asym packing

[Multipart message — attachments visible in raw view] — view raw

On Wed, 26 Oct 2016, Tim Chen wrote:
> On Wed, 2016-10-26 at 12:27 +0200, Thomas Gleixner wrote:
> > On Thu, 20 Oct 2016, Tim Chen wrote:
> > 
> > > 
> > > We generalize the scheduler's asym packing to provide an ordering
> > > of the cpu beyond just the cpu number.  This allows the use of the
> > > ASYM_PACKING scheduler machinery to move loads to preferred CPU in a
> > > sched domain. The preference is defined with the cpu priority
> > > given by arch_asym_cpu_priority(cpu).
> > > 
> > > We also record the most preferred cpu in a sched group when
> > > we build the cpu's capacity for fast lookup of preferred cpu
> > > during load balancing.
> > > 
> > > Signed-off-by: Tim Chen <tim.c.chen@linux.intel.com>
> > > Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
> > > Signed-off-by: Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>
> > This SOB-chain is bogus. Same for all other patches.
> > 
> 
> I am the primary author of the patch so I have my sign-off on top.  There
> were also much internal discussions/reviews between myself, Peter and Srinivas,
> before we post the first version of this patch.
> I incorporated their inputs into the patch and added their sign-offs.  
> 
> Can you be more explicit on why you think the sign-offs here are bogus?

Because SOB chains document the way a patch takes from the author to the
kernel. The above says:

You authored the patch and sent it to Peter who sent it to Srinivas. So how
does it end up sent from you in my inbox?

We have no formal tag for co developed patches, but it's common practice to
either acknowledge contributions from others in free text form or use a
non-documented tag like 'Co-developed-by:' or 'Co-authored-by:'.

Thanks,

	tglx

[toc] | [prev] | [next] | [standalone]

Page 1 of 2  [1] 2  Next page →

Back to top | Article view | linux.kernel

csiph-web