- Move rusage from being per-process in struct pstats to per-thread in

   td_ru.  This removes the requirement for per-process synchronization in
   statclock() and mi_switch().  This was previously supported by
   sched_lock which is going away.  All modifications to rusage are now
   done in the context of the owning thread.  reads proceed without locks.
 - Aggregate exiting threads rusage in thread_exit() such that the exiting
   thread's rusage is not lost.
 - Provide a new routine, rufetch() to fetch an aggregate of all rusage
   structures from all threads in a process.  This routine must be used
   in any place requiring a rusage from a process prior to it's exit.  The
   exited process's rusage is still available via p_ru.
 - Aggregate tick statistics only on demand via rufetch() or when a thread
   exits.  Tick statistics are kept in the thread and protected by sched_lock
   until it exits.

Initial patch by:	attilio
Reviewed by:		attilio, bde (some objections), arch (mostly silent)

1 files changed, 11 insertions, 8 deletions

diff --git a/sys/kern/kern_thread.c b/sys/kern/kern_thread.c
index e83bf7e..dcb00b7 100644
--- a/sys/kern/kern_thread.c
+++ b/sys/kern/kern_thread.c
@@ -352,6 +352,7 @@ thread_exit(void)
 {
 	uint64_t new_switchtime;
 	struct thread *td;
+	struct thread *td2;
 	struct proc *p;
 
 	td = curthread;
@@ -402,17 +403,17 @@ thread_exit(void)
 	/* Do the same timestamp bookkeeping that mi_switch() would do. */
 	new_switchtime = cpu_ticks();
 	p->p_rux.rux_runtime += (new_switchtime - PCPU_GET(switchtime));
-	p->p_rux.rux_uticks += td->td_uticks;
-	p->p_rux.rux_sticks += td->td_sticks;
-	p->p_rux.rux_iticks += td->td_iticks;
 	PCPU_SET(switchtime, new_switchtime);
 	PCPU_SET(switchticks, ticks);
 	cnt.v_swtch++;
-
-	/* Add our usage into the usage of all our children. */
+	/*
+	 * Aggregate this thread's tick stats in the parent so they are not
+	 * lost.  Also add the child usage to our own when the final thread
+	 * exits.
+	 */
+	ruxagg(&p->p_rux, td);
 	if (p->p_numthreads == 1)
 		ruadd(p->p_ru, &p->p_rux, &p->p_stats->p_cru, &p->p_crux);
-
 	/*
 	 * The last thread is left attached to the process
 	 * So that the whole bundle gets recycled. Skip
@@ -424,8 +425,10 @@ thread_exit(void)
 	if (p->p_flag & P_HADTHREADS) {
 		if (p->p_numthreads > 1) {
 			thread_unlink(td);
-
-			sched_exit_thread(FIRST_THREAD_IN_PROC(p), td);
+			/* Impart our resource usage on another thread */
+			td2 = FIRST_THREAD_IN_PROC(p);
+			rucollect(&td2->td_ru, &td->td_ru);
+			sched_exit_thread(td2, td);
 
 			/*
 			 * The test below is NOT true if we are the