jdk8-mips64-public/hotspot: comparison src/share/vm/services/heapDumper.cpp

-:626f594dffa6
+:ebd6745380b9
 enum {
 io_buffer_size  = 8*M
 };
 int _fd;              // file descriptor (-1 if dump file not open)
-jlong _bytes_written; // number of byte written to dump file
+julong _bytes_written; // number of byte written to dump file
 char* _buffer;    // internal buffer
-int _size;
+size_t _size;
-int _pos;
+size_t _pos;
 char* _error;   // error message when I/O fails
 void set_file_descriptor(int fd)              { _fd = fd; }
 int file_descriptor() const                   { return _fd; }
 char* buffer() const                          { return _buffer; }
-int buffer_size() const                       { return _size; }
+size_t buffer_size() const                    { return _size; }
-int position() const                          { return _pos; }
+size_t position() const                       { return _pos; }
-void set_position(int pos)                    { _pos = pos; }
+void set_position(size_t pos)                 { _pos = pos; }
 void set_error(const char* error)             { _error = (char*)os::strdup(error); }
 // all I/O go through this function
-void write_internal(void* s, int len);
+void write_internal(void* s, size_t len);
 public:
 DumpWriter(const char* path);
 ~DumpWriter();
 void close();
 bool is_open() const                  { return file_descriptor() >= 0; }
 void flush();
 // total number of bytes written to the disk
-jlong bytes_written() const           { return _bytes_written; }
+julong bytes_written() const          { return _bytes_written; }
 // adjust the number of bytes written to disk (used to keep the count
 // of the number of bytes written in case of rewrites)
-void adjust_bytes_written(jlong n)     { _bytes_written += n; }
+void adjust_bytes_written(jlong n)    { _bytes_written += n; }
 // number of (buffered) bytes as yet unwritten to the dump file
-jlong bytes_unwritten() const          { return (jlong)position(); }
+size_t bytes_unwritten() const        { return position(); }
 char* error() const                   { return _error; }
 jlong current_offset();
 void seek_to_offset(jlong pos);
 // writer functions
-void write_raw(void* s, int len);
+void write_raw(void* s, size_t len);
 void write_u1(u1 x)                   { write_raw((void*)&x, 1); }
 void write_u2(u2 x);
 void write_u4(u4 x);
 void write_u8(u8 x);
 void write_objectID(oop o);
 // closes dump file (if open)
 void DumpWriter::close() {
 // flush and close dump file
 if (is_open()) {
 flush();
-::close(file_descriptor());
+os::close(file_descriptor());
 set_file_descriptor(-1);
 }
 }
 // write directly to the file
