thread_base.cpp

Go to the documentation of this file.

/******************************************************************************
** Copyright © 2005 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 "../core/private_/thread_base.hpp"
 
#include <boost/exception/diagnostic_information.hpp>
 
// Implementation details..... Don't look below here!!! ;)
 
JMMCG_REVISION_CONSTANT(_T(LIBJMMCG_VERSION_NUMBER))
 
// "thread_base" implementation...
 
namespace jmmcg { namespace LIBJMMCG_VER_NAMESPACE { namespace ppd { namespace private_ {
 
typedef thread_base<generic_traits::api_type::posix_pthreads, sequential_mode> thread_t_s;
 
template<> thread_t_s::thread_traits::api_params_type::core_work_fn_ret_t
thread_t_s::core_work_fn(thread_traits::api_params_type::core_work_fn_arg_t ptr) noexcept(false) {
   assert(ptr);
   thread_t_s * const pthis=reinterpret_cast<thread_t_s *>(ptr);
   assert(pthis);
   if (pthis) {
      try {
         pthis->thread_params.state=thread_traits::api_params_type::active;
         thread_traits::set_cancelstate(thread_traits::api_params_type::cancel_disable);
         int old_state;
         [[maybe_unused]] const int pth_err=pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, &old_state);
         assert(pth_err==0);
         const thread_traits::api_params_type::states ret=pthis->process_chk();
         pthis->thread_params.state=thread_traits::api_params_type::exiting;
         return reinterpret_cast<thread_traits::api_params_type::core_work_fn_ret_t>(ret);
#if defined(__GNUC__) && !defined(__clang__)
      } catch (abi::__forced_unwind const &) {
         pthis->thread_params.state=thread_traits::api_params_type::exiting;
         throw;
#endif
      } catch (std::exception const &ex) {
         JMMCG_TRACE(_T("STL-derived exception. Details: ")<<boost::diagnostic_information(ex));
         pthis->exception_thrown_in_thread.set(std::current_exception());
      } catch (...) {
         JMMCG_TRACE(_T("Unknown exception caught. If it is a SIGSEGV, then the ss value in the thread_params ctor may need increasing."));
         auto ex=std::current_exception();
         if (ex) {
            pthis->exception_thrown_in_thread.set(ex);
         }
         throw;
      }
      pthis->thread_params.state=thread_traits::api_params_type::exiting;
      return reinterpret_cast<thread_traits::api_params_type::core_work_fn_ret_t>(thread_traits::api_params_type::unknown_exception);
   }
   // In reality, no errors are actively reported to the user for this case, as the pthis was null.
   // So we almost silently fail, and hope that they aren't sooooo dumb as to not notice that their work isn't being processed...
   // This is because the only "opportunity" I have to report it is as an exception in the destructor. Hooo-boy would that be evil...
   // Just think of the memory leaks.... So I don't do that. That's the breaks....
   return reinterpret_cast<thread_traits::api_params_type::core_work_fn_ret_t>(thread_traits::api_params_type::null_this_pointer);
}
 
typedef thread_base<generic_traits::api_type::posix_pthreads, heavyweight_threading> thread_t_m;
 
template<> thread_t_m::thread_traits::api_params_type::core_work_fn_ret_t
thread_t_m::core_work_fn(thread_traits::api_params_type::core_work_fn_arg_t ptr) noexcept(false) {
   assert(ptr);
   thread_t_m * const pthis=reinterpret_cast<thread_t_m *>(ptr);
   assert(dynamic_cast<thread_t_m *>(pthis));
   if (pthis) {
      try {
         pthis->thread_params.state=thread_traits::api_params_type::active;
         thread_traits::set_cancelstate(thread_traits::api_params_type::cancel_disable);
         int old_state;
         [[maybe_unused]] const int pth_err=pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, &old_state);
         assert(pth_err==0);
         const thread_traits::api_params_type::states ret=pthis->process_chk();
         pthis->thread_params.state=thread_traits::api_params_type::exiting;
         return reinterpret_cast<thread_traits::api_params_type::core_work_fn_ret_t>(ret);
#if defined(__GNUC__) && !defined(__clang__)
      } catch (abi::__forced_unwind const &) {
         pthis->thread_params.state=thread_traits::api_params_type::exiting;
         throw;
#endif
      } catch (std::exception const &ex) {
         JMMCG_TRACE(_T("STL-derived exception. Details: ")<<boost::diagnostic_information(ex));
         pthis->exception_thrown_in_thread.set(std::current_exception());
      } catch (...) {
         JMMCG_TRACE(_T("Unknown exception caught. If it is a SIGSEGV, then the ss value in the thread_params ctor may need increasing."));
         auto ex=std::current_exception();
         if (ex) {
            pthis->exception_thrown_in_thread.set(ex);
         }
         throw;
      }
      pthis->thread_params.state=thread_traits::api_params_type::exiting;
      return reinterpret_cast<thread_traits::api_params_type::core_work_fn_ret_t>(thread_traits::api_params_type::unknown_exception);
   }
   // In reality, no errors are actively reported to the user for this case, as the pthis was null.
   // So we almost silently fail, and hope that they aren't sooooo dumb as to not notice that their work isn't being processed...
   // This is because the only "opportunity" I have to report it is as an exception in the destructor. Hooo-boy would that be evil...
   // Just think of the memory leaks.... So I don't do that. That's the breaks....
   return reinterpret_cast<thread_traits::api_params_type::core_work_fn_ret_t>(thread_traits::api_params_type::null_this_pointer);
}
 
} } } }