cdeclog

sudo apt-get install libtcmalloc-minimal4

g++ -o mybin mybin.cpp -ltcmalloc_minimal 

LD_PRELOAD=/usr/lib/libtcmalloc_minimal.so mybin

// 소스에 아래와 같이 추가하여 라이브러리 참조 및 링크 심볼을 주입 함 

#pragma comment (lib, "libtcmalloc_minimal")

#pragma comment (linker, "/include:__tcmalloc") 

// 프로젝트 속성 환경에서 추가 할때는,  

// 구성속성-링커-입력-추가종속성 에 명시하여 링크를 추가하고, 

// 밑에 "강제 기호 참조"에 __tcmalloc 를 넣어주면 됨

sudo apt-get install libjemalloc-dev

// linux 

sudo apt-get install libtbb-dev

g++ -o mybin mybin.cpp -ltbbmalloc_proxy

// MSVC, tcmalloc 과 같은 방식

#pragma comment (lib, "tbbmalloc_proxy")

#pragma comment (linker, "/include:___TBB_malloc_proxy") 

// 설치 후, 설치 디렉토리에서 nmake 로 빌드 후 사용 

// dll 프리로드 후킹 (Windows)

withdll.exe /d:libtcmalloc_minimal.dll mybin

asb -d 10 -t 2 -c 40 http://localhost/index.html

> Start and Running 10s (2015-03-18.17:36:10)

  http://localhost/index.html

    40 connections and 2 Threads

> Duration         : 10000ms

    Latency        : 0.02ms

    Requests       : 426149

    Response       : 426109

    Transfer       : 147.11MB

> Per seconds

    Requests/sec   : 42610.90

    Transfer/sec   : 14.71MB

> Response Status

    HTTP/1.1 200   : 426109

> https://support.microsoft.com/ko-kr/kb/196271?wa=wsignin1.0

HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters

편집 메뉴에서 새로 만들기를 클릭하고 다음 레지스트리 항목을 추가합니다.

값 이름: MaxUserPort

값 형식: DWORD

값 데이터: 65534

유효 범위: 5000-65534(십진수)

기본값: 0x1388(십진수 5000)

설명: 이 매개 변수는 프로그램이 시스템에서 사용 가능한 사용자 포트를 요청할 때 사용되는 최대 포트 번호를 제어합니다. 일반적으로 수명이 짧은 임시(ephemeral) 포트에는 1024에서 5000 사이의 값이 할당됩니다. 보안 공지 MS08-037 릴리스 후 Windows Server 2003의 동작이 Windows Server 2008 및 Windows Vista의 동작과 보다 근접하게 일치하도록 변경되었습니다. Microsoft 보안 공지 MS08-037에 대한 자세한 내용은 다음 문서 번호를 클릭하여 Microsoft 기술 자료 문서를 참조하십시오.

 
#include <iostream>
#include <string>
#include <memory>
using namespace std;
 
#define CATCH_CONFIG_MAIN
#include "catch.hpp"
 
TEST_CASE("std::string", "test")
{
	string s = "abcedf";
 
	REQUIRE(s.capacity() > 0);
 
	SECTION("TEST 1") {
		REQUIRE(s.length() > 0);
		REQUIRE(s[0] == 'a');
		
		string ss(move(s));
		CAPTURE(ss);
 
		CAPTURE(s.capacity());
		REQUIRE(s.capacity() == 0);	// FAILED
		REQUIRE(ss.length() > 0);
	}
 
	s = "ab";
 
	SECTION("TEST 2") {
		REQUIRE_THROWS([]{ throw "error"; }());
		REQUIRE_THROWS(s.at(5) = 'e');
		REQUIRE_NOTHROW(s.at(0) = 's');
 
	}	
}
 
 
TEST_CASE("std::shared_ptr", "test")
{
	auto sp = std::make_shared<string>("init");
	CHECK(sp);
 
	auto sp2 = sp;
	CHECK(sp.use_count() == 2);
 
	weak_ptr<string> wp = sp;
	CHECK(sp.use_count() == 2);
 
	SECTION("WeakPtr 1") {
		auto spp = wp.lock();
		CAPTURE(sp.use_count());
		CAPTURE(spp.use_count());
		CHECK(spp.use_count() == 3);
	}
 
	sp.reset();
	sp2.reset();
 
	SECTION("WeakPtr 2") {
		auto spp = wp.lock();
		CAPTURE(sp.use_count());
		CAPTURE(spp.use_count());
		CHECK(spp);		// FAILED
	}
	
} 

