Skip to contentSkip to conversation

oprofile: Performance counter multiplexing

PATCH In review Robert Richter 7 participants 42 messages Jul 28, 2009 – Mar 8, 2010 1 message not in the archive x86

lore
Share & tools
lore
#0 lore raw

cover oprofile: Performance counter multiplexing

This patch series introduces performance counter multiplexing for oprofile.

The number of hardware counters is limited. The multiplexing feature enables OProfile to gather more events than counters are provided by the hardware. This is realized by switching between events at an user specified time interval.

A new file (/dev/oprofile/time_slice) is added for the user to specify the timer interval in ms. If the number of events to profile is higher than the number of hardware counters available, the patch will schedule a work queue that switches the event counter and re-writes the different sets of values into it. The switching mechanism needs to be implemented for each architecture to support multiplexing. This patch series only implements AMD CPU support, but multiplexing can be easily extended for other models and architectures.

The patch set includes the initial patch from Jason Yeh and many code improvements and reworks on top. It evolved over time and documents its development. Thus, for review also the enclosed overall diff might be useful.

The patches can be pulled from:

git://git.kernel.org/pub/scm/linux/kernel/git/rric/oprofile.git mux

-Robert

The following changes since commit 8045a4c293d36c61656a20d581b11f7f0cd7acd5:
Robert Richter (1):
x86/oprofile: Fix cast of counter value

are available in the git repository at:

git://git.kernel.org/pub/scm/linux/kernel/git/rric/oprofile.git mux

Jason Yeh (1):
oprofile: Implement performance counter multiplexing

Robert Richter (25):
x86/oprofile: Rework and simplify nmi_cpu_setup() x86/oprofile: Whitespaces changes only
x86/oprofile: Fix usage of NUM_CONTROLS/NUM_COUNTERS macros x86/oprofile: Use per_cpu() instead of __get_cpu_var() x86/oprofile: Fix initialization of switch_index
oprofile: oprofile_set_timeout(), return with error for invalid args
oprofile: Rename variable timeout_jiffies and move to oprofile_files.c
oprofile: Remove oprofile_multiplexing_init()
oprofile: Grouping multiplexing code in oprof.c
oprofile: Introduce op_x86_phys_to_virt()
oprofile: Grouping multiplexing code in op_model_amd.c x86/oprofile: Implement multiplexing setup/shutdown functions x86/oprofile: Moving nmi_setup_cpu_mux() in nmi_int.c x86/oprofile: Moving nmi_cpu_save/restore_mpx_registers() in nmi_int.c x86/oprofile: Moving nmi_cpu_switch() in nmi_int.c x86/oprofile: Remove const qualifier from struct op_x86_model_spec x86/oprofile: Remove unused num_virt_controls from struct op_x86_model_spec x86/oprofile: Modify initialization of num_virt_counters x86/oprofile: Add function has_mux() to check multiplexing support x86/oprofile: Enable multiplexing only if the model supports it x86/oprofile: Implement mux_clone()
oprofile: Adding switch counter to oprofile statistic variables x86/oprofile: Implement op_x86_virt_to_phys()
x86/oprofile: Add counter reservation check for virtual counters x86/oprofile: Small coding style fixes

 arch/Kconfig                      |   12 ++
 arch/x86/oprofile/nmi_int.c       |  307 +++++++++++++++++++++++++++++--------
 arch/x86/oprofile/op_counter.h    |    2 +-
 arch/x86/oprofile/op_model_amd.c  |  127 ++++++++++++----
 arch/x86/oprofile/op_model_p4.c   |   12 +-
 arch/x86/oprofile/op_model_ppro.c |   10 +-
 arch/x86/oprofile/op_x86_model.h  |   16 ++-
 drivers/oprofile/oprof.c          |   71 +++++++++-
 drivers/oprofile/oprof.h          |    3 +
 drivers/oprofile/oprofile_files.c |   46 ++++++
 drivers/oprofile/oprofile_stats.c |    5 +
 drivers/oprofile/oprofile_stats.h |    1 +
 include/linux/oprofile.h          |    3 +
 13 files changed, 501 insertions(+), 114 deletions(-)
arch/Kconfig +12 -0
index 99193b1..beea3cc 100644
@@ -30,6 +30,18 @@ config OPROFILE_IBS
 
 	  If unsure, say N.
 
+config OPROFILE_EVENT_MULTIPLEX
+	bool "OProfile multiplexing support (EXPERIMENTAL)"
+	default n
+	depends on OPROFILE && X86
+	help
+	  The number of hardware counters is limited. The multiplexing
+	  feature enables OProfile to gather more events than counters
+	  are provided by the hardware. This is realized by switching
+	  between events at an user specified time interval.
+
+	  If unsure, say N.
+
 config HAVE_OPROFILE
 	bool
 
arch/x86/oprofile/nmi_int.c +239 -68

437 lines not on this page · raw message

arch/x86/oprofile/op_counter.h +1 -1
index 91b6a11..e28398d 100644
@@ -10,7 +10,7 @@
 #ifndef OP_COUNTER_H
 #define OP_COUNTER_H
 
-#define OP_MAX_COUNTER 8
+#define OP_MAX_COUNTER 32
 
 /* Per-perfctr configuration as set via
  * oprofilefs.
arch/x86/oprofile/op_model_amd.c +98 -29

218 lines not on this page · raw message

arch/x86/oprofile/op_model_p4.c +6 -6
index 9db9e36..ac6b354 100644
@@ -558,7 +558,7 @@ static void p4_setup_ctrs(struct op_x86_model_spec const *model,
 	}
 
 	/* clear the cccrs we will use */
