GCC Code Coverage Report

Directory: cvmfs/
File: cvmfs/ring_buffer.cc
Date: 2026-05-24 02:35:55
Exec Total Coverage
Lines: 59 59 100.0%
Branches: 12 14 85.7%
Line Branch Exec Source
1 /**
2 * This file is part of the CernVM File System.
3 */
4
5 #include "ring_buffer.h"
6
7 #include <algorithm>
8 #include <cassert>
9 #include <cstdlib>
10 #include <cstring>
11
12 #include "util/smalloc.h"
13
14 const RingBuffer::ObjectHandle_t RingBuffer::kInvalidObjectHandle = size_t(-1);
15
16
17 80 RingBuffer::RingBuffer(size_t total_size)
18 80 : total_size_(total_size)
19 80 , free_space_(total_size)
20 80 , front_(0)
21 80 , back_(0)
22 80 , buffer_(reinterpret_cast<unsigned char *>(sxmmap(total_size_))) {
23
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 80 times.
 80 assert(total_size_ >= sizeof(size_t));
24 80 }
25
26
27 80 RingBuffer::~RingBuffer() { sxunmap(buffer_, total_size_); }
28
29
30 54134 void RingBuffer::Put(const void *data, size_t size) {
31 54134 const size_t size_head = std::min(size, total_size_ - front_);
32
2/2
✓ Branch 0 taken 54107 times.
✓ Branch 1 taken 27 times.
 54134 if (size_head > 0)
33 54107 memcpy(buffer_ + front_, data, size_head);
34
35
2/2
✓ Branch 0 taken 9153 times.
✓ Branch 1 taken 44981 times.
 54134 if (size_head < size) {
36 9153 const size_t size_tail = size - size_head;
37 9153 memcpy(buffer_, reinterpret_cast<const unsigned char *>(data) + size_head,
38 size_tail);
39 }
40
41 54134 front_ = (front_ + size) % total_size_;
42 54134 free_space_ -= size;
43 54134 }
44
45
46 2802464 void RingBuffer::Get(size_t from, size_t size, void *to) const {
47 2802464 const size_t size_head = std::min(size, total_size_ - from);
48
2/2
✓ Branch 0 taken 2671406 times.
✓ Branch 1 taken 131058 times.
 2802464 if (size_head > 0)
49 2671406 memcpy(to, buffer_ + from, size_head);
50
51
2/2
✓ Branch 0 taken 235413 times.
✓ Branch 1 taken 2567051 times.
 2802464 if (size_head < size) {
52 235413 const size_t size_tail = size - size_head;
53 235413 memcpy(reinterpret_cast<unsigned char *>(to) + size_head, buffer_,
54 size_tail);
55 }
56 2802464 }
57
58
59 53946 void RingBuffer::Shrink(size_t by) {
60 53946 back_ = (back_ + by) % total_size_;
61 53946 free_space_ += by;
62 53946 }
63
64
65 80905 size_t RingBuffer::GetObjectSize(ObjectHandle_t handle) const {
66 size_t size_tag;
67 80905 Get(handle, sizeof(size_tag), &size_tag);
68
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 80905 times.
 80905 assert(size_tag <= total_size_);
69 80905 return size_tag;
70 }
71
72
73 27094 RingBuffer::ObjectHandle_t RingBuffer::PushFront(const void *obj, size_t size) {
74 27094 size_t size_tag = size;
75 27094 size += sizeof(size_tag);
76
2/2
✓ Branch 0 taken 27 times.
✓ Branch 1 taken 27067 times.
 27094 if (size > free_space_) {
77 27 return kInvalidObjectHandle;
78 }
79
80 27067 const ObjectHandle_t result = front_;
81
82 27067 Put(&size_tag, sizeof(size_tag));
83 27067 Put(obj, size_tag);
84
85 27067 return result;
86 }
87
88
89 26973 RingBuffer::ObjectHandle_t RingBuffer::RemoveBack() {
90 26973 const ObjectHandle_t result = back_;
91
92 26973 const size_t size_tag = GetObjectSize(result);
93 26973 Shrink(sizeof(size_tag));
94 26973 Shrink(size_tag);
95
96 26973 return result;
97 }
98
99
100 26946 void RingBuffer::CopyObject(ObjectHandle_t handle, void *to) const {
101 26946 const size_t size_tag = GetObjectSize(handle);
102 26946 const ObjectHandle_t object = (handle + sizeof(size_tag)) % total_size_;
103 26946 Get(object, size_tag, to);
104 26946 }
105
106
107 2694613 void RingBuffer::CopySlice(ObjectHandle_t handle, size_t size, size_t offset,
108 void *to) const {
109 2694613 const ObjectHandle_t begin = (handle + sizeof(size_t) + offset) % total_size_;
110 2694613 Get(begin, size, to);
111 2694613 }
112