/*

 * Copyright (c) 1997, 2017, Oracle and/or its affiliates. All rights reserved.

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

 *

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

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

 * published by the Free Software Foundation.

 *

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

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

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

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

 * accompanied this code).

 *

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

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

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

 *

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

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

 * questions.

 *

 */

#include "precompiled.hpp"

#include "classfile/compactHashtable.inline.hpp"

#include "classfile/javaClasses.hpp"

#include "logging/logMessage.hpp"

#include "memory/metadataFactory.hpp"

#include "memory/metaspaceShared.hpp"

#include "prims/jvm.h"

#include "runtime/vmThread.hpp"

#include "utilities/numberSeq.hpp"

#include <sys/stat.h>

/////////////////////////////////////////////////////

//

// The compact hash table writer implementations

//

CompactHashtableWriter::CompactHashtableWriter(int num_buckets,

                                               CompactHashtableStats* stats) {

  assert(DumpSharedSpaces, "dump-time only");

  assert(num_buckets > 0, "no buckets");

  _num_buckets = num_buckets;

  _num_entries = 0;

  _buckets = NEW_C_HEAP_ARRAY(GrowableArray<Entry>*, _num_buckets, mtSymbol);

  for (int i=0; i<_num_buckets; i++) {

    _buckets[i] = new (ResourceObj::C_HEAP, mtSymbol) GrowableArray<Entry>(0, true, mtSymbol);

  }

  _stats = stats;

  _compact_buckets = NULL;

  _compact_entries = NULL;

  _num_empty_buckets = 0;

  _num_value_only_buckets = 0;

  _num_other_buckets = 0;

}

CompactHashtableWriter::~CompactHashtableWriter() {

  for (int index = 0; index < _num_buckets; index++) {

    GrowableArray<Entry>* bucket = _buckets[index];

    delete bucket;

  }

  FREE_C_HEAP_ARRAY(GrowableArray<Entry>*, _buckets);

}

// Add a symbol entry to the temporary hash table

void CompactHashtableWriter::add(unsigned int hash, u4 value) {

  int index = hash % _num_buckets;

  _buckets[index]->append_if_missing(Entry(hash, value));

  _num_entries++;

}

void CompactHashtableWriter::allocate_table() {

  int entries_space = 0;

  for (int index = 0; index < _num_buckets; index++) {

    GrowableArray<Entry>* bucket = _buckets[index];

    int bucket_size = bucket->length();

    if (bucket_size == 1) {

      entries_space++;

    } else {

      entries_space += 2 * bucket_size;

    }

  }

  if (entries_space & ~BUCKET_OFFSET_MASK) {

    vm_exit_during_initialization("CompactHashtableWriter::allocate_table: Overflow! "

                                  "Too many entries.");

  }

  _compact_buckets = MetaspaceShared::new_ro_array<u4>(_num_buckets + 1);

  _compact_entries = MetaspaceShared::new_ro_array<u4>(entries_space);

  _stats->bucket_count    = _num_buckets;

  _stats->bucket_bytes    = _compact_buckets->size() * BytesPerWord;

  _stats->hashentry_count = _num_entries;

  _stats->hashentry_bytes = _compact_entries->size() * BytesPerWord;

}

// Write the compact table's buckets

void CompactHashtableWriter::dump_table(NumberSeq* summary) {

  u4 offset = 0;

  for (int index = 0; index < _num_buckets; index++) {

    GrowableArray<Entry>* bucket = _buckets[index];

    int bucket_size = bucket->length();

    if (bucket_size == 1) {

      // bucket with one entry is compacted and only has the symbol offset

      _compact_buckets->at_put(index, BUCKET_INFO(offset, VALUE_ONLY_BUCKET_TYPE));

      Entry ent = bucket->at(0);

      _compact_entries->at_put(offset++, ent.value());

      _num_value_only_buckets++;

    } else {

      // regular bucket, each entry is a symbol (hash, offset) pair

      _compact_buckets->at_put(index, BUCKET_INFO(offset, REGULAR_BUCKET_TYPE));

      for (int i=0; i<bucket_size; i++) {

        Entry ent = bucket->at(i);

        _compact_entries->at_put(offset++, u4(ent.hash())); // write entry hash

        _compact_entries->at_put(offset++, ent.value());

      }

      if (bucket_size == 0) {

        _num_empty_buckets++;

      } else {

        _num_other_buckets++;

      }

    }

    summary->add(bucket_size);

  }

  // Mark the end of the buckets

  _compact_buckets->at_put(_num_buckets, BUCKET_INFO(offset, TABLEEND_BUCKET_TYPE));

  assert(offset == (u4)_compact_entries->length(), "sanity");

}

