shared_mem.cpp

Go to the documentation of this file.

/******************************************************************************
** Copyright © 2019 by J.M.McGuiness, coder@hussar.me.uk
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library 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
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
 
#include "stdafx.h"
 
#define BOOST_TEST_MODULE libjmmcg_tests
#include <boost/test/included/unit_test.hpp>
 
#include "config.h"
#include "shared_mem_struct.hpp"
 
#include "core/shared_mem.hpp"
 
#include <cstdlib>
#include <future>
 
static const std::string name("shared_mem_test");
static constexpr std::size_t size=sizeof(std::uint64_t)*10;
 
using namespace libjmmcg;
 
struct create_shm_and_child {
   class ensure_exits {
   public:
      explicit ensure_exits(shared_data &data) noexcept(true)
      : data_(data) {}
      ~ensure_exits() noexcept(true) {
         data_.exit_child=true;
      }
 
   private:
      shared_data &data_;
   };
 
   shared_mem shm{name, sizeof(shared_data)};
   shared_data * const data{shm.get<shared_data>()};
 
   void wait_for_subproc_to_start() {
      while (!data->subproc_started) {
         std::this_thread::yield();
      }
   }
 
   void new_data() {
      data->changed=!data->changed;
   }
 
   void wait_for_new_data() {
      const bool old=data->changed;
      while (data->changed==old) {
         std::this_thread::yield();
      }
   }
};
 
BOOST_AUTO_TEST_SUITE(shared_mem_test)
 
BOOST_AUTO_TEST_CASE(ctor) {
   BOOST_CHECK_NO_THROW(shared_mem shm(name, size));
}
 
BOOST_AUTO_TEST_CASE(create_shms_shared_another) {
   shared_mem shm(name, size);
   shared_mem shm_shared(name, size);
}
 
BOOST_AUTO_TEST_CASE(verify_mapped_Addr_not_nullptr) {
   shared_mem shm(name, size);
   BOOST_CHECK_NE(shm.get<void>(), nullptr);
}
 
BOOST_AUTO_TEST_CASE(write_word_to_memory_and_sync) {
   shared_mem shm(name, size);
   std::uint64_t *mem=shm.get<std::uint64_t>();
   *mem=42;
   BOOST_CHECK_EQUAL(*shm.get<std::uint64_t>(), 42);
   BOOST_CHECK_NO_THROW(shm.sync(shm.get<std::uint64_t>(), sizeof(std::uint64_t)));
   BOOST_CHECK_EQUAL(*shm.get<std::uint64_t>(), 42);
   BOOST_CHECK_NO_THROW(shm.sync(shm.get<std::uint64_t>(), sizeof(std::uint64_t), shared_mem::req_update_wait));
   BOOST_CHECK_EQUAL(*shm.get<std::uint64_t>(), 42);
   *mem=68;
   BOOST_CHECK_EQUAL(*shm.get<std::uint64_t>(), 68);
   BOOST_CHECK_NO_THROW(shm.sync(shm.get<std::uint64_t>(), sizeof(std::uint64_t)));
   BOOST_CHECK_EQUAL(*shm.get<std::uint64_t>(), 68);
   BOOST_CHECK_NO_THROW(shm.sync(shm.get<std::uint64_t>(), sizeof(std::uint64_t), shared_mem::req_update_wait));
   BOOST_CHECK_EQUAL(*shm.get<std::uint64_t>(), 68);
}
 
BOOST_AUTO_TEST_CASE(create_shms_shared_another_writes) {
   shared_mem shm(name, size);
   shared_mem shm_shared(name, size);
   std::uint64_t *mem=shm.get<std::uint64_t>();
   *mem=42;
   std::uint64_t *mem_shared=shm_shared.get<std::uint64_t>();
   BOOST_CHECK_EQUAL(*mem_shared, *mem);
   *mem_shared=68;
   BOOST_CHECK_EQUAL(*mem_shared, *mem);
}
 
BOOST_AUTO_TEST_CASE(create_shm_and_child_in_bg) {
   create_shm_and_child shm_and_child;
   int exit_code=-1;
   {
      const create_shm_and_child::ensure_exits exit(*shm_and_child.data);
      exit_code=std::system(JMMCG_SHAREDMEM_SUBPROC_NAME " &");
      BOOST_CHECK_NO_THROW(shm_and_child.wait_for_subproc_to_start());
      shm_and_child.data->ping=true;
      BOOST_CHECK_NO_THROW(shm_and_child.new_data());
      BOOST_CHECK_NO_THROW(shm_and_child.wait_for_new_data());
      BOOST_CHECK_EQUAL(shm_and_child.data->pong, true);
   }
   BOOST_CHECK_EQUAL(exit_code, 0);
}
 
BOOST_AUTO_TEST_CASE(create_shm_and_child_controlled_by_thread) {
   create_shm_and_child shm_and_child;
   auto get_subproc_ret_code=std::async(
      std::launch::async,
      []() {
         return std::system(JMMCG_SHAREDMEM_SUBPROC_NAME);
      }
   );
   {
      const create_shm_and_child::ensure_exits exit(*shm_and_child.data);
      BOOST_CHECK_NO_THROW(shm_and_child.wait_for_subproc_to_start());
      shm_and_child.data->ping=true;
      BOOST_CHECK_NO_THROW(shm_and_child.new_data());
      BOOST_CHECK_NO_THROW(shm_and_child.wait_for_new_data());
      BOOST_CHECK_EQUAL(shm_and_child.data->pong, true);
   }
   // No bloody idea why we get this weird difference...
#ifdef NDEBUG
   BOOST_CHECK_EQUAL(get_subproc_ret_code.get(), 0);
#else
   BOOST_CHECK_EQUAL(get_subproc_ret_code.get(), 256);
#endif
}
 
BOOST_AUTO_TEST_SUITE_END()