haiku.git

/*
 * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */


#include "thread_window/ActivityPage.h"

#include <new>

#include <GridLayoutBuilder.h>
#include <GroupLayoutBuilder.h>
#include <Message.h>
#include <ScrollView.h>

#include <AutoDeleter.h>

#include "ColorCheckBox.h"
#include "MessageCodes.h"
#include "ThreadModel.h"

#include "chart/NanotimeChartAxisLegendSource.h"
#include "chart/Chart.h"
#include "chart/ChartDataSource.h"
#include "chart/DefaultChartAxisLegendSource.h"
#include "chart/LegendChartAxis.h"
#include "chart/LineChartRenderer.h"
#include "chart/StringChartLegend.h"


enum {
	RUN_TIME			= 0,
	WAIT_TIME			= 1,
	PREEMPTION_TIME		= 2,
	LATENCY_TIME		= 3,
	UNSPECIFIED_TIME	= 4,
	TIME_TYPE_COUNT		= 5
};

static const rgb_color kRunTimeColor		= {0, 0, 0, 255};
static const rgb_color kWaitTimeColor		= {0, 255, 0, 255};
static const rgb_color kPreemptionTimeColor	= {0, 0, 255, 255};
static const rgb_color kLatencyTimeColor	= {255, 0, 0, 255};


