Exemplo n.º 1
0
int clock_gettime(clockid_t clk_id, struct timespec *tp)
{
        kern_return_t ret;
        clock_serv_t clk;
        clock_id_t clk_serv_id;
        mach_timespec_t tm;
        uint64_t start, end, delta, nano;
        int retval = -1;

        switch (clk_id) {
                case CLOCK_REALTIME:
                case CLOCK_MONOTONIC:
                        clk_serv_id = clk_id == CLOCK_REALTIME ? CALENDAR_CLOCK : SYSTEM_CLOCK;
                        if (KERN_SUCCESS == (ret = host_get_clock_service(mach_host_self(), clk_serv_id, &clk))) {
                                if (KERN_SUCCESS == (ret = clock_get_time(clk, &tm))) {
                                        tp->tv_sec  = tm.tv_sec;
                                        tp->tv_nsec = tm.tv_nsec;
                                        retval = 0;
                                }
                        }
                        if (KERN_SUCCESS != ret) {
                                errno = EINVAL;
                                retval = -1;
                        }
                break;
                case CLOCK_PROCESS_CPUTIME_ID:
                case CLOCK_THREAD_CPUTIME_ID:
                        start = mach_absolute_time();
                        if (clk_id == CLOCK_PROCESS_CPUTIME_ID) {
                                getpid();
                        } else {
                                sched_yield();
                        }
                        end = mach_absolute_time();
                        delta = end - start;
                        if (0 == clock_gettime_inf.denom) {
                                mach_timebase_info(&clock_gettime_inf);
                        }
                        nano = delta * clock_gettime_inf.numer / clock_gettime_inf.denom;
                        tp->tv_sec = nano * 1e-9;
                        tp->tv_nsec = nano - (tp->tv_sec * 1e9);
                        retval = 0;
                break;
                default:
                        errno = EINVAL;
                        retval = -1;
        }
        return retval;
}
Exemplo n.º 2
0
Arquivo: tools.cpp Projeto: dedok/nkit
  uint64_t cputime()
  {
#ifdef __MACH__ // OS X does not have clock_gettime, use clock_get_time
    clock_serv_t cclock;
    mach_timespec_t t;
    host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
    clock_get_time(cclock, &t);
    mach_port_deallocate(mach_task_self(), cclock);
    return t.tv_sec * __FREQUENCY + t.tv_nsec;
#else
    timespec t;
    clock_gettime(CLOCK_MONOTONIC, &t);
    return t.tv_sec * __FREQUENCY + t.tv_nsec;
#endif
  }
