[GR-69714]: Introduce storing 32-bit values into the PyObject* handles.

PullRequest: graalpython/3997

Author: timfel

.gitignore

@@ -97,3 +97,4 @@ pom-mx.xml
 /*-venv/
 .aider*
 *.iprof.gz
+compile_commands.json

graalpython/com.oracle.graal.python.benchmarks/python/micro/c-call-method-minimal.py

@@ -0,0 +1,86 @@
+# Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved.
+# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+#
+# The Universal Permissive License (UPL), Version 1.0
+#
+# Subject to the condition set forth below, permission is hereby granted to any
+# person obtaining a copy of this software, associated documentation and/or
+# data (collectively the "Software"), free of charge and under any and all
+# copyright rights in the Software, and any and all patent rights owned or
+# freely licensable by each licensor hereunder covering either (i) the
+# unmodified Software as contributed to or provided by such licensor, or (ii)
+# the Larger Works (as defined below), to deal in both
+#
+# (a) the Software, and
+#
+# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if
+# one is included with the Software each a "Larger Work" to which the Software
+# is contributed by such licensors),
+#
+# without restriction, including without limitation the rights to copy, create
+# derivative works of, display, perform, and distribute the Software and make,
+# use, sell, offer for sale, import, export, have made, and have sold the
+# Software and the Larger Work(s), and to sublicense the foregoing rights on
+# either these or other terms.
+#
+# This license is subject to the following condition:
+#
+# The above copyright notice and either this complete permission notice or at a
+# minimum a reference to the UPL must be included in all copies or substantial
+# portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+code = """
+#include "Python.h"
+
+PyObject* simple_method(PyObject* mod, PyObject* arg) {
+    return PyFloat_FromDouble(PyFloat_AsDouble(arg));
+}
+
+static PyMethodDef MyModuleMethods[] = {
+    {"as_double", simple_method, METH_O, NULL},
+    {NULL, NULL, 0, NULL}  // Sentinel
+};
+
+static PyModuleDef c_min_method_module = {
+    PyModuleDef_HEAD_INIT,
+    "int_float_method_module",
+    NULL,
+    -1,
+    MyModuleMethods
+};
+
+PyMODINIT_FUNC
+PyInit_c_min_method_module(void)
+{
+    return PyModule_Create(&c_min_method_module);
+}
+"""
+
+
+ccompile("c_min_method_module", code)
+from c_min_method_module import as_double
+
+# ~igv~: function_root_count_at
+def count(num):
+    print("###### NUM: " + str(num))
+    for i in range(num):
+        if 42 != as_double(42):
+            raise RuntimeError()
+    return 0
+
+
+def measure(num):
+    result = count(num)
+    return result
+
+
+def __benchmark__(num=1000000):
+    return measure(num)

graalpython/com.oracle.graal.python.cext/CMakeLists.txt

@@ -36,6 +36,8 @@ function(require_var var)
 endfunction()
 
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+add_custom_target(compile_commands_target ALL
+  COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_BINARY_DIR}/compile_commands.json" "${CMAKE_SOURCE_DIR}")
 
 require_var(GRAALPY_PARENT_DIR)
 require_var(CAPI_INC_DIR)

graalpython/com.oracle.graal.python.cext/compile_flags.txt

@@ -1,4 +1,4 @@
-/* Copyright (c) 2020, 2024, Oracle and/or its affiliates.
+/* Copyright (c) 2020, 2025, Oracle and/or its affiliates.
  * Copyright (C) 1996-2020 Python Software Foundation
  *
  * Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2

graalpython/com.oracle.graal.python.cext/include/cpython/pystate.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2024, 2024, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2024, 2025, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * The Universal Permissive License (UPL), Version 1.0
@@ -45,12 +45,50 @@
 #include <object.h>
 
 #define MANAGED_REFCNT 10
-#define HANDLE_BASE 0x8000000000000000ULL
+
+/*
+ * We cannot do NaN tagging. Even if we rely on running systems that use at
+ * most 48 bits for their adresses (so not running with PML5/la57 enabled), we
+ * do not control all allocations, so PyObject* allocated somewhere else will
+ * not be tagged and thus are indistinguishable from subnormal floating point
+ * values or +0.0 for NULL values. Additionally, we know that at least cffi
+ * uses tagging of the low 3 alignment bits o PyObject* and thus those also
+ * need to be 0 for anything we hand out. So we can realistically only use the
+ * upper 16 and lower 45 bits, which isn't enough to do NaN tagging (unless we
+ * want to do weird stuff like disallow certain double bit patterns). So the
+ * thing we can do is to tag managed pointers, 32-bit integers, and double
+ * values that fit into single-precision floats without loss.
+ */
+
+// Aligned with the same constants in CApiTransitions. Update comment there if
+// you change or move these.
+#define HANDLE_TAG_BIT  ((uint64_t)(1ULL << 63))
+#define INTEGER_TAG_BIT ((uint64_t)(1ULL << 62))
+#define FLOAT_TAG_BIT   ((uint64_t)(1ULL << 61))
+
  // IMMORTAL_REFCNT value is aligned with include/object.h
 #define IMMORTAL_REFCNT 0xFFFFFFFFL
