fix memory leak

liuxiaolong

2021-07-20 13c503b73b4ecc8ce4a6e344f9ac15202985d686

 utest/util.h

@@ -19,81 +19,118 @@
#ifndef UTIL_W8A0OA5U
#define UTIL_W8A0OA5U

#include <functional>
#include <vector>
#include <thread>
#include <stdlib.h>
#include "bh_util.h"
#include "shm.h"
#include "topic_node.h"
#include <boost/noncopyable.hpp>
#include <boost/test/unit_test.hpp>
#include <boost/timer/timer.hpp>
#include <chrono>
#include <functional>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <boost/noncopyable.hpp>
#include <boost/timer/timer.hpp>
#include <boost/test/unit_test.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include "shm.h"
#include "shm_queue.h"
#include "msg.h"
#include "bh_util.h"

using namespace boost::posix_time;
inline ptime Now() { return second_clock::universal_time(); };
#include <thread>
#include <vector>

using namespace std::chrono_literals;
using namespace std::chrono;

template <class D>
inline void Sleep(D d, bool print = true)
{
   if (print) {
      printf("sleep for %ld ms\n", std::chrono::duration_cast<std::chrono::milliseconds>(d).count());
   }
   std::this_thread::sleep_for(d);
}

typedef std::function<void(void)> FuncVV;

class ScopeCall : private boost::noncopyable {
    FuncVV f_;
class ScopeCall : private boost::noncopyable
{
   FuncVV f_;

public:
    ScopeCall(FuncVV f):f_(f) { f_(); }
    ~ScopeCall() { f_(); }
   ScopeCall(FuncVV f) :
       f_(f) { f_(); }
   ~ScopeCall() { f_(); }
};
class ThreadManager {
    std::vector<std::thread> threads_;
class ThreadManager
{
   std::vector<std::thread> threads_;

public:
    ~ThreadManager() { WaitAll(); }
    template <class T, class...P>
    void Launch(T t, P...p) { threads_.emplace_back(t, p...); }
    void WaitAll() {
        for (auto &t : threads_) {
            if (t.joinable()) {
                t.join();
            }
        }
    }
   ~ThreadManager() { WaitAll(); }
   template <class T, class... P>
   void Launch(T &&t, P &&...p) { threads_.emplace_back(std::forward<decltype(t)>(t), std::forward<decltype(p)>(p)...); }
   void WaitAll()
   {
      for (auto &t : threads_) {
         if (t.joinable()) {
            t.join();
         }
      }
   }
};
class ProcessManager {
    std::vector<pid_t> procs_;
class ProcessManager
{
   std::vector<pid_t> procs_;

public:
    ~ProcessManager() { WaitAll(); }
    template <class T, class ...P>
    void Launch(T t, P...p) {
        auto pid = fork();
        if (pid == 0) {
            // child
            t(p...);
            exit(0);
        } else if (pid != -1) { // Ok
            procs_.push_back(pid);
        }
    };
    void WaitAll() {
        for (auto &pid: procs_) {
            int status = 0;
            int options = WUNTRACED | WCONTINUED;
            waitpid(pid, &status, options);
        }
        procs_.clear();
    }
   ~ProcessManager() { WaitAll(); }
   template <class T, class... P>
   void Launch(T t, P... p)
   {
      auto pid = fork();
      if (pid == 0) {
         // child
         t(p...);
         exit(0);
      } else if (pid != -1) { // Ok
         procs_.push_back(pid);
      }
   };
   void WaitAll()
   {
      for (auto &pid : procs_) {
         int status = 0;
         int options = WUNTRACED | WCONTINUED;
         waitpid(pid, &status, options);
      }
      procs_.clear();
   }
};

using namespace bhome_shm;
using namespace bhome_msg;

struct ShmRemover {
    std::string name_;
    ShmRemover(const std::string &name):name_(name) { SharedMemory::Remove(name_); }
    ~ShmRemover() { SharedMemory::Remove(name_); }
   std::string name_;
   ShmRemover(const std::string &name) :
       name_(name) { SharedMemory::Remove(name_); }
   ~ShmRemover() { SharedMemory::Remove(name_); }
};

class DemoNode : public TopicNode
{
   std::string id_;

public:
   DemoNode(const std::string &id, SharedMemory &shm) :
       TopicNode(shm), id_(id) { Init(); }
   void Init()
   {
      ProcInfo proc;
      proc.set_proc_id(id_);
      MsgCommonReply reply_body;

      if (!Register(proc, reply_body, 1000)) {
         printf("node %s register failed\n", id_.c_str());
      }
   }
};

bhome_shm::SharedMemory &TestShm();

#endif // end of include guard: UTIL_W8A0OA5U