'Program Lang./C++' 카테고리의 글 목록 (2 Page)

boost asio 정리 - 2 (io_service single thread 처리)

Program Lang./C++ 2017. 5. 11. 14:46

1. 목적

boost asio 정리 -1 첫번째 한계인 io_service start 시점부터 main() 함수가 block되는 한계를 개선하기 위한 코드

2. 코드 설명

정리-1과의 차이점은 boost::scoped_ptr<boost::thread> pThread; 추가이다. io_service에 대한 처리를 별도의 thread를 통해서 처리함으로써 main() 함수의 block을 막았다. 따라서 io_service의 printerHandler가 동작 중에도 main()함수에서 Key입력이나 다른 동작에 대해서 interactive하게 user에게 반응할 수 있다.

지금도 한가지 명확하지는 않지만 operation 맴버변수는 강제로 printerHander를 종료하기 위해서 넣었다. 결론적으로 io_service가 start되면 post()함수에 설정된 handler가 완전히 종료되어야지만 io_service 종료됨을 알 수 있다.

#include <iostream> #include <boost/asio.hpp> #include <boost/smart_ptr.hpp> #include <boost/bind.hpp> #include <boost/thread.hpp> #include <boost/chrono.hpp> #include <boost/thread/scoped_thread.hpp> class CTest { public : CTest() : service(), pThread() { std::cout << __FUNCTION__ << std::endl; operation = true; } virtual ~CTest() { std::cout << __FUNCTION__ << std::endl; } void do_print(int x) { std::cout << __FUNCTION__ << std::endl; boost::function<void(int)> printerHandler = [&](int x) { for(int i = 1; i <= x; i++) { if(operation == false) { std::cout << "... forcibly finish handler ..." << std::endl; break; } std::cout << __FUNCTION__ << " : called and loop : " << i << std::endl; boost::this_thread::sleep_for(boost::chrono::seconds(1)); } }; service.post(boost::bind(printerHandler, x)); } void start(void) { if(pThread) return; // io_service를 main thread로부터 분리하기 위해서 별도의 thread 생성 pThread.reset(new boost::thread(boost::bind(&boost::asio::io_service::run, boost::ref(service)))); } void stop(void) { if(!pThread) return; operation = false; service.stop(); pThread->join(); // io_service 재시작을 위해서 reset를 건다. service.reset(); pThread.reset(); } private : boost::asio::io_service service; boost::scoped_ptr<boost::thread> pThread; bool operation; }; int main(int argc, char* argv[]) { CTest test; test.do_print(10); test.start(); while(1) { char option; std::cout << "... in while loop ..." << std::endl; std::cin.get(option); if(option == 'x') break; } test.stop(); std::cout << "... end of main ..." << std::endl; return 0; }

3. 실행결과

아래 실행 결과는 printerHandler loop 동작 중에 Enter 키를 누르면 반응하는 것을 알 수 있다.

hskim@hskim-VirtualBox:~/test/test_project/test1$ ./test CTest do_print ... in while loop ... operator() : called and loop : 1 operator() : called and loop : 2 ... in while loop ... ... in while loop ... operator() : called and loop : 3 ... in while loop ... ... in while loop ... operator() : called and loop : 4 operator() : called and loop : 5 xoperator() : called and loop : 6 ... forcibly finish handler ... ... end of main ... ~CTest

4. 정리

io_service start를 별도의 하나의 thread에서 실행하도록 하여, main()함수의 thread는 block되지 않도록 하였다. 이 코드에서 살펴봐야 할 부분이 io_service start를 위해서 하나의 thread만 생성하였다. 즉, single thread 구현이다. 차 후에 논의하겠지만 single thread로 돌리기 때문에 post()함수를 추가로 호출하여 handler를 추가하더라도 post에 정의된 handler 함수간에는 sync가 맞는다. 흔히 말하는 공유자원에 대한 lock이 필요 없다는 것이다. main() 함수에서 post함수를 하나 더 추가해서 호출하더라도 모든 처리는 io_service start된 single thread에서 처리된다는 것이다. 다음절에서 multi-thread 예제를 봐보독 한다.

'Program Lang. > C++' 카테고리의 다른 글

boost asio - 정리 4 (strand 적용) (0)	2017.05.12
boost asio - 3 (multi-thread 동작 고찰) (0)	2017.05.12
boost asio 정리 - 1 기본동작 (0)	2017.05.11
[Basic] 클래스 상속 및 가상함수, 순수가상함수 정리 (0)	2017.04.26
[Basic] 맴버변수의 상수, 정적 속성, 상수와 정적변수 동시적용 시, 상수 맴버 함수 정리 (0)	2017.04.26

:

boost asio 정리 - 1 기본동작

Program Lang./C++ 2017. 5. 11. 12:00

1. 목적

boost asio를 이용해서 IPTuner를 구현하는 과정에서 삽질한 내용을 정리한다. 국내 블로그들에는 정리가 잘 되어 있지 않는 것 같다. 따라서 stackoverflow등 여러 곳에서 참고한 내용을 기반으로 여기에 정리한다.

2. 코드 설명

정리-1부터 하나씩 기능을 추가해 가면서 고찰해 보도록 한다. 일단 아래 코드는 가장 간단한 예제이다. CTest라는 객체를 하나 생성하고 io_service를 start 시키는 코드이다.

여기서 자세히 봐야 할 부분은 io_service가 호출되면 아래 예제는 아래와 같은 특징을 갖는다.

main() 함수에서 키보드 입력해도 io_service의 handler함수인 printerHandler함수가 완료되기 전까지 block된다.

즉, loop가 10번까지 돌 때까지 main()함수의 동작은 io_service가 call되는 시점부터 block된다.

loop가 10번 돌고나면 std::cin.get()함수에서 멈쳐있다.

여기서 좀 더 고찰해봐야 할 부분이 io_service start 호출 후에 main()함수 부분이 block되지 않고 User로부터 계속 응답을 하는 것이 필요하다. 또한 io_service는 일반적으로 asynchronization 동작에서 사용하는 것으로 이 예제로 모든 것을 커버하기에는 어렵다. 주제별로 하나씩 고찰해 본다.

#include <iostream> #include <boost/asio.hpp> #include <boost/smart_ptr.hpp> #include <boost/bind.hpp> #include <boost/thread.hpp> #include <boost/chrono.hpp> #include <boost/thread/scoped_thread.hpp> class CTest { public : void do_print(int x) { boost::function<void(int)> printerHandler = [](int x) { for(int i = 1; i <= x; i++) { std::cout << __FUNCTION__ << " : called and loop : " << i << std::endl; boost::this_thread::sleep_for(boost::chrono::seconds(1)); } }; service.post(boost::bind(printerHandler, x)); } void start(void) { service.run(); //service.poll(); } void stop(void) { service.stop(); } private : boost::asio::io_service service; //boost::scoped_ptr<boost::thread> pThredd; }; int main(int argc, char* argv[]) { CTest test; test.do_print(10); test.start(); std::cin.get(); test.stop(); std::cout << "... end of main ..." << std::endl; return 0; }

3. 실행결과

printerHandler가 동작 중일 때, Enter키를 강제로 두번 때려봤다. 예상되로 main()함수는 끝나지 않는다. 그리고 shell prompt는 두 번 Enter키를 입력한 결과로 printerHandler가 완료된 후에 결과를 출력하는 것을 볼 수 있다.

hskim@hskim-VirtualBox:~/test/test_project/test1$ ./test operator() : called and loop : 1 operator() : called and loop : 2 operator() : called and loop : 3 operator() : called and loop : 4 operator() : called and loop : 5 operator() : called and loop : 6 operator() : called and loop : 7 operator() : called and loop : 8 operator() : called and loop : 9 operator() : called and loop : 10 ... end of main ... hskim@hskim-VirtualBox:~/test/test_project/test1$ hskim@hskim-VirtualBox:~/test/test_project/test1$

4. 정리

io_service start/poll이 호출되면 post에 정의된 callback함수가 완료될 때까지 io_service를 호출한 thread에서 block되는 것이 기본동작이다. start와 poll의 차이에 대해서는 최홍배님이 저술한 책 9장에 관련 내용이 정리되어 있다. 참고하시면 될 듯하다.

'Program Lang. > C++' 카테고리의 다른 글

boost asio - 3 (multi-thread 동작 고찰) (0)	2017.05.12
boost asio 정리 - 2 (io_service single thread 처리) (0)	2017.05.11
[Basic] 클래스 상속 및 가상함수, 순수가상함수 정리 (0)	2017.04.26
[Basic] 맴버변수의 상수, 정적 속성, 상수와 정적변수 동시적용 시, 상수 맴버 함수 정리 (0)	2017.04.26
[Basic] 생성자 호출 정리 (0)	2017.04.26

:

