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))...);
}
