simple arith-binop of benchmark for float subclass

Author: timfel

graalpython/benchmarks/src/micro/c_arith-binop.py

@@ -0,0 +1,113 @@
+# Copyright (c) 2017, 2018, Oracle and/or its affiliates.
+# Copyright (c) 2013, Regents of the University of California
+#
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification, are
+# permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this list of
+# conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright notice, this list of
+# conditions and the following disclaimer in the documentation and/or other materials provided
+# with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
+# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+# GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+# OF THE POSSIBILITY OF SUCH DAMAGE.
+# arithmetic ops (partially extracted from spectralnorm)
+
+code = """
+#include <Python.h>
+#include "structmember.h"
+
+static PyTypeObject FloatSubclass = {
+    PyVarObject_HEAD_INIT(NULL, 0)
+    "FloatSubclass", /* tp_name */
+    sizeof(PyFloatObject),  /* tp_basicsize */
+    0,                         /* tp_itemsize */
+    0,                         /* tp_dealloc */
+    0,                         /* tp_print */
+    0,                         /* tp_getattr */
+    0,                         /* tp_setattr */
+    0,                         /* tp_reserved */
+    0,                         /* tp_repr */
+    0,                         /* tp_as_number */
+    0,                         /* tp_as_sequence */
+    0,                         /* tp_as_mapping */
+    0,                         /* tp_hash  */
+    0,                         /* tp_call */
+    0,                         /* tp_str */
+    0,                         /* tp_getattro */
+    0,                         /* tp_setattro */
+    0,                         /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT |
+        Py_TPFLAGS_BASETYPE,   /* tp_flags */
+    "",                        /* tp_doc */
+    0,                         /* tp_traverse */
+    0,                         /* tp_clear */
+    0,                         /* tp_richcompare */
+    0,                         /* tp_weaklistoffset */
+    0,                         /* tp_iter */
+    0,                         /* tp_iternext */
+    0,                         /* tp_methods */
+    0,  /* tp_members */
+    0,                         /* tp_getset */
+    &PyFloat_Type,                         /* tp_base */
+    0,                         /* tp_dict */
+    0,                         /* tp_descr_get */
+    0,                         /* tp_descr_set */
+    0,                         /* tp_dictoffset */
+    0,      /* tp_init */
+    0,                         /* tp_alloc */
+    0,      /* tp_new */
+};
+
+static PyModuleDef module = {
+    PyModuleDef_HEAD_INIT,
+    "module",
+    "",
+    -1,
+    NULL, NULL, NULL, NULL, NULL
+};
+
+PyMODINIT_FUNC
+PyInit_c_arith_binop_module(void) {
+    PyType_Ready(&FloatSubclass);
+    PyObject* m = PyModule_Create(&module);
+    Py_INCREF(&FloatSubclass);
+    PyModule_AddObject(m, "FloatSubclass", (PyObject *)&FloatSubclass);
+    return m;
+}
+"""
+
+
+ccompile("c_arith_binop_module", code)
+from c_arith_binop_module import FloatSubclass
+
+
+def docompute(num):
+    for i in range(num):
+        sum_ = FloatSubclass(0.0)
+        j = FloatSubclass(0)
+        while j < num:
+            sum_ += 1.0 / ((i + j) * (i + j + 1) + i + 1)
+            j += 1
+
+    return sum_
+
+
+def measure(num):
+    for run in range(num):
+        sum_ = docompute(1000)
+    print("sum", sum_)
+
+
+def __benchmark__(num=5):
+    measure(num)

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/floats/FloatBuiltins.java

@@ -206,6 +206,28 @@ abstract static class AddNode extends PythonBinaryBuiltinNode {
             return left + right.doubleValue();
         }
 
+        @Specialization
+        Object doDP(PythonNativeObject left, long right,
+                        @Cached("nativeFloat()") FromNativeSubclassNode<Double> getFloat) {
+            Double leftPrimitive = getFloat.execute(left);
+            if (leftPrimitive != null) {
+                return leftPrimitive + right;
+            } else {
+                return PNotImplemented.NOT_IMPLEMENTED;
+            }
+        }
+
+        @Specialization
+        Object doDP(PythonNativeObject left, double right,
+                        @Cached("nativeFloat()") FromNativeSubclassNode<Double> getFloat) {
+            Double leftPrimitive = getFloat.execute(left);
+            if (leftPrimitive != null) {
+                return leftPrimitive + right;
+            } else {
+                return PNotImplemented.NOT_IMPLEMENTED;
+            }
+        }
+
         @SuppressWarnings("unused")
         @Fallback
         PNotImplemented doGeneric(Object left, Object right) {

mx.graalpython/mx_graalpython_bench_param.py

@@ -97,8 +97,9 @@
     'magic-iter': ITER_10 + ['10000000'],
     'c-magic-iter': ITER_10 + ['10000000'],
     'instantiation': ITER_10 + ['50000000'],
-    'c-instantiation': ITER_10 + ['50000000']
-
+    'c-instantiation': ITER_10 + ['50000000'],
+    'c-magic-bool': ITER_10 + ['100000000'],
+    'c_arith-binop': ITER_25 + ['5'],
 }