class ThreadWindow::ActivityPage::ThreadActivityData
	: public ChartDataSource {
public:
	ThreadActivityData(ThreadModel* model, int32 timeType)
		:
		fModel(model),
		fTimeType(timeType)
	{
	}

	virtual ChartDataRange Domain() const
	{
		return ChartDataRange(0.0, (double)fModel->GetModel()->LastEventTime());
	}

	virtual ChartDataRange Range() const
	{
		return ChartDataRange(0.0, 1.0);
	}

	virtual void GetSamples(double start, double end, double* samples,
		int32 sampleCount)
	{
		thread_id threadID = fModel->GetThread()->ID();

		double sampleLength = (end - start) / (double)sampleCount;

		int32 startIndex = fModel->FindSchedulingEvent((nanotime_t)start);
		nanotime_t baseTime = fModel->GetModel()->BaseTime();

		enum ScheduleState {
			RUNNING,
			STILL_RUNNING,
			PREEMPTED,
			READY,
			WAITING,
			UNKNOWN
		};

		ScheduleState state = UNKNOWN;

		// get the first event and guess the initial state
		const system_profiler_event_header* header
			= fModel->SchedulingEventAt(startIndex);
		if (header == NULL) {
			for (int32 i = 0; i < sampleCount; i++)
				samples[i] = 0;
			return;
		}

		double previousEventTime = start;

		switch (header->event) {
			case B_SYSTEM_PROFILER_THREAD_SCHEDULED:
			{
				system_profiler_thread_scheduled* event
					= (system_profiler_thread_scheduled*)(header + 1);
				if (event->thread == threadID) {
					// thread scheduled -- it must have been ready before
					state = READY;
				} else {
					// thread unscheduled -- it was running earlier, but should
					// now be "still running" or "running", depending on whether
					// it had been added to the run queue before
					const system_profiler_event_header* previousHeader
						= fModel->SchedulingEventAt(startIndex - 1);
					if (previousHeader != NULL
						&& previousHeader->event
							== B_SYSTEM_PROFILER_THREAD_ENQUEUED_IN_RUN_QUEUE) {
						state = STILL_RUNNING;
					} else
						state = RUNNING;
				}

				previousEventTime = event->time;
				break;
			}

			case B_SYSTEM_PROFILER_THREAD_ENQUEUED_IN_RUN_QUEUE:
			{
				system_profiler_thread_enqueued_in_run_queue* event
					= (system_profiler_thread_enqueued_in_run_queue*)
						(header + 1);
				state = WAITING;
				previousEventTime = event->time;
				break;
			}

			case B_SYSTEM_PROFILER_THREAD_REMOVED_FROM_RUN_QUEUE:
			{
				system_profiler_thread_removed_from_run_queue* event
					= (system_profiler_thread_removed_from_run_queue*)
						(header + 1);
				state = READY;
				previousEventTime = event->time;
				break;
			}
		}

		double times[TIME_TYPE_COUNT] = { };
		int32 sampleIndex = -1;
		double nextSampleTime = start;

		for (int32 i = startIndex; ; i++) {
			header = fModel->SchedulingEventAt(i);
			double eventTime = previousEventTime;
			int32 timeType = -1;

			if (header != NULL) {
				switch (header->event) {
					case B_SYSTEM_PROFILER_THREAD_SCHEDULED:
					{
						system_profiler_thread_scheduled* event
							= (system_profiler_thread_scheduled*)(header + 1);
						eventTime = double(event->time - baseTime);

						if (event->thread == threadID) {
							// thread scheduled
							if (state == READY) {
								// thread scheduled after having been woken up
								timeType = LATENCY_TIME;
							} else if (state == PREEMPTED) {
								// thread scheduled after having been preempted
								// before
								timeType = PREEMPTION_TIME;
							} else if (state == STILL_RUNNING) {
								// Thread was running and continues to run.
								timeType = RUN_TIME;
							} else {
								// Can only happen, if we're missing context.
								// Impossible to guess what the thread was doing
								// before.
								timeType = UNSPECIFIED_TIME;
							}

							state = RUNNING;
						} else {
							// thread unscheduled
							if (state == STILL_RUNNING) {
								// thread preempted
								state = PREEMPTED;
							} else if (state == RUNNING) {
								// thread starts waiting (it hadn't been added
								// to the run queue before being unscheduled)
								state = WAITING;
							} else {
								// Can only happen, if we're missing context.
								// Obviously the thread was running, but we
								// can't guess the new thread state.
							}

							timeType = RUN_TIME;
						}

						break;
					}

					case B_SYSTEM_PROFILER_THREAD_ENQUEUED_IN_RUN_QUEUE:
					{
						system_profiler_thread_enqueued_in_run_queue* event
							= (system_profiler_thread_enqueued_in_run_queue*)
								(header + 1);
						eventTime = double(event->time - baseTime);

						if (state == RUNNING || state == STILL_RUNNING) {
							// Thread was running and is reentered into the run
							// queue. This is done by the scheduler, if the
							// thread remains ready.
							state = STILL_RUNNING;
							timeType = RUN_TIME;
						} else if (state == READY || state == PREEMPTED) {
							// Happens only after having been removed from the
							// run queue for altering the priority.
							timeType = state == READY
								? LATENCY_TIME : PREEMPTION_TIME;
						} else {
							// Thread was waiting and is ready now.
							state = READY;
							timeType = WAIT_TIME;
						}

						break;
					}

					case B_SYSTEM_PROFILER_THREAD_REMOVED_FROM_RUN_QUEUE:
					{
						system_profiler_thread_removed_from_run_queue* event
							= (system_profiler_thread_removed_from_run_queue*)
								(header + 1);
						eventTime = double(event->time - baseTime);

						// This really only happens when the thread priority is
						// changed while the thread is ready.

						if (state == RUNNING) {
							// This should never happen.
							state = READY;
							timeType = RUN_TIME;
						} else if (state == READY) {
							// Thread was ready after having been woken up.
							timeType = LATENCY_TIME;
						} else if (state == PREEMPTED) {
							// Thread was ready after having been preempted.
							timeType = PREEMPTION_TIME;
						} else
							state = READY;

						break;
					}
				}
			} else {
				// no more events for this thread -- assume things go on like
				// this until the death of the thread
				switch (state) {
					case RUNNING:
					case STILL_RUNNING:
						timeType = RUN_TIME;
						break;
					case PREEMPTED:
						timeType = PREEMPTION_TIME;
						break;
					case READY:
						timeType = LATENCY_TIME;
						break;
					case WAITING:
						timeType = WAIT_TIME;
						break;
					case UNKNOWN:
						timeType = UNSPECIFIED_TIME;
						break;
				}

				if (fModel->GetThread()->DeletionTime() >= 0) {
					eventTime = double(fModel->GetThread()->DeletionTime()
						- baseTime);
					if (eventTime <= previousEventTime) {
						// thread is dead
						eventTime = end + 1;
						timeType = UNSPECIFIED_TIME;
					}
				} else
					eventTime = end + 1;
			}

			if (timeType < 0)
				continue;

			while (eventTime >= nextSampleTime) {
				// We've reached the next sample. Partially add this time to the
				// current sample.
				times[timeType] += nextSampleTime - previousEventTime;
				previousEventTime = nextSampleTime;

				// write the sample value
				if (sampleIndex >= 0) {
					samples[sampleIndex] = times[fTimeType] / sampleLength;
					if (samples[sampleIndex] > 1.0)
						samples[sampleIndex] = 1.0;
				}

				for (int32 k = 0; k < TIME_TYPE_COUNT; k++)
					times[k] = 0;

				// compute the time of the next sample
				if (++sampleIndex >= sampleCount)
					return;
				nextSampleTime = start
					+ (end - start)
						* (double)(sampleIndex + 1) / (double)sampleCount;
			}

			// next sample not yet reached -- just add the time
			times[timeType] += double(eventTime - previousEventTime);
			previousEventTime = eventTime;
		}
	}

private:
	ThreadModel*	fModel;
	int32			fTimeType;
};


