vm_version_sparc.hpp 7.9 KB
Newer Older
D
duke 已提交
1
/*
2
 * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
D
duke 已提交
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
 * 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.
 *
19 20 21
 * 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.
D
duke 已提交
22 23 24
 *
 */

25 26 27 28 29 30
#ifndef CPU_SPARC_VM_VM_VERSION_SPARC_HPP
#define CPU_SPARC_VM_VM_VERSION_SPARC_HPP

#include "runtime/globals_extension.hpp"
#include "runtime/vm_version.hpp"

D
duke 已提交
31 32 33
class VM_Version: public Abstract_VM_Version {
protected:
  enum Feature_Flag {
K
kvn 已提交
34 35 36 37 38 39 40 41 42
    v8_instructions      = 0,
    hardware_mul32       = 1,
    hardware_div32       = 2,
    hardware_fsmuld      = 3,
    hardware_popc        = 4,
    v9_instructions      = 5,
    vis1_instructions    = 6,
    vis2_instructions    = 7,
    sun4v_instructions   = 8,
43
    blk_init_instructions = 9,
K
kvn 已提交
44 45 46
    fmaf_instructions    = 10,
    fmau_instructions    = 11,
    vis3_instructions    = 12,
47 48 49 50 51
    cbcond_instructions  = 13,
    sparc64_family       = 14,
    M_family             = 15,
    T_family             = 16,
    T1_model             = 17
D
duke 已提交
52 53 54
  };

  enum Feature_Flag_Set {
55 56
    unknown_m           = 0,
    all_features_m      = -1,
D
duke 已提交
57

K
kvn 已提交
58 59 60 61 62 63 64 65 66
    v8_instructions_m       = 1 << v8_instructions,
    hardware_mul32_m        = 1 << hardware_mul32,
    hardware_div32_m        = 1 << hardware_div32,
    hardware_fsmuld_m       = 1 << hardware_fsmuld,
    hardware_popc_m         = 1 << hardware_popc,
    v9_instructions_m       = 1 << v9_instructions,
    vis1_instructions_m     = 1 << vis1_instructions,
    vis2_instructions_m     = 1 << vis2_instructions,
    sun4v_m                 = 1 << sun4v_instructions,
67
    blk_init_instructions_m = 1 << blk_init_instructions,
K
kvn 已提交
68 69 70
    fmaf_instructions_m     = 1 << fmaf_instructions,
    fmau_instructions_m     = 1 << fmau_instructions,
    vis3_instructions_m     = 1 << vis3_instructions,
71
    cbcond_instructions_m   = 1 << cbcond_instructions,
K
kvn 已提交
72
    sparc64_family_m        = 1 << sparc64_family,
73
    M_family_m              = 1 << M_family,
K
kvn 已提交
74 75
    T_family_m              = 1 << T_family,
    T1_model_m              = 1 << T1_model,
D
duke 已提交
76

77 78 79
    generic_v8_m        = v8_instructions_m | hardware_mul32_m | hardware_div32_m | hardware_fsmuld_m,
    generic_v9_m        = generic_v8_m | v9_instructions_m,
    ultra3_m            = generic_v9_m | vis1_instructions_m | vis2_instructions_m,
D
duke 已提交
80 81

    // Temporary until we have something more accurate
82 83
    niagara1_unique_m   = sun4v_m,
    niagara1_m          = generic_v9_m | niagara1_unique_m
D
duke 已提交
84 85 86 87 88 89 90 91 92
  };

  static int  _features;
  static const char* _features_str;

  static void print_features();
  static int  determine_features();
  static int  platform_features(int features);

93
  // Returns true if the platform is in the niagara line (T series)
94
  static bool is_M_family(int features) { return (features & M_family_m) != 0; }
95 96
  static bool is_T_family(int features) { return (features & T_family_m) != 0; }
  static bool is_niagara() { return is_T_family(_features); }
97 98 99 100 101 102 103
#ifdef ASSERT
  static bool is_niagara(int features)  {
    // 'sun4v_m' may be defined on both Sun/Oracle Sparc CPUs as well as
    // on Fujitsu Sparc64 CPUs, but only Sun/Oracle Sparcs can be 'niagaras'.
    return (features & sun4v_m) != 0 && (features & sparc64_family_m) == 0;
  }
#endif
104 105 106

  // Returns true if it is niagara1 (T1).
  static bool is_T1_model(int features) { return is_T_family(features) && ((features & T1_model_m) != 0); }
D
duke 已提交
107

108 109
  static int maximum_niagara1_processor_count() { return 32; }

D
duke 已提交
110 111 112 113 114 115 116
public:
  // Initialization
  static void initialize();

