brpc:countdown event acquire release

 

acquire 是要求下面的语句不能优化后跑到上面来；

release是要求上面的语句优化后，不能跑到下面去；

 

// bthread - A M:N threading library to make applications more concurrent.
// Copyright (c) 2016 Baidu, Inc.
// 
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// 
//     http://www.apache.org/licenses/LICENSE-2.0
// 
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// Author: Zhangyi Chen (chenzhangyi01@baidu.com)
// Date: 2016/06/03 13:06:40

#ifndef BTHREAD_COUNTDOWN_EVENT_H
#define BTHREAD_COUNTDOWN_EVENT_H

#include "bthread/bthread.h"

namespace bthread {

// A synchronization primitive to wait for multiple signallers.
class CountdownEvent {
public:
    CountdownEvent(int initial_count = 1);
    ~CountdownEvent();

    // Increase current counter by |v|
    void add_count(int v = 1);

    // Reset the counter to |v|
    void reset(int v = 1);

    // Decrease the counter by |sig|
    void signal(int sig = 1);

    // Block current thread until the counter reaches 0.
    // Returns 0 on success, error code otherwise.
    // This method never returns EINTR.
    int wait();

    // Block the current thread until the counter reaches 0 or duetime has expired
    // Returns 0 on success, error code otherwise. ETIMEDOUT is for timeout.
    // This method never returns EINTR.
    int timed_wait(const timespec& duetime);

private:
    int *_butex;
    bool _wait_was_invoked;
};

}  // namespace bthread

#endif  // BTHREAD_COUNTDOWN_EVENT_H

 

// bthread - A M:N threading library to make applications more concurrent.
// Copyright (c) 2016 Baidu, Inc.
// 
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// 
//     http://www.apache.org/licenses/LICENSE-2.0
// 
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// Author: Zhangyi Chen (chenzhangyi01@baidu.com)
// Date: 2016/06/03 13:15:24

#include "butil/atomicops.h"     // butil::atomic<int>
#include "bthread/butex.h"
#include "bthread/countdown_event.h"

namespace bthread 
{

    CountdownEvent::CountdownEvent(int initial_count) 
    {
        if (initial_count < 0) 
        {
            LOG(FATAL) << "Invalid initial_count=" << initial_count;
            abort();
        }
        _butex = butex_create_checked<int>();
        *_butex = initial_count;
        _wait_was_invoked = false;
    }

    CountdownEvent::~CountdownEvent() 
    {
        butex_destroy(_butex);
    }

    void CountdownEvent::signal(int sig) 
    {
        // Have to save _butex, *this is probably defreferenced by the wait thread
        // which sees fetch_sub
        void* const saved_butex = _butex;
        const int prev = ((butil::atomic<int>*)_butex)
            ->fetch_sub(sig, butil::memory_order_release);
        // DON'T touch *this ever after
        if ( prev > sig )
        {
            return;
        }
        LOG_IF(ERROR, prev < sig) << "Counter is over decreased";
        butex_wake_all(saved_butex);
    }

    int CountdownEvent::wait() 
    {
        _wait_was_invoked = true;
        for (;;) 
        {
            const int seen_counter = 
                ((butil::atomic<int>*)_butex)->load(butil::memory_order_acquire);
            // acquire 语义，下面的语句不能优化后，乱序执行跑到上面来
            if (seen_counter <= 0)
            {
                return 0;
            }

            if (butex_wait(_butex, seen_counter, NULL) < 0 &&
                errno != EWOULDBLOCK && errno != EINTR)
            {
                return errno;
            }
        }
    }

    void CountdownEvent::add_count(int v)
    {
        if (v <= 0)
        {
            LOG_IF(ERROR, v < 0) << "Invalid count=" << v;
            return;
        }
        LOG_IF(ERROR, _wait_was_invoked) 
            << "Invoking add_count() after wait() was invoked";
        ((butil::atomic<int>*)_butex)->fetch_add(v, butil::memory_order_release);
    }

    void CountdownEvent::reset(int v) 
    {
        if (v < 0)
        {
            LOG(ERROR) << "Invalid count=" << v;
            return;
        }
        // release语义，上面的语句执行，不能跑到release语句后面来
        const int prev_counter =
            ((butil::atomic<int>*)_butex)
            ->exchange(v, butil::memory_order_release);
        LOG_IF(ERROR, _wait_was_invoked && prev_counter)
            << "Invoking reset() while count=" << prev_counter;
        _wait_was_invoked = false;
    }

    int CountdownEvent::timed_wait(const timespec& duetime) 
    {
        _wait_was_invoked = true;
        for (;;) 
        {
            const int seen_counter = 
                ((butil::atomic<int>*)_butex)->load(butil::memory_order_acquire);
            // 下面的语句优化后不能跑到上面来
            if (seen_counter <= 0)
            {
                return 0;
            }

            if (butex_wait(_butex, seen_counter, &duetime) < 0 &&
                errno != EWOULDBLOCK && errno != EINTR)
            {
                return errno;
            }
        }
    }

}  // namespace bthread