static _ctx * _profile_thread(PyThreadState *ts) { uintptr_t ctx_id; _ctx *ctx; _hitem *it; ctx_id = _current_context_id(ts); it = hfind(contexts, ctx_id); if (!it) { ctx = _create_ctx(); if (!ctx) { return NULL; } if (!hadd(contexts, ctx_id, (uintptr_t)ctx)) { _del_ctx(ctx); if (!flput(flctx, ctx)) { _log_err(10); } _log_err(11); return NULL; } } else { ctx = (_ctx *)it->val; } ts->use_tracing = 1; ts->c_profilefunc = _yapp_callback; ctx->id = ctx_id; ctx->tid = ts->thread_id; return ctx; }
STATIC bool updateData(const SecureStorageS *storage, const unsigned char *key, const unsigned char *val) { int16_t kLen = 0, vLen = 0; unsigned char *keyStr = NULL, *valStr = NULL; htab *t = NULL; if (storage == NULL || key == NULL || val == NULL) { assert(LIB_NAME "Storage structure and key, value strings must not be NULL" && (false || Storage_TestMode)); return false; } t = storage->Data; clearKey(storage, key); if (Utils_GetCharArrayLen(key, &kLen, KEY_VAL_MIN_STR_LEN, KEY_VAL_MAX_STR_LEN) == false || Utils_GetCharArrayLen(val, &vLen, KEY_VAL_MIN_STR_LEN, KEY_VAL_MAX_STR_LEN) == false) return false; if (hadd(t, key, kLen + UTILS_STR_LEN_SIZE, val)) { Utils_CreateAndCopyUcString(&keyStr, key, kLen + UTILS_STR_LEN_SIZE); hkey(t) = keyStr; Utils_CreateAndCopyUcString(&valStr, val, vLen + UTILS_STR_LEN_SIZE); hstuff(t) = valStr; } else { printf("Internal error: item: %s must be free\n", key); return false; } return true; }
int main(int argc, char **argv) { if (argc < 3) { Usage(); return 1; } hadd(argv[1], argv[2]); return 0; }
// maps the PyCodeObject to our internal pit item via hash table. static _pit * _code2pit(PyFrameObject *fobj) { _hitem *it; PyCodeObject *cobj; _pit *pit; cobj = fobj->f_code; it = hfind(current_ctx->pits, (uintptr_t)cobj); if (it) { return ((_pit *)it->val); } pit = _create_pit(); if (!pit) return NULL; if (!hadd(current_ctx->pits, (uintptr_t)cobj, (uintptr_t)pit)) return NULL; pit->name = NULL; Py_INCREF(cobj->co_filename); pit->modname = cobj->co_filename; pit->lineno = cobj->co_firstlineno; PyFrame_FastToLocals(fobj); if (cobj->co_argcount) { const char *firstarg = PyStr_AS_CSTRING(PyTuple_GET_ITEM(cobj->co_varnames, 0)); if (!strcmp(firstarg, "self")) { PyObject* locals = fobj->f_locals; if (locals) { PyObject* self = PyDict_GetItemString(locals, "self"); if (self) { PyObject *class_obj = PyObject_GetAttrString(self, "__class__"); if (class_obj) { PyObject *class_name = PyObject_GetAttrString(class_obj, "__name__"); if (class_name) { pit->name = PyStr_FromFormat("%s.%s", PyStr_AS_CSTRING(class_name), PyStr_AS_CSTRING(cobj->co_name)); Py_DECREF(class_name); } Py_DECREF(class_obj); } } } } } if (!pit->name) { Py_INCREF(cobj->co_name); pit->name = cobj->co_name; } PyFrame_LocalsToFast(fobj, 0); return pit; }
static int incr_rec_level(uintptr_t key) { _hitem *it; it = hfind(current_ctx->rec_levels, key); if (it) { it->val++; } else { if (!hadd(current_ctx->rec_levels, key, 1)) { _log_err(2); return 0; // should not happen } } return 1; }
static _pit * _ccode2pit(void *cco) { PyCFunctionObject *cfn; _hitem *it; PyObject *name; cfn = cco; // Issue #15: // Hashing cfn to the pits table causes different object methods // to be hashed into the same slot. Use cfn->m_ml for hashing the // Python C functions. it = hfind(current_ctx->pits, (uintptr_t)cfn->m_ml); if (!it) { _pit *pit = _create_pit(); if (!pit) return NULL; if (!hadd(current_ctx->pits, (uintptr_t)cfn->m_ml, (uintptr_t)pit)) return NULL; pit->builtin = 1; pit->modname = _pycfunction_module_name(cfn); pit->lineno = 0; // built-in method? if (cfn->m_self != NULL) { name = PyStr_FromString(cfn->m_ml->ml_name); if (name != NULL) { PyObject *obj_type = PyObject_Type(cfn->m_self); PyObject *mo = _PyType_Lookup((PyTypeObject *)obj_type, name); Py_XINCREF(mo); Py_XDECREF(obj_type); Py_DECREF(name); if (mo != NULL) { pit->name = PyObject_Repr(mo); Py_DECREF(mo); return pit; } } PyErr_Clear(); } pit->name = PyStr_FromString(cfn->m_ml->ml_name); return pit; } return ((_pit *)it->val); }
CMT_INLINE vec<vec<T, 2>, N> process(const vec<vec<T, 2>, N>& x, csizes_t<indices...>) const { return vec<vec<T, 2>, N>(hadd(transpose(x[indices] * matrix))...); }