Beispiel #1
0
void CappedInsertNotifier::_wait(stdx::unique_lock<stdx::mutex>& lk,
                                 uint64_t prevVersion,
                                 Microseconds timeout) const {
    while (!_dead && prevVersion == _version) {
        if (timeout == Microseconds::max()) {
            _notifier.wait(lk);
        } else if (stdx::cv_status::timeout == _notifier.wait_for(lk, timeout.toSystemDuration())) {
            return;
        }
    }
}
Beispiel #2
0
Status ShardingState::_waitForInitialization(OperationContext* txn) {
    if (enabled())
        return Status::OK();

    stdx::unique_lock<stdx::mutex> lk(_mutex);

    {
        const Microseconds timeRemaining(txn->getRemainingMaxTimeMicros());
        while (_getInitializationState() == InitializationState::kInitializing ||
               _getInitializationState() == InitializationState::kNew) {
            if (timeRemaining.count()) {
                const auto deadline = stdx::chrono::system_clock::now() + timeRemaining;

                if (stdx::cv_status::timeout ==
                    _initializationFinishedCondition.wait_until(lk, deadline)) {
                    return Status(ErrorCodes::ExceededTimeLimit,
                                  "Initializing sharding state exceeded time limit");
                }
            } else {
                _initializationFinishedCondition.wait(lk);
            }
        }
    }

    auto initializationState = _getInitializationState();
    if (initializationState == InitializationState::kInitialized) {
        fassertStatusOK(34349, _initializationStatus);
        return Status::OK();
    }
    if (initializationState == InitializationState::kError) {
        return Status(ErrorCodes::ManualInterventionRequired,
                      str::stream()
                          << "Server's sharding metadata manager failed to initialize and will "
                             "remain in this state until the instance is manually reset"
                          << causedBy(_initializationStatus));
    }

    MONGO_UNREACHABLE;
}
Beispiel #3
0
int main(){
	
	std::cout << "0\t";
	for(int p = 0; p < NUM_CORES; ++p){
		std::cout << EXTRA_THREADS[p] + 1 << '\t';
	}
	std::cout << std::endl;
	
	for(int n = 0; n < N; ++n){
		Clock::time_point t0 = Clock::now();
		iteration();
		Clock::time_point t1 = Clock::now();
		Microseconds ms = std::chrono::duration_cast<Microseconds>(t1 - t0);
		std::cout << ms.count() << '\t';
		
		for(int p = 0; p < NUM_CORES; ++p){
			std::vector<std::thread> threads;
			t0 = Clock::now();
	
			for(int i = 0; i < EXTRA_THREADS[p]; ++i){
				threads.push_back(std::thread(lock));
			}
			lock();
			for(auto& thread : threads){
				thread.join();
			}

			t1 = Clock::now();
			ms = std::chrono::duration_cast<Microseconds>(t1 - t0);
			std::cout << ms.count() << '\t';
		}
		
		std::cout << std::endl;
	}
    return 0;
}
inline void setValue(tinyxml2::XMLElement& elt, const Microseconds& microseconds) {
    elt.DeleteChildren();
    setChildAttribute(elt, "Microseconds", microseconds.count());
    setChildAttribute(elt, "Milliseconds", us2ms(microseconds));
    setChildAttribute(elt, "Seconds", us2sec(microseconds));
}
Beispiel #5
0
	inline void Formatter(FormatData& formatData, const Microseconds& microseconds)
	{
		Formatter(formatData, microseconds.count());

		formatData.string.append(U"us", 2);
	}