1j>ddlZddlZddlZddlZddlZddlZddlZddlm Z m Z m Z ddl Z ej dZdZdZdZdZdZd Zd Zd Zd Zd ZejjdZeje jjdkdejdgddZ dZ!dS)N)extbuild assert_warnsIS_WASMc4tjdrtjdt rtjdgd}d}d} ddl}|S#t$rYnwxYwtj d ||tj g|| S) a Add a memory policy that returns a false pointer 64 bytes into the actual allocation, and fill the prefix with some text. Then check at each memory manipulation that the prefix exists, to make sure all alloc/realloc/ free/calloc go via the functions here. cygwinzlink fails on cygwinzCan't build module inside Wasm))get_default_policy METH_NOARGSzj Py_INCREF(PyDataMem_DefaultHandler); return PyDataMem_DefaultHandler; )set_secret_data_policyr aM PyObject *secret_data = PyCapsule_New(&secret_data_handler, "mem_handler", NULL); if (secret_data == NULL) { return NULL; } PyObject *old = PyDataMem_SetHandler(secret_data); Py_DECREF(secret_data); return old; )set_old_policyMETH_Oa PyObject *old; if (args != NULL && PyCapsule_CheckExact(args)) { old = PyDataMem_SetHandler(args); } else { old = PyDataMem_SetHandler(NULL); } return old; ) get_arrayr aM char *buf = (char *)malloc(20); npy_intp dims[1]; dims[0] = 20; PyArray_Descr *descr = PyArray_DescrNewFromType(NPY_UINT8); return PyArray_NewFromDescr(&PyArray_Type, descr, 1, dims, NULL, buf, NPY_ARRAY_WRITEABLE, NULL); )set_ownr a if (!PyArray_Check(args)) { PyErr_SetString(PyExc_ValueError, "need an ndarray"); return NULL; } PyArray_ENABLEFLAGS((PyArrayObject*)args, NPY_ARRAY_OWNDATA); // Maybe try this too? // PyArray_BASE(PyArrayObject *)args) = NULL; Py_RETURN_NONE; )get_array_with_baser a~ char *buf = (char *)malloc(20); npy_intp dims[1]; dims[0] = 20; PyArray_Descr *descr = PyArray_DescrNewFromType(NPY_UINT8); PyObject *arr = PyArray_NewFromDescr(&PyArray_Type, descr, 1, dims, NULL, buf, NPY_ARRAY_WRITEABLE, NULL); if (arr == NULL) return NULL; PyObject *obj = PyCapsule_New(buf, "buf capsule", (PyCapsule_Destructor)&warn_on_free); if (obj == NULL) { Py_DECREF(arr); return NULL; } if (PyArray_SetBaseObject((PyArrayObject *)arr, obj) < 0) { Py_DECREF(arr); Py_DECREF(obj); return NULL; } return arr; aI #define NPY_TARGET_VERSION NPY_1_22_API_VERSION #define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION #include /* * This struct allows the dynamic configuration of the allocator funcs * of the `secret_data_allocator`. It is provided here for * demonstration purposes, as a valid `ctx` use-case scenario. */ typedef struct { void *(*malloc)(size_t); void *(*calloc)(size_t, size_t); void *(*realloc)(void *, size_t); void (*free)(void *); } SecretDataAllocatorFuncs; NPY_NO_EXPORT void * shift_alloc(void *ctx, size_t sz) { SecretDataAllocatorFuncs *funcs = (SecretDataAllocatorFuncs *)ctx; char *real = (char *)funcs->malloc(sz + 64); if (real == NULL) { return NULL; } snprintf(real, 64, "originally allocated %ld", (unsigned long)sz); return (void *)(real + 64); } NPY_NO_EXPORT void * shift_zero(void *ctx, size_t sz, size_t cnt) { SecretDataAllocatorFuncs *funcs = (SecretDataAllocatorFuncs *)ctx; char *real = (char *)funcs->calloc(sz + 64, cnt); if (real == NULL) { return NULL; } snprintf(real, 64, "originally allocated %ld via zero", (unsigned long)sz); return (void *)(real + 64); } NPY_NO_EXPORT void shift_free(void *ctx, void * p, npy_uintp sz) { SecretDataAllocatorFuncs *funcs = (SecretDataAllocatorFuncs *)ctx; if (p == NULL) { return ; } char *real = (char *)p - 64; if (strncmp(real, "originally allocated", 20) != 0) { fprintf(stdout, "uh-oh, unmatched shift_free, " "no appropriate prefix\n"); /* Make C runtime crash by calling free on the wrong address */ funcs->free((char *)p + 10); /* funcs->free(real); */ } else { npy_uintp i = (npy_uintp)atoi(real +20); if (i != sz) { fprintf(stderr, "uh-oh, unmatched shift_free" "(ptr, %ld) but allocated %ld\n", sz, i); /* This happens in some places, only print */ funcs->free(real); } else { funcs->free(real); } } } NPY_NO_EXPORT void * shift_realloc(void *ctx, void * p, npy_uintp sz) { SecretDataAllocatorFuncs *funcs = (SecretDataAllocatorFuncs *)ctx; if (p != NULL) { char *real = (char *)p - 64; if (strncmp(real, "originally allocated", 20) != 0) { fprintf(stdout, "uh-oh, unmatched shift_realloc\n"); return realloc(p, sz); } return (void *)((char *)funcs->realloc(real, sz + 64) + 64); } else { char *real = (char *)funcs->realloc(p, sz + 64); if (real == NULL) { return NULL; } snprintf(real, 64, "originally allocated " "%ld via realloc", (unsigned long)sz); return (void *)(real + 64); } } /* As an example, we use the standard {m|c|re}alloc/free funcs. */ static SecretDataAllocatorFuncs secret_data_handler_ctx = { malloc, calloc, realloc, free }; static PyDataMem_Handler secret_data_handler = { "secret_data_allocator", 1, { &secret_data_handler_ctx, /* ctx */ shift_alloc, /* malloc */ shift_zero, /* calloc */ shift_realloc, /* realloc */ shift_free /* free */ } }; void warn_on_free(void *capsule) { PyErr_WarnEx(PyExc_UserWarning, "in warn_on_free", 1); void * obj = PyCapsule_GetPointer(capsule, PyCapsule_GetName(capsule)); free(obj); }; zimport_array();rN mem_policy)prologue include_dirs build_dir more_init) sysplatform startswithpytestskiprr ImportErrorrbuild_and_import_extensionnp get_include)tmp_path functionsrrrs t/builddir/build/BUILD/cloudlinux-venv-1.0.11/venv/lib64/python3.11/site-packages/numpy/core/tests/test_mem_policy.py get_moduler! s |x((, *+++6 4555CCCIHm H\"I         .|/88@=?^=M=M > > > >  qv & &! + + + +...!!$'''!!%8888888!!+...!!%5555555c.tjjj}|d}|dksJ|d}|dksJ||}||cxur|usnJdSNr))rr*r+r,r r)r!r,r3 def_policy_1 def_policy_2s r test_default_policy_singletonr;sw):++D11K    !4 4 4 4 4,,T22L    !4 4 4 4 4,,[99L < J J J J:+H+H+J+J J J J J J J J Jr6cGddtj}tjjj}|}tjd|d}||J|jj dusJ||j J|j jj dusJ||j j |ksJ|j j jj dusJdS)NceZdZdS)&test_policy_propagation..MyArrN)__name__ __module__ __qualname__r6r MyArrr> s r6rCr#r$FT) rndarrayr*r+r,r.viewr/flagsowndatar0)r!rCr,r1r2s r test_policy_propagationrH s         w):'')) " 5!!))&11A  A   & & & 7?e # # # #  AF # # + + + 6< 5 ( ( ( (  AFK ( (,< < < < < 6;  $ , , , , , ,r6c6K|dkr>|tjjdksJn>|dtjjdksJ|dSNr)r()r rr*r+r,r setr!r1events r concurrent_context1rNs...))+++w!22448OOOOOO!!$'''w!22448KKKKK IIKKKKKr6cK|d{Vtjj|ksJ|dkr?|tjjdksJdS|dtjjdksJdSrJ)waitrr*r+r,r r rLs r concurrent_context2rQ&s **,, 7  . . 0 04D D D D D...))+++w!22448OOOOOOO!!$'''w!22448KKKKKKKr6ctKtjj}t j}t jt|||}t jt|||}|d{V|d{Vtjj|ksJdS)N) rr*r+r,asyncioEvent create_taskrNrQr!r1rMconcurrent_task1concurrent_task2s r async_test_context_localityrY3sw)::<< MOOE*J(8%@@BB*J(8%@@BB   7  . . 0 04D D D D D D Dr6ctjjdkr,tjdddkrt jdt jt|dS)Npypy)r\z+no context-locality support in PyPy < 7.3.6) rimplementationnamepypy_version_inforrrSrunrY)r!s r test_context_localityrcCsZ 6))%bqb)I55 ABBB K+J7788888r6c|tjjdksJ|dS)Nr()r rr*r+r,rKr!rMs r concurrent_thread1rfJsH%%''' 7  . . 0 04K K K K K IIKKKKKr6c|tjjdksJ|dSr8)rPrr*r+r,r res r concurrent_thread2rhPsJ JJLLL 7  . . 0 04G G G G G%%'''''r6ctjj}t j}t jt||f}t jt||f}| | | | tjj|ksJdS)N)targetargs) rr*r+r, threadingrTThreadrfrhstartjoinrVs r test_thread_localityrpXsw)::<< O  E '/A.8%-@BBB '/A.8%-@BBB 7  . . 0 04D D D D D D Dr6c`tjd}tjj|}|}tjd}tjj|dksJ|dkrJtjdddgsJtjdddgsJ||tjd}tjj||ksJdS)Nr#r(r)fullr%z-vv)verbose extra_argv) rr.r*r+r,r testmar )r!r2r1r3r4cs r test_new_policyrxjs  " Aw)::1==3355K " A 7  . .q 1 15L L L L L...w||FA5'|BBBBBuzz&!z@@@@@k*** " A 7  . .q 1 15E E E E E E Er6r[z;bad interaction between getenv and os.environ inside pytest)reasonpolicy)01Nc&|}tjj|J||t jdd}|.dt jvrt j dn|t jd< |dkrAtt5}~tj dddn #1swxYwYn~tj |1dt jvr!t j ddSdS|t jd<dS#|.dt jvrt j dn|t jd<wxYw)NNUMPY_WARN_IF_NO_MEM_POLICYr|)r rr*r+r,rosenvirongetpoprRuntimeWarninggccollect)r!rzr2oldvalws r test_switch_ownerrs A 7  . .q 1 1 9 9 9q Z^^94 @ @F ~ (BJ 6 6 JNN8 9 9 94: 01? S==n--                  JLLL >, :: <=====;:9?BJ4 5 5 5 >, :: <===8>BJ4 5 > > > >s10E C+ E+C//E2C/3EAFc|}tjtd5~t jddddS#1swxYwYdS)N warn_on_free)match)rrwarns UserWarningrr)r!r2s r test_owner_is_basers&&((A k 8 8 8  sAAA)"rSrrrnumpyrrlwarnings numpy.testingrrrrfixturer!r5r;rHrNrQrYrcrfrhrpmarkslowrxxfailr_r` parametrizerrrBr6r rs 9999999999 HDHDHDV6668KKK*---& L L L E E E 999 (((EEE$FFF63%*f4688#3#3#344??5488?8r6