ode/src/threading_base.cpp

   1 /*************************************************************************
   2  *                                                                       *
   3  * Open Dynamics Engine, Copyright (C) 2001-2003 Russell L. Smith.       *
   4  * All rights reserved.  Email: russ@q12.org   Web: www.q12.org          *
   5  *                                                                       *
   6  * Threading base wrapper class implementation file.                     *
   7  * Copyright (C) 2011-2022 Oleh Derevenko. All rights reserved.          *
   8  * e-mail: odar@eleks.com (change all "a" to "e")                        *
   9  *                                                                       *
  10  * This library is free software; you can redistribute it and/or         *
  11  * modify it under the terms of EITHER:                                  *
  12  *   (1) The GNU Lesser General Public License as published by the Free  *
  13  *       Software Foundation; either version 2.1 of the License, or (at  *
  14  *       your option) any later version. The text of the GNU Lesser      *
  15  *       General Public License is included with this library in the     *
  16  *       file LICENSE.TXT.                                               *
  17  *   (2) The BSD-style license that is included with this library in     *
  18  *       the file LICENSE-BSD.TXT.                                       *
  19  *                                                                       *
  20  * This library is distributed in the hope that it will be useful,       *
  21  * but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  22  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the files    *
  23  * LICENSE.TXT and LICENSE-BSD.TXT for more details.                     *
  24  *                                                                       *
  25  *************************************************************************/
  26
  27 /*
  28  * Threading base class to be used for inheritance by dxWorld, dxSpace and others
  29  * to take advantage of threaded execution.
  30  */
  31
  32
  33 #include <ode/common.h>
  34 #include "config.h"
  35 #include "error.h"
  36 #include "threading_base.h"
  37
  38
  39 dxThreadingBase::~dxThreadingBase()
  40 {
  41     DoFreeStockCallWait();
  42 }
  43
  44
  45 void dxThreadingBase::PostThreadedCallsGroup(
  46     int *out_summary_fault/*=NULL*/,
  47     ddependencycount_t member_count, dCallReleaseeID dependent_releasee/*=NULL*/,
  48     dThreadedCallFunction *call_func, void *call_context,
  49     const char *call_name/*=NULL*/) const
  50 {
  51     dIASSERT(member_count != 0);
  52
  53     dThreadingImplementationID impl;
  54     const dxThreadingFunctionsInfo *functions = FindThreadingImpl(impl);
  55
  56     for (unsigned member_index = 0; member_index != member_count; ++member_index) {
  57         // Post individual group member jobs
  58         functions->post_call(impl, out_summary_fault, NULL, 0, dependent_releasee, NULL, call_func, call_context, member_index, call_name);
  59     }
  60 }
  61
  62 void dxThreadingBase::PostThreadedCallsIndexOverridenGroup(int *out_summary_fault/*=NULL*/,
  63     ddependencycount_t member_count, dCallReleaseeID dependent_releasee/*=NULL*/,
  64     dThreadedCallFunction *call_func, void *call_context, unsigned index_override,
  65     const char *call_name/*=NULL*/) const
  66 {
  67     dIASSERT(member_count != 0);
  68
  69     dThreadingImplementationID impl;
  70     const dxThreadingFunctionsInfo *functions = FindThreadingImpl(impl);
  71
  72     for (unsigned member_index = 0; member_index != member_count; ++member_index) {
  73         // Post individual group member jobs
  74         functions->post_call(impl, out_summary_fault, NULL, 0, dependent_releasee, NULL, call_func, call_context, index_override, call_name);
  75     }
  76 }
  77
  78 void dxThreadingBase::PostThreadedCallForUnawareReleasee(
  79     int *out_summary_fault/*=NULL*/,
  80     dCallReleaseeID *out_post_releasee/*=NULL*/, ddependencycount_t dependencies_count, dCallReleaseeID dependent_releasee/*=NULL*/,
  81     dCallWaitID call_wait/*=NULL*/,
  82     dThreadedCallFunction *call_func, void *call_context, dcallindex_t instance_index,
  83     const char *call_name/*=NULL*/) const
  84 {
  85     dThreadingImplementationID impl;
  86     const dxThreadingFunctionsInfo *functions = FindThreadingImpl(impl);
  87
  88     functions->alter_call_dependencies_count(impl, dependent_releasee, 1);
  89     functions->post_call(impl, out_summary_fault, out_post_releasee, dependencies_count, dependent_releasee, call_wait, call_func, call_context, instance_index, call_name);
  90 }
  91
  92
  93 const dxThreadingFunctionsInfo *dxThreadingBase::FindThreadingImpl(dThreadingImplementationID &out_impl_found) const
  94 {
  95     const dxThreadingFunctionsInfo *functions_found = GetFunctionsInfo();
  96
  97     if (functions_found != NULL)
  98     {
  99         out_impl_found = GetThreadingImpl();
 100     }
 101     else
 102     {
 103         functions_found = m_default_impl_provider->retrieveThreadingDefaultImpl(out_impl_found);
 104     }
 105
 106     return functions_found;
 107 }
 108
 109
 110 dCallWaitID dxThreadingBase::DoAllocateStockCallWait()
 111 {
 112     dIASSERT(GetStockCallWait() == NULL);
 113
 114     dCallWaitID stock_wait_id = AllocThreadedCallWait();
 115
 116     if (stock_wait_id != NULL)
 117     {
 118         SetStockCallWait(stock_wait_id);
 119     }
 120
 121     return stock_wait_id;
 122 }
 123
 124 void dxThreadingBase::DoFreeStockCallWait()
 125 {
 126     dCallWaitID stock_wait_id = GetStockCallWait();
 127
 128     if (stock_wait_id != NULL)
 129     {
 130         FreeThreadedCallWait(stock_wait_id);
 131
 132         SetStockCallWait(NULL);
 133     }
 134 }
 135