C++ PersistentTable::activeTupleCount方法代码示例

bool TableStreamer::activateStream(PersistentTable &table, CatalogId tableId)
{
    if (m_context == NULL) {
        // This is the only place that can create a streaming context based on
        // the stream type. Other places shouldn't need to know about the
        // context sub-types.
        try {
            switch (m_streamType) {
                case TABLE_STREAM_SNAPSHOT: {
                    // Constructor can throw exception when it parses the predicates.
                    CopyOnWriteContext *newContext =
                        new CopyOnWriteContext(table, m_tupleSerializer, m_partitionId,
                                               m_predicateStrings, table.activeTupleCount());
                    m_context.reset(newContext);
                    break;
                }

                case TABLE_STREAM_RECOVERY:
                    m_context.reset(new RecoveryContext(table, tableId));
                    break;

                case TABLE_STREAM_ELASTIC:
                    m_context.reset(new ElasticContext(table, m_predicateStrings));
                    break;

                default:
                    assert(false);
            }
        }
        catch(SerializableEEException &e) {
            // m_context will be NULL if we get an exception.
        }
    }

    return (m_context != NULL);
}

bool EvictionIterator::hasNext()
{        
    VOLT_TRACE("Size: %lu\n", (long unsigned int)m_size);
    PersistentTable* ptable = static_cast<PersistentTable*>(table);

    VOLT_TRACE("Count: %lu %lu\n", ptable->usedTupleCount(), ptable->activeTupleCount());

    if(ptable->usedTupleCount() == 0)
        return false; 

#ifndef ANTICACHE_TIMESTAMPS
    if(current_tuple_id == ptable->getNewestTupleID())
        return false;
    if(ptable->getNumTuplesInEvictionChain() == 0) { // there are no tuples in the chain
        VOLT_DEBUG("There are no tuples in the eviction chain.");
        return false; 
    }
#else
    if (current_tuple_id == m_size)
        return false;
#endif

    return true; 
}

bool DeleteExecutor::p_execute(const NValueArray &params) {
    // target table should be persistenttable
    // update target table reference from table delegate
    PersistentTable* targetTable = dynamic_cast<PersistentTable*>(m_node->getTargetTable());
    assert(targetTable);
    TableTuple targetTuple(targetTable->schema());

    int64_t modified_tuples = 0;

    if (m_truncate) {
        VOLT_TRACE("truncating table %s...", targetTable->name().c_str());
        // count the truncated tuples as deleted
        modified_tuples = targetTable->visibleTupleCount();

        VOLT_TRACE("Delete all rows from table : %s with %d active, %d visible, %d allocated",
                   targetTable->name().c_str(),
                   (int)targetTable->activeTupleCount(),
                   (int)targetTable->visibleTupleCount(),
                   (int)targetTable->allocatedTupleCount());

        // empty the table either by table swap or iteratively deleting tuple-by-tuple
        targetTable->truncateTable(m_engine);
    }
    else {
        assert(m_inputTable);
        assert(m_inputTuple.sizeInValues() == m_inputTable->columnCount());
        assert(targetTuple.sizeInValues() == targetTable->columnCount());
        TableIterator inputIterator = m_inputTable->iterator();
        while (inputIterator.next(m_inputTuple)) {
            //
            // OPTIMIZATION: Single-Sited Query Plans
            // If our beloved DeletePlanNode is apart of a single-site query plan,
            // then the first column in the input table will be the address of a
            // tuple on the target table that we will want to blow away. This saves
            // us the trouble of having to do an index lookup
            //
            void *targetAddress = m_inputTuple.getNValue(0).castAsAddress();
            targetTuple.move(targetAddress);

            // Delete from target table
            if (!targetTable->deleteTuple(targetTuple, true)) {
                VOLT_ERROR("Failed to delete tuple from table '%s'",
                           targetTable->name().c_str());
                return false;
            }
        }
        modified_tuples = m_inputTable->tempTableTupleCount();
        VOLT_TRACE("Deleted %d rows from table : %s with %d active, %d visible, %d allocated",
                   (int)modified_tuples,
                   targetTable->name().c_str(),
                   (int)targetTable->activeTupleCount(),
                   (int)targetTable->visibleTupleCount(),
                   (int)targetTable->allocatedTupleCount());

    }

    TableTuple& count_tuple = m_node->getOutputTable()->tempTuple();
    count_tuple.setNValue(0, ValueFactory::getBigIntValue(modified_tuples));
    // try to put the tuple into the output table
    if (!m_node->getOutputTable()->insertTuple(count_tuple)) {
        VOLT_ERROR("Failed to insert tuple count (%ld) into"
                   " output table '%s'",
                   static_cast<long int>(modified_tuples),
                   m_node->getOutputTable()->name().c_str());
        return false;
    }
    m_engine->addToTuplesModified(modified_tuples);

    return true;
}

