reduce.c

/*
 * Copyright (c) 2011 The Chromium OS Authors. All rights reserved.
 * Distributed under the terms of the GNU General Public License v2
 */

#include <pthread.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>

#include <debug.h>
#include <eprintf.h>
#include <style.h>

#include "ktop.h"
#include "reduce.h"
#include "syscall.h"
#include "tickcounter.h"

extern pthread_mutex_t Count_lock;


struct timespec Sleep = { 1, 0 };

static u64 A[NUM_SYS_CALLS];
static u64 B[NUM_SYS_CALLS];

u64 *Old = A;
u64 *New = B;
int Delta[NUM_SYS_CALLS];
void *Rank_pidcall[MAX_PIDCALLS];
int Num_rank;

TickCounter_s TotalDelta;

static int compare_pidcall(const void *a, const void *b)
{
	const Pidcall_s *p = *(const Pidcall_s **)a;
	const Pidcall_s *q = *(const Pidcall_s **)b;

	if (p->save.count > q->save.count) return -1;
	if (p->save.count == q->save.count) return 0;
	return 1;
}

static void reduce_pidcall(void)
{
	Pidcall_s *pc;
	int j;

	pthread_mutex_lock(&Count_lock);
	for (pc = Pidcall, j = 0; pc < &Pidcall[MAX_PIDCALLS]; pc++) {
		if (pc->count) {
			Rank_pidcall[j++] = pc;
			pc->save.count = pc->count;
			pc->count = 0;
			pc->save.time = pc->time.total;
			pc->time.total = 0;
		}
	}
	pthread_mutex_unlock(&Count_lock);
	Num_rank = j;
	if (1) {
		qsort(Rank_pidcall, j, sizeof(void *), compare_pidcall);
	}
}

static void delta(void)
{
	u64 *tmp;
	int sum;
	int i;

	tmp = Old;
	Old = New;
	New = tmp;

	if (0) {
		pthread_mutex_lock(&Count_lock);
		memmove(New, Syscall_count, sizeof(Syscall_count));
		memset(Syscall_count, 0, sizeof(Syscall_count));
		pthread_mutex_unlock(&Count_lock);
	} else {
		memmove(New, Syscall_count, sizeof(Syscall_count));
	}

	sum = 0;
	for (i = 0; i < NUM_SYS_CALLS; i++) {
		if (0) {
			Delta[i] = New[i];
		} else {
			Delta[i] = New[i] - Old[i];
			sum += Delta[i];
		}
	}
	tick(&TotalDelta, sum);
}

void decrease_reduce_interval(void)
{
	if (Sleep.tv_sec == 1) {
		Sleep.tv_sec = 0;
		Sleep.tv_nsec = 500 * A_MILLION;
	} else if (Sleep. tv_sec > 1) {
		Sleep.tv_sec >>= 1;
	} else if (Sleep.tv_nsec > A_MILLION) {
		Sleep.tv_nsec >>= 1;
	}
}

void increase_reduce_interval(void)
{
	if (Sleep.tv_nsec >= 500 * A_MILLION) {
		Sleep.tv_sec = 1;
		Sleep.tv_nsec = 0;
	} else if (Sleep. tv_sec >= 1) {
		Sleep.tv_sec <<= 1;
	} else {
		Sleep.tv_nsec <<= 1;
	}
}

void reset_reduce(void)
{
	zero(A);
	zero(B);
	zero(Pid);
	zero(Syscall_count);
	MyPidCount = 0;
	Slept = 0;
}

void *reduce(void *arg)
{
	ignore_pid(gettid());
	init_display();

	for (;;) {
		if (Halt) return NULL;
		delta();
		reduce_pidcall();
		Display();
		nanosleep(&Sleep, NULL);
	}
}