1 /*

     2  * Copyright (c) 2016, 2018, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    20  * or visit www.oracle.com if you need additional information or have any

    21  * questions.

    22  *

    23  */

    24 

    25 #ifndef SHARE_VM_JFR_WRITERS_JFRWRITERHOST_INLINE_HPP

    26 #define SHARE_VM_JFR_WRITERS_JFRWRITERHOST_INLINE_HPP

    27 

    28 #include "classfile/javaClasses.hpp"

    29 #include "jfr/recorder/checkpoint/types/traceid/jfrTraceId.inline.hpp"

    30 #include "jfr/recorder/service/jfrOptionSet.hpp"

    31 #include "jfr/writers/jfrEncoding.hpp"

    32 #include "jfr/writers/jfrWriterHost.hpp"

    33 #include "memory/resourceArea.hpp"

    34 #include "oops/oop.hpp"

    35 #include "oops/symbol.hpp"

    36 #include "oops/typeArrayOop.inline.hpp"

    37 

    38 inline bool compressed_integers() {

    39   static const bool comp_integers = JfrOptionSet::compressed_integers();

    40   return comp_integers;

    41 }

    42 

    43 template <typename BE, typename IE, typename WriterPolicyImpl >

    44 template <typename T>

    45 inline void WriterHost<BE, IE, WriterPolicyImpl>::write_padded(T value) {

    46   write_padded(&value, 1);

    47 }

    48 

    49 template <typename BE, typename IE, typename WriterPolicyImpl >

    50 template <typename T>

    51 inline void WriterHost<BE, IE, WriterPolicyImpl>::write_padded(const T* value, size_t len) {

    52   assert(value != NULL, "invariant");

    53   assert(len > 0, "invariant");

    54   u1* const pos = ensure_size(sizeof(T) * len);

    55   if (pos) {

    56     this->set_current_pos(write_padded(value, len, pos));

    57   }

    58 }

    59 

    60 template <typename BE, typename IE, typename WriterPolicyImpl >

    61 template <typename T>

    62 inline u1* WriterHost<BE, IE, WriterPolicyImpl>::write_padded(const T* value, size_t len, u1* pos) {

    63   assert(value != NULL, "invariant");

    64   assert(len > 0, "invariant");

    65   assert(pos != NULL, "invariant");

    66   return _compressed_integers ? IE::write_padded(value, len, pos) : BE::write_padded(value, len, pos);

    67 }

    68 

    69 template <typename BE, typename IE, typename WriterPolicyImpl >

    70 template <typename T>

    71 inline void WriterHost<BE, IE, WriterPolicyImpl>::write(const T* value, size_t len) {

    72   assert(value != NULL, "invariant");

    73   assert(len > 0, "invariant");

    74   u1* const pos = ensure_size(sizeof(T) * len);

    75   if (pos) {

    76     this->set_current_pos(write(value, len, pos));

    77   }

    78 }

    79 

    80 template <typename BE, typename IE, typename WriterPolicyImpl >

    81 template <typename T>

    82 inline u1* WriterHost<BE, IE, WriterPolicyImpl>::write(const T* value, size_t len, u1* pos) {

    83   assert(value != NULL, "invariant");

    84   assert(len > 0, "invariant");

    85   assert(pos != NULL, "invariant");

    86   return _compressed_integers ? IE::write(value, len, pos) : BE::write(value, len, pos);

    87 }

    88 

    89 template <typename BE, typename IE, typename WriterPolicyImpl>

    90 void WriterHost<BE, IE, WriterPolicyImpl>::write_utf8(const char* value) {

    91   if (NULL == value) {

    92     // only write encoding byte indicating NULL string

    93     write<u1>(NULL_STRING);

    94     return;

    95   }

    96   write<u1>(UTF8); // designate encoding

    97   const jint len = MIN2<jint>(max_jint, (jint)strlen(value));

    98   write(len);

    99   if (len > 0) {

   100     be_write(value, len);

   101   }

   102 }

   103 

   104 template <typename BE, typename IE, typename WriterPolicyImpl>

   105 void WriterHost<BE, IE, WriterPolicyImpl>::write_utf16(const jchar* value, jint len) {

   106   assert(value != NULL, "invariant");

   107   write((u1)UTF16); // designate encoding

   108   write(len);

   109   if (len > 0) {

   110     write(value, len);

   111   }

   112 }

   113 

   114 template <typename BE, typename IE, typename WriterPolicyImpl >

   115 template <typename T>

   116 inline void WriterHost<BE, IE, WriterPolicyImpl>::be_write(T value) {

   117   u1* const pos = ensure_size(sizeof(T));

   118   if (pos) {

   119     this->set_current_pos(BE::be_write(&value, 1, pos));

   120   }

   121 }

   122 

   123 template <typename BE, typename IE, typename WriterPolicyImpl >

   124 template <typename T>

   125 inline void WriterHost<BE, IE, WriterPolicyImpl>::be_write(const T* value, size_t len) {

   126   assert(value != NULL, "invariant");

   127   assert(len > 0, "invariant");

   128   u1* const pos = ensure_size(sizeof(T) * len);

   129   if (pos) {

   130     this->set_current_pos(BE::be_write(value, len, pos));

   131   }

   132 }

   133 

   134 template <typename BE, typename IE, typename WriterPolicyImpl >

   135 template <typename StorageType>

   136 inline WriterHost<BE, IE, WriterPolicyImpl>::WriterHost(StorageType* storage, Thread* thread) :

   137   WriterPolicyImpl(storage, thread),

   138   _compressed_integers(compressed_integers()) {

   139 }

   140 

   141 template <typename BE, typename IE, typename WriterPolicyImpl >

   142 template <typename StorageType>

   143 inline WriterHost<BE, IE, WriterPolicyImpl>::WriterHost(StorageType* storage, size_t size) :

   144   WriterPolicyImpl(storage, size),

   145   _compressed_integers(compressed_integers()) {

   146 }

   147 

   148 template <typename BE, typename IE, typename WriterPolicyImpl >

   149 inline WriterHost<BE, IE, WriterPolicyImpl>::WriterHost(Thread* thread) :

   150   WriterPolicyImpl(thread),

   151   _compressed_integers(compressed_integers()) {

   152 }

   153 

   154 // Extra size added as a safety cushion when dimensioning memory.

   155 // With varint encoding, the worst case is

   156 // associated with writing negative values.

   157 // For example, writing a negative s1 (-1)

   158 // will encode as 0xff 0x0f (2 bytes).

   159 // In this example, the sizeof(T) == 1 and length == 1,

   160 // but the implementation will need to dimension

   161 // 2 bytes for the encoding.

   162 // Hopefully, negative values should be relatively rare.

   163 static const size_t size_safety_cushion = 1;

   164 

   165 template <typename BE, typename IE, typename WriterPolicyImpl>

   166 inline u1* WriterHost<BE, IE, WriterPolicyImpl>::ensure_size(size_t requested) {

   167   if (!this->is_valid()) {

   168     // cancelled

   169     return NULL;

   170   }

   171   if (this->available_size() < requested + size_safety_cushion) {

   172     if (!this->accommodate(this->used_size(), requested + size_safety_cushion)) {

   173       this->cancel();

   174       return NULL;

   175     }

   176   }

   177   assert(requested + size_safety_cushion <= this->available_size(), "invariant");

   178   return this->current_pos();

   179 }

   180 

   181 template <typename BE, typename IE, typename WriterPolicyImpl>

   182 template <typename T>

   183 inline void WriterHost<BE, IE, WriterPolicyImpl>::write(T value) {

   184   write(&value, 1);

   185 }

   186 

   187 template <typename BE, typename IE, typename WriterPolicyImpl>

   188 inline void WriterHost<BE, IE, WriterPolicyImpl>::write(bool value) {

   189   be_write((u1)value);

   190 }

   191 

   192 template <typename BE, typename IE, typename WriterPolicyImpl>

   193 inline void WriterHost<BE, IE, WriterPolicyImpl>::write(float value) {

   194   be_write(*(u4*)&(value));

   195 }

   196 

   197 template <typename BE, typename IE, typename WriterPolicyImpl>

   198 inline void WriterHost<BE, IE, WriterPolicyImpl>::write(double value) {

   199   be_write(*(uintptr_t*)&(value));

   200 }

   201 

   202 template <typename BE, typename IE, typename WriterPolicyImpl>

   203 inline void WriterHost<BE, IE, WriterPolicyImpl>::write(const char* value) {

   204   // UTF-8, max_jint len

   205   write_utf8(value);

   206 }

   207 

   208 template <typename BE, typename IE, typename WriterPolicyImpl>

   209 inline void WriterHost<BE, IE, WriterPolicyImpl>::write(char* value) {

   210   write(const_cast<const char*>(value));

   211 }

   212 

   213 template <typename BE, typename IE, typename WriterPolicyImpl>

   214 inline void WriterHost<BE, IE, WriterPolicyImpl>::write(jstring string) {

   215   if (string == NULL) {

   216     write<u1>(NULL_STRING);

   217     return;

   218   }

   219   const oop string_oop = JNIHandles::resolve_external_guard(string);

   220   assert(string_oop != NULL, "invariant");

   221   const size_t length = (size_t)java_lang_String::length(string_oop);

   222   if (0 == length) {

   223     write<u1>(EMPTY_STRING);

   224     return;

   225   }

   226   const bool is_latin1_encoded = java_lang_String::is_latin1(string_oop);

   227   const typeArrayOop value = java_lang_String::value(string_oop);

   228   assert(value != NULL, "invariant");

   229   if (is_latin1_encoded) {

   230     write<u1>(LATIN1);

   231     write<u4>((u4)length);

   232     be_write(value->byte_at_addr(0), length);

   233   } else {

   234     write<u1>(UTF16);

   235     write<u4>((u4)length);

   236     write(value->char_at_addr(0), length);

   237   }

   238 }

   239 

   240 template <typename Writer, typename T>

   241 inline void tag_write(Writer* w, const T* t) {

   242   assert(w != NULL, "invariant");

   243   const traceid id = t == NULL ? 0 : JfrTraceId::use(t);

   244   w->write(id);

   245 }

   246 

   247 template <typename BE, typename IE, typename WriterPolicyImpl>

   248 void WriterHost<BE, IE, WriterPolicyImpl>::write(const ClassLoaderData* cld) {

   249   tag_write(this, cld);

   250 }

   251 

   252 template <typename BE, typename IE, typename WriterPolicyImpl>

   253 void WriterHost<BE, IE, WriterPolicyImpl>::write(const Klass* klass) {

   254   tag_write(this, klass);

   255 }

   256 

   257 template <typename BE, typename IE, typename WriterPolicyImpl>

   258 void WriterHost<BE, IE, WriterPolicyImpl>::write(const Method* method) {

   259   tag_write(this, method);

   260 }

   261 

   262 template <typename BE, typename IE, typename WriterPolicyImpl>

   263 void WriterHost<BE, IE, WriterPolicyImpl>::write(const ModuleEntry* module) {

   264   tag_write(this, module);

   265 }

   266 

   267 template <typename BE, typename IE, typename WriterPolicyImpl>

   268 void WriterHost<BE, IE, WriterPolicyImpl>::write(const PackageEntry* package) {

   269   tag_write(this, package);

   270 }

   271 

   272 template <typename BE, typename IE, typename WriterPolicyImpl>

   273 void WriterHost<BE, IE, WriterPolicyImpl>::write(const Symbol* symbol) {

   274   ResourceMark rm;

   275   write_utf8(symbol != NULL ? symbol->as_C_string() : NULL);

   276 }

   277 

   278 template <typename BE, typename IE, typename WriterPolicyImpl>

   279 void WriterHost<BE, IE, WriterPolicyImpl>::write(const Ticks& time) {

   280   write((uintptr_t)JfrTime::is_ft_enabled() ? time.ft_value() : time.value());

   281 }

   282 

   283 template <typename BE, typename IE, typename WriterPolicyImpl>

   284 void WriterHost<BE, IE, WriterPolicyImpl>::write(const Tickspan& time) {

   285   write((uintptr_t)JfrTime::is_ft_enabled() ? time.ft_value() : time.value());

   286 }

   287 

   288 template <typename BE, typename IE, typename WriterPolicyImpl>

   289 void WriterHost<BE, IE, WriterPolicyImpl>::write(const JfrTicks& time) {

   290   write((uintptr_t)time.value());

   291 }

   292 

   293 template <typename BE, typename IE, typename WriterPolicyImpl>

   294 void WriterHost<BE, IE, WriterPolicyImpl>::write(const JfrTickspan& time) {

   295   write((uintptr_t)time.value());

   296 }

   297 

   298 template <typename BE, typename IE, typename WriterPolicyImpl>

   299 void WriterHost<BE, IE, WriterPolicyImpl>::bytes(const void* buf, size_t len) {

   300   u1* const pos = this->ensure_size(len);

   301   if (pos != NULL) {

   302     WriterPolicyImpl::bytes(pos, buf, len); // WriterPolicyImpl responsible for position update

   303   }

   304 }

   305 

   306 // UTF-8 for use with classfile/bytecodes

   307 template <typename BE, typename IE, typename WriterPolicyImpl>

   308 inline void WriterHost<BE, IE, WriterPolicyImpl>::write_utf8_u2_len(const char* value) {

   309   u2 len = 0;

   310   if (value != NULL) {

   311     len = MIN2<u2>(max_jushort, (u2)strlen(value));

   312   }

   313   write(len);

   314   if (len > 0) {

   315     be_write(value, len);

   316   }

   317 }

   318 

   319 template <typename BE, typename IE, typename WriterPolicyImpl>

   320 inline intptr_t WriterHost<BE, IE, WriterPolicyImpl>::reserve(size_t size) {

   321   if (ensure_size(size) != NULL) {

   322     intptr_t reserved_offset = this->current_offset();

   323     this->set_current_pos(size);

   324     return reserved_offset;

   325   }

   326   this->cancel();

   327   return 0;

   328 }

   329 

   330 template <typename BE, typename IE, typename WriterPolicyImpl>

   331 template <typename T>

   332 inline void WriterHost<BE, IE, WriterPolicyImpl>::write_padded_at_offset(T value, intptr_t offset) {

   333   if (this->is_valid()) {

   334     const intptr_t current = this->current_offset();

   335     this->seek(offset);

   336     write_padded(value);

   337     this->seek(current); // restore

   338   }

   339 }

   340 

   341 template <typename BE, typename IE, typename WriterPolicyImpl>

   342 template <typename T>

   343 inline void WriterHost<BE, IE, WriterPolicyImpl>::write_at_offset(T value, intptr_t offset) {

   344   if (this->is_valid()) {

   345     const intptr_t current = this->current_offset();

   346     this->seek(offset);

   347     write(value);

   348     this->seek(current); // restore

   349   }

   350 }

   351 

   352 template <typename BE, typename IE, typename WriterPolicyImpl>

   353 template <typename T>

   354 inline void WriterHost<BE, IE, WriterPolicyImpl>::write_be_at_offset(T value, intptr_t offset) {

   355   if (this->is_valid()) {

   356     const intptr_t current = this->current_offset();

   357     this->seek(offset);

   358     be_write(value);

   359     this->seek(current); // restore

   360   }

   361 }

   362 

   363 #endif // SHARE_VM_JFR_WRITERS_JFRWRITERHOST_INLINE_HPP

   364