// COMDispatch.h: interface for the IDispatch class.
//////////////////////////////////////////////////////////////////////
 
#ifndef _DISPATCH_H_20011012_BY_CDECL_
#define _DISPATCH_H_20011012_BY_CDECL_
 
#include <comdef.h>
#include <vector>
 
 
#define BYREF(x)	GLASS::COMDispatch::ToRefParam((x))
 
namespace GLASS {
 
 
class COMDispatch 
{
public:
	typedef std::vector<_variant_t> vec_param;
	typedef _variant_t PT;	
 
	// Proxy Class
	class Proxy
	{	
	public:
		void SetParent(COMDispatch *p) { pDisp_ = p; }
		void SetPropName(const _bstr_t &bstrName) { bstrName_ = bstrName; }
 
		_variant_t operator=(const _variant_t &var) const 
		{
			pDisp_->PutProperty(bstrName_, var);
			return var;
		}
 
		operator _variant_t() const { 
			return pDisp_->GetProperty(bstrName_); 
		}
 
		_variant_t operator() ()
		{
			vec_param vecParams;
			return pDisp_->Call(bstrName_, vecParams);
		}
 
		template <typename...VARS>
		_variant_t operator() (VARS...param)
		{
			vec_param vecParams = Param(param...);
			return pDisp_->Call(bstrName_, vecParams);
		}
		
	private:
 
		template <typename Vartype>
		vec_param Param(Vartype p)
		{
			vec_param v;
			v.push_back(p);
 
			return std::move(v);
		}
 
		template <typename Vartype, typename...VARS>
		vec_param Param(Vartype p, VARS...vs)
		{
			vec_param v = Param(vs...);
			v.push_back(p);
 
			return std::move(v);
		}
 
	private:
		COMDispatch *pDisp_;
		_bstr_t bstrName_;
	};
 
public:
	COMDispatch() : spDispatch_(NULL) { proxy_.SetParent(this); }
	COMDispatch(const COMDispatch &disp) : spDispatch_(disp.spDispatch_) { proxy_.SetParent(this); }
	explicit COMDispatch(const _variant_t &var) : spDispatch_(var) { proxy_.SetParent(this); }
	COMDispatch(const char *) = delete;
	COMDispatch(const wchar_t *) = delete;
	virtual ~COMDispatch() { Release(); }
 
	COMDispatch& operator=(const COMDispatch &disp);
	COMDispatch& operator=(const _variant_t &var);
 
public:
	_variant_t Call(const _bstr_t &bstrMethodName, vec_param &vecParams);
 
	void PutProperty(const _bstr_t &strPropName, const _variant_t &var, bool bRef = false);
	_variant_t GetProperty(const _bstr_t &strPropName);
 
	virtual Proxy& operator[](const _bstr_t &bstrPropName);
 
