vmprof
diff --git a/‎src/_vmprof.c‎
Lines changed: 34 additions & 6 deletions b/‎src/_vmprof.c‎
Lines changed: 34 additions & 6 deletions
diff --git a/‎vmprof/__init__.py‎
Lines changed: 6 additions & 4 deletions b/‎vmprof/__init__.py‎
Lines changed: 6 additions & 4 deletions
diff --git a/‎vmprof/test/test_run.py‎
Lines changed: 30 additions & 0 deletions b/‎vmprof/test/test_run.py‎
Lines changed: 30 additions & 0 deletions
@@ -383,8 +383,22 @@ static PyObject * vmp_get_profile_path(PyObject *module, PyObject *noargs) {
 
 #ifdef VMPROF_UNIX
 static PyObject *
-insert_real_time_thread(PyObject *module, PyObject * noargs) {
+insert_real_time_thread(PyObject *module, PyObject * args) {
     ssize_t thread_count;
+    unsigned long thread_id = 0;
+    pthread_t th = pthread_self();
+
+    if (!PyArg_ParseTuple(args, "|k", &thread_id)) {
+        return NULL;
+    }
+
+    if (thread_id) {
+#if SIZEOF_LONG <= SIZEOF_PTHREAD_T
+        th = (pthread_t) thread_id;
+#else
+        th = (pthread_t) *(unsigned long *) &thread_id;
+#endif
+    }
 
     if (!vmprof_is_enabled()) {
         PyErr_SetString(PyExc_ValueError, "vmprof is not enabled");
@@ -397,15 +411,29 @@ insert_real_time_thread(PyObject *module, PyObject * noargs) {
     }
 
     vmprof_aquire_lock();
-    thread_count = insert_thread(pthread_self(), -1);
+    thread_count = insert_thread(th, -1);
     vmprof_release_lock();
 
     return PyLong_FromSsize_t(thread_count);
 }
 
 static PyObject *
-remove_real_time_thread(PyObject *module, PyObject * noargs) {
+remove_real_time_thread(PyObject *module, PyObject * args) {
     ssize_t thread_count;
+    unsigned long thread_id = 0;
+    pthread_t th = pthread_self();
+
+    if (!PyArg_ParseTuple(args, "|k", &thread_id)) {
+        return NULL;
+    }
+
+    if (thread_id) {
+#if SIZEOF_LONG <= SIZEOF_PTHREAD_T
+        th = (pthread_t) thread_id;
+#else
+        th = (pthread_t) *(unsigned long *) &thread_id;
+#endif
+    }
 
     if (!vmprof_is_enabled()) {
         PyErr_SetString(PyExc_ValueError, "vmprof is not enabled");
@@ -418,7 +446,7 @@ remove_real_time_thread(PyObject *module, PyObject * noargs) {
     }
 
     vmprof_aquire_lock();
-    thread_count = remove_thread(pthread_self(), -1);
+    thread_count = remove_thread(th, -1);
     vmprof_release_lock();
 
     return PyLong_FromSsize_t(thread_count);
@@ -445,9 +473,9 @@ static PyMethodDef VMProfMethods[] = {
 #ifdef VMPROF_UNIX
     {"get_profile_path", vmp_get_profile_path, METH_NOARGS,
         "Profile path the profiler logs to."},
-    {"insert_real_time_thread", insert_real_time_thread, METH_NOARGS,
+    {"insert_real_time_thread", insert_real_time_thread, METH_VARARGS,
         "Insert a thread into the real time profiling list."},
-    {"remove_real_time_thread", remove_real_time_thread, METH_NOARGS,
+    {"remove_real_time_thread", remove_real_time_thread, METH_VARARGS,
         "Remove a thread from the real time profiling list."},
 #endif
     {NULL, NULL, 0, NULL}        /* Sentinel */
 
@@ -102,19 +102,21 @@ def resolve_addr(addr):
         """
         return _vmprof.resolve_addr(addr)
 
-def insert_real_time_thread():
+def insert_real_time_thread(thread_id=0):
     """ Inserts a thread into the list of threads to be sampled in real time mode.
         When enabling real time mode, the caller thread is inserted automatically.
         Returns the number of registered threads, or -1 if we can't insert thread.
+        Inserts the current thread if thread_id is not provided.
     """
-    return _vmprof.insert_real_time_thread()
+    return _vmprof.insert_real_time_thread(thread_id)
 
-def remove_real_time_thread():
+def remove_real_time_thread(thread_id=0):
     """ Removes a thread from the list of threads to be sampled in real time mode.
         When disabling in real time mode, *all* threads are removed automatically.
         Returns the number of registered threads, or -1 if we can't remove thread.
+        Removes the current thread if thread_id is not provided.
     """
-    return _vmprof.remove_real_time_thread()
+    return _vmprof.remove_real_time_thread(thread_id)
 
 
 def is_enabled():
 
@@ -288,6 +288,36 @@ def test_vmprof_real_time_threaded(insert_foo, remove_bar):
     assert remove_bar != (bar_time_name in d)
 
 
+@py.test.mark.skipif("'__pypy__' in sys.builtin_module_names")
+@py.test.mark.skipif("sys.platform == 'win32'")
+@py.test.mark.parametrize("insert_foo,remove_bar", [
+    (False, False),
+    (False,  True),
+    ( True, False),
+    ( True,  True),
+])
+def test_insert_other_real_time_thread(insert_foo, remove_bar):
+    import threading
+    prof = vmprof.Profiler()
+    wait = 0.5
+    # This test is the same as above, except that we manually add/remove
+    # all threads explicitly by id from the main thread.
+    thread = threading.Thread(target=functime_foo, args=[wait, False])
+    with prof.measure(period=0.25, real_time=True):
+        thread.start()
+        if insert_foo:
+            vmprof.insert_real_time_thread(thread.ident)
+        if remove_bar:
+            vmprof.remove_real_time_thread(threading.current_thread().ident)
+        functime_bar(wait, False)
+        thread.join()
+    stats = prof.get_stats()
+    tprof = stats.top_profile()
+    d = dict(tprof)
+    assert insert_foo == (foo_time_name in d)
+    assert remove_bar != (bar_time_name in d)
+
+
 
 if GZIP:
     def test_gzip_problem():