-	for (i = 0 ; i < num_counters ; i++) {
+	for (i = 0; i < num_counters; i++) {
 		if (unlikely(!msrs->controls[i].addr))
 			continue;
 		rdmsr(p4_counters[VIRT_CTR(stag, i)].cccr_address, low, high);
@@ -575,7 +575,7 @@ static void p4_setup_ctrs(struct op_x86_model_spec const *model,
 	}
 
 	/* setup all counters */
-	for (i = 0 ; i < num_counters ; ++i) {
+	for (i = 0; i < num_counters; ++i) {
 		if (counter_config[i].enabled && msrs->controls[i].addr) {
 			reset_value[i] = counter_config[i].count;
 			pmc_setup_one_p4_counter(i);
@@ -678,7 +678,7 @@ static void p4_shutdown(struct op_msrs const * const msrs)
 {
 	int i;
 
-	for (i = 0 ; i < num_counters ; ++i) {
+	for (i = 0; i < num_counters; ++i) {
 		if (msrs->counters[i].addr)
 			release_perfctr_nmi(msrs->counters[i].addr);
 	}
@@ -687,7 +687,7 @@ static void p4_shutdown(struct op_msrs const * const msrs)
 	 * conjunction with the counter registers (hence the starting offset).
 	 * This saves a few bits.
 	 */
-	for (i = num_counters ; i < num_controls ; ++i) {
+	for (i = num_counters; i < num_controls; ++i) {
 		if (msrs->controls[i].addr)
 			release_evntsel_nmi(msrs->controls[i].addr);
 	}
@@ -695,7 +695,7 @@ static void p4_shutdown(struct op_msrs const * const msrs)
 
 
 #ifdef CONFIG_SMP
-struct op_x86_model_spec const op_p4_ht2_spec = {
+struct op_x86_model_spec op_p4_ht2_spec = {
 	.num_counters		= NUM_COUNTERS_HT2,
 	.num_controls		= NUM_CONTROLS_HT2,
 	.fill_in_addresses	= &p4_fill_in_addresses,
@@ -707,7 +707,7 @@ struct op_x86_model_spec const op_p4_ht2_spec = {
 };
 #endif
 
-struct op_x86_model_spec const op_p4_spec = {
+struct op_x86_model_spec op_p4_spec = {
 	.num_counters		= NUM_COUNTERS_NON_HT,
 	.num_controls		= NUM_CONTROLS_NON_HT,
 	.fill_in_addresses	= &p4_fill_in_addresses,
arch/x86/oprofile/op_model_ppro.c +5 -5
index cd72d5c..4899215 100644
@@ -81,7 +81,7 @@ static void ppro_setup_ctrs(struct op_x86_model_spec const *model,
 	}
 
 	/* clear all counters */
-	for (i = 0 ; i < num_counters; ++i) {
+	for (i = 0; i < num_counters; ++i) {
 		if (unlikely(!msrs->controls[i].addr))
 			continue;
 		rdmsrl(msrs->controls[i].addr, val);
@@ -125,7 +125,7 @@ static int ppro_check_ctrs(struct pt_regs * const regs,
 	if (unlikely(!reset_value))
 		goto out;
 
-	for (i = 0 ; i < num_counters; ++i) {
+	for (i = 0; i < num_counters; ++i) {
 		if (!reset_value[i])
 			continue;
 		rdmsrl(msrs->counters[i].addr, val);
@@ -188,11 +188,11 @@ static void ppro_shutdown(struct op_msrs const * const msrs)
 {
 	int i;
 
-	for (i = 0 ; i < num_counters ; ++i) {
+	for (i = 0; i < num_counters; ++i) {
 		if (msrs->counters[i].addr)
 			release_perfctr_nmi(MSR_P6_PERFCTR0 + i);
 	}
-	for (i = 0 ; i < num_counters ; ++i) {
+	for (i = 0; i < num_counters; ++i) {
 		if (msrs->controls[i].addr)
 			release_evntsel_nmi(MSR_P6_EVNTSEL0 + i);
 	}
@@ -203,7 +203,7 @@ static void ppro_shutdown(struct op_msrs const * const msrs)
 }
 
 
-struct op_x86_model_spec const op_ppro_spec = {
+struct op_x86_model_spec op_ppro_spec = {
 	.num_counters		= 2,
 	.num_controls		= 2,
 	.reserved		= MSR_PPRO_EVENTSEL_RESERVED,
arch/x86/oprofile/op_x86_model.h +12 -4
index 5054898..b837761 100644
@@ -23,6 +23,7 @@ struct op_msr {
 struct op_msrs {
 	struct op_msr *counters;
 	struct op_msr *controls;
+	struct op_msr *multiplex;
 };
 
 struct pt_regs;
@@ -35,6 +36,7 @@ struct oprofile_operations;
 struct op_x86_model_spec {
 	unsigned int	num_counters;
 	unsigned int	num_controls;
+	unsigned int	num_virt_counters;
 	u64		reserved;
 	u16		event_mask;
 	int		(*init)(struct oprofile_operations *ops);
@@ -47,17 +49,23 @@ struct op_x86_model_spec {
 	void		(*start)(struct op_msrs const * const msrs);
 	void		(*stop)(struct op_msrs const * const msrs);
 	void		(*shutdown)(struct op_msrs const * const msrs);
+#ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
+	void		(*switch_ctrl)(struct op_x86_model_spec const *model,
+				       struct op_msrs const * const msrs);
+#endif
 };
 
 struct op_counter_config;
 
 extern u64 op_x86_get_ctrl(struct op_x86_model_spec const *model,
 			   struct op_counter_config *counter_config);
+extern int op_x86_phys_to_virt(int phys);
+extern int op_x86_virt_to_phys(int virt);
 
-extern struct op_x86_model_spec const op_ppro_spec;
-extern struct op_x86_model_spec const op_p4_spec;
-extern struct op_x86_model_spec const op_p4_ht2_spec;
-extern struct op_x86_model_spec const op_amd_spec;
+extern struct op_x86_model_spec op_ppro_spec;
+extern struct op_x86_model_spec op_p4_spec;
+extern struct op_x86_model_spec op_p4_ht2_spec;
+extern struct op_x86_model_spec op_amd_spec;
 extern struct op_x86_model_spec op_arch_perfmon_spec;
 
 #endif /* OP_X86_MODEL_H */
drivers/oprofile/oprof.c +70 -1

101 lines not on this page · raw message

drivers/oprofile/oprof.h +3 -0
index c288d3c..cb92f5c 100644
@@ -24,6 +24,8 @@ struct oprofile_operations;
 extern unsigned long oprofile_buffer_size;
 extern unsigned long oprofile_cpu_buffer_size;
 extern unsigned long oprofile_buffer_watershed;
+extern unsigned long oprofile_time_slice;
+
 extern struct oprofile_operations oprofile_ops;
 extern unsigned long oprofile_started;
 extern unsigned long oprofile_backtrace_depth;
@@ -35,5 +37,6 @@ void oprofile_create_files(struct super_block *sb, struct dentry *root);
 void oprofile_timer_init(struct oprofile_operations *ops);
 
 int oprofile_set_backtrace(unsigned long depth);
+int oprofile_set_timeout(unsigned long time);
 
 #endif /* OPROF_H */
drivers/oprofile/oprofile_files.c +46 -0

74 lines not on this page · raw message

drivers/oprofile/oprofile_stats.c +5 -0
index 3c2270a..61689e8 100644
@@ -34,6 +34,7 @@ void oprofile_reset_stats(void)
 	atomic_set(&oprofile_stats.sample_lost_no_mapping, 0);
 	atomic_set(&oprofile_stats.event_lost_overflow, 0);
 	atomic_set(&oprofile_stats.bt_lost_no_mapping, 0);
+	atomic_set(&oprofile_stats.multiplex_counter, 0);
 }
 
 
@@ -76,4 +77,8 @@ void oprofile_create_stats_files(struct super_block *sb, struct dentry *root)
 		&oprofile_stats.event_lost_overflow);
 	oprofilefs_create_ro_atomic(sb, dir, "bt_lost_no_mapping",
 		&oprofile_stats.bt_lost_no_mapping);
+#ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
+	oprofilefs_create_ro_atomic(sb, dir, "multiplex_counter",
+		&oprofile_stats.multiplex_counter);
+#endif
 }
drivers/oprofile/oprofile_stats.h +1 -0
index 3da0d08..0b54e46 100644
@@ -17,6 +17,7 @@ struct oprofile_stat_struct {
 	atomic_t sample_lost_no_mapping;
 	atomic_t bt_lost_no_mapping;
 	atomic_t event_lost_overflow;
+	atomic_t multiplex_counter;
 };
 
 extern struct oprofile_stat_struct oprofile_stats;
include/linux/oprofile.h +3 -0
index d68d2ed..5171639 100644
@@ -67,6 +67,9 @@ struct oprofile_operations {
 
 	/* Initiate a stack backtrace. Optional. */
 	void (*backtrace)(struct pt_regs * const regs, unsigned int depth);
+
+	/* Multiplex between different events. Optional. */
+	int (*switch_events)(void);
 	/* CPU identification string. */
 	char * cpu_type;
 };
#1 lore raw

PATCH 1/26 x86/oprofile: Rework and simplify nmi_cpu_setup()

This patch removes the function nmi_save_registers(). Per-cpu code is now executed only in the function nmi_cpu_setup(). Also, it renames the per-cpu function nmi_restore_registers() to nmi_cpu_restore_registers().

---
 arch/x86/oprofile/nmi_int.c |   13 +++----------
 1 files changed, 3 insertions(+), 10 deletions(-)
arch/x86/oprofile/nmi_int.c +3 -10
index 93df76d..25da1e1 100644
@@ -87,13 +87,6 @@ static void nmi_cpu_save_registers(struct op_msrs *msrs)
 	}
 }
 
-static void nmi_save_registers(void *dummy)
-{
-	int cpu = smp_processor_id();
-	struct op_msrs *msrs = &per_cpu(cpu_msrs, cpu);
-	nmi_cpu_save_registers(msrs);
-}
-
 static void free_msrs(void)
 {
 	int i;
@@ -137,6 +130,7 @@ static void nmi_cpu_setup(void *dummy)
 {
 	int cpu = smp_processor_id();
 	struct op_msrs *msrs = &per_cpu(cpu_msrs, cpu);
+	nmi_cpu_save_registers(msrs);
 	spin_lock(&oprofilefs_lock);
 	model->setup_ctrs(model, msrs);
 	spin_unlock(&oprofilefs_lock);
@@ -182,13 +176,12 @@ static int nmi_setup(void)
 		}
 
 	}
-	on_each_cpu(nmi_save_registers, NULL, 1);
 	on_each_cpu(nmi_cpu_setup, NULL, 1);
 	nmi_enabled = 1;
 	return 0;
 }
 
-static void nmi_restore_registers(struct op_msrs *msrs)
+static void nmi_cpu_restore_registers(struct op_msrs *msrs)
 {
 	struct op_msr *counters = msrs->counters;
 	struct op_msr *controls = msrs->controls;
@@ -220,7 +213,7 @@ static void nmi_cpu_shutdown(void *dummy)
 	apic_write(APIC_LVTERR, v | APIC_LVT_MASKED);
 	apic_write(APIC_LVTPC, per_cpu(saved_lvtpc, cpu));
 	apic_write(APIC_LVTERR, v);
-	nmi_restore_registers(msrs);
+	nmi_cpu_restore_registers(msrs);
 }
 
 static void nmi_shutdown(void)
Signature · 1 line
1.6.3.3
#2 lore raw

PATCH 2/26 x86/oprofile: Whitespaces changes only

In reply to Robert Richter

This patch fixes whitespace changes of code that will be touched in follow-on patches.

---
 arch/x86/oprofile/nmi_int.c       |   12 ++++++------
 arch/x86/oprofile/op_model_amd.c  |   12 ++++++------
 arch/x86/oprofile/op_model_p4.c   |    8 ++++----
 arch/x86/oprofile/op_model_ppro.c |    8 ++++----
 4 files changed, 20 insertions(+), 20 deletions(-)
arch/x86/oprofile/nmi_int.c +6 -6
index 25da1e1..fca8dc9 100644
@@ -516,12 +516,12 @@ int __init op_nmi_init(struct oprofile_operations *ops)
 	register_cpu_notifier(&oprofile_cpu_nb);
 #endif
 	/* default values, can be overwritten by model */
-	ops->create_files = nmi_create_files;
-	ops->setup = nmi_setup;
-	ops->shutdown = nmi_shutdown;
-	ops->start = nmi_start;
-	ops->stop = nmi_stop;
-	ops->cpu_type = cpu_type;
+	ops->create_files	= nmi_create_files;
+	ops->setup		= nmi_setup;
+	ops->shutdown		= nmi_shutdown;
+	ops->start		= nmi_start;
+	ops->stop		= nmi_stop;
+	ops->cpu_type		= cpu_type;
 
 	if (model->init)
 		ret = model->init(ops);
arch/x86/oprofile/op_model_amd.c +6 -6
index 7ca8306..f676f88 100644
@@ -91,7 +91,7 @@ static void op_amd_setup_ctrs(struct op_x86_model_spec const *model,
 	int i;
 
 	/* clear all counters */
-	for (i = 0 ; i < NUM_CONTROLS; ++i) {
+	for (i = 0; i < NUM_CONTROLS; ++i) {
 		if (unlikely(!msrs->controls[i].addr))
 			continue;
 		rdmsrl(msrs->controls[i].addr, val);
@@ -229,7 +229,7 @@ static int op_amd_check_ctrs(struct pt_regs * const regs,
 	u64 val;
 	int i;
 
-	for (i = 0 ; i < NUM_COUNTERS; ++i) {
+	for (i = 0; i < NUM_COUNTERS; ++i) {
 		if (!reset_value[i])
 			continue;
 		rdmsrl(msrs->counters[i].addr, val);
@@ -250,7 +250,7 @@ static void op_amd_start(struct op_msrs const * const msrs)
 {
 	u64 val;
 	int i;
-	for (i = 0 ; i < NUM_COUNTERS ; ++i) {
+	for (i = 0; i < NUM_COUNTERS; ++i) {
 		if (reset_value[i]) {
 			rdmsrl(msrs->controls[i].addr, val);
 			val |= ARCH_PERFMON_EVENTSEL0_ENABLE;
@@ -270,7 +270,7 @@ static void op_amd_stop(struct op_msrs const * const msrs)
 	 * Subtle: stop on all counters to avoid race with setting our
 	 * pm callback
 	 */
-	for (i = 0 ; i < NUM_COUNTERS ; ++i) {
+	for (i = 0; i < NUM_COUNTERS; ++i) {
 		if (!reset_value[i])
 			continue;
 		rdmsrl(msrs->controls[i].addr, val);
@@ -285,11 +285,11 @@ static void op_amd_shutdown(struct op_msrs const * const msrs)
 {
 	int i;
 
-	for (i = 0 ; i < NUM_COUNTERS ; ++i) {
+	for (i = 0; i < NUM_COUNTERS; ++i) {
 		if (msrs->counters[i].addr)
 			release_perfctr_nmi(MSR_K7_PERFCTR0 + i);
 	}
-	for (i = 0 ; i < NUM_CONTROLS ; ++i) {
+	for (i = 0; i < NUM_CONTROLS; ++i) {
 		if (msrs->controls[i].addr)
 			release_evntsel_nmi(MSR_K7_EVNTSEL0 + i);
 	}
arch/x86/oprofile/op_model_p4.c +4 -4
index 9db9e36..5921b7f 100644
@@ -558,7 +558,7 @@ static void p4_setup_ctrs(struct op_x86_model_spec const *model,
 	}
 
 	/* clear the cccrs we will use */
-	for (i = 0 ; i < num_counters ; i++) {
+	for (i = 0; i < num_counters; i++) {
 		if (unlikely(!msrs->controls[i].addr))
 			continue;
 		rdmsr(p4_counters[VIRT_CTR(stag, i)].cccr_address, low, high);
@@ -575,7 +575,7 @@ static void p4_setup_ctrs(struct op_x86_model_spec const *model,
 	}
 
 	/* setup all counters */
-	for (i = 0 ; i < num_counters ; ++i) {
+	for (i = 0; i < num_counters; ++i) {
 		if (counter_config[i].enabled && msrs->controls[i].addr) {
 			reset_value[i] = counter_config[i].count;
 			pmc_setup_one_p4_counter(i);
@@ -678,7 +678,7 @@ static void p4_shutdown(struct op_msrs const * const msrs)
 {
 	int i;
 
-	for (i = 0 ; i < num_counters ; ++i) {
+	for (i = 0; i < num_counters; ++i) {
 		if (msrs->counters[i].addr)
 			release_perfctr_nmi(msrs->counters[i].addr);
 	}
@@ -687,7 +687,7 @@ static void p4_shutdown(struct op_msrs const * const msrs)
 	 * conjunction with the counter registers (hence the starting offset).
 	 * This saves a few bits.
 	 */
-	for (i = num_counters ; i < num_controls ; ++i) {
+	for (i = num_counters; i < num_controls; ++i) {
 		if (msrs->controls[i].addr)
 			release_evntsel_nmi(msrs->controls[i].addr);
 	}
arch/x86/oprofile/op_model_ppro.c +4 -4
index cd72d5c..570d717 100644
@@ -81,7 +81,7 @@ static void ppro_setup_ctrs(struct op_x86_model_spec const *model,
 	}
 
 	/* clear all counters */
-	for (i = 0 ; i < num_counters; ++i) {
+	for (i = 0; i < num_counters; ++i) {
 		if (unlikely(!msrs->controls[i].addr))
 			continue;
 		rdmsrl(msrs->controls[i].addr, val);
@@ -125,7 +125,7 @@ static int ppro_check_ctrs(struct pt_regs * const regs,
 	if (unlikely(!reset_value))
 		goto out;
 
-	for (i = 0 ; i < num_counters; ++i) {
+	for (i = 0; i < num_counters; ++i) {
 		if (!reset_value[i])
 			continue;
 		rdmsrl(msrs->counters[i].addr, val);
@@ -188,11 +188,11 @@ static void ppro_shutdown(struct op_msrs const * const msrs)
 {
 	int i;
 
-	for (i = 0 ; i < num_counters ; ++i) {
+	for (i = 0; i < num_counters; ++i) {
 		if (msrs->counters[i].addr)
 			release_perfctr_nmi(MSR_P6_PERFCTR0 + i);
 	}
-	for (i = 0 ; i < num_counters ; ++i) {
+	for (i = 0; i < num_counters; ++i) {
 		if (msrs->controls[i].addr)
 			release_evntsel_nmi(MSR_P6_EVNTSEL0 + i);
 	}
Signature · 1 line
1.6.3.3
#3 lore raw

PATCH 3/26 oprofile: Implement performance counter multiplexing

In reply to Robert Richter

From: Jason Yeh <[email protected]>

The number of hardware counters is limited. The multiplexing feature enables OProfile to gather more events than counters are provided by the hardware. This is realized by switching between events at an user specified time interval.

A new file (/dev/oprofile/time_slice) is added for the user to specify the timer interval in ms. If the number of events to profile is higher than the number of hardware counters available, the patch will schedule a work queue that switches the event counter and re-writes the different sets of values into it. The switching mechanism needs to be implemented for each architecture to support multiplexing. This patch only implements AMD CPU support, but multiplexing can be easily extended for other models and architectures.

There are follow-on patches that rework parts of this patch.

---
 arch/Kconfig                      |   12 +++
 arch/x86/oprofile/nmi_int.c       |  162 +++++++++++++++++++++++++++++++++++-
 arch/x86/oprofile/op_counter.h    |    2 +-
 arch/x86/oprofile/op_model_amd.c  |  110 ++++++++++++++++++++++---
 arch/x86/oprofile/op_model_p4.c   |    4 +
 arch/x86/oprofile/op_model_ppro.c |    2 +
 arch/x86/oprofile/op_x86_model.h  |    7 ++
 drivers/oprofile/oprof.c          |   78 ++++++++++++++++++
 drivers/oprofile/oprof.h          |    2 +
 drivers/oprofile/oprofile_files.c |   43 ++++++++++
 drivers/oprofile/oprofile_stats.c |   10 +++
 include/linux/oprofile.h          |    3 +
 12 files changed, 415 insertions(+), 20 deletions(-)
arch/Kconfig +12 -0
index 99193b1..beea3cc 100644
@@ -30,6 +30,18 @@ config OPROFILE_IBS
 
 	  If unsure, say N.
 
+config OPROFILE_EVENT_MULTIPLEX
+	bool "OProfile multiplexing support (EXPERIMENTAL)"
+	default n
+	depends on OPROFILE && X86
+	help
+	  The number of hardware counters is limited. The multiplexing
+	  feature enables OProfile to gather more events than counters
+	  are provided by the hardware. This is realized by switching
+	  between events at an user specified time interval.
+
+	  If unsure, say N.
+
 config HAVE_OPROFILE
 	bool
 
arch/x86/oprofile/nmi_int.c +157 -5

270 lines not on this page · raw message

arch/x86/oprofile/op_counter.h +1 -1
index 91b6a11..e28398d 100644
@@ -10,7 +10,7 @@
 #ifndef OP_COUNTER_H
 #define OP_COUNTER_H
 
-#define OP_MAX_COUNTER 8
+#define OP_MAX_COUNTER 32
 
 /* Per-perfctr configuration as set via
  * oprofilefs.
arch/x86/oprofile/op_model_amd.c +96 -14

198 lines not on this page · raw message

arch/x86/oprofile/op_model_p4.c +4 -0
index 5921b7f..65b9237 100644
@@ -698,6 +698,8 @@ static void p4_shutdown(struct op_msrs const * const msrs)
 struct op_x86_model_spec const op_p4_ht2_spec = {
 	.num_counters		= NUM_COUNTERS_HT2,
 	.num_controls		= NUM_CONTROLS_HT2,
+	.num_virt_counters	= NUM_COUNTERS_HT2,
+	.num_virt_controls	= NUM_CONTROLS_HT2,
 	.fill_in_addresses	= &p4_fill_in_addresses,
 	.setup_ctrs		= &p4_setup_ctrs,
 	.check_ctrs		= &p4_check_ctrs,
@@ -710,6 +712,8 @@ struct op_x86_model_spec const op_p4_ht2_spec = {
 struct op_x86_model_spec const op_p4_spec = {
 	.num_counters		= NUM_COUNTERS_NON_HT,
 	.num_controls		= NUM_CONTROLS_NON_HT,
+	.num_virt_counters	= NUM_COUNTERS_NON_HT,
+	.num_virt_controls	= NUM_CONTROLS_NON_HT,
 	.fill_in_addresses	= &p4_fill_in_addresses,
 	.setup_ctrs		= &p4_setup_ctrs,
 	.check_ctrs		= &p4_check_ctrs,
arch/x86/oprofile/op_model_ppro.c +2 -0
index 570d717..098cbca 100644
@@ -206,6 +206,8 @@ static void ppro_shutdown(struct op_msrs const * const msrs)
 struct op_x86_model_spec const op_ppro_spec = {
 	.num_counters		= 2,
 	.num_controls		= 2,
+	.num_virt_counters	= 2,
+	.num_virt_controls	= 2,
 	.reserved		= MSR_PPRO_EVENTSEL_RESERVED,
 	.fill_in_addresses	= &ppro_fill_in_addresses,
 	.setup_ctrs		= &ppro_setup_ctrs,
arch/x86/oprofile/op_x86_model.h +7 -0
index 5054898..0d07d23 100644
@@ -23,6 +23,7 @@ struct op_msr {
 struct op_msrs {
 	struct op_msr *counters;
 	struct op_msr *controls;
+	struct op_msr *multiplex;
 };
 
 struct pt_regs;
@@ -35,6 +36,8 @@ struct oprofile_operations;
 struct op_x86_model_spec {
 	unsigned int	num_counters;
 	unsigned int	num_controls;
+	unsigned int	num_virt_counters;
+	unsigned int	num_virt_controls;
 	u64		reserved;
 	u16		event_mask;
 	int		(*init)(struct oprofile_operations *ops);
@@ -47,6 +50,10 @@ struct op_x86_model_spec {
 	void		(*start)(struct op_msrs const * const msrs);
 	void		(*stop)(struct op_msrs const * const msrs);
 	void		(*shutdown)(struct op_msrs const * const msrs);
+#ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
+	void		(*switch_ctrl)(struct op_x86_model_spec const *model,
+				       struct op_msrs const * const msrs);
+#endif
 };
 
 struct op_counter_config;
drivers/oprofile/oprof.c +78 -0

124 lines not on this page · raw message

drivers/oprofile/oprof.h +2 -0
index c288d3c..ee38abc 100644
@@ -27,6 +27,7 @@ extern unsigned long oprofile_buffer_watershed;
 extern struct oprofile_operations oprofile_ops;
 extern unsigned long oprofile_started;
 extern unsigned long oprofile_backtrace_depth;
+extern unsigned long timeout_jiffies;
 
 struct super_block;
 struct dentry;
@@ -35,5 +36,6 @@ void oprofile_create_files(struct super_block *sb, struct dentry *root);
 void oprofile_timer_init(struct oprofile_operations *ops);
 
 int oprofile_set_backtrace(unsigned long depth);
+int oprofile_set_timeout(unsigned long time);
 
 #endif /* OPROF_H */
drivers/oprofile/oprofile_files.c +43 -0

61 lines not on this page · raw message

drivers/oprofile/oprofile_stats.c +10 -0
index 3c2270a..77a57a6 100644
@@ -16,6 +16,9 @@
 #include "cpu_buffer.h"
 
 struct oprofile_stat_struct oprofile_stats;
+#ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
+atomic_t multiplex_counter;
+#endif
 
 void oprofile_reset_stats(void)
 {
@@ -34,6 +37,9 @@ void oprofile_reset_stats(void)
 	atomic_set(&oprofile_stats.sample_lost_no_mapping, 0);
 	atomic_set(&oprofile_stats.event_lost_overflow, 0);
 	atomic_set(&oprofile_stats.bt_lost_no_mapping, 0);
+#ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
+	atomic_set(&multiplex_counter, 0);
+#endif
 }
 
 
@@ -76,4 +82,8 @@ void oprofile_create_stats_files(struct super_block *sb, struct dentry *root)
 		&oprofile_stats.event_lost_overflow);
 	oprofilefs_create_ro_atomic(sb, dir, "bt_lost_no_mapping",
 		&oprofile_stats.bt_lost_no_mapping);
+#ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
+	oprofilefs_create_ro_atomic(sb, dir, "multiplex_counter",
+		&multiplex_counter);
+#endif
 }
include/linux/oprofile.h +3 -0
index d68d2ed..5171639 100644
@@ -67,6 +67,9 @@ struct oprofile_operations {
 
 	/* Initiate a stack backtrace. Optional. */
 	void (*backtrace)(struct pt_regs * const regs, unsigned int depth);
+
+	/* Multiplex between different events. Optional. */
+	int (*switch_events)(void);
 	/* CPU identification string. */
 	char * cpu_type;
 };
Signature · 1 line
1.6.3.3
#4 lore raw

PATCH 4/26 x86/oprofile: Fix usage of NUM_CONTROLS/NUM_COUNTERS macros

In reply to Robert Richter

Use the corresponding macros when iterating over counter and control registers. Since NUM_CONTROLS and NUM_COUNTERS are equal for AMD cpus the fix is more a cosmetical change.

---
 arch/x86/oprofile/op_model_amd.c |    4 ++--
 1 files changed, 2 insertions(+), 2 deletions(-)
arch/x86/oprofile/op_model_amd.c +2 -2
index fdbed3a..dcfd450 100644
@@ -99,7 +99,7 @@ static void op_amd_fill_in_addresses(struct op_msrs * const msrs)
 
 #ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
 	for (i = 0; i < NUM_VIRT_COUNTERS; i++) {
-		int hw_counter = i % NUM_CONTROLS;
+		int hw_counter = i % NUM_COUNTERS;
 		if (reserve_perfctr_nmi(MSR_K7_PERFCTR0 + i))
 			msrs->multiplex[i].addr = MSR_K7_PERFCTR0 + hw_counter;
 		else
@@ -366,7 +366,7 @@ static void op_amd_shutdown(struct op_msrs const * const msrs)
 		if (msrs->counters[i].addr)
 			release_perfctr_nmi(MSR_K7_PERFCTR0 + i);
 	}
-	for (i = 0; i < NUM_COUNTERS; ++i) {
+	for (i = 0; i < NUM_CONTROLS; ++i) {
 		if (msrs->controls[i].addr)
 			release_evntsel_nmi(MSR_K7_EVNTSEL0 + i);
 	}
Signature · 1 line
1.6.3.3
#5 lore raw

PATCH 5/26 x86/oprofile: Use per_cpu() instead of __get_cpu_var()

In reply to Robert Richter

__get_cpu_var() calls smp_processor_id(). When the cpu id is already known, instead use per_cpu() to avoid generating the id again.

---
 arch/x86/oprofile/nmi_int.c |    4 ++--
 1 files changed, 2 insertions(+), 2 deletions(-)
arch/x86/oprofile/nmi_int.c +2 -2
index e54f6a0..8cd4658 100644
@@ -294,7 +294,7 @@ static void nmi_cpu_shutdown(void *dummy)
 {
 	unsigned int v;
 	int cpu = smp_processor_id();
-	struct op_msrs *msrs = &__get_cpu_var(cpu_msrs);
+	struct op_msrs *msrs = &per_cpu(cpu_msrs, cpu);
 
 	/* restoring APIC_LVTPC can trigger an apic error because the delivery
 	 * mode and vector nr combination can be illegal. That's by design: on
@@ -307,7 +307,7 @@ static void nmi_cpu_shutdown(void *dummy)
 	apic_write(APIC_LVTERR, v);
 	nmi_cpu_restore_registers(msrs);
 #ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
-	__get_cpu_var(switch_index) = 0;
+	per_cpu(switch_index, cpu) = 0;
 #endif
 }
 
Signature · 1 line
1.6.3.3
#6 lore raw

PATCH 6/26 x86/oprofile: Fix initialization of switch_index

In reply to Robert Richter

Variable switch_index must be initialized for each cpu. This patch fixes the initialization by moving it to the per-cpu init function nmi_cpu_setup().

---
 arch/x86/oprofile/nmi_int.c |   16 +++++++++-------
 1 files changed, 9 insertions(+), 7 deletions(-)
arch/x86/oprofile/nmi_int.c +9 -7
index 8cd4658..b211d33 100644
@@ -160,7 +160,7 @@ static int allocate_msrs(void)
 
 #ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
 
-static void nmi_setup_cpu_mux(struct op_msrs const * const msrs)
+static void nmi_cpu_setup_mux(int cpu, struct op_msrs const * const msrs)
 {
 	int i;
 	struct op_msr *multiplex = msrs->multiplex;
@@ -173,8 +173,15 @@ static void nmi_setup_cpu_mux(struct op_msrs const * const msrs)
 			multiplex[i].saved = 0;
 		}
 	}
+
+	per_cpu(switch_index, cpu) = 0;
 }
 
+#else
+
+static inline void
+nmi_cpu_setup_mux(int cpu, struct op_msrs const * const msrs) { }
+
 #endif
 
 static void nmi_cpu_setup(void *dummy)
@@ -184,9 +191,7 @@ static void nmi_cpu_setup(void *dummy)
 	nmi_cpu_save_registers(msrs);
 	spin_lock(&oprofilefs_lock);
 	model->setup_ctrs(model, msrs);
-#ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
-	nmi_setup_cpu_mux(msrs);
-#endif
+	nmi_cpu_setup_mux(cpu, msrs);
 	spin_unlock(&oprofilefs_lock);
 	per_cpu(saved_lvtpc, cpu) = apic_read(APIC_LVTPC);
 	apic_write(APIC_LVTPC, APIC_DM_NMI);
@@ -662,9 +667,6 @@ int __init op_nmi_init(struct oprofile_operations *ops)
 	register_cpu_notifier(&oprofile_cpu_nb);
 #endif
 	/* default values, can be overwritten by model */
-#ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
-	__raw_get_cpu_var(switch_index) = 0;
-#endif
 	ops->create_files	= nmi_create_files;
 	ops->setup		= nmi_setup;
 	ops->shutdown		= nmi_shutdown;
Signature · 1 line
1.6.3.3
#7 lore raw

PATCH 7/26 oprofile: oprofile_set_timeout(), return with error for invalid args

In reply to Robert Richter

Return with -EINVAL for invalid parameters instead of setting the default value in oprofile_set_timeout().

---
 drivers/oprofile/oprof.c |   11 ++++++++---
 1 files changed, 8 insertions(+), 3 deletions(-)
drivers/oprofile/oprof.c +8 -3
index 7bc64af..42c9c76 100644
@@ -196,6 +196,7 @@ post_sync:
 int oprofile_set_timeout(unsigned long val_msec)
 {
 	int err = 0;
+	unsigned long time_slice;
 
 	mutex_lock(&start_mutex);
 
@@ -209,9 +210,13 @@ int oprofile_set_timeout(unsigned long val_msec)
 		goto out;
 	}
 
-	timeout_jiffies = msecs_to_jiffies(val_msec);
-	if (timeout_jiffies == MAX_JIFFY_OFFSET)
-		timeout_jiffies = msecs_to_jiffies(MULTIPLEXING_TIMER_DEFAULT);
+	time_slice = msecs_to_jiffies(val_msec);
+	if (time_slice == MAX_JIFFY_OFFSET) {
+		err = -EINVAL;
+		goto out;
+	}
+
+	timeout_jiffies = time_slice;
 
 out:
 	mutex_unlock(&start_mutex);
Signature · 1 line
1.6.3.3
#8 lore raw

PATCH 8/26 oprofile: Rename variable timeout_jiffies and move to oprofile_files.c

In reply to Robert Richter

This patch renames timeout_jiffies into an oprofile specific name. The macro MULTIPLEXING_TIMER_DEFAULT is changed too.

Also, since this variable is controlled using oprofilefs, its definition is moved to oprofile_files.c.

---
 drivers/oprofile/oprof.c          |    9 ++++-----
 drivers/oprofile/oprof.h          |    3 ++-
 drivers/oprofile/oprofile_files.c |    5 +++--
 3 files changed, 9 insertions(+), 8 deletions(-)
drivers/oprofile/oprof.c +4 -5
index 42c9c76..2b33de7 100644
@@ -33,8 +33,7 @@ static DEFINE_MUTEX(start_mutex);
 
 static void switch_worker(struct work_struct *work);
 static DECLARE_DELAYED_WORK(switch_work, switch_worker);
-unsigned long timeout_jiffies;
-#define MULTIPLEXING_TIMER_DEFAULT 1
+#define TIME_SLICE_DEFAULT		1
 
 #endif
 
@@ -102,7 +101,7 @@ out:
 
 static void start_switch_worker(void)
 {
-	schedule_delayed_work(&switch_work, timeout_jiffies);
+	schedule_delayed_work(&switch_work, oprofile_time_slice);
 }
 
 static void switch_worker(struct work_struct *work)
@@ -216,7 +215,7 @@ int oprofile_set_timeout(unsigned long val_msec)
 		goto out;
 	}
 
-	timeout_jiffies = time_slice;
+	oprofile_time_slice = time_slice;
 
 out:
 	mutex_unlock(&start_mutex);
@@ -253,7 +252,7 @@ out:
 
 static void __init oprofile_multiplexing_init(void)
 {
-	timeout_jiffies = msecs_to_jiffies(MULTIPLEXING_TIMER_DEFAULT);
+	oprofile_time_slice = msecs_to_jiffies(TIME_SLICE_DEFAULT);
 }
 
 #endif
drivers/oprofile/oprof.h +2 -1
index ee38abc..cb92f5c 100644
@@ -24,10 +24,11 @@ struct oprofile_operations;
 extern unsigned long oprofile_buffer_size;
 extern unsigned long oprofile_cpu_buffer_size;
 extern unsigned long oprofile_buffer_watershed;
+extern unsigned long oprofile_time_slice;
+
 extern struct oprofile_operations oprofile_ops;
 extern unsigned long oprofile_started;
 extern unsigned long oprofile_backtrace_depth;
-extern unsigned long timeout_jiffies;
 
 struct super_block;
 struct dentry;
drivers/oprofile/oprofile_files.c +3 -2
index 468ec3e..4c5b947 100644
@@ -22,14 +22,15 @@
 unsigned long oprofile_buffer_size;
 unsigned long oprofile_cpu_buffer_size;
 unsigned long oprofile_buffer_watershed;
+unsigned long oprofile_time_slice;
 
 #ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
 
 static ssize_t timeout_read(struct file *file, char __user *buf,
 		size_t count, loff_t *offset)
 {
-	return oprofilefs_ulong_to_user(jiffies_to_msecs(timeout_jiffies),
-				buf, count, offset);
+	return oprofilefs_ulong_to_user(jiffies_to_msecs(oprofile_time_slice),
+					buf, count, offset);
 }
 
 
Signature · 1 line
1.6.3.3
#9 lore raw

PATCH 9/26 oprofile: Remove oprofile_multiplexing_init()

In reply to Robert Richter

oprofile_multiplexing_init() can be removed when moving the initialization of oprofile_time_slice to oprofile_create_files().

---
 drivers/oprofile/oprof.c          |   14 --------------
 drivers/oprofile/oprofile_files.c |    2 ++
 2 files changed, 2 insertions(+), 14 deletions(-)
drivers/oprofile/oprof.c +0 -14
index 2b33de7..fa6cccd 100644
@@ -33,7 +33,6 @@ static DEFINE_MUTEX(start_mutex);
 
 static void switch_worker(struct work_struct *work);
 static DECLARE_DELAYED_WORK(switch_work, switch_worker);
-#define TIME_SLICE_DEFAULT		1
 
 #endif
 
@@ -248,23 +247,10 @@ out:
 	return err;
 }
 
-#ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
-
-static void __init oprofile_multiplexing_init(void)
-{
-	oprofile_time_slice = msecs_to_jiffies(TIME_SLICE_DEFAULT);
-}
-
-#endif
-
 static int __init oprofile_init(void)
 {
 	int err;
 
-#ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
-	oprofile_multiplexing_init();
-#endif
-
 	err = oprofile_arch_init(&oprofile_ops);
 
 	if (err < 0 || timer) {
drivers/oprofile/oprofile_files.c +2 -0
index 4c5b947..bbd7516 100644
@@ -18,6 +18,7 @@
 #define BUFFER_SIZE_DEFAULT		131072
 #define CPU_BUFFER_SIZE_DEFAULT		8192
 #define BUFFER_WATERSHED_DEFAULT	32768	/* FIXME: tune */
+#define TIME_SLICE_DEFAULT		1
 
 unsigned long oprofile_buffer_size;
 unsigned long oprofile_cpu_buffer_size;
@@ -170,6 +171,7 @@ void oprofile_create_files(struct super_block *sb, struct dentry *root)
 	oprofile_buffer_size =		BUFFER_SIZE_DEFAULT;
 	oprofile_cpu_buffer_size =	CPU_BUFFER_SIZE_DEFAULT;
 	oprofile_buffer_watershed =	BUFFER_WATERSHED_DEFAULT;
+	oprofile_time_slice =		msecs_to_jiffies(TIME_SLICE_DEFAULT);
 
 	oprofilefs_create_file(sb, root, "enable", &enable_fops);
 	oprofilefs_create_file_perm(sb, root, "dump", &dump_fops, 0666);
Signature · 1 line
1.6.3.3
#10 lore raw

PATCH 10/26 oprofile: Grouping multiplexing code in oprof.c

In reply to Robert Richter

This patch moves multiplexing code to a single section of code. This reduces the use of #ifdefs especially within functions.

---
 drivers/oprofile/oprof.c |  100 ++++++++++++++++++++++-----------------------
 1 files changed, 49 insertions(+), 51 deletions(-)
drivers/oprofile/oprof.c +49 -51
index fa6cccd..a48294a 100644
@@ -29,13 +29,6 @@ unsigned long oprofile_backtrace_depth;
 static unsigned long is_setup;
 static DEFINE_MUTEX(start_mutex);
 
-#ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
-
-static void switch_worker(struct work_struct *work);
-static DECLARE_DELAYED_WORK(switch_work, switch_worker);
-
-#endif
-
 /* timer
    0 - use performance monitoring hardware if available
    1 - use the timer int mechanism regardless
@@ -98,9 +91,18 @@ out:
 
 #ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
 
+static void switch_worker(struct work_struct *work);
+static DECLARE_DELAYED_WORK(switch_work, switch_worker);
+
 static void start_switch_worker(void)
 {
-	schedule_delayed_work(&switch_work, oprofile_time_slice);
+	if (oprofile_ops.switch_events)
+		schedule_delayed_work(&switch_work, oprofile_time_slice);
+}
+
+static void stop_switch_worker(void)
+{
+	cancel_delayed_work_sync(&switch_work);
 }
 
 static void switch_worker(struct work_struct *work)
@@ -109,6 +111,43 @@ static void switch_worker(struct work_struct *work)
 		start_switch_worker();
 }
 
+/* User inputs in ms, converts to jiffies */
+int oprofile_set_timeout(unsigned long val_msec)
+{
+	int err = 0;
+	unsigned long time_slice;
+
+	mutex_lock(&start_mutex);
+
+	if (oprofile_started) {
+		err = -EBUSY;
+		goto out;
+	}
+
+	if (!oprofile_ops.switch_events) {
+		err = -EINVAL;
+		goto out;
+	}
+
+	time_slice = msecs_to_jiffies(val_msec);
+	if (time_slice == MAX_JIFFY_OFFSET) {
+		err = -EINVAL;
+		goto out;
+	}
+
+	oprofile_time_slice = time_slice;
+
+out:
+	mutex_unlock(&start_mutex);
+	return err;
+
+}
+
+#else
+
+static inline void start_switch_worker(void) { }
+static inline void stop_switch_worker(void) { }
+
 #endif
 
 /* Actually start profiling (echo 1>/dev/oprofile/enable) */
@@ -131,10 +170,7 @@ int oprofile_start(void)
 	if ((err = oprofile_ops.start()))
 		goto out;
 
-#ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
-	if (oprofile_ops.switch_events)
-		start_switch_worker();
-#endif
+	start_switch_worker();
 
 	oprofile_started = 1;
 out:
@@ -152,9 +188,7 @@ void oprofile_stop(void)
 	oprofile_ops.stop();
 	oprofile_started = 0;
 
-#ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
-	cancel_delayed_work_sync(&switch_work);
-#endif
+	stop_switch_worker();
 
 	/* wake up the daemon to read what remains */
 	wake_up_buffer_waiter();
@@ -188,42 +222,6 @@ post_sync:
 	mutex_unlock(&start_mutex);
 }
 
-#ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
-
-/* User inputs in ms, converts to jiffies */
-int oprofile_set_timeout(unsigned long val_msec)
-{
-	int err = 0;
-	unsigned long time_slice;
-
-	mutex_lock(&start_mutex);
-
-	if (oprofile_started) {
-		err = -EBUSY;
-		goto out;
-	}
-
-	if (!oprofile_ops.switch_events) {
-		err = -EINVAL;
-		goto out;
-	}
-
-	time_slice = msecs_to_jiffies(val_msec);
-	if (time_slice == MAX_JIFFY_OFFSET) {
-		err = -EINVAL;
-		goto out;
-	}
-
-	oprofile_time_slice = time_slice;
-
-out:
-	mutex_unlock(&start_mutex);
-	return err;
-
-}
-
-#endif
-
 int oprofile_set_backtrace(unsigned long val)
 {
 	int err = 0;
Signature · 1 line
1.6.3.3
#11 lore raw

PATCH 11/26 oprofile: Introduce op_x86_phys_to_virt()

In reply to Robert Richter

This new function translates physical to virtual counter numbers.

---
 arch/x86/oprofile/nmi_int.c      |   43 +++++++++++---------
 arch/x86/oprofile/op_model_amd.c |   80 +++++++++++++++-----------------------
 arch/x86/oprofile/op_x86_model.h |    1 +
 3 files changed, 55 insertions(+), 69 deletions(-)
arch/x86/oprofile/nmi_int.c +23 -20
index b211d33..02b57b8 100644
@@ -27,12 +27,6 @@
 #include "op_counter.h"
 #include "op_x86_model.h"
 
-
-#ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
-DEFINE_PER_CPU(int, switch_index);
-#endif
-
-
 static struct op_x86_model_spec const *model;
 static DEFINE_PER_CPU(struct op_msrs, cpu_msrs);
 static DEFINE_PER_CPU(unsigned long, saved_lvtpc);
@@ -103,6 +97,21 @@ static void nmi_cpu_save_registers(struct op_msrs *msrs)
 	}
 }
 
+#ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
+
+static DEFINE_PER_CPU(int, switch_index);
+
+inline int op_x86_phys_to_virt(int phys)
+{
+	return __get_cpu_var(switch_index) + phys;
+}
+
+#else
+
+inline int op_x86_phys_to_virt(int phys) { return phys; }
+
+#endif
+
 static void free_msrs(void)
 {
 	int i;
@@ -248,31 +257,25 @@ static int nmi_setup(void)
 
 static void nmi_cpu_save_mpx_registers(struct op_msrs *msrs)
 {
-	unsigned int si = __get_cpu_var(switch_index);
 	struct op_msr *multiplex = msrs->multiplex;
-	unsigned int i;
+	int i;
 
 	for (i = 0; i < model->num_counters; ++i) {
-		int offset = i + si;
-		if (multiplex[offset].addr) {
-			rdmsrl(multiplex[offset].addr,
-			       multiplex[offset].saved);
-		}
+		int virt = op_x86_phys_to_virt(i);
+		if (multiplex[virt].addr)
+			rdmsrl(multiplex[virt].addr, multiplex[virt].saved);
 	}
 }
 
 static void nmi_cpu_restore_mpx_registers(struct op_msrs *msrs)
 {
-	unsigned int si = __get_cpu_var(switch_index);
 	struct op_msr *multiplex = msrs->multiplex;
-	unsigned int i;
+	int i;
 
 	for (i = 0; i < model->num_counters; ++i) {
-		int offset = i + si;
-		if (multiplex[offset].addr) {
-			wrmsrl(multiplex[offset].addr,
-			       multiplex[offset].saved);
-		}
+		int virt = op_x86_phys_to_virt(i);
+		if (multiplex[virt].addr)
+			wrmsrl(multiplex[virt].addr, multiplex[virt].saved);
 	}
 }
 
arch/x86/oprofile/op_model_amd.c +31 -49

121 lines not on this page · raw message

arch/x86/oprofile/op_x86_model.h +1 -0
index 0d07d23..e874dc3 100644
@@ -60,6 +60,7 @@ struct op_counter_config;
 
 extern u64 op_x86_get_ctrl(struct op_x86_model_spec const *model,
 			   struct op_counter_config *counter_config);
+extern int op_x86_phys_to_virt(int phys);
 
 extern struct op_x86_model_spec const op_ppro_spec;
 extern struct op_x86_model_spec const op_p4_spec;
Signature · 1 line
1.6.3.3
#12 lore raw

PATCH 12/26 oprofile: Grouping multiplexing code in op_model_amd.c

In reply to Robert Richter

This patch moves some multiplexing code to the new function op_mux_fill_in_addresses(). Also, the whole multiplexing code is now at a single location.

---
 arch/x86/oprofile/op_model_amd.c |   75 +++++++++++++++++++++-----------------
 1 files changed, 41 insertions(+), 34 deletions(-)
arch/x86/oprofile/op_model_amd.c +41 -34
index 67f830d..644980f 100644
@@ -74,6 +74,45 @@ static struct op_ibs_config ibs_config;
 
 #endif
 
+#ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
+
+static void op_mux_fill_in_addresses(struct op_msrs * const msrs)
+{
+	int i;
+
+	for (i = 0; i < NUM_VIRT_COUNTERS; i++) {
+		int hw_counter = i % NUM_COUNTERS;
+		if (reserve_perfctr_nmi(MSR_K7_PERFCTR0 + i))
+			msrs->multiplex[i].addr = MSR_K7_PERFCTR0 + hw_counter;
+		else
+			msrs->multiplex[i].addr = 0;
+	}
+}
+
+static void op_mux_switch_ctrl(struct op_x86_model_spec const *model,
+			       struct op_msrs const * const msrs)
+{
+	u64 val;
+	int i;
+
+	/* enable active counters */
+	for (i = 0; i < NUM_COUNTERS; ++i) {
+		int virt = op_x86_phys_to_virt(i);
+		if (!counter_config[virt].enabled)
+			continue;
+		rdmsrl(msrs->controls[i].addr, val);
+		val &= model->reserved;
+		val |= op_x86_get_ctrl(model, &counter_config[virt]);
+		wrmsrl(msrs->controls[i].addr, val);
+	}
+}
+
+#else
+
+static inline void op_mux_fill_in_addresses(struct op_msrs * const msrs) { }
+
+#endif
+
 /* functions for op_amd_spec */
 
 static void op_amd_fill_in_addresses(struct op_msrs * const msrs)
@@ -94,15 +133,7 @@ static void op_amd_fill_in_addresses(struct op_msrs * const msrs)
 			msrs->controls[i].addr = 0;
 	}
 
-#ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
-	for (i = 0; i < NUM_VIRT_COUNTERS; i++) {
-		int hw_counter = i % NUM_COUNTERS;
-		if (reserve_perfctr_nmi(MSR_K7_PERFCTR0 + i))
-			msrs->multiplex[i].addr = MSR_K7_PERFCTR0 + hw_counter;
-		else
-			msrs->multiplex[i].addr = 0;
-	}
-#endif
+	op_mux_fill_in_addresses(msrs);
 }
 
 static void op_amd_setup_ctrs(struct op_x86_model_spec const *model,
@@ -155,30 +186,6 @@ static void op_amd_setup_ctrs(struct op_x86_model_spec const *model,
 	}
 }
 
-
-#ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
-
-static void op_amd_switch_ctrl(struct op_x86_model_spec const *model,
-			       struct op_msrs const * const msrs)
-{
-	u64 val;
-	int i;
-
-	/* enable active counters */
-	for (i = 0; i < NUM_COUNTERS; ++i) {
-		int virt = op_x86_phys_to_virt(i);
-		if (!counter_config[virt].enabled)
-			continue;
-		rdmsrl(msrs->controls[i].addr, val);
-		val &= model->reserved;
-		val |= op_x86_get_ctrl(model, &counter_config[virt]);
-		wrmsrl(msrs->controls[i].addr, val);
-	}
-}
-
-#endif
-
-
 #ifdef CONFIG_OPROFILE_IBS
 
 static inline int
@@ -535,6 +542,6 @@ struct op_x86_model_spec const op_amd_spec = {
 	.stop			= &op_amd_stop,
 	.shutdown		= &op_amd_shutdown,
 #ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
-	.switch_ctrl		= &op_amd_switch_ctrl,
+	.switch_ctrl		= &op_mux_switch_ctrl,
 #endif
 };
Signature · 1 line
1.6.3.3
#13 lore raw

PATCH 13/26 x86/oprofile: Implement multiplexing setup/shutdown functions

In reply to Robert Richter

This patch implements nmi_setup_mux() and nmi_shutdown_mux() functions to setup/shutdown multiplexing. Multiplexing code in nmi_int.c is now much more separated.

---
 arch/x86/oprofile/nmi_int.c |   76 ++++++++++++++++++++++--------------------
 1 files changed, 40 insertions(+), 36 deletions(-)
arch/x86/oprofile/nmi_int.c +40 -36
index 02b57b8..674fa37 100644
@@ -106,9 +106,35 @@ inline int op_x86_phys_to_virt(int phys)
 	return __get_cpu_var(switch_index) + phys;
 }
 
+static void nmi_shutdown_mux(void)
+{
+	int i;
+	for_each_possible_cpu(i) {
+		kfree(per_cpu(cpu_msrs, i).multiplex);
+		per_cpu(cpu_msrs, i).multiplex = NULL;
+		per_cpu(switch_index, i) = 0;
+	}
+}
+
+static int nmi_setup_mux(void)
+{
+	size_t multiplex_size =
+		sizeof(struct op_msr) * model->num_virt_counters;
+	int i;
+	for_each_possible_cpu(i) {
+		per_cpu(cpu_msrs, i).multiplex =
+			kmalloc(multiplex_size, GFP_KERNEL);
+		if (!per_cpu(cpu_msrs, i).multiplex)
+			return 0;
+	}
+	return 1;
+}
+
 #else
 
 inline int op_x86_phys_to_virt(int phys) { return phys; }
+static inline void nmi_shutdown_mux(void) { }
+static inline int nmi_setup_mux(void) { return 1; }
 
 #endif
 
@@ -120,51 +146,27 @@ static void free_msrs(void)
 		per_cpu(cpu_msrs, i).counters = NULL;
 		kfree(per_cpu(cpu_msrs, i).controls);
 		per_cpu(cpu_msrs, i).controls = NULL;
-
-#ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
-		kfree(per_cpu(cpu_msrs, i).multiplex);
-		per_cpu(cpu_msrs, i).multiplex = NULL;
-#endif
 	}
 }
 
 static int allocate_msrs(void)
 {
-	int success = 1;
 	size_t controls_size = sizeof(struct op_msr) * model->num_controls;
 	size_t counters_size = sizeof(struct op_msr) * model->num_counters;
-#ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
-	size_t multiplex_size = sizeof(struct op_msr) * model->num_virt_counters;
-#endif
 
 	int i;
 	for_each_possible_cpu(i) {
 		per_cpu(cpu_msrs, i).counters = kmalloc(counters_size,
-								GFP_KERNEL);
-		if (!per_cpu(cpu_msrs, i).counters) {
-			success = 0;
-			break;
-		}
+							GFP_KERNEL);
+		if (!per_cpu(cpu_msrs, i).counters)
+			return 0;
 		per_cpu(cpu_msrs, i).controls = kmalloc(controls_size,
-								GFP_KERNEL);
-		if (!per_cpu(cpu_msrs, i).controls) {
-			success = 0;
-			break;
-		}
-#ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
-		per_cpu(cpu_msrs, i).multiplex =
-				kmalloc(multiplex_size, GFP_KERNEL);
-		if (!per_cpu(cpu_msrs, i).multiplex) {
-			success = 0;
-			break;
-		}
-#endif
+							GFP_KERNEL);
+		if (!per_cpu(cpu_msrs, i).controls)
+			return 0;
 	}
 
-	if (!success)
-		free_msrs();
-
-	return success;
+	return 1;
 }
 
 #ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
@@ -218,11 +220,15 @@ static int nmi_setup(void)
 	int cpu;
 
 	if (!allocate_msrs())
-		return -ENOMEM;
+		err = -ENOMEM;
+	else if (!nmi_setup_mux())
+		err = -ENOMEM;
+	else
+		err = register_die_notifier(&profile_exceptions_nb);
 
-	err = register_die_notifier(&profile_exceptions_nb);
 	if (err) {
 		free_msrs();
+		nmi_shutdown_mux();
 		return err;
 	}
 
@@ -314,9 +320,6 @@ static void nmi_cpu_shutdown(void *dummy)
 	apic_write(APIC_LVTPC, per_cpu(saved_lvtpc, cpu));
 	apic_write(APIC_LVTERR, v);
 	nmi_cpu_restore_registers(msrs);
-#ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
-	per_cpu(switch_index, cpu) = 0;
-#endif
 }
 
 static void nmi_shutdown(void)
@@ -326,6 +329,7 @@ static void nmi_shutdown(void)
 	nmi_enabled = 0;
 	on_each_cpu(nmi_cpu_shutdown, NULL, 1);
 	unregister_die_notifier(&profile_exceptions_nb);
+	nmi_shutdown_mux();
 	msrs = &get_cpu_var(cpu_msrs);
 	model->shutdown(msrs);
 	free_msrs();
Signature · 1 line
1.6.3.3
#14 lore raw

PATCH 14/26 x86/oprofile: Moving nmi_setup_cpu_mux() in nmi_int.c

In reply to Robert Richter

This patch moves some code in nmi_int.c to get a single separate multiplexing code section.

---
 arch/x86/oprofile/nmi_int.c |   45 ++++++++++++++++++------------------------
 1 files changed, 19 insertions(+), 26 deletions(-)
arch/x86/oprofile/nmi_int.c +19 -26
index 674fa37..b1edfc9 100644
@@ -130,11 +130,30 @@ static int nmi_setup_mux(void)
 	return 1;
 }
 
+static void nmi_cpu_setup_mux(int cpu, struct op_msrs const * const msrs)
+{
+	int i;
+	struct op_msr *multiplex = msrs->multiplex;
+
+	for (i = 0; i < model->num_virt_counters; ++i) {
+		if (counter_config[i].enabled) {
+			multiplex[i].saved = -(u64)counter_config[i].count;
+		} else {
+			multiplex[i].addr  = 0;
+			multiplex[i].saved = 0;
+		}
+	}
+
+	per_cpu(switch_index, cpu) = 0;
+}
+
 #else
 
 inline int op_x86_phys_to_virt(int phys) { return phys; }
 static inline void nmi_shutdown_mux(void) { }
 static inline int nmi_setup_mux(void) { return 1; }
+static inline void
+nmi_cpu_setup_mux(int cpu, struct op_msrs const * const msrs) { }
 
 #endif
 
@@ -169,32 +188,6 @@ static int allocate_msrs(void)
 	return 1;
 }
 
-#ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
-
-static void nmi_cpu_setup_mux(int cpu, struct op_msrs const * const msrs)
-{
-	int i;
-	struct op_msr *multiplex = msrs->multiplex;
-
-	for (i = 0; i < model->num_virt_counters; ++i) {
-		if (counter_config[i].enabled) {
-			multiplex[i].saved = -(u64)counter_config[i].count;
-		} else {
-			multiplex[i].addr  = 0;
-			multiplex[i].saved = 0;
-		}
-	}
-
-	per_cpu(switch_index, cpu) = 0;
-}
-
-#else
-
-static inline void
-nmi_cpu_setup_mux(int cpu, struct op_msrs const * const msrs) { }
-
-#endif
-
 static void nmi_cpu_setup(void *dummy)
 {
 	int cpu = smp_processor_id();
Signature · 1 line
1.6.3.3
#15 lore raw

PATCH 15/26 x86/oprofile: Moving nmi_cpu_save/restore_mpx_registers() in nmi_int.c

In reply to Robert Richter

This patch moves some code in nmi_int.c to get a single separate multiplexing code section.

---
 arch/x86/oprofile/nmi_int.c |   52 +++++++++++++++++++-----------------------
 1 files changed, 24 insertions(+), 28 deletions(-)
arch/x86/oprofile/nmi_int.c +24 -28
index b1edfc9..f38c5cf 100644
@@ -147,6 +147,30 @@ static void nmi_cpu_setup_mux(int cpu, struct op_msrs const * const msrs)
 	per_cpu(switch_index, cpu) = 0;
 }
 
+static void nmi_cpu_save_mpx_registers(struct op_msrs *msrs)
+{
+	struct op_msr *multiplex = msrs->multiplex;
+	int i;
+
+	for (i = 0; i < model->num_counters; ++i) {
+		int virt = op_x86_phys_to_virt(i);
+		if (multiplex[virt].addr)
+			rdmsrl(multiplex[virt].addr, multiplex[virt].saved);
+	}
+}
+
+static void nmi_cpu_restore_mpx_registers(struct op_msrs *msrs)
+{
+	struct op_msr *multiplex = msrs->multiplex;
+	int i;
+
+	for (i = 0; i < model->num_counters; ++i) {
+		int virt = op_x86_phys_to_virt(i);
+		if (multiplex[virt].addr)
+			wrmsrl(multiplex[virt].addr, multiplex[virt].saved);
+	}
+}
+
 #else
 
 inline int op_x86_phys_to_virt(int phys) { return phys; }
@@ -252,34 +276,6 @@ static int nmi_setup(void)
 	return 0;
 }
 
-#ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
-
-static void nmi_cpu_save_mpx_registers(struct op_msrs *msrs)
-{
-	struct op_msr *multiplex = msrs->multiplex;
-	int i;
-
-	for (i = 0; i < model->num_counters; ++i) {
-		int virt = op_x86_phys_to_virt(i);
-		if (multiplex[virt].addr)
-			rdmsrl(multiplex[virt].addr, multiplex[virt].saved);
-	}
-}
-
-static void nmi_cpu_restore_mpx_registers(struct op_msrs *msrs)
-{
-	struct op_msr *multiplex = msrs->multiplex;
-	int i;
-
-	for (i = 0; i < model->num_counters; ++i) {
-		int virt = op_x86_phys_to_virt(i);
-		if (multiplex[virt].addr)
-			wrmsrl(multiplex[virt].addr, multiplex[virt].saved);
-	}
-}
-
-#endif
-
 static void nmi_cpu_restore_registers(struct op_msrs *msrs)
 {
 	struct op_msr *counters = msrs->counters;
Signature · 1 line
1.6.3.3
#16 lore raw

PATCH 16/26 x86/oprofile: Moving nmi_cpu_switch() in nmi_int.c

In reply to Robert Richter

This patch moves some code in nmi_int.c to get a single separate multiplexing code section.

---
 arch/x86/oprofile/nmi_int.c |  144 +++++++++++++++++++++----------------------
 1 files changed, 70 insertions(+), 74 deletions(-)
arch/x86/oprofile/nmi_int.c +70 -74
index f38c5cf..998c7dc 100644
@@ -97,6 +97,29 @@ static void nmi_cpu_save_registers(struct op_msrs *msrs)
 	}
 }
 
+static void nmi_cpu_start(void *dummy)
+{
+	struct op_msrs const *msrs = &__get_cpu_var(cpu_msrs);
+	model->start(msrs);
+}
+
+static int nmi_start(void)
+{
+	on_each_cpu(nmi_cpu_start, NULL, 1);
+	return 0;
+}
+
+static void nmi_cpu_stop(void *dummy)
+{
+	struct op_msrs const *msrs = &__get_cpu_var(cpu_msrs);
+	model->stop(msrs);
+}
+
+static void nmi_stop(void)
+{
+	on_each_cpu(nmi_cpu_stop, NULL, 1);
+}
+
 #ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
 
 static DEFINE_PER_CPU(int, switch_index);
@@ -171,6 +194,53 @@ static void nmi_cpu_restore_mpx_registers(struct op_msrs *msrs)
 	}
 }
 
+static void nmi_cpu_switch(void *dummy)
+{
+	int cpu = smp_processor_id();
+	int si = per_cpu(switch_index, cpu);
+	struct op_msrs *msrs = &per_cpu(cpu_msrs, cpu);
+
+	nmi_cpu_stop(NULL);
+	nmi_cpu_save_mpx_registers(msrs);
+
+	/* move to next set */
+	si += model->num_counters;
+	if ((si > model->num_virt_counters) || (counter_config[si].count == 0))
+		per_cpu(switch_index, cpu) = 0;
+	else
+		per_cpu(switch_index, cpu) = si;
+
+	model->switch_ctrl(model, msrs);
+	nmi_cpu_restore_mpx_registers(msrs);
+
+	nmi_cpu_start(NULL);
+}
+
+
+/*
+ * Quick check to see if multiplexing is necessary.
+ * The check should be sufficient since counters are used
+ * in ordre.
+ */
+static int nmi_multiplex_on(void)
+{
+	return counter_config[model->num_counters].count ? 0 : -EINVAL;
+}
+
+static int nmi_switch_event(void)
+{
+	if (!model->switch_ctrl)
+		return -ENOSYS;		/* not implemented */
+	if (nmi_multiplex_on() < 0)
+		return -EINVAL;		/* not necessary */
+
+	on_each_cpu(nmi_cpu_switch, NULL, 1);
+
+	atomic_inc(&multiplex_counter);
+
+	return 0;
+}
+
 #else
 
 inline int op_x86_phys_to_virt(int phys) { return phys; }
@@ -325,29 +395,6 @@ static void nmi_shutdown(void)
 	put_cpu_var(cpu_msrs);
 }
 
-static void nmi_cpu_start(void *dummy)
-{
-	struct op_msrs const *msrs = &__get_cpu_var(cpu_msrs);
-	model->start(msrs);
-}
-
-static int nmi_start(void)
-{
-	on_each_cpu(nmi_cpu_start, NULL, 1);
-	return 0;
-}
-
-static void nmi_cpu_stop(void *dummy)
-{
-	struct op_msrs const *msrs = &__get_cpu_var(cpu_msrs);
-	model->stop(msrs);
-}
-
-static void nmi_stop(void)
-{
-	on_each_cpu(nmi_cpu_stop, NULL, 1);
-}
-
 static int nmi_create_files(struct super_block *sb, struct dentry *root)
 {
 	unsigned int i;
@@ -379,57 +426,6 @@ static int nmi_create_files(struct super_block *sb, struct dentry *root)
 	return 0;
 }
 
-#ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
-
-static void nmi_cpu_switch(void *dummy)
-{
-	int cpu = smp_processor_id();
-	int si = per_cpu(switch_index, cpu);
-	struct op_msrs *msrs = &per_cpu(cpu_msrs, cpu);
-
-	nmi_cpu_stop(NULL);
-	nmi_cpu_save_mpx_registers(msrs);
-
-	/* move to next set */
-	si += model->num_counters;
-	if ((si > model->num_virt_counters) || (counter_config[si].count == 0))
-		per_cpu(switch_index, cpu) = 0;
-	else
-		per_cpu(switch_index, cpu) = si;
-
-	model->switch_ctrl(model, msrs);
-	nmi_cpu_restore_mpx_registers(msrs);
-
-	nmi_cpu_start(NULL);
-}
-
-
-/*
- * Quick check to see if multiplexing is necessary.
- * The check should be sufficient since counters are used
- * in ordre.
- */
-static int nmi_multiplex_on(void)
-{
-	return counter_config[model->num_counters].count ? 0 : -EINVAL;
-}
-
-static int nmi_switch_event(void)
-{
-	if (!model->switch_ctrl)
-		return -ENOSYS;		/* not implemented */
-	if (nmi_multiplex_on() < 0)
-		return -EINVAL;		/* not necessary */
-
-	on_each_cpu(nmi_cpu_switch, NULL, 1);
-
-	atomic_inc(&multiplex_counter);
-
-	return 0;
-}
-
-#endif
-
 #ifdef CONFIG_SMP
 static int oprofile_cpu_notifier(struct notifier_block *b, unsigned long action,
 				 void *data)
Signature · 1 line
1.6.3.3
#17 lore raw

PATCH 17/26 x86/oprofile: Remove const qualifier from struct op_x86_model_spec

In reply to Robert Richter

This patch removes the const qualifier from struct op_x86_model_spec to make model parameters changable.

---
 arch/x86/oprofile/nmi_int.c       |    4 ++--
 arch/x86/oprofile/op_model_amd.c  |    2 +-
 arch/x86/oprofile/op_model_p4.c   |    4 ++--
 arch/x86/oprofile/op_model_ppro.c |    2 +-
 arch/x86/oprofile/op_x86_model.h  |    8 ++++----
 5 files changed, 10 insertions(+), 10 deletions(-)
arch/x86/oprofile/nmi_int.c +2 -2
index 998c7dc..826f391 100644
@@ -27,7 +27,7 @@
 #include "op_counter.h"
 #include "op_x86_model.h"
 
-static struct op_x86_model_spec const *model;
+static struct op_x86_model_spec *model;
 static DEFINE_PER_CPU(struct op_msrs, cpu_msrs);
 static DEFINE_PER_CPU(unsigned long, saved_lvtpc);
 
@@ -542,7 +542,7 @@ module_param_call(cpu_type, force_cpu_type, NULL, NULL, 0);
 static int __init ppro_init(char **cpu_type)
 {
 	__u8 cpu_model = boot_cpu_data.x86_model;
-	struct op_x86_model_spec const *spec = &op_ppro_spec;	/* default */
+	struct op_x86_model_spec *spec = &op_ppro_spec;	/* default */
 
 	if (force_arch_perfmon && cpu_has_arch_perfmon)
 		return 0;
arch/x86/oprofile/op_model_amd.c +1 -1
index 644980f..39604b4 100644
@@ -526,7 +526,7 @@ static void op_amd_exit(void) {}
 
 #endif /* CONFIG_OPROFILE_IBS */
 
-struct op_x86_model_spec const op_amd_spec = {
+struct op_x86_model_spec op_amd_spec = {
 	.num_counters		= NUM_COUNTERS,
 	.num_controls		= NUM_CONTROLS,
 	.num_virt_counters	= NUM_VIRT_COUNTERS,
arch/x86/oprofile/op_model_p4.c +2 -2
index 65b9237..40df028 100644
@@ -695,7 +695,7 @@ static void p4_shutdown(struct op_msrs const * const msrs)
 
 
 #ifdef CONFIG_SMP
-struct op_x86_model_spec const op_p4_ht2_spec = {
+struct op_x86_model_spec op_p4_ht2_spec = {
 	.num_counters		= NUM_COUNTERS_HT2,
 	.num_controls		= NUM_CONTROLS_HT2,
 	.num_virt_counters	= NUM_COUNTERS_HT2,
@@ -709,7 +709,7 @@ struct op_x86_model_spec const op_p4_ht2_spec = {
 };
 #endif
 
-struct op_x86_model_spec const op_p4_spec = {
+struct op_x86_model_spec op_p4_spec = {
 	.num_counters		= NUM_COUNTERS_NON_HT,
 	.num_controls		= NUM_CONTROLS_NON_HT,
 	.num_virt_counters	= NUM_COUNTERS_NON_HT,
arch/x86/oprofile/op_model_ppro.c +1 -1
index 098cbca..659f3b6 100644
@@ -203,7 +203,7 @@ static void ppro_shutdown(struct op_msrs const * const msrs)
 }
 
 
-struct op_x86_model_spec const op_ppro_spec = {
+struct op_x86_model_spec op_ppro_spec = {
 	.num_counters		= 2,
 	.num_controls		= 2,
 	.num_virt_counters	= 2,
arch/x86/oprofile/op_x86_model.h +4 -4
index e874dc3..0c886fa 100644
@@ -62,10 +62,10 @@ extern u64 op_x86_get_ctrl(struct op_x86_model_spec const *model,
 			   struct op_counter_config *counter_config);
 extern int op_x86_phys_to_virt(int phys);
 
-extern struct op_x86_model_spec const op_ppro_spec;
-extern struct op_x86_model_spec const op_p4_spec;
-extern struct op_x86_model_spec const op_p4_ht2_spec;
-extern struct op_x86_model_spec const op_amd_spec;
+extern struct op_x86_model_spec op_ppro_spec;
+extern struct op_x86_model_spec op_p4_spec;
+extern struct op_x86_model_spec op_p4_ht2_spec;
+extern struct op_x86_model_spec op_amd_spec;
 extern struct op_x86_model_spec op_arch_perfmon_spec;
 
 #endif /* OP_X86_MODEL_H */
Signature · 1 line
1.6.3.3
#18 lore raw

PATCH 18/26 x86/oprofile: Remove unused num_virt_controls from struct op_x86_model_spec

In reply to Robert Richter

The member num_virt_controls of struct op_x86_model_spec is not used. This patch removes it.

---
 arch/x86/oprofile/op_model_amd.c  |    1 -
 arch/x86/oprofile/op_model_p4.c   |    2 --
 arch/x86/oprofile/op_model_ppro.c |    1 -
 arch/x86/oprofile/op_x86_model.h  |    1 -
 4 files changed, 0 insertions(+), 5 deletions(-)
arch/x86/oprofile/op_model_amd.c +0 -1
index 39604b4..dce69b5 100644
@@ -530,7 +530,6 @@ struct op_x86_model_spec op_amd_spec = {
 	.num_counters		= NUM_COUNTERS,
 	.num_controls		= NUM_CONTROLS,
 	.num_virt_counters	= NUM_VIRT_COUNTERS,
-	.num_virt_controls	= NUM_VIRT_CONTROLS,
 	.reserved		= MSR_AMD_EVENTSEL_RESERVED,
 	.event_mask		= OP_EVENT_MASK,
 	.init			= op_amd_init,
arch/x86/oprofile/op_model_p4.c +0 -2
index 40df028..0a4f2de 100644
@@ -699,7 +699,6 @@ struct op_x86_model_spec op_p4_ht2_spec = {
 	.num_counters		= NUM_COUNTERS_HT2,
 	.num_controls		= NUM_CONTROLS_HT2,
 	.num_virt_counters	= NUM_COUNTERS_HT2,
-	.num_virt_controls	= NUM_CONTROLS_HT2,
 	.fill_in_addresses	= &p4_fill_in_addresses,
 	.setup_ctrs		= &p4_setup_ctrs,
 	.check_ctrs		= &p4_check_ctrs,
@@ -713,7 +712,6 @@ struct op_x86_model_spec op_p4_spec = {
 	.num_counters		= NUM_COUNTERS_NON_HT,
 	.num_controls		= NUM_CONTROLS_NON_HT,
 	.num_virt_counters	= NUM_COUNTERS_NON_HT,
-	.num_virt_controls	= NUM_CONTROLS_NON_HT,
 	.fill_in_addresses	= &p4_fill_in_addresses,
 	.setup_ctrs		= &p4_setup_ctrs,
 	.check_ctrs		= &p4_check_ctrs,
arch/x86/oprofile/op_model_ppro.c +0 -1
index 659f3b6..753a02a 100644
@@ -207,7 +207,6 @@ struct op_x86_model_spec op_ppro_spec = {
 	.num_counters		= 2,
 	.num_controls		= 2,
 	.num_virt_counters	= 2,
-	.num_virt_controls	= 2,
 	.reserved		= MSR_PPRO_EVENTSEL_RESERVED,
 	.fill_in_addresses	= &ppro_fill_in_addresses,
 	.setup_ctrs		= &ppro_setup_ctrs,
arch/x86/oprofile/op_x86_model.h +0 -1
index 0c886fa..4e2e7c2 100644
@@ -37,7 +37,6 @@ struct op_x86_model_spec {
 	unsigned int	num_counters;
 	unsigned int	num_controls;
 	unsigned int	num_virt_counters;
-	unsigned int	num_virt_controls;
 	u64		reserved;
 	u16		event_mask;
 	int		(*init)(struct oprofile_operations *ops);
Signature · 1 line
1.6.3.3
#19 lore raw

PATCH 19/26 x86/oprofile: Modify initialization of num_virt_counters

In reply to Robert Richter

Models that do not yet support counter multiplexing have to setup num_virt_counters. This patch implements the setup from num_counters if num_virt_counters is not set. Thus, num_virt_counters must be setup only for multiplexing support.

---
 arch/x86/oprofile/nmi_int.c       |    3 +++
 arch/x86/oprofile/op_model_p4.c   |    2 --
 arch/x86/oprofile/op_model_ppro.c |    1 -
 3 files changed, 3 insertions(+), 3 deletions(-)
arch/x86/oprofile/nmi_int.c +3 -0
index 826f391..82ee295 100644
@@ -674,6 +674,9 @@ int __init op_nmi_init(struct oprofile_operations *ops)
 	if (ret)
 		return ret;
 
+	if (!model->num_virt_counters)
+		model->num_virt_counters = model->num_counters;
+
 	init_sysfs();
 	using_nmi = 1;
 	printk(KERN_INFO "oprofile: using NMI interrupt.\n");
arch/x86/oprofile/op_model_p4.c +0 -2
index 0a4f2de..ac6b354 100644
@@ -698,7 +698,6 @@ static void p4_shutdown(struct op_msrs const * const msrs)
 struct op_x86_model_spec op_p4_ht2_spec = {
 	.num_counters		= NUM_COUNTERS_HT2,
 	.num_controls		= NUM_CONTROLS_HT2,
-	.num_virt_counters	= NUM_COUNTERS_HT2,
 	.fill_in_addresses	= &p4_fill_in_addresses,
 	.setup_ctrs		= &p4_setup_ctrs,
 	.check_ctrs		= &p4_check_ctrs,
@@ -711,7 +710,6 @@ struct op_x86_model_spec op_p4_ht2_spec = {
 struct op_x86_model_spec op_p4_spec = {
 	.num_counters		= NUM_COUNTERS_NON_HT,
 	.num_controls		= NUM_CONTROLS_NON_HT,
-	.num_virt_counters	= NUM_COUNTERS_NON_HT,
 	.fill_in_addresses	= &p4_fill_in_addresses,
 	.setup_ctrs		= &p4_setup_ctrs,
 	.check_ctrs		= &p4_check_ctrs,
arch/x86/oprofile/op_model_ppro.c +0 -1
index 753a02a..4899215 100644
@@ -206,7 +206,6 @@ static void ppro_shutdown(struct op_msrs const * const msrs)
 struct op_x86_model_spec op_ppro_spec = {
 	.num_counters		= 2,
 	.num_controls		= 2,
-	.num_virt_counters	= 2,
 	.reserved		= MSR_PPRO_EVENTSEL_RESERVED,
 	.fill_in_addresses	= &ppro_fill_in_addresses,
 	.setup_ctrs		= &ppro_setup_ctrs,
Signature · 1 line
1.6.3.3
#20 lore raw

PATCH 20/26 x86/oprofile: Add function has_mux() to check multiplexing support

In reply to Robert Richter

The check is used to prevent running multiplexing code for models not supporting multiplexing. Before, the code was running but without effect.

---
 arch/x86/oprofile/nmi_int.c |   19 ++++++++++++++++++-
 1 files changed, 18 insertions(+), 1 deletions(-)
arch/x86/oprofile/nmi_int.c +18 -1
index 82ee295..dca7240 100644
@@ -124,6 +124,11 @@ static void nmi_stop(void)
 
 static DEFINE_PER_CPU(int, switch_index);
 
+static inline int has_mux(void)
+{
+	return !!model->switch_ctrl;
+}
+
 inline int op_x86_phys_to_virt(int phys)
 {
 	return __get_cpu_var(switch_index) + phys;
@@ -132,6 +137,10 @@ inline int op_x86_phys_to_virt(int phys)
 static void nmi_shutdown_mux(void)
 {
 	int i;
+
+	if (!has_mux())
+		return;
+
 	for_each_possible_cpu(i) {
 		kfree(per_cpu(cpu_msrs, i).multiplex);
 		per_cpu(cpu_msrs, i).multiplex = NULL;
@@ -144,12 +153,17 @@ static int nmi_setup_mux(void)
 	size_t multiplex_size =
 		sizeof(struct op_msr) * model->num_virt_counters;
 	int i;
+
+	if (!has_mux())
+		return 1;
+
 	for_each_possible_cpu(i) {
 		per_cpu(cpu_msrs, i).multiplex =
 			kmalloc(multiplex_size, GFP_KERNEL);
 		if (!per_cpu(cpu_msrs, i).multiplex)
 			return 0;
 	}
+
 	return 1;
 }
 
@@ -158,6 +172,9 @@ static void nmi_cpu_setup_mux(int cpu, struct op_msrs const * const msrs)
 	int i;
 	struct op_msr *multiplex = msrs->multiplex;
 
+	if (!has_mux())
+		return;
+
 	for (i = 0; i < model->num_virt_counters; ++i) {
 		if (counter_config[i].enabled) {
 			multiplex[i].saved = -(u64)counter_config[i].count;
@@ -229,7 +246,7 @@ static int nmi_multiplex_on(void)
 
 static int nmi_switch_event(void)
 {
-	if (!model->switch_ctrl)
+	if (!has_mux())
 		return -ENOSYS;		/* not implemented */
 	if (nmi_multiplex_on() < 0)
 		return -EINVAL;		/* not necessary */
Signature · 1 line
1.6.3.3
#21 lore raw

PATCH 21/26 x86/oprofile: Enable multiplexing only if the model supports it

In reply to Robert Richter

This patch checks if the model supports multiplexing. Only then multiplexing will be enabled. The code is added to the common x86 initialization.

---
 arch/x86/oprofile/nmi_int.c |   12 +++++++++---
 1 files changed, 9 insertions(+), 3 deletions(-)
arch/x86/oprofile/nmi_int.c +9 -3
index dca7240..f0fb447 100644
@@ -258,6 +258,12 @@ static int nmi_switch_event(void)
 	return 0;
 }
 
+static inline void mux_init(struct oprofile_operations *ops)
+{
+	if (has_mux())
+		ops->switch_events = nmi_switch_event;
+}
+
 #else
 
 inline int op_x86_phys_to_virt(int phys) { return phys; }
@@ -265,6 +271,7 @@ static inline void nmi_shutdown_mux(void) { }
 static inline int nmi_setup_mux(void) { return 1; }
 static inline void
 nmi_cpu_setup_mux(int cpu, struct op_msrs const * const msrs) { }
+static inline void mux_init(struct oprofile_operations *ops) { }
 
 #endif
 
@@ -682,9 +689,6 @@ int __init op_nmi_init(struct oprofile_operations *ops)
 	ops->start		= nmi_start;
 	ops->stop		= nmi_stop;
 	ops->cpu_type		= cpu_type;
-#ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
-	ops->switch_events	= nmi_switch_event;
-#endif
 
 	if (model->init)
 		ret = model->init(ops);
@@ -694,6 +698,8 @@ int __init op_nmi_init(struct oprofile_operations *ops)
 	if (!model->num_virt_counters)
 		model->num_virt_counters = model->num_counters;
 
+	mux_init(ops);
+
 	init_sysfs();
 	using_nmi = 1;
 	printk(KERN_INFO "oprofile: using NMI interrupt.\n");
Signature · 1 line
1.6.3.3
#22 lore raw

PATCH 22/26 x86/oprofile: Implement mux_clone()

In reply to Robert Richter

To setup a counter for all cpus, its structure is cloned from cpu
0. This patch implements mux_clone() to do this part for multiplexing data.

---
 arch/x86/oprofile/nmi_int.c |   37 +++++++++++++++++++++++--------------
 1 files changed, 23 insertions(+), 14 deletions(-)
arch/x86/oprofile/nmi_int.c +23 -14
index f0fb447..da6d2ab 100644
@@ -264,6 +264,16 @@ static inline void mux_init(struct oprofile_operations *ops)
 		ops->switch_events = nmi_switch_event;
 }
 
+static void mux_clone(int cpu)
+{
+	if (!has_mux())
+		return;
+
+	memcpy(per_cpu(cpu_msrs, cpu).multiplex,
+	       per_cpu(cpu_msrs, 0).multiplex,
+	       sizeof(struct op_msr) * model->num_virt_counters);
+}
+
 #else
 
 inline int op_x86_phys_to_virt(int phys) { return phys; }
@@ -272,6 +282,7 @@ static inline int nmi_setup_mux(void) { return 1; }
 static inline void
 nmi_cpu_setup_mux(int cpu, struct op_msrs const * const msrs) { }
 static inline void mux_init(struct oprofile_operations *ops) { }
+static void mux_clone(int cpu) { }
 
 #endif
 
@@ -350,20 +361,18 @@ static int nmi_setup(void)
 	/* Assume saved/restored counters are the same on all CPUs */
 	model->fill_in_addresses(&per_cpu(cpu_msrs, 0));
 	for_each_possible_cpu(cpu) {
-		if (cpu != 0) {
-			memcpy(per_cpu(cpu_msrs, cpu).counters,
-				per_cpu(cpu_msrs, 0).counters,
-				sizeof(struct op_msr) * model->num_counters);
-
-			memcpy(per_cpu(cpu_msrs, cpu).controls,
-				per_cpu(cpu_msrs, 0).controls,
-				sizeof(struct op_msr) * model->num_controls);
-#ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
-			memcpy(per_cpu(cpu_msrs, cpu).multiplex,
-				per_cpu(cpu_msrs, 0).multiplex,
-				sizeof(struct op_msr) * model->num_virt_counters);
-#endif
-		}
+		if (!cpu)
+			continue;
+
+		memcpy(per_cpu(cpu_msrs, cpu).counters,
+		       per_cpu(cpu_msrs, 0).counters,
+		       sizeof(struct op_msr) * model->num_counters);
+
+		memcpy(per_cpu(cpu_msrs, cpu).controls,
+		       per_cpu(cpu_msrs, 0).controls,
+		       sizeof(struct op_msr) * model->num_controls);
+
+		mux_clone(cpu);
 	}
 	on_each_cpu(nmi_cpu_setup, NULL, 1);
 	nmi_enabled = 1;
Signature · 1 line
1.6.3.3
#23 lore raw

PATCH 23/26 oprofile: Adding switch counter to oprofile statistic variables

In reply to Robert Richter

This patch moves the multiplexing switch counter from x86 code to common oprofile statistic variables. Now the value will be available and usable for all architectures. The initialization and incrementation also moved to common code.

---
 arch/x86/oprofile/nmi_int.c       |    7 -------
 drivers/oprofile/oprof.c          |    7 +++++--
 drivers/oprofile/oprofile_stats.c |    9 ++-------
 drivers/oprofile/oprofile_stats.h |    1 +
 4 files changed, 8 insertions(+), 16 deletions(-)
arch/x86/oprofile/nmi_int.c +0 -7
index da6d2ab..7b3362f 100644
@@ -34,11 +34,6 @@ static DEFINE_PER_CPU(unsigned long, saved_lvtpc);
 /* 0 == registered but off, 1 == registered and on */
 static int nmi_enabled = 0;
 
-
-#ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
-extern atomic_t multiplex_counter;
-#endif
-
 struct op_counter_config counter_config[OP_MAX_COUNTER];
 
 /* common functions */
@@ -253,8 +248,6 @@ static int nmi_switch_event(void)
 
 	on_each_cpu(nmi_cpu_switch, NULL, 1);
 
-	atomic_inc(&multiplex_counter);
-
 	return 0;
 }
 
drivers/oprofile/oprof.c +5 -2
index a48294a..dc8a042 100644
@@ -107,8 +107,11 @@ static void stop_switch_worker(void)
 
 static void switch_worker(struct work_struct *work)
 {
-	if (!oprofile_ops.switch_events())
-		start_switch_worker();
+	if (oprofile_ops.switch_events())
+		return;
+
+	atomic_inc(&oprofile_stats.multiplex_counter);
+	start_switch_worker();
 }
 
 /* User inputs in ms, converts to jiffies */
drivers/oprofile/oprofile_stats.c +2 -7
index 77a57a6..61689e8 100644
@@ -16,9 +16,6 @@
 #include "cpu_buffer.h"
 
 struct oprofile_stat_struct oprofile_stats;
-#ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
-atomic_t multiplex_counter;
-#endif
 
 void oprofile_reset_stats(void)
 {
@@ -37,9 +34,7 @@ void oprofile_reset_stats(void)
 	atomic_set(&oprofile_stats.sample_lost_no_mapping, 0);
 	atomic_set(&oprofile_stats.event_lost_overflow, 0);
 	atomic_set(&oprofile_stats.bt_lost_no_mapping, 0);
-#ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
-	atomic_set(&multiplex_counter, 0);
-#endif
+	atomic_set(&oprofile_stats.multiplex_counter, 0);
 }
 
 
@@ -84,6 +79,6 @@ void oprofile_create_stats_files(struct super_block *sb, struct dentry *root)
 		&oprofile_stats.bt_lost_no_mapping);
 #ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
 	oprofilefs_create_ro_atomic(sb, dir, "multiplex_counter",
-		&multiplex_counter);
+		&oprofile_stats.multiplex_counter);
 #endif
 }
drivers/oprofile/oprofile_stats.h +1 -0
index 3da0d08..0b54e46 100644
@@ -17,6 +17,7 @@ struct oprofile_stat_struct {
 	atomic_t sample_lost_no_mapping;
 	atomic_t bt_lost_no_mapping;
 	atomic_t event_lost_overflow;
+	atomic_t multiplex_counter;
 };
 
 extern struct oprofile_stat_struct oprofile_stats;
Signature · 1 line
1.6.3.3
#24 lore raw

PATCH 24/26 x86/oprofile: Implement op_x86_virt_to_phys()

In reply to Robert Richter

This patch implements a common x86 function to convert virtual counter numbers to physical.

---
 arch/x86/oprofile/nmi_int.c      |    6 ++++++
 arch/x86/oprofile/op_model_amd.c |    2 +-
 arch/x86/oprofile/op_x86_model.h |    1 +
 3 files changed, 8 insertions(+), 1 deletions(-)
arch/x86/oprofile/nmi_int.c +6 -0
index 7b3362f..5856e61 100644
@@ -129,6 +129,11 @@ inline int op_x86_phys_to_virt(int phys)
 	return __get_cpu_var(switch_index) + phys;
 }
 
+inline int op_x86_virt_to_phys(int virt)
+{
+	return virt % model->num_counters;
+}
+
 static void nmi_shutdown_mux(void)
 {
 	int i;
@@ -270,6 +275,7 @@ static void mux_clone(int cpu)
 #else
 
 inline int op_x86_phys_to_virt(int phys) { return phys; }
+inline int op_x86_virt_to_phys(int virt) { return virt; }
 static inline void nmi_shutdown_mux(void) { }
 static inline int nmi_setup_mux(void) { return 1; }
 static inline void
arch/x86/oprofile/op_model_amd.c +1 -1
index dce69b5..1ea1982 100644
@@ -81,7 +81,7 @@ static void op_mux_fill_in_addresses(struct op_msrs * const msrs)
 	int i;
 
 	for (i = 0; i < NUM_VIRT_COUNTERS; i++) {
-		int hw_counter = i % NUM_COUNTERS;
+		int hw_counter = op_x86_virt_to_phys(i);
 		if (reserve_perfctr_nmi(MSR_K7_PERFCTR0 + i))
 			msrs->multiplex[i].addr = MSR_K7_PERFCTR0 + hw_counter;
 		else
arch/x86/oprofile/op_x86_model.h +1 -0
index 4e2e7c2..b837761 100644
@@ -60,6 +60,7 @@ struct op_counter_config;
 extern u64 op_x86_get_ctrl(struct op_x86_model_spec const *model,
 			   struct op_counter_config *counter_config);
 extern int op_x86_phys_to_virt(int phys);
+extern int op_x86_virt_to_phys(int virt);
 
 extern struct op_x86_model_spec op_ppro_spec;
 extern struct op_x86_model_spec op_p4_spec;
Signature · 1 line
1.6.3.3
#25 lore raw

PATCH 25/26 x86/oprofile: Add counter reservation check for virtual counters

In reply to Robert Richter

This patch adds a check for the availability of a counter. A virtual counter is used only if its physical counter is not reserved.

---
 arch/x86/oprofile/nmi_int.c |    4 +---
 1 files changed, 1 insertions(+), 3 deletions(-)
arch/x86/oprofile/nmi_int.c +1 -3
index 5856e61..cb88b1a 100644
@@ -435,15 +435,13 @@ static int nmi_create_files(struct super_block *sb, struct dentry *root)
 		struct dentry *dir;
 		char buf[4];
 
-#ifndef CONFIG_OPROFILE_EVENT_MULTIPLEX
 		/* quick little hack to _not_ expose a counter if it is not
 		 * available for use.  This should protect userspace app.
 		 * NOTE:  assumes 1:1 mapping here (that counters are organized
 		 *        sequentially in their struct assignment).
 		 */
-		if (unlikely(!avail_to_resrv_perfctr_nmi_bit(i)))
+		if (!avail_to_resrv_perfctr_nmi_bit(op_x86_virt_to_phys(i)))
 			continue;
-#endif /* CONFIG_OPROFILE_EVENT_MULTIPLEX */
 
 		snprintf(buf,  sizeof(buf), "%d", i);
 		dir = oprofilefs_mkdir(sb, root, buf);
Signature · 1 line
1.6.3.3
#26 lore raw

PATCH 26/26 x86/oprofile: Small coding style fixes

In reply to Robert Richter

Some small coding style fixes.

---
 arch/x86/oprofile/op_model_amd.c |    5 ++---
 1 files changed, 2 insertions(+), 3 deletions(-)
arch/x86/oprofile/op_model_amd.c +2 -3
index 1ea1982..827beec 100644
@@ -144,11 +144,10 @@ static void op_amd_setup_ctrs(struct op_x86_model_spec const *model,
 
 	/* setup reset_value */
 	for (i = 0; i < NUM_VIRT_COUNTERS; ++i) {
-		if (counter_config[i].enabled) {
+		if (counter_config[i].enabled)
 			reset_value[i] = counter_config[i].count;
-		} else {
+		else
 			reset_value[i] = 0;
-		}
 	}
 
 	/* clear all counters */
Signature · 1 line
1.6.3.3
#27 lore raw
In reply to Robert Richter

arch/Kconfig config OPROFILE_IBS · line 42

Quoted 12 lines · Robert Richter
arch/Kconfig +10 -0
 	  If unsure, say N.
 
+config OPROFILE_EVENT_MULTIPLEX
+	bool "OProfile multiplexing support (EXPERIMENTAL)"
+	default n
+	depends on OPROFILE && X86
+	help
+	  The number of hardware counters is limited. The multiplexing
+	  feature enables OProfile to gather more events than counters
+	  are provided by the hardware. This is realized by switching
+	  between events at an user specified time interval.
+

I would suggest to drop that CONFIG and have the code unconditional. It's not a lot code and should be always available.

Will do more detailed review later and will look at Intel P6 support.

Where's the userland support for this?

-Andi

Signature · 1 line
[email protected] -- Speaking for myself only.
#28 lore raw

Hi,

The user-space support is currently in AMD CodeAnalyst utility. I am working on the more generic user-space support (non-AMD specific) and will send the patches to OProfile for review.

Suravee

-----Original Message-----
From: Andi Kleen [mailto:[email protected]]
Sent: Tuesday, July 28, 2009 1:45 PM
To: Richter, Robert
Cc: LKML; oprofile-list
Subject: Re: [PATCH 0/26] oprofile: Performance counter multiplexing

arch/Kconfig config OPROFILE_IBS · line 42

Quoted 12 lines · Robert Richter
arch/Kconfig +10 -0
 	  If unsure, say N.
 
+config OPROFILE_EVENT_MULTIPLEX
+	bool "OProfile multiplexing support (EXPERIMENTAL)"
+	default n
+	depends on OPROFILE && X86
+	help
+	  The number of hardware counters is limited. The multiplexing
+	  feature enables OProfile to gather more events than counters
+	  are provided by the hardware. This is realized by switching
+	  between events at an user specified time interval.
+

I would suggest to drop that CONFIG and have the code unconditional. It's not a lot code and should be always available.

Will do more detailed review later and will look at Intel P6 support.

Where's the userland support for this?

-Andi

Signature · 14 lines
[email protected] -- Speaking for myself only.

------------------------------------------------------------------------
------
Let Crystal Reports handle the reporting - Free Crystal Reports 2008
30-Day 
trial. Simplify your report design, integration and deployment - and
focus on 
what you do best, core application coding. Discover what's new with 
Crystal Reports now.  http://p.sf.net/sfu/bobj-july
_______________________________________________
oprofile-list mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/oprofile-list
#29 lore raw
In reply to Robert Richter

( Linus and perfcounters folks Cc:-ed - i'd like to solicite
suggestions about future oprofile design and subsystem maintainance directions. I'd also like to preempt potential "Why did you pull this crap???" flames from Linus in the .32 merge window ;-)

Quoted 68 lines · Robert Richter

This patch series introduces performance counter multiplexing for oprofile.

The number of hardware counters is limited. The multiplexing feature enables OProfile to gather more events than counters are provided by the hardware. This is realized by switching between events at an user specified time interval.

A new file (/dev/oprofile/time_slice) is added for the user to specify the timer interval in ms. If the number of events to profile is higher than the number of hardware counters available, the patch will schedule a work queue that switches the event counter and re-writes the different sets of values into it. The switching mechanism needs to be implemented for each architecture to support multiplexing. This patch series only implements AMD CPU support, but multiplexing can be easily extended for other models and architectures.

The patch set includes the initial patch from Jason Yeh and many code improvements and reworks on top. It evolved over time and documents its development. Thus, for review also the enclosed overall diff might be useful.

The patches can be pulled from:

git://git.kernel.org/pub/scm/linux/kernel/git/rric/oprofile.git mux

-Robert

The following changes since commit 8045a4c293d36c61656a20d581b11f7f0cd7acd5:
Robert Richter (1):
x86/oprofile: Fix cast of counter value

are available in the git repository at:

git://git.kernel.org/pub/scm/linux/kernel/git/rric/oprofile.git mux

Jason Yeh (1):
oprofile: Implement performance counter multiplexing

Robert Richter (25):
x86/oprofile: Rework and simplify nmi_cpu_setup() x86/oprofile: Whitespaces changes only
x86/oprofile: Fix usage of NUM_CONTROLS/NUM_COUNTERS macros x86/oprofile: Use per_cpu() instead of __get_cpu_var() x86/oprofile: Fix initialization of switch_index
oprofile: oprofile_set_timeout(), return with error for invalid args
oprofile: Rename variable timeout_jiffies and move to oprofile_files.c
oprofile: Remove oprofile_multiplexing_init()
oprofile: Grouping multiplexing code in oprof.c
oprofile: Introduce op_x86_phys_to_virt()
oprofile: Grouping multiplexing code in op_model_amd.c x86/oprofile: Implement multiplexing setup/shutdown functions x86/oprofile: Moving nmi_setup_cpu_mux() in nmi_int.c x86/oprofile: Moving nmi_cpu_save/restore_mpx_registers() in nmi_int.c x86/oprofile: Moving nmi_cpu_switch() in nmi_int.c x86/oprofile: Remove const qualifier from struct op_x86_model_spec x86/oprofile: Remove unused num_virt_controls from struct op_x86_model_spec x86/oprofile: Modify initialization of num_virt_counters x86/oprofile: Add function has_mux() to check multiplexing support x86/oprofile: Enable multiplexing only if the model supports it x86/oprofile: Implement mux_clone()
oprofile: Adding switch counter to oprofile statistic variables x86/oprofile: Implement op_x86_virt_to_phys()
x86/oprofile: Add counter reservation check for virtual counters x86/oprofile: Small coding style fixes

Quoted 14 lines
 arch/Kconfig                      |   12 ++
 arch/x86/oprofile/nmi_int.c       |  307 +++++++++++++++++++++++++++++--------
 arch/x86/oprofile/op_counter.h    |    2 +-
 arch/x86/oprofile/op_model_amd.c  |  127 ++++++++++++----
 arch/x86/oprofile/op_model_p4.c   |   12 +-
 arch/x86/oprofile/op_model_ppro.c |   10 +-
 arch/x86/oprofile/op_x86_model.h  |   16 ++-
 drivers/oprofile/oprof.c          |   71 +++++++++-
 drivers/oprofile/oprof.h          |    3 +
 drivers/oprofile/oprofile_files.c |   46 ++++++
 drivers/oprofile/oprofile_stats.c |    5 +
 drivers/oprofile/oprofile_stats.h |    1 +
 include/linux/oprofile.h          |    3 +
 13 files changed, 501 insertions(+), 114 deletions(-)

Ok. The oprofile patches have been going upstream via -tip and i've been pulling and testing/relaying them for upstream for more than a year with pretty good results.

Now i'm also co-maintaining perfcounters and because it's a full oprofile replacement (which aspect Robert seems to disagree with ;-) i'd like to make sure it's not seen by Robert as a conflict of interest so let me raise the following questions publicly:

This new oprofile multiplexing mechanism really overlaps the PMU abstractions that perfcounters already provide, and i disagree with this general direction. The code you wrote is clean though so i've (reluctantly) pulled it into tip:oprofile and started testing it, and will send it Linus-wards in the .32 merge window - unless Linus agrees with my general objections against this oprofile direction.

The reason for my disagreement is on the technical and on the policy level.

Here's the (rough) support comparison matrix:

perfcounters | oprofile-mux
..........................................
granularity: per task or per cpu | per cpu

                                           .
   switch mechanism:             interrupt |            workqueue
                                           .
   limits:                 soft, unlimited |      hardcoded to 32
                                           .

arch support: generic, all | AMD only, needs per
perfcounter arches | cpu and arch changes

The perfcounters multiplexing is visibly more mature and more
capable: more generic, integrated into the scheduler, not hardcoded, etc.

And the oprofile bits are for x86 (AMD) only, with every oprofile architecture having to do similarly invasive changes - so these 500 lines of changes probably get multipled by a factor of 10 or so in the end, years down the line. A lot of work and i think it can and should all be avoided.

So there are two technical/policy questions:

Would it be fair to require oprofile to implement a similarly high-quality counter virtualization as perfcounters? If yes then i think the end result would be oprofile based on perfcounters: i.e. this particular oprofile-mux patchset becomes largely moot and we'd not have to go through the (non-trivial) transition period of updating every single oprofile driver for multiplexing.

The other question is: do we really want to have a constant distraction via the overlapping oprofile space? I think a feasible and sane looking approach would be to:

- Put oprofile into maintenance mode, fix all bugs that get reported/found, perhaps add new hw enablement drivers in the existing scheme (if they are submitted) but otherwise dont complicate the code any more.

- Extend PMU and performance instrumentation support via perfcounters primarily.

- Possibly base oprofile user-space on perfcounters syscalls (with a fall-back to old oprofile syscalls on older kernels), if there's interest from folks who want the oprofile tool-chain, allowing the removal of the oprofile kernel code in the long run.

This series of steps seems to be the technically sanest approach to me, and we are certainly willing to extend perfcounters in any fashion to allow a fuller replacement for oprofile. (we already think it's a worthy replacement and more - but we are open to all enhancements.)

I'd not be against maintaining the code in its current form, but i'm not sure whether we should extend the core oprofile code itself with things like the multiplexing code above which is seriously non-trivial and splits both developer attention and testing efforts.

Linus, Peter, Paul, do you have any preferences? I'm really on two minds about whether to do this oprofile feature. The overlap of this patch-set with perfcounters is serious, the induced complexity is serious and the ongoing maintenance cost is non-trivial.

Since PMU developers is a more or less constant pool of people, these policy issues do matter IMO and affect perfcounters as well indirectly, not just oprofile. Hardware vendors generally want to enable all facilities that are in the kernel, regardless of which one we consider to be the best one. So by forcing development of a new oprofile driver variant, resources are taken away from perfcounters.

It's as if we continued maintaining and developing ipchains after iptables was merged upstream. Instead we used compatibility mechanisms and phased out ipchains rather gracefully. Robert is apparently of the opinion that oprofile needs to be developed further - hence these questions.

So on those grounds i'm (mildly) inclined to not do this and suggest that we work on achieving the same end result via other means: via the perfcounters enabling of oprofile userspace.

But if Linus/Peter/Paul thinks that pulling it was the right solution then i'll keep the bits - i wanted to have a public discussion of these questions first.

Thanks,

Ingo

#30 lore raw
Quoted 4 lines · On Mon, 3 Aug 2009 13:22:20 +0200 Ingo Molnar <[email protected]> wrote:

This new oprofile multiplexing mechanism really overlaps the PMU abstractions that perfcounters already provide, and i disagree with this general direction. The code you wrote is clean though so i've

is there any way thast the oprofole interfaces can be written on top of the low level perf infrastructure?

#31 lore raw
Quoted 10 lines · Arjan van de Ven
Quoted 5 lines · On Mon, 3 Aug 2009 13:22:20 +0200 Ingo Molnar <[email protected]> wrote:

This new oprofile multiplexing mechanism really overlaps the PMU abstractions that perfcounters already provide, and i disagree with this general direction. The code you wrote is clean though so i've

is there any way that the oprofile interfaces can be written on top of the low level perf infrastructure?

Everything 'can' be done - the question is, is that the best approach? The technically best interface to utilize perfcounters is not to whack it into the oprofile kernel code, but to minimally update the oprofile user-space code (the sample collection daemon) to use the sys_perf_counter_open() system call.

It is by far the most elegant solution and needs no kernel changes at all:

The oprofile daemon should open percpu sampling counters and create oprofile-compatible sample files. That way the rest of the oprofile user-space does not have to be touched at all. The raw event ids that oprofile knows about can be used in perfcounter parameters directly.

In such a mode of operation both oprofilefs and the dcookies syscall can be omitted completely - all of the kernel side oprofile code becomes mooted and pushed into legacy mode.

Is there any reason or oprofile property that makes this impossible or undesirable to do?

Ingo

#32 lore raw
Quoted 29 lines · Ingo Molnar
Quoted 10 lines · Arjan van de Ven
Quoted 5 lines · On Mon, 3 Aug 2009 13:22:20 +0200 Ingo Molnar <[email protected]> wrote:

This new oprofile multiplexing mechanism really overlaps the PMU abstractions that perfcounters already provide, and i disagree with this general direction. The code you wrote is clean though so i've

is there any way that the oprofile interfaces can be written on top of the low level perf infrastructure?

Everything 'can' be done - the question is, is that the best approach? The technically best interface to utilize perfcounters is not to whack it into the oprofile kernel code, but to minimally update the oprofile user-space code (the sample collection daemon) to use the sys_perf_counter_open() system call.

It is by far the most elegant solution and needs no kernel changes at all:

The oprofile daemon should open percpu sampling counters and create oprofile-compatible sample files. That way the rest of the oprofile user-space does not have to be touched at all. The raw event ids that oprofile knows about can be used in perfcounter parameters directly.

Quoted 6 lines

In such a mode of operation both oprofilefs and the dcookies syscall can be omitted completely - all of the kernel side oprofile code becomes mooted and pushed into legacy mode.

Is there any reason or oprofile property that makes this impossible or undesirable to do?

The question is more if it makes sense. It's new to me dropping user/kernel interfaces that are in use and forcing its developers to rewrite their code. Oprofile is actively developed and in many distros. It supports architectures perfcounters doesn't. So, what do you want?

And why not having more than one profiling subsystem in the kernel? I see also more than one type of car on the street though all of them have 4 wheels.

-Robert

Signature · 3 lines
Advanced Micro Devices, Inc.
Operating System Research Center
email: [email protected]
#33 lore raw

Hi Robert,

Quoted 5 lines · Robert Richter

The question is more if it makes sense. It's new to me dropping user/kernel interfaces that are in use and forcing its developers to rewrite their code. Oprofile is actively developed and in many distros. It supports architectures perfcounters doesn't. So, what do you want?

Maybe we can keep the ABIs in place but use a common machinery under the hood for both perf and oprofile? That said, I do expect oprofile ABIs to be special meaning that there's probably not a whole lot users other than the oprofile user-space tool? So if do convert the user-space tool to use sys_perf_counter_open() and put the in-kernel oprofile code into deep-maintenance mode, maybe we can eventually get rid of it?

That said, the lack of architecture support for perf is definitely a blocker here...

Quoted 3 lines · Robert Richter

And why not having more than one profiling subsystem in the kernel? I see also more than one type of car on the street though all of them have 4 wheels.

Well, so far I've only had bad experiences with duplicate functionality in the kernel be it a core kernel subsystem like slab or a device driver (broadcom and e100 come to mind). The problem is that you fragment tester and developer base and end up with a different set of bugs for each of the duplicate components causing more work than necessary. And what eventually happens is that you have only one component that's under active development but you can't get rid of the less active ones because people depend on them and the active one has corner case bugs that just don't get fixed.

Pekka

#34 lore raw
Quoted 10 lines · Pekka Enberg

Hi Robert,

Quoted 5 lines · Robert Richter

The question is more if it makes sense. It's new to me dropping user/kernel interfaces that are in use and forcing its developers to rewrite their code. Oprofile is actively developed and in many distros. It supports architectures perfcounters doesn't. So, what do you want?

Quoted 7 lines

Maybe we can keep the ABIs in place but use a common machinery under the hood for both perf and oprofile? That said, I do expect oprofile ABIs to be special meaning that there's probably not a whole lot users other than the oprofile user-space tool? So if do convert the user-space tool to use sys_perf_counter_open() and put the in-kernel oprofile code into deep-maintenance mode, maybe we can eventually get rid of it?

Note, we dont need to (and dont want to) 'get rid of oprofile' - that's not the point. Nobody is arguing for instant removal of oprofile.

All i'm arguing for is to not rewrite all oprofile drivers while we try to extend perfcounters support. Robert's series does exactly that and that's where my unhappiness comes from ...

As you note it below, in terms of development it's quite a distraction to have active development in both facilities, when oprofile is arguably on the to-be-obsoleted side of the equation.

Converting the user-space oprofile tools: instead of some in-kernel wrappery, the right approach is to use the already existing high level interface: to use sys_perf_counter_open() in the oprofile daemon.

It only affects the sample collection daemon (which is a small portion of oprofile user-space) and needs no kernel changes. This is what i suggested to Robert before and i've seen no argument why this cannot be done.

An added bonus is that the legacy oprofile kernel ABI can stay completely untouched. (and the oprofile tooling can fall back to it)

And yes, AFAIK oprofile user-space is pretty much the only user-space app that relies on the oprofile ABI - at least in the OSS space. Robert, is there perhaps some bin-only oprofile based tool that you implied before? Which one is it?

Quoted 2 lines

That said, the lack of architecture support for perf is definitely a blocker here...

Note, here's the current (roughly calculated, possibly inaccurate) platform support matrix between oprofile and perfcounters:

+ : hw support available
0 : sw support available
- : no support

oprofile perfcounters

   alpha                   +             -
   arm                     +             -
   avr32                   +             -
   blackfin                -             -
   cris                    -             -
   frv                     -             0
   h8300                   -             -
   ia64                    +             -
   m32r                    -             -
   m68k                    -             -
   m68knommu               -             -
   microblaze              -             -
   mips                    +             0
   mn10300                 -             -
   parisc                  -             0
   powerpc                 +             +
   s390                    0             0
   sh                      +             0
   sparc                   0             0-[pending]
   x86                     +             +
   xtensa                  -             -

Takeaway points:

- out of 20 hardware architectures, 8 have oprofile hw-PMU support, 2 have timer-fallback support, 11 are not supported at all.

- out of 20 hardware architectures, 2 have perfcounters hw-PMU support, 6 have sw event support, 12 are not supported at all.

The architectures with the biggest practical weight are: x86, powerpc, arm, mips.

So there's a gap but it's not "all architectures" and the transition to perfcounters is well underway. Still, oprofile obviously leads (it has a 10 years headway) - and it's needed as a compatibility option during the migration and even if perf had equivalent support it would _still_ be around for some time as a pure ABI compatibility thing.

Quoted 6 lines · Robert Richter
Quoted 4 lines

And why not having more than one profiling subsystem in the kernel? I see also more than one type of car on the street though all of them have 4 wheels.

Quoted 10 lines

Well, so far I've only had bad experiences with duplicate functionality in the kernel be it a core kernel subsystem like slab or a device driver (broadcom and e100 come to mind). The problem is that you fragment tester and developer base and end up with a different set of bugs for each of the duplicate components causing more work than necessary. And what eventually happens is that you have only one component that's under active development but you can't get rid of the less active ones because people depend on them and the active one has corner case bugs that just don't get fixed.

Correct. That's my main point.

Ingo

#35 lore raw
Quoted 21 lines · Ingo Molnar
Quoted 10 lines · Pekka Enberg

Hi Robert,

Quoted 5 lines · Robert Richter

The question is more if it makes sense. It's new to me dropping user/kernel interfaces that are in use and forcing its developers to rewrite their code. Oprofile is actively developed and in many distros. It supports architectures perfcounters doesn't. So, what do you want?

Quoted 7 lines

Maybe we can keep the ABIs in place but use a common machinery under the hood for both perf and oprofile? That said, I do expect oprofile ABIs to be special meaning that there's probably not a whole lot users other than the oprofile user-space tool? So if do convert the user-space tool to use sys_perf_counter_open() and put the in-kernel oprofile code into deep-maintenance mode, maybe we can eventually get rid of it?

Quoted 3 lines

Note, we dont need to (and dont want to) 'get rid of oprofile' - that's not the point. Nobody is arguing for instant removal of oprofile.

This sound good to me...

Quoted 7 lines

All i'm arguing for is to not rewrite all oprofile drivers while we try to extend perfcounters support. Robert's series does exactly that and that's where my unhappiness comes from ...

As you note it below, in terms of development it's quite a distraction to have active development in both facilities, when oprofile is arguably on the to-be-obsoleted side of the equation.

Ingo, you can be sure, future implementations will keep the focus on perfcounters. A single pmu implementation is that I prefer too, it reduces development and testing efforts.

Quoted 5 lines

Converting the user-space oprofile tools: instead of some in-kernel wrappery, the right approach is to use the already existing high level interface: to use sys_perf_counter_open() in the oprofile daemon.

Quoted 7 lines

It only affects the sample collection daemon (which is a small portion of oprofile user-space) and needs no kernel changes. This is what i suggested to Robert before and i've seen no argument why this cannot be done.

An added bonus is that the legacy oprofile kernel ABI can stay completely untouched. (and the oprofile tooling can fall back to it)

I am fine with this. The oprofile daemon could be ported to use the perfcounters i/f and existing oprofile tools that are not ported may fall back to the legacy oprofile kernel ABI.

Quoted 4 lines

And yes, AFAIK oprofile user-space is pretty much the only user-space app that relies on the oprofile ABI - at least in the OSS space. Robert, is there perhaps some bin-only oprofile based tool that you implied before? Which one is it?

I know of hardware platform vendors using oprofile for system testing, but I don't know exactly how their user-land looks like and whether the daemon is used. AMD's CodeAnalyst tool (OSS) uses oprofile with an own daemon.

Quoted 46 lines
Quoted 3 lines

That said, the lack of architecture support for perf is definitely a blocker here...

Note, here's the current (roughly calculated, possibly inaccurate) platform support matrix between oprofile and perfcounters:

+ : hw support available
0 : sw support available
- : no support

oprofile perfcounters

   alpha                   +             -
   arm                     +             -
   avr32                   +             -
   blackfin                -             -
   cris                    -             -
   frv                     -             0
   h8300                   -             -
   ia64                    +             -
   m32r                    -             -
   m68k                    -             -
   m68knommu               -             -
   microblaze              -             -
   mips                    +             0
   mn10300                 -             -
   parisc                  -             0
   powerpc                 +             +
   s390                    0             0
   sh                      +             0
   sparc                   0             0-[pending]
   x86                     +             +
   xtensa                  -             -

Takeaway points:

- out of 20 hardware architectures, 8 have oprofile hw-PMU support, 2 have timer-fallback support, 11 are not supported at all.

- out of 20 hardware architectures, 2 have perfcounters hw-PMU support, 6 have sw event support, 12 are not supported at all.

The architectures with the biggest practical weight are: x86, powerpc, arm, mips.

Quoted 6 lines

So there's a gap but it's not "all architectures" and the transition to perfcounters is well underway. Still, oprofile obviously leads (it has a 10 years headway) - and it's needed as a compatibility option during the migration and even if perf had equivalent support it would _still_ be around for some time as a pure ABI compatibility thing.

Surely the argument of unsupported architectures will not be valid for a long time as its number for PCL will probably decrease fast.

Quoted 18 lines
Quoted 7 lines · Robert Richter
Quoted 4 lines

And why not having more than one profiling subsystem in the kernel? I see also more than one type of car on the street though all of them have 4 wheels.

Quoted 10 lines

Well, so far I've only had bad experiences with duplicate functionality in the kernel be it a core kernel subsystem like slab or a device driver (broadcom and e100 come to mind). The problem is that you fragment tester and developer base and end up with a different set of bugs for each of the duplicate components causing more work than necessary. And what eventually happens is that you have only one component that's under active development but you can't get rid of the less active ones because people depend on them and the active one has corner case bugs that just don't get fixed.

Quoted 1 line

Correct. That's my main point.

I don't want to have duplicate implementations, I want to have multiple interfaces using the same in-kernel implementation. The code base developed and tested will be the same then.

In the end I don't see much disagreement at all.

-Robert

Signature · 3 lines
Advanced Micro Devices, Inc.
Operating System Research Center
email: [email protected]

A message that is not in the archive (sent off-list or not yet received): 20090806105134.GD11236__37984.4768475325$1249556453$gmane$org@elte.hu

#37 lore raw
Quoted 4 lines · Ingo Molnar

As you note it below, in terms of development it's quite a distraction to have active development in both facilities, when oprofile is arguably on the to-be-obsoleted side of the equation.

I don't see how it is distracting (for whom anyways?) at all to develop both. It's just like two ethernet/SCSI/... drivers being developed in parallel by different people. Happens all the time. The Linux development model can handle it.

That said the biggest problem with oprofile right now that the new buffer it's using is quite a lot less reliable and drops events left and right on any non trivial load. That makes oprofile very unreliable, especially in call graph mode.

So if there was a "legacy oprofile" it would be better to have one that does not use the ring buffer, but using the old buffer which at least worked. This would drop IBS support unfortunately, but perhaps that could be just done in perf only (depends on how big the IBS user base for current oprofile is)

Quoted 4 lines

And yes, AFAIK oprofile user-space is pretty much the only user-space app that relies on the oprofile ABI - at least in the OSS space. Robert, is there perhaps some bin-only oprofile based tool that you implied before? Which one is it?

There are multiple, e.g. Zoom or the old HP tool whose name escapes me now. Also I think there are a couple of minor forks around in various distro trees.

-Andi

Signature · 1 line
[email protected] -- Speaking for myself only.
#38 lore raw
Quoted 4 lines · Andi Kleen

That said the biggest problem with oprofile right now that the new buffer it's using is quite a lot less reliable and drops events left and right on any non trivial load. That makes oprofile very unreliable, especially in call graph mode.

(cc'ing Steve)

Andi,

the tests I run with oprofile do not indicate unreliable ring_buffer behavior. Maybe my use cases and loads are different. Can you describe a setup where this may happen for sure? What is the impact, do you have lost samples or inconsistent buffer data? Is the data loss in kernel or user space? Also, I am not aware that the ring_buffer is unreliable for ftrace or tracepoints, where it is heavily used. I really want to find the root cause here.

Thanks,

-Robert

Signature · 3 lines
Advanced Micro Devices, Inc.
Operating System Research Center
email: [email protected]
#39 lore raw
Quoted 8 lines · Robert Richter
Quoted 4 lines · Andi Kleen

That said the biggest problem with oprofile right now that the new buffer it's using is quite a lot less reliable and drops events left and right on any non trivial load. That makes oprofile very unreliable, especially in call graph mode.

(cc'ing Steve)

Thanks.

Quoted 9 lines

Andi,

the tests I run with oprofile do not indicate unreliable ring_buffer behavior. Maybe my use cases and loads are different. Can you describe a setup where this may happen for sure? What is the impact, do you have lost samples or inconsistent buffer data? Is the data loss in kernel or user space? Also, I am not aware that the ring_buffer is unreliable for ftrace or tracepoints, where it is heavily used. I really want to find the root cause here.

Yes, the ftrace ring buffer (which I believe oprofile now uses) is lockless and re-entrant. That means if a interrupt goes off while one event is being recorded, and that interrupt writes to the same ring buffer, the ring buffer will be able to record it without dropping the event.

As long as the readers keep up, no event will ever be dropped. Perhaps you need to increase the size of the ring buffers?

-- Steve

#40 lore raw
In reply to Robert Richter
Quoted 1 line

the tests I run with oprofile do not indicate unreliable ring_buffer

Did you try it with callgraph mode? That seems to be worst.

Quoted 2 lines

behavior. Maybe my use cases and loads are different. Can you describe a setup where this may happen for sure? What is the impact, do you

Seeing it on very busy 16 CPU and larger systems.

Quoted 1 line

have lost samples or inconsistent buffer data? Is the data loss in

There are a lot of lost samples, callgraphs are incomplete etc.

Quoted 1 line

kernel or user space? Also, I am not aware that the ring_buffer is

Not sure.

-Andi

Signature · 1 line
[email protected] -- Speaking for myself only.
#41 lore raw
In reply to Ingo Molnar
Quoted 6 lines · Ingo Molnar

Ok. The oprofile patches have been going upstream via -tip and i've been pulling and testing/relaying them for upstream for more than a year with pretty good results.

Now i'm also co-maintaining perfcounters and because it's a full oprofile replacement (which aspect Robert seems to disagree with ;-)

I can't imagine a full oprofile replacement. This would require a rewrite of all userland tools and also the complete port of all architectures (which has to be done for each architecture individually). And first of all, I don't think it is necessary to do this, why not keep different interfaces for different purposes? Why reimplement architectural code if the current implementation fits its need? We should reduce duplicate implementations such as hardware drivers, especially for x86 (I remember implementing the same pmu feature for three kinds of kernel profiling subsystems). And of course, future hardware implementations should support a generic perfcounter abstraction to only have a single implementation for all.

Quoted 9 lines

i'd like to make sure it's not seen by Robert as a conflict of interest so let me raise the following questions publicly:

This new oprofile multiplexing mechanism really overlaps the PMU abstractions that perfcounters already provide, and i disagree with this general direction. The code you wrote is clean though so i've (reluctantly) pulled it into tip:oprofile and started testing it, and will send it Linus-wards in the .32 merge window - unless Linus agrees with my general objections against this oprofile direction.

I do not see this patch set as a step away from perfcounters, instead it is going towards perfcounters. Since it implements a feature for oprofile that is already available for perfcounters. This will make migration easier. Also, this multiplexing implementation is mainly an extension of the oprofile user/kernel i/f. I don't see much overlapping code with perfcounters.

When talking about migration: I also would like to see one single pmu abstraction in the kernel and I already was thinking about the best way to do this. The current oprofile implementation does not allow an easy transition, since the internal data representation is very different to perfcounters and code is very model specific (x86). First there must be implemented a single generic abstraction layer including all models, then hardware access can be changed to use a perfcounter in-kernel api. In the end there would be one implementation for both profiling subsystems. I already started to rework oprofile with my recent update patch set for v2.6.32 and I already provided updates also for perfcounters.

The transition to perfcounters is not easy to make. There are many changes that can break much. Switching directly to perfcounters for multiplexing would have delayed the feature for oprofile for months, which is not acceptable for oprofile users. There would have been a higher risk having a reimplementation together with a feature implementation. So doing step by step is much more safe.

Perfcounters were merged for v2.6.31 in June, so less than 2 months ago. A long time it was not clear if and when it will go into the kernel. Still it has to be proved for production and stable usage. You can't expect that ongoing feature development for oprofile is stopped immediately and all efforts promptly are moved to perfcounters.

Overall, I don't see oprofile going away from perfcounters, there will be a migration. This patch set simply documents ongoing development for oprofile in parallel of perfcounters. Stopping this is not an option, it is in the kernel for years and there are users that can expect ongoing support and feature extension for oprofile.

Quoted 27 lines

The reason for my disagreement is on the technical and on the policy level.

Here's the (rough) support comparison matrix:

perfcounters | oprofile-mux
..........................................
granularity: per task or per cpu | per cpu

                                           .
   switch mechanism:             interrupt |            workqueue
                                           .
   limits:                 soft, unlimited |      hardcoded to 32
                                           .

arch support: generic, all | AMD only, needs per
perfcounter arches | cpu and arch changes

The perfcounters multiplexing is visibly more mature and more
capable: more generic, integrated into the scheduler, not hardcoded, etc.

And the oprofile bits are for x86 (AMD) only, with every oprofile architecture having to do similarly invasive changes - so these 500 lines of changes probably get multipled by a factor of 10 or so in the end, years down the line. A lot of work and i think it can and should all be avoided.

Quoted 8 lines

So there are two technical/policy questions:

Would it be fair to require oprofile to implement a similarly high-quality counter virtualization as perfcounters? If yes then i think the end result would be oprofile based on perfcounters: i.e. this particular oprofile-mux patchset becomes largely moot and we'd not have to go through the (non-trivial) transition period of updating every single oprofile driver for multiplexing.

Oprofile will base on perfcounters, but porting oprofile to perfcounters should be done separately and not delay oprofile feature development. As soon as oprofile uses a perfcounter api for counter setup there will be only a single implementation. But until then it is a long way to go.

Quoted 5 lines

The other question is: do we really want to have a constant distraction via the overlapping oprofile space? I think a feasible and sane looking approach would be to:

Quoted 7 lines

- Put oprofile into maintenance mode, fix all bugs that get reported/found, perhaps add new hw enablement drivers in the existing scheme (if they are submitted) but otherwise dont complicate the code any more.

- Extend PMU and performance instrumentation support via perfcounters primarily.

In my opinion it is too early for both. As said, perfcounters are out less than 2 months. We can consider this later approach when an in-kernel perfcounters api is in sight and oprofile is using perfcounters. At least ongoing development shouldn't be stopped.

Quoted 5 lines

- Possibly base oprofile user-space on perfcounters syscalls (with a fall-back to old oprofile syscalls on older kernels), if there's interest from folks who want the oprofile tool-chain, allowing the removal of the oprofile kernel code in the long run.

This looks very intrusive. Tools base on the user/kernel i/f that is mainly controlled with oprofilefs. I don't see many options to change this. And as said, it is not necessary.

Quoted 31 lines

This series of steps seems to be the technically sanest approach to me, and we are certainly willing to extend perfcounters in any fashion to allow a fuller replacement for oprofile. (we already think it's a worthy replacement and more - but we are open to all enhancements.)

I'd not be against maintaining the code in its current form, but i'm not sure whether we should extend the core oprofile code itself with things like the multiplexing code above which is seriously non-trivial and splits both developer attention and testing efforts.

Linus, Peter, Paul, do you have any preferences? I'm really on two minds about whether to do this oprofile feature. The overlap of this patch-set with perfcounters is serious, the induced complexity is serious and the ongoing maintenance cost is non-trivial.

Since PMU developers is a more or less constant pool of people, these policy issues do matter IMO and affect perfcounters as well indirectly, not just oprofile. Hardware vendors generally want to enable all facilities that are in the kernel, regardless of which one we consider to be the best one. So by forcing development of a new oprofile driver variant, resources are taken away from perfcounters.

It's as if we continued maintaining and developing ipchains after iptables was merged upstream. Instead we used compatibility mechanisms and phased out ipchains rather gracefully. Robert is apparently of the opinion that oprofile needs to be developed further - hence these questions.

Quoted 7 lines

So on those grounds i'm (mildly) inclined to not do this and suggest that we work on achieving the same end result via other means: via the perfcounters enabling of oprofile userspace.

But if Linus/Peter/Paul thinks that pulling it was the right solution then i'll keep the bits - i wanted to have a public discussion of these questions first.

I do not agree to stop oprofile development from one day to the other. As you, I also want to have one single pmu implementation in the kernel and we have to avoid writing duplicate code and having duplicate development efforts. But, a transition of oprofile to use perfcounters is not trivial and should be smooth. Mixing this transition with a feature implementation is also not a good idea. So lets narrow each other from both sides. Moving oprofile towards perfcounters and vice versa.

-Robert

Signature · 3 lines
Advanced Micro Devices, Inc.
Operating System Research Center
email: [email protected]
#42 lore raw
Quoted 11 lines · Robert Richter
Quoted 4 lines · Ingo Molnar

Now i'm also co-maintaining perfcounters and because it's a full oprofile replacement (which aspect Robert seems to disagree with ;-)

I can't imagine a full oprofile replacement. This would require a rewrite of all userland tools and also the complete port of all architectures (which has to be done for each architecture individually). And first of all, I don't think it is necessary to do this, why not keep different interfaces for different purposes?

Perfcounters and tools/perf/ intends to be everything that oprofile is - just implemented in a better way. What 'different purposes' do you mean?

Lets admit it: the oprofile kernel-side code has been mis-designed from the get go and it is unfixable in its current form. The mis-design is hardcoded in the oprofile ABIs and into portions of the oprofile tooling. If you wanted to fix that you'd have to rewrite the whole thing from scratch.

And the thing is, we already did that: the 'fix' for oprofile is perfcounters and the perf tool ;-) This is why we developed and merged perfcounters upstream and did not extend oprofile to begin with.

All in one, Oprofile is largely obsolete and i dont see that realization from your patches. I see a lot of ongoing churn coming up on the oprofile kernel side and i'm not sure i want to assist that, because i think it's stupid and i dont like doing or helping stupid things.

So please either convince me that it's not obsolete, or lets state it as a fundamental disagreement that you dont think that oprofile is obsolete and that you still want to develop it.

Ingo