ThreadWindow::ActivityPage::ActivityPage()
	:
	BGroupView(B_VERTICAL),
	fThreadModel(NULL),
	fActivityChart(NULL),
	fActivityChartRenderer(NULL),
	fRunTimeData(NULL),
	fWaitTimeData(NULL),
	fPreemptionTimeData(NULL),
	fLatencyTimeData(NULL)
{
	SetName("Activity");

	GroupLayout()->SetInsets(10, 10, 10, 10);

	fActivityChartRenderer = new LineChartRenderer;
	ObjectDeleter<ChartRenderer> rendererDeleter(fActivityChartRenderer);

	fActivityChart = new Chart(fActivityChartRenderer);
	fActivityChart->SetDomainZoomLimit(1000);
		// maximal zoom: 1 ms for the whole displayed domain

	BGroupLayoutBuilder(this)
		.Add(new BScrollView("activity scroll", fActivityChart, 0, true, false))
		.AddStrut(20)
		.Add(BGridLayoutBuilder()
			.Add(fRunTimeCheckBox = new ColorCheckBox("Run time", kRunTimeColor,
					new BMessage(MSG_CHECK_BOX_RUN_TIME)),
				0, 0)
			.Add(fWaitTimeCheckBox = new ColorCheckBox("Wait time",
					kWaitTimeColor, new BMessage(MSG_CHECK_BOX_WAIT_TIME)),
				1, 0)
			.Add(fPreemptionTimeCheckBox = new ColorCheckBox("Preemption time",
					kPreemptionTimeColor,
					new BMessage(MSG_CHECK_BOX_PREEMPTION_TIME)),
				0, 1)
			.Add(fLatencyTimeCheckBox = new ColorCheckBox("Latency time",
					kLatencyTimeColor,
					new BMessage(MSG_CHECK_BOX_LATENCY_TIME)),
				1, 1)
		)
	;

	rendererDeleter.Detach();

	// enable the run time chart data
	fRunTimeCheckBox->CheckBox()->SetValue(B_CONTROL_ON);

// TODO: Allocation management...
	LegendChartAxis* axis = new LegendChartAxis(
		new NanotimeChartAxisLegendSource, new StringChartLegendRenderer);
	fActivityChart->SetAxis(CHART_AXIS_BOTTOM, axis);

	axis = new LegendChartAxis(
		new NanotimeChartAxisLegendSource, new StringChartLegendRenderer);
	fActivityChart->SetAxis(CHART_AXIS_TOP, axis);

	axis = new LegendChartAxis(
		new DefaultChartAxisLegendSource, new StringChartLegendRenderer);
	fActivityChart->SetAxis(CHART_AXIS_LEFT, axis);

	axis = new LegendChartAxis(
		new DefaultChartAxisLegendSource, new StringChartLegendRenderer);
	fActivityChart->SetAxis(CHART_AXIS_RIGHT, axis);
}


