HOT_FUNC_HPHP bool ZendArray::addLvalImpl(int64 h, Variant **pDest, bool doFind /* = true */) { ASSERT(pDest != NULL); Bucket *p; if (doFind) { p = findForInsert(h); if (p) { *pDest = &p->data; return false; } } p = NEW(Bucket)(); p->setIntKey(h); if (pDest) { *pDest = &p->data; } uint nIndex = (h & m_nTableMask); CONNECT_TO_BUCKET_LIST(p, m_arBuckets[nIndex]); SET_ARRAY_BUCKET_HEAD(m_arBuckets, nIndex, p); CONNECT_TO_GLOBAL_DLLIST(p); if (h >= m_nNextFreeElement && m_nNextFreeElement >= 0) { m_nNextFreeElement = h + 1; } if (++m_size > tableSize()) { resize(); } return true; }
//------------------------------------------------------------------------------ // setDataTable() -- for Table //------------------------------------------------------------------------------ bool Table::setDataTable(const List* const sdtobj) { bool ok = true; if (sdtobj != nullptr) { // First determine the size of the table -- ALL breakpoint data MUST // have been set first (order in input file) to determine the size // of the data table unsigned int ts = tableSize(); if (ts > 0) { // Allocate table space and load the table LCreal* p = new LCreal[ts]; ok = loadData(*sdtobj, p); if (ok) { // Loading completed, so // free up any old data and set to the new. if (dtable != nullptr) delete[] dtable; dtable = p; nd = ts; } else { // Something was wrong! delete[] p; std::cerr << "Table::setDataTable: Something is wrong! Data table aborted." << std::endl; ok = false; } } valid = isValid(); } return ok; }
unsigned int ofxLua::tableSize(const string& tableName) { unsigned int size = 0; pushTable(tableName); size = tableSize(); popTable(); return size; }
void ZendArray::rehash() { memset(m_arBuckets, 0, tableSize() * sizeof(Bucket*)); for (Bucket *p = m_pListHead; p; p = p->pListNext) { uint nIndex = (p->hashKey() & m_nTableMask); CONNECT_TO_BUCKET_LIST(p, m_arBuckets[nIndex]); SET_ARRAY_BUCKET_HEAD(m_arBuckets, nIndex, p); } }
HOT_FUNC_HPHP void ZendArray::resize() { uint newSize = tableSize() << 1; // No need to use calloc() or memset(), as rehash() is going to clear // m_arBuckets any way. if (m_arBuckets == m_inlineBuckets) { m_arBuckets = (Bucket**)malloc(newSize * sizeof(Bucket*)); } else { m_arBuckets = (Bucket **)realloc(m_arBuckets, newSize * sizeof(Bucket*)); } m_nTableMask = newSize - 1; rehash(); }
static void link_enums(void) { int i; for (i=0; i < tableSize(all_enums); ++i) { int j; enum_index_st * t = all_enums[i]; for (j=0; t[j].n != -1; ++j) { if (!t[j].e) { enum_index_st * e = bsearch(t + j, all_enum, tableSize(all_enum), sizeof(*all_enum), cmp_key); assert(e != NULL); t[j].e = e->e; } } } }
static const char * gl_lookup_enum_by_nr( int nr, enum_index_st * table, size_t size) { enum_index_st e, *f; e.n = nr; e.e = NULL; if (!(f = bsearch(&e, table, size, sizeof(*table), cmp_key))) f = bsearch(&e, all_enums, tableSize(all_enums), sizeof(*all_enums), cmp_key); return f ? f->e : NULL; }
bool ZendArray::nextInsertWithRef(CVarRef data) { int64 h = m_nNextFreeElement; Bucket * p = NEW(Bucket)(withRefBind(data)); p->setIntKey(h); uint nIndex = (h & m_nTableMask); CONNECT_TO_BUCKET_LIST(p, m_arBuckets[nIndex]); SET_ARRAY_BUCKET_HEAD(m_arBuckets, nIndex, p); CONNECT_TO_GLOBAL_DLLIST(p); m_nNextFreeElement = h + 1; if (++m_size > tableSize()) { resize(); } return true; }
void testJoining(struct htmlPage *rootPage) /* Simulate pressing buttons to get a reasonable join on a * couple of uniProt tables. */ { struct htmlPage *allPage, *page; char *org = NULL, *db = NULL, *group = "allTables", *track="uniProt"; int expectedCount = tableSize("uniProt", "taxon"); allPage = quickSubmit(rootPage, org, db, group, "uniProt", "uniProt.taxon", "taxonJoin1", NULL, NULL); if (allPage != NULL) { if (allPage->forms == NULL) { errAbort("uniProt page with no form"); } else { int count = testAllFields(allPage, allPage->forms, org, db, group, track, "uniProt.taxon"); if (count != expectedCount) qaStatusSoftError(tablesTestList->status, "Got %d rows in uniProt.taxon, expected %d", count, expectedCount); htmlPageSetVar(allPage, NULL, hgtaOutputType, "selectedFields"); page = quickSubmit(allPage, org, db, group, track, "uniProt.taxon", "taxonJoin2", hgtaDoTopSubmit, "submit"); htmlPageSetVar(page, NULL, "hgta_fs.linked.uniProt.commonName", "on"); serialSubmit(&page, org, db, group, track, NULL, "taxonJoin3", hgtaDoSelectFieldsMore, "submit"); if (page != NULL) { htmlPageSetVar(page, NULL, "hgta_fs.check.uniProt.taxon.binomial", "on"); htmlPageSetVar(page, NULL, "hgta_fs.check.uniProt.commonName.val", "on"); serialSubmit(&page, org, db, group, track, NULL, "taxonJoin4", hgtaDoPrintSelectedFields, "submit"); if (page != NULL) { checkExpectedSimpleRows(page, expectedCount); verifyJoinedFormat(page->htmlText); htmlPageFree(&page); } } } } htmlPageFree(&allPage); verbose(1, "Tested joining on uniProt.taxon & commonName\n"); }
void ZendArray::init(uint nSize) { uint size = MinSize; if (nSize >= 0x80000000) { size = 0x80000000; // prevent overflow } else { while (size < nSize) size <<= 1; } m_nTableMask = size - 1; if (size <= MinSize) { m_arBuckets = m_inlineBuckets; memset(m_inlineBuckets, 0, MinSize * sizeof(Bucket*)); } else { m_arBuckets = (Bucket **)calloc(tableSize(), sizeof(Bucket*)); } }
/** * Initialize the table to be empty. * @param n initial table size. */ void initialize(size_t n) { tableSize_ = tableSize(n); maxSize_ = tableSize_ * MAX_FILL / 100; size_ = 0; collisions_ = 0; if (tableSize_ <= tableCapacity_) { for (size_t i = 0; i < tableSize_; ++i) { table[i] = Entry(); } } else { tableCapacity_ = tableSize_; delete[] table; table = new Entry[tableCapacity_](); } }
HOT_FUNC_HPHP bool ZendArray::addValWithRef(StringData *key, CVarRef data) { int64 h = key->hash(); Bucket *p = findForInsert(key->data(), key->size(), h); if (p) { return false; } p = NEW(Bucket)(withRefBind(data)); p->setStrKey(key, h); uint nIndex = (h & m_nTableMask); CONNECT_TO_BUCKET_LIST(p, m_arBuckets[nIndex]); SET_ARRAY_BUCKET_HEAD(m_arBuckets, nIndex, p); CONNECT_TO_GLOBAL_DLLIST(p); if (++m_size > tableSize()) { resize(); } return true; }
bool ZendArray::nextInsertRef(CVarRef data) { if (m_nNextFreeElement < 0) { raise_warning("Cannot add element to the array as the next element is " "already occupied"); return false; } int64 h = m_nNextFreeElement; Bucket * p = NEW(Bucket)(strongBind(data)); p->setIntKey(h); uint nIndex = (h & m_nTableMask); CONNECT_TO_BUCKET_LIST(p, m_arBuckets[nIndex]); SET_ARRAY_BUCKET_HEAD(m_arBuckets, nIndex, p); CONNECT_TO_GLOBAL_DLLIST(p); m_nNextFreeElement = h + 1; if (++m_size > tableSize()) { resize(); } return true; }
HOT_FUNC_HPHP ArrayData *ZendArray::add(CStrRef k, CVarRef v, bool copy) { ASSERT(!exists(k)); if (UNLIKELY(copy)) { ZendArray *result = copyImpl(); result->add(k, v, false); return result; } int64 h = k->hash(); Bucket *p = NEW(Bucket)(v); p->setStrKey(k.get(), h); uint nIndex = (h & m_nTableMask); CONNECT_TO_BUCKET_LIST(p, m_arBuckets[nIndex]); SET_ARRAY_BUCKET_HEAD(m_arBuckets, nIndex, p); CONNECT_TO_GLOBAL_DLLIST(p); if (++m_size > tableSize()) { resize(); } return NULL; }
HOT_FUNC_HPHP bool ZendArray::addValWithRef(int64 h, CVarRef data) { Bucket *p = findForInsert(h); if (p) { return false; } p = NEW(Bucket)(withRefBind(data)); p->setIntKey(h); uint nIndex = (h & m_nTableMask); CONNECT_TO_BUCKET_LIST(p, m_arBuckets[nIndex]); SET_ARRAY_BUCKET_HEAD(m_arBuckets, nIndex, p); CONNECT_TO_GLOBAL_DLLIST(p); if (h >= m_nNextFreeElement && m_nNextFreeElement >= 0) { m_nNextFreeElement = h + 1; } if (++m_size > tableSize()) { resize(); } return true; }
bool ZendArray::updateRef(StringData *key, CVarRef data) { int64 h = key->hash(); Bucket *p = findForInsert(key->data(), key->size(), h); if (p) { p->data.assignRefHelper(data); return true; } p = NEW(Bucket)(strongBind(data)); p->setStrKey(key, h); uint nIndex = (h & m_nTableMask); CONNECT_TO_BUCKET_LIST(p, m_arBuckets[nIndex]); SET_ARRAY_BUCKET_HEAD(m_arBuckets, nIndex, p); CONNECT_TO_GLOBAL_DLLIST(p); if (++m_size > tableSize()) { resize(); } return true; }
/** * postSort() runs after sorting has been performed. For ZendArray, postSort() * handles rewiring the linked list according to the results of the sort. Also, * if resetKeys is true, postSort() will renumber the keys 0 thru n-1. */ void ZendArray::postSort(Bucket** buffer, bool resetKeys) { uint last = m_size-1; m_pListHead = buffer[0]; m_pListTail = buffer[last]; m_pos = (ssize_t)m_pListHead; Bucket* b = buffer[0]; b->pListLast = NULL; if (resetKeys) { memset(m_arBuckets, 0, tableSize() * sizeof(Bucket*)); for (uint i = 0; i < last; ++i) { Bucket* bNext = buffer[i+1]; b->pListNext = bNext; bNext->pListLast = b; if (b->hasStrKey() && b->skey->decRefCount() == 0) { DELETE(StringData)(b->skey); } b->setIntKey(i); uint nIndex = (i & m_nTableMask); CONNECT_TO_BUCKET_LIST(b, m_arBuckets[nIndex]); SET_ARRAY_BUCKET_HEAD(m_arBuckets, nIndex, b); b = bNext; } if (b->hasStrKey() && b->skey->decRefCount() == 0) { DELETE(StringData)(b->skey); } b->setIntKey(last); uint nIndex = (last & m_nTableMask); CONNECT_TO_BUCKET_LIST(b, m_arBuckets[nIndex]); SET_ARRAY_BUCKET_HEAD(m_arBuckets, nIndex, b); m_nNextFreeElement = m_size; } else { for (uint i = 0; i < last; ++i) { Bucket* bNext = buffer[i+1]; b->pListNext = bNext; bNext->pListLast = b; b = bNext; } } b->pListNext = NULL; }
HOT_FUNC_HPHP ArrayData *ZendArray::add(int64 k, CVarRef v, bool copy) { ASSERT(!exists(k)); if (UNLIKELY(copy)) { ZendArray *result = copyImpl(); result->add(k, v, false); return result; } Bucket *p = NEW(Bucket)(v); p->setIntKey(k); uint nIndex = (k & m_nTableMask); CONNECT_TO_BUCKET_LIST(p, m_arBuckets[nIndex]); SET_ARRAY_BUCKET_HEAD(m_arBuckets, nIndex, p); CONNECT_TO_GLOBAL_DLLIST(p); if (k >= m_nNextFreeElement && m_nNextFreeElement >= 0) { m_nNextFreeElement = k + 1; } if (++m_size > tableSize()) { resize(); } return NULL; }
bool ZendArray::updateRef(int64 h, CVarRef data) { Bucket *p = findForInsert(h); if (p) { p->data.assignRefHelper(data); return true; } p = NEW(Bucket)(strongBind(data)); p->setIntKey(h); uint nIndex = (h & m_nTableMask); CONNECT_TO_BUCKET_LIST(p, m_arBuckets[nIndex]); SET_ARRAY_BUCKET_HEAD(m_arBuckets, nIndex, p); CONNECT_TO_GLOBAL_DLLIST(p); if (h >= m_nNextFreeElement && m_nNextFreeElement >= 0) { m_nNextFreeElement = h + 1; } if (++m_size > tableSize()) { resize(); } return true; }
HOT_FUNC_HPHP bool ZendArray::addLvalImpl(StringData *key, int64 h, Variant **pDest, bool doFind /* = true */) { ASSERT(key != NULL && pDest != NULL); Bucket *p; if (doFind) { p = findForInsert(key->data(), key->size(), h); if (p) { *pDest = &p->data; return false; } } p = NEW(Bucket)(); p->setStrKey(key, h); *pDest = &p->data; uint nIndex = (h & m_nTableMask); CONNECT_TO_BUCKET_LIST(p, m_arBuckets[nIndex]); SET_ARRAY_BUCKET_HEAD(m_arBuckets, nIndex, p); CONNECT_TO_GLOBAL_DLLIST(p); if (++m_size > tableSize()) { resize(); } return true; }
TEST_F(TpccTableLoadTests, table_load_with_header_file_test_warehouse) { ASSERT_EQ(2u,tableSize("warehouse")); }
TEST_F(TpccTableLoadTests, table_load_with_header_file_test_orders) { ASSERT_EQ(45u,tableSize("orders")); }
TEST_F(TpccTableLoadTests, table_load_with_header_file_test_stock) { ASSERT_EQ(30u,tableSize("stock")); }
TEST_F(TpccTableLoadTests, table_load_with_header_file_test_item) { ASSERT_EQ(15u,tableSize("item")); }
TEST_F(TpccTableLoadTests, table_load_with_header_file_test_order_line) { ASSERT_EQ(225u,tableSize("order_line")); }
TEST_F(TpccTableLoadTests, table_load_with_header_file_test_history) { ASSERT_EQ(45u,tableSize("history")); }
TEST_F(TpccTableLoadTests, table_load_with_header_file_test_district) { ASSERT_EQ(20u,tableSize("district")); }
TEST_F(TpccTableLoadTests, table_load_with_header_file_test_customer) { ASSERT_EQ(45u,tableSize("customer")); }
// ----------------------------------------------------------------------------- // CSatTimer::Tick // Static callback method for CPeriodic timer. // (other items were commented in a header). // ----------------------------------------------------------------------------- // TInt CSatTimer::Tick ( TAny* aSatTimer ) { // Logging omitted to avoid excessive log output // This is a static method, we need a pointer to parent class in // order to utilize it's method and members CSatTimer* satTimer = static_cast<CSatTimer*>( aSatTimer ); // Invert boolean value of half second boolean satTimer->iHalfSecondTick = !satTimer->iHalfSecondTick; // Update second counter and check timers only when there are active // timers and whole second has passed since last update. TInt tableSize( satTimer->iTimerTable->Count() ); if ( KZero != tableSize && !satTimer->iHalfSecondTick ) { satTimer->iSecondsPassed++; TFLOGSTRING2("TSY: CSatTimer::Tick, seconds %d", satTimer->iSecondsPassed ); OstTrace1( TRACE_INTERNALS, CSATTIMER_TICK_TD, "CSatTimer::Tick, seconds %u", satTimer->iSecondsPassed ); for( TInt i = tableSize - 1; KZero <= i; i-- ) { // Get reference to a timer in TimerTable TTimer& timer = ( *satTimer->iTimerTable )[i]; // Send timer expiration envelope if: // 1) Enough time has passed // 2) Timer is active // 3) Proactive command is not ongoing if ( timer.TimeStamp() <= satTimer->iSecondsPassed && TTimer::ETicking == timer.State() ) { // Deactive timer to avoid multiple envelopes timer.SetState( TTimer::EBeingSent); // Elapsed time TInt time( satTimer->iSecondsPassed - timer.StartTime() ); satTimer->iSatMessaging->TimerExpiration( timer.Id(), time ); } } } // Handle the stored envelopes. Look for envelopes activated for resending. // Resend the oldest envelope if delay criteria has been met. tableSize = satTimer->iEnvelopeTable->Count(); TBool done( EFalse ); if ( KZero != tableSize ) { for ( TInt i = 0 ; i < tableSize && done == EFalse ; i++ ) { TSatEnvelope& current = ( *satTimer->iEnvelopeTable )[i]; if ( current.iActive ) { // Active envelope found. Decrease delay and send envelope // if zero. current.iDelay--; if ( KZero >= current.iDelay ) { TFLOGSTRING2("TSY: CSatTimer::Tick: \ Resending type %x envelope", current.iType ); OstTraceExt1( TRACE_INTERNALS, DUP1_CSATTIMER_TICK_TD, "CSatTimer::Tick Resending type %hhu envelope", current.iType ); // Deactivate envelope just in case. Get new transaction // if for envelope and resend it. Finally remove the // envelope from table. current.iActive = EFalse; satTimer->iSatMessHandler->UiccCatReqEnvelope( current.iTId, current.iEnvelope, EFalse ); satTimer->RemoveEnvelope( current.iTId ); tableSize = satTimer->iEnvelopeTable->Count(); // Exit resending loop, only one resent envelope per tick done = ETrue; } } // If active } // For-loop
static inline const char * gl_lookup_error_by_nr(int error) { const int size = tableSize(_ErrorCode_enum_); return gl_lookup_enum_by_nr(error, _ErrorCode_enum_, size); }