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 #include "ring_buffer.h"
19 #include "perf_event_record.h"
20 #if defined(is_ohos) && is_ohos
21 #include "hiperf_hilog.h"
22 #endif
23
24 namespace OHOS {
25 namespace Developtools {
26 namespace HiPerf {
RingBuffer(size_t size)27 RingBuffer::RingBuffer(size_t size) : size_(size)
28 {
29 if (size > 0) {
30 buf_ = std::make_unique<uint8_t[]>(size);
31 }
32 }
33
~RingBuffer()34 RingBuffer::~RingBuffer()
35 {
36 buf_.reset();
37 }
38
39 // get size of the writable space
GetFreeSize() const40 size_t RingBuffer::GetFreeSize() const
41 {
42 return size_ - (head_.load(std::memory_order_relaxed) - tail_.load(std::memory_order_relaxed));
43 }
44
AllocForWrite(size_t writeSize)45 uint8_t *RingBuffer::AllocForWrite(size_t writeSize)
46 {
47 if (buf_ == nullptr) {
48 HLOGE("buf_ is nullptr");
49 return nullptr;
50 }
51 size_t writeHead = head_.load(std::memory_order_relaxed);
52 size_t readHead = tail_.load(std::memory_order_acquire);
53 if (size_ == 0) {
54 return nullptr;
55 }
56 size_t writePos = writeHead % size_;
57 size_t readPos = readHead % size_;
58 writeSize_ = writeSize;
59 if (writePos < readPos) {
60 // |---writePos<---writeSize--->readPos---|
61 if (writePos + writeSize > readPos) {
62 return nullptr;
63 }
64 } else if (writePos == readPos && writeHead != readHead) {
65 // writePos catch up with readPos, but buffer is full
66 return nullptr;
67 } else {
68 // two cases: 1, writePos catch up with readPos, but buffer is empty
69 // 2, |---readPos---writePos<---writeSize--->|
70 if (writePos + writeSize > size_) {
71 // no enough space at the end
72 if (readPos < writeSize) {
73 return nullptr;
74 }
75 // wrap to the start, set mark byte
76 buf_.get()[writePos] = MARGIN_BYTE;
77 writeSize_ += (size_ - writePos);
78 writePos = 0;
79 }
80 }
81
82 return buf_.get() + writePos;
83 }
84
EndWrite()85 void RingBuffer::EndWrite()
86 {
87 size_t head = head_.load(std::memory_order_relaxed);
88 head += writeSize_;
89 head_.store(head, std::memory_order_release);
90 }
91
GetReadData()92 uint8_t *RingBuffer::GetReadData()
93 {
94 CHECK_TRUE(buf_ == nullptr || buf_.get() == nullptr, nullptr, 0, "");
95 size_t writeHead = head_.load(std::memory_order_acquire);
96 size_t readHead = tail_.load(std::memory_order_relaxed);
97 if (writeHead == readHead) {
98 return nullptr;
99 }
100
101 readSize_ = 0;
102 if (size_ == 0) {
103 return nullptr;
104 }
105 size_t writePos = writeHead % size_;
106 size_t readPos = readHead % size_;
107 if (writePos <= readPos) {
108 // |<---data2--->writePos---readPos<---data1--->|
109 if (buf_.get()[readPos] == MARGIN_BYTE) {
110 CHECK_TRUE(writePos == 0, nullptr, 0, "");
111 readSize_ = (size_ - readPos);
112 readPos = 0;
113 }
114 }
115 // else |---readPos<---data--->writePos---|
116 perf_event_header *header = reinterpret_cast<perf_event_header *>(buf_.get() + readPos);
117 CHECK_TRUE(header == nullptr, nullptr, 0, "");
118
119 if (header->type == PERF_RECORD_AUXTRACE) {
120 struct PerfRecordAuxtraceData *auxtrace = reinterpret_cast<struct PerfRecordAuxtraceData *>(header + 1);
121 readSize_ += header->size + auxtrace->size;
122 } else {
123 readSize_ += header->size;
124 }
125 return buf_.get() + readPos;
126 }
127
EndRead()128 void RingBuffer::EndRead()
129 {
130 size_t tail = tail_.load(std::memory_order_relaxed);
131 tail += readSize_;
132 tail_.store(tail, std::memory_order_release);
133 }
134 } // namespace HiPerf
135 } // namespace Developtools
136 } // namespace OHOS
137