/**
 * Reserve some tuples when an eviction requested.
 */
void EvictionIterator::reserve(int64_t amount) {
    VOLT_DEBUG("amount: %ld\n", amount);

    char* addr = NULL;
    PersistentTable* ptable = static_cast<PersistentTable*>(table);
    int tuple_size = ptable->m_schema->tupleLength() + TUPLE_HEADER_SIZE;
    int active_tuple = (int)ptable->activeTupleCount();
    int evict_num = 0;
    int64_t used_tuple = ptable->usedTupleCount();
#ifdef ANTICACHE_TIMESTAMPS_PRIME
    uint32_t tuples_per_block = ptable->m_tuplesPerBlock;
#endif

    if (active_tuple)   
        evict_num = (int)(amount / (tuple_size + ptable->nonInlinedMemorySize() / active_tuple));
    else 
        evict_num = (int)(amount / tuple_size);

    VOLT_DEBUG("Count: %lu %lu\n", ptable->usedTupleCount(), ptable->activeTupleCount());

    if (evict_num > active_tuple)
        evict_num = active_tuple;

    int pick_num = evict_num * RANDOM_SCALE;

    int block_num = (int)ptable->m_data.size();
    int block_size = ptable->m_tuplesPerBlock;
    int location_size;
#ifndef ANTICACHE_TIMESTAMPS_PRIME
    int block_location;
#endif

    srand((unsigned int)time(0));

    VOLT_INFO("evict pick num: %d %d\n", evict_num, pick_num);
    VOLT_INFO("active_tuple: %d\n", active_tuple);
    VOLT_INFO("block number: %d\n", block_num);

    m_size = 0;
    current_tuple_id = 0;

#ifdef ANTICACHE_TIMESTAMPS_PRIME
    int pick_num_block = (int)(((int64_t)pick_num * tuples_per_block) / used_tuple);
    int last_full_block = (int)(used_tuple / block_size);
    VOLT_INFO("LOG: %d %d %ld\n", last_full_block, tuples_per_block, used_tuple);
    int last_block_size = (int)(used_tuple % block_size);
    int pick_num_last_block = pick_num - pick_num_block * last_full_block;
#endif

    // If we'll evict the entire table, we should do a scan instead of sampling.
    // The main reason we should do that is to past the test...
    if (evict_num < active_tuple) {
        candidates = new EvictionTuple[pick_num];
#ifdef ANTICACHE_TIMESTAMPS_PRIME
        for (int i = 0; i < last_full_block; ++i) {
            
            /**
             * if this is a beginning of a loop of scan, find a proper step to let it sample tuples from almost the whole block
             * TODO: Here we use a method that every time try a different prime number from what we use last time. Is it better?
             *       That would need further analysis.
             */  
            if (ptable->m_stepPrime[i] < 0) {
                int ideal_step = (rand() % 5) * tuples_per_block / pick_num_block;
                int old_prime = - ptable->m_stepPrime[i];
                for (int j = prime_size - 1; j >= 0; --j) {
                    if (prime_list[j] != old_prime && (tuples_per_block % prime_list[j]) > 0) {
                        ptable->m_stepPrime[i] = prime_list[j];
                        VOLT_TRACE("DEBUG: %d %d\n", tuples_per_block, ptable->m_stepPrime[i]);
                    }
                    if (prime_list[j] <= ideal_step)
                        break;
                }
                VOLT_INFO("Prime of block %d: %d %d\n", i, tuples_per_block, ptable->m_stepPrime[i]);
            }

            // now scan the block with a step of we select.
            // if we go across the boundry, minus it back to the beginning (like a mod operation)
            int step_prime = ptable->m_stepPrime[i];
            int step_offset = step_prime * tuple_size;
            int block_size_bytes = block_size * tuple_size;
            addr = ptable->m_data[i] + ptable->m_evictPosition[i];
            uint64_t end_of_block = (uint64_t)ptable->m_data[i] + block_size_bytes;
            bool flag_new = false;
            for (int j = 0; j < pick_num_block; ++j) {
                VOLT_TRACE("Flip addr: %p %p %lu\n", addr, ptable->m_data[i], ((uint64_t)addr - (uint64_t)ptable->m_data[i]) / 1024);

                current_tuple->move(addr);

                if (current_tuple->isActive()) {
                    candidates[m_size].setTuple(current_tuple->getTimeStamp(), addr);
                    m_size++;
                }

                addr += step_offset;
                if ((uint64_t)addr >= end_of_block)
                    addr -= block_size_bytes;
                if (addr == ptable->m_data[i])
//.........这里部分代码省略.........