-void DumpWriter::write_internal(void* s, int len) {
+void DumpWriter::write_internal(void* s, size_t len) {
 if (is_open()) {
-int n = ::write(file_descriptor(), s, len);
+const char* pos = (char*)s;
-if (n > 0) {
+ssize_t n = 0;
+while (len > 0) {
+uint tmp = (uint)MIN2(len, (size_t)UINT_MAX);
+n = os::write(file_descriptor(), pos, tmp);
+if (n < 0) {
+// EINTR cannot happen here, os::write will take care of that
+set_error(strerror(errno));
+os::close(file_descriptor());
+set_file_descriptor(-1);
+return;
+}
 _bytes_written += n;
-}
+pos += n;
-if (n != len) {
+len -= n;
-if (n < 0) {
-set_error(strerror(errno));
-} else {
-set_error("file size limit");
-}
-::close(file_descriptor());
-set_file_descriptor(-1);
 }
 }
 }
 // write raw bytes
-void DumpWriter::write_raw(void* s, int len) {
+void DumpWriter::write_raw(void* s, size_t len) {
 if (is_open()) {
-// flush buffer to make toom
+// flush buffer to make room
-if ((position()+ len) >= buffer_size()) {
+if ((position() + len) >= buffer_size()) {
 flush();
 }
 // buffer not available or too big to buffer it
 if ((buffer() == NULL) || (len >= buffer_size())) {
 write_internal(buffer(), position());
 set_position(0);
 }
 }
 jlong DumpWriter::current_offset() {
 if (is_open()) {
 // the offset is the file offset plus whatever we have buffered
 jlong offset = os::current_file_offset(file_descriptor());
 assert(offset >= 0, "lseek failed");
-return offset + (jlong)position();
+return offset + position();
 } else {
 return (jlong)-1;
 }
 }
 // returns the size of the instance of the given class
 u4 DumperSupport::instance_size(Klass* k) {
 HandleMark hm;
 instanceKlassHandle ikh = instanceKlassHandle(Thread::current(), k);
-int size = 0;
+u4 size = 0;
 for (FieldStream fld(ikh, false, false); !fld.eos(); fld.next()) {
 if (!fld.access_flags().is_static()) {
 Symbol* sig = fld.signature();
 switch (sig->byte_at(0)) {
 default : ShouldNotReachHere();
 }
 }
 }
-return (u4)size;
+return size;
 }
 // dumps static fields of the given class
 void DumperSupport::dump_static_fields(DumpWriter* writer, Klass* k) {
 HandleMark hm;
 if (array->length() == 0) {
 return;
 }
 // If the byte ordering is big endian then we can copy most types directly
-int length_in_bytes = array->length() * type2aelembytes(type);
+u4 length_in_bytes = (u4)array->length() * type2aelembytes(type);
-assert(length_in_bytes > 0, "nothing to copy");
 switch (type) {
 case T_INT : {
 if (Bytes::is_Java_byte_ordering_different()) {
 WRITE_ARRAY(array, int, u4);
 if (!java_lang_Class::is_primitive(o)) {
 return;
 }
 }
-// create a HPROF_GC_INSTANCE record for each object
 if (o->is_instance()) {
+// create a HPROF_GC_INSTANCE record for each object
 DumperSupport::dump_instance(writer(), o);
 mark_end_of_record();
-} else {
+} else if (o->is_objArray()) {
 // create a HPROF_GC_OBJ_ARRAY_DUMP record for each object array
-if (o->is_objArray()) {
+DumperSupport::dump_object_array(writer(), objArrayOop(o));
-DumperSupport::dump_object_array(writer(), objArrayOop(o));
+mark_end_of_record();
-mark_end_of_record();
+} else if (o->is_typeArray()) {
-} else {
+// create a HPROF_GC_PRIM_ARRAY_DUMP record for each type array
-// create a HPROF_GC_PRIM_ARRAY_DUMP record for each type array
+DumperSupport::dump_prim_array(writer(), typeArrayOop(o));
-if (o->is_typeArray()) {
+mark_end_of_record();
-DumperSupport::dump_prim_array(writer(), typeArrayOop(o));
-mark_end_of_record();
-}
-}
 }
 }
 // The VM operation that performs the heap dump
 class VM_HeapDumper : public VM_GC_Operation {
 void VM_HeapDumper::write_current_dump_record_length() {
 if (writer()->is_open()) {
 assert(dump_start() >= 0, "no dump start recorded");
 // calculate the size of the dump record
-jlong dump_end = writer()->current_offset();
+julong dump_end = writer()->current_offset();
-jlong dump_len = (dump_end - dump_start() - 4);
+julong dump_len = (dump_end - dump_start() - 4);
 // record length must fit in a u4
-if (dump_len > (jlong)(4L*(jlong)G)) {
+if (dump_len > max_juint) {
 warning("record is too large");
 }
 // seek to the dump start and fix-up the length
 writer()->seek_to_offset(dump_start());
 writer()->write_u4((u4)dump_len);
 // adjust the total size written to keep the bytes written correct.
-writer()->adjust_bytes_written(-((long) sizeof(u4)));
+writer()->adjust_bytes_written(-((jlong) sizeof(u4)));
 // seek to dump end so we can continue
 writer()->seek_to_offset(dump_end);
 // no current dump record
 // new segment.
 void VM_HeapDumper::check_segment_length() {
 if (writer()->is_open()) {
 if (is_segmented_dump()) {
 // don't use current_offset that would be too expensive on a per record basis
-jlong dump_end = writer()->bytes_written() + writer()->bytes_unwritten();
+julong dump_end = writer()->bytes_written() + writer()->bytes_unwritten();
-assert(dump_end == writer()->current_offset(), "checking");
+assert(dump_end == (julong)writer()->current_offset(), "checking");
-jlong dump_len = (dump_end - dump_start() - 4);
+julong dump_len = (dump_end - dump_start() - 4);
-assert(dump_len >= 0 && dump_len <= max_juint, "bad dump length");
+assert(dump_len <= max_juint, "bad dump length");
-if (dump_len > (jlong)HeapDumpSegmentSize) {
+if (dump_len > HeapDumpSegmentSize) {
 write_current_dump_record_length();
 write_dump_header();
 }
 }
 }
 // print message in interactive case
 if (print_to_tty()) {
 timer()->stop();
 if (error() == NULL) {
-char msg[256];
+tty->print_cr("Heap dump file created [" JULONG_FORMAT " bytes in %3.3f secs]",
-sprintf(msg, "Heap dump file created [%s bytes in %3.3f secs]",
+writer.bytes_written(), timer()->seconds());
-JLONG_FORMAT, timer()->seconds());
-PRAGMA_DIAG_PUSH
-PRAGMA_FORMAT_NONLITERAL_IGNORED_INTERNAL
-tty->print_cr(msg, writer.bytes_written());
-PRAGMA_DIAG_POP
 } else {
 tty->print_cr("Dump file is incomplete: %s", writer.error());
 }
 }

Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/services/heapDumper.cpp

src/share/vm/services/heapDumper.cpp