Uploaded image for project: 'JDK'
  1. JDK
  2. JDK-8013168

extend the set of code pointers from Method to support multiple architectures

    Details

    • Type: Enhancement
    • Status: Closed
    • Priority: P4
    • Resolution: Duplicate
    • Affects Version/s: 9, 10
    • Fix Version/s: None
    • Component/s: hotspot
    • Labels:
      None

      Description

      We need to store GPU/APU code on selected methods, independently of normal CPU code.

      There are currently 5 words used in the Method struct to store code and structures relating to code. Even if we support only one type of GPU this means something like 5 more words.

      Let's think about merging all the pointers used to manage code (code, x_adapter, etc.) into a consolidated format that will save memory and allow new degrees of freedom.

      (This is similar to the work in JDK-8010862 that consolidated the method counters.)

      Note: The OSR side table might be able to go away also if we do this right.

      Consider an open api like:
        address Method::entry_point(enum EntryPointKind k, int subtype = 0)

      (Subtype is usually zero but may be BCI for an OSR nmethod, or what-not.)

      The data structure probably needs searching but can be organized so that search length is 1 almost always. Compact the common cases.

      EntryPointKinds for _code and for _gpu_code, for example.

      (Definition of GPU could be, "whatever we found besides the CPU when the JVM started". If there are up to 2 possibilities, CPU + GPU1 + GPU2, etc.)

      Existing pointer words relevant to enum EPK:
      {
        address _i2i_entry; // All-args-on-stack calling convention
        // Adapter blob (i2c/c2i) for this Method*. Set once when method is linked.
        AdapterHandlerEntry* _adapter;
        // Entry point for calling from compiled code, to compiled code if it exists
        // or else the interpreter.
        volatile address _from_compiled_entry; // Cache of: _code ? _code->entry_point() : _adapter->c2i_entry()
        // The entry point for calling both from and to compiled code is
        // "_code->entry_point()". Because of tiered compilation and de-opt, this
        // field can come and go. It can transition from NULL to not-null at any
        // time (whenever a compile completes). It can transition from not-null to
        // NULL only at safepoints (because of a de-opt).
        nmethod* volatile _code; // Points to the corresponding piece of native code
        volatile address _from_interpreted_entry; // Cache of _code ? _adapter->i2c_entry() : _i2i_entry
      }

        Attachments

          Issue Links

            Activity

              People

              • Assignee:
                iveresov Igor Veresov
                Reporter:
                jrose John Rose
              • Votes:
                0 Vote for this issue
                Watchers:
                6 Start watching this issue

                Dates

                • Created:
                  Updated:
                  Resolved: