EIO_Status CConn_FtpStream::Drain(const STimeout* timeout) { const STimeout* r_timeout = kInfiniteTimeout/*0*/; const STimeout* w_timeout = kInfiniteTimeout/*0*/; CONN conn = GetCONN(); char block[1024]; if (conn) { size_t n; r_timeout = CONN_GetTimeout(conn, eIO_Read); w_timeout = CONN_GetTimeout(conn, eIO_Write); _VERIFY(SetTimeout(eIO_Read, timeout) == eIO_Success); _VERIFY(SetTimeout(eIO_Write, timeout) == eIO_Success); // Cause any upload-in-progress to abort CONN_Read (conn, block, sizeof(block), &n, eIO_ReadPlain); // Cause any command-in-progress to abort CONN_Write(conn, "NOOP\n", 5, &n, eIO_WritePersist); } clear(); while (read(block, sizeof(block))) ; if (!conn) return eIO_Closed; EIO_Status status; do { size_t n; status = CONN_Read(conn, block, sizeof(block), &n, eIO_ReadPersist); } while (status == eIO_Success); _VERIFY(CONN_SetTimeout(conn, eIO_Read, r_timeout) == eIO_Success); _VERIFY(CONN_SetTimeout(conn, eIO_Write, w_timeout) == eIO_Success); clear(); return status == eIO_Closed ? eIO_Success : status; }
void CConn_Streambuf::x_Init(const STimeout* timeout, size_t buf_size, CConn_IOStream::TConn_Flags flags, CT_CHAR_TYPE* ptr, size_t size) { _ASSERT(m_Status == eIO_Success); if (timeout != kDefaultTimeout) { _VERIFY(CONN_SetTimeout(m_Conn, eIO_Open, timeout) ==eIO_Success); _VERIFY(CONN_SetTimeout(m_Conn, eIO_ReadWrite, timeout) ==eIO_Success); _VERIFY(CONN_SetTimeout(m_Conn, eIO_Close, timeout) ==eIO_Success); } if (!(flags & (CConn_IOStream::fConn_ReadBuffered | CConn_IOStream::fConn_WriteBuffered))) { buf_size = 0; } if (buf_size) { m_WriteBuf = new CT_CHAR_TYPE[buf_size << ((flags & (CConn_IOStream::fConn_ReadBuffered | CConn_IOStream::fConn_WriteBuffered)) == (CConn_IOStream::fConn_ReadBuffered | CConn_IOStream::fConn_WriteBuffered) ? 1 : 0)]; if (flags & CConn_IOStream::fConn_ReadBuffered) m_BufSize = buf_size; if (!(flags & CConn_IOStream::fConn_WriteBuffered)) buf_size = 0; if (flags & CConn_IOStream::fConn_ReadBuffered) m_ReadBuf = m_WriteBuf + buf_size; } /* else see ctor */ if (buf_size) setp(m_WriteBuf, m_WriteBuf + buf_size); /* else setp(0, 0) */ if (ptr) setg(ptr, ptr, ptr + size); // Initial get area else setg(m_ReadBuf, m_ReadBuf, m_ReadBuf); // Empty get area SCONN_Callback cb; cb.func = x_OnClose; /* NCBI_FAKE_WARNING: WorkShop */ cb.data = this; CONN_SetCallback(m_Conn, eCONN_OnClose, &cb, &m_Cb); m_CbValid = true; }
static int idaapi init(void) { msg("\nLoadMap: Plugin init.\n\n"); // Get the full path of plugin WIN32CHECK(GetModuleFileName(g_hinstPlugin, g_szIniPath, sizeof(g_szIniPath))); g_szIniPath[sizeof(g_szIniPath) - 1] = '\0'; // Change the extension of plugin to '.ini' _VERIFY(PathRenameExtension(g_szIniPath, ".ini")); // Get options saved in ini file _VERIFY(GetPrivateProfileStruct(g_szLoadMapSection, g_szOptionsKey, &g_options, sizeof(g_options), g_szIniPath)); return PLUGIN_KEEP; }
static void idaapi term(void) { msg("LoadMap: Plugin terminate.\n"); // Write the plugin's options to ini file _VERIFY(WritePrivateProfileStruct(g_szLoadMapSection, g_szOptionsKey, &g_options, sizeof(g_options), g_szIniPath)); }
void CMutexPool::SetSize(int size) { _VERIFY(m_size==0 && !m_Locks); m_size = size; m_Locks = new CMutex[m_size]; spread = new int[m_size]; for ( int i = 0; i < m_size; ++i ) { spread[i]=0; } }
static TLastNewPtrMultiple& sx_GetLastNewPtrMultiple(void) { #ifdef NCBI_NO_THREADS return s_LastNewPtrMultiple; #else if ( !s_LastNewPtrMultiple_key ) { DEFINE_STATIC_FAST_MUTEX(s_InitMutex); NCBI_NS_NCBI::CFastMutexGuard guard(s_InitMutex); if ( !s_LastNewPtrMultiple_key ) { TTlsKey key = 0; do { # ifdef NCBI_WIN32_THREADS _VERIFY((key = TlsAlloc()) != DWORD(-1)); # else _VERIFY(pthread_key_create(&key, sx_EraseLastNewPtrMultiple)==0); # endif } while ( !key ); # ifndef NCBI_WIN32_THREADS pthread_setspecific(key, 0); # endif s_LastNewPtrMultiple_key = key; } } TLastNewPtrMultiple* set; # ifdef NCBI_WIN32_THREADS set = (TLastNewPtrMultiple*)TlsGetValue(s_LastNewPtrMultiple_key); # else set = (TLastNewPtrMultiple*)pthread_getspecific(s_LastNewPtrMultiple_key); # endif if ( !set ) { set = new TLastNewPtrMultiple(); # ifdef NCBI_WIN32_THREADS TlsSetValue(s_LastNewPtrMultiple_key, set); # else pthread_setspecific(s_LastNewPtrMultiple_key, set); # endif } return *set; #endif }
CGBLGuard::CGBLGuard(CGBLGuard &g,const char *loc) : m_Locks(g.m_Locks), m_Loc(g.m_Loc), m_orig(g.m_current), m_current(g.m_current), m_select(g.m_select) { if ( loc ) { m_Loc = loc; } _VERIFY(m_Locks); }
static VOID CdiagsDereferenceFormatter( __in PCDIAG_FORMATTER This ) { PCDIAGP_FORMATTER Formatter = ( PCDIAGP_FORMATTER ) This; _ASSERTE( CdiagsIsValidFormatter( Formatter ) ); if ( 0 == InterlockedDecrement( &Formatter->ReferenceCount ) ) { _VERIFY( S_OK == CdiagsDeleteFormatter( Formatter ) ); } }
int VideoEncoderFfmpeg::Encode(int force_key_frame, int *is_key_frame) { if (bitrate() < 0) return 0; frag_writer()->Clear(); frame_->pict_type = AV_PICTURE_TYPE_NONE != force_key_frame ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_NONE; int enc_size = avcodec_encode_video(context_, output_buffer(), output_buffer_size(), frame_); if (0 == enc_size) return 0; if (NULL != is_key_frame) *is_key_frame = frame_->key_frame; int size = 0; Fragmenter *fragmenter = GetFragmenter(); if (fragsize() > 0 && NULL != fragmenter) { #ifdef FRAG_FILE_DEBUG { static int frame_count_enc = 0; FILE *fd = NULL; char filename[50]; sprintf_s(filename, "out_enc_%03d.dbg", frame_count_enc); _VERIFY(0 == fopen_s(&fd, filename, "wb")); fwrite(output_buffer(), enc_size, 1, fd); fclose(fd); ++frame_count_enc; } #endif size = fragmenter->Fragment(output_buffer(), enc_size); } else { size = enc_size; _VERIFY(frag_writer()->AppendItem(output_buffer(), enc_size)); } *fragcount() = frag_writer()->frag_count(); return size; }
void CInterProcessLock::Unlock() { if (m_Handle == kInvalidLockHandle) { NCBI_THROW(CInterProcessLockException, eNotLocked, "Attempt to unlock not-yet-acquired lock"); } CFastMutexGuard LOCK(s_ProcessLock); // Check that lock with specified name not already locked // in the current process. TLocks::iterator it = s_Locks->find(m_SystemName); _VERIFY(it != s_Locks->end()); if ( it->second > 1 ) { // Just decrease reference counter it->second--; return; } // Release lock #if defined(NCBI_OS_UNIX) # if defined(F_TLOCK) int res = lockf(m_Handle, F_ULOCK, 0); # elif defined(F_SETLK) struct flock lockparam; lockparam.l_type = F_UNLCK; lockparam.l_whence = SEEK_SET; lockparam.l_start = 0; lockparam.l_len = 0; /* whole file */ int res = fcntl(m_Handle, F_SETLK, &lockparam); # else # error "No supported lock method. Please port this code." # endif if ( res < 0 ) { NCBI_THROW(CInterProcessLockException, eUnlockError, "Cannot release the lock"); } close(m_Handle); #elif defined(NCBI_OS_MSWIN) if ( !::ReleaseMutex(m_Handle) ) { NCBI_THROW(CInterProcessLockException, eUnlockError, "Cannot release the lock"); } ::CloseHandle(m_Handle); #endif m_Handle = kInvalidLockHandle; s_Locks->erase(m_SystemName); }
_f_int _F90_VERIFY( char *str1, char *str2, _f_int *back, _f_int len1, _f_int len2 ) { fcd_t fcd1, fcd2; fcd1.ptr = str1; fcd1.len = len1; fcd2.ptr = str2; fcd2.len = len2; return( _VERIFY( fcd1, fcd2, back ) ); }
void CDelayBuffer::DoUpdate(void) { _ASSERT(m_Info.get() != 0); SInfo& info = *m_Info; { auto_ptr<CObjectIStream> in(CObjectIStream::Create(info.m_DataFormat, *info.m_Source)); in->SetFlags(info.m_Flags); info.m_ItemInfo->UpdateDelayedBuffer(*in, info.m_Object); _VERIFY(in->EndOfData()); } m_Info.reset(0); }
void check_cnts(size_t expected = 0, size_t expected_static = 0) { if ( expected == ~0u ) { expected = 0; } else { expected = 1; } if ( expected == 0 ) { if ( alloc_count.Get() != expected-expected_static ) ERR_FATAL("alloc_count: "<<alloc_count.Get()); if ( object_count.Get() != expected ) ERR_FATAL("object_count: "<<object_count.Get()); } _VERIFY(!sx_HaveLastNewPtr()); }
streamsize CConn_Streambuf::showmanyc(void) { static const STimeout kZeroTmo = {0, 0}; _ASSERT(gptr() >= egptr()); if (!m_Conn) return -1L; // flush output buffer, if tied up to it if (m_Tie) x_sync(); const STimeout* tmo; const STimeout* timeout = CONN_GetTimeout(m_Conn, eIO_Read); if (timeout == kDefaultTimeout) { // HACK * HACK * HACK tmo = ((SMetaConnector*) m_Conn)->default_timeout; } else tmo = timeout; size_t x_read; bool backup = false; if (m_BufSize > 1) { if (eback() < gptr()) { x_Buf = gptr()[-1]; backup = true; } if (!tmo) _VERIFY(CONN_SetTimeout(m_Conn, eIO_Read, &kZeroTmo)==eIO_Success); m_Status = CONN_Read(m_Conn, m_ReadBuf + 1, m_BufSize - 1, &x_read, eIO_ReadPlain); if (!tmo) _VERIFY(CONN_SetTimeout(m_Conn, eIO_Read, timeout) ==eIO_Success); _ASSERT(x_read > 0 || m_Status != eIO_Success); } else { m_Status = CONN_Wait(m_Conn, eIO_Read, tmo ? tmo : &kZeroTmo); x_read = 0; } if (!x_read) { switch (m_Status) { case eIO_Success: _ASSERT(m_BufSize <= 1); return 1L; // can read at least 1 byte case eIO_Timeout: if (!tmo || !(tmo->sec | tmo->usec)) break; /*FALLTHRU*/ case eIO_Closed: return -1L; // EOF default: break; } return 0; // no data available immediately } m_ReadBuf[0] = x_Buf; _ASSERT(m_BufSize > 1); setg(m_ReadBuf + !backup, m_ReadBuf + 1, m_ReadBuf + 1 + x_read); x_GPos += x_read; return x_read; }
int CCompressionStreambuf::Flush(CCompressionStream::EDirection dir) { CSP* sp = GetStreamProcessor(dir); // Check processor's status if ( sp->m_LastStatus == CP::eStatus_Error ) { return -1; } if ( sp->m_LastStatus == CP::eStatus_EndOfData ) { // Flush underlying stream (on write) if (dir == CCompressionStream::eWrite && !WriteOutBufToStream(true /*force write*/)) { return -1; } // End of data, nothing to do return 0; } // Flush stream compressor CT_CHAR_TYPE* buf = 0; size_t out_size = 0, out_avail = 0; do { // Get pointer to the free space in the buffer if ( dir == CCompressionStream::eRead ) { buf = egptr(); } else { buf = sp->m_End; } out_size = sp->m_OutBuf + sp->m_OutBufSize - buf; // Get data from processor out_avail = 0; if ( sp->m_State == CSP::eFinalize ) { // State is eFinalize sp->m_LastStatus = sp->m_Processor->Finish(buf, out_size, &out_avail); } else { // State is eActive _VERIFY(sp->m_State == CSP::eActive); sp->m_LastStatus = sp->m_Processor->Flush(buf, out_size, &out_avail); // No more data -- automaticaly finalize stream if ( sp->m_LastStatus == CP::eStatus_EndOfData ) { sp->m_State = CSP::eFinalize; } } // Check on error if ( sp->m_LastStatus == CP::eStatus_Error ) { return -1; } if ( dir == CCompressionStream::eRead ) { // Update the get's pointers setg(sp->m_OutBuf, gptr(), egptr() + out_avail); } else { // CCompressionStream::eWrite // Update the output buffer pointer sp->m_End += out_avail; // Write data to the underlying stream only if the output buffer // is full or an overflow/endofdata occurs. if ( !WriteOutBufToStream() ) { return -1; } } } while (sp->m_LastStatus == CP::eStatus_Repeat || (out_avail && (sp->m_LastStatus == CP::eStatus_Success || sp->m_LastStatus == CP::eStatus_Overflow)) ); // Flush underlying stream (on write) if (dir == CCompressionStream::eWrite) { if ( sp->m_LastStatus == CP::eStatus_EndOfData || sp->m_State == CSP::eFinalize) { if ( !WriteOutBufToStream(true /*force write*/) ) { return -1; } } } return 0; }
void CId2Reader::x_RemoveConnectionSlot(TConn conn) { _VERIFY(m_Connections.erase(conn)); }
void CInterProcessLock::Lock(const CTimeout& timeout, const CTimeout& granularity) { CFastMutexGuard LOCK(s_ProcessLock); // Check that lock with specified name not already locked // in the current process. TLocks::iterator it = s_Locks->find(m_SystemName); if (m_Handle != kInvalidLockHandle) { // The lock is already set in this CInterProcessLock object, // just increase reference counter. _VERIFY(it != s_Locks->end()); it->second++; return; } else { if (it != s_Locks->end()) { // The lock already exists in the current process. // We can use one CInterProcessLock object with // multiple Lock() calls, but not with different // CInterProcessLock objects. For example, on MS-Windows, // we cannot wait on the same mutex in the same thread. // So, two different objects can set locks simultaneously. // And for OS-compatibility we can do nothing here, // except throwing an exception. NCBI_THROW(CInterProcessLockException, eMultipleLocks, "Attempt to lock already locked object " \ "in the same process"); } } // Try to acquire a lock with specified timeout #if defined(NCBI_OS_UNIX) // Open lock file mode_t perm = CDirEntry::MakeModeT( CDirEntry::fRead | CDirEntry::fWrite /* user */, CDirEntry::fRead | CDirEntry::fWrite /* group */, 0, 0 /* other & special */); int fd = open(m_SystemName.c_str(), O_CREAT | O_RDWR, perm); if (fd == -1) { NCBI_THROW(CInterProcessLockException, eCreateError, string("Error creating lockfile ") + m_SystemName + ": " + strerror(errno)); } // Try to acquire the lock int x_errno = 0; if (timeout.IsInfinite() || timeout.IsDefault()) { while ((x_errno = s_UnixLock(fd))) { if (errno != EAGAIN) break; } } else { unsigned long ms = timeout.GetAsMilliSeconds(); if ( !ms ) { // Timeout == 0 x_errno = s_UnixLock(fd); } else { // Timeout > 0 unsigned long ms_gran; if ( granularity.IsInfinite() || granularity.IsDefault() ) { ms_gran = min(ms/5, (unsigned long)500); } else { ms_gran = granularity.GetAsMilliSeconds(); } // Try to lock within specified timeout for (;;) { x_errno = s_UnixLock(fd); if ( !x_errno ) { // Successfully locked break; } if (x_errno != EACCES && x_errno != EAGAIN ) { // Error break; } // Otherwise -- sleep granularity timeout unsigned long ms_sleep = ms_gran; if (ms_sleep > ms) { ms_sleep = ms; } if ( !ms_sleep ) { break; } SleepMilliSec(ms_sleep); ms -= ms_sleep; } // Timeout if ( !ms ) { close(fd); NCBI_THROW(CInterProcessLockException, eLockTimeout, "The lock could not be acquired in the time " \ "allotted"); } } // if (!ms) } // if (timeout.IsInfinite()) // Error if ( x_errno ) { close(fd); NCBI_THROW(CInterProcessLockException, eLockError, "Error creating lock"); } // Success m_Handle = fd; #elif defined(NCBI_OS_MSWIN) HANDLE handle = ::CreateMutex(NULL, TRUE, _T_XCSTRING(m_SystemName)); errno_t errcode = ::GetLastError(); if (handle == kInvalidLockHandle) { switch(errcode) { case ERROR_ACCESS_DENIED: // Mutex with specified name already exists, // but we don't have enough rights to open it. NCBI_THROW(CInterProcessLockException, eLockError, "The lock already exists"); break; case ERROR_INVALID_HANDLE: // Some system object with the same name already exists NCBI_THROW(CInterProcessLockException, eLockError, "Error creating lock, system object with the same" \ "name already exists"); break; default: // Unknown error NCBI_THROW(CInterProcessLockException, eCreateError, "Error creating lock"); break; } } else { // Mutex with specified name already exists if (errcode == ERROR_ALREADY_EXISTS) { // Wait DWORD res; if (timeout.IsInfinite() || timeout.IsDefault()) { res = WaitForSingleObject(handle, INFINITE); } else { res = WaitForSingleObject(handle, timeout.GetAsMilliSeconds()); } switch(res) { case WAIT_OBJECT_0: // The lock has been acquired break; case WAIT_TIMEOUT: ::CloseHandle(handle); NCBI_THROW(CInterProcessLockException, eLockTimeout, "The lock could not be acquired in the time " \ "allotted"); break; case WAIT_ABANDONED: // The lock is in abandoned state... Other thread/process // owning it was terminated. We can reuse this mutex, but // it is better to wait until it will be released by OS. /* FALLTHRU */ default: ::CloseHandle(handle); NCBI_THROW(CInterProcessLockException, eLockError, "Error creating lock"); break; } } m_Handle = handle; } #endif // Set reference counter to 1 (*s_Locks)[m_SystemName] = 1; }
void CTestTlsObjectApp::RunTest(void) { const size_t OBJECT_SIZE = sizeof(CObjectWithNew); for ( int t = 0; t < 1; ++t ) { // prealloc { size_t size = (OBJECT_SIZE+16)*COUNT; void* p = ::operator new(size); memset(p, 1, size); ::operator delete(p); } { const size_t COUNT2 = COUNT*2; void** p = new void*[COUNT2]; for ( size_t i = 0; i < COUNT2; ++i ) { add_alloc(1); add_step(); p[i] = ::operator new(OBJECT_SIZE); } for ( size_t i = 0; i < COUNT2; ++i ) { add_alloc(-1); add_step(); ::operator delete(p[i]); } delete[] p; } { const size_t COUNT2 = COUNT*2; int** p = new int*[COUNT2]; for ( size_t i = 0; i < COUNT2; ++i ) { add_alloc(1); add_step(); p[i] = new int(int(i)); } for ( size_t i = 0; i < COUNT2; ++i ) { add_alloc(-1); add_step(); delete p[i]; } delete[] p; } } //return; CStopWatch sw; check_cnts(); for ( int t = 0; t < 1; ++t ) { void** ptr = new void*[COUNT]; sw.Start(); for ( size_t i = 0; i < COUNT; ++i ) { add_alloc(1); add_step(); ptr[i] = ::operator new(OBJECT_SIZE); } double t1 = sw.Elapsed(); sw.Start(); for ( size_t i = 0; i < COUNT; ++i ) { add_alloc(-1); add_step(); ::operator delete(ptr[i]); } double t2 = sw.Elapsed(); message("plain malloc", "create", t1, "delete", t2, COUNT); delete[] ptr; } check_cnts(); { sw.Start(); int* ptr = new int; sx_PushLastNewPtr(ptr, 2); double t1 = sw.Elapsed(); sw.Start(); _VERIFY(sx_PopLastNewPtr(ptr)); delete ptr; double t2 = sw.Elapsed(); message("tls", "set", t1, "get", t2, COUNT); } check_cnts(); { CObjectWithNew** ptr = new CObjectWithNew*[COUNT]; for ( size_t i = 0; i < COUNT; ++i ) { ptr[i] = 0; } sw.Start(); s_CurrentStep = "new CObjectWithNew"; s_CurrentInHeap = true; for ( size_t i = 0; i < COUNT; ++i ) { add_step(); ptr[i] = new CObjectWithNew; } s_CurrentInHeap = false; double t1 = sw.Elapsed(); check_cnts(COUNT); for ( size_t i = 0; i < COUNT; ++i ) { _ASSERT(ptr[i]->IsInHeap()); } sw.Start(); for ( size_t i = 0; i < COUNT; ++i ) { add_step(); CObjectWithNew::Delete(ptr[i]); } double t2 = sw.Elapsed(); message("new CObjectWithNew", "create", t1, "delete", t2, COUNT); delete[] ptr; } check_cnts(); { CObjectWithTLS** ptr = new CObjectWithTLS*[COUNT]; sw.Start(); s_CurrentStep = "new CObjectWithTLS"; s_CurrentInHeap = true; for ( size_t i = 0; i < COUNT; ++i ) { add_step(); try { switch ( rand()%3 ) { case 0: ptr[i] = new CObjectWithTLS; break; case 1: ptr[i] = new CObjectWithTLS2; break; case 2: ptr[i] = new CObjectWithTLS3; break; } } catch ( exception& ) { ptr[i] = 0; } _ASSERT(!sx_HaveLastNewPtr()); _ASSERT(!ptr[i] || ptr[i]->IsInHeap()); } s_CurrentInHeap = false; double t1 = sw.Elapsed(); check_cnts(COUNT); sw.Start(); for ( size_t i = 0; i < COUNT; ++i ) { add_step(); CObjectWithTLS::Delete(ptr[i]); } double t2 = sw.Elapsed(); message("new CObjectWithTLS", "create", t1, "delete", t2, COUNT); delete[] ptr; } check_cnts(); { CRef<CObjectWithRef>* ptr = new CRef<CObjectWithRef>[COUNT]; sw.Start(); s_CurrentStep = "new CObjectWithRef"; for ( size_t i = 0; i < COUNT; ++i ) { add_step(); try { switch ( rand()%2 ) { case 0: ptr[i] = new CObjectWithRef; break; case 1: ptr[i] = new CObjectWithRef2; break; } } catch ( exception& ) { ptr[i] = 0; } _ASSERT(!sx_HaveLastNewPtr()); _ASSERT(!ptr[i] || ptr[i]->CanBeDeleted()); } double t1 = sw.Elapsed(); check_cnts(COUNT); sw.Start(); for ( size_t i = 0; i < COUNT; ++i ) { add_step(); ptr[i].Reset(); } double t2 = sw.Elapsed(); message("new CObjectWithRef", "create", t1, "delete", t2, COUNT); delete[] ptr; } check_cnts(); { CObjectWithNew** ptr = new CObjectWithNew*[COUNT]; for ( size_t i = 0; i < COUNT; ++i ) { ptr[i] = 0; } sw.Start(); s_CurrentStep = "new CObjectWithNew()"; s_CurrentInHeap = true; for ( size_t i = 0; i < COUNT; ++i ) { add_step(); ptr[i] = new CObjectWithNew(); } s_CurrentInHeap = false; double t1 = sw.Elapsed(); check_cnts(COUNT); for ( size_t i = 0; i < COUNT; ++i ) { _ASSERT(ptr[i]->IsInHeap()); } sw.Start(); for ( size_t i = 0; i < COUNT; ++i ) { add_step(); CObjectWithNew::Delete(ptr[i]); } double t2 = sw.Elapsed(); message("new CObjectWithNew()", "create", t1, "delete", t2, COUNT); delete[] ptr; } check_cnts(); { CObjectWithTLS** ptr = new CObjectWithTLS*[COUNT]; sw.Start(); s_CurrentStep = "new CObjectWithTLS()"; s_CurrentInHeap = true; for ( size_t i = 0; i < COUNT; ++i ) { add_step(); try { switch ( rand()%4 ) { case 0: ptr[i] = new CObjectWithTLS(); break; case 1: ptr[i] = new CObjectWithTLS2(); break; case 2: ptr[i] = new CObjectWithTLS3(); break; case 3: ptr[i] = new CObjectWithTLS3(RecursiveNewTLS(rand()%4)); break; } } catch ( exception& ) { ptr[i] = 0; } _ASSERT(!sx_HaveLastNewPtr()); _ASSERT(!ptr[i] || ptr[i]->IsInHeap()); } s_CurrentInHeap = false; double t1 = sw.Elapsed(); check_cnts(COUNT); sw.Start(); for ( size_t i = 0; i < COUNT; ++i ) { add_step(); CObjectWithTLS::Delete(ptr[i]); } double t2 = sw.Elapsed(); message("new CObjectWithTLS()", "create", t1, "delete", t2, COUNT); delete[] ptr; } check_cnts(); { CRef<CObjectWithRef>* ptr = new CRef<CObjectWithRef>[COUNT]; sw.Start(); s_CurrentStep = "new CObjectWithRef()"; for ( size_t i = 0; i < COUNT; ++i ) { add_step(); try { size_t j = rand()%COUNT; switch ( rand()%4 ) { case 0: ptr[j] = new CObjectWithRef(); break; case 1: ptr[j] = new CObjectWithRef(RecursiveNewRef(rand()%4)); break; case 2: ptr[j] = new CObjectWithRef2(); break; case 3: ptr[j] = new CObjectWithRef2(RecursiveNewRef(rand()%4)); break; } } catch ( exception& ) { ptr[i] = 0; } _ASSERT(!sx_HaveLastNewPtr()); _ASSERT(!ptr[i] || ptr[i]->CanBeDeleted()); } double t1 = sw.Elapsed(); check_cnts(COUNT); sw.Start(); for ( size_t i = 0; i < COUNT; ++i ) { add_step(); ptr[i] = 0; } double t2 = sw.Elapsed(); message("new CObjectWithRef()", "create", t1, "delete", t2, COUNT); delete[] ptr; } check_cnts(); { sw.Start(); s_CurrentStep = "CObjectWithNew[]"; CArray<CObjectWithNew, COUNT>* arr = new CArray<CObjectWithNew, COUNT>; double t1 = sw.Elapsed(); check_cnts(COUNT, COUNT); for ( size_t i = 0; i < COUNT; ++i ) { _ASSERT(!arr->m_Array[i].IsInHeap()); } sw.Start(); delete arr; double t2 = sw.Elapsed(); message("static CObjectWithNew", "create", t1, "delete", t2, COUNT); } check_cnts(); { sw.Start(); s_CurrentStep = "CObjectWithTLS[]"; CArray<CObjectWithTLS, COUNT, false>* arr = new CArray<CObjectWithTLS, COUNT, false>; double t1 = sw.Elapsed(); check_cnts(COUNT, COUNT); for ( size_t i = 0; i < COUNT; ++i ) { _ASSERT(!arr->m_Array[i].IsInHeap()); } sw.Start(); delete arr; double t2 = sw.Elapsed(); message("static CObjectWithTLS", "create", t1, "delete", t2, COUNT); } check_cnts(); { sw.Start(); s_CurrentStep = "CObjectWithRef[]"; CArray<CObjectWithRef, COUNT, false>* arr = new CArray<CObjectWithRef, COUNT, false>; double t1 = sw.Elapsed(); check_cnts(COUNT, COUNT); for ( size_t i = 0; i < COUNT; ++i ) { _ASSERT(!arr->m_Array[i].CanBeDeleted()); } sw.Start(); delete arr; double t2 = sw.Elapsed(); message("static CObjectWithRef", "create", t1, "delete", t2, COUNT); } check_cnts(); }