Ejemplo n.º 1
0
void Controller::checkMigration(Key& key, const Choice& current,
        bool extraGet, shared_ptr<Value> valueGot) {
    Requirements requirements;
    size_t size;
    {
        lock_guard<mutex> guard(infoLock);
        if (info.count(key) == 0) return;
        requirements = *info[key].requirements.get();
        size = info[key].size;
    }
    Condition condition = prepareCondition(key, size, requirements);
    double estimatedCost;
    Choice* choice = decider->findBetter(condition, current, extraGet,
            &estimatedCost);
    if (choice != nullptr) {
        Dbg() << "migrating from " << current.desc() << " to " << choice->desc() << endl;
        shared_ptr<Value> value;
        Requirements migrateRequirements;
        if (extraGet) {
            value = current.getActor()->get(key, current.getProfile());
        } else {
            value = valueGot;
        }
        storeInto(key, value, *choice, requirements);
        choice_id old_id = memory->remember(key, choice->getId());
        deleteFrom(key, current);
        accountant->recordMigrate(current.getId(), choice->getId(), size,
                extraGet);
    }
}
Ejemplo n.º 2
0
shared_ptr<Value> Controller::handleGet(Key& key, const Requirements& requirements) {
    shared_ptr<Value> value;

    Requirements mutable_requirements = requirements;

    choice_id cid;
    if (memory->recall(key, &cid)) {
        auto cit = choices.find(cid);
        assert(cit != choices.end());
        Choice choice = cit->second;
        accountant->recordGet(cid);

        Actor* actor = choice.getActor();
        Dbg() << "choice " << choice.desc() << "handle this" << endl;
        if (requirements.prefer_url) {
            value = actor->get_url(key, requirements.expiration, choice.getProfile());
        }
        if (!value) {
            value = actor->get(key, choice.getProfile(), requirements.range, &mutable_requirements.metadata);
        }

        if (!value) {
            Err() << "cannot find " << key.toString() << " in choice " << choice.desc() << endl;
            for (auto& choice_pair : choices) {
                Choice& choice = choice_pair.second;
                if (choice.getActor()->get(key, choice.getProfile(), requirements.range, &mutable_requirements.metadata)) {
                    Err() << "found key in " << choice.desc() << "instead" << endl;
                    abort();
                }
            }
        }

        if (enableGetMigration) {
            bool extraGet = !value->hasUrl();
            checkMigration(key, choice, extraGet, value);
        }
    }

    estimator->notifyGet(key, mutable_requirements);
    if (enableStat) {
        stat->notifyGet(key);
    }

    return value;
}
Ejemplo n.º 3
0
void Controller::storeInto(Key& key, shared_ptr<Value> value,
        const Choice& choice, const Requirements& requirements) {
    Actor* actor = choice.getActor();
    Dbg() << "chose " << choice.desc() << " for this" << endl;
    if (requirements.metadata.empty()) {
        actor->put(key, value, choice.getProfile());
    } else {
        actor->put(key, value, choice.getProfile(), &requirements.metadata);
    }
}
Ejemplo n.º 4
0
string Controller::handleDist() {
    stringstream ss;
    const map<Key, choice_id>& mem = memory->dump();
    double tcost = 0;
    if (enableStat) Info() << "======== Cost Report ========" << endl;
    try {
        memory->lockIt();
        for (auto& it : mem) {
            string key = it.first.toString();
            choice_id choice_id = it.second;
            Choice& choice = choices.find(choice_id)->second;

            if (!(info.count(key) == 1)) {
                continue;
            }
            size_t size;
            Requirements requirements;
            {
                lock_guard<mutex> guard(infoLock);
                requirements = *info[key].requirements.get();
                size = info[key].size;
            }

            ss << key << " " << size << " " << choice.desc();

            if (enableStat) {
                double cost = 0;
                long get, put;
                stat->getInfo(key, get, put);

                Condition condition;
                condition.size = size;
                condition.durabilityRequired = requirements.durabilityRequired;
                condition.latencyRequired = requirements.latencyRequired;
                condition.bandwidthRequired = requirements.bandwidthRequired;
                condition.getRequests = get;
                condition.putRequests = put;
                condition.timeSpan = 86400 * 30;
                Choice *bestChoice = decider->choose(condition, &cost);
                if (bestChoice == nullptr) {
                    Err() << "can't find optimal place?" << endl;
                } else {
                    tcost += cost;
                }
                ss << " " << get << " " << put << " " << bestChoice->desc();
            }
            ss << endl;
        }
        if (enableStat) {
            for (const auto& it : getChoices()) {
                double myCost = 0;
                double realMyCost = 0;
                const Choice& myChoice = it.second;
                for (auto& it : mem) {
                    string key = it.first.toString();
                    choice_id choice_id = it.second;
                    Choice& choice = choices.find(choice_id)->second;

                    if (!(info.count(key) == 1)) {
                        continue;
                    }

                    size_t size;
                    {
                        lock_guard<mutex> guard(infoLock);
                        size = info[key].size;
                    }

                    long get, put;
                    stat->getInfo(key, get, put);

                    double cost = myChoice.calcCost(get, put, size);
                    myCost += cost;
                    if (choice_id == myChoice.getId()) realMyCost += cost;
                }
                Info() << myChoice.getName() << " SOLO: " << myCost / 1000 << " nano$"
                    << "  COST: " << realMyCost / 1000 << " nano$" << endl;
            }
        }
        memory->unlockIt();
        if (enableStat) {
            Info() << "Optimal total cost: " << tcost / 1000 << " nano$" << endl;
        }
    } catch (...) {
        Err() << "got exception in handleDist" << endl;
        memory->unlockIt();
    }
    return ss.str();
}