diff options
Diffstat (limited to 'libs/ode-0.16.1/ode/src/resource_control.h')
| -rw-r--r-- | libs/ode-0.16.1/ode/src/resource_control.h | 151 |
1 files changed, 151 insertions, 0 deletions
diff --git a/libs/ode-0.16.1/ode/src/resource_control.h b/libs/ode-0.16.1/ode/src/resource_control.h new file mode 100644 index 0000000..cadae0e --- /dev/null +++ b/libs/ode-0.16.1/ode/src/resource_control.h @@ -0,0 +1,151 @@ +/************************************************************************* + * * + * Open Dynamics Engine, Copyright (C) 2001,2002 Russell L. Smith. * + * All rights reserved. Email: russ@q12.org Web: www.q12.org * + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of EITHER: * + * (1) 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. The text of the GNU Lesser * + * General Public License is included with this library in the * + * file LICENSE.TXT. * + * (2) The BSD-style license that is included with this library in * + * the file LICENSE-BSD.TXT. * + * * + * 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 files * + * LICENSE.TXT and LICENSE-BSD.TXT for more details. * + * * + *************************************************************************/ + +/* + * Resource accounting/preallocation class declarations + * Copyright (c) 2017-2019 Oleh Derevenko, odar@eleks.com (change all "a" to "e") + */ + +#ifndef _ODE__PRIVATE_RESOURCE_CONTRIOL_H_ +#define _ODE__PRIVATE_RESOURCE_CONTRIOL_H_ + + +#include "objects.h" +#include "threading_base.h" +#include "odeou.h" +#include "common.h" +#include "error.h" + + +using _OU_NAMESPACE::CSimpleFlags; + + +class dxResourceRequirementDescriptor: + public dBase +{ +public: + explicit dxResourceRequirementDescriptor(dxThreadingBase *relatedThreading): + dBase(), + m_relatedThreading(relatedThreading), + m_memorySizeRequirement(0), + m_memoryAlignmentRequirement(0), + m_simultaneousCallRequirement(0), + m_featureRequirements() + { + } + + ~dxResourceRequirementDescriptor(); + + enum + { + STOCK_CALLWAIT_REQUIRED = 0x00000001, + }; + + void mergeAnotherDescriptorIn(const dxResourceRequirementDescriptor &anotherDescriptor) + { + dIASSERT(getrelatedThreading() == anotherDescriptor.getrelatedThreading()); // m_simultaneousCallRequirement typically depends on threading used + + CSimpleFlags::value_type allOtherFeatureFlags = anotherDescriptor.queryAllFeatureFlags(); + mergeAnotherDescriptorIn(anotherDescriptor.m_memorySizeRequirement, anotherDescriptor.m_memoryAlignmentRequirement, anotherDescriptor.m_simultaneousCallRequirement, allOtherFeatureFlags); + } + + void mergeAnotherDescriptorIn(sizeint memorySizeRequirement/*=0*/, unsigned memoryAlignmentRequirement, + unsigned simultaneousCallRequirement/*=0*/, unsigned featureRequirement/*=0*/) + { + m_memorySizeRequirement = dMACRO_MAX(m_memorySizeRequirement, memorySizeRequirement); + m_memoryAlignmentRequirement = dMACRO_MAX(m_memoryAlignmentRequirement, memoryAlignmentRequirement); + m_simultaneousCallRequirement = dMACRO_MAX(m_simultaneousCallRequirement, simultaneousCallRequirement); + mergeFeatureFlags(featureRequirement); + } + +public: + dxThreadingBase *getrelatedThreading() const { return m_relatedThreading; } + sizeint getMemorySizeRequirement() const { return m_memorySizeRequirement; } + unsigned getMemoryAlignmentRequirement() const { return m_memoryAlignmentRequirement; } + + unsigned getSimultaneousCallRequirement() const { return m_simultaneousCallRequirement; } + + bool getIsStockCallWaitRequired() const { return getStockCallWaitRequiredFlag(); } + +private: + enum + { + FL_STOCK_CALLWAIT_REQUIRED = STOCK_CALLWAIT_REQUIRED, + }; + + bool getStockCallWaitRequiredFlag() const { return m_featureRequirements.GetFlagsMaskValue(FL_STOCK_CALLWAIT_REQUIRED); } + + CSimpleFlags::value_type queryAllFeatureFlags() const { return m_featureRequirements.QueryFlagsAllValues(); } + void mergeFeatureFlags(CSimpleFlags::value_type flagValues) { m_featureRequirements.SignalFlagsMaskValue(flagValues); } + +private: + dxThreadingBase *m_relatedThreading; + sizeint m_memorySizeRequirement; + unsigned m_memoryAlignmentRequirement; + unsigned m_simultaneousCallRequirement; + CSimpleFlags m_featureRequirements; +}; + +static inline +dxResourceRequirementDescriptor *decodeResourceRequirementsID(dResourceRequirementsID requirements) +{ + return (dxResourceRequirementDescriptor *)requirements; +} + + +class dxRequiredResourceContainer: + public dBase +{ +public: + dxRequiredResourceContainer(): + dBase(), + m_relatedThreading(NULL), + m_stockCallWait(NULL), + m_memoryAllocation() + { + } + + ~dxRequiredResourceContainer(); + + bool allocateResources(const dxResourceRequirementDescriptor &requirementDescriptor); + void freeResources(); + +public: + dxThreadingBase *getThreadingInstance() const { return m_relatedThreading; } + dCallWaitID getStockCallWait() const { return m_stockCallWait; } + void *getMemoryBufferPointer() const { return m_memoryAllocation.getUserAreaPointer(); } + sizeint getMemoryBufferSize() const { return m_memoryAllocation.getUserAreaSize(); } + +private: + dxThreadingBase *m_relatedThreading; + dCallWaitID m_stockCallWait; + dxAlignedAllocation m_memoryAllocation; +}; + +static inline +dxRequiredResourceContainer *decodeResourceContainerID(dResourceContainerID resources) +{ + return (dxRequiredResourceContainer *)resources; +} + + +#endif // #ifndef _ODE__PRIVATE_RESOURCE_CONTRIOL_H_ |