28 #include "jfr/writers/jfrBigEndianWriter.hpp" |
28 #include "jfr/writers/jfrBigEndianWriter.hpp" |
29 |
29 |
30 JfrCheckpointFlush::JfrCheckpointFlush(Type* old, size_t used, size_t requested, Thread* t) : |
30 JfrCheckpointFlush::JfrCheckpointFlush(Type* old, size_t used, size_t requested, Thread* t) : |
31 _result(JfrCheckpointManager::flush(old, used, requested, t)) {} |
31 _result(JfrCheckpointManager::flush(old, used, requested, t)) {} |
32 |
32 |
33 JfrCheckpointWriter::JfrCheckpointWriter() : |
33 JfrCheckpointWriter::JfrCheckpointWriter(JfrCheckpointMode mode /* NORMAL */) : |
34 JfrCheckpointWriterBase(JfrCheckpointManager::lease_buffer(Thread::current()), Thread::current()), |
34 JfrCheckpointWriterBase(JfrCheckpointManager::lease_buffer(Thread::current()), Thread::current()), |
35 _time(JfrTicks::now()), |
35 _time(JfrTicks::now()), |
36 _offset(0), |
36 _offset(0), |
37 _count(0), |
37 _count(0), |
|
38 _mode(mode), |
38 _header(true) { |
39 _header(true) { |
39 assert(this->is_acquired(), "invariant"); |
40 assert(this->is_acquired(), "invariant"); |
40 assert(0 == this->current_offset(), "invariant"); |
41 assert(0 == this->current_offset(), "invariant"); |
41 if (_header) { |
42 if (_header) { |
42 reserve(sizeof(JfrCheckpointEntry)); |
43 reserve(sizeof(JfrCheckpointEntry)); |
43 } |
44 } |
44 } |
45 } |
45 |
46 |
46 JfrCheckpointWriter::JfrCheckpointWriter(Thread* t, bool header /* true */) : |
47 JfrCheckpointWriter::JfrCheckpointWriter(Thread* t, bool header /* true */, JfrCheckpointMode mode /* NORMAL */) : |
47 JfrCheckpointWriterBase(JfrCheckpointManager::lease_buffer(t), t), |
48 JfrCheckpointWriterBase(JfrCheckpointManager::lease_buffer(t), t), |
48 _time(JfrTicks::now()), |
49 _time(JfrTicks::now()), |
49 _offset(0), |
50 _offset(0), |
50 _count(0), |
51 _count(0), |
|
52 _mode(mode), |
51 _header(header) { |
53 _header(header) { |
52 assert(this->is_acquired(), "invariant"); |
54 assert(this->is_acquired(), "invariant"); |
53 assert(0 == this->current_offset(), "invariant"); |
55 assert(0 == this->current_offset(), "invariant"); |
54 if (_header) { |
56 if (_header) { |
55 reserve(sizeof(JfrCheckpointEntry)); |
57 reserve(sizeof(JfrCheckpointEntry)); |
56 } |
58 } |
57 } |
59 } |
58 |
60 |
59 JfrCheckpointWriter::JfrCheckpointWriter(Thread* t, JfrBuffer* buffer) : |
61 JfrCheckpointWriter::JfrCheckpointWriter(Thread* t, JfrBuffer* buffer, JfrCheckpointMode mode /* NORMAL */) : |
60 JfrCheckpointWriterBase(buffer, t), |
62 JfrCheckpointWriterBase(buffer, t), |
61 _time(JfrTicks::now()), |
63 _time(JfrTicks::now()), |
62 _offset(0), |
64 _offset(0), |
63 _count(0), |
65 _count(0), |
|
66 _mode(mode), |
64 _header(true) { |
67 _header(true) { |
65 assert(this->is_acquired(), "invariant"); |
68 assert(this->is_acquired(), "invariant"); |
66 assert(0 == this->current_offset(), "invariant"); |
69 assert(0 == this->current_offset(), "invariant"); |
67 if (_header) { |
70 if (_header) { |
68 reserve(sizeof(JfrCheckpointEntry)); |
71 reserve(sizeof(JfrCheckpointEntry)); |
69 } |
72 } |
70 } |
73 } |
71 |
74 |
72 static void write_checkpoint_header(u1* pos, int64_t size, jlong time, u4 type_count) { |
75 static void write_checkpoint_header(u1* pos, int64_t size, jlong time, u4 mode, u4 type_count) { |
73 assert(pos != NULL, "invariant"); |
76 assert(pos != NULL, "invariant"); |
74 JfrBigEndianWriter be_writer(pos, sizeof(JfrCheckpointEntry)); |
77 JfrBigEndianWriter be_writer(pos, sizeof(JfrCheckpointEntry)); |
75 be_writer.write(size); |
78 be_writer.write(size); |
76 be_writer.write(time); |
79 be_writer.write(time); |
77 be_writer.write(JfrTicks::now().value() - time); |
80 be_writer.write(JfrTicks::now().value() - time); |
78 be_writer.write((u4)0); // not a flushpoint |
81 be_writer.write(mode); |
79 be_writer.write(type_count); |
82 be_writer.write(type_count); |
80 assert(be_writer.is_valid(), "invariant"); |
83 assert(be_writer.is_valid(), "invariant"); |
81 } |
84 } |
82 |
85 |
83 JfrCheckpointWriter::~JfrCheckpointWriter() { |
86 JfrCheckpointWriter::~JfrCheckpointWriter() { |
96 assert(this->is_valid(), "invariant"); |
99 assert(this->is_valid(), "invariant"); |
97 assert(count() > 0, "invariant"); |
100 assert(count() > 0, "invariant"); |
98 assert(this->used_size() > sizeof(JfrCheckpointEntry), "invariant"); |
101 assert(this->used_size() > sizeof(JfrCheckpointEntry), "invariant"); |
99 const int64_t size = this->current_offset(); |
102 const int64_t size = this->current_offset(); |
100 assert(size + this->start_pos() == this->current_pos(), "invariant"); |
103 assert(size + this->start_pos() == this->current_pos(), "invariant"); |
101 write_checkpoint_header(const_cast<u1*>(this->start_pos()), size, _time, count()); |
104 write_checkpoint_header(const_cast<u1*>(this->start_pos()), size, _time, _mode, count()); |
102 release(); |
105 release(); |
103 } |
106 } |
104 |
107 |
105 u4 JfrCheckpointWriter::count() const { |
108 u4 JfrCheckpointWriter::count() const { |
106 return _count; |
109 return _count; |
154 *size = this->current_pos() - session_start_pos; |
157 *size = this->current_pos() - session_start_pos; |
155 return session_start_pos; |
158 return session_start_pos; |
156 } |
159 } |
157 *size = this->used_size(); |
160 *size = this->used_size(); |
158 assert(this->start_pos() + *size == this->current_pos(), "invariant"); |
161 assert(this->start_pos() + *size == this->current_pos(), "invariant"); |
159 write_checkpoint_header(const_cast<u1*>(this->start_pos()), this->used_offset(), _time, count()); |
162 write_checkpoint_header(const_cast<u1*>(this->start_pos()), this->used_offset(), _time, _mode, count()); |
160 _header = false; // the header is already written |
163 _header = false; // the header is already written |
161 if (move) { |
164 if (move) { |
162 this->seek(_offset); |
165 this->seek(_offset); |
163 } |
166 } |
164 return this->start_pos(); |
167 return this->start_pos(); |