[Basic] 클래스 상속 및 가상함수, 순수가상함수 정리

Program Lang./C++ 2017. 4. 26. 16:13

1. 목적

클래스 상속의 기본 동작, virtual을 써야하는 이유, 순수 가상함수는 무엇인지 정리

2. 클래스 상속 기본

상속은 부모클래스의 생성자, 소멸자, 대입연산자, 정적속성, friend 속성을 제외한 모든 맴버변수 및 함수는 자식 클래스로 복사된다. 만약 부모와 동일이름의 맴버변수가 있으면 자식 클래스의 맴버변수가 우선순위를 가지고 부모 맴버변수는 자식 맴버변수에 가려진다. 동일 이름의 맴버변수는 자식 클래스의 맴버함수로 Overriding된다. 따라서 동일 이름이 존재하면 자식 것은 없애고 부모 것을 사용하던지, 추가 기능이나 변경이 필요하면 자식 클래스에 동일이름에 대해서 다시 구현하면 자동적으로 Overriding이 된다. 아래 예제의 color와 draw()가 이에 해당되는 변수와 함수이다.

강제타입 변환을 제외하고 부모 클래스는 자식을 가르킬 수 있으나, 그 역은 금지되어 있다. 주석처리된 부분이 풀리면 이와 같은 사유로 빌드 에러가 발생한다.

class CGraphic { public : CGraphic() = default; CGraphic(unsigned int color) : _color(color) { std::cout << __FUNCTION__ << std::endl; } void draw() { std::cout << "In CGraphic : " << __FUNCTION__ << std::endl; } private : unsigned int _color = 0; }; class CLine : public CGraphic { public : CLine() = default; CLine(unsigned int color) : _color(color) { std::cout << __FUNCTION__ << std::endl; } void draw() { std::cout << "In CLine : " << __FUNCTION__ << std::endl; } private : unsigned int _color = 0; }; int main() { CGraphic graphic; CLine line; line.draw(); line.CGraphic::draw(); //line = graphic; //line.draw(); //line.CGraphic::draw(); CGraphic *pGraphic = new CLine(); pGraphic->draw(); return 0; }

In CLine : draw
In CGraphic : draw
In CGraphic : draw

3. virtual 정의

객체를 동적할당하여 포인터 변수로 받을 때에 포인터 변수가 가르키는 객체를 어떤 기준으로 가져 올 것인가가 virtual의 사용의 출발점이다. 위의 예제에서 draw()함수는 virtual이 아니다. 따라서 CGraphic *pGraphic의 현재 포인터 변수 타입을 기준으로 객체를 가져온다. 따라서 자식 객체를 받더라도 실제 draw()의 실행은 부모 객체의 것이 실행된다. 이를 뒷 단의 할당되는 객체의 타입에 해당하는 draw()을 가져오고 싶으면 virtual로 draw()함수를 선언해야 한다. 아래 코드는 virtual로 변경한 예제와 실행 결과이다.

class CGraphic { public : CGraphic() = default; CGraphic(unsigned int color) : _color(color) { std::cout << __FUNCTION__ << std::endl; } virtual void draw() { std::cout << "In CGraphic : " << __FUNCTION__ << std::endl; } private : unsigned int _color = 0; }; class CLine : public CGraphic { public : CLine() = default; CLine(unsigned int color) : _color(color) { std::cout << __FUNCTION__ << std::endl; } virtual void draw() { std::cout << "In CLine : " << __FUNCTION__ << std::endl; } private : unsigned int _color = 0; }; int main() { CGraphic *pGraphic = new CLine(); pGraphic->draw(); return 0; }

In CLine : draw

4. 순수 가상함수

상속 받은 자식 클래스에서 완벽하게 구현을 해야 하는 함수에 해당하는 것으로 순수 가상함수 존재하는 클래스는 객체를 생성할 수 없다. 단지 객체를 가르킬 수 있는 포인터 변수는 선언할 수 있다.

class CGraphic { public : CGraphic() = default; CGraphic(unsigned int color) : _color(color) { std::cout << __FUNCTION__ << std::endl; } virtual void draw()= 0; private : unsigned int _color = 0; }; class CLine : public CGraphic { public : CLine() = default; CLine(unsigned int color) : _color(color) { std::cout << __FUNCTION__ << std::endl; } virtual void draw() { std::cout << "In CLine : " << __FUNCTION__ << std::endl; } private : unsigned int _color = 0; }; int main() { // build error, 가상함수가 존재하는 추상 클래스는 객체 선언을 할 수 없다. //CGraphic graphic; CGraphic *pGraphic = new CLine(); pGraphic->draw(); return 0; }

5. 정리

부모클래스의 모든 맴버변수 및 함수는 자식 클래스로 복사되고 동일 이름이 존재하면 맴버함수는 Overriding된다. 즉 그대로 사용하거나 재정의해서 사용하면 된다. virtual은 실제 포인터 변수에 할당되는 변수의 타입에 해당되는 객체의 타입을 가르키고자 할 때 사용한다. SoEn에 정리된 내용을 빌리자면 자식클래스에서 변경하거나 포인터 변수로 사용될 가능성이 있는 맴버함수는 virtual로 선언한다. 순수가상함수는 모든 구현을 자식클래스에 양도하는 것으로 부모클래스에는 Interface만 제공한다. 이를 추상클래스라고 한다.

'Program Lang. > C++' 카테고리의 다른 글

boost asio 정리 - 2 (io_service single thread 처리) (0)	2017.05.11
boost asio 정리 - 1 기본동작 (0)	2017.05.11
[Basic] 맴버변수의 상수, 정적 속성, 상수와 정적변수 동시적용 시, 상수 맴버 함수 정리 (0)	2017.04.26
[Basic] 생성자 호출 정리 (0)	2017.04.26
boost asio를 이용한 iptuner 제작 (0)	2017.04.11

:

[Basic] 맴버변수의 상수, 정적 속성, 상수와 정적변수 동시적용 시, 상수 맴버 함수 정리

Program Lang./C++ 2017. 4. 26. 14:16

1. 목적

맴버변수나 맴버함수를 상수로 선언했을 때, 상수와 정적변수를 동시에 선언했을 때 동작이 나의 경우에는 잘 정리가 안되어서 여기에 정리한다.

2. 맴버변수

1) 맴버변수가 상수속성만 가질 경우

- 각 객체는 생성자 호출 통해서 맴버변수를 초기화하고 다른 맴버 함수를 통해서 상수 속성을 가지는 맴버변수의 값을 바꿀 수 없다. 아래 첫번째 예제는 각 객체는 서로 다른 초기값으로 객체를 생성하엿다. 하지만 상수 맴버변수에 값을 설정하는 setDebugLevel() 함수의 구현부분은 주석처리 되어야지만 빌드 에러가 발생하지 않는다.

enum DEBUG_LEVEL { LEVEL_NORMAL, LEVEL_TRACE, LEVEL_DEBUG, LEVEL_ERROR, LEVEL_MAX }; std::string LEVEL_STR[LEVEL_MAX] = { "LEVEL_NORMAL", "LEVEL_TRACE", "LEVEL_DEBUG", "LEVEL_ERROR" }; class CDebug { public : CDebug() = default; CDebug(DEBUG_LEVEL debugLevel) : _debugLevel(debugLevel) { std::cout << __FUNCTION__ << std::endl; } void setDebugLevel(DEBUG_LEVEL debugLevel) { //_debugLevel = debugLevel; } void printDeubLevel(void) { std::cout << "debug Level : " << LEVEL_STR[_debugLevel] << std::endl; } private : const DEBUG_LEVEL _debugLevel; }; int main() { // const variable but not static variable CDebug debug1(LEVEL_DEBUG); debug1.printDeubLevel(); // const variable but not static variable CDebug debug2(LEVEL_ERROR); debug2.printDeubLevel(); return 0; }

2) 맴버변수가 정적 속성만 가질 경우

- 각 객체는 해당 정적 변수에 대해서 모두 동일한 초기값을 가지며, 해당 정적 변수는 객체 생성전에 반드시 초기화되어야 한다. 따라서 생성자에 정적변수에 값을 설정하는 부분이 있는 1)번 예제는 모두 빌드 에러가 발생한다.

초기화 후에 다른 맴버 함수를 통해서 초기값은 변경가능하다. 1)번 예제와 차이점은 주석처리된 코드를 참조

