/*
 * \brief  Application to show highest CPU consumer per CPU via LOG session
 * \author Norman Feske
 *         Alexander Boettcher
 * \date   2015-06-15
 */

/*
 * Copyright (C) 2015-2017 Genode Labs GmbH
 *
 * This file is part of the Genode OS framework, which is distributed
 * under the terms of the GNU Affero General Public License version 3.
 */

/* Genode includes */
#include <trace_session/connection.h>
#include <timer_session/connection.h>
#include <base/component.h>
#include <base/attached_rom_dataspace.h>
#include <base/heap.h>
#include <os/reporter.h>

enum SORT_TIME { EC_TIME = 0, SC_TIME = 1};

struct Trace_subject_registry
{
	private:

		struct Entry : Genode::List<Entry>::Element
		{
			Genode::Trace::Subject_id const id;

			Genode::Trace::Subject_info info { };

			/**
			 * Execution time during the last period
			 */
			Genode::uint64_t recent_time[2] = { 0, 0 };

			Entry(Genode::Trace::Subject_id id) : id(id) { }

			void update(Genode::Trace::Subject_info const &new_info)
			{
				if (new_info.execution_time().thread_context < info.execution_time().thread_context)
					recent_time[EC_TIME] = 0;
				else
					recent_time[EC_TIME] = new_info.execution_time().thread_context -
				                           info.execution_time().thread_context;

				if (new_info.execution_time().scheduling_context < info.execution_time().scheduling_context)
					recent_time[SC_TIME] = 0;
				else
					recent_time[SC_TIME] = new_info.execution_time().scheduling_context -
				                           info.execution_time().scheduling_context;

				info = new_info;
			}
		};

		Genode::List<Entry> _entries { };

		Entry *_lookup(Genode::Trace::Subject_id const id)
		{
			for (Entry *e = _entries.first(); e; e = e->next())
				if (e->id == id)
					return e;

			return nullptr;
		}

		enum { MAX_SUBJECTS = 1024 };
		Genode::Trace::Subject_id _subjects[MAX_SUBJECTS];

		enum { MAX_CPUS_X = 16, MAX_CPUS_Y = 4, MAX_ELEMENTS_PER_CPU = 6};

		/* accumulated execution time on all CPUs */
		unsigned long long total_first [MAX_CPUS_X][MAX_CPUS_Y];
		unsigned long long total_second [MAX_CPUS_X][MAX_CPUS_Y];

		/* most significant consumer per CPU */
		Entry const * load[MAX_CPUS_X][MAX_CPUS_Y][MAX_ELEMENTS_PER_CPU];

		bool _reconstruct_trace_connection = false;

		template <typename FN>
		unsigned update_subjects(Genode::Pd_session &pd,
		                         Genode::Trace::Connection &trace,
		                         FN const &fn)
		{
			Genode::Ram_quota ram_quota;

			do {
				try {
					return trace.for_each_subject_info(fn);
				} catch (Genode::Out_of_ram) {
					trace.upgrade_ram(4096);
				}

				ram_quota = pd.avail_ram();
				_reconstruct_trace_connection = (ram_quota.value < 4 * 4096);

			} while (ram_quota.value >= 2 * 4096);

			return 0;
		}

	public:

		void update(Genode::Pd_session &pd, Genode::Trace::Connection &trace,
		            Genode::Allocator &alloc)
		{
			update_subjects(pd, trace, [&](Genode::Trace::Subject_id const &id, Genode::Trace::Subject_info const &info) {

				Entry *e = _lookup(id);
				if (!e) {
					e = new (alloc) Entry(id);
					_entries.insert(e);
				}

				e->update(info);

				/* remove dead threads which did not run in the last period */
				if (e->info.state() == Genode::Trace::Subject_info::DEAD &&
				    !e->recent_time[EC_TIME] && !e->recent_time[SC_TIME]) {

					trace.free(e->id);
					_entries.remove(e);
					Genode::destroy(alloc, e);
				}
			});

			if (_reconstruct_trace_connection)
				throw Genode::Out_of_ram();
		}

