Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from http://www.ncbi.nlm.nih.gov/IEB/ToolBox/CPP_DOC/doxyhtml/ncbiobj_8cpp_source.html below:

NCBI C++ ToolKit: src/corelib/ncbiobj.cpp Source File

m_Value +=

;

TlsSetValue(

,

);

pthread_setspecific(

,

);

TlsSetValue(

,

);

pthread_setspecific(

, 0);

pthread_setspecific(

,

);

( it->first == ptr ) {

s_LastNewPtr =

.front().first;

( s_LastNewPtr ) {

s_LastNewType =

;

* last_ptr = s_LastNewPtr;

( s_LastNewPtr != ptr ) {

* single_alloc_pool = 0;

single_alloc_pool_size = 0;

* single_alloc(

)

(

> SINGLE_ALLOC_THRESHOLD ) {

return ::operator

(

);

sx_SingleAllocMutex.Lock();

pool_size = single_alloc_pool_size;

(

> pool_size ) {

pool_size = SINGLE_ALLOC_POOL_SIZE;

pool = (

*)

(pool_size);

sx_SingleAllocMutex.Unlock();

single_alloc_pool = pool;

single_alloc_pool_size = pool_size;

pool = single_alloc_pool;

single_alloc_pool = pool +

;

single_alloc_pool_size = pool_size -

;

sx_SingleAllocMutex.Unlock();

*

= ::getenv(

);

memset(ptr, 0,

);

* CObject::operator

(

)

* ptr = single_alloc(

);

* ptr = ::operator

(

);

s_heap_obj->push_front(ptr);

CObject::operator

(

* ptr)

magic =

*

(ptr)->m_Counter;

::operator

(ptr);

* CObject::operator

(

,

* place)

CObject::operator

(

*

(ptr),

*

)

( !memory_pool ) {

(

);

* ptr = memory_pool->Allocate(

);

(

);

magic =

*

(ptr)->m_Counter;

memory_pool->Deallocate(ptr);

* CObject::operator

[](

)

* ptr = ::operator

(

);

* ptr = ::operator

[](

);

CObject::operator

[](

* ptr)

::operator

(ptr);

::operator

[](ptr);

<<

<<

<<StackTrace);

inStack =

;

* ptr =

*

(

);

list<const void*>::iterator

=

find( s_heap_obj->begin(), s_heap_obj->end(), ptr);

inStack = (

== s_heap_obj->end());

s_heap_obj->erase(

);

inStack = GetSecondCounter(

)->m_Value != main_counter;

* stackObjectPtr = &stackObject;

* objectPtr =

*

(

);

(objectPtr < stackObjectPtr) &&

(objectPtr > stackObjectPtr) &&

<<StackTrace);

<<StackTrace);

<<StackTrace);

);

);

);

<<StackTrace);

<<StackTrace);

<<StackTrace);

);

);

);

);

);

);

eCheckBits = eStateBitsValid | eStateBitsHeapSignature;

( (

& eCheckBits) == eCheckBits ) {

( !(

& eStateBitsInHeap) ) {

<<StackTrace);

);

);

( TAbortOnNull::GetDefault() ) {

( TAbortOnNull::GetDefault() ) {

(

)+

.

());

total_locks = 0;

<<it->first<<

<<

<<

<< *it->second);

total_unlocks = 0;

<<it->first<<

<<

<<

<< *it->second);

( total_locks ) {

( total_unlocks ) {

[object].Locked(locker,

);

->AddReference();

->RemoveReference();

(

<<

<<

(*object).name()<<

<<

<<

<<

<<

<< StackTrace);

->ReleaseReference();

<<

.

()<<

);

:

;

:

;

: m_Ptr(

), m_WeakPtr(ptr)

<<

.

()<<

);

s_EnvFlag(

* env_var_name)

*

= getenv(env_var_name);

seq_number;

seq_number;

