1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
|
/*
* Copyright (C) 2017-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/source/helpers/debug_helpers.h"
#include "shared/source/helpers/ptr_math.h"
#include <atomic>
#include <cstddef>
#include <cstdint>
namespace NEO {
class GraphicsAllocation;
class LinearStream {
public:
virtual ~LinearStream() = default;
LinearStream();
LinearStream(void *buffer, size_t bufferSize);
LinearStream(GraphicsAllocation *buffer);
LinearStream(GraphicsAllocation *gfxAllocation, void *buffer, size_t bufferSize);
void *getCpuBase() const;
void *getSpace(size_t size);
size_t getMaxAvailableSpace() const;
size_t getAvailableSpace() const;
size_t getUsed() const;
void overrideMaxSize(size_t newMaxSize);
void replaceBuffer(void *buffer, size_t bufferSize);
GraphicsAllocation *getGraphicsAllocation() const;
void replaceGraphicsAllocation(GraphicsAllocation *gfxAllocation);
template <typename Cmd>
Cmd *getSpaceForCmd() {
auto ptr = getSpace(sizeof(Cmd));
return reinterpret_cast<Cmd *>(ptr);
}
protected:
std::atomic<size_t> sizeUsed;
size_t maxAvailableSpace;
void *buffer;
GraphicsAllocation *graphicsAllocation;
};
inline void *LinearStream::getCpuBase() const {
return buffer;
}
inline void *LinearStream::getSpace(size_t size) {
UNRECOVERABLE_IF(sizeUsed + size > maxAvailableSpace);
auto memory = ptrOffset(buffer, sizeUsed);
sizeUsed += size;
return memory;
}
inline size_t LinearStream::getMaxAvailableSpace() const {
return maxAvailableSpace;
}
inline size_t LinearStream::getAvailableSpace() const {
DEBUG_BREAK_IF(sizeUsed > maxAvailableSpace);
return maxAvailableSpace - sizeUsed;
}
inline size_t LinearStream::getUsed() const {
return sizeUsed;
}
inline void LinearStream::overrideMaxSize(size_t newMaxSize) {
maxAvailableSpace = newMaxSize;
}
inline void LinearStream::replaceBuffer(void *buffer, size_t bufferSize) {
this->buffer = buffer;
maxAvailableSpace = bufferSize;
sizeUsed = 0;
}
inline GraphicsAllocation *LinearStream::getGraphicsAllocation() const {
return graphicsAllocation;
}
inline void LinearStream::replaceGraphicsAllocation(GraphicsAllocation *gfxAllocation) {
graphicsAllocation = gfxAllocation;
}
} // namespace NEO
|