  // Instruction support
  static bool has_v8()                  { return (_features & v8_instructions_m) != 0; }
  static bool has_v9()                  { return (_features & v9_instructions_m) != 0; }
117 118
  static bool has_hardware_mul32()      { return (_features & hardware_mul32_m) != 0; }
  static bool has_hardware_div32()      { return (_features & hardware_div32_m) != 0; }
D
duke 已提交
119
  static bool has_hardware_fsmuld()     { return (_features & hardware_fsmuld_m) != 0; }
120
  static bool has_hardware_popc()       { return (_features & hardware_popc_m) != 0; }
D
duke 已提交
121 122
  static bool has_vis1()                { return (_features & vis1_instructions_m) != 0; }
  static bool has_vis2()                { return (_features & vis2_instructions_m) != 0; }
123
  static bool has_vis3()                { return (_features & vis3_instructions_m) != 0; }
124
  static bool has_blk_init()            { return (_features & blk_init_instructions_m) != 0; }
K
kvn 已提交
125
  static bool has_cbcond()              { return (_features & cbcond_instructions_m) != 0; }
D
duke 已提交
126 127 128 129

  static bool supports_compare_and_exchange()
                                        { return has_v9(); }

130 131 132
  // Returns true if the platform is in the niagara line (T series)
  // and newer than the niagara1.
  static bool is_niagara_plus()         { return is_T_family(_features) && !is_T1_model(_features); }
133 134

  static bool is_M_series()             { return is_M_family(_features); }
135
  static bool is_T4()                   { return is_T_family(_features) && has_cbcond(); }
K
kvn 已提交
136

137 138 139
  // Fujitsu SPARC64
  static bool is_sparc64()              { return (_features & sparc64_family_m) != 0; }

K
kvn 已提交
140 141 142
  static bool is_sun4v()                { return (_features & sun4v_m) != 0; }
  static bool is_ultra3()               { return (_features & ultra3_m) == ultra3_m && !is_sun4v() && !is_sparc64(); }

143 144
  static bool has_fast_fxtof()          { return is_niagara() || is_sparc64() || has_v9() && !is_ultra3(); }
  static bool has_fast_idiv()           { return is_niagara_plus() || is_sparc64(); }
145

K
kvn 已提交
146
  // T4 and newer Sparc have fast RDPC instruction.
147 148
  static bool has_fast_rdpc()           { return is_T4(); }

K
kvn 已提交
149 150
  // On T4 and newer Sparc BIS to the beginning of cache line always zeros it.
  static bool has_block_zeroing()       { return has_blk_init() && is_T4(); }
D
duke 已提交
151 152 153

  static const char* cpu_features()     { return _features_str; }

154 155
  static intx prefetch_data_size()  {
    return is_T4() ? 32 : 64;  // default prefetch block size on sparc
D
duke 已提交
156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191
  }

  // Prefetch
  static intx prefetch_copy_interval_in_bytes() {
    intx interval = PrefetchCopyIntervalInBytes;
    return interval >= 0 ? interval : (has_v9() ? 512 : 0);
  }
  static intx prefetch_scan_interval_in_bytes() {
    intx interval = PrefetchScanIntervalInBytes;
    return interval >= 0 ? interval : (has_v9() ? 512 : 0);
  }
  static intx prefetch_fields_ahead() {
    intx count = PrefetchFieldsAhead;
    return count >= 0 ? count : (is_ultra3() ? 1 : 0);
  }

  static intx allocate_prefetch_distance() {
    // This method should be called before allocate_prefetch_style().
    intx count = AllocatePrefetchDistance;
    if (count < 0) { // default is not defined ?
      count = 512;
    }
    return count;
  }
  static intx allocate_prefetch_style() {
    assert(AllocatePrefetchStyle >= 0, "AllocatePrefetchStyle should be positive");
    // Return 0 if AllocatePrefetchDistance was not defined.
    return AllocatePrefetchDistance > 0 ? AllocatePrefetchStyle : 0;
  }

  // Assembler testing
  static void allow_all();
  static void revert();

  // Override the Abstract_VM_Version implementation.
  static uint page_size_count() { return is_sun4v() ? 4 : 2; }
192 193 194

  // Calculates the number of parallel threads
  static unsigned int calc_parallel_worker_threads();
D
duke 已提交
195
};
196 197

#endif // CPU_SPARC_VM_VM_VERSION_SPARC_HPP