kindred/create
1
1
Fork 0
Code Issues 37 Pull Requests Actions Packages Projects 9 Releases 2 Wiki Activity

Made the interval that the Python profiler runs at configurable

Browse Source 
Added a "User parameter:BaseApp/Preferences/PythonConsole/ProfilerInterval" int
property which sets how often (in milliseconds) the Python profiler runs while
Python code is running. Setting this value to zero will totally disable it.

Also added a preference in the Python console screen which allows the user to
set the value of this property to between 0 (disabled) and 5000 (once every 5
seconds). (+1 squashed commits)

Squashed commits:

[cca88ac633] Made the Python profiler only run when the console is running code

This has two purposes. First, it prevents a performance impact from running the
profiler whenever Python code is running. Second, it prevents crashes caused by
Qt's process events function being called too frequently. When the Python code
is running in the console, it monopolizes the main thread and prevents events
from being processed. Therefore, causing events to be processed in the callback
should not force events to be processed too frequently, because the normal loop
is being prevented by the Python code. (+1 squashed commits)

Squashed commits:

[45f86917e6] Made long-running Python code not freeze the GUI without multithreading

Removed the background thread running Python code and replaced it with a custom
profiler which the Python interpreter runs frequently (at every Python opcode I
believe) on the main thread whenever Python code is running. The profiler will
make Qt process any new events every 200 ms, preventing "App not responding"
messages and making sure any Ctrl+C keypresses will be processed. This prevents
the previous issue where running anything GUI-related from Python would crash
the program (because Qt isn't thread-safe). (+1 squashed commits)

Squashed commits:

[0ef7d810b3] Made the process of getting thread IDs cross-platform compatible

Instead of using <threads.h>, now the standard <thread> header from C++
11 is used to find the thread ID, since <threads.h> is apparently not
available on Windows. (+1 squashed commits)

Squashed commits:

[74c7b867f2] # This is a combination of 2 commits.

Python from the console now runs in the background

In a nutshell, all Python code which is input from the interactive console
now runs in a seperate QThread which runs in the background, instead of
on the UI thread. This means that long operates operations will no longer
cause the app to display an "App not responding" message, because the UI
thread is now free to keep running unencumbered.

However, it is still not possible to run multiple Python statements at
the same time. If the user tries to run some Python while a previous
statement is still being processed, instead it will display an error
message in the console stating that the previous command is still
being processed.

I also added a seperate QTimer which runs once every 100ms to flush any
output from the Python code back to the console. I can't flush the output
to the console from the background thread because the relevant Qt5 code
is not thread-safe (it causes random segfaults). So I added this timer
as a work-around, since it runs in the main UI thread.

Implemented Ctrl+C keyboard interrupts in the console

This is implemented by detecting a Ctrl+C key event in the Python
console in the main Qt UI thread, and sending a keyboard interrupt
to the background thread that runs the Python code.
This commit is contained in:
Michael Tuma
2022-04-06 17:45:08 -04:00
committed by wwmayer
parent dda8166119
commit e78f74b01a
7 changed files with 375 additions and 7 deletions
Download Patch File Download Diff File Expand all files Collapse all files

161
src/Gui/PythonTracing.cpp Normal file
View File

@@ -0,0 +1,161 @@
// SPDX-License-Identifier: LGPL-2.1-or-later
/***************************************************************************
* Copyright (c) 2023 Werner Mayer <wmayer[at]users.sourceforge.net> *
* *
* This file is part of FreeCAD. *
* *
* FreeCAD is free software: you can redistribute it and/or modify it *
* under the terms of the GNU Lesser General Public License as *
* published by the Free Software Foundation, either version 2.1 of the *
* License, or (at your option) any later version. *
* *
* FreeCAD is distributed in the hope that it will be useful, but *
* WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
* Lesser General Public License for more details. *
* *
* You should have received a copy of the GNU Lesser General Public *
* License along with FreeCAD. If not, see *
* <https://www.gnu.org/licenses/>. *
* *
**************************************************************************/
#include "PreCompiled.h"
#ifndef _PreComp_
#include <QTime>
#include <QGuiApplication>
#endif
#include "PythonTracing.h"
#include <App/Application.h>
using namespace Gui;
struct PythonTracing::Private
{
bool active{false};
int timeout{200}; //NOLINT
// NOLINTBEGIN
static int profilerInterval;
static bool profilerDisabled;
// NOLINTEND
};
// NOLINTBEGIN
int PythonTracing::Private::profilerInterval = 200;
bool PythonTracing::Private::profilerDisabled = false;
// NOLINTEND
PythonTracing::PythonTracing()
: d{std::make_unique<Private>()}
{
}
PythonTracing::~PythonTracing() = default;
bool PythonTracing::isActive() const
{
return d->active;
}
void PythonTracing::activate()
{
d->active = true;
setPythonTraceEnabled(true);
}
void PythonTracing::deactivate()
{
d->active = false;
setPythonTraceEnabled(false);
}
void PythonTracing::fetchFromSettings()
{
const long defaultTimeout = 200;
auto parameterGroup = App::GetApplication().GetParameterGroupByPath(
"User parameter:BaseApp/Preferences/PythonConsole");
int interval = static_cast<int>(parameterGroup->GetInt("ProfilerInterval", defaultTimeout));
setTimeout(interval);
}
bool PythonTracing::interrupt() const
{
if (isActive()) {
PyErr_SetInterrupt();
return true;
}
return false;
}
void PythonTracing::setTimeout(int ms)
{
d->timeout = ms;
}
int PythonTracing::timeout() const
{
return d->timeout;
}
void PythonTracing::setPythonTraceEnabled(bool enabled) const
{
Py_tracefunc trace = nullptr;
if (enabled && timeout() > 0) {
Private::profilerInterval = timeout();
trace = &tracer_callback;
}
else {
Private::profilerDisabled = true;
}
PyEval_SetTrace(trace, nullptr);
}
/*
* This callback ensures that Qt runs its event loop (i.e. updates the GUI, processes keyboard and
* mouse events, etc.) at least every 200 ms, even when there is long-running Python code on the
* main thread. It is registered as the global trace function of the Python environment.
*/
int PythonTracing::tracer_callback(PyObject *obj, PyFrameObject *frame, int what, PyObject *arg)
{
Q_UNUSED(obj)
Q_UNUSED(frame)
Q_UNUSED(what)
Q_UNUSED(arg)
static QTime lastCalledTime = QTime::currentTime();
QTime currTime = QTime::currentTime();
// if previous code object was executed
if (Private::profilerDisabled) {
Private::profilerDisabled = false;
lastCalledTime = currTime;
}
int ms = lastCalledTime.msecsTo(currTime);
if (ms >= Private::profilerInterval) {
lastCalledTime = currTime;
QGuiApplication::processEvents();
}
return 0;
}
// ------------------------------------------------------------------------------------------------
PythonTracingLocker::PythonTracingLocker(PythonTracing& trace)
: trace{trace}
{
trace.activate();
}
PythonTracingLocker::~PythonTracingLocker()
{
trace.deactivate();
}