OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-05 18:16:23 +03:00
Code Packages Releases Activity

0026551: Optimization of initialization of OCCT RTTI

Browse Source 
Global instances of type descriptors are eliminated as unnecessary
This commit is contained in:
abv 2015-12-12 19:07:35 +03:00 committed by bugmaster
parent a0218ba1c5
commit 795be040eb
2 changed files with 10 additions and 18 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
src/Standard/Standard_Type.cxx
View File

@ -37,8 +37,10 @@ Standard_Type::Standard_Type (const char* theSystemName,
const char* theName, const char* theName,
Standard_Size theSize, Standard_Size theSize,
const Handle(Standard_Type)& theParent) : const Handle(Standard_Type)& theParent) :
mySystemName (copy_string (theSystemName)), mySystemName(copy_string (theSystemName)),
myName(theName), mySize(theSize), myParent(theParent) myName(copy_string (theName)),
mySize(theSize),
myParent(theParent)
{ {
} }
@ -127,4 +129,5 @@ Standard_Type::~Standard_Type ()
// cout << "Unregistering " << mySystemName << ": " << aRegistry.Extent() << endl; // cout << "Unregistering " << mySystemName << ": " << aRegistry.Extent() << endl;
Standard::Free (mySystemName); Standard::Free (mySystemName);
Standard::Free (myName);
} }

21
src/Standard/Standard_Type.hxx
View File

@ -57,7 +57,7 @@ public: \
// forward declaration of type_instance class // forward declaration of type_instance class
namespace opencascade { namespace opencascade {
template <typename T> template <typename T>
class type_instance; struct type_instance;
} }
//! This class provides legacy interface (type descriptor) to run-time type //! This class provides legacy interface (type descriptor) to run-time type
@ -156,22 +156,18 @@ namespace opencascade {
//! Template class providing instantiation of type descriptors as static //! Template class providing instantiation of type descriptors as static
//! variables (one per binary module). Having type descriptors defined as //! variables (one per binary module). Having type descriptors defined as
//! static variables is essential to ensure that everything gets initialized //! static variables is essential to ensure that descriptors are initialized
//! during library loading and thus no concurrency occurs when type system //! once and in correct order.
//! is accessed from multiple threads.
template <typename T> template <typename T>
class type_instance struct type_instance
{ {
static Handle(Standard_Type) myInstance;
public:
static const Handle(Standard_Type)& get (); static const Handle(Standard_Type)& get ();
}; };
//! Specialization of type descriptor instance for void; returns null handle //! Specialization of type descriptor instance for void; returns null handle
template <> template <>
class type_instance<void> struct type_instance<void>
{ {
public:
Standard_EXPORT static Handle(Standard_Type) get () { return 0; } Standard_EXPORT static Handle(Standard_Type) get () { return 0; }
}; };
@ -180,8 +176,6 @@ namespace opencascade {
template <typename T> template <typename T>
const Handle(Standard_Type)& type_instance<T>::get () const Handle(Standard_Type)& type_instance<T>::get ()
{ {
(void)myInstance; // ensure that myInstance is instantiated
// static variable inside function ensures that descriptors // static variable inside function ensures that descriptors
// are initialized in correct sequence // are initialized in correct sequence
static Handle(Standard_Type) anInstance = static Handle(Standard_Type) anInstance =
@ -190,11 +184,6 @@ namespace opencascade {
return anInstance; return anInstance;
} }
// Static class field is defined to ensure initialization of all type
// descriptors at load time of the library
template <typename T>
Handle(Standard_Type) type_instance<T>::myInstance (get());
} }
//! Operator printing type descriptor to stream //! Operator printing type descriptor to stream