28 #include "memory/allocation.hpp"

    28 #include "utilities/macros.hpp"  // for CPU_HEADER() macro.

    29 #include "utilities/ostream.hpp"

    30 #include "utilities/macros.hpp"

    31 

    32 typedef enum {

    33   NoDetectedVirtualization,

    34   XenHVM,

    35   KVM,

    36   VMWare,

    37   HyperV,

    38   PowerVM, // on AIX or Linux ppc64(le)

    39   PowerFullPartitionMode, // on Linux ppc64(le)

    40   PowerKVM

    41 } VirtualizationType;

    42 

    43 // VM_Version provides information about the VM.

    44 

    45 class Abstract_VM_Version: AllStatic {

    46   friend class VMStructs;

    47   friend class JVMCIVMStructs;

    48 

    49  protected:

    50   static const char*  _s_vm_release;

    51   static const char*  _s_internal_vm_info_string;

    52 

    53   // CPU feature flags.

    54   static uint64_t _features;

    55   static const char* _features_string;

    56 

    57   // These are set by machine-dependent initializations

    58   static bool         _supports_cx8;

    59   static bool         _supports_atomic_getset4;

    60   static bool         _supports_atomic_getset8;

    61   static bool         _supports_atomic_getadd4;

    62   static bool         _supports_atomic_getadd8;

    63   static unsigned int _logical_processors_per_package;

    64   static unsigned int _L1_data_cache_line_size;

    65   static int          _vm_major_version;

    66   static int          _vm_minor_version;

    67   static int          _vm_security_version;

    68   static int          _vm_patch_version;

    69   static int          _vm_build_number;

    70   static unsigned int _data_cache_line_flush_size;

    71 

    72   static VirtualizationType _detected_virtualization;

    73 

    74  public:

    75   // Called as part of the runtime services initialization which is

    76   // called from the management module initialization (via init_globals())

    77   // after argument parsing and attaching of the main thread has

    78   // occurred.  Examines a variety of the hardware capabilities of

    79   // the platform to determine which features can be used to execute the

    80   // program.

    81   static void initialize() { }

    82 

    83   // This allows for early initialization of VM_Version information

    84   // that may be needed later in the initialization sequence but before

    85   // full VM_Version initialization is possible. It can not depend on any

    86   // other part of the VM being initialized when called. Platforms that

    87   // need to specialize this define VM_Version::early_initialize().

    88   static void early_initialize() { }

    89 

    90   // Called to initialize VM variables needing initialization

    91   // after command line parsing. Platforms that need to specialize

    92   // this should define VM_Version::init_before_ergo().

    93   static void init_before_ergo() {}

    94 

    95   // Name

    96   static const char* vm_name();

    97   // Vendor

    98   static const char* vm_vendor();

    99   // VM version information string printed by launcher (java -version)

   100   static const char* vm_info_string();

   101   static const char* vm_release();

   102   static const char* vm_platform_string();

   103   static const char* vm_build_user();

   104 

   105   static int vm_major_version()               { return _vm_major_version; }

   106   static int vm_minor_version()               { return _vm_minor_version; }

   107   static int vm_security_version()            { return _vm_security_version; }

   108   static int vm_patch_version()               { return _vm_patch_version; }

   109   static int vm_build_number()                { return _vm_build_number; }

   110 

   111   // Gets the jvm_version_info.jvm_version defined in jvm.h

   112   static unsigned int jvm_version();

   113 

   114   // Internal version providing additional build information

   115   static const char* internal_vm_info_string();

   116   static const char* jre_release_version();

   117   static const char* jdk_debug_level();

   118   static const char* printable_jdk_debug_level();

   119 

   120   static uint64_t features() {

   121     return _features;

   122   }

   123 

   124   static const char* features_string() {

   125     return _features_string;

   126   }

   127 

   128   static VirtualizationType get_detected_virtualization() {

   129     return _detected_virtualization;

   130   }

   131 

   132   // platforms that need to specialize this

   133   // define VM_Version::print_platform_virtualization_info()

   134   static void print_platform_virtualization_info(outputStream*) { }

   135 

   136   // does HW support an 8-byte compare-exchange operation?

   137   static bool supports_cx8()  {

   138 #ifdef SUPPORTS_NATIVE_CX8

   139     return true;

   140 #else

   141     return _supports_cx8;

   142 #endif

   143   }

   144   // does HW support atomic get-and-set or atomic get-and-add?  Used

   145   // to guide intrinsification decisions for Unsafe atomic ops

   146   static bool supports_atomic_getset4()  {return _supports_atomic_getset4;}

   147   static bool supports_atomic_getset8()  {return _supports_atomic_getset8;}

   148   static bool supports_atomic_getadd4()  {return _supports_atomic_getadd4;}

   149   static bool supports_atomic_getadd8()  {return _supports_atomic_getadd8;}

   150 

   151   static unsigned int logical_processors_per_package() {

   152     return _logical_processors_per_package;

   153   }

   154 

   155   static unsigned int L1_data_cache_line_size() {

   156     return _L1_data_cache_line_size;

   157   }

   158 

   159   // the size in bytes of a data cache line flushed by a flush

   160   // operation which should be a power of two or zero if cache line

   161   // writeback is not supported by the current os_cpu combination

   162   static unsigned int data_cache_line_flush_size() {

   163     return _data_cache_line_flush_size;

   164   }

   165 

   166   // returns true if and only if cache line writeback is supported

   167   static bool supports_data_cache_line_flush() {

   168     return _data_cache_line_flush_size != 0;

   169   }

   170 

   171   // ARCH specific policy for the BiasedLocking

   172   static bool use_biased_locking()  { return true; }

   173 

   174   // Number of page sizes efficiently supported by the hardware.  Most chips now

   175   // support two sizes, thus this default implementation.  Processor-specific

   176   // subclasses should define new versions to hide this one as needed.  Note

   177   // that the O/S may support more sizes, but at most this many are used.

   178   static uint page_size_count() { return 2; }

   179 

   180   // Denominator for computing default ParallelGCThreads for machines with

   181   // a large number of cores.

   182   static uint parallel_worker_threads_denominator() { return 8; }

   183 

   184   // Does this CPU support spin wait instruction?

   185   static bool supports_on_spin_wait() { return false; }

   186 

   187   // Does platform support fast class initialization checks for static methods?

   188   static bool supports_fast_class_init_checks() { return false; }

   189 

   190   static bool print_matching_lines_from_file(const char* filename, outputStream* st, const char* keywords_to_match[]);

   191 };

   192