Changeset - 098a8d4c944c
Parent rev.
Child rev.
[Not reviewed]
Merge
0 4 0
Jan Kaluza - 13 years ago 2013-02-04 19:46:32
hanzz.k@gmail.com
Merge pull request #26 from vitalyster/win32_memusage

memory usage on Windows
4 files changed with 15 insertions and 13 deletions:
include/transport/memoryusage.h
2
4
src/CMakeLists.txt
1
1
src/admininterface.cpp
8
src/memoryusage.cpp
12
0 comments (0 inline, 0 general)
include/transport/memoryusage.h
➞
Show inline comments
 
/**
 
 * libtransport -- C++ library for easy XMPP Transports development
 
 *
 
 * Copyright (C) 2011, Jan Kaluza <hanzz.k@gmail.com>
 
 *
 
 * This program is free software; you can redistribute it and/or modify
 
 * it under the terms of the GNU General Public License as published by
 
 * the Free Software Foundation; either version 2 of the License, or
 
 * (at your option) any later version.
 
 *
 
 * This program is distributed in the hope that it will be useful,
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
 * GNU General Public License for more details.
 
 *
 
 * You should have received a copy of the GNU General Public License
 
 * along with this program; if not, write to the Free Software
 
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
 
 */
 

			




	
	
	
		
 
