Skip to contentSkip to conversation

contention on profile_lock

DISCUSSION Jesse Barnes 5 participants 13 messages Nov 2, 2004 – Nov 4, 2004

lore
Share & tools
lore
#0 lore raw

Hmm, the last patch you sent me worked ok, so I'm not sure why we're seeing problems with profiling now. There seems to be very heavy contention on profile_lock since profile_hook is called unconditionally every timer tick. Should it only be called if profiling is enabled? Is there a way we can check the notifier list to see if it's empty before calling it or something? The only user appears to be oprofile timer based profiling, so in the general case we're taking the profile_lock and not doing anything.

Thanks,
Jesse

#1 lore raw
Quoted 10 lines · Jesse Barnes

Hmm, the last patch you sent me worked ok, so I'm not sure why we're seeing problems with profiling now. There seems to be very heavy contention on profile_lock since profile_hook is called unconditionally every timer tick. Should it only be called if profiling is enabled? Is there a way we can check the notifier list to see if it's empty before calling it or something? The only user appears to be oprofile timer based profiling, so in the general case we're taking the profile_lock and not doing anything.

Thanks,
Jesse

Calling profile_hook() only if the notifier list is non-empty seems like a good step but I don't think that is the complete fix. We need to be able to enable profiling without killing performance.

Signature · 4 lines
Thanks

Jack Steiner ([email protected])          651-683-5302
Principal Engineer                      SGI - Silicon Graphics, Inc.
#2 lore raw
Quoted 10 lines · Jack Steiner
Quoted 9 lines · Jesse Barnes

Hmm, the last patch you sent me worked ok, so I'm not sure why we're seeing problems with profiling now. There seems to be very heavy contention on profile_lock since profile_hook is called unconditionally every timer tick. Should it only be called if profiling is enabled? Is there a way we can check the notifier list to see if it's empty before calling it or something? The only user appears to be oprofile timer based profiling, so in the general case we're taking the profile_lock and not doing anything.

Quoted 6 lines
Quoted 2 lines

Thanks,
Jesse

Calling profile_hook() only if the notifier list is non-empty seems like a good step but I don't think that is the complete fix. We need to be able to enable profiling without killing performance.

Agreed. Dipankar already suggested RCUifying the notifier list, but another option would be to simply check to see if oprofile timer based profiling is enabled since it seems to be the only user. That would turn a lock into a read-mostly variable at least.

Jesse

#3 lore raw
Quoted 4 lines · Jesse Barnes

Agreed. Dipankar already suggested RCUifying the notifier list, but another option would be to simply check to see if oprofile timer based profiling is enabled since it seems to be the only user. That would turn a lock into a read-mostly variable at least.

..but since I haven't heard from Dipankar, here's a patch that removes the profile_hook notifier list altogether in favor of a simple flag that controls whether or not to call the oprofile timer routine directly. Does it look ok?

Thanks,
Jesse

===== drivers/oprofile/timer_int.c 1.8 vs edited =====

drivers/oprofile/timer_int.c +7 -10
@@ -14,32 +14,29 @@
 #include <linux/profile.h>
 #include <linux/init.h>
 #include <asm/ptrace.h>
+
+int oprofile_timer;
  
-static int timer_notify(struct notifier_block * self, unsigned long val, void * data)
+int oprofile_timer_notify(struct pt_regs *regs)
 {
-	struct pt_regs * regs = (struct pt_regs *)data;
 	int cpu = smp_processor_id();
 	unsigned long eip = profile_pc(regs);
  
 	oprofile_add_sample(eip, !user_mode(regs), 0, cpu);
 	return 0;
 }
- 
- 
-static struct notifier_block timer_notifier = {
-	.notifier_call	= timer_notify,
-};
- 
 
 static int timer_start(void)
 {
-	return register_profile_notifier(&timer_notifier);
+	oprofile_timer = 1;
+	return 0;
 }
 
 
 static void timer_stop(void)
 {
-	unregister_profile_notifier(&timer_notifier);
+	oprofile_timer = 0;
+	wmb();
 }
 
 

===== include/linux/oprofile.h 1.10 vs edited =====