		void flush(Genode::Trace::Connection &trace, Genode::Allocator &alloc)
		{
			_reconstruct_trace_connection = false;

			while (Entry * const e = _entries.first()) {
					trace.free(e->id);
					_entries.remove(e);
					Genode::destroy(alloc, e);
			}
		}

		void top(enum SORT_TIME sorting)
		{
			/* clear old calculations */
			Genode::memset(total_first, 0, sizeof(total_first));
			Genode::memset(total_second, 0, sizeof(total_second));
			Genode::memset(load, 0, sizeof(load));

			unsigned const first  = sorting == EC_TIME ? EC_TIME : SC_TIME;
			unsigned const second = sorting == EC_TIME ? SC_TIME : EC_TIME;

			for (Entry const *e = _entries.first(); e; e = e->next()) {

				/* collect highest execution time per CPU */
				unsigned const x = e->info.affinity().xpos();
				unsigned const y = e->info.affinity().ypos();
				if (x >= MAX_CPUS_X || y >= MAX_CPUS_Y) {
					Genode::error("cpu ", e->info.affinity().xpos(), ".",
					              e->info.affinity().ypos(), " is outside "
					              "supported range ",
					              (int)MAX_CPUS_X, ".", (int)MAX_CPUS_Y);
					continue;
				}

				total_first[x][y] += e->recent_time[first];
				total_second[x][y] += e->recent_time[second];

				enum { NONE = ~0U };
				unsigned replace = NONE;

				for (unsigned i = 0; i < MAX_ELEMENTS_PER_CPU; i++) {
					if (load[x][y][i])
						continue;

					replace = i;
					break;
				}

				if (replace != NONE) {
					load[x][y][replace] = e;
					continue;
				}

				for (unsigned i = 0; i < MAX_ELEMENTS_PER_CPU; i++) {
					if (e->recent_time[first]
					    <= load[x][y][i]->recent_time[first])
						continue;

					if (replace == NONE) {
						replace = i;
						continue;
					}
					if (load[x][y][replace]->recent_time[first]
					    > load[x][y][i]->recent_time[first])
						replace = i;
				}

				if (replace != NONE)
					load[x][y][replace] = e;
			}

			/* sort */
			for (unsigned x = 0; x < MAX_CPUS_X; x++) {
				for (unsigned y = 0; y < MAX_CPUS_Y; y++) {
					for (unsigned k = 0; k < MAX_ELEMENTS_PER_CPU;) {
						if (!load[x][y][k])
							break;

						unsigned i = k;
						for (unsigned j = i; j < MAX_ELEMENTS_PER_CPU; j++) {
							if (!load[x][y][j])
								break;

							if (load[x][y][i]->recent_time[first]
							    < load[x][y][j]->recent_time[first]) {

								Entry const * tmp = load[x][y][j];
								load[x][y][j] = load[x][y][i];
								load[x][y][i] = tmp;

								i++;
								if (i >= MAX_ELEMENTS_PER_CPU || !load[x][y][i])
									break;
							}
						}
						if (i == k)
							k++;
					}
				}
			}

			for (unsigned x = 0; x < MAX_CPUS_X; x++) {
				for (unsigned y = 0; y < MAX_CPUS_Y; y++) {
					for (unsigned i = 0; i < MAX_ELEMENTS_PER_CPU; i++) {
						if (!load[x][y][i] || !total_first[x][y])
							continue;

						Entry const &entry = *load[x][y][i];

						unsigned ec_percent = entry.recent_time[first] * 100   / total_first[x][y];
						unsigned ec_rest    = entry.recent_time[first] * 10000 / total_first[x][y] - (ec_percent * 100);

						unsigned sc_percent = 0;
						unsigned sc_rest    = 0;
						if (total_second[x][y]) {
							sc_percent = entry.recent_time[second] * 100   / total_second[x][y];
							sc_rest    = entry.recent_time[second] * 10000 / total_second[x][y] - (sc_percent * 100);
						}

						enum { NAME_SPACE = 24 };
						static char space[NAME_SPACE];
						Genode::memset(space, ' ', NAME_SPACE - 1);

						unsigned thread_name_len = entry.info.thread_name().length();
						if (!thread_name_len)
							space[NAME_SPACE - 1] = 0;
						else
						if (thread_name_len >= NAME_SPACE)
							space[0] = 0;
						else
							space[NAME_SPACE - thread_name_len] = 0;

						Genode::String<NAME_SPACE> space_string(space);

						using Genode::log;
						log("cpu=", entry.info.affinity().xpos(),
						    ".", entry.info.affinity().ypos(),
						    " ", _align_right<4>(entry.info.execution_time().priority),
						    " ", _align_right<6>(entry.info.execution_time().quantum),
						    " ", _align_right<4>(ec_percent),
						    ".", _align_right<3>(ec_rest, true), "%"
						    " ", _align_right<4>(sc_percent),
						    ".", _align_right<3>(sc_rest, true), "% "
						    "thread='", entry.info.thread_name(), "' ", space_string,
						    "label='", entry.info.session_label(), "'");
					}
				}
			}
			if (load[0][0][0] && load[0][0][0]->recent_time[first])
				Genode::log("");
		}