+#define _35_BIT_MASK (0xFFFFFFFFULL << 3)
+
+#define points_to_py_handle_space(PTR) (((uint64_t)(uintptr_t)(PTR)) & HANDLE_TAG_BIT)
+#define points_to_py_int_handle(PTR) (((uint64_t)(uintptr_t)(PTR)) & INTEGER_TAG_BIT)
+#define points_to_py_float_handle(PTR) (((uint64_t)(uintptr_t)(PTR)) & FLOAT_TAG_BIT)
+
+#define stub_to_pointer(STUB_PTR) ((uintptr_t)(((uint64_t)(uintptr_t)(PTR)) | HANDLE_TAG_BIT))
+#define int32_to_pointer(INT)       ((uintptr_t)((((uint64_t)(uint32_t)(INT) << 3) & _35_BIT_MASK) | HANDLE_TAG_BIT | INTEGER_TAG_BIT))
+static inline PyObject* float_to_pointer(float dbl) {
+    uint32_t float_bits;
+    memcpy(&float_bits, &dbl, sizeof(float));
+    return (PyObject *)(uintptr_t)(((((uint64_t)float_bits) << 3) & _35_BIT_MASK) | HANDLE_TAG_BIT | FLOAT_TAG_BIT);
+}
 
-#define points_to_py_handle_space(PTR) ((((uintptr_t) (PTR)) & HANDLE_BASE) != 0)
-#define stub_to_pointer(STUB_PTR) (((uintptr_t) (STUB_PTR)) | HANDLE_BASE)
-#define pointer_to_stub(PTR) ((PyObject *)(((uintptr_t) (PTR)) & ~HANDLE_BASE))
+#define pointer_to_stub(PTR)  ((PyObject*)(((uint64_t)(uintptr_t)(PTR)) & ~HANDLE_TAG_BIT))
+#define pointer_to_int64(PTR)   ((int64_t)(int32_t)(((uint64_t)(uintptr_t)(PTR)) >> 3))
+static inline double pointer_to_double(PyObject* ptr) {
+    uint32_t float_bits = (uint32_t)(((uint64_t)(uintptr_t)ptr) >> 3);
+    float value;
+    memcpy(&value, &float_bits, sizeof(float));
+    return (double)value;
+}
 
 #endif /* SRC_HANDLES_H_ */

graalpython/com.oracle.graal.python.cext/include/graalpy/handles.h

@@ -33,7 +33,7 @@ static inline PyGC_Head* _Py_AS_GC(PyObject *op) {
 #define _PyGC_Head_UNUSED PyGC_Head
 
 // GraalPy change
-#define _PyGCHead_UNTAG(PTR) ((PyGC_Head *)(((uintptr_t) (PTR)) & ~HANDLE_BASE))
+#define _PyGCHead_UNTAG(PTR) ((PyGC_Head *)(((uintptr_t) (PTR)) & ~HANDLE_TAG_BIT))
 
 /* True if the object is currently tracked by the GC. */
 static inline int _PyObject_GC_IS_TRACKED(PyObject *op) {

graalpython/com.oracle.graal.python.cext/include/internal/pycore_gc.h

@@ -64,23 +64,22 @@ extern void _PyLong_FiniTypes(PyInterpreterState *interp);
 /* GraalVM change
 #define _PyLong_SMALL_INTS _Py_SINGLETON(small_ints)
 */
-#define _PyLong_SMALL_INT_PTRS (PyThreadState_GET()->small_ints)
 
 // Return a borrowed reference to the zero singleton.
 // The function cannot return NULL.
 static inline PyObject* _PyLong_GetZero(void)
 /* GraalVM change
 { return (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS]; }
 */
-{ return _PyLong_SMALL_INT_PTRS[_PY_NSMALLNEGINTS]; }
+{ return int32_to_pointer(0); }
 
 // Return a borrowed reference to the one singleton.
 // The function cannot return NULL.
 static inline PyObject* _PyLong_GetOne(void)
 /* GraalVM change
 { return (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS+1]; }
 */
-{ return _PyLong_SMALL_INT_PTRS[_PY_NSMALLNEGINTS+1]; }
+{ return int32_to_pointer(1); }
 
 static inline PyObject* _PyLong_FromUnsignedChar(unsigned char i)
 {

graalpython/com.oracle.graal.python.cext/include/internal/pycore_long.h

@@ -145,11 +145,20 @@ PyFloat_GetInfo(void)
 
     return floatinfo;
 }
+#endif
 
 PyObject *
 PyFloat_FromDouble(double fval)
 {
     PyFloatObject *op;
+    // GraalPy: different implementation
+    if (fval == (float)fval) {
+        return float_to_pointer(fval);
+    } else {
+        return GraalPyPrivate_Float_FromDouble(fval);
+    }
+}
+#if 0 // GraalPy change
 #if PyFloat_MAXFREELIST > 0
     struct _Py_float_state *state = get_float_state();
     op = state->free_list;
@@ -323,6 +332,9 @@ PyFloat_AsDouble(PyObject *op)
 
     // GraalPy change: upcall for managed
     if (points_to_py_handle_space(op)) {
+        if (points_to_py_int_handle(op)) {
+            return (double)pointer_to_int64(op);
+        }
         return GraalPyPrivate_Float_AsDouble(op);
     }
 
@@ -2661,6 +2673,9 @@ PyFloat_Unpack8(const char *data, int le)
 
 double GraalPyFloat_AS_DOUBLE(PyObject *op) {
     if (points_to_py_handle_space(op)) {
+        if (points_to_py_float_handle(op)) {
+            return pointer_to_double(op);
+        }
         return ((GraalPyFloatObject*) pointer_to_stub(op))->ob_fval;
     } else {
         return _PyFloat_CAST(op)->ob_fval;