cpyobject

label与object分离共享object, 分离的好处是垃圾回收就方便。code1,/* https://www.onlinegdb.com/online_c_compiler */ #include stdio.h #include stdlib.h /* Simplified Py_ssize_t */ typedef long Py_ssize_t; /* Forward declarations */ typedef struct PyObject PyObject; typedef struct PyTypeObject PyTypeObject; /* This is similar to CPythons idea: typedef struct _object { Py_ssize_t ob_refcnt; PyTypeObject *ob_type; } PyObject; */ struct PyTypeObject { const char *tp_name; void (*tp_print)(PyObject *self); void (*tp_dealloc)(PyObject *self); }; struct PyObject { Py_ssize_t ob_refcnt; /* reference count */ PyTypeObject *ob_type; /* dynamic type information */ }; /* Concrete object types. They start with PyObject so that PyObject* can be safely cast to them. */ typedef struct { PyObject ob_base; long value; } PyIntObject; typedef struct { PyObject ob_base; double value; } PyFloatObject; /* ---------------- Printing functions ---------------- */ static void PyInt_Print(PyObject *self) { PyIntObject *obj (PyIntObject *)self; printf(%ld, obj-value); } static void PyFloat_Print(PyObject *self) { PyFloatObject *obj (PyFloatObject *)self; printf(%g, obj-value); } /* ---------------- Deallocation functions ---------------- */ static void PyInt_Dealloc(PyObject *self) { PyIntObject *obj (PyIntObject *)self; printf([gc] dealloc int object %ld\n, obj-value); free(obj); } static void PyFloat_Dealloc(PyObject *self) { PyFloatObject *obj (PyFloatObject *)self; printf([gc] dealloc float object %g\n, obj-value); free(obj); } /* ---------------- Type objects ---------------- */ static PyTypeObject PyInt_Type { int, PyInt_Print, PyInt_Dealloc }; static PyTypeObject PyFloat_Type { float, PyFloat_Print, PyFloat_Dealloc }; /* ---------------- Reference counting ---------------- */ static void Py_Incref(PyObject *obj) { if (obj) { obj-ob_refcnt; } } static void Py_Decref(PyObject *obj) { if (!obj) { return; } obj-ob_refcnt--; if (obj-ob_refcnt 0) { obj-ob_type-tp_dealloc(obj); } } /* ---------------- Object constructors ---------------- */ static PyObject *PyInt_FromLong(long value) { PyIntObject *obj malloc(sizeof *obj); if (!obj) { exit(EXIT_FAILURE); } obj-ob_base.ob_refcnt 1; obj-ob_base.ob_type PyInt_Type; obj-value value; return (PyObject *)obj; } static PyObject *PyFloat_FromDouble(double value) { PyFloatObject *obj malloc(sizeof *obj); if (!obj) { exit(EXIT_FAILURE); } obj-ob_base.ob_refcnt 1; obj-ob_base.ob_type PyFloat_Type; obj-value value; return (PyObject *)obj; } /* ---------------- Generic object printing ---------------- */ static void PyObject_Print(PyObject *obj) { if (!obj) { printf(NULL); return; } printf(%s, value, obj-ob_type-tp_name); obj-ob_type-tp_print(obj); printf(, refcnt%ld, obj-ob_refcnt); } /* This is the Python-like assignment operation. In Python: x some_object means: make x refer to some_object decrease reference to old object */ static void PyVar_Set(PyObject **label, PyObject *new_object) { if (!label) { return; } /* Protect new_object in case it is the same as *label. */ Py_Incref(new_object); /* Release old object. */ Py_Decref(*label); /* Rebind the label. */ *label new_object; } /* C11 _Generic allows a nicer macro: PY_SET(x, 5); PY_SET(x, 5.5); This is still not literally x 5, but it is close in spirit. */ #if defined(__STDC_VERSION__) __STDC_VERSION__ 201112L #define PY_SET(var, value) \ do { \ PyObject *tmp_ _Generic((value), \ int: PyInt_FromLong, \ long: PyInt_FromLong, \ float: PyFloat_FromDouble, \ double: PyFloat_FromDouble \ )(value); \ PyVar_Set((var), tmp_); \ Py_Decref(tmp_); \ } while (0) #endif int main(void) { /* x and y are not int variables or float variables. They are labels/references to Python-style objects. */ PyObject *x NULL; PyObject *y NULL; #ifdef PY_SET printf(x 5;\n); PY_SET(x, 5); printf(x - ); PyObject_Print(x); printf(\n\n); printf(x 5.5;\n); PY_SET(x, 5.5); printf(x - ); PyObject_Print(x); printf(\n\n); printf(y x;\n); PyVar_Set(y, x); printf(x - ); PyObject_Print(x); printf(\n); printf(y - ); PyObject_Print(y); printf(\n\n); printf(x 10;\n); PY_SET(x, 10); printf(x - ); PyObject_Print(x); printf(\n); printf(y - ); PyObject_Print(y); printf(\n\n); #else /* Fallback for non-C11 compilers */ PyObject *tmp; printf(x 5;\n); tmp PyInt_FromLong(5); PyVar_Set(x, tmp); Py_Decref(tmp); printf(x - ); PyObject_Print(x); printf(\n\n); printf(x 5.5;\n); tmp PyFloat_FromDouble(5.5); PyVar_Set(x, tmp); Py_Decref(tmp); printf(x - ); PyObject_Print(x); printf(\n\n); printf(y x;\n); PyVar_Set(y, x); printf(x - ); PyObject_Print(x); printf(\n); printf(y - ); PyObject_Print(y); printf(\n\n); printf(x 10;\n); tmp PyInt_FromLong(10); PyVar_Set(x, tmp); Py_Decref(tmp); printf(x - ); PyObject_Print(x); printf(\n); printf(y - ); PyObject_Print(y); printf(\n\n); #endif printf(cleanup:\n); Py_Decref(x); Py_Decref(y); return 0; }code2#include stdio.h #include stdlib.h /* Simplified Py_ssize_t */ typedef long Py_ssize_t; /* Forward declarations */ typedef struct PyObject PyObject; typedef struct PyTypeObject PyTypeObject; /* CPython-like base object. typedef struct _object { Py_ssize_t ob_refcnt; PyTypeObject *ob_type; } PyObject; */ struct PyTypeObject { const char *tp_name; void (*tp_print)(PyObject *self); void (*tp_dealloc)(PyObject *self); }; struct PyObject { Py_ssize_t ob_refcnt; /* reference count */ PyTypeObject *ob_type; /* dynamic type information */ }; /* Concrete object types. They start with PyObject so that PyObject* can be safely cast to them. */ typedef struct { PyObject ob_base; long value; } PyIntObject; typedef struct { PyObject ob_base; double value; } PyFloatObject; /* A mutable object type used to demonstrate shared mutable state. */ typedef struct { PyObject ob_base; long value; } PyBoxObject; /* ---------------- Printing functions ---------------- */ static void PyInt_Print(PyObject *self) { PyIntObject *obj (PyIntObject *)self; printf(%ld, obj-value); } static void PyFloat_Print(PyObject *self) { PyFloatObject *obj (PyFloatObject *)self; printf(%g, obj-value); } static void PyBox_Print(PyObject *self) { PyBoxObject *obj (PyBoxObject *)self; printf(box(%ld), obj-value); } /* ---------------- Deallocation functions ---------------- */ static void PyInt_Dealloc(PyObject *self) { PyIntObject *obj (PyIntObject *)self; printf([gc] dealloc int object %ld at %p\n, obj-value, (void *)obj); free(obj); } static void PyFloat_Dealloc(PyObject *self) { PyFloatObject *obj (PyFloatObject *)self; printf([gc] dealloc float object %g at %p\n, obj-value, (void *)obj); free(obj); } static void PyBox_Dealloc(PyObject *self) { PyBoxObject *obj (PyBoxObject *)self; printf([gc] dealloc box object %ld at %p\n, obj-value, (void *)obj); free(obj); } /* ---------------- Type objects ---------------- */ static PyTypeObject PyInt_Type { int, PyInt_Print, PyInt_Dealloc }; static PyTypeObject PyFloat_Type { float, PyFloat_Print, PyFloat_Dealloc }; static PyTypeObject PyBox_Type { box, PyBox_Print, PyBox_Dealloc }; /* ---------------- Reference counting ---------------- */ static void Py_Incref(PyObject *obj) { if (obj) { obj-ob_refcnt; } } static void Py_Decref(PyObject *obj) { if (!obj) { return; } obj-ob_refcnt--; if (obj-ob_refcnt 0) { obj-ob_type-tp_dealloc(obj); } } /* ---------------- Object constructors ---------------- */ static PyObject *PyInt_FromLong(long value) { PyIntObject *obj malloc(sizeof *obj); if (!obj) { exit(EXIT_FAILURE); } obj-ob_base.ob_refcnt 1; obj-ob_base.ob_type PyInt_Type; obj-value value; return (PyObject *)obj; } static PyObject *PyFloat_FromDouble(double value) { PyFloatObject *obj malloc(sizeof *obj); if (!obj) { exit(EXIT_FAILURE); } obj-ob_base.ob_refcnt 1; obj-ob_base.ob_type PyFloat_Type; obj-value value; return (PyObject *)obj; } static PyObject *PyBox_FromLong(long value) { PyBoxObject *obj malloc(sizeof *obj); if (!obj) { exit(EXIT_FAILURE); } obj-ob_base.ob_refcnt 1; obj-ob_base.ob_type PyBox_Type; obj-value value; return (PyObject *)obj; } /* ---------------- Object identity utilities ---------------- */ /* Similar to Python id(object). Here we simply use the objects memory address as its identity. */ static const void *PyObject_Id(PyObject *obj) { return (const void *)obj; } /* Similar to Python: a is b but here we use it mainly for non-NULL shared object checking. */ static int PyObject_IsShared(PyObject *a, PyObject *b) { return a ! NULL a b; } /* ---------------- Detailed validation printing ---------------- */ /* Print: - address of the label variable itself, e.g. x - address of the object it points to, e.g. x - object type - object value - reference count */ static void PyVar_PrintDetail(const char *label, PyObject **slot) { PyObject *obj slot ? *slot : NULL; printf(%-6s: label_addr%p, object_id%p, , label ? label : ?, (void *)slot, (void *)PyObject_Id(obj)); if (!obj) { printf(typeNULL, valueNULL, refcnt0\n); return; } printf(type%s, value, obj-ob_type-tp_name); obj-ob_type-tp_print(obj); printf(, refcnt%ld\n, obj-ob_refcnt); } /* Validate whether two labels refer to the same object. */ static void PyVar_ValidateShared(const char *label_a, PyObject **slot_a, const char *label_b, PyObject **slot_b) { PyObject *a slot_a ? *slot_a : NULL; PyObject *b slot_b ? *slot_b : NULL; printf(\n shared? %s(label_addr%p, object_id%p) vs %s(label_addr%p, object_id%p): , label_a ? label_a : ?, (void *)slot_a, (void *)PyObject_Id(a), label_b ? label_b : ?, (void *)slot_b, (void *)PyObject_Id(b)); if (!a !b) { printf(both NULL\n); return; } if (PyObject_IsShared(a, b)) { printf(YES, same object, refcnt%ld\n, a-ob_refcnt); } else { printf(NO, different objects\n); } } /* ---------------- Python-like assignment ---------------- */ /* In Python: x some_object means: make label x refer to some_object decrease reference to old object increase reference to new object */ static void PyVar_Set(PyObject **label, PyObject *new_object) { if (!label) { return; } /* Protect new_object in case it is the same as *label. */ Py_Incref(new_object); /* Release old object. */ Py_Decref(*label); /* Rebind the label. */ *label new_object; } /* ---------------- Mutable box operations ---------------- */ static void PyBox_Set(PyObject *self, long value) { if (!self || self-ob_type ! PyBox_Type) { fprintf(stderr, PyBox_Set: not a box object\n); return; } PyBoxObject *obj (PyBoxObject *)self; obj-value value; } static long PyBox_Get(PyObject *self) { if (!self || self-ob_type ! PyBox_Type) { fprintf(stderr, PyBox_Get: not a box object\n); return -1; } PyBoxObject *obj (PyBoxObject *)self; return obj-value; } /* ---------------- Demo ---------------- */ int main(void) { PyObject *x NULL; PyObject *y NULL; PyObject *tmp NULL; printf( Part 1: dynamic labels and shared object \n); printf(\n); printf(x 5\n); tmp PyInt_FromLong(5); PyVar_Set(x, tmp); Py_Decref(tmp); PyVar_PrintDetail(x, x); printf(x 5.5\n); tmp PyFloat_FromDouble(5.5); PyVar_Set(x, tmp); Py_Decref(tmp); PyVar_PrintDetail(x, x); printf(y x\n); PyVar_Set(y, x); PyVar_PrintDetail(x, x); PyVar_PrintDetail(y, y); PyVar_ValidateShared(x, x, y, y); printf(\n); printf(x 10\n); tmp PyInt_FromLong(10); PyVar_Set(x, tmp); Py_Decref(tmp); PyVar_PrintDetail(x, x); PyVar_PrintDetail(y, y); PyVar_ValidateShared(x, x, y, y); printf(\ncleanup part 1\n); Py_Decref(x); Py_Decref(y); x y NULL; printf(\n Part 2: mutable shared object \n); PyObject *a NULL; PyObject *b NULL; printf(\n); printf(a box(5)\n); tmp PyBox_FromLong(5); PyVar_Set(a, tmp); Py_Decref(tmp); PyVar_PrintDetail(a, a); printf(b a\n); PyVar_Set(b, a); PyVar_PrintDetail(a, a); PyVar_PrintDetail(b, b); PyVar_ValidateShared(a, a, b, b); printf(mutate through a: PyBox_Set(a, 99)\n); PyBox_Set(a, 99); printf(\n); PyVar_PrintDetail(a, a); PyVar_PrintDetail(b, b); printf(read through b: PyBox_Get(b) %ld\n, PyBox_Get(b)); PyVar_ValidateShared(a, a, b, b); printf(rebind a to a new object: a box(123)\n); tmp PyBox_FromLong(123); PyVar_Set(a, tmp); Py_Decref(tmp); printf(\n); PyVar_PrintDetail(a, a); PyVar_PrintDetail(b, b); PyVar_ValidateShared(a, a, b, b); printf(\ncleanup part 2\n); Py_Decref(a); Py_Decref(b); return 0; }