get rid of sleepForInterval() which didn't seem to be used anywhere in the... (1bc9c93f) · Commits · e / os / platform_frameworks_native

include/utils/Timers.h

+0 −3

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

		// return the system-time according to the specified clock
		int sleepForInterval(long interval, struct timeval* pNextTick);

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

include/utils/ported.h

deleted100644 → 0

+0 −50

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2005 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		//
		// Standard functions ported to the current platform. Note these are NOT
		// in the "android" namespace.
		//
		#ifndef _LIBS_UTILS_PORTED_H
		#define _LIBS_UTILS_PORTED_H

		#include <sys/time.h> // for timeval

		#ifdef __cplusplus
		extern "C" {
		#endif

		/* library replacement functions */
		#if defined(NEED_GETTIMEOFDAY)
		int gettimeofday(struct timeval* tv, struct timezone* tz);
		#endif
		#if defined(NEED_USLEEP)
		void usleep(unsigned long usec);
		#endif
		#if defined(NEED_PIPE)
		int pipe(int filedes[2]);
		#endif
		#if defined(NEED_SETENV)
		int setenv(const char* name, const char* value, int overwrite);
		void unsetenv(const char* name);
		char* getenv(const char* name);
		#endif

		#ifdef __cplusplus
		}
		#endif

		#endif // _LIBS_UTILS_PORTED_H

libs/utils/Android.mk

+0 −1

Original line number	Diff line number	Diff line
		@@ -42,7 +42,6 @@ commonSources:= \
		ZipFileRO.cpp \
		ZipUtils.cpp \
		misc.cpp \
		ported.cpp \
		LogSocket.cpp

		#

libs/utils/Timers.cpp

+0 −125

Original line number	Diff line number	Diff line
		@@ -18,7 +18,6 @@
		// Timer functions.
		//
		#include <utils/Timers.h>
		#include <utils/ported.h> // may need usleep
		#include <utils/Log.h>

		#include <stdlib.h>
		@@ -54,130 +53,6 @@ nsecs_t systemTime(int clock)
		#endif
		}

		//#define MONITOR_USLEEP

		/*
		* Sleep long enough that we'll wake up "interval" milliseconds after
		* the previous snooze.
		*
		* The "nextTick" argument is updated on each call, and should be passed
		* in every time. Set its fields to zero on the first call.
		*
		* Returns the #of intervals we have overslept, which will be zero if we're
		* on time. [Currently just returns 0 or 1.]
		*/
		int sleepForInterval(long interval, struct timeval* pNextTick)
		{
		struct timeval now;
		long long timeBeforeNext;
		long sleepTime = 0;
		bool overSlept = false;
		//int usleepBias = 0;

		#ifdef USLEEP_BIAS
		/*
		* Linux likes to add 9000ms or so.
		* [not using this for now]
		*/
		//usleepBias = USLEEP_BIAS;
		#endif

		gettimeofday(&now, NULL);

		if (pNextTick->tv_sec == 0) {
		/* special-case for first time through */
		*pNextTick = now;
		sleepTime = interval;
		android::DurationTimer::addToTimeval(pNextTick, interval);
		} else {
		/*
		* Compute how much time there is before the next tick. If this
		* value is negative, we've run over. If we've run over a little
		* bit we can shorten the next frame to keep the pace steady, but
		* if we've dramatically overshot we need to re-sync.
		*/
		timeBeforeNext = android::DurationTimer::subtractTimevals(pNextTick, &now);
		//printf("TOP: now=%ld.%ld next=%ld.%ld diff=%ld\n",
		// now.tv_sec, now.tv_usec, pNextTick->tv_sec, pNextTick->tv_usec,
		// (long) timeBeforeNext);
		if (timeBeforeNext < -interval) {
		/* way over */
		overSlept = true;
		sleepTime = 0;
		*pNextTick = now;
		} else if (timeBeforeNext <= 0) {
		/* slightly over, keep the pace steady */
		overSlept = true;
		sleepTime = 0;
		} else if (timeBeforeNext <= interval) {
		/* right on schedule */
		sleepTime = timeBeforeNext;
		} else if (timeBeforeNext > interval && timeBeforeNext <= 2*interval) {
		/* sleep call returned early; do a longer sleep this time */
		sleepTime = timeBeforeNext;
		} else if (timeBeforeNext > interval) {
		/* we went back in time -- somebody updated system clock? */
		/* (could also be a seriously broken usleep()) */
		LOG(LOG_DEBUG, "",
		" Impossible: timeBeforeNext = %ld\n", (long)timeBeforeNext);
		sleepTime = 0;
		*pNextTick = now;
		}
		android::DurationTimer::addToTimeval(pNextTick, interval);
		}
		//printf(" Before sleep: now=%ld.%ld next=%ld.%ld sleepTime=%ld\n",
		// now.tv_sec, now.tv_usec, pNextTick->tv_sec, pNextTick->tv_usec,
		// sleepTime);

		/*
		* Sleep for the designated period of time.
		*
		* Linux tends to sleep for longer than requested, often by 17-18ms.
		* MinGW tends to sleep for less than requested, by as much as 14ms,
		* but occasionally oversleeps for 40+ms (looks like some external
		* factors plus round-off on a 64Hz clock). Cygwin is pretty steady.
		*
		* If you start the MinGW version, and then launch the Cygwin version,
		* the MinGW clock becomes more erratic. Not entirely sure why.
		*
		* (There's a lot of stuff here; it's really just a usleep() call with
		* a bunch of instrumentation.)
		*/
		if (sleepTime > 0) {
		#if defined(MONITOR_USLEEP)
		struct timeval before, after;
		long long actual;

		gettimeofday(&before, NULL);
		usleep((long) sleepTime);
		gettimeofday(&after, NULL);

		/* check usleep() accuracy; default Linux threads are pretty sloppy */
		actual = android::DurationTimer::subtractTimevals(&after, &before);
		if ((long) actual < sleepTime - 14000 /(sleepTime/10)/ \|\|
		(long) actual > sleepTime + 20000 /(sleepTime/10)/)
		{
		LOG(LOG_DEBUG, "", " Odd usleep: req=%ld, actual=%ld\n", sleepTime,
		(long) actual);
		}
		#else
		#ifdef HAVE_WIN32_THREADS
		Sleep( sleepTime/1000 );
		#else
		usleep((long) sleepTime);
		#endif
		#endif
		}

		//printf("slept %d\n", sleepTime);

		if (overSlept)
		return 1; // close enough
		else
		return 0;
		}


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