include/linux/oprofile.h +10 -0
@@ -13,6 +13,7 @@
 #ifndef OPROFILE_H
 #define OPROFILE_H
 
+#include <linux/config.h>
 #include <linux/types.h>
 #include <linux/spinlock.h>
 #include <asm/atomic.h>
@@ -105,5 +106,14 @@
 
 /** lock for read/write safety */
 extern spinlock_t oprofilefs_lock;
+
+#ifdef CONFIG_OPROFILE
+extern int oprofile_timer; /* bool for the oprofile timer */
+extern int oprofile_timer_notify(struct pt_regs *);
+#else
+#define oprofile_timer 0
+static inline int oprofile_timer_notify(struct pt_regs *) { return 0; }
+#endif
+
  
 #endif /* OPROFILE_H */

===== kernel/profile.c 1.14 vs edited =====

kernel/profile.c +3 -34
@@ -22,6 +22,7 @@
 #include <linux/cpumask.h>
 #include <linux/cpu.h>
 #include <linux/profile.h>
+#include <linux/oprofile.h>
 #include <linux/highmem.h>
 #include <asm/sections.h>
 #include <asm/semaphore.h>
@@ -168,38 +169,6 @@
 	return err;
 }
 
-static struct notifier_block * profile_listeners;
-static rwlock_t profile_lock = RW_LOCK_UNLOCKED;
- 
-int register_profile_notifier(struct notifier_block * nb)
-{
-	int err;
-	write_lock_irq(&profile_lock);
-	err = notifier_chain_register(&profile_listeners, nb);
-	write_unlock_irq(&profile_lock);
-	return err;
-}
-
-
-int unregister_profile_notifier(struct notifier_block * nb)
-{
-	int err;
-	write_lock_irq(&profile_lock);
-	err = notifier_chain_unregister(&profile_listeners, nb);
-	write_unlock_irq(&profile_lock);
-	return err;
-}
-
-
-void profile_hook(struct pt_regs * regs)
-{
-	read_lock(&profile_lock);
-	notifier_call_chain(&profile_listeners, 0, regs);
-	read_unlock(&profile_lock);
-}
-
-EXPORT_SYMBOL_GPL(register_profile_notifier);
-EXPORT_SYMBOL_GPL(unregister_profile_notifier);
 EXPORT_SYMBOL_GPL(task_handoff_register);
 EXPORT_SYMBOL_GPL(task_handoff_unregister);
 
@@ -394,8 +363,8 @@
 
 void profile_tick(int type, struct pt_regs *regs)
 {
-	if (type == CPU_PROFILING)
-		profile_hook(regs);
+	if (type == CPU_PROFILING && oprofile_timer)
+		oprofile_timer_notify(regs);
 	if (!user_mode(regs) && cpu_isset(smp_processor_id(), prof_cpu_mask))
 		profile_hit(type, (void *)profile_pc(regs));
 }
#4 lore raw
Quoted 3 lines · Jesse Barnes

..but since I haven't heard from Dipankar, here's a patch that removes the profile_hook notifier list altogether in favor of a simple flag that controls whether or not to call the oprofile timer routine directly. Does it look ok?

This looks reasonable to me.

-- wli

#5 lore raw
Quoted 7 lines · William Lee Irwin III
Quoted 4 lines · Jesse Barnes

..but since I haven't heard from Dipankar, here's a patch that removes the profile_hook notifier list altogether in favor of a simple flag that controls whether or not to call the oprofile timer routine directly. Does it look ok?

This looks reasonable to me.

John pointed out that this breaks modules. Would registering and unregistering a function pointer thus be module safe? Dipankar, hopefully you have something better?

static int timer_start(void)
{
/* Setup the callback pointer */
oprofile_timer_notify = oprofile_timer;
return 0;
}

static void timer_stop(void)
{
/* Tear down the callback pointer after sync_kernel */ synchronize_kernel();
oprofile_timer_notify = NULL;
}

Thanks,
Jesse

#6 lore raw
Quoted 10 lines · Jesse Barnes

John pointed out that this breaks modules. Would registering and unregistering a function pointer thus be module safe? Dipankar, hopefully you have something better?

static int timer_start(void)
{
/* Setup the callback pointer */
oprofile_timer_notify = oprofile_timer;
return 0;
}

