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; }
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"); }
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; }
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; }
//------------------------------------------------------------------------------ // 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 }
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 }
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; }
/// \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; }
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; }
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; }
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); }
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 }
// 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; }
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; } }
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; }
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); }
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 }
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; }
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 }
// 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(); }
/** * 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 }
// Возвращает в милисекундах разницу во времени между двумя временными отсчётами 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")); }
// 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 }
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 }
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; }
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; }
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; }