[GR-70907] Remove allocation reporting.

PullRequest: graalpython/4071

Author: timfel

CHANGELOG.md

@@ -5,6 +5,7 @@ language runtime. The main focus is on user-observable behavior of the engine.
 
 ## Version 25.1.0
 * Intern string literals in source files
+* Allocation reporting via Truffle has been removed. Python object sizes were never reported correctly, so the data was misleading and there was a non-neglible overhead for object allocations even when reporting was inactive.
 
 ## Version 25.0.1
 * Allow users to keep going on unsupported JDK/OS/ARCH combinations at their own risk by opting out of early failure using `-Dtruffle.UseFallbackRuntime=true`, `-Dpolyglot.engine.userResourceCache=/set/to/a/writeable/dir`, `-Dpolyglot.engine.allowUnsupportedPlatform=true`, and `-Dpolyglot.python.UnsupportedPlatformEmulates=[linux|macos|windows]` and `-Dorg.graalvm.python.resources.exclude=native.files`.

graalpython/com.oracle.graal.python.pegparser.generator/asdl/asdl_java.py

@@ -225,7 +225,7 @@ def visit_enum(self, c: model.Enum, emitter: java_file.Emitter):
             emitter.println()
             emitter.println(f'// {c.name.java}.{m.java}')
             self.emit_make_type(emitter, m, c.name, (), (), m.python)
