GeezerVison

The NEWOBJ and NEWOBJ_EX opcodes are documented to call cls.__new__(cls, *args), but the C implementation called tp_new directly, so a metaclass __getattribute__ hook was skipped unless the class happened to define __new__ in Python. Perform a real attribute lookup of cls.__new__ when the class has a custom metaclass, matching the pure Python implementation.

When the metaclass is exactly type, no hook can exist and the lookup is not observable, so tp_new is still called directly - no performance change for ordinary classes.

The new test runs against both implementations and covers NEWOBJ (protocols 2-5) and NEWOBJ_EX (protocols 4-5); the cases inheriting object.__new__ fail on the C unpickler without this change.

I benchmarked the three affected paths with pyperf 2.10.0 (script below). Both interpreters were built with the same plain ./configure (release build, Py_DEBUG=0). Baseline is main at 70fdc96. Each benchmark unpickles a
list of 1000 instances.

The fast path shows no measurable regression for either opcode — the added Py_TYPE(cls) == &PyType_Type check is lost in the noise. The 1.15x slowdown is confined to the new slow path, which is only taken for classes with a custom metaclass: the cost of the PyObject_GetAttr(cls, '__new__') call plus building the argument tuple, on the path where the previous behaviour did not match the documented semantics.

Environment: macOS 26.5.1, Apple M3 Pro, no CPU isolation (pyperf system tune is Linux-only), 20 processes per benchmark.

Given the trade-off — documented cls.__new__ semantics for custom-metaclass classes, at ~15% on that path and no change for ordinary classes — I'd like your feedback on whether this is acceptable, or whether you'd prefer to close
gh-105250 as a known limitation instead.

"""Micro-benchmark for load_newobj() in Modules/_pickle.c (gh-105250)."""
import pickle
import pyperf

assert pickle.Unpickler.__module__ == '_pickle', 'need the C implementation'


class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y


class PointEx:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __getnewargs_ex__(self):
        return (self.x,), {'y': self.y}

    def __new__(cls, x=0, y=0):
        return super().__new__(cls)


class Meta(type):
    pass


class PointMeta(metaclass=Meta):
    def __init__(self, x, y):
        self.x = x
        self.y = y


N = 1000
DATA_DEFAULT = pickle.dumps([Point(i, i) for i in range(N)], protocol=2)
DATA_EX = pickle.dumps([PointEx(i, i) for i in range(N)], protocol=4)
DATA_META = pickle.dumps([PointMeta(i, i) for i in range(N)], protocol=2)

runner = pyperf.Runner()
runner.metadata['description'] = 'unpickle NEWOBJ/NEWOBJ_EX (gh-105250)'
runner.bench_func('newobj_default', pickle.loads, DATA_DEFAULT)
runner.bench_func('newobj_ex_default', pickle.loads, DATA_EX)
runner.bench_func('newobj_metaclass', pickle.loads, DATA_META)

• Issue: Difference in behavior between pure Python pickle and C extension _pickle when unpickling instance of instance of metaclass #105250