Ejemplo n.º 1
0
CMemoryFunction::CMemoryFunction(const void* code, size_t size)
: m_code(nullptr)
{
#ifdef WIN32
	m_size = size;
	m_code = malloc(size);
	memcpy(m_code, code, size);
	
	DWORD oldProtect = 0;
	BOOL result = VirtualProtect(m_code, size, PAGE_EXECUTE_READWRITE, &oldProtect);
	assert(result == TRUE);
#elif defined(__APPLE__)
	vm_size_t page_size = 0;
	host_page_size(mach_task_self(), &page_size);
	unsigned int allocSize = ((size + page_size - 1) / page_size) * page_size;
	vm_allocate(mach_task_self(), reinterpret_cast<vm_address_t*>(&m_code), allocSize, TRUE); 
	memcpy(m_code, code, size);
	sys_icache_invalidate(m_code, size);
	kern_return_t result = vm_protect(mach_task_self(), reinterpret_cast<vm_address_t>(m_code), size, 0, VM_PROT_READ | VM_PROT_EXECUTE);
	assert(result == 0);
	m_size = allocSize;
#elif defined(__ANDROID__) || defined(__linux__) || defined(__FreeBSD__)
	m_size = size;
	m_code = mmap(nullptr, size, PROT_WRITE | PROT_EXEC, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
	assert(m_code != MAP_FAILED);
	memcpy(m_code, code, size);
#if defined(__arm__) || defined(__aarch64__)
	__clear_cache(m_code, reinterpret_cast<uint8*>(m_code) + size);
#endif
#endif
}
Ejemplo n.º 2
0
size_t oskar_get_free_physical_memory(void)
{
#ifdef OSKAR_OS_LINUX
    size_t freePhysMem = 0;
    struct sysinfo memInfo;
    sysinfo(&memInfo);
    freePhysMem = memInfo.freeram;
    freePhysMem *= memInfo.mem_unit;
    return freePhysMem;
#elif defined(OSKAR_OS_MAC)
    vm_size_t page_size;
    mach_port_t mach_port;
    mach_msg_type_number_t count;
    vm_statistics64_data_t vm_stats;
    mach_port = mach_host_self();
    count = sizeof(vm_stats) / sizeof(natural_t);
    if (KERN_SUCCESS == host_page_size(mach_port, &page_size) &&
            KERN_SUCCESS == host_statistics64(mach_port, HOST_VM_INFO,
                    (host_info64_t)&vm_stats, &count))
    {
        /* Note on OS X since 10.9, compressed memory makes this value somewhat
         * flexible. */
        return (size_t)((int64_t)vm_stats.free_count*(int64_t)page_size);
    }
    return 0;
#elif defined(OSKAR_OS_WIN)
    MEMORYSTATUSEX memInfo;
    memInfo.dwLength = sizeof(MEMORYSTATUSEX);
    GlobalMemoryStatusEx(&memInfo);
    DWORDLONG freePhysMem = memInfo.ullAvailPhys;
    return (size_t)freePhysMem;
#endif
}
Ejemplo n.º 3
0
bool ksmach_i_VMStats(vm_statistics_data_t* const vmStats,
                      vm_size_t* const pageSize)
{
    kern_return_t kr;
    const mach_port_t hostPort = mach_host_self();

    if((kr = host_page_size(hostPort, pageSize)) != KERN_SUCCESS)
    {
        KSLOG_ERROR("host_page_size: %s", mach_error_string(kr));
        return false;
    }

    mach_msg_type_number_t hostSize = sizeof(*vmStats) / sizeof(natural_t);
    kr = host_statistics(hostPort,
                         HOST_VM_INFO,
                         (host_info_t)vmStats,
                         &hostSize);
    if(kr != KERN_SUCCESS)
    {
        KSLOG_ERROR("host_statistics: %s", mach_error_string(kr));
        return false;
    }
    
    return true;
}
Ejemplo n.º 4
0
int run_get_dynamic_sys_info(RunSysDyn *rsd)
{
	int mib[4];
	size_t len;
	vm_size_t pagesize;
	vmtotal_t value;
	struct timeval tp;
	struct timezone tzp;
	vm_statistics_data_t vm_stat;
	mach_msg_type_number_t count;
	kern_return_t error;

	count = sizeof(vm_stat) / sizeof(natural_t);
	error = host_statistics(mach_host_self(), HOST_VM_INFO, (host_info_t)&vm_stat, &count);
	assert(error == KERN_SUCCESS && count == sizeof(vm_stat) / sizeof(natural_t));
	host_page_size(mach_host_self(), &pagesize);
	rsd->mem_free = (size_t)vm_stat.free_count * pagesize;
	rsd->mem_available = (size_t)(vm_stat.free_count + vm_stat.inactive_count) * pagesize;
	gettimeofday(&tp, &tzp);
	rsd->wall_clock = tp.tv_sec + tp.tv_usec * 1e-6;
	mib[0] = CTL_VM; mib[1] = VM_METER;
	len = sizeof(vmtotal_t);
	sysctl(mib, 2, &value, &len, 0, 0);
	assert(len == sizeof(vmtotal_t));
	return 0;
}
Ejemplo n.º 5
0
int		mach_init()
{
	kern_return_t		kr;

#undef	mach_task_self

	/*
	 *	Get the important ports into the cached values,
	 *	as required by "mach_init.h".
	 */
	 
	mach_task_self_ = mach_task_self();

	/*
	 *	Initialize the single mig reply port
	 */

	mig_init(0);

	/*
	 *	Cache some other valuable system constants
	 */

        (void) host_page_size(mach_host_self(), &vm_page_size);

	return(0);
}
Ejemplo n.º 6
0
	mach_error_t
freeBranchIsland(
		BranchIsland	*island )
{
	assert( island );
	assert( (*(long*)&island->instructions[0]) == kIslandTemplate[0] );
	assert( island->allocatedHigh );
	
	mach_error_t	err = err_none;
	
	if( island->allocatedHigh ) {
		vm_size_t pageSize;
		err = host_page_size( mach_host_self(), &pageSize );
		if( !err ) {
			assert( sizeof( BranchIsland ) <= pageSize );
			err = vm_deallocate(
					mach_task_self(),
					(vm_address_t) island, pageSize );
		}
	} else {
		free( island );
	}
	
	return err;
}
Ejemplo n.º 7
0
size_t Page_Size(void)
{
#if defined(__MACH30__)
  kern_return_t result;
  vm_size_t page_size = 0;

  result = host_page_size(mach_host_self(), &page_size);
  MACH_CHECK_ERROR(result);

  return (size_t)page_size;
#else /* ! __MACH30__ */
  static struct vm_statistics stats_data;
  static struct vm_statistics *stats = NULL;
  kern_return_t kret;

  if (stats == NULL) {
    kret = vm_statistics(mach_task_self(), &stats_data);
    MACH_CHECK_ERROR(kret);

    stats = &stats_data;
  }

  return stats->pagesize;
#endif /* ! __MACH30__ */
}
Ejemplo n.º 8
0
Archivo: pmda.c Proyecto: Aconex/pcp
void 
darwin_init(pmdaInterface *dp)
{
    if (_isDSO) {
	int sep = __pmPathSeparator();
	char helppath[MAXPATHLEN];
	sprintf(helppath, "%s%c" "darwin" "%c" "help",
		pmGetConfig("PCP_PMDAS_DIR"), sep, sep);
	pmdaDSO(dp, PMDA_INTERFACE_3, "darwin DSO", helppath);
    } else {
	__pmSetProcessIdentity(username);
    }

    if (dp->status != 0)
	return;

    dp->version.two.instance = darwin_instance;
    dp->version.two.fetch = darwin_fetch;
    pmdaSetFetchCallBack(dp, darwin_fetchCallBack);

    pmdaSetFlags(dp, PMDA_EXT_FLAG_DIRECT);
    pmdaInit(dp, indomtab, sizeof(indomtab)/sizeof(indomtab[0]),
		metrictab, sizeof(metrictab)/sizeof(metrictab[0]));

    mach_host = mach_host_self();
    host_page_size(mach_host, &mach_page_size);
    mach_page_shift = ffs(mach_page_size) - 1;
    if (refresh_hertz(&mach_hertz) != 0)
	mach_hertz = 100;
    init_network();
}
Ejemplo n.º 9
0
	mach_error_t
allocateBranchIsland(
		BranchIsland	**island,
		int				allocateHigh,
		void *originalFunctionAddress)
{
	assert( island );
	
	mach_error_t	err = err_none;
	
	if( allocateHigh ) {
		vm_size_t pageSize;
		err = host_page_size( mach_host_self(), &pageSize );
		if( !err ) {
			assert( sizeof( BranchIsland ) <= pageSize );
#if defined(__x86_64__)
			vm_address_t first = (uint64_t)originalFunctionAddress & ~(uint64_t)(((uint64_t)1 << 31) - 1) | ((uint64_t)1 << 31); // start in the middle of the page?
			vm_address_t last = 0x0;
#else
			vm_address_t first = 0xfeffffff;
			vm_address_t last = 0xfe000000 + pageSize;
#endif

			vm_address_t page = first;
			int allocated = 0;
			vm_map_t task_self = mach_task_self();
			
			while( !err && !allocated && page != last ) {

				err = vm_allocate( task_self, &page, pageSize, 0 );
				if( err == err_none )
					allocated = 1;
				else if( err == KERN_NO_SPACE ) {
#if defined(__x86_64__)
					page -= pageSize;
#else
					page += pageSize;
#endif
					err = err_none;
				}
			}
			if( allocated )
				*island = (void*) page;
			else if( !allocated && !err )
				err = KERN_NO_SPACE;
		}
	} else {
		void *block = malloc( sizeof( BranchIsland ) );
		if( block )
			*island = block;
		else
			err = KERN_NO_SPACE;
	}
	if( !err )
		(**island).allocatedHigh = allocateHigh;
	
	return err;
}
Ejemplo n.º 10
0
/**
 * lw6sys_megabytes_available
 *
 * @sys_context: global system context
 *
 * Gives a raw approximation of available memory, in megabytes.
 * Value is to be taken with distance, but it can give good hints
 * when system is running short of ressources.
 *
 * Return value: number of megabytes (physical memory) available.
 */
int
lw6sys_megabytes_available (lw6sys_context_t * sys_context)
{
  int ret = 0;

#ifdef LW6_MS_WINDOWS
  MEMORYSTATUS status;

  memset (&status, 0, sizeof (status));
  status.dwLength = sizeof (status);

  GlobalMemoryStatus (&status);
  ret = status.dwAvailPhys / MEM_DIVIDE;
#else // LW6_MS_WINDOWS
#ifdef LW6_MAC_OS_X
  vm_size_t page_size;
  mach_port_t mach_port;
  mach_msg_type_number_t count;
  vm_statistics_data_t vm_stats;
  int64_t freeram = 0;

  mach_port = mach_host_self ();
  count = sizeof (vm_stats) / sizeof (natural_t);
  if (KERN_SUCCESS == host_page_size (mach_port, &page_size) && KERN_SUCCESS == host_statistics (mach_port, HOST_VM_INFO, (host_info_t) & vm_stats, &count))
    {
      freeram = (int64_t) vm_stats.free_count * (int64_t) page_size;
    }
  freeram /= MEM_DIVIDE;
  ret = freeram;
#else // LW6_MAC_OS_X
#ifdef HAVE_SYS_SYSINFO_H
  /*
   * sys/sysinfo.h is Linux specific
   */
  struct sysinfo meminfo;
  int64_t freeram = 0;

  memset (&meminfo, 0, sizeof (struct sysinfo));
  sysinfo (&meminfo);
  freeram = meminfo.freeram;
  freeram *= meminfo.mem_unit;
  freeram /= MEM_DIVIDE;
  ret = freeram;
#else // HAVE_SYS_SYSINFO_H
#ifdef _SC_AVPHYS_PAGES
  /*
   * Fallback, seems to return low values, dunno why
   */
  ret = (sysconf (_SC_PAGESIZE) * sysconf (_SC_AVPHYS_PAGES)) / MEM_DIVIDE;
#else // _SC_AVPHYS_PAGES
  lw6sys_log (sys_context, LW6SYS_LOG_WARNING, _x_ ("unable to guess how much free memory is available"));
#endif // _SC_AVPHYS_PAGES
#endif // HAVE_SYS_SYSINFO_H
#endif // LW6_MAC_OS_X
#endif // LW6_MS_WINDOWS

  return ret;
}
Ejemplo n.º 11
0
static int tsk_pagesize(RIODesc *desc) {
	int tid = __get_pid (desc);
	task_t task = pid_to_task (desc, tid);
	static vm_size_t pagesize = 0;
	return pagesize
		? pagesize
		: (host_page_size (task, &pagesize) == KERN_SUCCESS)
			? pagesize : 4096;
}
Ejemplo n.º 12
0
bool ZGPageSize(ZGMemoryMap processTask, ZGMemorySize *pageSize)
{
	vm_size_t tempPageSize;
	kern_return_t retValue = host_page_size(processTask, &tempPageSize);
	if (retValue == KERN_SUCCESS)
	{
		*pageSize = tempPageSize;
	}
	return (retValue == KERN_SUCCESS);
}
Ejemplo n.º 13
0
int ofxMemoryUsage::getUsedMemory(){

	int mb = 0;
	int gb = 0;

#ifdef TARGET_WIN32	
    MEMORYSTATUSEX memInfo;
    memInfo.dwLength = sizeof(MEMORYSTATUSEX);
    GlobalMemoryStatusEx(&memInfo);
    DWORDLONG used_memory = memInfo.ullTotalPhys - memInfo.ullAvailPhys;
	mb = used_memory/1048576;	
#endif
	
#ifdef TARGET_LINUX
    struct sysinfo memInfo;
    sysinfo (&memInfo);
    long long used_memory = memInfo.totalram - memInfo.freeram;
    used_memory *= memInfo.mem_unit;
	mb = used_memory/1048576;
#endif
	
#if defined(TARGET_OSX) || defined(TARGET_OF_IPHONE)
	
	vm_size_t page_size;
	mach_port_t mach_port;
	mach_msg_type_number_t count;
	vm_statistics_data_t vm_stats;
	int64_t used_memory = 0;
	int64_t myFreeMemory = 0;
	
	mach_port = mach_host_self();
	count = sizeof(vm_stats) / sizeof(natural_t);
	if (KERN_SUCCESS == host_page_size(mach_port, &page_size) &&
		KERN_SUCCESS == host_statistics(mach_port, HOST_VM_INFO, 
										(host_info_t)&vm_stats, &count))
	{
		myFreeMemory = (int64_t)vm_stats.free_count * (int64_t)page_size;
		
		used_memory = ((int64_t)vm_stats.active_count + 
					   (int64_t)vm_stats.inactive_count + 
					   (int64_t)vm_stats.wire_count) *  (int64_t)page_size;
		mb = used_memory/1048576;
	}

//	int mb = used_memory/1048576;	
//	printf("physical_memory : used : mb : %i\n",mb);
//	mb = myFreeMemory/1048576;
//	printf("physical_memory : free : mb : %i\n",mb);

	
#endif
	
	return mb;
	
}
Ejemplo n.º 14
0
static int tsk_pagesize(RIOMach *riom) {
	//cache the pagesize
	static vm_size_t pagesize = 0;
	kern_return_t kr;
	if (pagesize)
		return pagesize;
	kr = host_page_size (mach_host_self (), &pagesize);
	if (kr != KERN_SUCCESS)
		pagesize = 4096;
	return pagesize;
}
Ejemplo n.º 15
0
static int32 GetFreeMemoryMB()
{
	// get free memory
	vm_size_t PageSize;
	host_page_size(mach_host_self(), &PageSize);

	// get memory stats
	vm_statistics Stats;
	mach_msg_type_number_t StatsSize = sizeof(Stats);
	host_statistics(mach_host_self(), HOST_VM_INFO, (host_info_t)&Stats, &StatsSize);
	return (Stats.free_count * PageSize) / 1024 / 1024;
}
Ejemplo n.º 16
0
mach_error_t makeIslandExecutable(void *address) {
	mach_error_t err = err_none;
    vm_size_t pageSize;
    host_page_size( mach_host_self(), &pageSize );
    uintptr_t page = (uintptr_t)address & ~(uintptr_t)(pageSize-1);
    int e = err_none;
    e |= mprotect((void *)page, pageSize, PROT_EXEC | PROT_READ | PROT_WRITE);
    e |= msync((void *)page, pageSize, MS_INVALIDATE );
    if (e) {
        err = err_cannot_override;
    }
    return err;
}
Ejemplo 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;
}
Ejemplo n.º 18
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;
}
FMalloc* FIOSPlatformMemory::BaseAllocator()
{
	// get free memory
	vm_size_t PageSize;
	host_page_size(mach_host_self(), &PageSize);

	vm_statistics Stats;
	mach_msg_type_number_t StatsSize = sizeof(Stats);
	host_statistics(mach_host_self(), HOST_VM_INFO, (host_info_t)&Stats, &StatsSize);
	// 1 << FMath::CeilLogTwo(MemoryConstants.TotalPhysical) should really be FMath::RoundUpToPowerOfTwo,
	// but that overflows to 0 when MemoryConstants.TotalPhysical is close to 4GB, since CeilLogTwo returns 32
	// this then causes the MemoryLimit to be 0 and crashing the app
	uint64 MemoryLimit = FMath::Min<uint64>( uint64(1) << FMath::CeilLogTwo(Stats.free_count * PageSize), 0x100000000);

	//return new FMallocAnsi();
	return new FMallocBinned(PageSize, MemoryLimit);
}
Ejemplo n.º 20
0
static int memory_init(void) {
#if HAVE_HOST_STATISTICS
  port_host = mach_host_self();
  host_page_size(port_host, &pagesize);
/* #endif HAVE_HOST_STATISTICS */

#elif HAVE_SYSCTLBYNAME
/* no init stuff */
/* #endif HAVE_SYSCTLBYNAME */

#elif defined(KERNEL_LINUX)
/* no init stuff */
/* #endif KERNEL_LINUX */

#elif defined(HAVE_LIBKSTAT)
  /* getpagesize(3C) tells me this does not fail.. */
  pagesize = getpagesize();
  if (get_kstat(&ksp, "unix", 0, "system_pages") != 0) {
    ksp = NULL;
    return -1;
  }
  if (get_kstat(&ksz, "zfs", 0, "arcstats") != 0) {
    ksz = NULL;
    return -1;
  }

/* #endif HAVE_LIBKSTAT */

#elif HAVE_SYSCTL
  pagesize = getpagesize();
  if (pagesize <= 0) {
    ERROR("memory plugin: Invalid pagesize: %i", pagesize);
    return -1;
  }
/* #endif HAVE_SYSCTL */

#elif HAVE_LIBSTATGRAB
/* no init stuff */
/* #endif HAVE_LIBSTATGRAB */

#elif HAVE_PERFSTAT
  pagesize = getpagesize();
#endif /* HAVE_PERFSTAT */
  return 0;
} /* int memory_init */
Ejemplo n.º 21
0
void sys::OSUnix::getMemInfo(size_t &totalPhysMem, size_t &freePhysMem) const
{
    // Unfortunately sysctl is the best way to do this on OSX,
    // but sysctl is deprecated in favor of sysconf on linux
#if defined(__APPLE__)
    long long physMem = 0;
    size_t size = sizeof(physMem);
    int status = sysctlbyname("hw.memsize", &physMem, &size, 0, 0);
    if(status)
    {
        throw sys::SystemException(Ctxt("Call to sysctl() has failed"));
    }

    mach_port_t            machPort = mach_host_self();
    mach_msg_type_number_t count     = HOST_VM_INFO_COUNT;
    vm_size_t              pageSize = 0;
    vm_statistics_data_t   vmstat;

    if(KERN_SUCCESS != host_statistics(machPort, HOST_VM_INFO,
                (host_info_t) &vmstat, &count))
    {
        throw sys::SystemException(Ctxt("Call to host_statistics() has failed"));
    }

    if(KERN_SUCCESS != host_page_size(machPort, &pageSize))
    {
        throw sys::SystemException(Ctxt("Call to host_page_size has failed"));
    }

    long long freeBytes = vmstat.free_count * pageSize;

    totalPhysMem = physMem / 1024 / 1024;
    freePhysMem = freeBytes / 1024 / 1024;

#else
    long long pageSize = sysconfCaller(_SC_PAGESIZE);
    long long totalNumPages = sysconfCaller(_SC_PHYS_PAGES);
    long long availNumPages = sysconfCaller(_SC_AVPHYS_PAGES);

    totalPhysMem = (pageSize*totalNumPages/1024)/1024;
    freePhysMem = (pageSize*availNumPages/1024)/1024;

#endif
}
Ejemplo n.º 22
0
vm_size_t
child_get_pagesize ()
{
  kern_return_t status;
  static vm_size_t g_cached_child_page_size = 0;

  if (g_cached_child_page_size == -1)
    {
      status = host_page_size (mach_host_self (), &g_cached_child_page_size);
      /* This is probably being over-careful, since if we
         can't call host_page_size on ourselves, we probably
         aren't going to get much further.  */
      if (status != KERN_SUCCESS)
        g_cached_child_page_size = 0;
      MACH_CHECK_ERROR (status);
    }

  return g_cached_child_page_size;
}
Ejemplo n.º 23
0
/*==========================================================================*/
size_t SystemInformation::FreeMemorySize()
{
// Windows
#if defined ( KVS_PLATFORM_WINDOWS )
#if defined ( KVS_PLATFORM_CPU_64 )
    MEMORYSTATUSEX memstat;
    GlobalMemoryStatusEx( &memstat );
    return memstat.ullAvailPhys;
#else
    MEMORYSTATUS memstat;
    GlobalMemoryStatus( &memstat );
    return memstat.dwAvailPhys;
#endif

// Linux
#elif defined ( KVS_PLATFORM_LINUX ) || defined ( KVS_PLATFORM_CYGWIN )
    long avphys_page_size = sysconf( _SC_AVPHYS_PAGES );
    kvsMessageWarning( avphys_page_size != -1,
                       ::GetWarningMessage( errno, "_SC_AVPHYS_PAGES is not supported." ) );

    long page_size = sysconf( _SC_PAGESIZE );
    kvsMessageWarning( page_size != -1,
                       ::GetWarningMessage( errno, "_SC_PAGESIZE is not supported." ) );

    return avphys_page_size * page_size;

// Mac OS X
#elif defined ( KVS_PLATFORM_MACOSX )
    kern_return_t kr;

    vm_size_t page_size = 0;
    kr = host_page_size( mach_host_self(), &page_size );
    kvsMessageWarning( kr != KERN_SUCCESS, "Failure to get page size." );

    vm_statistics_data_t   page_info;
    mach_msg_type_number_t count = HOST_VM_INFO_COUNT;
    kr = host_statistics( mach_host_self(), HOST_VM_INFO, (host_info_t)&page_info, &count );
    kvsMessageWarning( kr != KERN_SUCCESS, "Failure to get page info." );

    return page_info.free_count * page_size;
#endif

}
Ejemplo n.º 24
0
//====================================================================
size_t KLHeapDebug_GetRemain() {

    mach_port_t				hostport;
    mach_msg_type_number_t	szHost;
    vm_size_t				szPage;
    vm_statistics_data_t	stat;

    hostport	= mach_host_self();
    szHost		= sizeof(vm_statistics_data_t) / sizeof(integer_t);

    host_page_size( hostport, &szPage );

    if( host_statistics( hostport, HOST_VM_INFO, (host_info_t)&stat, &szHost) != KERN_SUCCESS )
    {
        KLLog("[KLHeapDebug] failed GetRemain.");
        return 0;
    }

    return stat.free_count * szPage;

}
Ejemplo n.º 25
0
bool get_available_memory(available_memory_info* info)
{
	const mach_port_t host_port = mach_host_self();
	mach_msg_type_number_t host_size = sizeof(vm_statistics_data_t) / sizeof(integer_t);

	vm_size_t pagesize;
	host_page_size(host_port, &pagesize);

	vm_statistics_data_t vm_stat;
	if(host_statistics(host_port, HOST_VM_INFO, (host_info_t)&vm_stat, &host_size) != KERN_SUCCESS) {
		return false;
	}

	if(info != NULL) {
		info->mem_used_kb = (vm_stat.active_count + vm_stat.inactive_count + vm_stat.wire_count) * (pagesize/1024);

		info->mem_free_kb = vm_stat.free_count * (pagesize/1024);
		info->mem_total_kb = info->mem_used_kb + info->mem_free_kb;
	}

	return true;
}
Ejemplo n.º 26
0
/**
* Get usage of physical memory and save data to in a SQLite db
*/
void OSXDeviceInfo::physicalMemory() {
    long long free_memory;
    long long used_memory;

    vm_size_t page_size;
    mach_port_t mach_port;
    mach_msg_type_number_t count;
    vm_statistics64_data_t vm_stats;

    mach_port = mach_host_self();
    count = sizeof(vm_stats) / sizeof(natural_t);

    // get total physical memory in bytes
    int mib[2];
    int64_t physical_memory;
    mib[0] = CTL_HW;
    mib[1] = HW_MEMSIZE;
    std::size_t length = sizeof(int64_t);
    sysctl(mib, 2, &physical_memory, &length, NULL, 0);

    if (KERN_SUCCESS == host_page_size(mach_port, &page_size) &&
        KERN_SUCCESS == host_statistics64(mach_port, HOST_VM_INFO,
                                         (host_info64_t)&vm_stats, &count)) {
        
        // get free and used memory in bytes
        free_memory = (int64_t)vm_stats.free_count * (int64_t)page_size;
        used_memory = ((int64_t)vm_stats.active_count +
                       (int64_t)vm_stats.inactive_count +
                       (int64_t)vm_stats.wire_count) *  (int64_t)page_size;
    }
    
    // create a query to save data in Mb
    std::string sql = "INSERT INTO memory(total, used, available, time) "   \
                      "VALUES (" + std::to_string(physical_memory/(1024*1024)) + "," +  \
                                   std::to_string(used_memory/(1024*1024)) + "," +      \
                                   std::to_string(free_memory/(1024*1024))  + ","  \
                      "strftime('%H:%M','now', 'localtime'));";
    db->query(sql.c_str());
}
Ejemplo n.º 27
0
int SysInfo::GetMemoryInfo(int* wired, int* active, int* inactive, int* free)
{
	int poll = 0;
    kern_return_t ke = KERN_SUCCESS;
    mach_port_t host;
    vm_size_t hps;
    vm_statistics_data_t hs;
    mach_msg_type_number_t vmsz;
	
    host = mach_host_self();
    vmsz = sizeof(hs) / sizeof(integer_t);
	
    while (1) {
        if ((ke = host_page_size(host, &hps)) != KERN_SUCCESS) {
            return EXIT_FAILURE;
        }
		
        ke = host_statistics(host, HOST_VM_INFO, (host_info_t) &hs, &vmsz);
        if (ke != KERN_SUCCESS) {
            return EXIT_FAILURE;
        }

        int used = ((hs.active_count + hs.inactive_count + hs.wire_count)* hps);
        *free = (hs.free_count * hps);
        *active = (hs.active_count * hps);
        *inactive = (hs.inactive_count * hps);
        *wired = (hs.wire_count * hps);
		
        if (poll != 0) {
            sleep(poll);
            printf("\n");
        } else {
            break;
        }
    }
	
    return EXIT_SUCCESS;
}
int
machine_init(void)
{
	/*
	 * get the page size with "getpagesize" and calculate pageshift from
	 * it
	 */
	unsigned int pagesize = 0;
	pageshift = 0;

	lcdproc_port = mach_host_self();
	host_page_size(lcdproc_port, &pagesize);

	while (pagesize > 1) {
		pageshift++;
		pagesize >>= 1;
	}

	/* we only need the amount of log(2)1024 for our conversion */
	pageshift -= 10;

	return (TRUE);
}
Ejemplo n.º 29
0
VALUE method_memory(VALUE self) {
  VALUE memory = Qnil;
  vm_size_t pagesize;
  uint host_count = HOST_VM_INFO_COUNT;
  kern_return_t err;
  vm_statistics_data_t vm_stat;
  
  err = host_page_size(mach_host_self(), &pagesize);
  if (err == KERN_SUCCESS) {
    err = host_statistics(mach_host_self(), HOST_VM_INFO,
                          (host_info_t)&vm_stat, &host_count);
    if (err == KERN_SUCCESS) {
      memory = rb_hash_new();
      rb_hash_aset(memory, SYM_PAGESIZE, ULL2NUM(pagesize));
      rb_hash_aset(memory, SYM_WIRED, ULL2NUM(vm_stat.active_count));
      rb_hash_aset(memory, SYM_ACTIVE, ULL2NUM(vm_stat.inactive_count));
      rb_hash_aset(memory, SYM_INACTIVE, ULL2NUM(vm_stat.wire_count));
      rb_hash_aset(memory, SYM_FREE, ULL2NUM(vm_stat.free_count));
      rb_hash_aset(memory, SYM_WIRED_BYTES, ULL2NUM(vm_stat.wire_count * pagesize));
      rb_hash_aset(memory, SYM_ACTIVE_BYTES, ULL2NUM(vm_stat.active_count * pagesize));
      rb_hash_aset(memory, SYM_INACTIVE_BYTES, ULL2NUM(vm_stat.inactive_count * pagesize));
      rb_hash_aset(memory, SYM_FREE_BYTES, ULL2NUM(vm_stat.free_count * pagesize));
      rb_hash_aset(memory, SYM_ZERO_FILLED, ULL2NUM(vm_stat.zero_fill_count));
      rb_hash_aset(memory, SYM_REACTIVATED, ULL2NUM(vm_stat.reactivations));
      rb_hash_aset(memory, SYM_PURGEABLE, ULL2NUM(vm_stat.purgeable_count));
      rb_hash_aset(memory, SYM_PURGED, ULL2NUM(vm_stat.purges));
      rb_hash_aset(memory, SYM_PAGEINS, ULL2NUM(vm_stat.pageins));
      rb_hash_aset(memory, SYM_PAGEOUTS, ULL2NUM(vm_stat.pageouts));
      rb_hash_aset(memory, SYM_FAULTS, ULL2NUM(vm_stat.faults));
      rb_hash_aset(memory, SYM_COW_FAULTS, ULL2NUM(vm_stat.cow_faults));
      rb_hash_aset(memory, SYM_LOOKUPS, ULL2NUM(vm_stat.lookups));
      rb_hash_aset(memory, SYM_HITS, ULL2NUM(vm_stat.hits));
    }
  }
  
  return memory;
}
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;	
}