kAllocSizeBefore = 32;

kAllocSizeAfter = 32;

kAllocFillBeforeArray = 0xba;

kAllocFillBeforeOne = 0xbb;

kAllocFillInside = 0xdd;

kAllocFillAfter = 0xaa;

kAllocFillFree = 0xee;

kAllocMagicHeader = 0x8b9b0b0b;

kAllocMagicFooter = 0x9e8e0e0e;

kFreedMagicHeader = 0x8b0bdead;

kFreedMagicFooter = 0x9e0edead;

NCBI_NS_NCBI::CAtomicCounter seq_number;

kLogSize = 64 * 1024;

seq_number;

SAllocLog alloc_log[kLogSize];

SAllocHeader* get_header(

* ptr)

(SAllocHeader*) ((

*) ptr-kAllocSizeBefore);

* get_guard_before(SAllocHeader* header)

(

*) header +

(SAllocHeader);

get_guard_before_size()

kAllocSizeBefore -

(SAllocHeader);

get_extra_size(

)

(-

) & 7;

get_guard_after_size(

)

kAllocSizeAfter -

(SAllocFooter) + get_extra_size(

);

* get_ptr(SAllocHeader* header)

(

*) header + kAllocSizeBefore;

* get_guard_after(SAllocFooter* footer,

)

(

*)footer-get_guard_after_size(

);

SAllocFooter* get_footer(SAllocHeader* header,

)

(SAllocFooter*)((

*)get_ptr(header)+

+get_guard_after_size(

));

get_total_size(

)

+get_extra_size(

) + (kAllocSizeBefore+kAllocSizeAfter);

get_all_guards_size(

)

get_total_size(

) - (

(SAllocHeader)+

(SAllocFooter));

SAllocLog& start_log(

, SAllocLog::EType

)

SAllocLog& slot = alloc_log[

% kLogSize];

slot.type = SAllocLog::eInit;

slot.completed =

;

slot.seq_number =

;

memchk(

* ptr,

,

)