/* this function is a lightly modified version of some code from Apple's developer homepage to detect G5 CPUs at runtime */
main()
{
	host_basic_info_data_t hostInfo;
	mach_msg_type_number_t infoCount;
	boolean_t is_G5;

	infoCount = HOST_BASIC_INFO_COUNT;
	host_info(mach_host_self(), HOST_BASIC_INFO,
			  (host_info_t)&hostInfo, &infoCount);

	 is_G5 = ((hostInfo.cpu_type == CPU_TYPE_POWERPC) &&
			(hostInfo.cpu_subtype == CPU_SUBTYPE_POWERPC_970));
	 if (is_G5)
		 printf("1");
}
Exemplo n.º 4
0
int
clock_gettime(clock_t clock_id, struct timespec *timestamp)
{
  clock_serv_t clock_server;
  mach_timespec_t mach_timestamp;

  host_get_clock_service(mach_host_self(), clock_id, &clock_server);
  clock_get_time(clock_server, &mach_timestamp);

  timestamp->tv_sec = mach_timestamp.tv_sec;
  timestamp->tv_nsec = mach_timestamp.tv_nsec;

  mach_port_deallocate(mach_task_self(), clock_server);
  return 0;
}
Exemplo n.º 5
0
double current_time() {
    struct timespec ts;
#ifdef __MACH__
    clock_serv_t cclock;
    mach_timespec_t mts;
    host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
    clock_get_time(cclock, &mts);
    mach_port_deallocate(mach_task_self(), cclock);
    ts.tv_sec = mts.tv_sec;
    ts.tv_nsec = mts.tv_nsec;
#else
    clock_gettime(CLOCK_REALTIME, &ts);
#endif
    return (double)ts.tv_sec + (double)ts.tv_nsec / 1000000000.0;
}
const FPlatformMemoryConstants& FIOSPlatformMemory::GetConstants()
{
	static FPlatformMemoryConstants MemoryConstants;

	if( MemoryConstants.TotalPhysical == 0 )
	{
		// Gather platform memory constants.
		
		// Get page size.
		vm_size_t PageSize;
		host_page_size(mach_host_self(), &PageSize);

		// Get swap file info
		xsw_usage SwapUsage;
		SIZE_T Size = sizeof(SwapUsage);
		sysctlbyname("vm.swapusage", &SwapUsage, &Size, NULL, 0);

		// Get memory.
		vm_statistics Stats;
		mach_msg_type_number_t StatsSize = sizeof(Stats);
		host_statistics(mach_host_self(), HOST_VM_INFO, (host_info_t)&Stats, &StatsSize);
		uint64_t FreeMem = Stats.free_count * PageSize;
		uint64_t UsedMem = (Stats.active_count + Stats.inactive_count + Stats.wire_count) * PageSize;
		uint64_t TotalPhys = FreeMem + UsedMem;
		uint64_t TotalPageFile = SwapUsage.xsu_total;
		uint64_t TotalVirtual = TotalPhys + TotalPageFile;
	
		MemoryConstants.TotalPhysical = TotalPhys;
		MemoryConstants.TotalVirtual = TotalVirtual;
		MemoryConstants.PageSize = (uint32)PageSize;

		MemoryConstants.TotalPhysicalGB = (MemoryConstants.TotalPhysical + 1024 * 1024 * 1024 - 1) / 1024 / 1024 / 1024;
	}

	return MemoryConstants;	
}
Exemplo n.º 7
0
//------------------------------------------------------------------------------
// Clock::GetTime
//------------------------------------------------------------------------------
double Clock::GetTime()
{
#if defined(WIN32)
    QueryPerformanceFrequency(&_frequency);
    QueryPerformanceCounter(&_counter);
    return (double(_counter.QuadPart) / double(_frequency.QuadPart));
#elif __MACH__
    clock_serv_t cclock;
    mach_timespec_t mts;
    host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
    clock_get_time(cclock, &mts);
    mach_port_deallocate(mach_task_self(), cclock);
    return mts.tv_sec + 1e-9 * mts.tv_nsec;
#endif
}
Exemplo n.º 8
0
void current_utc_time(struct timespec *ts) {

#ifdef __MACH__ // OS X does not have clock_gettime, use clock_get_time
  clock_serv_t cclock;
  mach_timespec_t mts;
  host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
  clock_get_time(cclock, &mts);
  mach_port_deallocate(mach_task_self(), cclock);
  ts->tv_sec = mts.tv_sec;
  ts->tv_nsec = mts.tv_nsec;
#else
  clock_gettime(CLOCK_REALTIME, ts);
#endif

}
Exemplo n.º 9
0
time_t get_monotonic_timestamp() {
    struct timespec ts;
#if defined(__MACH__) && ! defined(CLOCK_REALTIME) // OS X does not have clock_gettime, use clock_get_time
    clock_serv_t cclock;
    mach_timespec_t mts;
    host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
    clock_get_time(cclock, &mts);
    mach_port_deallocate(mach_task_self(), cclock);
    ts.tv_sec = mts.tv_sec;
    ts.tv_nsec = mts.tv_nsec;
#else
    clock_gettime(CLOCK_REALTIME, &ts);
#endif
    return ts.tv_sec;
}
Exemplo n.º 10
0
/// \return .tv_sec .tv_nsec
inline struct timespec monotonic_timespec() {
  struct timespec ts;
#ifdef __MACH__  // OS X does not have clock_gettime, use clock_get_time
  clock_serv_t cclock;
  mach_timespec_t mts;
  host_get_clock_service(mach_host_self(), SYSTEM_CLOCK, &cclock);
  clock_get_time(cclock, &mts);
  mach_port_deallocate(mach_task_self(), cclock);
  ts.tv_sec = mts.tv_sec;
  ts.tv_nsec = mts.tv_nsec;
#else
  clock_gettime(CLOCK_MONOTONIC, &ts);
#endif
  return ts;
}
Exemplo n.º 11
0
int clock_gettime(int i,struct timespec *ts) {
    if (i != 42)
    {
        errno = EINVAL;
        return -1;
    }
    clock_serv_t cclock;
    mach_timespec_t mts;
    host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
    clock_get_time(cclock, &mts);
    mach_port_deallocate(mach_task_self(), cclock);
    ts->tv_sec = mts.tv_sec;
    ts->tv_nsec = mts.tv_nsec;
    return 0;
    }