		template <int T>
		Genode::String<T> _align_right(Genode::uint64_t value, bool zero = false)
		{
			Genode::String<T> result(value);

			for (Genode::uint64_t i = 1, pow = 10; i < (T - 1); i++, pow *= 10) {
				if (value < pow)
					result = Genode::String<T>(zero ? "0" : " ", result);
			}

			return result;
		}
};


namespace App {

	struct Main;
	using namespace Genode;
}


struct App::Main
{
	Env &_env;

	enum {
		TRACE_RAM_QUOTA = 10 * 4096,
		ARG_BUFFER_RAM  = 32 * 1024,
		PARENT_LEVELS   = 0
	};

	Reconstructible<Trace::Connection> _trace { _env, TRACE_RAM_QUOTA,
	                                            ARG_BUFFER_RAM, PARENT_LEVELS };

	static uint64_t _default_period_ms() { return 5000; }

	uint64_t _period_ms = _default_period_ms();

	SORT_TIME _sort { EC_TIME };

	Attached_rom_dataspace _config { _env, "config" };

	Timer::Connection _timer { _env };

	Heap _heap { _env.ram(), _env.rm() };

	Trace_subject_registry _trace_subject_registry { };

	void _handle_config();

	Signal_handler<Main> _config_handler = {
		_env.ep(), *this, &Main::_handle_config};

	void _handle_period();

	Signal_handler<Main> _periodic_handler = {
		_env.ep(), *this, &Main::_handle_period};

	Main(Env &env) : _env(env)
	{
		_config.sigh(_config_handler);
		_handle_config();

		_timer.sigh(_periodic_handler);
	}
};


void App::Main::_handle_config()
{
	_config.update();

	_period_ms = _config.xml().attribute_value("period_ms", _default_period_ms());

	String<8> ec_sc(_config.xml().attribute_value("sort_time", String<8>("ec")));
	if (ec_sc == "ec")
		_sort = EC_TIME;
	else
		_sort = SC_TIME;

	log("sorting based on ",
	    _sort == EC_TIME ? "execution context (ec) [other option is scheduling context (sc)]"
	                     : "scheduling context (sc) [other option is execution context (ec)]");

	_timer.trigger_periodic(1000*_period_ms);
}


void App::Main::_handle_period()
{
	bool reconstruct = false;

	/* update subject information */
	try {
		_trace_subject_registry.update(_env.pd(), *_trace, _heap);
	} catch (Genode::Out_of_ram) {
		reconstruct = true;
	}

	/* show most significant consumers */
	_trace_subject_registry.top(_sort);

	/* by destructing the session we free up the allocated memory in core */
	if (reconstruct) {
		Genode::warning("re-construct trace session because of out of memory");

		_trace_subject_registry.flush(*_trace, _heap);

		_trace.destruct();
		_trace.construct(_env, TRACE_RAM_QUOTA, ARG_BUFFER_RAM, PARENT_LEVELS);
	}
}


void Component::construct(Genode::Env &env) { static App::Main main(env); }