class CDebug { public : CDebug() = default; #if 0 CDebug(DEBUG_LEVEL debugLevel) : _debugLevel(debugLevel) { std::cout << __FUNCTION__ << std::endl; } #endif void setDebugLevel(DEBUG_LEVEL debugLevel) { _debugLevel = debugLevel; } void printDeubLevel(void) { std::cout << "debug Level : " << LEVEL_STR[_debugLevel] << std::endl; } private : static DEBUG_LEVEL _debugLevel; }; DEBUG_LEVEL CDebug::_debugLevel = LEVEL_NORMAL; int main() { // static variable but not const //CDebug debug1(LEVEL_DEBUG); CDebug debug1; debug1.setDebugLevel(LEVEL_DEBUG); debug1.printDeubLevel(); // static variable but not const //CDebug debug2(LEVEL_ERROR); CDebug debug2; debug2.setDebugLevel(LEVEL_ERROR); debug2.printDeubLevel(); return 0; }

3) 맴버변수가 상수와 정적 속성을 모두 가질 경우

- 각 객체는 동일한 초기값을 가지면서 이제 더이상 다른 맴버함수를 통해서 초기값을 변경할 수 없다. 아래 예제는 위의 예제 2)보다 더 많은 코드 부분을 주석처리해야지만 빌드에 성공할 수 있다. 즉 초기값을 변경하는 코드와 초기값에도 const라는 지시어가 들어가야 한다. 주석 부분 참조