#pragma once

			




	
	
	
		
 

			




	
	
	
		
 
#include <vector>

			




	
	
	
		
 

			




	
	
	
		
 
#ifndef WIN32

			




	
	
	
		
 
#include "signal.h"

			




	
	
	
		
 
#else 

			




	
	
	
		
 
#define pid_t void*

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
namespace Transport {

			




	
	
	
		
 

			




	
	
	
		
 
#ifndef WIN32

			




	
	
	
		
 
	void process_mem_usage(double& shared, double& resident_set, pid_t pid = 0);

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
}

			




        

    


    
    

    

        

                

                    src/CMakeLists.txt
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -2,64 +2,64 @@ cmake_minimum_required(VERSION 2.6)

			




	
	
	
		
 
FILE(GLOB SRC *.cpp *.h)

			




	
	
	
		
 
FILE(GLOB_RECURSE SWIFTEN_SRC ../include/Swiften/*.cpp)

			




	
	
	
		
 

			




	
	
	
		
 
# Build without openssl on msvc

			




	
	
	
		
 
if (NOT MSVC)

			




	
	
	
		
 
	string(REGEX REPLACE "[^;]+;?/Schannel/[^;]+;?" "" SWIFTEN_SRC "${SWIFTEN_SRC}") 

			




	
	
	
		
 
else()

			




	
	
	
		
 
	string(REGEX REPLACE "[^;]+;?/OpenSSL/[^;]+;?" "" SWIFTEN_SRC "${SWIFTEN_SRC}") 

			




	
	
	
		
 
endif()

			




	
	
	
		
 

			




	
	
	
		
 
FILE(GLOB HEADERS ../include/transport/*.h)

			




	
	
	
		
 

			




	
	
	
		
 
if (CPPUNIT_FOUND)

			




	
	
	
		
 
	FILE(GLOB SRC_TEST tests/*.cpp)

			




	
	
	
		
 

			




	
	
	
		
 
	ADD_EXECUTABLE(libtransport_test ${SRC_TEST})

			




	
	
	
		
 
	set_target_properties(libtransport_test PROPERTIES COMPILE_DEFINITIONS LIBTRANSPORT_TEST=1)

			




	
	
	
		
 

			




	
	
	
		
 
	target_link_libraries(libtransport_test transport ${CPPUNIT_LIBRARY} ${Boost_LIBRARIES})

			




	
	
	
		
 
endif()

			




	
	
	
		
 

			




	
	
	
		
 
if (NOT WIN32)

			




	
	
	
		
 
include_directories(${POPT_INCLUDE_DIR})

			




	
	
	
		
 
endif()

			




	
	
	
		
 

			




	
	
	
		
 
# SOURCE_GROUP(headers FILES ${HEADERS})

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
if (PROTOBUF_FOUND)

			




	
	
	
		
 
	if (NOT WIN32)

			




	
	
	
		
 
		ADD_LIBRARY(transport SHARED ${HEADERS} ${SRC} ${SWIFTEN_SRC})

			




	
	
	
		
 
	else()

			




	
	
	
		
 
		ADD_LIBRARY(transport STATIC ${HEADERS} ${SRC} ${SWIFTEN_SRC})

			




	
	
	
		
 
	endif()

			




	
	
	
		
 
#	SET_SOURCE_FILES_PROPERTIES(${CMAKE_CURRENT_BINARY_DIR}/../include/transport/protocol.pb.cc PROPERTIES GENERATED 1)

			




	
	
	
		
 
	ADD_DEPENDENCIES(transport pb) 

			




	
	
	
		
 
else(PROTOBUF_FOUND)

			




	
	
	
		
 
	ADD_LIBRARY(transport SHARED ${HEADERS} ${SRC} ${SWIFTEN_SRC})

			




	
	
	
		
 
endif(PROTOBUF_FOUND)

			




	
	
	
		
 

			




	
	
	
		
 
# if (CMAKE_COMPILER_IS_GNUCXX)

			




	
	
	
		
 
	if (NOT WIN32)

			




	
	
	
		
 
		ADD_DEFINITIONS(-fPIC)

			




	
	
	
		
 
	endif()

			




	
	
	
		
 
# endif()

			




	
	
	
		
 

			




	
	
	
		
 
if (WIN32)

			




	
	
	
		
 
	include_directories("${CMAKE_SOURCE_DIR}/msvc-deps/sqlite3")

			




	
	
	
		
 
	TARGET_LINK_LIBRARIES(transport transport-plugin sqlite3 ${PQXX_LIBRARY} ${PQ_LIBRARY} ${MYSQL_LIBRARIES} ${SWIFTEN_LIBRARY} ${LOG4CXX_LIBRARIES} ${PROTOBUF_LIBRARY})

			




	
	
	
		
 
	TARGET_LINK_LIBRARIES(transport transport-plugin sqlite3 ${PQXX_LIBRARY} ${PQ_LIBRARY} ${MYSQL_LIBRARIES} ${SWIFTEN_LIBRARY} ${LOG4CXX_LIBRARIES} ${PROTOBUF_LIBRARY} psapi.lib)

			




	
	
	
		
 
else()

			




	
	
	
		
 
	TARGET_LINK_LIBRARIES(transport transport-plugin ${PQXX_LIBRARY} ${PQ_LIBRARY} ${SQLITE3_LIBRARIES} ${MYSQL_LIBRARIES} ${SWIFTEN_LIBRARY} ${LOG4CXX_LIBRARIES} ${POPT_LIBRARY} ${PROTOBUF_LIBRARY})

			




	
	
	
		
 
endif()

			




	
	
	
		
 

			




	
	
	
		
 
SET_TARGET_PROPERTIES(transport PROPERTIES

			




	
	
	
		
 
      VERSION ${TRANSPORT_VERSION} SOVERSION ${TRANSPORT_VERSION}

			




	
	
	
		
 
)

			




	
	
	
		
 
if (APPLE)

			




	
	
	
		
 
	TARGET_LINK_LIBRARIES(transport ${APPLE_FRAMEWORKS})

			




	
	
	
		
 
endif()

			




	
	
	
		
 

			




	
	
	
		
 
INSTALL(TARGETS transport LIBRARY DESTINATION ${LIB_INSTALL_DIR} ARCHIVE DESTINATION ${LIB_INSTALL_DIR} COMPONENT libraries)

			




	
	
	
		
 

			




	
	
	
		
 
#CONFIGURE_FILE(transport.pc.in "${CMAKE_CURRENT_BINARY_DIR}/transport.pc")

			




	
	
	
		
 
#INSTALL(FILES "${CMAKE_CURRENT_BINARY_DIR}/transport.pc" DESTINATION lib/pkgconfig)

			




        

    


    
    

    

        

                

                    src/admininterface.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -91,127 +91,119 @@ void AdminInterface::handleQuery(Swift::Message::ref message) {

			




	
	
	
		
 
		bool done = m_component->getConfig()->reload();

			




	
	
	
		
 
		if (done) {

			




	
	
	
		
 
			message->setBody("Config reloaded");

			




	
	
	
		
 
		}

			




	
	
	
		
 
		else {

			




	
	
	
		
 
			message->setBody("Error during config reload");

			




	
	
	
		
 
		}

			




	
	
	
		
 
	}

			




	
	
	
		
 
	else if (message->getBody() == "online_users_per_backend") {

			




	
	
	
		
 
		std::string lst;

			




	
	
	
		
 
		int id = 1;

			




	
	
	
		
 

			




	
	
	
		
 
		const std::list <NetworkPluginServer::Backend *> &backends = m_server->getBackends();

			




	
	
	
		
 
		for (std::list <NetworkPluginServer::Backend *>::const_iterator b = backends.begin(); b != backends.end(); b++) {

			




	
	
	
		
 
			NetworkPluginServer::Backend *backend = *b;

			




	
	
	
		
 
			lst += "Backend " + boost::lexical_cast<std::string>(id) + " (ID=" + backend->id + ")";

			




	
	
	
		
 
			lst += backend->acceptUsers ? "" : " - not-accepting";

			




	
	
	
		
 
			lst += backend->longRun ? " - long-running" : "";

			




	
	
	
		
 
			lst += ":\n";

			




	
	
	
		
 
			if (backend->users.size() == 0) {

			




	
	
	
		
 
				lst += "   waiting for users\n";

			




	
	
	
		
 
			}

			




	
	
	
		
 
			else {

			




	
	
	
		
 
				time_t now = time(NULL);

			




	
	
	
		
 
				for (std::list<User *>::const_iterator u = backend->users.begin(); u != backend->users.end(); u++) {

			




	
	
	
		
 
					User *user = *u;

			




	
	
	
		
 
					lst += "   " + user->getJID().toBare().toString();

			




	
	
	
		
 
					lst += " - non-active for " + boost::lexical_cast<std::string>(now - user->getLastActivity()) + " seconds";

			




	
	
	
		
 
					lst += "\n";

			




	
	
	
		
 
				}

			




	
	
	
		
 
			}

			




	
	
	
		
 
			id++;

			




	
	
	
		
 
		}

			




	
	
	
		
 

			




	
	
	
		
 
		message->setBody(lst);

			




	
	
	
		
 
	}

			




	
	
	
		
 
	else if (message->getBody().find("has_online_user") == 0) {

			




	
	
	
		
 
		User *user = m_userManager->getUser(getArg(message->getBody()));

			




	
	
	
		
 
		std::cout << getArg(message->getBody()) << "\n";

			




	
	
	
		
 
		message->setBody(boost::lexical_cast<std::string>(user != NULL));

			




	
	
	
		
 
	}

			




	
	
	
		
 
	else if (message->getBody() == "backends_count") {

			




	
	
	
		
 
		int backends = m_server->getBackendCount();

			




	
	
	
		
 
		message->setBody(boost::lexical_cast<std::string>(backends));

			




	
	
	
		
 
	}

			




	
	
	
		
 
	else if (message->getBody() == "res_memory") {

			




	
	
	
		
 
		double shared = 0;

			




	
	
	
		
 
		double rss = 0;

			




	
	
	
		
 
#ifndef WIN32

			




	
	
	
		
 
		process_mem_usage(shared, rss);

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
		const std::list <NetworkPluginServer::Backend *> &backends = m_server->getBackends();

			




	
	
	
		
 
		BOOST_FOREACH(NetworkPluginServer::Backend * backend, backends) {

			




	
	
	
		
 
			rss += backend->res;

			




	
	
	
		
 
		}

			




	
	
	
		
 

			




	
	
	
		
 
		message->setBody(boost::lexical_cast<std::string>(rss));

			




	
	
	
		
 
	}

			




	
	
	
		
 
	else if (message->getBody() == "shr_memory") {

			




	
	
	
		
 
		double shared = 0;

			




	
	
	
		
 
		double rss = 0;

			




	
	
	
		
 
#ifndef WIN32

			




	
	
	
		
 
		process_mem_usage(shared, rss);

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
		const std::list <NetworkPluginServer::Backend *> &backends = m_server->getBackends();

			




	
	
	
		
 
		BOOST_FOREACH(NetworkPluginServer::Backend * backend, backends) {

			




	
	
	
		
 
			shared += backend->shared;

			




	
	
	
		
 
		}

			




	
	
	
		
 

			




	
	
	
		
 
		message->setBody(boost::lexical_cast<std::string>(shared));

			




	
	
	
		
 
	}

			




	
	
	
		
 
	else if (message->getBody() == "used_memory") {

			




	
	
	
		
 
		double shared = 0;

			




	
	
	
		
 
		double rss = 0;

			




	
	
	
		
 
#ifndef WIN32

			




	
	
	
		
 
		process_mem_usage(shared, rss);

			




	
	
	
		
 
#endif

			




	
	
	
		
 
		rss -= shared;

			




	
	
	
		
 

			




	
	
	
		
 
		const std::list <NetworkPluginServer::Backend *> &backends = m_server->getBackends();

			




	
	
	
		
 
		BOOST_FOREACH(NetworkPluginServer::Backend * backend, backends) {

			




	
	
	
		
 
			rss += backend->res - backend->shared;

			




	
	
	
		
 
		}

			




	
	
	
		
 

			




	
	
	
		
 
		message->setBody(boost::lexical_cast<std::string>(rss));

			




	
	
	
		
 
	}

			




	
	
	
		
 
	else if (message->getBody() == "average_memory_per_user") {

			




	
	
	
		
 
		if (m_userManager->getUserCount() == 0) {

			




	
	
	
		
 
			message->setBody(boost::lexical_cast<std::string>(0));

			




	
	
	
		
 
		}

			




	
	
	
		
 
		else {

			




	
	
	
		
 
			unsigned long per_user = 0;

			




	
	
	
		
 
			const std::list <NetworkPluginServer::Backend *> &backends = m_server->getBackends();

			




	
	
	
		
 
			BOOST_FOREACH(NetworkPluginServer::Backend * backend, backends) {

			




	
	
	
		
 
				per_user += (backend->res - backend->init_res);

			




	
	
	
		
 
			}

			




	
	
	
		
 

			




	
	
	
		
 
			message->setBody(boost::lexical_cast<std::string>(per_user / m_userManager->getUserCount()));

			




	
	
	
		
 
		}

			




	
	
	
		
 
	}

			




	
	
	
		
 
	else if (message->getBody() == "res_memory_per_backend") {

			




	
	
	
		
 
		std::string lst;

			




	
	
	
		
 
		int id = 1;

			




	
	
	
		
 
		const std::list <NetworkPluginServer::Backend *> &backends = m_server->getBackends();

			




	
	
	
		
 
		BOOST_FOREACH(NetworkPluginServer::Backend * backend, backends) {

			




	
	
	
		
 
			lst += "Backend " + boost::lexical_cast<std::string>(id) + " (ID=" + backend->id + "): " + boost::lexical_cast<std::string>(backend->res) + "\n";

			




	
	
	
		
 
			id++;

			




	
	
	
		
 
		}

			




	
	
	
		
 

			




	
	
	
		
 
		message->setBody(lst);

			




	
	
	
		
 
	}

			




	
	
	
		
 
	else if (message->getBody() == "shr_memory_per_backend") {

			




	
	
	
		
 
		std::string lst;

			




	
	
	
		
 
		int id = 1;

			




	
	
	
		
 
		const std::list <NetworkPluginServer::Backend *> &backends = m_server->getBackends();

			




	
	
	
		
 
		BOOST_FOREACH(NetworkPluginServer::Backend * backend, backends) {

			




	
	
	
		
 
			lst += "Backend " + boost::lexical_cast<std::string>(id)  + " (ID=" + backend->id + "): " + boost::lexical_cast<std::string>(backend->shared) + "\n";

			




	
	
	
		
 
			id++;

			




	
	
	
		
 
		}

			




	
	
	
		
 

			




	
	
	
		
 
		message->setBody(lst);

			




	
	
	
		
 
	}

			




	
	
	
		
 
	else if (message->getBody() == "used_memory_per_backend") {

			




	
	
	
		
 
		std::string lst;

			




	
	
	
		
 
		int id = 1;

			




        

    


    
    

    

        

                

                    src/memoryusage.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
/**

			




	
	
	
		
 
 * XMPP - libpurple transport

			




	
	
	
		
 
 *

			




	
	
	
		
 
 * Copyright (C) 2009, Jan Kaluza <hanzz@soc.pidgin.im>

			




	
	
	
		
 
 *

			




	
	
	
		
 
 * This program is free software; you can redistribute it and/or modify

			




	
	
	
		
 
 * it under the terms of the GNU General Public License as published by

			




	
	
	
		
 
 * the Free Software Foundation; either version 2 of the License, or

			




	
	
	
		
 
 * (at your option) any later version.

			




	
	
	
		
 
 *

			




	
	
	
		
 
 * This program is distributed in the hope that it will be useful,

			




	
	
	
		
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of

			




	
	
	
		
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

			




	
	
	
		
 
 * GNU General Public License for more details.

			




	
	
	
		
 
 *

			




	
	
	
		
 
 * You should have received a copy of the GNU General Public License

			




	
	
	
		
 
 * along with this program; if not, write to the Free Software

			




	
	
	
		
 
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA

			




	
	
	
		
 
 */

			




	
	
	
		
 

			




	
	
	
		
 
#include "transport/memoryusage.h"

			




	
	
	
		
 

			




	
	
	
		
 
#include <iostream>

			




	
	
	
		
 
#include <cstring>

			




	
	
	
		
 
#include <sstream>

			




	
	
	
		
 
#include <fstream>

			




	
	
	
		
 
#include <algorithm>

			




	
	
	
		
 
#include <boost/lexical_cast.hpp>

			




	
	
	
		
 
#ifndef WIN32

			




	
	
	
		
 
#include <sys/param.h>

			




	
	
	
		
 
#else 

			




	
	
	
		
 
#include <windows.h>

			




	
	
	
		
 
#include <psapi.h>

			




	
	
	
		
 
#endif

			




	
	
	
		
 
#ifdef __MACH__

			




	
	
	
		
 
#include <mach/mach.h>

			




	
	
	
		
 
#elif BSD

			




	
	
	
		
 
#include <sys/types.h>

			




	
	
	
		
 
#include <sys/sysctl.h>

			




	
	
	
		
 
#include <sys/param.h>

			




	
	
	
		
 
#include <sys/sysctl.h>

			




	
	
	
		
 
#include <sys/user.h>

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
namespace Transport {

			




	
	
	
		
 

			




	
	
	
		
 
#ifndef WIN32

			




	
	
	
		
 
#ifdef __MACH__

			




	
	
	
		
 

			




	
	
	
		
 
void process_mem_usage(double& vm_usage, double& resident_set, pid_t pid) {

			




	
	
	
		
 

			




	
	
	
		
 
	struct task_basic_info t_info;

			




	
	
	
		
 
	mach_msg_type_number_t t_info_count = TASK_BASIC_INFO_COUNT;

			




	
	
	
		
 

			




	
	
	
		
 
	if (KERN_SUCCESS != task_info(mach_task_self(),

			




	
	
	
		
 
                              TASK_BASIC_INFO, (task_info_t)&t_info, 

			




	
	
	
		
 
                              &t_info_count)) {

			




	
	
	
		
 
		vm_usage = 0;

			




	
	
	
		
 
		resident_set = 0;

			




	
	
	
		
 
    		return;

			




	
	
	
		
 
	}

			




	
	
	
		
 
	vm_usage = t_info.virtual_size;

			




	
	
	
		
 
	resident_set = t_info.resident_size;

			




	
	
	
		
 
}

			




	
	
	
		
 
#elif BSD

			




	
	
	
		
 
void process_mem_usage(double& vm_usage, double& resident_set, pid_t pid) {

			




	
	
	
		
 
	int mib[4];

			




	
	
	
		
 
	size_t size;

			




	
	
	
		
 
	mib[0] = CTL_KERN;

			




	
	
	
		
 
	mib[1] = KERN_PROC;

			




	
	
	
		
 
	mib[2] = KERN_PROC_PID;

			




	
	
	
		
 
	if (pid == 0) {

			




	
	
	
		
 
		mib[3] = getpid();

			




	
	
	
		
 
	}

			




	
	
	
		
 
	else {

			




	
	
	
		
 
		mib[3] = pid;

			




	
	
	
		
 
	}

			




	
	
	
		
 
	struct kinfo_proc proc;

			




	
	
	
		
 

			




	
	
	
		
 
	size = sizeof(struct kinfo_proc);

			




	
	
	
		
 

			




	
	
		
 
@@ -93,51 +96,60 @@ void process_mem_usage(double& vm_usage, double& resident_set, pid_t pid) {

			




	
	
	
		
 
	int pagesize,cnt;

			




	
	
	
		
 

			




	
	
	
		
 
	size = sizeof(pagesize);

			




	
	
	
		
 
	sysctlbyname("hw.pagesize", &pagesize, &size, NULL, 0);

			




	
	
	
		
 

			




	
	
	
		
 
	resident_set = (double) (proc.ki_rssize * pagesize / 1024);

			




	
	
	
		
 
	vm_usage = (double) proc.ki_size;

			




	
	
	
		
 
}

			




	
	
	
		
 
#else /* BSD */

			




	
	
	
		
 
void process_mem_usage(double& shared, double& resident_set, pid_t pid) {

			




	
	
	
		
 
	using std::ios_base;

			




	
	
	
		
 
	using std::ifstream;

			




	
	
	
		
 
	using std::string;

			




	
	
	
		
 

			




	
	
	
		
 
	shared       = 0.0;

			




	
	
	
		
 
	resident_set = 0.0;

			




	
	
	
		
 

			




	
	
	
		
 
	// 'file' stat seems to give the most reliable results

			




	
	
	
		
 
	std::string f = "/proc/self/statm";

			




	
	
	
		
 
	if (pid != 0) {

			




	
	
	
		
 
		f = "/proc/" + boost::lexical_cast<std::string>(pid) + "/statm";

			




	
	
	
		
 
	}

			




	
	
	
		
 
	ifstream stat_stream(f.c_str(), ios_base::in);

			




	
	
	
		
 
	if (!stat_stream.is_open()) {

			




	
	
	
		
 
		shared = 0;

			




	
	
	
		
 
		resident_set = 0;

			




	
	
	
		
 
		return;

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	// dummy vars for leading entries in stat that we don't care about

			




	
	
	
		
 
	//

			




	
	
	
		
 
	string pid1, comm, state, ppid, pgrp, session, tty_nr;

			




	
	
	
		
 
	string tpgid, flags, minflt, cminflt, majflt, cmajflt;

			




	
	
	
		
 
	string utime, stime, cutime, cstime, priority, nice;

			




	
	
	
		
 
	string O, itrealvalue, starttime;

			




	
	
	
		
 

			




	
	
	
		
 
	// the two fields we want

			




	
	
	
		
 
	//

			




	
	
	
		
 
	unsigned long shared_;

			




	
	
	
		
 
	long rss;

			




	
	
	
		
 

			




	
	
	
		
 
	stat_stream >> O >> rss >> shared_; // don't care about the rest

			




	
	
	
		
 

			




	
	
	
		
 
	long page_size_kb = sysconf(_SC_PAGE_SIZE) / 1024; // in case x86-64 is configured to use 2MB pages

			




	
	
	
		
 
	shared     = shared_ * page_size_kb;

			




	
	
	
		
 
	resident_set = rss * page_size_kb;

			




	
	
	
		
 
}

			




	
	
	
		
 
#endif /* else BSD */

			




	
	
	
		
 
#else

			




	
	
	
		
 
#define PSAPI_VERSION 1

			




	
	
	
		
 
#define pid_t void*

			




	
	
	
		
 
	void process_mem_usage(double& shared, double& resident_set, pid_t pid) {

			




	
	
	
		
 
		PROCESS_MEMORY_COUNTERS_EX pmc;

			




	
	
	
		
 
		GetProcessMemoryInfo(GetCurrentProcess(), (PROCESS_MEMORY_COUNTERS*)&pmc, sizeof(pmc));

			




	
	
	
		
 
		shared =  (double)pmc.PrivateUsage;

			




	
	
	
		
 
		resident_set = (double)pmc.WorkingSetSize;

			




	
	
	
		
 
	}

			




	
	
	
		
 
#endif /* WIN32 */

			




	
	
	
		
 

			




	
	
	
		
 
}

			




        

    



    


    



    



      

      





    
    0 comments (0 inline, 0 general)
    





    


  

  







  


    




    








    
        Server instance: srv01-3934
    
    
        This site is powered by
            Kallithea,
        which is
        © 2010–2021 by various authors & licensed under GPLv3.
            – Support