29 #include "jfr/writers/jfrBigEndianWriter.hpp" |
29 #include "jfr/writers/jfrBigEndianWriter.hpp" |
30 |
30 |
31 JfrCheckpointFlush::JfrCheckpointFlush(Type* old, size_t used, size_t requested, Thread* t) : |
31 JfrCheckpointFlush::JfrCheckpointFlush(Type* old, size_t used, size_t requested, Thread* t) : |
32 _result(JfrCheckpointManager::flush(old, used, requested, t)) {} |
32 _result(JfrCheckpointManager::flush(old, used, requested, t)) {} |
33 |
33 |
34 JfrCheckpointWriter::JfrCheckpointWriter(bool flushpoint, bool header, Thread* thread) : |
34 JfrCheckpointWriter::JfrCheckpointWriter(JfrCheckpointType type /* GENERIC */) : |
35 JfrCheckpointWriterBase(JfrCheckpointManager::lease_buffer(thread), thread), |
35 JfrCheckpointWriterBase(JfrCheckpointManager::lease_buffer(Thread::current()), Thread::current()), |
36 _time(JfrTicks::now()), |
36 _time(JfrTicks::now()), |
37 _offset(0), |
37 _offset(0), |
38 _count(0), |
38 _count(0), |
39 _flushpoint(flushpoint), |
39 _type(type), |
40 _header(header) { |
40 _header(true) { |
41 assert(this->is_acquired(), "invariant"); |
41 assert(this->is_acquired(), "invariant"); |
42 assert(0 == this->current_offset(), "invariant"); |
42 assert(0 == this->current_offset(), "invariant"); |
43 if (_header) { |
43 if (_header) { |
44 reserve(sizeof(JfrCheckpointEntry)); |
44 reserve(sizeof(JfrCheckpointEntry)); |
45 } |
45 } |
46 } |
46 } |
47 |
47 |
48 static void write_checkpoint_header(u1* pos, int64_t size, jlong time, bool flushpoint, u4 type_count) { |
48 JfrCheckpointWriter::JfrCheckpointWriter(Thread* t, bool header /* true */, JfrCheckpointType type /* GENERIC */) : |
|
49 JfrCheckpointWriterBase(JfrCheckpointManager::lease_buffer(t), t), |
|
50 _time(JfrTicks::now()), |
|
51 _offset(0), |
|
52 _count(0), |
|
53 _type(type), |
|
54 _header(header) { |
|
55 assert(this->is_acquired(), "invariant"); |
|
56 assert(0 == this->current_offset(), "invariant"); |
|
57 if (_header) { |
|
58 reserve(sizeof(JfrCheckpointEntry)); |
|
59 } |
|
60 } |
|
61 |
|
62 JfrCheckpointWriter::JfrCheckpointWriter(Thread* t, JfrBuffer* buffer, JfrCheckpointType type /* GENERIC */) : |
|
63 JfrCheckpointWriterBase(buffer, t), |
|
64 _time(JfrTicks::now()), |
|
65 _offset(0), |
|
66 _count(0), |
|
67 _type(type), |
|
68 _header(true) { |
|
69 assert(this->is_acquired(), "invariant"); |
|
70 assert(0 == this->current_offset(), "invariant"); |
|
71 if (_header) { |
|
72 reserve(sizeof(JfrCheckpointEntry)); |
|
73 } |
|
74 } |
|
75 |
|
76 static void write_checkpoint_header(u1* pos, int64_t size, jlong time, u4 checkpoint_type, u4 type_count) { |
49 assert(pos != NULL, "invariant"); |
77 assert(pos != NULL, "invariant"); |
50 JfrBigEndianWriter be_writer(pos, sizeof(JfrCheckpointEntry)); |
78 JfrBigEndianWriter be_writer(pos, sizeof(JfrCheckpointEntry)); |
51 be_writer.write(size); |
79 be_writer.write(size); |
52 be_writer.write(time); |
80 be_writer.write(time); |
53 be_writer.write(JfrTicks::now().value() - time); |
81 be_writer.write(JfrTicks::now().value() - time); |
54 be_writer.write(flushpoint ? (u4)1 : (u4)0); |
82 be_writer.write(checkpoint_type); |
55 be_writer.write(type_count); |
83 be_writer.write(type_count); |
56 assert(be_writer.is_valid(), "invariant"); |
84 assert(be_writer.is_valid(), "invariant"); |
57 } |
85 } |
58 |
86 |
59 JfrCheckpointWriter::~JfrCheckpointWriter() { |
87 JfrCheckpointWriter::~JfrCheckpointWriter() { |
72 assert(this->is_valid(), "invariant"); |
100 assert(this->is_valid(), "invariant"); |
73 assert(count() > 0, "invariant"); |
101 assert(count() > 0, "invariant"); |
74 assert(this->used_size() > sizeof(JfrCheckpointEntry), "invariant"); |
102 assert(this->used_size() > sizeof(JfrCheckpointEntry), "invariant"); |
75 const int64_t size = this->current_offset(); |
103 const int64_t size = this->current_offset(); |
76 assert(size + this->start_pos() == this->current_pos(), "invariant"); |
104 assert(size + this->start_pos() == this->current_pos(), "invariant"); |
77 write_checkpoint_header(const_cast<u1*>(this->start_pos()), size, _time, is_flushpoint(), count()); |
105 write_checkpoint_header(const_cast<u1*>(this->start_pos()), size, _time, (u4)_type, count()); |
78 release(); |
106 release(); |
79 } |
|
80 |
|
81 void JfrCheckpointWriter::set_flushpoint(bool flushpoint) { |
|
82 _flushpoint = flushpoint; |
|
83 } |
|
84 |
|
85 bool JfrCheckpointWriter::is_flushpoint() const { |
|
86 return _flushpoint; |
|
87 } |
107 } |
88 |
108 |
89 u4 JfrCheckpointWriter::count() const { |
109 u4 JfrCheckpointWriter::count() const { |
90 return _count; |
110 return _count; |
91 } |
111 } |
138 *size = this->current_pos() - session_start_pos; |
158 *size = this->current_pos() - session_start_pos; |
139 return session_start_pos; |
159 return session_start_pos; |
140 } |
160 } |
141 *size = this->used_size(); |
161 *size = this->used_size(); |
142 assert(this->start_pos() + *size == this->current_pos(), "invariant"); |
162 assert(this->start_pos() + *size == this->current_pos(), "invariant"); |
143 write_checkpoint_header(const_cast<u1*>(this->start_pos()), this->used_offset(), _time, is_flushpoint(), count()); |
163 write_checkpoint_header(const_cast<u1*>(this->start_pos()), this->used_offset(), _time, (u4)_type, count()); |
144 _header = false; // the header was just written |
164 _header = false; // the header was just written |
145 if (move) { |
165 if (move) { |
146 this->seek(_offset); |
166 this->seek(_offset); |
147 } |
167 } |
148 return this->start_pos(); |
168 return this->start_pos(); |