Merge "Refactor how timeouts are calculated. (DO NOT MERGE)" into honeycomb-mr2 (85a7f99c) · Commits · e / os / android_frameworks_base

include/utils/Timers.h

+10 −0

Original line number	Original line	Diff line number	Diff line
	@@ -88,6 +88,16 @@ nsecs_t systemTime(int clock = SYSTEM_TIME_MONOTONIC);
	nsecs_t systemTime(int clock);		nsecs_t systemTime(int clock);
	#endif // def __cplusplus		#endif // def __cplusplus

			/**
			* Returns the number of milliseconds to wait between the reference time and the timeout time.
			* If the timeout is in the past relative to the reference time, returns 0.
			* If the timeout is more than INT_MAX milliseconds in the future relative to the reference time,
			* such as when timeoutTime == LLONG_MAX, returns -1 to indicate an infinite timeout delay.
			* Otherwise, returns the difference between the reference time and timeout time
			* rounded up to the next millisecond.
			*/
			int toMillisecondTimeoutDelay(nsecs_t referenceTime, nsecs_t timeoutTime);

	#ifdef __cplusplus		#ifdef __cplusplus
	} // extern "C"		} // extern "C"
	#endif		#endif

libs/utils/Looper.cpp

+7 −12

Original line number	Original line	Diff line number	Diff line
	@@ -218,14 +218,10 @@ int Looper::pollInner(int timeoutMillis) {
	// Adjust the timeout based on when the next message is due.		// Adjust the timeout based on when the next message is due.
	if (timeoutMillis != 0 && mNextMessageUptime != LLONG_MAX) {		if (timeoutMillis != 0 && mNextMessageUptime != LLONG_MAX) {
	nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);		nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
	if (mNextMessageUptime <= now) {		int messageTimeoutMillis = toMillisecondTimeoutDelay(now, mNextMessageUptime);
	timeoutMillis = 0;		if (messageTimeoutMillis >= 0
	} else {		&& (timeoutMillis < 0 \|\| messageTimeoutMillis < timeoutMillis)) {
	uint64_t delay = (mNextMessageUptime - now + 999999LL) / 1000000LL;		timeoutMillis = messageTimeoutMillis;
	if (delay < INT_MAX
	&& (timeoutMillis < 0 \|\| int(delay) < timeoutMillis)) {
	timeoutMillis = int(delay);
	}
	}		}
	#if DEBUG_POLL_AND_WAKE		#if DEBUG_POLL_AND_WAKE
	LOGD("%p ~ pollOnce - next message in %lldns, adjusted timeout: timeoutMillis=%d",		LOGD("%p ~ pollOnce - next message in %lldns, adjusted timeout: timeoutMillis=%d",
	@@ -444,12 +440,11 @@ int Looper::pollAll(int timeoutMillis, int* outFd, int* outEvents, void** outDat
	return result;		return result;
	}		}

	nsecs_t timeoutNanos = endTime - systemTime(SYSTEM_TIME_MONOTONIC);		nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
	if (timeoutNanos <= 0) {		timeoutMillis = toMillisecondTimeoutDelay(now, endTime);
			if (timeoutMillis == 0) {
	return ALOOPER_POLL_TIMEOUT;		return ALOOPER_POLL_TIMEOUT;
	}		}

	timeoutMillis = int(nanoseconds_to_milliseconds(timeoutNanos + 999999LL));
	}		}
	}		}
	}		}

libs/utils/Timers.cpp

+18 −0