	virtual void CreateObject(const _bstr_t &bstrProgID);
	virtual void Release();
 
public:
	virtual void GetIDsOfNames(const _bstr_t &bstrMethodName, DISPID &lDispID);
 
protected:
	virtual void Invoke(const DISPID lDispID, vec_param &vecParams, _variant_t &varRetVal, 
const WORD wFlags = DISPATCH_METHOD);
 
public:
	static _variant_t ToRefParam(_variant_t &var);
 
protected:
	Proxy proxy_;
	IDispatchPtr spDispatch_;	
};
 
 
 
 
 
//////////////////////////////////////////////////////////////////////
// Dispatch implementation
 
COMDispatch& COMDispatch::operator=(const COMDispatch &disp)
{
	if (this != &disp) {
		spDispatch_ = disp.spDispatch_;
		proxy_.SetParent(this);
	}
 
	return *this;
}
 
 
COMDispatch& COMDispatch::operator=(const _variant_t &var)
{
	spDispatch_ = var;
	proxy_.SetParent(this);
 
	return *this;
}
 
void COMDispatch::Release()
{
	if (spDispatch_ != NULL) {
		spDispatch_.Release();
	}
}
 
void COMDispatch::CreateObject(const _bstr_t &bstrProgID)
{
	HRESULT hr = spDispatch_.CreateInstance((LPCSTR)bstrProgID);
 
	if (FAILED(hr)) {
		_com_raise_error(hr);
	}
}
 
_variant_t COMDispatch::Call(const _bstr_t &bstrMethodName, vec_param &vecParams)
{
	DISPID lDispID;
	GetIDsOfNames(bstrMethodName, lDispID);
 
	_variant_t varRetVal;
	Invoke(lDispID, vecParams, varRetVal);
 
	return varRetVal;
}
 
 
COMDispatch::Proxy& COMDispatch::operator[](const _bstr_t &bstrPropName)
{
	proxy_.SetPropName(bstrPropName);
	return proxy_;
}
 
 
void COMDispatch::PutProperty(const _bstr_t &strPropName, const _variant_t &var, bool bRef)
{
	DISPID lDispID;
	GetIDsOfNames(strPropName, lDispID);
 
	vec_param vecParams;
	vecParams.push_back(var);
 
	_variant_t varRetVal;
	Invoke(lDispID, vecParams, varRetVal, bRef ? DISPATCH_PROPERTYPUTREF : DISPATCH_PROPERTYPUT);
}
 
_variant_t COMDispatch::GetProperty(const _bstr_t &strPropName)
{
	DISPID lDispID;
	GetIDsOfNames(strPropName, lDispID);
 
	vec_param vecParams;
 
	_variant_t varRetVal;
	Invoke(lDispID, vecParams, varRetVal, DISPATCH_PROPERTYGET);
 
	return varRetVal;
}
 
 
void COMDispatch::GetIDsOfNames(const _bstr_t &bstrMethodName, DISPID &lDispID)
{
	BSTR bstrMN = static_cast<BSTR>(bstrMethodName);
 
	HRESULT hr = spDispatch_->GetIDsOfNames(IID_NULL, &bstrMN, 1, LOCALE_SYSTEM_DEFAULT, &lDispID);
 
	if (FAILED(hr)) {
		_com_raise_error(hr);
	}
}
 
 
void COMDispatch::Invoke(const DISPID lDispID, vec_param &vecParams, _variant_t &varRetVal, const WORD wFlags)
{
	DISPPARAMS dispparams = { 0 };
	DISPID dsipid_put = DISPID_PROPERTYPUT;
 
	if (DISPATCH_PROPERTYGET != wFlags) {
		dispparams.cArgs = vecParams.size();
		dispparams.rgvarg = (vecParams.size() == 0) ? NULL : &vecParams.front();
 
		if ((DISPATCH_PROPERTYPUT | DISPATCH_PROPERTYPUTREF) & wFlags) {
			dispparams.rgdispidNamedArgs = &dsipid_put;
			dispparams.cNamedArgs = 1;
		}
	}
 
	HRESULT hr = spDispatch_->Invoke(
		lDispID,
		IID_NULL,
		LOCALE_USER_DEFAULT,
		wFlags,
		&dispparams,
		DISPATCH_PROPERTYPUT == wFlags ? NULL : &varRetVal,
		NULL,
		NULL
		);
 
	if (FAILED(hr)) {
		_com_raise_error(hr);
	}
}
 
 
_variant_t COMDispatch::ToRefParam(_variant_t &var)
{
	_variant_t varRet;
	varRet.vt = VT_BYREF | VT_VARIANT;
	varRet.pvarVal = &var;
 
	return varRet;
}
 
 
} // end namespace 
 
  