Exemplo n.º 12
0
int clock_gettime(int clk_id, struct timespec *ts)
{
	clock_serv_t cclock;
	mach_timespec_t mts;
	kern_return_t retval = KERN_SUCCESS;

	host_get_clock_service(mach_host_self(), SYSTEM_CLOCK, &cclock);
	retval = clock_get_time(cclock, &mts);
	mach_port_deallocate(mach_task_self(), cclock);

	ts->tv_sec = mts.tv_sec;
	ts->tv_nsec = mts.tv_nsec;

	return retval;
}
Exemplo n.º 13
0
u64 raw__nanoseconds_since_1970() {
  struct timespec ts;
#ifdef F2__APPLE // OS X does not have clock_gettime, use clock_get_time
  clock_serv_t cclock;
  mach_timespec_t mts;
  host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
  clock_get_time(cclock, &mts);
  mach_port_deallocate(mach_task_self(), cclock);
  ts.tv_sec = mts.tv_sec;
  ts.tv_nsec = mts.tv_nsec;
#else
  clock_gettime(CLOCK_REALTIME, &ts);
#endif
  return (((u64)ts.tv_sec) * nanoseconds_per_second) + ((u64)ts.tv_nsec);
}
Exemplo n.º 14
0
  static inline void
  current_utc_time(struct timespec *ts)
  {
#if defined(__APPLE__) && defined(__MACH__)
    clock_serv_t cclock;
    mach_timespec_t mts;
    host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
    clock_get_time(cclock, &mts);
    mach_port_deallocate(mach_task_self(), cclock);
    ts->tv_sec = mts.tv_sec;
    ts->tv_nsec = mts.tv_nsec;
#else
    clock_gettime(CLOCK_REALTIME, ts);
#endif
  }