class CDebug { public : CDebug() = default; #if 0 CDebug(DEBUG_LEVEL debugLevel) : _debugLevel(debugLevel) { std::cout << __FUNCTION__ << std::endl; } #endif #if 0 void setDebugLevel(DEBUG_LEVEL debugLevel) { _debugLevel = debugLevel; } #endif void printDeubLevel(void) { std::cout << "debug Level : " << LEVEL_STR[_debugLevel] << std::endl; } private : static const DEBUG_LEVEL _debugLevel; }; //DEBUG_LEVEL CDebug::_debugLevel = LEVEL_NORMAL; const DEBUG_LEVEL CDebug::_debugLevel = LEVEL_NORMAL; int main() { // static variable but not const //CDebug debug1(LEVEL_DEBUG); CDebug debug1; //debug1.setDebugLevel(LEVEL_DEBUG); debug1.printDeubLevel(); // const variable but not static variable //CDebug debug2(LEVEL_ERROR); CDebug debug2; //debug2.setDebugLevel(LEVEL_ERROR); debug2.printDeubLevel(); return 0; }

3. 맴버함수 (상수속성의 맴버함수)

값을 변경하지 않는 맴버함수는 상수 속성을 주는 것을 권장하고 있다. 실제 이 부분은 Modern C++ 책에 잘 가이드되어 있다. 맴버함수의 상수 속성은 맴버함수의 Overloading의 기준이 됨으로 항상 상수와 비상수 맴버함수의 쌍을 가지는 것이 좋다. 아래 예처럼 객체가 상수 속성을 가지고 생성되면 상수 속성을 가지지 않는 맴버함수는 호출될 수 없다. 아래 주석 처리 부분 참조

class CDebug { public : CDebug() = default; #if 0 void printDeubLevel(void) { std::cout << "debug Level : " << LEVEL_STR[_debugLevel] << std::endl; } #else void printDeubLevel(void) const { std::cout << "debug Level : " << LEVEL_STR[_debugLevel] << std::endl; } #endif private : static const DEBUG_LEVEL _debugLevel; }; const DEBUG_LEVEL CDebug::_debugLevel = LEVEL_NORMAL; int main() { const CDebug debug; debug.printDeubLevel(); return 0; }

4. 결론

const 속성을 가지는 맴버변수는 생성자에서 초기값을 전달할 수 있고, 이 그외의 맴버함수를 통해서 값 변경은 불가하다. 정적변수는 클래스에 속하는 변수로 초기화는 객체 생성전에 한번만 가능하고 맴버함수를 통해서 기존에 설정된 초기값을 변경할 수 있다. const와 static이 동시에 사용되면 각각 속성에서 제한된 속성이 모두 적용되는 형태이다. 상수 맴버함수는 객체가 상수속성을 가지고 생성되는 경우를 대비해서 값을 변경하지 않는 맴버함수는 상수 속성을 주는 것이 바람직하다.

'Program Lang. > C++' 카테고리의 다른 글

boost asio 정리 - 1 기본동작 (0)	2017.05.11
[Basic] 클래스 상속 및 가상함수, 순수가상함수 정리 (0)	2017.04.26
[Basic] 생성자 호출 정리 (0)	2017.04.26
boost asio를 이용한 iptuner 제작 (0)	2017.04.11
message queue implementation by c++ STL (0)	2017.04.06

:

[Basic] 생성자 호출 정리

Program Lang./C++ 2017. 4. 26. 13:35

1. 목적

너무 어려운 부분만 파다보면 기본에서 헛갈리기 시작한다. 그런 면에서 "http://soen.kr/" 사이트는 정리가 잘 되어 있어서 도움이 많이 된다. 가장 기본이지만 자주 혼돈스러운 생성자 호출 방법에 대해서 정리한다. SoEn 사이트 내용을 인용 할 수 있다는 점을 원작자에게 알립니다.

2. 소스코드

아래 코드는 default 생성자 및 일반 매개변수를 가지는 생성자를 정적 또는 동적으로 호출하는 여러가지 경우에 대해서 정리하였다.

SoEn 사이트를 보면 암시적인 방법과 명시적인 방법으로 분류되어 있던데, 확실히 알아두면 다른 책을 보기에 편하다.

class CPerson { public : CPerson() { std::cout << __FUNCTION__ << std::endl; } CPerson(std::string aname, unsigned int aage) : name(aname), age(aage) { std::cout << __FUNCTION__ << std::endl; } virtual ~CPerson() { std::cout << __FUNCTION__ << std::endl; } private : std::string name; unsigned int age; }; int main() { // default 생성자 호출 (정적) CPerson person1; CPerson person2 = CPerson(); // 생성자 호출 (정적) CPerson person3("heesoon.kim", 42); CPerson person4 = CPerson("heesoon.kim", 42); // default 생성자 호출 (동적) CPerson *pPerson1 = new CPerson; CPerson *pPerson2 = new CPerson(); // 생성자 호출 (동적) CPerson *pPerson3 = new CPerson("heesoon.kim", 42); return 0; }

아래 코드는 생성자 부분에 default 지시어와 explicit 지시어를 추가하였다. 상세한 의미는 생략하고 내가 이해한 바로는 default 지시어는 default 생성자를 컴파일러에게 생성하도록 명명하는 것이고, explicit 지시어는 변환 생성자에 의미가 더 큰 지시어로 컴파일러가 임의적으로 변환을 막기 위해서 사용하는 것으로 SoEn에 잘 정리되어 있다. (변환 생성자부분 참조)

class CPerson { public : CPerson() = default; explicit CPerson(std::string aname, unsigned int aage) : name(aname), age(aage) { std::cout << __FUNCTION__ << std::endl; } virtual ~CPerson() { std::cout << __FUNCTION__ << std::endl; } private : std::string name; unsigned int age; };

3. 생성자가 아닌 맴버변수 자체 초기화

default 지시어가 설정된 생성자를 통해서 생성된 객체는 맴버변수 초기화가 제대로 되어 있지 않다. 따라서 이를 다른 방법으로 처리할 수 있는데 c++11 이후에 가능한 것으로 안다. 예전에 읽었던 Modern C++에 정리되거나 standard c++ 표준에서 본 것 같은데 어디서 봤는지는 기억이 잘 안다. 하지만 아래와 같은 방법을 통해서 초기화가 가능하다.

class CPerson { public : CPerson() = default; explicit CPerson(std::string aname, unsigned int aage) : name(aname), age(aage) { std::cout << __FUNCTION__ << std::endl; } void printPerson() { std::cout << "name : " << name << ", "; std::cout << "age : " << age << std::endl; } virtual ~CPerson() { std::cout << __FUNCTION__ << std::endl; } private : // after c++11 //std::string name = "heesoon.kim"; //unsigned int age = 42; // after c++11 std::string name{"heesoon.kim"}; unsigned int age{42}; }; int main() { CPerson person; person.printPerson(); return 0; }

'Program Lang. > C++' 카테고리의 다른 글

[Basic] 클래스 상속 및 가상함수, 순수가상함수 정리 (0)	2017.04.26
[Basic] 맴버변수의 상수, 정적 속성, 상수와 정적변수 동시적용 시, 상수 맴버 함수 정리 (0)	2017.04.26
boost asio를 이용한 iptuner 제작 (0)	2017.04.11
message queue implementation by c++ STL (0)	2017.04.06
enable_shared_from_this 정리 (0)	2017.01.12

:

boost asio를 이용한 iptuner 제작

Program Lang./C++ 2017. 4. 11. 20:23

1. 목적

boost asio를 몇 번을 봤는데, 볼 때마다 기억이 잘 나지 않는다. boost asio 예제를 하나 만들면 기억에 도움이 되지 않을까 하는 마음으로 작성한다. 예제는 내 Job과 관련이 있는 부분인 IPTV의 한 부분인 간단한 IPTuner를 만들어 본다.

IPTuner는 일반적으로 Multicast Stream을 수신하는 부분으로 간단한 예제이지만 큰 틀은 변하지 않는다.

boost buffer 부분은 좀 더 공부를 해야 할 듯 하다.

2. 소스코드

windsend나 VLC를 이용해서 server는 대체한다. 다만 VLC는 TS Stream를 VLC 맞게 변경하는 부분이 있어서 정확한 값을 얻기는 힘들다. 일단 windsend를 기반으로 동작 테스트를 진행한다.

전에 올렸던 소스가 CTRL-C를 누르지 않으면 종료되지 않은 문제가 있어서 수정해서 다시 올린다. 전에 CTRL-C를 누르지 않으면 종료하지 않는 이유는 io_service에서 run을 호출하는 thread에서 block되기 때문에 그 thread가 main함수가 돌고 있는 thread여서 동작하지 않았다. 따라서 실제 socket에서 receive 동작을 하는 io_service 동작은 별도의 thread로 분리한다.

소스상에서 한가지 동작 중에 문제가 있는 부분은 io_service work에 관한 것이다. 실제 work는 io_service가 stop을 호출하지 전까지 io_service에 계속 block되어져야 하는데 block되지 않고 종료되는 문제가 있다. 계속 삽질 중이지만 생각되로 동작하지 않는 문제가 있다. 여기까지 오는데 엄청난 삽질을 해 됐다. 몇 가지 문제 빼 놓고는 정상적으로 동작하는 것으로 보인다.

#ifndef __IPTUNER_HPP__ #define __IPTUNER_HPP__ #include <iostream> #include <string> #include <boost/asio.hpp> #include <boost/thread.hpp> #include <boost/bind.hpp> #include <boost/array.hpp> #include <functional> #include <boost/smart_ptr.hpp> using boost::asio::ip::udp; class CIPTuner { public : #ifdef USE_BOOST_ARRAY const static int BUFFER_SIZE = 188*7; using pCallBackFuncType = std::function<void(boost::array<unsigned char, BUFFER_SIZE>)>; #else using pCallBackFuncType = std::function<void(char*, size_t)>; #endif public : CIPTuner(); CIPTuner(boost::asio::io_service &io); virtual ~CIPTuner(); virtual bool startTune(std::string addr, unsigned short port); virtual bool stopTune(void); virtual void do_receive(void); virtual void handle_receiver(const boost::system::error_code& error, size_t bytes_transferred); virtual void registerCallBackFunc(pCallBackFuncType pFunc); private : std::string addr_; unsigned short port_; boost::asio::io_service io_service_; boost::asio::ip::udp::socket socket; boost::scoped_ptr<boost::thread> receiveTrId; pCallBackFuncType pCallBack; #ifdef USE_BOOST_ARRAY boost::array<unsigned char, BUFFER_SIZE> recv_buffer; #else enum { BUFFER_SIZE = 188*7 }; char recv_buffer[BUFFER_SIZE]; #endif }; #endif enum class DebugLevel4IPTuner { DEBUG_LEVEL_NORMAL, // No Debug Message from class DEBUG_LEVEL_ERROR, // Print Error Message DEBUG_LEVEL_DEBUG, // Print Debug Related Message DEBUG_LEVEL_TRACE, // All Debug Message Trace including class member function DEBUG_LEVEL_MAX }; static DebugLevel4IPTuner gDebugLevel = DebugLevel4IPTuner::DEBUG_LEVEL_TRACE; #define DEBUG_PRINT(debugPrint, debugMsg)\ {\ if((debugPrint) <= gDebugLevel)\ {\ switch(debugPrint) \ {\ case DebugLevel4IPTuner::DEBUG_LEVEL_NORMAL:\ std::printf("[%s,%d] %s \n", __FUNCTION__, __LINE__, debugMsg);\ break;\ case DebugLevel4IPTuner::DEBUG_LEVEL_ERROR:\ std::printf("\033[0;31m Error in [%s,%d] %s \n", __FUNCTION__, __LINE__, debugMsg);\ break;\ case DebugLevel4IPTuner::DEBUG_LEVEL_DEBUG:\ std::printf("\033[1;32m Debug in [%s,%d] %s \n", __FUNCTION__, __LINE__, debugMsg);\ break;\ case DebugLevel4IPTuner::DEBUG_LEVEL_TRACE:\ std::printf("\033[1;33m Trace in [%s,%d] %s \n", __FUNCTION__, __LINE__, debugMsg);\ break;\ default :\ break;\ }\ std::printf("\033[0m");\ }\ } CIPTuner::CIPTuner() : socket(io_service_), receiveTrId() { DEBUG_PRINT(DebugLevel4IPTuner::DEBUG_LEVEL_TRACE, ""); pCallBack = nullptr; } CIPTuner::~CIPTuner() { DEBUG_PRINT(DebugLevel4IPTuner::DEBUG_LEVEL_TRACE, ""); stopTune(); } bool CIPTuner::startTune(std::string addr, unsigned short port) { DEBUG_PRINT(DebugLevel4IPTuner::DEBUG_LEVEL_TRACE, ""); if( (addr_.compare(addr) == 0) && (port_ == port) ) { DEBUG_PRINT(DebugLevel4IPTuner::DEBUG_LEVEL_ERROR, "same address and port"); return false; } if(receiveTrId) { DEBUG_PRINT(DebugLevel4IPTuner::DEBUG_LEVEL_ERROR, "Already Task Started"); return false; } addr_ = addr; port_ = port; boost::asio::ip::address multicast_address = boost::asio::ip::address::from_string(addr); boost::asio::ip::udp::endpoint endpoint = boost::asio::ip::udp::endpoint(multicast_address, port); socket.open(udp::v4()); socket.set_option(boost::asio::ip::udp::socket::reuse_address(true)); socket.set_option(boost::asio::ip::multicast::enable_loopback(true)); socket.bind(endpoint); // Join the multicast group. socket.set_option(boost::asio::ip::multicast::join_group(multicast_address)); //socket.non_blocking(true); //boost::scoped_ptr<boost::asio::io_service::work> work_(new boost::asio::io_service::work(io_service_)); io_service_.post(boost::bind(&CIPTuner::do_receive, this)); receiveTrId.reset(new boost::thread(boost::bind(&boost::asio::io_service::run, &io_service_))); DEBUG_PRINT(DebugLevel4IPTuner::DEBUG_LEVEL_TRACE, ""); return true; } void CIPTuner::handle_receiver(const boost::system::error_code& error, size_t bytes_transferred) { DEBUG_PRINT(DebugLevel4IPTuner::DEBUG_LEVEL_TRACE, ""); if (!error || error == boost::asio::error::message_size) { #ifdef USE_BOOST_ARRAY if(pCallBack != nullptr) pCallBack(recv_buffer); #else if(pCallBack != nullptr) pCallBack(recv_buffer, bytes_transferred); #endif do_receive(); } } void CIPTuner::do_receive(void) { DEBUG_PRINT(DebugLevel4IPTuner::DEBUG_LEVEL_TRACE, ""); boost::asio::ip::udp::endpoint sender_endpoint; #ifdef USE_BOOST_ARRAY socket.async_receive_from(boost::asio::buffer(recv_buffer), sender_endpoint, boost::bind(&CIPTuner::handle_receiver, this, boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred)); #else socket.async_receive_from(boost::asio::buffer(recv_buffer, BUFFER_SIZE), sender_endpoint, boost::bind(&CIPTuner::handle_receiver, this, boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred)); #endif } void CIPTuner::registerCallBackFunc(pCallBackFuncType pFunc) { DEBUG_PRINT(DebugLevel4IPTuner::DEBUG_LEVEL_TRACE, ""); pCallBack = pFunc; } bool CIPTuner::stopTune(void) { DEBUG_PRINT(DebugLevel4IPTuner::DEBUG_LEVEL_TRACE, ""); boost::asio::ip::address multicast_address = boost::asio::ip::address::from_string(addr_); if(!receiveTrId) { DEBUG_PRINT(DebugLevel4IPTuner::DEBUG_LEVEL_ERROR, "Task is Null"); return false; } socket.set_option(boost::asio::ip::multicast::leave_group(multicast_address)); socket.close(); io_service_.stop(); receiveTrId->join(); io_service_.reset(); receiveTrId.reset(); DEBUG_PRINT(DebugLevel4IPTuner::DEBUG_LEVEL_TRACE, ""); return true; } #include "iptuner.hpp" #define PRINT_HEADER_MARK(c, l) {for(int i = 0; i < (l); i++) std::printf("%c", (c)); std::printf("\n");} #define PRINT_HEADER_INFO(s, x) std::printf("%-30s : %10d [%#10x]\n", #s, x, x); struct TSfilterInfo_t { bool transport_error_indicator; bool payload_unit_start_indicator; bool transport_priority; unsigned short pid; // 13 bit unsigned char transport_scrambling_control; // 2 bit unsigned char adaptation_field_control; // 2 bit unsigned char continuity_counter; // 4 bit unsigned char pointer_field; // 8 bit unsigned char payload_length; unsigned long long ts_packet_number; // 64 bit }; std::function<void(char*, size_t)> pCallBack = [&](char* _buffer, size_t num) { static unsigned long long cnt = 0; for(int i = 0; i < 7; i++) { char *buffer = &_buffer[188*i]; TSfilterInfo_t tsInfo; if(buffer[0] != 0x47) { std::cout << "Not Header Start " << std::endl; } tsInfo.ts_packet_number = ++cnt; tsInfo.transport_error_indicator = (buffer[1] >> 7) & 0x01; tsInfo.payload_unit_start_indicator = (buffer[1] >> 6) & 0x01; tsInfo.pid = ((buffer[1] & 0x1f) << 8) | buffer[2]; tsInfo.transport_scrambling_control = (buffer[3] >> 6) & 0x03; tsInfo.adaptation_field_control = (buffer[3] >> 4) & 0x03; tsInfo.continuity_counter = buffer[3] & 0x0f; PRINT_HEADER_MARK('-', 56) PRINT_HEADER_INFO(ts_packet_number , tsInfo.ts_packet_number) PRINT_HEADER_INFO(transport_error_indicator , tsInfo.transport_error_indicator) PRINT_HEADER_INFO(payload_unit_start_indicator , tsInfo.payload_unit_start_indicator) PRINT_HEADER_INFO(pid , tsInfo.pid) PRINT_HEADER_INFO(transport_scrambling_control , tsInfo.transport_scrambling_control) PRINT_HEADER_INFO(adaptation_field_control , tsInfo.adaptation_field_control) PRINT_HEADER_INFO(continuity_counter , tsInfo.continuity_counter) } }; int main() { CIPTuner iptuner; while(1) { char option; std::cout << "Enter Debug Menu : "; std::cin.get(option); if( (option == 'x') || (option == 'X') ) break; if( (option == 'b') || (option == 'B') ) { std::cout << "Start Tune !!" << std::endl; std::string addr = "234.1.1.1"; unsigned short port = 5000; iptuner.registerCallBackFunc(pCallBack); iptuner.startTune(addr, port); } else if( (option == 'r') || (option == 'R') ) { std::cout << "Restart Tune !!" << std::endl; std::string addr = "234.1.1.2"; unsigned short port = 5000; iptuner.registerCallBackFunc(pCallBack); iptuner.startTune(addr, port); } else if( (option == 'e') || (option == 'E') ) { std::cout << "Stop Tune !!" << std::endl; iptuner.stopTune(); } } std::cout << " ... end of main ... " << std::endl; return 0; }

3. 실행 결과

몇가지 스트림을 테스트 해 봤는데 값은 정상적으로 얻어온다.

-------------------------------------------------------- ts_packet_number : 24203 [ 0x5e8b] transport_error_indicator : 0 [ 0] payload_unit_start_indicator : 0 [ 0] pid : 8191 [ 0x1fff] transport_scrambling_control : 0 [ 0] adaptation_field_control : 1 [ 0x1] continuity_counter : 15 [ 0xf] -------------------------------------------------------- ts_packet_number : 24204 [ 0x5e8c] transport_error_indicator : 0 [ 0] payload_unit_start_indicator : 0 [ 0] pid : 8191 [ 0x1fff] transport_scrambling_control : 0 [ 0] adaptation_field_control : 1 [ 0x1] continuity_counter : 15 [ 0xf] -------------------------------------------------------- ts_packet_number : 24205 [ 0x5e8d] transport_error_indicator : 0 [ 0] payload_unit_start_indicator : 0 [ 0] pid : 8191 [ 0x1fff] transport_scrambling_control : 0 [ 0] adaptation_field_control : 1 [ 0x1] continuity_counter : 15 [ 0xf] -------------------------------------------------------- ts_packet_number : 24206 [ 0x5e8e] transport_error_indicator : 0 [ 0] payload_unit_start_indicator : 0 [ 0] pid : 8191 [ 0x1fff] transport_scrambling_control : 0 [ 0] adaptation_field_control : 1 [ 0x1] continuity_counter : 15 [ 0xf] do_receive handle_receiver

'Program Lang. > C++' 카테고리의 다른 글

[Basic] 맴버변수의 상수, 정적 속성, 상수와 정적변수 동시적용 시, 상수 맴버 함수 정리 (0)	2017.04.26
[Basic] 생성자 호출 정리 (0)	2017.04.26
message queue implementation by c++ STL (0)	2017.04.06
enable_shared_from_this 정리 (0)	2017.01.12
[json-c] simple generator json ojbect (0)	2017.01.09

:

message queue implementation by c++ STL

Program Lang./C++ 2017. 4. 6. 19:37

1. 목적

내 기억으로는 c++ STL에는 IPC 기능을 제공하는 Container가 존재하지 않는 것 같다. 결국 POSIX 같은 리눅스/유닉스 기반 IPC를 혼합해서 써야 하는 것인지 의문이다. c++ 공부 차원에서 Thread간 통신을 위해서 Message Queue를 한번 구현해 봤다. 많은 것을 고민하였으나 부족한 점이 많아 보인다. 부족한 점은 잘 잊혀버리니까 정리차원에서 아래에 기술하도록 한다.

2. 테스트 코드

코드의 전체 구성은 다음과 같다. class CMessageQueue와 class CMessageQueuePool로 구성되어 있다. CMessageQueuePool은 각각의 이름으로 생성된 CMessageQueue를 관리하기 위한 목적 이외에는 다른 사용 목적은 없다. CMessageQueuePool은 SingleTon 형식으로 만들려고 했는데 정확히 맞는지 확신은 없다. 일단 상속은 생각하지 않았다. 내 기억으로는 Boost에서는 SingleTon을 상속 받아서 처리하면 매우 쉬운것으로 알고 있다. 사실 CMessageQueuePool은 별개 없고 실제 동작은 CMessageQueue에서 이루어진다.

그럼 CMessageQueue를 살펴보면 std::queue<T>와 std::mutex 맴버변수가 있고 전송과 수신 메세지 맴버함수로 이루어져 있다. std::queue<T>는 실제 주고 받을 메세지가 저장되는 Queue이다. template를 사용한 목적은 메세지의 형식이 목적에 따라 다르기 때문에 template로 처리하였다. std::mutex는 std::queue<T>를 전송과 수신 쓰레드에서 각각 접근하는 공유자원이다. 따라서 mutex로 동기를 맞추기 위해서 추가하였다.

한가지 아쉬운 점은 CMessageQueue는 CMessageQueuePool에서만 객체를 생성할 수 있도록 하고 쉽은데, 몇 가지 이유로 쉽지 않다. CMessageQueue를 CMessageQueuePool 내부에 집어 넣으면 getMessageQueue() 함수처럼 CMessageQueue를 리턴 받아야 하는 함수를 어떻게 처리할 지 의문이다. CMessageQueue를 리턴 받지 않고 모두 CMessageQueuePool 내부에서 처리하도록 하면은 매번 messageQueue 이름으로 CMessageQueue의 객체를 뒤져야 하는 성능상의 단점이 있다. 이 부분은 좀 더 고민을 해 봐야 겠다.

#include <iostream> #include <string> #include <sstream> #include <queue> #include <memory> #include <mutex> #include <map> #include <thread> #include <chrono> #include <pthread.h> enum class DebugLevel4MessageQueuePool { DEBUG_LEVEL_NORMAL, // No Debug Message from class DEBUG_LEVEL_ERROR, // Print Error Message DEBUG_LEVEL_DEBUG, // Print Debug Related Message DEBUG_LEVEL_TRACE, // All Debug Message Trace including class member function DEBUG_LEVEL_MAX }; DebugLevel4MessageQueuePool gDebugLevel = DebugLevel4MessageQueuePool::DEBUG_LEVEL_TRACE; //const std::string red("\033[0;31m"); //const std::string green("\033[1;32m"); //const std::string yellow("\033[1;33m"); //const std::string cyan("\033[0;36m"); //const std::string magenta("\033[0;35m"); //const std::string reset("\033[0m"); #define DEBUG_PRINT(debugPrint, debugMsg)\ {\ if((debugPrint) <= gDebugLevel)\ {\ switch(debugPrint) \ {\ case DebugLevel4MessageQueuePool::DEBUG_LEVEL_NORMAL:\ std::printf("[%s,%d] %s \n", __FUNCTION__, __LINE__, debugMsg);\ break;\ case DebugLevel4MessageQueuePool::DEBUG_LEVEL_ERROR:\ std::printf("\033[0;31m Error in [%s,%d] %s \n", __FUNCTION__, __LINE__, debugMsg);\ break;\ case DebugLevel4MessageQueuePool::DEBUG_LEVEL_DEBUG:\ std::printf("\033[1;32m Debug in [%s,%d] %s \n", __FUNCTION__, __LINE__, debugMsg);\ break;\ case DebugLevel4MessageQueuePool::DEBUG_LEVEL_TRACE:\ std::printf("\033[1;33m Trace in [%s,%d] %s \n", __FUNCTION__, __LINE__, debugMsg);\ break;\ default :\ break;\ }\ std::printf("\033[0m");\ }\ } template <typename T> class CMessageQueuePool; template <typename T> class CMessageQueue { friend class CMessageQueuePool<T>; private : std::queue<T> msgQ; std::mutex mtx; std::string nameOfmsgQ; pthread_mutex_t mutexForMsgQCond; pthread_cond_t msgQCond; public : CMessageQueue(); virtual ~CMessageQueue(); virtual void sendMessage(const T& msg); virtual T receiveMessage(void); virtual bool receiveMessage(T& msg); virtual bool isMessageQueueEmpty(void); }; template <typename T> CMessageQueue<T>::CMessageQueue() { msgQCond = PTHREAD_COND_INITIALIZER; mutexForMsgQCond = PTHREAD_MUTEX_INITIALIZER; pthread_cond_init(&msgQCond, NULL); pthread_mutex_init(&mutexForMsgQCond, NULL); DEBUG_PRINT(DebugLevel4MessageQueuePool::DEBUG_LEVEL_TRACE, ""); } template <typename T> CMessageQueue<T>::~CMessageQueue() { std::queue<T> empty; std::swap(empty, msgQ); pthread_cond_destroy(&msgQCond); pthread_mutex_destroy(&mutexForMsgQCond); DEBUG_PRINT(DebugLevel4MessageQueuePool::DEBUG_LEVEL_TRACE, ""); } template <typename T> void CMessageQueue<T>::sendMessage(const T& msg) { mtx.lock(); msgQ.push(msg); mtx.unlock(); pthread_mutex_lock(&mutexForMsgQCond); pthread_cond_signal(&msgQCond); pthread_mutex_unlock(&mutexForMsgQCond); DEBUG_PRINT(DebugLevel4MessageQueuePool::DEBUG_LEVEL_DEBUG, ""); } template <typename T> T CMessageQueue<T>::receiveMessage(void) { T msg; pthread_mutex_lock(&mutexForMsgQCond); while(isMessageQueueEmpty() == true) { DEBUG_PRINT(DebugLevel4MessageQueuePool::DEBUG_LEVEL_NORMAL, "Message Queue Empty Condition"); pthread_cond_wait(&msgQCond, &mutexForMsgQCond); } pthread_mutex_unlock(&mutexForMsgQCond); mtx.lock(); msg = msgQ.front(); msgQ.pop(); mtx.unlock(); DEBUG_PRINT(DebugLevel4MessageQueuePool::DEBUG_LEVEL_DEBUG, ""); return msg; } template <typename T> bool CMessageQueue<T>::receiveMessage(T& msg) { pthread_mutex_lock(&mutexForMsgQCond); while(isMessageQueueEmpty() == true) { DEBUG_PRINT(DebugLevel4MessageQueuePool::DEBUG_LEVEL_NORMAL, "Message Queue Empty Condition"); pthread_cond_wait(&msgQCond, &mutexForMsgQCond); } pthread_mutex_unlock(&mutexForMsgQCond); mtx.lock(); msg = msgQ.front(); msgQ.pop(); mtx.unlock(); DEBUG_PRINT(DebugLevel4MessageQueuePool::DEBUG_LEVEL_DEBUG, ""); return true; } template <typename T> bool CMessageQueue<T>::isMessageQueueEmpty(void) { bool isEmpty = false; mtx.lock(); isEmpty = msgQ.empty(); mtx.unlock(); DEBUG_PRINT(DebugLevel4MessageQueuePool::DEBUG_LEVEL_DEBUG, ""); return isEmpty; } template <typename T> class CMessageQueuePool { private : std::map<std::string, CMessageQueue<T>*> poolOfmsgQ; //using iterType = typename std::map<std::string, CMessageQueue<T>*>; CMessageQueuePool(){}; static std::shared_ptr<CMessageQueuePool<T>> inst; public : void setCurrentDebugLevel(DebugLevel4MessageQueuePool debugLevel); public : virtual ~CMessageQueuePool(); static std::shared_ptr<CMessageQueuePool<T>> getInstance(void); virtual bool createMessageQueue(std::string nameOfmsgQ); virtual CMessageQueue<T>* getMessageQueue(std::string nameOfmsgQ); }; template <typename T> std::shared_ptr<CMessageQueuePool<T>> CMessageQueuePool<T>::inst = nullptr; template <typename T> std::shared_ptr<CMessageQueuePool<T>> CMessageQueuePool<T>::getInstance(void) { if(inst == nullptr) { inst.reset(new CMessageQueuePool<T>); } DEBUG_PRINT(DebugLevel4MessageQueuePool::DEBUG_LEVEL_TRACE, ""); return inst; } template <typename T> CMessageQueuePool<T>::~CMessageQueuePool() { for(auto iter = poolOfmsgQ.begin(); iter != poolOfmsgQ.end(); iter++) { delete iter->second; } DEBUG_PRINT(DebugLevel4MessageQueuePool::DEBUG_LEVEL_TRACE, ""); poolOfmsgQ.clear(); } template <typename T> bool CMessageQueuePool<T>::createMessageQueue(std::string nameOfmsgQ) { if(poolOfmsgQ.find(nameOfmsgQ) != poolOfmsgQ.end()) { DEBUG_PRINT(DebugLevel4MessageQueuePool::DEBUG_LEVEL_ERROR, "Already Message Queue Exist!!"); return false; } CMessageQueue<T> *newMessageQueue = new CMessageQueue<T>; newMessageQueue->nameOfmsgQ = nameOfmsgQ; poolOfmsgQ[nameOfmsgQ] = newMessageQueue; DEBUG_PRINT(DebugLevel4MessageQueuePool::DEBUG_LEVEL_DEBUG, ""); return true; } template <typename T> CMessageQueue<T>* CMessageQueuePool<T>::getMessageQueue(std::string nameOfmsgQ) { for(auto iter = poolOfmsgQ.begin(); iter != poolOfmsgQ.end(); iter++) { if(iter->first.compare(nameOfmsgQ) == 0) { return iter->second; } } DEBUG_PRINT(DebugLevel4MessageQueuePool::DEBUG_LEVEL_DEBUG, ""); return nullptr; } template <typename T> void CMessageQueuePool<T>::setCurrentDebugLevel(DebugLevel4MessageQueuePool debugLevel) { gDebugLevel = debugLevel; DEBUG_PRINT(DebugLevel4MessageQueuePool::DEBUG_LEVEL_DEBUG, ""); } int main() { auto pSharedPtr = CMessageQueuePool<int>::getInstance(); pSharedPtr->createMessageQueue("heesoon.kim"); CMessageQueue<int> *handlerOfmsgQ = pSharedPtr->getMessageQueue("heesoon.kim"); if(handlerOfmsgQ == nullptr) { DEBUG_PRINT(DebugLevel4MessageQueuePool::DEBUG_LEVEL_NORMAL, "No Message handler Exist!!"); return 0; } std::thread sender = std::thread([&](){ for(int i = 0; i < 10; i++) { std::this_thread::sleep_for(std::chrono::milliseconds(500)); handlerOfmsgQ->sendMessage(i); } }); std::thread receiver = std::thread([&](){ while(1) { //std::this_thread::sleep_for(std::chrono::milliseconds(500)); //int data = handlerOfmsgQ->receiveMessage(); int data = 0; handlerOfmsgQ->receiveMessage(data); std::stringstream ss; std::string msg; ss << "received data : " << data << std::endl; msg = ss.str(); DEBUG_PRINT(DebugLevel4MessageQueuePool::DEBUG_LEVEL_NORMAL, msg.c_str()); if(data == 9) break; } }); sender.join(); receiver.join(); return 0; }

3. 테스트 코드 실행

실행을 시켜보면 의도한 되로 정상동작한다. MesasgeQueue 전송 시에는 강제로 MessageQueue Empty 환경을 만들기 위해서 delay를 500ms 주고 던졌다. 수신쪽에서는 MessageQueue가 비어있으면 pthread condition 변수에 의해서 Task를 대기 시킴으로써 불필요한 CPU 점유률과 사용을 제거하였다.

