1 /*
2 * Copyright (c) 2021 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 #define HILOG_TAG "RingBuffer"
16
17 #include <linux/perf_event.h>
18
19 #include "ring_buffer.h"
20
21 namespace OHOS {
22 namespace Developtools {
23 namespace HiPerf {
RingBuffer(size_t size)24 RingBuffer::RingBuffer(size_t size) : size_(size)
25 {
26 if (size > 0) {
27 buf_ = std::make_unique<uint8_t[]>(size);
28 }
29 }
30
~RingBuffer()31 RingBuffer::~RingBuffer() {}
32
33 // get size of the writable space
GetFreeSize() const34 size_t RingBuffer::GetFreeSize() const
35 {
36 return size_ - (head_.load(std::memory_order_relaxed) - tail_.load(std::memory_order_relaxed));
37 }
38
AllocForWrite(size_t writeSize)39 uint8_t *RingBuffer::AllocForWrite(size_t writeSize)
40 {
41 size_t writeHead = head_.load(std::memory_order_relaxed);
42 size_t readHead = tail_.load(std::memory_order_acquire);
43 size_t writePos = writeHead % size_;
44 size_t readPos = readHead % size_;
45 writeSize_ = writeSize;
46 if (writePos < readPos) {
47 // |---writePos<---writeSize--->readPos---|
48 if (writePos + writeSize > readPos) {
49 return nullptr;
50 }
51 } else if (writePos == readPos and writeHead != readHead) {
52 // writePos catch up with readPos, but buffer is full
53 return nullptr;
54 } else {
55 // two cases: 1, writePos catch up with readPos, but buffer is empty
56 // 2, |---readPos---writePos<---writeSize--->|
57 if (writePos + writeSize > size_) {
58 // no enough space at the end
59 if (readPos < writeSize) {
60 return nullptr;
61 }
62 // wrap to the start, set mark byte
63 buf_.get()[writePos] = MARGIN_BYTE;
64 writeSize_ += (size_ - writePos);
65 writePos = 0;
66 }
67 }
68
69 return buf_.get() + writePos;
70 }
71
EndWrite()72 void RingBuffer::EndWrite()
73 {
74 size_t head = head_.load(std::memory_order_relaxed);
75 head += writeSize_;
76 head_.store(head, std::memory_order_release);
77 }
78
GetReadData()79 uint8_t *RingBuffer::GetReadData()
80 {
81 size_t writeHead = head_.load(std::memory_order_acquire);
82 size_t readHead = tail_.load(std::memory_order_relaxed);
83 if (writeHead == readHead) {
84 return nullptr;
85 }
86
87 readSize_ = 0;
88 size_t writePos = writeHead % size_;
89 size_t readPos = readHead % size_;
90 if (writePos <= readPos) {
91 // |<---data2--->writePos---readPos<---data1--->|
92 if (buf_.get()[readPos] == MARGIN_BYTE) {
93 if (writePos == 0) {
94 return nullptr;
95 }
96 readSize_ = (size_ - readPos);
97 readPos = 0;
98 }
99 }
100 // else |---readPos<---data--->writePos---|
101 perf_event_header *header = reinterpret_cast<perf_event_header *>(buf_.get() + readPos);
102 readSize_ += header->size;
103 return buf_.get() + readPos;
104 }
105
EndRead()106 void RingBuffer::EndRead()
107 {
108 size_t tail = tail_.load(std::memory_order_relaxed);
109 tail += readSize_;
110 tail_.store(tail, std::memory_order_release);
111 }
112 } // namespace HiPerf
113 } // namespace Developtools
114 } // namespace OHOS