(

* p = (

*)ptr;

; ++p, --

) {

* s_alloc_mem(

,

)

()

= seq_number.Add(1);

SAllocHeader* header;

.completed =

;

SAllocFooter* footer = get_footer(header,

);

header->magic = kAllocMagicHeader;

footer->magic = kAllocMagicFooter;

header->seq_number = footer->seq_number =

;

header->size = footer->size =

;

header->ptr = footer->ptr =

.ptr = get_ptr(header);

std::memset(get_guard_before(header),

? kAllocFillBeforeArray: kAllocFillBeforeOne,

get_guard_before_size());

std::memset(get_guard_after(footer,

),

get_guard_after_size(

));

std::memset(get_ptr(header), kAllocFillInside,

);

.completed =

;

get_ptr(header);

s_free_mem(

* ptr,

)

= seq_number.Add(1);

start_log(

,

? SAllocLog::eDeleteArr: SAllocLog::eDelete);

SAllocHeader* header = get_header(ptr);

( header->magic != kAllocMagicHeader ||

header->seq_number >=

||

header->ptr != get_ptr(header) ) {

=

.size = header->size;

SAllocFooter* footer = get_footer(header,

);

( footer->magic != kAllocMagicFooter ||

footer->seq_number != header->seq_number ||

footer->ptr != get_ptr(header) ||

footer->size !=

) {

memchk(get_guard_before(header),

? kAllocFillBeforeArray: kAllocFillBeforeOne,

get_guard_before_size());

memchk(get_guard_after(footer,

),

get_guard_after_size(

));

header->magic = kFreedMagicHeader;

footer->magic = kFreedMagicFooter;

footer->seq_number =

;

no_clear = s_EnvFlag(

);

std::memset(get_guard_before(header),

get_all_guards_size(

));

no_free = s_EnvFlag(

);

.completed =

;

*

(

)

(std::bad_alloc)

* ret = s_alloc_mem(

,

);

std::bad_alloc();

*

(

,

std::nothrow_t&)

()

s_alloc_mem(

,

);

*

[](

)

(std::bad_alloc)

* ret = s_alloc_mem(

,

);

std::bad_alloc();

*

[](

,

std::nothrow_t&)

()

s_alloc_mem(

,

);

(

* ptr)

()

s_free_mem(ptr,

);

(

* ptr,

std::nothrow_t&)

()

s_free_mem(ptr,

);

[](

* ptr)

()

s_free_mem(ptr,

);

[](

* ptr,

std::nothrow_t&)

()

s_free_mem(ptr,

);

@ eEmpty

no filtering at all.

void SetFrame(const string &frame)

void Log(const string &name, const char *value, CDebugDumpFormatter::EValueType type=CDebugDumpFormatter::eValue, const string &comment=kEmptyStr)

void DumpLocks(bool clear=false)

void Unlocked(const CObjectCounterLocker *locker, const CObject *object)

void Locked(const CObjectCounterLocker *locker, const CObject *object)

map< const CObject *, SLocks > TLocks

const_iterator lower_bound(const key_type &key) const

const_iterator end() const

iterator insert(const value_type &val)

container_type::iterator iterator

container_type::value_type value_type

#define ITERATE(Type, Var, Cont)

ITERATE macro to sequence through container elements.

#define NON_CONST_ITERATE(Type, Var, Cont)

Non constant version of ITERATE macro.

void swap(NCBI_NS_NCBI::pair_base_member< T1, T2 > &pair1, NCBI_NS_NCBI::pair_base_member< T1, T2 > &pair2)

TNCBIAtomicValue TValue

Alias TValue for TNCBIAtomicValue.

TValue Add(int delta) THROWS_NONE

Atomically add value (=delta), and return new counter value.

#define ERR_FATAL_X(err_subcode, message)

NCBI_XNCBI_EXPORT void Abort(void)

Smart abort function.

#define ERR_POST_X(err_subcode, message)

Error posting with default error code and given error subcode.

#define ERR_POST(message)

Error posting with file, line number information but without error codes.

@ eDiag_Critical

Critical error message.

void Error(CExceptionArgs_Base &args)

#define NCBI_EXCEPTION_VAR(name, exception_class, err_code, message)

Create an instance of the exception to be thrown later.

#define NCBI_THROW(exception_class, err_code, message)

Generic macro to throw an exception, given the exception class, error code and message string.

#define NCBI_EXCEPTION_THROW(exception_var)

Throw an existing exception object.

virtual void x_InitErrCode(CException::EErrCode err_code)

Helper method for initializing error code.

#define THROWS_NONE

Do not use 'throw' dynamic exception specification for C++11 compilers.

EErrCode

Error types that an application can generate.

TErrCode GetErrCode(void) const

#define NCBI_THROW_FMT(exception_class, err_code, message)

The same as NCBI_THROW but with message processed as output to ostream.

virtual const char * GetErrCodeString(void) const

Get error code interpreted as text.

void RemoveLastReference(TCount count) const

Remove the last reference.

void TransferLock(const CObject *object, const CObjectCounterLocker &old_locker) const

static const int eCounterStep

Skip over the "in heap" bits.

void Clear(void)

Set pointer to NULL from object's destructor.

void CleanWeakRefs(void) const

Method cleaning all CWeakRefs referencing at this moment to the object After calling to this method a...

Uint8 TCount

Alias for value type of counter.

static void ReportLockedObjects(bool clear=false)

Print all currently locked objects of monitored type.

virtual void DoDeleteThisObject(void)

Mark this object as allocated in heap – object can be deleted.

static void StopMonitoring(void)

Stop lock/unlock monitoring.

EAllocFillMode

Control filling of newly allocated memory.

virtual const char * GetErrCodeString(void) const override

Translate from the error code value to its string representation.

static void SetAllocFillMode(EAllocFillMode mode)

CPtrToObjectProxy(CWeakObject *ptr)

static EAllocFillMode GetAllocFillMode(void)

void InitCounter(void)

Initialize counter.

bool x_AddWeakReference(CObject *obj)

Add reference to the object in "weak" manner.

virtual ~CObject(void)

Destructor.

virtual void DoNotDeleteThisObject(void)

Mark this object as not allocated in heap – do not delete this object.

void Relock(const CObject *object) const

void ReleaseReference(void) const

Remove reference without deleting object.

static bool ObjectStateReferencedOnlyOnce(TCount count)

Check if object can be referenced only once.

static NCBI_XNCBI_EXPORT void ThrowNullPointerException(void)

Define method to throw null pointer exception.

virtual void DebugDump(CDebugDumpContext ddc, unsigned int depth) const

Define method for dumping debug information.

virtual ~CWeakObject(void)

static const TCount eCounterBitsCanBeDeleted

Define possible object states.

void Reset(void)

Reset reference object.

void x_InitErrCode(CException::EErrCode err_code) override

Helper method for initializing error code.

void UnlockRelease(const CObject *object) const

virtual void DeleteThis(void)

Virtual method "deleting" this object.

static bool ObjectStateValid(TCount count)

Check if object state is valid.

static bool ObjectStateReferenced(TCount count)

Check if object can be referenced.

NCBI_XNCBI_EXPORT void CheckReferenceOverflow(TCount count) const

Report that counter has overflowed.

static void Delete(const CObject *object)

Check if object is allocated from some memory pool, and delete it correspondingly.

static bool ObjectStateIsAllocatedInPool(TCount count)

Check if object is allocated in memory pool.

static void ReportIncompatibleType(const type_info &type)

static const TCount eCounterValid

Minimal value for valid objects (reference counter is zero) Must be a single bit value.

static void MonitorObjectType(const type_info &type)

Set monitored object type, e.g.

CRef< CPtrToObjectProxy > m_SelfPtrProxy

Proxy object with pointer to this instance.

friend class CPtrToObjectProxy

CObject * GetLockedObject(void)

Lock the object and return pointer to it.

void Unlock(const CObject *object) const

atomic< Uint8 > TCounter

Counter type is CAtomiCounter.

static bool ObjectStateCanBeDeleted(TCount count)

Check if object can be deleted.

void Lock(const CObject *object) const

CObject(void)

Constructor.

static NCBI_XNCBI_EXPORT void ReportIncompatibleType(const type_info &type)

Report about trying to convert incompatible interface fo CObject.

static const TCount eCounterBitsInPlainHeap

Heap signature was found.

TCounter m_Counter

The actual reference counter.

static bool ObjectStateUnreferenced(TCount count)

Check if object can be referenced.

static const TCount eCounterStateMask

Valid object, and object in heap.

@ eDeleted

Attempt to delete a deleted object.

@ eRefDelete

Attempt to delete valid reference.

@ eCorrupted

Object corrupted error.

@ eRefOverflow

Reference overflow error.

@ eHeapState

Attempt to make incorrect in-heap state.

@ eRefUnref

Attempt to make a referenced object an unreferenced one.

@ eNoRef

Attempt to access an object that is unreferenced.

@ eParam_NoThread

Do not use per-thread values.

#define END_NCBI_SCOPE

End previously defined NCBI scope.

#define BEGIN_NCBI_SCOPE

Define ncbi namespace.

static int CompareNocase(const CTempString s1, SIZE_TYPE pos, SIZE_TYPE n, const char *s2)

Case-insensitive compare of a substring with another string.

TFastMutexGuard CFastMutexGuard

...and backward compatibility

pthread_key_t TTlsKey

Define internal TLS key type.

unsigned int

A callback function used to compare two keys in a database.

Definition of all error codes used in corelib (xncbi.lib).

where both of them are integers Note

const struct ncbi::grid::netcache::search::fields::SIZE size

const struct ncbi::grid::netcache::search::fields::KEY key

const GenericPointer< typename T::ValueType > T2 value

static void s_Cleanup(void *data)

Static variables safety - create on demand, destroy on application termination.

#define NCBI_CONST_UINT8(v)

Memory pool for fast allocation of memory for localized set of CObjects, e.g.

Multi-threading – mutexes; rw-locks; semaphore.

#define ALLOC_FILL_BYTE_PATTERN

static DECLARE_TLS_VAR(void *, s_LastNewPtr)

static CObject::EAllocFillMode sx_InitFillNewMemoryMode(void)

static const CObject::TCount eInitCounterInHeap

Initial counter value for in-heap objects.

static const CObject::TCount eMagicCounterPoolNew

Magic counter value for objects allocated in memory pool.

static void sx_PushLastNewPtrMultiple(void *ptr, CAtomicCounter::TValue type)

static TTlsKey sx_GetLastNewPtrMultipleKey(void)

static void sx_FillNewMemory(void *ptr, size_t size)

bool MonitoredType(const CObject *object)

static CObject::EAllocFillMode sm_AllocFillMode

static const CObject::TCount eInitCounterInPool

Initial counter value for objects allocated in memory pool.

static CAtomicCounter::TValue sx_PopLastNewPtrMultiple(void *ptr)

static const CAtomicCounter::TValue kLastNewTypeMultiple

#define ALLOC_FILL_MODE_INIT

NCBI_PARAM_DEF_EX(bool, NCBI, ABORT_ON_COBJECT_THROW, false, eParam_NoThread, NCBI_ABORT_ON_COBJECT_THROW)

static CSafeStatic< CLocksMonitor > sx_LocksMonitor

static TLastNewPtrMultiple & sx_GetLastNewPtrMultiple(void)

static const CObject::TCount eMagicCounterNew

Magic counter value for object allocated in heap.

NCBI_PARAM_DECL(bool, NCBI, ABORT_ON_COBJECT_THROW)

#define ALLOC_FILL_MODE_DEFAULT

static const CObject::TCount eMagicCounterPoolDeleted

Magic counter value for deleted object allocated in memory pool.

typedef NCBI_PARAM_TYPE(NCBI, ABORT_ON_NULL) TAbortOnNull

static bool sm_AllocFillMode_IsSet

static CAtomicCounter::TValue sx_PopLastNewPtr(void *ptr)

static const type_info * sx_MonitorType

static const CObject::TCount eMagicCounterDeleted

All magic counter values should have all their state bits off.

vector< TLastNewPtrMultipleInfo > TLastNewPtrMultiple

static void sx_PushLastNewPtr(void *ptr, CAtomicCounter::TValue type)

DEFINE_STATIC_FAST_MUTEX(s_WeakRefMutex)

pair< void *, CAtomicCounter::TValue > TLastNewPtrMultipleInfo

static const CObject::TCount eInitCounterNotInHeap

Initial counter value for non-heap objects.

static atomic< TTlsKey > s_LastNewPtrMultiple_key

static TTlsKey sx_GetLastNewPtrMultipleCurrentKey(void)

Portable reference counted smart and weak pointers using CWeakRef, CRef, CObject and CObjectEx.

Multi-threading – classes, functions, and features.

Int4 delta(size_t dimension_, const Int4 *score_)

multimap< const CObjectCounterLocker *, AutoPtr< CStackTrace > > TUnlocks

int LockCount(void) const

multimap< const CObjectCounterLocker *, AutoPtr< CStackTrace > > TLocks

void Locked(const CObjectCounterLocker *locker, const CObject *object)

bool Unlocked(const CObjectCounterLocker *locker)

static void sx_Cleanup(void *ptr)

~SEraseLastNewPtrMultiple()

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4