 Trace in [getInstance,198]  
 Trace in [CMessageQueue,86]  
 Debug in [createMessageQueue,227]  
 Debug in [isMessageQueueEmpty,166]  
[receiveMessage,143] Message Queue Empty Condition 
 Debug in [sendMessage,112]  
 Debug in [isMessageQueueEmpty,166]  
 Debug in [receiveMessage,153]  
[operator(),287] received data : 0
 
 Debug in [isMessageQueueEmpty,166]  
[receiveMessage,143] Message Queue Empty Condition 
 Debug in [sendMessage,112]  
 Debug in [isMessageQueueEmpty,166]  
 Debug in [receiveMessage,153]  
[operator(),287] received data : 1
 
 Debug in [isMessageQueueEmpty,166]  
[receiveMessage,143] Message Queue Empty Condition 
 Debug in [sendMessage,112]  
 Debug in [isMessageQueueEmpty,166]  
 Debug in [receiveMessage,153]  
[operator(),287] received data : 2
 
 Debug in [isMessageQueueEmpty,166]  
[receiveMessage,143] Message Queue Empty Condition 
 Debug in [sendMessage,112]  
 Debug in [isMessageQueueEmpty,166]  
 Debug in [receiveMessage,153]  
[operator(),287] received data : 3

'Program Lang. > C++' 카테고리의 다른 글

[Basic] 생성자 호출 정리 (0)	2017.04.26
boost asio를 이용한 iptuner 제작 (0)	2017.04.11
enable_shared_from_this 정리 (0)	2017.01.12
[json-c] simple generator json ojbect (0)	2017.01.09
[json-c] simple parsing example (0)	2017.01.09

:

enable_shared_from_this 정리

Program Lang./C++ 2017. 1. 12. 19:02

1. shared_ptr 사용 시 고려사항

말로 기술하기 보다는 아래 예제 코드를 보면서 이해를 하자. shared_ptr 사용 시 주의해야할 내용이며 이를 방지하기 위해서 c++에서는 어떤 기술들이 고려되었는지 고민해 본다.

#include <iostream> #include <memory> class type { public: type(){ std::cout << __FUNCTION__ << std::endl;} ~type(){ std::cout << __FUNCTION__ << std::endl;} }; int main() { type *p = new type; std::shared_ptr<type> ptr1(p); //p object를 가르키는 shared_ptr 생성자 호출 std::cout <<"ptr1.use_count(): " << ptr1.use_count() << std::endl; std::shared_ptr<type> ptr2(p); //p object를 가르키는 shared_ptr 생성자 호출 std::cout <<"ptr2.use_count(): " << ptr2.use_count() << std::endl; return 0; }

위의 코드는 shared_ptr의 잘못된 사용 예이다. type이라는 클래스를 하나 동적선언하고 두 개의 shared_ptr ptr1, ptr2에 할당하였다. 이 코드를 실행하면 실행파일이 죽는다. 왜냐하면 ptr2를 실행하는 시점에 ptr1에 의해서 이미 type객체의 파괴자는 호출되어서 객체가 없는 상태인데 ptr2에서 다시 파괴자를 호출하는 구조이다.

[실행결과] http://melpon.org/wandbox/ 에서 실행한 결과이다.

Start type ptr1.use_count(): 1 ptr2.use_count(): 1 ~type ~type Segmentation fault Finish

2. shared_ptr 사용 시 다른 고려사항

아래 예제는 http://en.cppreference.com/w/cpp/memory/enable_shared_from_this 의 내용을 내가 이해하기 편하게 수정한 내용이다. 위의 예제는 서로 다른 shared_ptr에 동일한 객체의 포인터를 할당하면 안되는 것을 보여주는 예제이다. 아래 예제는 단순하게 생각했을 때 충분히 있을 수 있는 내용이다.

만약 생성된 현재 객체의 주소를 넘겨서 다른 shared_ptr에서 받아서 처리한다면 어떨까? 아래 예제는 형식은 다르지만 결과적으로 위의 1번 예제와 동일한 문제로 귀결된다.

#include <iostream> #include <memory> class type { public: type(){ std::cout << __FUNCTION__ << std::endl;} ~type(){ std::cout << __FUNCTION__ << std::endl;} std::shared_ptr<type> getPtr() { return std::shared_ptr<type>(this); } }; int main() { type *p = new type; std::shared_ptr<type> ptr1(p); //p object를 가르키는 shared_ptr 생성자 호출 std::cout <<"ptr1.use_count(): " << ptr1.use_count() << std::endl; // ptr2에 ptr1에서 객체의 주소를 return 받아 할당한다. std::shared_ptr<type> ptr2 = ptr1->getPtr(); std::cout <<"ptr2.use_count(): " << ptr2.use_count() << std::endl; return 0; }

[실행결과] http://melpon.org/wandbox/ 에서 실행한 결과이다. 결과는 예제 1번 동일하게 실행 파일이 죽는다. 실행 파일이 죽는 이유도 동일하다.

Start type ptr1.use_count(): 1 ptr2.use_count(): 1 ~type ~type Segmentation fault Finish

3. enable_shared_from_this 필요성

enable_shared_from_this를 써야 하는 이유는 이제 알 수 있다. cppreference의 내용을 읽어보면 내 수준에서는 마음에 와 닿지 않았다. 아래 예제만 놓고 본다면 현재 객체를 가르키는 share_ptr이외에 추가적으로 현재 객체의 소유권을 갖고자 하는 shared_ptr을 추가하고 할 경우, std::enable_shared_from_this 클래스로부터 상속을 받는다. 이 때 2번 예제처럼 shared_ptr<type>(this)로 넘기기 보다는 enable_shared_from_this의 맴버함수를 통해서 유사한 동작을 수행하지만 shared_ptr의 reference_count를 증가시켜서 넘기는 추가적인 작업을 내부적으로 수행하는 것으로 보인다.

enable_shared_from_this 사용을 통해서 2번 예제의 문제점을 적절하게 수정한 아래 예제를 참조한다.

#include <iostream> #include <memory> class type : public std::enable_shared_from_this<type> { public: type(){ std::cout << __FUNCTION__ << std::endl;} ~type(){ std::cout << __FUNCTION__ << std::endl;} std::shared_ptr<type> getPtr() { //return std::shared_ptr<type>(this); return shared_from_this(); } }; int main() { type *p = new type; std::shared_ptr<type> ptr1(p); //p object를 가르키는 shared_ptr 생성자 호출 std::cout <<"ptr1.use_count(): " << ptr1.use_count() << std::endl; // ptr2에 ptr1에서 객체의 주소를 return 받아 할당한다. std::shared_ptr<type> ptr2 = ptr1->getPtr(); std::cout <<"ptr2.use_count(): " << ptr2.use_count() << std::endl; return 0; }

[실행결과] http://melpon.org/wandbox/ 에서 실행한 결과이다. 정상적으로 객체가 소멸하는 것을 볼 수 있다.

Start type ptr1.use_count(): 1 ptr2.use_count(): 2 ~type 0 Finish

4. 추가 reference

boost asio http server example 코드에서 enable_shared_from_this의 사용을 찾아볼 수 있다. connection.cpp 파일을 참조하면 사용 보기가 나온다.

http://www.boost.org/doc/libs/1_55_0/doc/html/boost_asio/examples/cpp11_examples.html#boost_asio.examples.cpp11_examples.http_server

'Program Lang. > C++' 카테고리의 다른 글

boost asio를 이용한 iptuner 제작 (0)	2017.04.11
message queue implementation by c++ STL (0)	2017.04.06
[json-c] simple generator json ojbect (0)	2017.01.09
[json-c] simple parsing example (0)	2017.01.09
std::function 정리 (0)	2017.01.02

:

[json-c] simple generator json ojbect

Program Lang./C++ 2017. 1. 9. 21:57

1. 개요

이번에는 object를 만들어서 string 및 파일로 출력하는 예제를 만들어 본다.

2. 테스트 코드

앞장에서 주어진 string을 object 객체로 parsing했다면 이 장에서는 각 객체를 하나의 객체로 만드는 과정이다.

앞장의 역이라고 보면 된다.

#include <stdio.h>
#include <string.h>
#include <json.h>

// reference => https://linuxprograms.wordpress.com/2010/08/19/json_object_new_object/

int main()
{
	char *out_file = "out_json.txt";

system("free");

// create new json ojbect
	json_object *jobj = json_object_new_object();

// create a json string
	json_object *jstring = json_object_new_string("heesoon.kim");
	// create a json integer
	json_object *jint1 = json_object_new_int(41);
	// create a json double
	json_object *jdouble = json_object_new_double(172.20);
	// create a json boolean
	json_object *jboolean = json_object_new_boolean(0);

// create a json array
	json_object *jarray = json_object_new_array();
	// create a json data for array
	json_object *jstring1 = json_object_new_string("c");
	// create a json data for array
	json_object *jstring2 = json_object_new_string("c++");
	// create a json data for array
	json_object *jstring3 = json_object_new_string("javascript");
	// create a json data for array
	json_object *jstring4 = json_object_new_string("phython");

// add data to array
	json_object_array_add(jarray, jstring1);
	json_object_array_add(jarray, jstring2);
	json_object_array_add(jarray, jstring3);
	//json_object_array_add(jarray, jstring4);
	json_object_array_put_idx(jarray, 4, jstring4);

// create a json object to be included above outer object
    json_object *jinner_object = json_object_new_object();
	// create a json integer
	json_object *jint2 = json_object_new_int(10);

// add data to inner object
	json_object_object_add(jinner_object, "name", jstring);
	json_object_object_add(jinner_object, "Number of Posts", jint2);

// add data to outer object
	json_object_object_add(jobj, "name", 			jstring);
	json_object_object_add(jobj, "student", 		jboolean);
	json_object_object_add(jobj, "age", 			jint1);
	json_object_object_add(jobj, "height", 			jdouble);
	json_object_object_add(jobj, "interestings", 	jarray);
	json_object_object_add(jobj, "author-details", 	jinner_object);

printf("The json ojbect created: %s\n", json_object_to_json_string(jobj));

// save to file
	json_object_to_file(out_file, jobj);

system("free");

// delete all memory allocated in heap region
	json_object_put(jstring);
	json_object_put(jint1);
	json_object_put(jdouble);
	json_object_put(jboolean);

// delete all data in array
	for(int i = 0; i < json_object_array_length(jarray); i++)
	{
		json_object_array_del_idx(jarray, 0, 1);
	}

json_object_put(jarray);
	json_object_put(jinner_object);
	json_object_put(jobj);

system("free");

return 0;
}

3. 실행 결과

{"name":"heesoon.kim","student":false,"age":41,"height":172.19999999999999,"interestings":["c","c++","javascript","phython"],"author-details":{"name":"heesoon.kim","Number of Posts":10}}

4. Check Point

마지막에 호출한 json_object_put()에 주의할 필요가 있다. json-c library는 객체 생성을 위해서 HEAP 영역에 메모리를 할당한다. 이 할당한 메모리를 관리하기 위해서 reference count를 내부적으로 가지고 있다. json object들의 생성함수를 호출하면 reference count는 '1'로 초기화하고 json_object_get()을 호출하면 reference count가 1 증가, json_object_put()함수를 호출하면 reference count를 1 감소하는 구조이다. 또한 json_object_put()함수는 reference count가 '0'이 되면 객체를 위해서 할당한 HEAP 영역 메모리를 모두 해재한다.

따라서 마지막에 json_object_put()함수를 모두 호출하여 객체 생성을 위해서 할당한 메모리를 모두 해제하도록 하였다. 앞 장에서 전문가가 json-c library를 잘못 사용하면 메모리 누수가 발생할 수 있다는 의미를 알 것 같다. json_object_put()과 json_object_get()함수의 짝이 맞지 않거나 json_ojbect_put()함수를 객체 생성 후에 호출하지 않으면 모두 메모리가 쌓여 있을 것으로 보입니다.

'Program Lang. > C++' 카테고리의 다른 글

message queue implementation by c++ STL (0)	2017.04.06
enable_shared_from_this 정리 (0)	2017.01.12
[json-c] simple parsing example (0)	2017.01.09
std::function 정리 (0)	2017.01.02
unique_ptr, shared_ptr 읽히기 (0)	2016.12.30

:

[json-c] simple parsing example

Program Lang./C++ 2017. 1. 9. 14:45

1. 개요

c언어로 되어 있는 json library이다. 나는 관련 일을 하지 않고 단순히 이용만 하는 입장이라서 자세히는 모르지만 제 기억에 어떤 전문가께서 세미나 하는 것을 들었는데 json-c는 주의를 기울이지 않으면 memory leak에 취약하다고 들었던 것 기억이 있다. 일단 난 사용법 익히는데 집중한다.

2. json-c를 위한 cmake 수정 사항

할 때마다 매번 찾아봐야 해서 여기에 정리해 놓는다. 다른 방법이 있겠지만 나는 단순히 pkg-config로 cflags 값과 libs 위치확인하고 강제로 cmake에 막았다.

수정사항은 cflags (헤더파일 위치)를 위한 include_directories(/usr/local/include/json-c)

libs 관련 정보 : link_directories(/usr/local/lib), json-c (-l 플래그 관련 수정 사항)

3. json 기본 Type 테스트

json의 기본 타입은 아래와 같다.

null
boolean
double
int
object
array
string

타입에 대한 정의 및 각 타입을 읽어들이는 방법은 아래 코드에 자세하게 나와 있다.

#include <stdio.h>
#include <string.h>
#include <json.h>

int main()
{
	enum json_type type;
	
	char *string = "{\
			\"name\" 			: \"heesoon.kim\",\
		    \"student\" 		: false,\
		    \"age\" 			: 41,\
		    \"heigh\" 			: 172.2,\
		    \"interestings\" 	: [ \"c\" , \"c++\", \"javascript\", \"phython\" ],\
		    \"author-details\"	: { \"name\" : \"heesoon.kim\", \"Number of Posts\" : 10 }\
	  }";

// string type is converted to json object type
	json_object *jobj = json_tokener_parse(string);

// parse each json object paired with key and val
	json_object_object_foreach(jobj, key, val)
	{
		// get current json object type
		type = json_object_get_type(val);
		printf("type = ");

switch(type)
		{
			case json_type_null:
				printf("json_type_null\n");
				break;
			case json_type_boolean:
				printf("json_type_boolean\n");
				printf("key = %-15s : value = %s\n", key, json_object_get_boolean(val) ? "true" : "false");
				break;
			case json_type_double:
				printf("json_type_double\n");
				printf("key = %-15s : value = %lf\n", key, json_object_get_double(val));
				break;
			case json_type_int:
				printf("json_type_int\n");
				printf("key = %-15s : value = %d\n", key, json_object_get_int(val));
				break;
			case json_type_object:
				printf("json_type_object\n");
				printf("key = %-15s : value = \n", key);
				break;
			case json_type_array:
				printf("json_type_array\n");
				printf("key = %-15s : value = \n", key);
				break;
			case json_type_string:
				printf("json_type_string\n");
				printf("key = %-15s : value = %s\n", key, json_object_get_string(val));
				break;
		}
	}

printf("\n");

return 0;
}

char형의 string을 json_tokener_parse() 함수를 통해서 json object로 변경한다. object내에 있는 각 값을 타입에 따라 parsing하는 예제이다. 입력 string은 하나의 큰 object에 string, boolean, integer, float, array, object로 구성되어 있다. 앞의 name, student, age, height, interestings, author-details는 key를 의미하고 각각 key와 오른쪽은 value이다.

여기서 array와 object는 추가적인 parsing이 더 들어가야 한다.

4. 실행결과

hskim@hskim-VirtualBox:~/share/prj/c++/test2$ ./test type = json_type_string key = name : value = heesoon.kim type = json_type_boolean key = student : value = false type = json_type_int key = age : value = 41 type = json_type_double key = heigh : value = 172.200000 type = json_type_array key = interestings : value = type = json_type_object key = author-details : value =

'Program Lang. > C++' 카테고리의 다른 글

enable_shared_from_this 정리 (0)	2017.01.12
[json-c] simple generator json ojbect (0)	2017.01.09
std::function 정리 (0)	2017.01.02
unique_ptr, shared_ptr 읽히기 (0)	2016.12.30
c++ pair 읽히기 (0)	2016.12.30

:

CHIPMAKER

'Program Lang./C++'에 해당되는 글 36건

boost asio 정리 - 2 (io_service single thread 처리)

'Program Lang. > C++' 카테고리의 다른 글

boost asio 정리 - 1 기본동작

'Program Lang. > C++' 카테고리의 다른 글

[Basic] 클래스 상속 및 가상함수, 순수가상함수 정리

'Program Lang. > C++' 카테고리의 다른 글

[Basic] 맴버변수의 상수, 정적 속성, 상수와 정적변수 동시적용 시, 상수 맴버 함수 정리

'Program Lang. > C++' 카테고리의 다른 글

[Basic] 생성자 호출 정리

'Program Lang. > C++' 카테고리의 다른 글

boost asio를 이용한 iptuner 제작

'Program Lang. > C++' 카테고리의 다른 글

message queue implementation by c++ STL

'Program Lang. > C++' 카테고리의 다른 글

enable_shared_from_this 정리

'Program Lang. > C++' 카테고리의 다른 글

[json-c] simple generator json ojbect

'Program Lang. > C++' 카테고리의 다른 글

[json-c] simple parsing example

'Program Lang. > C++' 카테고리의 다른 글

티스토리툴바