Surely something like (profile.c):

funcptr_t timer_hook;

static int register_timer_hook(funcptr_t hook)

{
	if (timer_hook)
		return -EBUSY;
	timer_hook = hook;
}

static void unregister_timer_hook(funcptr_t hook)

{
	WARN_ON(hook != timer_hook);
	timer_hook = NULL;
	/* make sure all CPUs see the NULL hook */
	synchronize_kernel();
}

john

#7 lore raw
Quoted 23 lines · John Levon
Quoted 10 lines · Jesse Barnes

John pointed out that this breaks modules. Would registering and unregistering a function pointer thus be module safe? Dipankar, hopefully you have something better?

static int timer_start(void)
{
/* Setup the callback pointer */
oprofile_timer_notify = oprofile_timer;
return 0;
}

Surely something like (profile.c):

funcptr_t timer_hook;

static int register_timer_hook(funcptr_t hook)
{
if (timer_hook)
return -EBUSY;
timer_hook = hook;
}

Quoted 7 lines

static void unregister_timer_hook(funcptr_t hook)
{
WARN_ON(hook != timer_hook);
timer_hook = NULL;
/* make sure all CPUs see the NULL hook */
synchronize_kernel();
}

Yes, that's much better. Will post another one shortly. Thanks.

Jesse

#8 lore raw
In reply to Jesse Barnes
Quoted 12 lines · Jesse Barnes

John pointed out that this breaks modules. Would registering and unregistering a function pointer thus be module safe? Dipankar, hopefully you have something better?

static int timer_start(void)
{
/* Setup the callback pointer */
oprofile_timer_notify = oprofile_timer;
return 0;
}

Quoted 6 lines

static void timer_stop(void)
{
/* Tear down the callback pointer after sync_kernel */ synchronize_kernel();
oprofile_timer_notify = NULL;
}

Ok, here's another one that uses this approach. Hopefully it satisfies all parties? (Compile tested only so far.)

Thanks,
Jesse

===== drivers/oprofile/timer_int.c 1.8 vs edited =====

drivers/oprofile/timer_int.c +8 -10
@@ -13,33 +13,31 @@
 #include <linux/oprofile.h>
 #include <linux/profile.h>
 #include <linux/init.h>
+#include <linux/rcupdate.h>
 #include <asm/ptrace.h>
  
-static int timer_notify(struct notifier_block * self, unsigned long val, void * data)
+static int timer_notify(struct pt_regs *regs)
 {
-	struct pt_regs * regs = (struct pt_regs *)data;
 	int cpu = smp_processor_id();
 	unsigned long eip = profile_pc(regs);
  
 	oprofile_add_sample(eip, !user_mode(regs), 0, cpu);
 	return 0;
 }
- 
- 
-static struct notifier_block timer_notifier = {
-	.notifier_call	= timer_notify,
-};
- 
 
 static int timer_start(void)
 {
-	return register_profile_notifier(&timer_notifier);
+	/* Setup the callback pointer */
+	oprofile_timer_notify = timer_notify;
+	return 0;
 }
 
 
 static void timer_stop(void)
 {
-	unregister_profile_notifier(&timer_notifier);
+	/* Tear down the callback pointer after sync_kernel */
+	synchronize_kernel();
+	oprofile_timer_notify = NULL;
 }
 
 

===== include/linux/oprofile.h 1.10 vs edited =====

include/linux/oprofile.h +3 -0
@@ -105,5 +105,8 @@
 
 /** lock for read/write safety */
 extern spinlock_t oprofilefs_lock;
+
+/* Timer based profiling hook */
+extern int (*oprofile_timer_notify)(struct pt_regs *);
  
 #endif /* OPROFILE_H */

===== kernel/profile.c 1.14 vs edited =====

kernel/profile.c +6 -34
@@ -22,6 +22,7 @@
 #include <linux/cpumask.h>
 #include <linux/cpu.h>
 #include <linux/profile.h>
+#include <linux/oprofile.h>
 #include <linux/highmem.h>
 #include <asm/sections.h>
 #include <asm/semaphore.h>