ThreadWindow::ActivityPage::~ActivityPage()
{
	delete fRunTimeData;
	delete fWaitTimeData;
	delete fLatencyTimeData;
	delete fPreemptionTimeData;
	delete fActivityChartRenderer;
}


void
ThreadWindow::ActivityPage::SetModel(ThreadModel* model)
{
	if (model == fThreadModel)
		return;

	if (fThreadModel != NULL) {
		fActivityChart->RemoveAllDataSources();
		delete fRunTimeData;
		delete fWaitTimeData;
		delete fLatencyTimeData;
		delete fPreemptionTimeData;
		fRunTimeData = NULL;
		fWaitTimeData = NULL;
		fLatencyTimeData = NULL;
		fPreemptionTimeData = NULL;
	}

	fThreadModel = model;

	if (fThreadModel != NULL) {
		_UpdateChartDataEnabled(RUN_TIME);
		_UpdateChartDataEnabled(WAIT_TIME);
		_UpdateChartDataEnabled(PREEMPTION_TIME);
		_UpdateChartDataEnabled(LATENCY_TIME);
	}
}


void
ThreadWindow::ActivityPage::MessageReceived(BMessage* message)
{
	switch (message->what) {
		case MSG_CHECK_BOX_RUN_TIME:
			_UpdateChartDataEnabled(RUN_TIME);
			break;
		case MSG_CHECK_BOX_WAIT_TIME:
			_UpdateChartDataEnabled(WAIT_TIME);
			break;
		case MSG_CHECK_BOX_PREEMPTION_TIME:
			_UpdateChartDataEnabled(PREEMPTION_TIME);
			break;
		case MSG_CHECK_BOX_LATENCY_TIME:
			_UpdateChartDataEnabled(LATENCY_TIME);
			break;
		default:
			BGroupView::MessageReceived(message);
			break;
	}
}


void
ThreadWindow::ActivityPage::AttachedToWindow()
{
	fRunTimeCheckBox->SetTarget(this);
	fWaitTimeCheckBox->SetTarget(this);
	fPreemptionTimeCheckBox->SetTarget(this);
	fLatencyTimeCheckBox->SetTarget(this);
}


void
ThreadWindow::ActivityPage::_UpdateChartDataEnabled(int timeType)
{
	ThreadActivityData** data;
	ColorCheckBox* checkBox;
	rgb_color color;

	switch (timeType) {
		case RUN_TIME:
			data = &fRunTimeData;
			checkBox = fRunTimeCheckBox;
			color = kRunTimeColor;
			break;
		case WAIT_TIME:
			data = &fWaitTimeData;
			checkBox = fWaitTimeCheckBox;
			color = kWaitTimeColor;
			break;
		case PREEMPTION_TIME:
			data = &fPreemptionTimeData;
			checkBox = fPreemptionTimeCheckBox;
			color = kPreemptionTimeColor;
			break;
		case LATENCY_TIME:
			data = &fLatencyTimeData;
			checkBox = fLatencyTimeCheckBox;
			color = kLatencyTimeColor;
			break;
		default:
			return;
	}

	bool enabled = checkBox->CheckBox()->Value() == B_CONTROL_ON;

	if ((*data != NULL) == enabled)
		return;

	if (enabled) {
		LineChartRendererDataSourceConfig config(color);

		*data = new(std::nothrow) ThreadActivityData(fThreadModel, timeType);
		if (*data == NULL)
			return;

		fActivityChart->AddDataSource(*data, &config);
	} else {
		fActivityChart->RemoveDataSource(*data);
		delete *data;
		*data = NULL;
	}
}