libs/utils/ported.cpp

deleted100644 → 0

+0 −106

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2005 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		//
		// Ports of standard functions that don't exist on a specific platform.
		//
		// Note these are NOT in the "android" namespace.
		//
		#include <utils/ported.h>

		#if defined(NEED_GETTIMEOFDAY) \|\| defined(NEED_USLEEP)
		# include <sys/time.h>
		# include <windows.h>
		#endif


		#if defined(NEED_GETTIMEOFDAY)
		/*
		* Replacement gettimeofday() for Windows environments (primarily MinGW).
		*
		* Ignores "tz".
		*/
		int gettimeofday(struct timeval* ptv, struct timezone* tz)
		{
		long long nsTime; // time in 100ns units since Jan 1 1601
		FILETIME ft;

		if (tz != NULL) {
		// oh well
		}

		::GetSystemTimeAsFileTime(&ft);
		nsTime = (long long) ft.dwHighDateTime << 32 \|
		(long long) ft.dwLowDateTime;
		// convert to time in usec since Jan 1 1970
		ptv->tv_usec = (long) ((nsTime / 10LL) % 1000000LL);
		ptv->tv_sec = (long) ((nsTime - 116444736000000000LL) / 10000000LL);

		return 0;
		}
		#endif

		#if defined(NEED_USLEEP)
		//
		// Replacement usleep for Windows environments (primarily MinGW).
		//
		void usleep(unsigned long usec)
		{
		// Win32 API function Sleep() takes milliseconds
		::Sleep((usec + 500) / 1000);
		}
		#endif

		#if 0 //defined(NEED_PIPE)
		//
		// Replacement pipe() command for MinGW
		//
		// The _O_NOINHERIT flag sets bInheritHandle to FALSE in the
		// SecurityAttributes argument to CreatePipe(). This means the handles
		// aren't inherited when a new process is created. The examples I've seen
		// use it, possibly because there's a lot of junk going on behind the
		// scenes. (I'm assuming "process" and "thread" are different here, so
		// we should be okay spinning up a thread.) The recommended practice is
		// to dup() the descriptor you want the child to have.
		//
		// It appears that unnamed pipes can't do non-blocking ("overlapped") I/O.
		// You can't use select() either, since that only works on sockets. The
		// Windows API calls that are useful here all operate on a HANDLE, not
		// an integer file descriptor, and I don't think you can get there from
		// here. The "named pipe" stuff is insane.
		//
		int pipe(int filedes[2])
		{
		return _pipe(filedes, 0, _O_BINARY \| _O_NOINHERIT);
		}
		#endif

		#if defined(NEED_SETENV)
		/*
		* MinGW lacks these. For now, just stub them out so the code compiles.
		*/
		int setenv(const char* name, const char* value, int overwrite)
		{
		return 0;
		}
		void unsetenv(const char* name)
		{
		}
		char* getenv(const char* name)
		{
		return NULL;
		}
		#endif