@@ -34,6 +35,9 @@
 #define NR_PROFILE_HIT		(PAGE_SIZE/sizeof(struct profile_hit))
 #define NR_PROFILE_GRP		(NR_PROFILE_HIT/PROFILE_GRPSZ)
 
+/* Oprofile timer tick hook */
+int (*oprofile_timer_notify)(struct pt_regs *);
+
 static atomic_t *prof_buffer;
 static unsigned long prof_len, prof_shift;
 static int prof_on;
@@ -168,38 +172,6 @@
 	return err;
 }
 
-static struct notifier_block * profile_listeners;
-static rwlock_t profile_lock = RW_LOCK_UNLOCKED;
- 
-int register_profile_notifier(struct notifier_block * nb)
-{
-	int err;
-	write_lock_irq(&profile_lock);
-	err = notifier_chain_register(&profile_listeners, nb);
-	write_unlock_irq(&profile_lock);
-	return err;
-}
-
-
-int unregister_profile_notifier(struct notifier_block * nb)
-{
-	int err;
-	write_lock_irq(&profile_lock);
-	err = notifier_chain_unregister(&profile_listeners, nb);
-	write_unlock_irq(&profile_lock);
-	return err;
-}
-
-
-void profile_hook(struct pt_regs * regs)
-{
-	read_lock(&profile_lock);
-	notifier_call_chain(&profile_listeners, 0, regs);
-	read_unlock(&profile_lock);
-}
-
-EXPORT_SYMBOL_GPL(register_profile_notifier);
-EXPORT_SYMBOL_GPL(unregister_profile_notifier);
 EXPORT_SYMBOL_GPL(task_handoff_register);
 EXPORT_SYMBOL_GPL(task_handoff_unregister);
 
@@ -394,8 +366,8 @@
 
 void profile_tick(int type, struct pt_regs *regs)
 {
-	if (type == CPU_PROFILING)
-		profile_hook(regs);
+	if (type == CPU_PROFILING && oprofile_timer_notify)
+		oprofile_timer_notify(regs);
 	if (!user_mode(regs) && cpu_isset(smp_processor_id(), prof_cpu_mask))
 		profile_hit(type, (void *)profile_pc(regs));
 }
#9 lore raw
Quoted 37 lines · Jesse Barnes
Quoted 1 line · Jesse Barnes

John pointed out that this breaks modules. Would registering and

static void timer_stop(void)
{

drivers/oprofile/timer_int.c +6 -10
-	unregister_profile_notifier(&timer_notifier);
+	/* Tear down the callback pointer after sync_kernel */
+	synchronize_kernel();
+	oprofile_timer_notify = NULL;
 }
 
 
+/* Oprofile timer tick hook */
+int (*oprofile_timer_notify)(struct pt_regs *);
+
 static atomic_t *prof_buffer;
 static unsigned long prof_len, prof_shift;
 static int prof_on;
@@ -168,38 +172,6 @@
 	return err;
 }
 
 
 
-void profile_hook(struct pt_regs * regs)
-{
-	read_lock(&profile_lock);
-	notifier_call_chain(&profile_listeners, 0, regs);
-	read_unlock(&profile_lock);
-}
-
-EXPORT_SYMBOL_GPL(register_profile_notifier);
-EXPORT_SYMBOL_GPL(unregister_profile_notifier);
 EXPORT_SYMBOL_GPL(task_handoff_register);
 EXPORT_SYMBOL_GPL(task_handoff_unregister);

drivers/oprofile/timer_int.c line 373

Quoted 10 lines
drivers/oprofile/timer_int.c +2 -2
@@ -394,8 +366,8 @@
 
 void profile_tick(int type, struct pt_regs *regs)
 {
-	if (type == CPU_PROFILING)
-		profile_hook(regs);
+	if (type == CPU_PROFILING && oprofile_timer_notify)
+		oprofile_timer_notify(regs);
 	if (!user_mode(regs) && cpu_isset(smp_processor_id(), prof_cpu_mask))
 		profile_hit(type, (void *)profile_pc(regs));
 }

Or you could just do -

void profile_tick(int type, struct pt_regs *regs)