// Write the compact table

void CompactHashtableWriter::dump(SimpleCompactHashtable *cht, const char* table_name) {

  NumberSeq summary;

  allocate_table();

  dump_table(&summary);

  int table_bytes = _stats->bucket_bytes + _stats->hashentry_bytes;

  address base_address = address(MetaspaceShared::shared_rs()->base());

  cht->init(base_address,  _num_entries, _num_buckets,

            _compact_buckets->data(), _compact_entries->data());

  if (log_is_enabled(Info, cds, hashtables)) {

    ResourceMark rm;

    LogMessage(cds, hashtables) msg;

    stringStream info_stream;

    double avg_cost = 0.0;

    if (_num_entries > 0) {

      avg_cost = double(table_bytes)/double(_num_entries);

    }

    info_stream.print_cr("Shared %s table stats -------- base: " PTR_FORMAT,

                         table_name, (intptr_t)base_address);

    info_stream.print_cr("Number of entries       : %9d", _num_entries);

    info_stream.print_cr("Total bytes used        : %9d", table_bytes);

    info_stream.print_cr("Average bytes per entry : %9.3f", avg_cost);

    info_stream.print_cr("Average bucket size     : %9.3f", summary.avg());

    info_stream.print_cr("Variance of bucket size : %9.3f", summary.variance());

    info_stream.print_cr("Std. dev. of bucket size: %9.3f", summary.sd());

    info_stream.print_cr("Empty buckets           : %9d", _num_empty_buckets);

    info_stream.print_cr("Value_Only buckets      : %9d", _num_value_only_buckets);

    info_stream.print_cr("Other buckets           : %9d", _num_other_buckets);

    msg.info("%s", info_stream.as_string());

  }

}

/////////////////////////////////////////////////////////////

//

// Customization for dumping Symbol and String tables

void CompactSymbolTableWriter::add(unsigned int hash, Symbol *symbol) {

  uintx deltax = MetaspaceShared::object_delta(symbol);

  // When the symbols are stored into the archive, we already check that

  // they won't be more than MAX_SHARED_DELTA from the base address, or

  // else the dumping would have been aborted.

  assert(deltax <= MAX_SHARED_DELTA, "must not be");

  u4 delta = u4(deltax);

  CompactHashtableWriter::add(hash, delta);

}

void CompactStringTableWriter::add(unsigned int hash, oop string) {

  CompactHashtableWriter::add(hash, oopDesc::encode_heap_oop(string));

}

void CompactSymbolTableWriter::dump(CompactHashtable<Symbol*, char> *cht) {

  CompactHashtableWriter::dump(cht, "symbol");

}

void CompactStringTableWriter::dump(CompactHashtable<oop, char> *cht) {

  CompactHashtableWriter::dump(cht, "string");

}

/////////////////////////////////////////////////////////////

//

// The CompactHashtable implementation

//

void SimpleCompactHashtable::serialize(SerializeClosure* soc) {

  soc->do_ptr((void**)&_base_address);

  soc->do_u4(&_entry_count);

  soc->do_u4(&_bucket_count);

  soc->do_ptr((void**)&_buckets);

  soc->do_ptr((void**)&_entries);

}

bool SimpleCompactHashtable::exists(u4 value) {

  assert(!DumpSharedSpaces, "run-time only");

  if (_entry_count == 0) {

    return false;

  }

  unsigned int hash = (unsigned int)value;

  int index = hash % _bucket_count;

  u4 bucket_info = _buckets[index];

  u4 bucket_offset = BUCKET_OFFSET(bucket_info);

  int bucket_type = BUCKET_TYPE(bucket_info);

  u4* entry = _entries + bucket_offset;

  if (bucket_type == VALUE_ONLY_BUCKET_TYPE) {

    return (entry[0] == value);

  } else {

    u4*entry_max = _entries + BUCKET_OFFSET(_buckets[index + 1]);

    while (entry <entry_max) {

      if (entry[1] == value) {

        return true;

      }

      entry += 2;

    }

    return false;

  }

}