Exemplo n.º 15
0
// Internal function
static inline host_cpu_load_info_data_t _get_cpu_percentage()
{
    kern_return_t              error;
    mach_msg_type_number_t     count;
    host_cpu_load_info_data_t  r_load;
    mach_port_t                mach_port;

    count = HOST_CPU_LOAD_INFO_COUNT;
    mach_port       = mach_host_self();
    error = host_statistics(mach_port, HOST_CPU_LOAD_INFO, (host_info_t)&r_load, &count);
    if (error != KERN_SUCCESS)
        return host_cpu_load_info_data_t();

    return r_load;
}
Exemplo n.º 16
0
void wTimeInit()
{
    assert(!gTimeInitDone);
    if (!gTimeInitDone)
    {
        #if defined(__APPLE__)
        int ret = host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &gClockServ);
        assert(ret == 0);
        #elif defined(__WIN32__)
        int ret = QueryPerformanceFrequency(&gFrequency);
        assert(ret != 0);
        #endif
        gTimeInitDone = true;
    }
}
Exemplo n.º 17
0
int	VM_MEMORY_SIZE(AGENT_REQUEST *request, AGENT_RESULT *result)
{
	char	*mode;
	int	ret = SYSINFO_RET_FAIL;

	if (1 < request->nparam)
	{
		SET_MSG_RESULT(result, zbx_strdup(NULL, "Too many parameters."));
		return SYSINFO_RET_FAIL;
	}

	if (0 == pagesize)
	{
		if (KERN_SUCCESS != host_page_size(mach_host_self(), &pagesize))
		{
			SET_MSG_RESULT(result, zbx_strdup(NULL, "Cannot obtain host page size."));
			return SYSINFO_RET_FAIL;
		}
	}

	mode = get_rparam(request, 0);

	if (NULL == mode || '\0' == *mode || 0 == strcmp(mode, "total"))
		ret = VM_MEMORY_TOTAL(result);
	else if (0 == strcmp(mode, "active"))
		ret = VM_MEMORY_ACTIVE(result);
	else if (0 == strcmp(mode, "inactive"))
		ret = VM_MEMORY_INACTIVE(result);
	else if (0 == strcmp(mode, "wired"))
		ret = VM_MEMORY_WIRED(result);
	else if (0 == strcmp(mode, "free"))
		ret = VM_MEMORY_FREE(result);
	else if (0 == strcmp(mode, "used"))
		ret = VM_MEMORY_USED(result);
	else if (0 == strcmp(mode, "pused"))
		ret = VM_MEMORY_PUSED(result);
	else if (0 == strcmp(mode, "available"))
		ret = VM_MEMORY_AVAILABLE(result);
	else if (0 == strcmp(mode, "pavailable"))
		ret = VM_MEMORY_PAVAILABLE(result);
	else
	{
		SET_MSG_RESULT(result, zbx_strdup(NULL, "Invalid first parameter."));
		return SYSINFO_RET_FAIL;
	}

	return ret;
}
Exemplo n.º 18
0
VALUE gettime_monotonic(VALUE self) {
  struct timespec ts;

#ifdef __MACH__ // OS X does not have clock_gettime, use clock_get_time
  clock_serv_t cclock;
  mach_timespec_t mts;
  host_get_clock_service(mach_host_self(), SYSTEM_CLOCK, &cclock);
  clock_get_time(cclock, &mts);
  mach_port_deallocate(mach_task_self(), cclock);
  ts.tv_sec = mts.tv_sec;
  ts.tv_nsec = mts.tv_nsec;
#else
  clock_gettime(CLOCK_REALTIME, &ts);
#endif
  return rb_float_new((double)ts.tv_sec + (double)ts.tv_nsec * 1e-9);
}
Exemplo n.º 19
0
static unsigned long long current_time_ns() {
#ifdef __MACH__
    clock_serv_t cclock;
    mach_timespec_t mts;
    host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
    clock_get_time(cclock, &mts);
    mach_port_deallocate(mach_task_self(), cclock);
    unsigned long long s = 1000000000ULL * (unsigned long long)mts.tv_sec;
    return (unsigned long long)mts.tv_nsec + s;
#else
    struct timespec t ={0,0};
    clock_gettime(CLOCK_MONOTONIC, &t);
    unsigned long long s = 1000000000ULL * (unsigned long long)t.tv_sec;
    return (((unsigned long long)t.tv_nsec)) + s;
#endif
}
Exemplo n.º 20
0
EXPORT
void GetSystemInfo(LPSYSTEM_INFO lpSystemInfo){
	host_name_port_t myhost;
	host_basic_info_data_t hinfo;
	vm_size_t page_size;
	mach_msg_type_number_t count;
	
	myhost = mach_host_self();
	count = HOST_BASIC_INFO_COUNT;
	host_info(myhost, HOST_BASIC_INFO, (host_info_t) &hinfo, &count);
	host_page_size(myhost, &page_size);
	
	lpSystemInfo->dwPageSize = page_size;
	lpSystemInfo->dwNumberOfProcessors = hinfo.avail_cpus;
	return;
}
Exemplo n.º 21
0
Arquivo: nif.c Projeto: arekinath/e2qc
void
clock_now(struct timespec *ts)
{
#if defined(__MACH__)
	/* this is not quite monotonic time, but hopefully it's good enough */
	clock_serv_t cclock;
	mach_timespec_t mts;
	host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
	clock_get_time(cclock, &mts);
	mach_port_deallocate(mach_task_self(), cclock);
	ts->tv_sec = mts.tv_sec;
	ts->tv_nsec = mts.tv_nsec;
#else
	clock_gettime(CLOCK_MONOTONIC, ts);
#endif
}
Exemplo n.º 22
0
    // Fill the stop point
    void check()
    {

#ifdef __MACH__ // OS X does not have clock_gettime, use clock_get_time
        clock_serv_t cclock;
        mach_timespec_t mts;
        host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
        clock_get_time(cclock, &mts);
        mach_port_deallocate(mach_task_self(), cclock);
        tsstop.tv_sec = mts.tv_sec;
        tsstop.tv_nsec = mts.tv_nsec;
#else
        clock_gettime(CLOCK_REALTIME, &tsstop);
#endif
        cstop = clock();
    }
Exemplo n.º 23
0
/**
 * Stops the high resolution timer
 */
