1 /* 2 * Copyright (c) 2022 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include "sync_fence_timeline.h" 17 #include <atomic> 18 #include <memory> 19 #include <mutex> 20 #include <utility> 21 22 namespace OHOS { SyncFenceTime(const sptr<SyncFence> & fence)23SyncFenceTime::SyncFenceTime(const sptr<SyncFence>& fence) : fence_(fence) 24 { 25 signaledTimestamps_ = fence->IsValid() ? SyncFence::FENCE_PENDING_TIMESTAMP : 26 SyncFence::INVALID_TIMESTAMP; 27 } 28 SyncFenceTime(sptr<SyncFence> && fence)29SyncFenceTime::SyncFenceTime(sptr<SyncFence>&& fence) : fence_(std::move(fence)) 30 { 31 signaledTimestamps_ = fence_->IsValid() ? SyncFence::FENCE_PENDING_TIMESTAMP : 32 SyncFence::INVALID_TIMESTAMP; 33 } 34 IsValid() const35bool SyncFenceTime::IsValid() const 36 { 37 return fence_->IsValid(); 38 } 39 GetSignalTimestamp()40ns_sec_t SyncFenceTime::GetSignalTimestamp() 41 { 42 ns_sec_t timestamp = signaledTimestamps_.load(std::memory_order_relaxed); 43 if (timestamp != SyncFence::FENCE_PENDING_TIMESTAMP) { 44 return timestamp; 45 } 46 47 sptr<SyncFence> fence; 48 49 std::lock_guard<std::mutex> lock(mutex_); 50 if (fence_.GetRefPtr() == nullptr) { 51 return signaledTimestamps_.load(std::memory_order_relaxed); 52 } 53 fence = fence_; 54 55 timestamp = fence->SyncFileReadTimestamp(); 56 if (timestamp != SyncFence::FENCE_PENDING_TIMESTAMP) { 57 std::lock_guard<std::mutex> lockTimestampStore(mutex_); 58 fence_.clear(); 59 signaledTimestamps_.store(timestamp, std::memory_order_relaxed); 60 } 61 return timestamp; 62 } 63 GetCachedSignalTimestamp() const64ns_sec_t SyncFenceTime::GetCachedSignalTimestamp() const 65 { 66 return signaledTimestamps_.load(std::memory_order_relaxed); 67 } 68 Push(const std::shared_ptr<SyncFenceTime> & fence)69void SyncFenceTimeline::Push(const std::shared_ptr<SyncFenceTime> &fence) 70 { 71 std::lock_guard<std::mutex> lock(mutex_); 72 if (queue_.size() >= MAX_COUNT) { 73 std::shared_ptr<SyncFenceTime> front = queue_.front().lock(); 74 if (front) { 75 front->GetSignalTimestamp(); 76 } 77 queue_.pop(); 78 } 79 queue_.push(fence); 80 } 81 UpdateFenceTimeline()82void SyncFenceTimeline::UpdateFenceTimeline() 83 { 84 std::lock_guard<std::mutex> lock(mutex_); 85 while (!queue_.empty()) { 86 std::shared_ptr<SyncFenceTime> fenceTime = queue_.front().lock(); 87 if (!fenceTime) { 88 queue_.pop(); 89 continue; 90 } else if (fenceTime->GetSignalTimestamp() != SyncFence::FENCE_PENDING_TIMESTAMP) { 91 queue_.pop(); 92 continue; 93 } else { 94 // the fence is not signal yet. and later ones are not signal either. 95 break; 96 } 97 } 98 } 99 } // namespace OHOS 100 101