template <class I>

inline void SimpleCompactHashtable::iterate(const I& iterator) {

  for (u4 i = 0; i < _bucket_count; i++) {

    u4 bucket_info = _buckets[i];

    u4 bucket_offset = BUCKET_OFFSET(bucket_info);

    int bucket_type = BUCKET_TYPE(bucket_info);

    u4* entry = _entries + bucket_offset;

    if (bucket_type == VALUE_ONLY_BUCKET_TYPE) {

      iterator.do_value(_base_address, entry[0]);

    } else {

      u4*entry_max = _entries + BUCKET_OFFSET(_buckets[i + 1]);

      while (entry < entry_max) {

        iterator.do_value(_base_address, entry[1]);

        entry += 2;

      }

    }

  }

}

template <class T, class N> void CompactHashtable<T, N>::serialize(SerializeClosure* soc) {

  SimpleCompactHashtable::serialize(soc);

  soc->do_u4(&_type);

}

class CompactHashtable_SymbolIterator {

  SymbolClosure* const _closure;

public:

  CompactHashtable_SymbolIterator(SymbolClosure *cl) : _closure(cl) {}

  inline void do_value(address base_address, u4 offset) const {

    Symbol* sym = (Symbol*)((void*)(base_address + offset));

    _closure->do_symbol(&sym);

  }

};

template <class T, class N> void CompactHashtable<T, N>::symbols_do(SymbolClosure *cl) {

  CompactHashtable_SymbolIterator iterator(cl);

  iterate(iterator);

}

class CompactHashtable_OopIterator {

  OopClosure* const _closure;

public:

  CompactHashtable_OopIterator(OopClosure *cl) : _closure(cl) {}

  inline void do_value(address base_address, u4 offset) const {

    narrowOop o = (narrowOop)offset;

    _closure->do_oop(&o);

  }

};

template <class T, class N> void CompactHashtable<T, N>::oops_do(OopClosure* cl) {

  assert(_type == _string_table || _bucket_count == 0, "sanity");

  CompactHashtable_OopIterator iterator(cl);

  iterate(iterator);

}

// Explicitly instantiate these types

template class CompactHashtable<Symbol*, char>;

template class CompactHashtable<oop, char>;

#ifndef O_BINARY       // if defined (Win32) use binary files.

#define O_BINARY 0     // otherwise do nothing.

#endif

////////////////////////////////////////////////////////

//

// HashtableTextDump

//

HashtableTextDump::HashtableTextDump(const char* filename) : _fd(-1) {

  struct stat st;

  if (os::stat(filename, &st) != 0) {

    quit("Unable to get hashtable dump file size", filename);

  }

  _size = st.st_size;

  _fd = open(filename, O_RDONLY | O_BINARY, 0);

  if (_fd < 0) {

    quit("Unable to open hashtable dump file", filename);

  }

  _base = os::map_memory(_fd, filename, 0, NULL, _size, true, false);

  if (_base == NULL) {

    quit("Unable to map hashtable dump file", filename);

  }

  _p = _base;

  _end = _base + st.st_size;

  _filename = filename;

  _prefix_type = Unknown;

  _line_no = 1;

}

HashtableTextDump::~HashtableTextDump() {

  os::unmap_memory((char*)_base, _size);

  if (_fd >= 0) {

    close(_fd);

  }

}

void HashtableTextDump::quit(const char* err, const char* msg) {

  vm_exit_during_initialization(err, msg);

}

void HashtableTextDump::corrupted(const char *p, const char* msg) {

  char info[100];

  jio_snprintf(info, sizeof(info),

               "%s. Corrupted at line %d (file pos %d)",

               msg, _line_no, (int)(p - _base));

  quit(info, _filename);

}

bool HashtableTextDump::skip_newline() {

  if (_p[0] == '\r' && _p[1] == '\n') {

    _p += 2;

  } else if (_p[0] == '\n') {

    _p += 1;

  } else {

    corrupted(_p, "Unexpected character");

  }

  _line_no++;

  return true;

}