void stop_timer(struct hrtimer_t *timer) {
#ifdef LINUX
	clock_gettime(CLOCK_REALTIME, &timer->stop);
#elif __APPLE__
// OS X does not have clock_gettime, use clock_get_time
    clock_serv_t cclock;
    mach_timespec_t mts;
    host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
    clock_get_time(cclock, &mts);
    mach_port_deallocate(mach_task_self(), cclock);
    timer->stop.tv_sec = mts.tv_sec;
    timer->stop.tv_nsec = mts.tv_nsec;
#else
	QueryPerformanceCounter(&timer->stop);
#endif
}
Exemplo n.º 24
0
// Возвращает в милисекундах разницу во времени между двумя временными отсчётами
void CTimePrivate::captureTime()
{
#ifdef __MACH__ // OS X does not have clock_gettime, use clock_get_time
	clock_serv_t cclock;
	mach_timespec_t mts;
	host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
	clock_get_time(cclock, &mts);
	mach_port_deallocate(mach_task_self(), cclock);
	m_tspec.tv_sec = mts.tv_sec;
	m_tspec.tv_nsec = mts.tv_nsec;
	m_bIsValid = true;
#else
	m_bIsValid = clock_gettime(CLOCK_MONOTONIC, &m_tspec) == 0;
#endif
	assert(m_bIsValid == bool("Error calling clock_gettime"));
}
Exemplo n.º 25
0
// the portable function for clock_gettime ;-)
void current_utc_time(struct timespec *ts) {
// mac implementation of clock_get_time by: jbenet (https://gist.github.com/1087739)
#ifdef __MACH__ // OS X does not have clock_gettime, use clock_get_time
  clock_serv_t cclock;
  mach_timespec_t mts;
  host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
  clock_get_time(cclock, &mts);
  mach_port_deallocate(mach_task_self(), cclock);
  ts->tv_sec = mts.tv_sec;
  ts->tv_nsec = mts.tv_nsec;
#elif _WIN32
  clock_gettime(CLOCK_REALTIME, (struct timeval*)ts);
#else /* LINUX */
  clock_gettime(CLOCK_REALTIME, ts);
#endif
}
Exemplo n.º 26
0
void corto_timeGet(corto_time* time) {
#ifdef __MACH__ // OS X does not have clock_gettime, use clock_get_time
    clock_serv_t cclock;
    mach_timespec_t mts;
    host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
    clock_get_time(cclock, &mts);
    mach_port_deallocate(mach_task_self(), cclock);
    time->sec = mts.tv_sec;
    time->nanosec = mts.tv_nsec;
#else
    struct timespec t;
    clock_gettime(CLOCK_REALTIME, &t);
    time->sec = t.tv_sec;
    time->nanosec = t.tv_nsec;
#endif
}
Exemplo n.º 27
0
unsigned long getMilliSec()
{
    struct timespec ts;
 #ifdef __MACH__ // OS X does not have clock_gettime, use clock_get_time
    clock_serv_t cclock;
    mach_timespec_t mts;
    host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
    clock_get_time(cclock, &mts);
    mach_port_deallocate(mach_task_self(), cclock);
    ts.tv_sec = mts.tv_sec;
    ts.tv_nsec = mts.tv_nsec;
#else
   clock_gettime(CLOCK_REALTIME, &ts);
#endif
    return 1000 * ts.tv_sec + ts.tv_nsec/1000000;
}
Exemplo n.º 28
0
void _init_clock_port(void) {
	kern_return_t kr;
	mach_port_t host = mach_host_self();
	
	/* Get the clock service port for nanosleep */
	kr = host_get_clock_service(host, SYSTEM_CLOCK, &clock_port);
	if (kr != KERN_SUCCESS) {
		abort();
	}
	
	kr = semaphore_create(mach_task_self_, &clock_sem, SYNC_POLICY_FIFO, 0);
	if (kr != KERN_SUCCESS) {
		abort();
	}
	mach_port_deallocate(mach_task_self(), host);
}
void AJ_InitTimer(AJ_Time* timer)
{
    struct timespec now;
    
    clock_serv_t cclock;
    mach_timespec_t mts;
    host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
    clock_get_time(cclock, &mts);
    mach_port_deallocate(mach_task_self(), cclock);
    now.tv_sec = mts.tv_sec;
    now.tv_nsec = mts.tv_nsec;
    
    //clock_gettime(CLOCK_MONOTONIC, &now);
    timer->seconds = now.tv_sec;
    timer->milliseconds = now.tv_nsec / 1000000;
}
Exemplo n.º 30
0
avdecc_lib_os::aTimestamp timer::clk_monotonic(void)
{
    struct timespec tp;
    avdecc_lib_os::aTimestamp time;

    clock_serv_t cclock;
    mach_timespec_t mts;
    host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
    clock_get_time(cclock, &mts);
    mach_port_deallocate(mach_task_self(), cclock);
    tp.tv_sec = mts.tv_sec;
    tp.tv_nsec = mts.tv_nsec;

    time = (avdecc_lib_os::aTimestamp)(tp.tv_sec * 1000) + (avdecc_lib_os::aTimestamp)(tp.tv_nsec/1000000);
    return time;
}