-            emitter.println(f'{m.singleton_field} = factory.createSingleton({m.cls_field});')
+            emitter.println(f'{m.singleton_field} = AstTypeFactory.createSingleton({m.cls_field});')
 
     @staticmethod
     def emit_make_type(emitter: java_file.Emitter, name: model.Name, base_class: Optional[model.Name],

graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/runtime/PythonModuleTests.java

@@ -92,7 +92,7 @@ public void tearDown() {
 
     @Test
     public void pythonModuleTest() {
-        PythonModule module = PFactory.createPythonModule(context.getLanguage(), tsLiteral("testModule"));
+        PythonModule module = PFactory.createPythonModule(tsLiteral("testModule"));
         assertEquals("testModule", module.getAttribute(T___NAME__).toString());
         assertEquals("None", module.getAttribute(T___DOC__).toString());
         assertEquals("None", module.getAttribute(T___PACKAGE__).toString());

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/PythonLanguage.java

@@ -129,7 +129,6 @@
 import com.oracle.truffle.api.dsl.Idempotent;
 import com.oracle.truffle.api.exception.AbstractTruffleException;
 import com.oracle.truffle.api.frame.VirtualFrame;
-import com.oracle.truffle.api.instrumentation.AllocationReporter;
 import com.oracle.truffle.api.instrumentation.ProvidedTags;
 import com.oracle.truffle.api.instrumentation.StandardTags;
 import com.oracle.truffle.api.interop.InteropLibrary;
@@ -396,7 +395,6 @@ public boolean isSingleContext() {
 
     @CompilationFinal(dimensions = 1) private volatile Object[] engineOptionsStorage;
     @CompilationFinal private volatile OptionValues engineOptions;
-    @CompilationFinal private AllocationReporter allocationReporter;
 
     /** For fast access to the PythonThreadState object by the owning thread. */
     private final ContextThreadLocal<PythonThreadState> threadState = locals.createContextThreadLocal(PythonContext.PythonThreadState::new);
@@ -491,11 +489,6 @@ public <T> T getEngineOption(OptionKey<T> key) {
         }
     }
 
-    public AllocationReporter getAllocationReporter() {
-        assert allocationReporter != null;
-        return allocationReporter;
-    }
-
     @Override
     protected OptionDescriptors getOptionDescriptors() {
         return PythonOptions.DESCRIPTORS;
@@ -504,12 +497,6 @@ protected OptionDescriptors getOptionDescriptors() {
     @Override
     protected void initializeContext(PythonContext context) {
         if (!isLanguageInitialized) {
-            if (allocationReporter == null) {
-                allocationReporter = context.getEnv().lookup(AllocationReporter.class);
-            } else {
-                // GR-61960
-                // assert allocationReporter == env.lookup(AllocationReporter.class);
-            }
             initializeLanguage();
         }
         if (PythonOS.isUnsupported() && context.getEnv().isNativeAccessAllowed()) {

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/Python3Core.java

@@ -1230,8 +1230,8 @@ private void initializeTypes() {
         // now initialize well-known objects
         PythonBuiltinClassType booleanType = PythonBuiltinClassType.Boolean;
         Shape booleanShape = booleanType.getInstanceShape(getLanguage());
-        pyTrue = PFactory.createInt(getLanguage(), booleanType, booleanShape, BigInteger.ONE);
-        pyFalse = PFactory.createInt(getLanguage(), booleanType, booleanShape, BigInteger.ZERO);
+        pyTrue = PFactory.createInt(booleanType, booleanShape, BigInteger.ONE);
+        pyFalse = PFactory.createInt(booleanType, booleanShape, BigInteger.ZERO);
         pyNaN = PFactory.createFloat(getLanguage(), Double.NaN);
     }
 
@@ -1284,7 +1284,7 @@ private void addBuiltinModule(TruffleString name, PythonModule module) {
     private PythonModule createModule(TruffleString name, PythonBuiltins moduleBuiltins) {
         PythonModule mod = builtinModules.get(name);
         if (mod == null) {
-            mod = PFactory.createPythonModule(getLanguage(), name);
+            mod = PFactory.createPythonModule(name);
             if (moduleBuiltins != null) {
                 mod.setBuiltins(moduleBuiltins);
             }
@@ -1321,7 +1321,7 @@ private void loadFile(TruffleString s, TruffleString prefix) {
         PythonModule mod = lookupBuiltinModule(s);
         if (mod == null) {
             // use an anonymous module for the side-effects
-            mod = PFactory.createPythonModule(getLanguage(), T___ANONYMOUS__);
+            mod = PFactory.createPythonModule(T___ANONYMOUS__);
         }
         loadFile(s, prefix, mod);
     }

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/ArrayModuleBuiltins.java

@@ -35,7 +35,6 @@
 import java.nio.ByteOrder;
 import java.util.List;
 
-import com.oracle.graal.python.PythonLanguage;
 import com.oracle.graal.python.annotations.ArgumentClinic;
 import com.oracle.graal.python.annotations.Builtin;
 import com.oracle.graal.python.builtins.CoreFunctions;
@@ -151,11 +150,11 @@ private static Object doReconstruct(VirtualFrame frame, Node inliningTarget, Obj
             if (machineFormat != null) {
                 PArray array;
                 if (machineFormat == MachineFormat.forFormat(format)) {
-                    array = PFactory.createArray(PythonLanguage.get(inliningTarget), arrayType, getInstanceShape.execute(arrayType), typeCode, machineFormat.format);
+                    array = PFactory.createArray(arrayType, getInstanceShape.execute(arrayType), typeCode, machineFormat.format);
                     fromBytesNode.executeWithoutClinic(frame, array, bytes);
                 } else {
                     TruffleString newTypeCode = machineFormat.format == format ? typeCode : machineFormat.format.baseTypeCode;
-                    array = PFactory.createArray(PythonLanguage.get(inliningTarget), arrayType, getInstanceShape.execute(arrayType), newTypeCode, machineFormat.format);
+                    array = PFactory.createArray(arrayType, getInstanceShape.execute(arrayType), newTypeCode, machineFormat.format);
                     if (machineFormat.unicodeEncoding != null) {
                         Object decoded = callDecode.execute(frame, inliningTarget, bytes, T_DECODE, machineFormat.unicodeEncoding);
                         fromUnicodeNode.execute(frame, array, decoded);

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/CodecsTruffleModuleBuiltins.java

@@ -186,30 +186,29 @@ static PTuple codecsInfo(PythonModule self, TruffleString encoding, PythonContex
             initCodecClasses(self, codecsModule, context);
         }
 
-        PythonLanguage language = context.getLanguage();
         // encode/decode methods for codecs.CodecInfo
-        PythonObject truffleCodec = createPythonObject(language, codecsTruffleBuiltins.truffleCodecClass);
+        PythonObject truffleCodec = createPythonObject(codecsTruffleBuiltins.truffleCodecClass);
         truffleCodec.setAttribute(T_ATTR_ENCODING, encoding);
         Object encodeMethod = PyObjectGetAttr.executeUncached(truffleCodec, T_ENCODE);
         Object decodeMethod = PyObjectGetAttr.executeUncached(truffleCodec, T_DECODE);
 
         // incrementalencoder factory function for codecs.CodecInfo
-        PythonObject tie = createPythonObject(language, codecsTruffleBuiltins.applyEncodingClass);
+        PythonObject tie = createPythonObject(codecsTruffleBuiltins.applyEncodingClass);
         tie.setAttribute(T_ATTR_FN, codecsTruffleBuiltins.truffleIncrementalEncoderClass);
         tie.setAttribute(T_ATTR_ENCODING, encoding);
 
         // incrementaldecoder factory function for codecs.CodecInfo
-        PythonObject tid = createPythonObject(language, codecsTruffleBuiltins.applyEncodingClass);
+        PythonObject tid = createPythonObject(codecsTruffleBuiltins.applyEncodingClass);
         tid.setAttribute(T_ATTR_FN, codecsTruffleBuiltins.truffleIncrementalDecoderClass);
         tid.setAttribute(T_ATTR_ENCODING, encoding);
 
         // streamwriter factory function for codecs.CodecInfo
-        PythonObject sr = createPythonObject(language, codecsTruffleBuiltins.applyEncodingClass);
+        PythonObject sr = createPythonObject(codecsTruffleBuiltins.applyEncodingClass);
         sr.setAttribute(T_ATTR_FN, codecsTruffleBuiltins.truffleStreamReaderClass);
         sr.setAttribute(T_ATTR_ENCODING, encoding);
 
         // streamreader factory function for codecs.CodecInfo
-        PythonObject sw = createPythonObject(language, codecsTruffleBuiltins.applyEncodingClass);
+        PythonObject sw = createPythonObject(codecsTruffleBuiltins.applyEncodingClass);
         sw.setAttribute(T_ATTR_FN, codecsTruffleBuiltins.truffleStreamWriterClass);
         sw.setAttribute(T_ATTR_ENCODING, encoding);
 
@@ -218,8 +217,8 @@ static PTuple codecsInfo(PythonModule self, TruffleString encoding, PythonContex
         return (PTuple) CallNode.getUncached().execute(null, codecInfoClass, new Object[]{}, createCodecInfoArgs(encoding, encodeMethod, decodeMethod, tie, tid, sr, sw));
     }
 
-    private static PythonObject createPythonObject(PythonLanguage language, PythonClass cls) {
-        return PFactory.createPythonObject(language, cls, cls.getInstanceShape());
+    private static PythonObject createPythonObject(PythonClass cls) {
+        return PFactory.createPythonObject(cls, cls.getInstanceShape());
     }
 
     private static PKeyword[] createCodecInfoArgs(TruffleString encoding, Object encodeMethod, Object decodeMethod, PythonObject tie, PythonObject tid, PythonObject sr, PythonObject sw) {

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/ImpModuleBuiltins.java

@@ -601,7 +601,7 @@ public static PythonModule importFrozenModuleObject(Python3Core core, TruffleStr
         }
 
         RootCallTarget callTarget = createCallTarget(core.getContext(), info);
-        PythonModule module = globals == null ? PFactory.createPythonModule(core.getLanguage(), name) : globals;
+        PythonModule module = globals == null ? PFactory.createPythonModule(name) : globals;
 
         if (info.isPackage) {
             /* Set __path__ to the empty list */

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/ast/AstBuiltins.java

@@ -108,9 +108,8 @@ public abstract static class AstNode extends PythonVarargsBuiltinNode {
 
         @Specialization
         static PythonObject generic(Object cls, @SuppressWarnings("unused") Object[] varargs, @SuppressWarnings("unused") PKeyword[] kwargs,
-                        @Bind PythonLanguage language,
                         @Cached TypeNodes.GetInstanceShape getInstanceShape) {
-            return PFactory.createPythonObject(language, cls, getInstanceShape.execute(cls));
+            return PFactory.createPythonObject(cls, getInstanceShape.execute(cls));
         }
     }