#endif // _DISPATCH_H_20011012_BY_CDECL_

<예제, boost::asio 필요 라이브러리 >

# msvc-14.0 : vc++ 2015

# msvc-12.0 : vc++ 2013

# 64bit : address-model=64

bjam.exe toolset=msvc-11.0 link=static runtime-link=static --with-system --with-date_time --with-regex --with-thread -j 4 stage

출처 : http://www.viper.pe.kr/cgi-bin/moin.cgi/Boost

3.1. bjam 사용법 [Bottom] [Top]

Boost 라이브러리는 대부분 Template 으로 구성되어 있다. 하지만 regex, thread 와 같이 빌드가 필요한 라이브러리를 포함하고 있다. bjam 은 이런 라이브러리들을 빌드와 설치를 자동화 해주기 위한 프로그램으로 직접 빌드해서 사용해도 되고 아래의 링크에서 다운받아서 사용해도 된다.

• 다운로드 - http://sourceforge.net/project/showfiles.php?group_id=7586&package_id=72941&release_id=643622

• 사용법

  bjam [options] [properties] [install|stage]
  

• Targets 과 관련 옵션 ([install|stage], [options])

  install

  헤더 파일과 빌드된 라이브러리 파일을 설치한다.

  --prefix=<PREFIX>

  플랫폼에 종속적이지 않은 파일(헤더 파일)을 설치할 경로를 지정한다. (기본값: [Win32] C:\Boost, [Unix계열] /usr/local)

  --exec-prefix=<EPREFIX>

  플랫폼에 종속적인 파일(바이너리 파일)을 설치할 경로를 지정한다. (기본값: <PREFIX>)

  --libdir=<DIR>

  라이브러리 파일을 설치할 경로를 지정한다. (기본값: <EPREFIX>/lib)

  --includedir=<HDRDIR>

  헤더 파일을 설치할 경로를 지정한다. (기본값: <PREFIX>/include)

  stage

  빌드된 라이브러리 파일만 설치한다.

  --stagedir=<STAGEDIR>

  라이브러리 파일을 설치할 경로를 지정한다. (기본값: ./stage)

• 기타 옵션 ([options])

  --build-type=<type>

  미리 정의된 빌드 타입 중에서 빌드될 타입을 지정한다. 단, 각 라이브러리에서 지원하는 빌드 타입에 한해서 빌드 가능하다.

  minimal (기본값)

  - 릴리즈 모드(빌드 속성: "release <threading>multi <link>shared <link>static <runtime-link>shared")만 빌드한다.

  complete

  - 가능한 모든 타입(릴리즈/디버그, 정적/동적, 싱글/멀티 쓰레드 등)의 라이브러리를 빌드한다.

  --build-dir=DIR

  빌드 시 사용될 임시 디렉토리를 지정한다.

  --show-libraries

  빌드가 필요한 라이브러리를 보여준다.

  --layout=<layout>

  Boost 의 다양한 버전에 대한 라이브러리 파일 이름과 헤더 파일의 위치를 결정하거나 동일 시스템에서 여러 컴파일러를 사용할 경우 사용한다.

  versioned (기본값)

  - 라이브러리(바이너리) 파일의 이름에 버전, 라이브러리 이름, 컴파일러 버전을 포함한다. Boost 헤더 파일은 Boost 버전이 포함된 이름으로 생성된 <HDRDIR> 의 하위 디렉토리에 설치된다.

  system

  - 라이브러리(바이너리) 파일의 이름에 버전, 라이브러리 이름, 컴파일러 버전을 포함하지 않는다. Boost 헤더 파일은 <HDRDIR> 디렉토리에 설치된다. 이 옵션은 배포 패키지를 빌드하기 위하여 준비된 옵션이다.

  --buildid=ID

  빌드된 라이브러리 파일 이름에 지정된 ID 를 추가한다. 기본적으로는 어떤 것도 추가되지 않는다.

  --help

  도움말을 보여준다.

  --with-<library>

  지정된 라이브러리만 빌드 후 설치한다.

  --without-<library>

  지정된 라이브러리를 빌드하지 않는다. (기본값: 모든 라이브러리를 빌드한다.)

