moved winix directories to winixd subdirectory

git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1027 e52654a7-88a9-db11-a3e9-0013d4bc506e
2016-03-17 08:24:59 +00:00
parent 7d0508961e
commit ed5adb3f23
222 changed files with 0 additions and 0 deletions
--- a/winixd/core/loadavg.cpp
+++ b/winixd/core/loadavg.cpp
@@ -0,0 +1,413 @@
+/*
+ * This file is a part of Winix
+ * and is distributed under the 2-Clause BSD licence.
+ * Author: Tomasz Sowa <t.sowa@ttmath.org>
+ */
+
+/* 
+ * Copyright (c) 2008-2014, Tomasz Sowa
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+ 
+
+#include "loadavg.h"
+#include "log.h"
+
+
+namespace Winix
+{
+
+
+
+LoadAvg::LoadAvg()
+{
+	current1.Clear();
+	current5.Clear();
+	current15.Clear();
+
+	cache_load1  = 0.0;
+	cache_load5  = 0.0;
+	cache_load15 = 0.0;
+
+	cache_req_per_sec1  = 0.0;
+	cache_req_per_sec5  = 0.0;
+	cache_req_per_sec15 = 0.0;
+
+	was_stop_request = false;
+
+	CreateTable();
+}
+
+
+LoadAvg & LoadAvg::operator=(const LoadAvg & l)
+{
+	current1  = l.current1;
+	current5  = l.current5;
+	current15 = l.current15;
+
+	cache_load1  = l.cache_load1;
+	cache_load5  = l.cache_load5;
+	cache_load15 = l.cache_load15;
+
+	cache_req_per_sec1  = l.cache_req_per_sec1;
+	cache_req_per_sec5  = l.cache_req_per_sec5;
+	cache_req_per_sec15 = l.cache_req_per_sec15;
+
+	was_stop_request = l.was_stop_request;
+
+	CreateTable();
+
+return *this;
+}
+
+
+LoadAvg::LoadAvg(const LoadAvg & l)
+{
+	operator=(l);
+}
+
+
+LoadAvg::~LoadAvg()
+{
+	delete [] tab1;
+	delete [] tab5;
+	delete [] tab15;
+}
+
+
+
+void LoadAvg::CreateTable(size_t seconds, size_t granularity, Times* & tab, size_t & len)
+{
+	len = (seconds / granularity) + 1; // rounding up (len mininum is 1)
+	tab = new Times[len];
+
+	for(size_t i=0 ; i<len ; ++i)
+	{
+		tab[i].Clear();
+		tab[i].dp = granularity; // at the beginning we assume the pause for all items
+	}
+}
+
+
+void LoadAvg::CreateTable()
+{
+	CreateTable(60,      WINIX_LOADAVG_GRANULARITY1,  tab1,  len1);
+	CreateTable(60 * 5,  WINIX_LOADAVG_GRANULARITY5,  tab5,  len5);
+	CreateTable(60 * 15, WINIX_LOADAVG_GRANULARITY15, tab15, len15);
+}
+
+
+
+void LoadAvg::MoveTab(Times * tab, size_t len)
+{
+	if( len > 1 )
+	{
+		for(size_t i=0 ; i<len-1 ; ++i)
+			tab[i] = tab[i+1];
+	}
+
+	tab[len-1].Clear();
+}
+
+
+void LoadAvg::UpdateTimer1()
+{
+	MoveTab(tab1, len1);
+
+	tab1[len1-1] = current1;
+	current1.Clear();
+	cache_load1 = 0.0;
+	cache_req_per_sec1 = 0.0;
+}
+
+
+void LoadAvg::UpdateTimer5()
+{
+	MoveTab(tab5, len5);
+
+	tab5[len5-1] = current5;
+	current5.Clear();
+	cache_load5 = 0.0;
+	cache_req_per_sec5 = 0.0;
+}
+
+
+
+void LoadAvg::UpdateTimer15()
+{
+	MoveTab(tab15, len15);
+
+	tab15[len15-1] = current15;
+	current15.Clear();
+	cache_load15 = 0.0;
+	cache_req_per_sec15 = 0.0;
+}
+
+
+void LoadAvg::CheckTimers()
+{
+	if( current1.dr + current1.dp > (double)WINIX_LOADAVG_GRANULARITY1 )
+		UpdateTimer1();
+
+	if( current5.dr + current5.dp > (double)WINIX_LOADAVG_GRANULARITY5 )
+		UpdateTimer5();
+
+	if( current15.dr + current15.dp > (double)WINIX_LOADAVG_GRANULARITY15 )
+		UpdateTimer15();
+}
+
+
+
+
+void LoadAvg::StartRequest()
+{
+	clock_gettime(CLOCK_REALTIME, &start_req);
+
+	if( was_stop_request )
+	{
+		double dp = (start_req.tv_sec - stop_req.tv_sec);
+		dp += double(start_req.tv_nsec - stop_req.tv_nsec) / 1000000000.0; // make sure that tv_nsec has signed type
+
+		current1.dp  += dp;
+		current5.dp  += dp;
+		current15.dp += dp;
+
+		CheckTimers();
+	}
+}
+
+
+
+
+
+void LoadAvg::StopRequest()
+{
+char buf[50];
+
+	clock_gettime(CLOCK_REALTIME, &stop_req);
+	
+	double dr = (stop_req.tv_sec - start_req.tv_sec);
+	dr += double(stop_req.tv_nsec - start_req.tv_nsec) / 1000000000.0; // make sure that tv_nsec has signed type
+
+	current1.dr  += dr;
+	current5.dr  += dr;
+	current15.dr += dr;
+
+	current1.req  += 1;
+	current5.req  += 1;
+	current15.req += 1;
+
+	sprintf(buf, "%f", dr);
+	SetNonZeroDigitsAfterComma(buf, 2);
+
+	log << log2 << "LA: request took: " << buf << "s" << logend;
+	was_stop_request = true;
+}
+
+
+void LoadAvg::SumTab(Times * tab, size_t len, double expected, Times & t)
+{
+	size_t i = len;
+
+	while( i-- > 0 && t.dr+t.dp < expected )
+	{
+		t.dr  += tab[i].dr;
+		t.dp  += tab[i].dp;
+		t.req += tab[i].req;
+	}
+}
+
+
+void LoadAvg::Calculate1()
+{
+Times t = current1;
+
+	SumTab(tab1, len1, 60.0, t);
+
+	if( t.dr+t.dp == 0.0 )
+	{
+		cache_load1        = 0.0;
+		cache_req_per_sec1 = 0.0;
+	}
+	else
+	{
+		cache_load1        = t.dr  / (t.dr+t.dp);
+		cache_req_per_sec1 = t.req / (t.dr+t.dp);
+	}
+}
+
+
+void LoadAvg::Calculate5()
+{
+Times t = current5;
+
+	SumTab(tab5, len5, 60.0 * 5, t);
+
+	if( t.dr+t.dp == 0.0 )
+	{
+		cache_load5        = 0.0;
+		cache_req_per_sec5 = 0.0;
+	}
+	else
+	{
+		cache_load5        = t.dr  / (t.dr+t.dp);
+		cache_req_per_sec5 = t.req / (t.dr+t.dp);
+	}
+}
+
+
+void LoadAvg::Calculate15()
+{
+Times t = current15;
+
+	SumTab(tab15, len15, 60.0 * 15, t);
+
+	if( t.dr+t.dp == 0.0 )
+	{
+		cache_load15        = 0.0;
+		cache_req_per_sec15 = 0.0;
+	}
+	else
+	{
+		cache_load15        = t.dr  / (t.dr+t.dp);
+		cache_req_per_sec15 = t.req / (t.dr+t.dp);
+	}
+}
+
+
+double LoadAvg::LoadAvgNow()
+{
+double load = 0.0;
+
+	double dr = current1.dr;
+	double dp = current1.dp;
+
+	if( tab1[len1-1].dr + tab1[len1-1].dp < WINIX_LOADAVG_GRANULARITY1 * 2 )
+	{
+		dr  += tab1[len1-1].dr;
+		dp  += tab1[len1-1].dp;
+	}
+
+	if( dr + dp != 0.0 )
+		load = dr / (dr + dp);
+
+return load;
+}
+
+
+
+double LoadAvg::LoadAvg1()
+{
+	if( cache_load1 != 0.0 )
+		return cache_load1;
+
+	Calculate1();
+
+return cache_load1;
+}
+
+
+double LoadAvg::LoadAvg5()
+{
+	if( cache_load5 != 0.0 )
+		return cache_load5;
+
+	Calculate5();
+
+return cache_load5;
+}
+
+
+double LoadAvg::LoadAvg15()
+{
+	if( cache_load15 != 0.0 )
+		return cache_load15;
+
+	Calculate15();
+
+return cache_load15;
+}
+
+
+
+double LoadAvg::ReqPerSecNow()
+{
+double req_per_sec = 0.0;
+
+	double dr  = current1.dr;
+	double dp  = current1.dp;
+	double req = current1.req;
+
+	if( tab1[len1-1].dr + tab1[len1-1].dp < WINIX_LOADAVG_GRANULARITY1 * 2 )
+	{
+		dr  += tab1[len1-1].dr;
+		dp  += tab1[len1-1].dp;
+		req += tab1[len1-1].req;
+	}
+
+	if( dr + dp != 0.0 )
+		req_per_sec = req / (dr + dp);
+
+return req_per_sec;
+}
+
+
+double LoadAvg::ReqPerSec1()
+{
+	if( cache_req_per_sec1 != 0.0 )
+		return cache_req_per_sec1;
+
+	Calculate1();
+
+return cache_req_per_sec1;
+}
+
+
+double LoadAvg::ReqPerSec5()
+{
+	if( cache_req_per_sec5 != 0.0 )
+		return cache_req_per_sec5;
+
+	Calculate5();
+
+return cache_req_per_sec5;
+}
+
+
+double LoadAvg::ReqPerSec15()
+{
+	if( cache_req_per_sec15 != 0.0 )
+		return cache_req_per_sec15;
+
+	Calculate15();
+
+return cache_req_per_sec15;
+}
+
+
+
+} // namespace Winix
+