--- /dev/null
+/* Copyright (C) 2005 Constantin Kaplinsky. All Rights Reserved.
+ *
+ * This is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this software; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ * USA.
+ */
+
+//
+// CPUMonitor.cxx
+//
+
+#include "CPUMonitor.h"
+
+CPUMonitor::CPUMonitor(int optimalLevel, int updatePeriod)
+{
+ setLevel(optimalLevel);
+ setPeriod(updatePeriod);
+ update();
+}
+
+void CPUMonitor::setLevel(int optimalLevel)
+{
+ m_optimalLevel = optimalLevel;
+ if (m_optimalLevel < 0) {
+ m_optimalLevel = 0;
+ } else if (m_optimalLevel > 100) {
+ m_optimalLevel = 100;
+ }
+}
+
+void CPUMonitor::setPeriod(int updatePeriod)
+{
+ m_updatePeriod = (updatePeriod > 10) ? updatePeriod : 10;
+}
+
+void CPUMonitor::update()
+{
+ getClock(&m_savedTime, &m_savedClock);
+}
+
+int CPUMonitor::check()
+{
+ struct timeval timeNow;
+ clock_t clockNow;
+ getClock(&timeNow, &clockNow);
+
+ int coeff = 100; // 100% means no changes.
+
+ if (m_savedClock != (clock_t)-1 && clockNow != (clock_t)-1) {
+
+ // Find out how much real time has been elapsed (in milliseconds).
+ int timeDiff = (int)((timeNow.tv_usec - m_savedTime.tv_usec + 500) / 1000 +
+ (timeNow.tv_sec - m_savedTime.tv_sec) * 1000);
+ if (timeDiff < m_updatePeriod) {
+ // Measuring CPU usage is problematic in this case. So return
+ // 100 and do not update saved time and clock numbers.
+ return coeff;
+ }
+
+ // Calculate how much processor time has been consumed (in milliseconds).
+ unsigned int clockDiff = (unsigned int)(clockNow - m_savedClock);
+ clockDiff /= (CLOCKS_PER_SEC / 1000);
+
+ // Get actual CPU usage and convert optimal level (to 1/1000).
+ int realUsage = (clockDiff * 1000 + timeDiff/2) / timeDiff;
+ int optimalUsage = m_optimalLevel * 10;
+
+ // Compute correction coefficient (in percents).
+ if (realUsage != 0) {
+ coeff = (optimalUsage * 100 + realUsage/2) / realUsage;
+ } else {
+ coeff = 10000;
+ }
+
+ }
+
+ // Update saved time and clock numbers.
+ m_savedTime = timeNow;
+ m_savedClock = clockNow;
+
+ return coeff;
+}
+
+void CPUMonitor::getClock(struct timeval *tv, clock_t *clk)
+{
+ if (gettimeofday(tv, NULL) != 0) {
+ *clk = (clock_t)-1;
+ } else {
+ *clk = clock();
+ }
+}
--- /dev/null
+/* Copyright (C) 2005 Constantin Kaplinsky. All Rights Reserved.
+ *
+ * This is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this software; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ * USA.
+ */
+
+//
+// CPUMonitor.h
+//
+
+#ifndef __CPUMONITOR_H__
+#define __CPUMONITOR_H__
+
+#include <sys/time.h>
+#include <time.h>
+
+class CPUMonitor {
+
+public:
+
+ CPUMonitor(int optimalLevel = 50, int updatePeriod = 1000);
+
+ //
+ // Optimal level is the CPU utilization level to maintain, in
+ // percents.
+ //
+ void setLevel(int optimalLevel);
+
+ //
+ // Update period is the minimum time in milliseconds that has to
+ // pass after update() or check() call, before next check() call
+ // will return meaningful value.
+ //
+ void setPeriod(int updatePeriod);
+
+ //
+ // Save current time and CPU clock, to use in the next check() call.
+ //
+ void update();
+
+ //
+ // This method calculates recent CPU utilization and returns a
+ // percentage factor which would convert current CPU usage into the
+ // optimal value. For example, if the optimal level was set to 40%
+ // and the real value was 50%, the function will return 80, because
+ // 50 * 80% == 40.
+ //
+ // If the CPU utilization cannot be measured, this function returns
+ // 100. This may be the case on the first call to check(), or if the
+ // time period between two successive check() calls was too small.
+ //
+ int check();
+
+protected:
+
+ static void getClock(struct timeval *tv, clock_t *clk);
+
+ int m_optimalLevel;
+ int m_updatePeriod;
+ struct timeval m_savedTime;
+ clock_t m_savedClock;
+
+};
+
+#endif // __CPUMONITOR_H__
-SRCS = Image.cxx x0vncserver.cxx
+SRCS = Image.cxx CPUMonitor.cxx x0vncserver.cxx
OBJS = $(SRCS:.cxx=.o)
#include <network/TcpSocket.h>
#include "Image.h"
+#include "CPUMonitor.h"
+
#include <signal.h>
#include <X11/X.h>
#include <X11/Xlib.h>
LogWriter vlog("main");
-IntParameter pollingCycle("PollingCycle", "Milliseconds per one "
- "polling cycle", 50);
+IntParameter pollingCycle("PollingCycle", "Milliseconds per one polling "
+ "cycle; actual interval may be dynamically "
+ "adjusted to satisfy MaxProcessorUsage setting", 50);
+IntParameter maxProcessorUsage("MaxProcessorUsage", "Maximum percentage of "
+ "CPU time to be consumed", 35);
BoolParameter useShm("UseSHM", "Use MIT-SHM extension if available", true);
BoolParameter useOverlay("OverlayMode", "Use overlay mode under "
"IRIX or Solaris", true);
if (strlen(hostsFile.getData()) != 0)
listener.setFilter(&fileTcpFilter);
+ CPUMonitor cpumon((int)maxProcessorUsage, 1000);
+ int dynPollingCycle = (int)pollingCycle;
+
struct timeval timeSaved, timeNow;
struct timezone tz;
gettimeofday(&timeSaved, &tz);
struct timeval tv;
tv.tv_sec = 0;
- tv.tv_usec = (int)pollingCycle * 1000;
+ tv.tv_usec = dynPollingCycle * 1000;
+ if (tv.tv_usec > 500000) {
+ tv.tv_usec = 500000;
+ }
FD_ZERO(&rfds);
FD_SET(listener.getFd(), &rfds);
Socket* sock = listener.accept();
if (sock) {
server.addClient(sock);
+ cpumon.update(); // count time from now
} else {
vlog.status("Client connection rejected");
}
if (gettimeofday(&timeNow, &tz) == 0) {
int diff = (int)((timeNow.tv_usec - timeSaved.tv_usec + 500) / 1000 +
(timeNow.tv_sec - timeSaved.tv_sec) * 1000);
- if (diff >= (int)pollingCycle) {
+ if (diff >= dynPollingCycle) {
timeSaved = timeNow;
+ int coeff = cpumon.check();
+ if (coeff < 90 || coeff > 110) {
+ // Adjust polling cycle to satisfy MaxProcessorUsage setting
+ dynPollingCycle = (dynPollingCycle * 100 + coeff/2) / coeff;
+ if (dynPollingCycle < (int)pollingCycle) {
+ dynPollingCycle = (int)pollingCycle;
+ } else if (dynPollingCycle > (int)pollingCycle * 32) {
+ dynPollingCycle = (int)pollingCycle * 32;
+ }
+ // DEBUG:
+ // if (dynPollingCycle != old) {
+ // fprintf(stderr, "[%dms]\t", dynPollingCycle);
+ // }
+ }
desktop.poll();
}
} else {
projects / tigervnc.git / commitdiff