{
	int (*timer_notify)(struct pt_regs *);

	timer_notify = oprofile_timer_notify;
	smp_read_barrier_depends();
	if (type == CPU_PROFILING && timer_notify) {
		timer_notify(regs);
	}
	if (!user_mode(regs) && cpu_isset(smp_processor_id(), prof_cpu_mask))
		profile_hit(type, (void *)profile_pc(regs));
}

And avoid the synchronize_kernel(). But I think the synchronize_kernel() thing is cleaner.

I am looking at the notifier chain mechanism itself and its lack of proper locking. That is a different story.

Thanks
Dipankar

#10 lore raw
In reply to Jesse Barnes

kernel/profile.c line 39

Quoted 2 lines · Jesse Barnes
kernel/profile.c +2 -0
+/* Oprofile timer tick hook */
+int (*oprofile_timer_notify)(struct pt_regs *);

How is the module going to access this if you don't EXPORT_SYMBOL_GPL() it ?

Do you have some specific objection to keeping the register/unregister functions as I showed?

john

#11 lore raw
Quoted 9 lines · John Levon

Review

Quoted 2 lines · Jesse Barnes
(quoted diff) +2 -0
+/* Oprofile timer tick hook */
+int (*oprofile_timer_notify)(struct pt_regs *);

How is the module going to access this if you don't EXPORT_SYMBOL_GPL() it ?

Do you have some specific objection to keeping the register/unregister functions as I showed?

Nope, not at all, just the locking :). How does this one look? I think I've exported the right symbols.

Jesse

===== drivers/oprofile/timer_int.c 1.8 vs edited =====

drivers/oprofile/timer_int.c +3 -10
@@ -15,31 +15,24 @@
 #include <linux/init.h>
 #include <asm/ptrace.h>
  
-static int timer_notify(struct notifier_block * self, unsigned long val, void * data)
+static int timer_notify(struct pt_regs *regs)
 {
-	struct pt_regs * regs = (struct pt_regs *)data;
 	int cpu = smp_processor_id();
 	unsigned long eip = profile_pc(regs);
  
 	oprofile_add_sample(eip, !user_mode(regs), 0, cpu);
 	return 0;
 }
- 
- 
-static struct notifier_block timer_notifier = {
-	.notifier_call	= timer_notify,
-};
- 
 
 static int timer_start(void)
 {
-	return register_profile_notifier(&timer_notifier);
+	return register_timer_hook(timer_notify);
 }
 
 
 static void timer_stop(void)
 {
-	unregister_profile_notifier(&timer_notifier);
+	unregister_timer_hook(timer_notify);
 }
 
 

===== include/linux/profile.h 1.11 vs edited =====

include/linux/profile.h +8 -10
@@ -53,13 +53,13 @@
 int profile_event_register(enum profile_type, struct notifier_block * n);
 int profile_event_unregister(enum profile_type, struct notifier_block * n);
 
-int register_profile_notifier(struct notifier_block * nb);
-int unregister_profile_notifier(struct notifier_block * nb);
+int register_timer_hook(int (*hook)(struct pt_regs *));
+void unregister_timer_hook(int (*hook)(struct pt_regs *));
 
-struct pt_regs;
+/* Timer based profiling hook */
+extern int (*timer_hook)(struct pt_regs *);
 
-/* profiling hook activated on each timer interrupt */
-void profile_hook(struct pt_regs * regs);
+struct pt_regs;
 
 #else
 
@@ -87,17 +87,15 @@
 #define profile_handoff_task(a) (0)
 #define profile_munmap(a) do { } while (0)
 
-static inline int register_profile_notifier(struct notifier_block * nb)
+static inline int register_timer_hook(int (*hook)(struct pt_regs *))
 {
 	return -ENOSYS;
 }
 
-static inline int unregister_profile_notifier(struct notifier_block * nb)
+static inline void unregister_timer_hook(int (*hook)(struct pt_regs *))
 {
-	return -ENOSYS;
+	return;
 }
-
-#define profile_hook(regs) do { } while (0)
 
 #endif /* CONFIG_PROFILING */
 

===== kernel/profile.c 1.14 vs edited =====

kernel/profile.c +17 -28

69 lines not on this page · raw message

#12 lore raw
Quoted 2 lines · Jesse Barnes

Nope, not at all, just the locking :). How does this one look? I think I've exported the right symbols.

Looks fine to me

regards
john