• 빌드 속성 ([properties])

  toolset=toolset

  컴파일러를 지정한다. (VC++일 경우: msvc 사용)

  variant=debug|release

  릴리즈 또는 디버그 모드로 빌드할지 선택한다.

  link=static|shared

  정적 또는 동적(공유) 라이브러리로 빌드할지 선택한다.

  threading=single|multi

  멀티 쓰레드 지원 여부를 선택한다.

  runtime-link=static|shared

  C/C++ Runtime 라이브러리를 정적 또는 동적(공유) 라이브러리로 링크할지 선택한다.

• 중요 옵션 ([options])

  --clean

  Targets 을 정리(제거)한다.

  -a

  라이브러리를 재빌드(Rebuild)한다.

  -n

  빌드 명령을 실행하지 않고, 출력만 한다.

  -d+2

  실행되는 빌드 명령을 출력한다.

  -d0

  빌드 메시지를 출력하지 않는다.

  -q

  에러 발생 시 작업 과정을 중지한다.

  --debug-generator

  빌드 과정과 명령을 상세히 출력한다.

  --debug-configuration

  환경 설정 사항(요구사항 검사)을 포함하여 빌드 과정과 명령을 상세히 출력한다.

  --debug-building

  Targets 의 빌드 속성을 포함하여 빌드 과정과 명령을 상세히 출력한다.

• 빌드가 필요한 라이브러리 (--show-libraries 옵션으로 확인 가능)

  • date_time 

  • filesystem 

  • graph
  • graph_parallel

  • iostreams 

  • math
  • mpi

  • program_options 

  • python
  • random
  • regex
  • serialization

  • signals 

  • system 

  • test

  • thread 

  • wave

3.2. 라이브러리 네이밍(Library Naming) [Bottom] [Top]

For example, libboost_regex-vc71-mt-d-1_34.lib can be broken down into the following elements:

lib

Prefix: except on Microsoft Windows, every Boost library name begins with this string. On Windows, only ordinary static libraries use the lib prefix; import libraries and DLLs do not.

boost_regex

Library name: all boost library filenames begin with boost_.

-vc71

Toolset tag: identifies the toolset and version used to build the binary.

-mt

Threading tag: indicates that the library was built with multithreading support enabled. Libraries built without multithreading support can be identified by the absence of -mt.

-d

ABI tag: encodes details that affect the library's interoperability with other compiled code. For each such feature, a single letter is added to the tag:

• Key	Use this library when:
  s	linking statically to the C++ standard library and compiler runtime support libraries.
  g	using debug versions of the standard and runtime support libraries.
  y	using a special debug build of Python.
  d	building a debug version of your code.
  p	using the STLPort standard library rather than the default one supplied with your compiler.
  n	using STLPort's deprecated “native iostreams” feature.

  For example, if you build a debug version of your code for use with debug versions of the static runtime library and the STLPort standard library in “native iostreams” mode, the tag would be: -sgdpn. If none of the above apply, the ABI tag is ommitted.

-1_34

Version tag: the full Boost release number, with periods replaced by underscores. For example, version 1.31.1 would be tagged as "-1_31_1".

.lib

Extension: determined according to the operating system's usual convention. On most unix-style platforms the extensions are .a and .so for static libraries (archives) and shared libraries, respectively. On Windows, .dll indicates a shared library and .lib indicates a static or import library. Where supported by toolsets on unix variants, a full version extension is added (e.g. ".so.1.34") and a symbolic link to the library file, named without the trailing version number, will also be created.