Original line number	Original line	Diff line number	Diff line
	@@ -26,6 +26,7 @@
	#include <sys/time.h>		#include <sys/time.h>
	#include <time.h>		#include <time.h>
	#include <errno.h>		#include <errno.h>
			#include <limits.h>

	#ifdef HAVE_WIN32_THREADS		#ifdef HAVE_WIN32_THREADS
	#include <windows.h>		#include <windows.h>
	@@ -53,6 +54,23 @@ nsecs_t systemTime(int clock)
	#endif		#endif
	}		}

			int toMillisecondTimeoutDelay(nsecs_t referenceTime, nsecs_t timeoutTime)
			{
			int timeoutDelayMillis;
			if (timeoutTime > referenceTime) {
			uint64_t timeoutDelay = uint64_t(timeoutTime - referenceTime);
			if (timeoutDelay > uint64_t((INT_MAX - 1) * 1000000LL)) {
			timeoutDelayMillis = -1;
			} else {
			timeoutDelayMillis = (timeoutDelay + 999999LL) / 1000000LL;
			}
			} else {
			timeoutDelayMillis = 0;
			}
			return timeoutDelayMillis;
			}


	/*		/*
	* ===========================================================================		* ===========================================================================
	* DurationTimer		* DurationTimer

services/input/EventHub.cpp

+10 −3

Original line number	Original line	Diff line number	Diff line
	@@ -445,7 +445,7 @@ EventHub::Device* EventHub::getDeviceLocked(int32_t deviceId) const {
	return NULL;		return NULL;
	}		}

	bool EventHub::getEvent(RawEvent* outEvent) {		bool EventHub::getEvent(int timeoutMillis, RawEvent* outEvent) {
	outEvent->deviceId = 0;		outEvent->deviceId = 0;
	outEvent->type = 0;		outEvent->type = 0;
	outEvent->scanCode = 0;		outEvent->scanCode = 0;
	@@ -598,13 +598,20 @@ bool EventHub::getEvent(RawEvent* outEvent) {
	// when this happens, the EventHub holds onto its own user wake lock while the client		// when this happens, the EventHub holds onto its own user wake lock while the client
	// is processing events. Thus the system can only sleep if there are no events		// is processing events. Thus the system can only sleep if there are no events
	// pending or currently being processed.		// pending or currently being processed.
			//
			// The timeout is advisory only. If the device is asleep, it will not wake just to
			// service the timeout.
	release_wake_lock(WAKE_LOCK_ID);		release_wake_lock(WAKE_LOCK_ID);

	int pollResult = poll(mFds.editArray(), mFds.size(), -1);		int pollResult = poll(mFds.editArray(), mFds.size(), timeoutMillis);

	acquire_wake_lock(PARTIAL_WAKE_LOCK, WAKE_LOCK_ID);		acquire_wake_lock(PARTIAL_WAKE_LOCK, WAKE_LOCK_ID);

	if (pollResult <= 0) {		if (pollResult == 0) {
			// Timed out.
			return false;
			}
			if (pollResult < 0) {
	if (errno != EINTR) {		if (errno != EINTR) {
	LOGW("poll failed (errno=%d)\n", errno);		LOGW("poll failed (errno=%d)\n", errno);
	usleep(100000);		usleep(100000);

services/input/EventHub.h

+7 −2

Original line number	Original line	Diff line number	Diff line
	@@ -186,8 +186,13 @@ public:
	* This ensures that the device will not go to sleep while the event is being processed.		* This ensures that the device will not go to sleep while the event is being processed.
	* If the device needs to remain awake longer than that, then the caller is responsible		* If the device needs to remain awake longer than that, then the caller is responsible
	* for taking care of it (say, by poking the power manager user activity timer).		* for taking care of it (say, by poking the power manager user activity timer).
			*
			* The timeout is advisory only. If the device is asleep, it will not wake just to
			* service the timeout.
			*
			* Returns true if an event was obtained, false if the timeout expired.
	*/		*/
	virtual bool getEvent(RawEvent* outEvent) = 0;		virtual bool getEvent(int timeoutMillis, RawEvent* outEvent) = 0;

	/*		/*
	* Query current input state.		* Query current input state.
	@@ -244,7 +249,7 @@ public:
	virtual bool markSupportedKeyCodes(int32_t deviceId, size_t numCodes,		virtual bool markSupportedKeyCodes(int32_t deviceId, size_t numCodes,
	const int32_t* keyCodes, uint8_t* outFlags) const;		const int32_t* keyCodes, uint8_t* outFlags) const;

	virtual bool getEvent(RawEvent* outEvent);		virtual bool getEvent(int timeoutMillis, RawEvent* outEvent);

	virtual bool hasLed(int32_t deviceId, int32_t led) const;		virtual bool hasLed(int32_t deviceId, int32_t led) const;
	virtual void setLedState(int32_t deviceId, int32_t led, bool on);		virtual void setLedState(int32_t deviceId, int32_t led, bool on);