int HashtableTextDump::skip(char must_be_char) {

  corrupted_if(remain() < 1, "Truncated");

  corrupted_if(*_p++ != must_be_char, "Unexpected character");

  return 0;

}

void HashtableTextDump::skip_past(char c) {

  for (;;) {

    corrupted_if(remain() < 1, "Truncated");

    if (*_p++ == c) {

      return;

    }

  }

}

void HashtableTextDump::check_version(const char* ver) {

  int len = (int)strlen(ver);

  corrupted_if(remain() < len, "Truncated");

  if (strncmp(_p, ver, len) != 0) {

    quit("wrong version of hashtable dump file", _filename);

  }

  _p += len;

  skip_newline();

}

void HashtableTextDump::scan_prefix_type() {

  _p++;

  if (strncmp(_p, "SECTION: String", 15) == 0) {

    _p += 15;

    _prefix_type = StringPrefix;

  } else if (strncmp(_p, "SECTION: Symbol", 15) == 0) {

    _p += 15;

    _prefix_type = SymbolPrefix;

  } else {

    _prefix_type = Unknown;

  }

  skip_newline();

}

int HashtableTextDump::scan_prefix(int* utf8_length) {

  if (*_p == '@') {

    scan_prefix_type();

  }

  switch (_prefix_type) {

  case SymbolPrefix:

    *utf8_length = scan_symbol_prefix(); break;

  case StringPrefix:

    *utf8_length = scan_string_prefix(); break;

  default:

    tty->print_cr("Shared input data type: Unknown.");

    corrupted(_p, "Unknown data type");

  }

  return _prefix_type;

}

int HashtableTextDump::scan_string_prefix() {

  // Expect /[0-9]+: /

  int utf8_length = 0;

  get_num(':', &utf8_length);

  if (*_p != ' ') {

    corrupted(_p, "Wrong prefix format for string");

  }

  _p++;

  return utf8_length;

}

int HashtableTextDump::scan_symbol_prefix() {

  // Expect /[0-9]+ (-|)[0-9]+: /

  int utf8_length = 0;

  get_num(' ', &utf8_length);

  if (*_p == '-') {

    _p++;

  }

  int ref_num;

  get_num(':', &ref_num);

  if (*_p != ' ') {

    corrupted(_p, "Wrong prefix format for symbol");

  }

  _p++;

  return utf8_length;

}

jchar HashtableTextDump::unescape(const char* from, const char* end, int count) {

  jchar value = 0;

  corrupted_if(from + count > end, "Truncated");

  for (int i=0; i<count; i++) {

    char c = *from++;

    switch (c) {

    case '0': case '1': case '2': case '3': case '4':

    case '5': case '6': case '7': case '8': case '9':

      value = (value << 4) + c - '0';

      break;

    case 'a': case 'b': case 'c':

    case 'd': case 'e': case 'f':

      value = (value << 4) + 10 + c - 'a';

      break;

    case 'A': case 'B': case 'C':

    case 'D': case 'E': case 'F':

      value = (value << 4) + 10 + c - 'A';

      break;

    default:

      ShouldNotReachHere();

    }

  }

  return value;

}

void HashtableTextDump::get_utf8(char* utf8_buffer, int utf8_length) {

  // cache in local vars

  const char* from = _p;

  const char* end = _end;

  char* to = utf8_buffer;

  int n = utf8_length;

  for (; n > 0 && from < end; n--) {

    if (*from != '\\') {

      *to++ = *from++;

    } else {

      corrupted_if(from + 2 > end, "Truncated");

      char c = from[1];

      from += 2;

      switch (c) {

      case 'x':

        {

          jchar value = unescape(from, end, 2);

          from += 2;

          assert(value <= 0xff, "sanity");

          *to++ = (char)(value & 0xff);

        }

        break;

      case 't':  *to++ = '\t'; break;

      case 'n':  *to++ = '\n'; break;

      case 'r':  *to++ = '\r'; break;

      case '\\': *to++ = '\\'; break;

      default:

        corrupted(_p, "Unsupported character");

      }

    }