feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

Fixes for valgrind-callgrind feedback by Nokia

Browse Source 
Most changes include style fixes and UI changes for better usability.

Merge-request: 324
Reviewed-by: hjk <qtc-committer@nokia.com>
This commit is contained in:
Kevin Funk
2011-05-11 16:26:34 +02:00
committed by hjk
parent f5601d7b1b
commit bf1f5c2b02
44 changed files with 429 additions and 234 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
src/libs/valgrind/callgrind/callgrindcallmodel.cpp
View File

@@ -208,11 +208,21 @@ QVariant CallModel::data(const QModelIndex &index, int role) const
QVariant CallModel::headerData(int section, Qt::Orientation orientation, int role) const QVariant CallModel::headerData(int section, Qt::Orientation orientation, int role) const
{ {
if (orientation == Qt::Vertical || role != Qt::DisplayRole) if (orientation == Qt::Vertical || (role != Qt::DisplayRole && role != Qt::ToolTipRole))
return QVariant(); return QVariant();
QTC_ASSERT(section >= 0 && section < columnCount(), return QVariant()); QTC_ASSERT(section >= 0 && section < columnCount(), return QVariant());
if (role == Qt::ToolTipRole) {
if (section == CostColumn) {
if (!d->m_data)
return QVariant();
return ParseData::prettyStringForEvent(d->m_data->events().at(d->m_event));
}
return QVariant();
}
if (section == CalleeColumn) if (section == CalleeColumn)
return tr("Callee"); return tr("Callee");
else if (section == CallerColumn) else if (section == CallerColumn)

4
src/libs/valgrind/callgrind/callgrindcontroller.h
View File

@@ -36,7 +36,6 @@
#include <QObject> #include <QObject>
#include <qprocess.h> #include <qprocess.h>
#include <qmetatype.h>
#include <utils/ssh/sshconnection.h> #include <utils/ssh/sshconnection.h>
#include <utils/ssh/sshremoteprocess.h> #include <utils/ssh/sshremoteprocess.h>
@@ -69,6 +68,7 @@ public:
void run(Valgrind::Callgrind::CallgrindController::Option option); void run(Valgrind::Callgrind::CallgrindController::Option option);
void setValgrindProcess(ValgrindProcess *process); void setValgrindProcess(ValgrindProcess *process);
inline ValgrindProcess *valgrindProcess() { return m_valgrindProc; }
/** /**
* Make data file available locally, triggers @c localParseDataAvailable. * Make data file available locally, triggers @c localParseDataAvailable.
@@ -96,7 +96,7 @@ private Q_SLOTS:
private: private:
void cleanupTempFile(); void cleanupTempFile();
// callgrind_controll process // callgrind_control process
Valgrind::ValgrindProcess *m_process; Valgrind::ValgrindProcess *m_process;
// valgrind process // valgrind process
Valgrind::ValgrindProcess *m_valgrindProc; Valgrind::ValgrindProcess *m_valgrindProc;

30
src/libs/valgrind/callgrind/callgrinddatamodel.cpp
View File

@@ -65,6 +65,7 @@ public:
Private() Private()
: m_data(0) : m_data(0)
, m_event(0) , m_event(0)
, m_verboseToolTips(true)
, m_cycleDetection(false) , m_cycleDetection(false)
{ {
} }
@@ -77,6 +78,7 @@ public:
const ParseData *m_data; const ParseData *m_data;
int m_event; int m_event;
bool m_verboseToolTips;
bool m_cycleDetection; bool m_cycleDetection;
QVector<const Function *> m_functions; QVector<const Function *> m_functions;
}; };
@@ -128,6 +130,16 @@ void DataModel::setParseData(const ParseData *data)
endResetModel(); endResetModel();
} }
void DataModel::setVerboseToolTipsEnabled(bool enabled)
{
d->m_verboseToolTips = enabled;
}
bool DataModel::verboseToolTipsEnabled() const
{
return d->m_verboseToolTips;
}
const ParseData *DataModel::parseData() const const ParseData *DataModel::parseData() const
{ {
return d->m_data; return d->m_data;
@@ -254,6 +266,9 @@ QVariant DataModel::data(const QModelIndex &index, int role) const
else if (index.column() == InclusiveCostColumn) else if (index.column() == InclusiveCostColumn)
return inclusiveCost; return inclusiveCost;
} else if (role == Qt::ToolTipRole) { } else if (role == Qt::ToolTipRole) {
if (!d->m_verboseToolTips)
return data(index, Qt::DisplayRole);
QString ret = "<html><head><style>\ QString ret = "<html><head><style>\
dt { font-weight: bold; }\ dt { font-weight: bold; }\
dd { font-family: monospace; }\ dd { font-family: monospace; }\
@@ -311,11 +326,24 @@ QVariant DataModel::data(const QModelIndex &index, int role) const
QVariant DataModel::headerData(int section, Qt::Orientation orientation, int role) const QVariant DataModel::headerData(int section, Qt::Orientation orientation, int role) const
{ {
if (orientation == Qt::Vertical || role != Qt::DisplayRole) if (orientation == Qt::Vertical || (role != Qt::DisplayRole && role != Qt::ToolTipRole))
return QVariant(); return QVariant();
QTC_ASSERT(section >= 0 && section < columnCount(), return QVariant()); QTC_ASSERT(section >= 0 && section < columnCount(), return QVariant());
if (role == Qt::ToolTipRole) {
if (!d->m_data)
return QVariant();
const QString prettyCostStr = ParseData::prettyStringForEvent(d->m_data->events().at(d->m_event));
if (section == SelfCostColumn) {
return tr("%1 cost spent in a given function excluding costs from called functions.").arg(prettyCostStr);
} else if (section == InclusiveCostColumn) {
return tr("%1 cost spent in a given function including costs from called functions.").arg(prettyCostStr);
}
return QVariant();
}
if (section == NameColumn) if (section == NameColumn)
return tr("Function"); return tr("Function");
else if (section == LocationColumn) else if (section == LocationColumn)

3
src/libs/valgrind/callgrind/callgrinddatamodel.h
View File

@@ -56,6 +56,9 @@ public:
virtual void setParseData(const ParseData *data); virtual void setParseData(const ParseData *data);
virtual const ParseData *parseData() const; virtual const ParseData *parseData() const;
void setVerboseToolTipsEnabled(bool enabled);
bool verboseToolTipsEnabled() const;
/// Only one cost event column will be shown, this decides which one it is. /// Only one cost event column will be shown, this decides which one it is.
/// By default it is the first event in the @c ParseData, i.e. 0. /// By default it is the first event in the @c ParseData, i.e. 0.
virtual int costEvent() const; virtual int costEvent() const;

15
src/libs/valgrind/valgrindprocess.cpp
View File

@@ -38,6 +38,8 @@
#include <QtCore/QEventLoop> #include <QtCore/QEventLoop>
#include <QtCore/QFileInfo> #include <QtCore/QFileInfo>
#include <utils/qtcassert.h>
namespace Valgrind { namespace Valgrind {
ValgrindProcess::ValgrindProcess(QObject *parent) ValgrindProcess::ValgrindProcess(QObject *parent)
@@ -204,6 +206,8 @@ void RemoteValgrindProcess::run(const QString &valgrindExecutable, const QString
void RemoteValgrindProcess::connected() void RemoteValgrindProcess::connected()
{ {
QTC_ASSERT(m_connection->state() == Utils::SshConnection::Connected, return);
// connected, run command // connected, run command
QString cmd; QString cmd;
@@ -235,6 +239,8 @@ Utils::SshConnection::Ptr RemoteValgrindProcess::connection() const
void RemoteValgrindProcess::processStarted() void RemoteValgrindProcess::processStarted()
{ {
QTC_ASSERT(m_connection->state() == Utils::SshConnection::Connected, return);
// find out what PID our process has // find out what PID our process has
// NOTE: valgrind cloaks its name, // NOTE: valgrind cloaks its name,
@@ -293,9 +299,8 @@ void RemoteValgrindProcess::error(Utils::SshError error)
void RemoteValgrindProcess::close() void RemoteValgrindProcess::close()
{ {
QTC_ASSERT(m_connection->state() == Utils::SshConnection::Connected, return);
if (m_process) { if (m_process) {
m_process->closeChannel();
if (m_pid) { if (m_pid) {
const QString killTemplate = QString("kill -%2 %1" // kill const QString killTemplate = QString("kill -%2 %1" // kill
).arg(m_pid); ).arg(m_pid);
@@ -304,14 +309,16 @@ void RemoteValgrindProcess::close()
const QString brutalKill = killTemplate.arg("SIGKILL"); const QString brutalKill = killTemplate.arg("SIGKILL");
const QString remoteCall = niceKill + QLatin1String("; sleep 1; ") + brutalKill; const QString remoteCall = niceKill + QLatin1String("; sleep 1; ") + brutalKill;
m_cleanup = m_connection->createRemoteProcess(remoteCall.toUtf8()); Utils::SshRemoteProcess::Ptr cleanup = m_connection->createRemoteProcess(remoteCall.toUtf8());
m_cleanup->start(); cleanup->start();
} }
} }
} }
void RemoteValgrindProcess::closed(int status) void RemoteValgrindProcess::closed(int status)
{ {
QTC_ASSERT(m_process, return);
m_errorString = m_process->errorString(); m_errorString = m_process->errorString();
if (status == Utils::SshRemoteProcess::FailedToStart) { if (status == Utils::SshRemoteProcess::FailedToStart) {
m_error = QProcess::FailedToStart; m_error = QProcess::FailedToStart;

1
src/libs/valgrind/valgrindprocess.h
View File

@@ -156,7 +156,6 @@ private:
Utils::SshConnectionParameters m_params; Utils::SshConnectionParameters m_params;
Utils::SshConnection::Ptr m_connection; Utils::SshConnection::Ptr m_connection;
Utils::SshRemoteProcess::Ptr m_process; Utils::SshRemoteProcess::Ptr m_process;
Utils::SshRemoteProcess::Ptr m_cleanup;
QString m_workingDir; QString m_workingDir;
QString m_valgrindExe; QString m_valgrindExe;
QStringList m_valgrindArgs; QStringList m_valgrindArgs;

9
src/plugins/analyzerbase/analyzermanager.cpp
View File

@@ -210,6 +210,7 @@ public:
AnalyzerRunControlFactory *m_runControlFactory; AnalyzerRunControlFactory *m_runControlFactory;
ProjectExplorer::RunControl *m_currentRunControl; ProjectExplorer::RunControl *m_currentRunControl;
Utils::FancyMainWindow *m_mainWindow; Utils::FancyMainWindow *m_mainWindow;
IAnalyzerTool *m_currentTool;
QList<IAnalyzerTool *> m_tools; QList<IAnalyzerTool *> m_tools;
QActionGroup *m_toolGroup; QActionGroup *m_toolGroup;
QAction *m_startAction; QAction *m_startAction;
@@ -232,7 +233,6 @@ public:
bool m_restartOnStop; bool m_restartOnStop;
bool m_initialized; bool m_initialized;
IAnalyzerTool *m_currentTool;
}; };
AnalyzerManager::AnalyzerManagerPrivate::AnalyzerManagerPrivate(AnalyzerManager *qq): AnalyzerManager::AnalyzerManagerPrivate::AnalyzerManagerPrivate(AnalyzerManager *qq):
@@ -242,6 +242,7 @@ AnalyzerManager::AnalyzerManagerPrivate::AnalyzerManagerPrivate(AnalyzerManager
m_runControlFactory(0), m_runControlFactory(0),
m_currentRunControl(0), m_currentRunControl(0),
m_mainWindow(0), m_mainWindow(0),
m_currentTool(0),
m_toolGroup(0), m_toolGroup(0),
m_startAction(0), m_startAction(0),
m_startRemoteAction(0), m_startRemoteAction(0),
@@ -253,8 +254,7 @@ AnalyzerManager::AnalyzerManagerPrivate::AnalyzerManagerPrivate(AnalyzerManager
m_statusLabel(new Utils::StatusLabel), m_statusLabel(new Utils::StatusLabel),
m_resizeEventFilter(new DockWidgetEventFilter(qq)), m_resizeEventFilter(new DockWidgetEventFilter(qq)),
m_restartOnStop(false), m_restartOnStop(false),
m_initialized(false), m_initialized(false)
m_currentTool(0)
{ {
m_toolBox->setObjectName(QLatin1String("AnalyzerManagerToolBox")); m_toolBox->setObjectName(QLatin1String("AnalyzerManagerToolBox"));
m_runControlFactory = new AnalyzerRunControlFactory(); m_runControlFactory = new AnalyzerRunControlFactory();
@@ -541,7 +541,7 @@ void AnalyzerManager::AnalyzerManagerPrivate::startTool()
const QString msg = tr("<html><head/><body><center><i>%1</i> is still running. You have to quit the Analyzer before being able to run another instance.<center/>" const QString msg = tr("<html><head/><body><center><i>%1</i> is still running. You have to quit the Analyzer before being able to run another instance.<center/>"
"<center>Force it to quit?</center></body></html>").arg(m_currentRunControl->displayName()); "<center>Force it to quit?</center></body></html>").arg(m_currentRunControl->displayName());
bool stopRequested = showPromptDialog(tr("Analyzer Still Running"), msg, bool stopRequested = showPromptDialog(tr("Analyzer Still Running"), msg,
tr("Stop active run"), tr("Keep Running")); tr("Stop Active Run"), tr("Keep Running"));
if (!stopRequested) if (!stopRequested)
return; // no restart, keep it running, do nothing return; // no restart, keep it running, do nothing
@@ -657,7 +657,6 @@ void AnalyzerManager::toolSelected(int idx)
return; return;
selectingTool = true; selectingTool = true;
if (oldTool != 0) { if (oldTool != 0) {
saveToolSettings(oldTool); saveToolSettings(oldTool);

18
src/plugins/callgrind/callgrindconfigwidget.cpp
View File

@@ -68,6 +68,24 @@ CallgrindConfigWidget::CallgrindConfigWidget(AbstractCallgrindSettings *settings
m_settings, SLOT(setCollectBusEvents(bool))); m_settings, SLOT(setCollectBusEvents(bool)));
connect(m_settings, SIGNAL(collectBusEventsChanged(bool)), connect(m_settings, SIGNAL(collectBusEventsChanged(bool)),
m_ui->collectBusEvents, SLOT(setChecked(bool))); m_ui->collectBusEvents, SLOT(setChecked(bool)));
m_ui->enableEventToolTips->setChecked(m_settings->enableEventToolTips());
connect(m_ui->enableEventToolTips, SIGNAL(toggled(bool)),
m_settings, SLOT(setEnableEventToolTips(bool)));
connect(m_settings, SIGNAL(enableEventToolTipsChanged(bool)),
m_ui->enableEventToolTips, SLOT(setChecked(bool)));
m_ui->minimumInclusiveCostRatio->setValue(m_settings->minimumInclusiveCostRatio());
connect(m_ui->minimumInclusiveCostRatio, SIGNAL(valueChanged(double)),
m_settings, SLOT(setMinimumInclusiveCostRatio(double)));
connect(m_settings, SIGNAL(minimumInclusiveCostRatioChanged(double)),
m_ui->minimumInclusiveCostRatio, SLOT(setValue(double)));
m_ui->visualisationMinimumInclusiveCostRatio->setValue(m_settings->visualisationMinimumInclusiveCostRatio());
connect(m_ui->visualisationMinimumInclusiveCostRatio, SIGNAL(valueChanged(double)),
m_settings, SLOT(setVisualisationMinimumInclusiveCostRatio(double)));
connect(m_settings, SIGNAL(visualisationMinimumInclusiveCostRatioChanged(double)),
m_ui->visualisationMinimumInclusiveCostRatio, SLOT(setValue(double)));
} }
CallgrindConfigWidget::~CallgrindConfigWidget() CallgrindConfigWidget::~CallgrindConfigWidget()

94
src/plugins/callgrind/callgrindconfigwidget.ui
View File

@@ -10,8 +10,8 @@
<height>565</height> <height>565</height>
</rect> </rect>
</property> </property>
<layout class="QVBoxLayout" name="verticalLayout"> <layout class="QGridLayout" name="gridLayout">
<item> <item row="0" column="0" colspan="2">
<widget class="QGroupBox" name="memcheckOptions"> <widget class="QGroupBox" name="memcheckOptions">
<property name="sizePolicy"> <property name="sizePolicy">
<sizepolicy hsizetype="Preferred" vsizetype="Preferred"> <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
@@ -22,21 +22,46 @@
<property name="title"> <property name="title">
<string>Profiling Options</string> <string>Profiling Options</string>
</property> </property>
<layout class="QGridLayout" name="gridLayout"> <layout class="QFormLayout" name="formLayout">
<item row="4" column="0" colspan="2"> <item row="0" column="0">
<spacer name="verticalSpacer"> <widget class="QLabel" name="minimumInclusiveCostRatioLabel">
<property name="orientation"> <property name="toolTip">
<enum>Qt::Vertical</enum> <string>This option limits the amount of results the profiler will give you. A lower limit will likely increase performance.</string>
</property> </property>
<property name="sizeHint" stdset="0"> <property name="text">
<size> <string>Result view: Show events with inclusive costs higher than:</string>
<width>20</width>
<height>40</height>
</size>
</property> </property>
</spacer> <property name="buddy">
<cstring>minimumInclusiveCostRatio</cstring>
</property>
</widget>
</item> </item>
<item row="0" column="0" colspan="2"> <item row="0" column="1">
<widget class="QDoubleSpinBox" name="minimumInclusiveCostRatio">
<property name="suffix">
<string>%</string>
</property>
<property name="decimals">
<number>2</number>
</property>
<property name="maximum">
<double>10.000000000000000</double>
</property>
<property name="singleStep">
<double>0.100000000000000</double>
</property>
</widget>
</item>
<item row="2" column="0" colspan="2">
<widget class="QGroupBox" name="enableEventToolTips">
<property name="title">
<string>Show additional information for events in tooltips</string>
</property>
<property name="checkable">
<bool>true</bool>
</property>
<layout class="QGridLayout" name="gridLayout_3">
<item row="0" column="0">
<widget class="QCheckBox" name="enableCacheSim"> <widget class="QCheckBox" name="enableCacheSim">
<property name="toolTip"> <property name="toolTip">
<string>&lt;!DOCTYPE HTML PUBLIC &quot;-//W3C//DTD HTML 4.0//EN&quot; &quot;http://www.w3.org/TR/REC-html40/strict.dtd&quot;&gt; <string>&lt;!DOCTYPE HTML PUBLIC &quot;-//W3C//DTD HTML 4.0//EN&quot; &quot;http://www.w3.org/TR/REC-html40/strict.dtd&quot;&gt;
@@ -96,13 +121,52 @@ p, li { white-space: pre-wrap; }
<string>This specifies whether the number of global bus events executed should be collected. The event type &quot;Ge&quot; is used for these events.</string> <string>This specifies whether the number of global bus events executed should be collected. The event type &quot;Ge&quot; is used for these events.</string>
</property> </property>
<property name="text"> <property name="text">
<string>Collect global bus events</string> <string>Collect global bus events:</string>
</property> </property>
</widget> </widget>
</item> </item>
</layout> </layout>
</widget> </widget>
</item> </item>
<item row="1" column="0">
<widget class="QLabel" name="visualisationMinimumInclusiveCostRatioLabel">
<property name="text">
<string>Visualisation: Show events with inclusive costs higher than:</string>
</property>
</widget>
</item>
<item row="1" column="1">
<widget class="QDoubleSpinBox" name="visualisationMinimumInclusiveCostRatio">
<property name="prefix">
<string/>
</property>
<property name="suffix">
<string>%</string>
</property>
<property name="minimum">
<double>0.000000000000000</double>
</property>
<property name="maximum">
<double>50.000000000000000</double>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item row="1" column="0" colspan="2">
<spacer name="verticalSpacer">
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>20</width>
<height>40</height>
</size>
</property>
</spacer>
</item>
</layout> </layout>
</widget> </widget>
<resources/> <resources/>

4
src/plugins/callgrind/callgrindengine.cpp
View File

@@ -126,12 +126,14 @@ void CallgrindEngine::setPaused(bool paused)
m_markAsPaused = paused; m_markAsPaused = paused;
// call controller // call controller only if it is attached to a valgrind process
if (m_runner.controller()->valgrindProcess()) {
if (paused) if (paused)
pause(); pause();
else else
unpause(); unpause();
} }
}
void CallgrindEngine::setToggleCollectFunction(const QString &toggleCollectFunction) void CallgrindEngine::setToggleCollectFunction(const QString &toggleCollectFunction)
{ {

3
src/plugins/callgrind/callgrindengine.h
View File

@@ -60,7 +60,10 @@ public slots:
void pause(); void pause();
void unpause(); void unpause();
/// marks the callgrind process as paused
/// calls pause() and unpause() if there's an active run
void setPaused(bool paused); void setPaused(bool paused);
void setToggleCollectFunction(const QString &toggleCollectFunction); void setToggleCollectFunction(const QString &toggleCollectFunction);
protected: protected:

59
src/plugins/callgrind/callgrindsettings.cpp
View File

@@ -44,10 +44,12 @@ static const char callgrindEnableCacheSimC[] = "Analyzer.Valgrind.Callgrind.Enab
static const char callgrindEnableBranchSimC[] = "Analyzer.Valgrind.Callgrind.EnableBranchSim"; static const char callgrindEnableBranchSimC[] = "Analyzer.Valgrind.Callgrind.EnableBranchSim";
static const char callgrindCollectSystimeC[] = "Analyzer.Valgrind.Callgrind.CollectSystime"; static const char callgrindCollectSystimeC[] = "Analyzer.Valgrind.Callgrind.CollectSystime";
static const char callgrindCollectBusEventsC[] = "Analyzer.Valgrind.Callgrind.CollectBusEvents"; static const char callgrindCollectBusEventsC[] = "Analyzer.Valgrind.Callgrind.CollectBusEvents";
static const char callgrindEnableEventToolTipsC[] = "Analyzer.Valgrind.Callgrind.EnableEventToolTips";
static const char callgrindMinimumCostRatioC[] = "Analyzer.Valgrind.Callgrind.MinimumCostRatio";
static const char callgrindVisualisationMinimumCostRatioC[] = "Analyzer.Valgrind.Callgrind.VisualisationMinimumCostRatio";
static const char callgrindCycleDetectionC[] = "Analyzer.Valgrind.Callgrind.CycleDetection"; static const char callgrindCycleDetectionC[] = "Analyzer.Valgrind.Callgrind.CycleDetection";
static const char callgrindCostFormatC[] = "Analyzer.Valgrind.Callgrind.CostFormat"; static const char callgrindCostFormatC[] = "Analyzer.Valgrind.Callgrind.CostFormat";
static const char callgrindMinimumCostRatioC[] = "Analyzer.Valgrind.Callgrind.MinimumCostRatio";
AbstractCallgrindSettings::AbstractCallgrindSettings(QObject *parent) AbstractCallgrindSettings::AbstractCallgrindSettings(QObject *parent)
: AbstractAnalyzerSubConfig(parent) : AbstractAnalyzerSubConfig(parent)
@@ -96,6 +98,35 @@ void AbstractCallgrindSettings::setCollectBusEvents(bool collect)
emit collectBusEventsChanged(collect); emit collectBusEventsChanged(collect);
} }
void AbstractCallgrindSettings::setEnableEventToolTips(bool enable)
{
if (m_enableEventToolTips == enable)
return;
m_enableEventToolTips = enable;
emit enableEventToolTipsChanged(enable);
}
void AbstractCallgrindSettings::setMinimumInclusiveCostRatio(
double minimumInclusiveCostRatio)
{
if (m_minimumInclusiveCostRatio == minimumInclusiveCostRatio)
return;
m_minimumInclusiveCostRatio = qBound(0.0, minimumInclusiveCostRatio, 100.0);
emit minimumInclusiveCostRatioChanged(minimumInclusiveCostRatio);
}
void AbstractCallgrindSettings::setVisualisationMinimumInclusiveCostRatio(
double minimumInclusiveCostRatio)
{
if (m_visualisationMinimumInclusiveCostRatio == minimumInclusiveCostRatio)
return;
m_visualisationMinimumInclusiveCostRatio = qBound(0.0, minimumInclusiveCostRatio, 100.0);
emit visualisationMinimumInclusiveCostRatioChanged(minimumInclusiveCostRatio);
}
QVariantMap AbstractCallgrindSettings::defaults() const QVariantMap AbstractCallgrindSettings::defaults() const
{ {
QVariantMap map; QVariantMap map;
@@ -103,6 +134,9 @@ QVariantMap AbstractCallgrindSettings::defaults() const
map.insert(QLatin1String(callgrindEnableBranchSimC), false); map.insert(QLatin1String(callgrindEnableBranchSimC), false);
map.insert(QLatin1String(callgrindCollectSystimeC), false); map.insert(QLatin1String(callgrindCollectSystimeC), false);
map.insert(QLatin1String(callgrindCollectBusEventsC), false); map.insert(QLatin1String(callgrindCollectBusEventsC), false);
map.insert(QLatin1String(callgrindEnableEventToolTipsC), true);
map.insert(QLatin1String(callgrindMinimumCostRatioC), 0.01);
map.insert(QLatin1String(callgrindVisualisationMinimumCostRatioC), 10.0);
return map; return map;
} }
@@ -112,6 +146,10 @@ bool AbstractCallgrindSettings::fromMap(const QVariantMap &map)
setIfPresent(map, QLatin1String(callgrindEnableBranchSimC), &m_enableBranchSim); setIfPresent(map, QLatin1String(callgrindEnableBranchSimC), &m_enableBranchSim);
setIfPresent(map, QLatin1String(callgrindCollectSystimeC), &m_collectSystime); setIfPresent(map, QLatin1String(callgrindCollectSystimeC), &m_collectSystime);
setIfPresent(map, QLatin1String(callgrindCollectBusEventsC), &m_collectBusEvents); setIfPresent(map, QLatin1String(callgrindCollectBusEventsC), &m_collectBusEvents);
setIfPresent(map, QLatin1String(callgrindEnableEventToolTipsC), &m_enableEventToolTips);
setIfPresent(map, QLatin1String(callgrindMinimumCostRatioC), &m_minimumInclusiveCostRatio);
setIfPresent(map, QLatin1String(callgrindVisualisationMinimumCostRatioC),
&m_visualisationMinimumInclusiveCostRatio);
return true; return true;
} }
@@ -122,7 +160,10 @@ QVariantMap AbstractCallgrindSettings::toMap() const
map.insert(QLatin1String(callgrindEnableBranchSimC), m_enableBranchSim); map.insert(QLatin1String(callgrindEnableBranchSimC), m_enableBranchSim);
map.insert(QLatin1String(callgrindCollectSystimeC), m_collectSystime); map.insert(QLatin1String(callgrindCollectSystimeC), m_collectSystime);
map.insert(QLatin1String(callgrindCollectBusEventsC), m_collectBusEvents); map.insert(QLatin1String(callgrindCollectBusEventsC), m_collectBusEvents);
map.insert(QLatin1String(callgrindEnableEventToolTipsC), m_enableEventToolTips);
map.insert(QLatin1String(callgrindMinimumCostRatioC), m_minimumInclusiveCostRatio);
map.insert(QLatin1String(callgrindVisualisationMinimumCostRatioC),
m_visualisationMinimumInclusiveCostRatio);
return map; return map;
} }
@@ -158,7 +199,6 @@ QVariantMap CallgrindGlobalSettings::defaults() const
QVariantMap map = AbstractCallgrindSettings::defaults(); QVariantMap map = AbstractCallgrindSettings::defaults();
map.insert(QLatin1String(callgrindCostFormatC), CostDelegate::FormatRelative); map.insert(QLatin1String(callgrindCostFormatC), CostDelegate::FormatRelative);
map.insert(QLatin1String(callgrindCycleDetectionC), true); map.insert(QLatin1String(callgrindCycleDetectionC), true);
map.insert(QLatin1String(callgrindMinimumCostRatioC), 0.0001);
return map; return map;
} }
@@ -170,7 +210,6 @@ bool CallgrindGlobalSettings::fromMap(const QVariantMap &map)
m_costFormat = static_cast<CostDelegate::CostFormat>(map.value(QLatin1String(callgrindCostFormatC)).toInt()); m_costFormat = static_cast<CostDelegate::CostFormat>(map.value(QLatin1String(callgrindCostFormatC)).toInt());
} }
setIfPresent(map, QLatin1String(callgrindCycleDetectionC), &m_detectCycles); setIfPresent(map, QLatin1String(callgrindCycleDetectionC), &m_detectCycles);
setIfPresent(map, QLatin1String(callgrindMinimumCostRatioC), &m_minimumInclusiveCostRatio);
return true; return true;
} }
@@ -179,7 +218,6 @@ QVariantMap CallgrindGlobalSettings::toMap() const
QVariantMap map = AbstractCallgrindSettings::toMap(); QVariantMap map = AbstractCallgrindSettings::toMap();
map.insert(QLatin1String(callgrindCostFormatC), m_costFormat); map.insert(QLatin1String(callgrindCostFormatC), m_costFormat);
map.insert(QLatin1String(callgrindCycleDetectionC), m_detectCycles); map.insert(QLatin1String(callgrindCycleDetectionC), m_detectCycles);
map.insert(QLatin1String(callgrindMinimumCostRatioC), m_minimumInclusiveCostRatio);
return map; return map;
} }
@@ -205,17 +243,6 @@ void CallgrindGlobalSettings::setDetectCycles(bool detect)
AnalyzerGlobalSettings::instance()->writeSettings(); AnalyzerGlobalSettings::instance()->writeSettings();
} }
double CallgrindGlobalSettings::minimumInclusiveCostRatio() const
{
return m_minimumInclusiveCostRatio;
}
void CallgrindGlobalSettings::setMinimumInclusiveCostRatio(double minimumInclusiveCost)
{
m_minimumInclusiveCostRatio = minimumInclusiveCost;
AnalyzerGlobalSettings::instance()->writeSettings();
}
CallgrindProjectSettings::CallgrindProjectSettings(QObject *parent) CallgrindProjectSettings::CallgrindProjectSettings(QObject *parent)
: AbstractCallgrindSettings(parent) : AbstractCallgrindSettings(parent)
{ {

23
src/plugins/callgrind/callgrindsettings.h
View File

@@ -56,6 +56,13 @@ public:
inline bool enableBranchSim() const { return m_enableBranchSim; } inline bool enableBranchSim() const { return m_enableBranchSim; }
inline bool collectSystime() const { return m_collectSystime; } inline bool collectSystime() const { return m_collectSystime; }
inline bool collectBusEvents() const { return m_collectBusEvents; } inline bool collectBusEvents() const { return m_collectBusEvents; }
inline bool enableEventToolTips() const { return m_enableEventToolTips; }
/// \return Minimum cost ratio, range [0.0..100.0]
inline double minimumInclusiveCostRatio() const { return m_minimumInclusiveCostRatio; }
/// \return Minimum cost ratio, range [0.0..100.0]
inline double visualisationMinimumInclusiveCostRatio() const { return m_visualisationMinimumInclusiveCostRatio; }
// abstract virtual methods from base class // abstract virtual methods from base class
virtual bool fromMap(const QVariantMap &map); virtual bool fromMap(const QVariantMap &map);
@@ -71,12 +78,22 @@ public Q_SLOTS:
void setEnableBranchSim(bool enable); void setEnableBranchSim(bool enable);
void setCollectSystime(bool collect); void setCollectSystime(bool collect);
void setCollectBusEvents(bool collect); void setCollectBusEvents(bool collect);
void setEnableEventToolTips(bool enable);
/// \param minimumInclusiveCostRatio Minimum inclusive cost ratio, valid values are [0.0..100.0]
void setMinimumInclusiveCostRatio(double minimumInclusiveCostRatio);
/// \param minimumInclusiveCostRatio Minimum inclusive cost ratio, valid values are [0.0..100.0]
void setVisualisationMinimumInclusiveCostRatio(double minimumInclusiveCostRatio);
Q_SIGNALS: Q_SIGNALS:
void enableCacheSimChanged(bool); void enableCacheSimChanged(bool);
void enableBranchSimChanged(bool); void enableBranchSimChanged(bool);
void collectSystimeChanged(bool); void collectSystimeChanged(bool);
void collectBusEventsChanged(bool); void collectBusEventsChanged(bool);
void enableEventToolTipsChanged(bool);
void minimumInclusiveCostRatioChanged(double);
void visualisationMinimumInclusiveCostRatioChanged(double);
protected: protected:
virtual QVariantMap toMap() const; virtual QVariantMap toMap() const;
@@ -86,6 +103,9 @@ private:
bool m_collectSystime; bool m_collectSystime;
bool m_collectBusEvents; bool m_collectBusEvents;
bool m_enableBranchSim; bool m_enableBranchSim;
bool m_enableEventToolTips;
double m_minimumInclusiveCostRatio;
double m_visualisationMinimumInclusiveCostRatio;
}; };
/** /**
@@ -104,12 +124,10 @@ public:
CostDelegate::CostFormat costFormat() const; CostDelegate::CostFormat costFormat() const;
bool detectCycles() const; bool detectCycles() const;
double minimumInclusiveCostRatio() const;
public slots: public slots:
void setCostFormat(Callgrind::Internal::CostDelegate::CostFormat format); void setCostFormat(Callgrind::Internal::CostDelegate::CostFormat format);
void setDetectCycles(bool detect); void setDetectCycles(bool detect);
void setMinimumInclusiveCostRatio(double minimumInclusiveCost);
protected: protected:
virtual QVariantMap toMap() const; virtual QVariantMap toMap() const;
@@ -117,7 +135,6 @@ protected:
private: private:
CostDelegate::CostFormat m_costFormat; CostDelegate::CostFormat m_costFormat;
bool m_detectCycles; bool m_detectCycles;
double m_minimumInclusiveCostRatio;
}; };
/** /**

18
src/plugins/callgrind/callgrindtool.cpp
View File

@@ -208,7 +208,7 @@ void CallgrindTool::extensionsInitialized()
analyzerContext); analyzerContext);
editorContextMenu->addAction(cmd); editorContextMenu->addAction(cmd);
action = new QAction(tr("Profile costs of this function and its callees"), this); action = new QAction(tr("Profile Costs of this Function and its Callees"), this);
action->setIcon(QIcon(Analyzer::Constants::ANALYZER_CONTROL_START_ICON)); action->setIcon(QIcon(Analyzer::Constants::ANALYZER_CONTROL_START_ICON));
connect(action, SIGNAL(triggered()), SLOT(handleShowCostsOfFunction())); connect(action, SIGNAL(triggered()), SLOT(handleShowCostsOfFunction()));
cmd = actionManager->registerAction(action, Callgrind::Constants::A_SHOWCOSTSOFFUNCTION, cmd = actionManager->registerAction(action, Callgrind::Constants::A_SHOWCOSTSOFFUNCTION,
@@ -245,6 +245,15 @@ IAnalyzerEngine *CallgrindTool::createEngine(const AnalyzerStartParameters &sp,
AnalyzerManager::instance()->showStatusMessage(AnalyzerManager::msgToolStarted(displayName())); AnalyzerManager::instance()->showStatusMessage(AnalyzerManager::msgToolStarted(displayName()));
// apply project settings
AnalyzerProjectSettings *analyzerSettings = runConfiguration->extraAspect<AnalyzerProjectSettings>();
CallgrindProjectSettings *settings = analyzerSettings->subConfig<CallgrindProjectSettings>();
QTC_ASSERT(settings, return engine)
m_callgrindWidgetHandler->visualisation()->setMinimumInclusiveCostRatio(settings->visualisationMinimumInclusiveCostRatio() / 100.0);
m_callgrindWidgetHandler->proxyModel()->setMinimumInclusiveCostRatio(settings->minimumInclusiveCostRatio() / 100.0);
m_callgrindWidgetHandler->dataModel()->setVerboseToolTipsEnabled(settings->enableEventToolTips());
return engine; return engine;
} }
@@ -313,9 +322,6 @@ QWidget *CallgrindTool::createPaneToolBarWidget()
connect(m_callgrindWidgetHandler, SIGNAL(cycleDetectionEnabled(bool)), connect(m_callgrindWidgetHandler, SIGNAL(cycleDetectionEnabled(bool)),
settings, SLOT(setDetectCycles(bool))); settings, SLOT(setDetectCycles(bool)));
// performance: add a minimum cost index so that we are not flooded by the results
m_callgrindWidgetHandler->proxyModel()->setMinimumInclusiveCostRatio(settings->minimumInclusiveCostRatio());
return toolbarWidget; return toolbarWidget;
} }
@@ -397,7 +403,7 @@ void CallgrindTool::requestContextMenu(TextEditor::ITextEditor *editor, int line
return; // no callgrind text mark under cursor, return return; // no callgrind text mark under cursor, return
// add our action to the context menu // add our action to the context menu
QAction *action = new QAction(tr("Select this function in the analyzer output"), menu); QAction *action = new QAction(tr("Select this Function in the Analyzer Output"), menu);
connect(action, SIGNAL(triggered()), this, SLOT(handleShowCostsAction())); connect(action, SIGNAL(triggered()), this, SLOT(handleShowCostsAction()));
action->setData(QVariant::fromValue<const Function *>(func)); action->setData(QVariant::fromValue<const Function *>(func));
menu->addAction(action); menu->addAction(action);
@@ -435,7 +441,7 @@ void CallgrindTool::handleShowCostsOfFunction()
void CallgrindTool::slotRequestDump() void CallgrindTool::slotRequestDump()
{ {
m_callgrindWidgetHandler->visualisation()->setText(tr("Populating...")); m_callgrindWidgetHandler->slotRequestDump();
emit dumpRequested(); emit dumpRequested();
} }

62
src/plugins/callgrind/callgrindvisualisation.cpp
View File

@@ -73,13 +73,9 @@ public:
const QStyleOptionGraphicsItem *option, QWidget *widget); const QStyleOptionGraphicsItem *option, QWidget *widget);
virtual QRectF boundingRect() const; virtual QRectF boundingRect() const;
void setRotateText(bool rotate);
private: private:
QString m_text; QString m_text;
QStaticText m_staticText; QStaticText m_staticText;
bool m_rotateText;
QColor m_textColor;
qreal m_previousViewportDimension; qreal m_previousViewportDimension;
}; };
@@ -105,7 +101,6 @@ FunctionGraphicsTextItem::FunctionGraphicsTextItem(const QString &text,
QGraphicsItem *parent) QGraphicsItem *parent)
: QAbstractGraphicsShapeItem(parent) : QAbstractGraphicsShapeItem(parent)
, m_text(text) , m_text(text)
, m_rotateText(true)
, m_previousViewportDimension(0) , m_previousViewportDimension(0)
{ {
setFlag(QGraphicsItem::ItemIgnoresTransformations); setFlag(QGraphicsItem::ItemIgnoresTransformations);
@@ -113,11 +108,6 @@ FunctionGraphicsTextItem::FunctionGraphicsTextItem(const QString &text,
setToolTip(text); setToolTip(text);
} }
void FunctionGraphicsTextItem::setRotateText(bool rotate)
{
m_rotateText = rotate;
}
void FunctionGraphicsTextItem::paint(QPainter *painter, void FunctionGraphicsTextItem::paint(QPainter *painter,
const QStyleOptionGraphicsItem *, const QStyleOptionGraphicsItem *,
QWidget *widget) QWidget *widget)
@@ -135,30 +125,17 @@ void FunctionGraphicsTextItem::paint(QPainter *painter,
* parentItem()->boundingRect().height() * parentItem()->boundingRect().height()
/ scene()->sceneRect().height(); / scene()->sceneRect().height();
qreal textMaxHeight; if (textHeight > maxHeight)
qreal textMaxWidth;
qreal viewportDim;
if (m_rotateText) {
viewportDim = viewportRect.height();
textMaxHeight = maxWidth;
textMaxWidth = maxHeight;
} else {
viewportDim = viewportRect.width();
textMaxHeight = maxHeight;
textMaxWidth = maxWidth;
}
if (textHeight > textMaxHeight)
return; return;
if (viewportDim != m_previousViewportDimension) { if (viewportRect.width() != m_previousViewportDimension) {
const QString &elidedText = const QString &elidedText =
painter->fontMetrics().elidedText(m_text, Qt::ElideRight, painter->fontMetrics().elidedText(m_text, Qt::ElideRight,
textMaxWidth); maxWidth);
m_staticText.setText(elidedText); m_staticText.setText(elidedText);
m_staticText.prepare(); m_staticText.prepare();
m_previousViewportDimension = viewportDim; m_previousViewportDimension = viewportRect.width();
} }
#if VISUALISATION_DEBUG #if VISUALISATION_DEBUG
@@ -169,16 +146,9 @@ void FunctionGraphicsTextItem::paint(QPainter *painter,
painter->save(); painter->save();
int textLeft = 0; int textLeft = 0;
int textTop = 0; int textTop = 0;
if (m_rotateText) {
painter->rotate(90);
textLeft = 2;
textTop = -textHeight/2;
}
else {
const int textWidth = painter->fontMetrics().width(m_staticText.text()); const int textWidth = painter->fontMetrics().width(m_staticText.text());
textLeft = -textWidth/2; textLeft = -textWidth/2;
textTop = (maxHeight - textHeight)/2; textTop = (maxHeight - textHeight)/2;
}
painter->drawStaticText(textLeft, textTop, m_staticText); painter->drawStaticText(textLeft, textTop, m_staticText);
painter->restore(); painter->restore();
@@ -218,9 +188,10 @@ void FunctionGraphicsItem::paint(QPainter *painter,
QRectF rect = this->rect(); QRectF rect = this->rect();
const QColor &color = brush().color(); const QColor &color = brush().color();
if (option->state & QStyle::State_Selected) { if (option->state & QStyle::State_Selected) {
QLinearGradient gradient(0, 0, rect.width(), rect.height()); QLinearGradient gradient(0, 0, rect.width(), 0);
gradient.setColorAt(0, color.lighter(250)); gradient.setColorAt(0, color.darker(100));
gradient.setColorAt(1, color.darker()); gradient.setColorAt(0.5, color.lighter(200));
gradient.setColorAt(1, color.darker(100));
painter->setBrush(gradient); painter->setBrush(gradient);
} }
else { else {
@@ -256,13 +227,11 @@ public:
Visualisation *q; Visualisation *q;
DataProxyModel *m_model; DataProxyModel *m_model;
QGraphicsScene m_scene; QGraphicsScene m_scene;
int m_modelColumn;
}; };
Visualisation::Private::Private(Visualisation *qq) Visualisation::Private::Private(Visualisation *qq)
: q(qq) : q(qq)
, m_model(new DataProxyModel(qq)) , m_model(new DataProxyModel(qq))
, m_modelColumn(-1)
{ {
// setup scene // setup scene
m_scene.setObjectName("Visualisation Scene"); m_scene.setObjectName("Visualisation Scene");
@@ -359,6 +328,11 @@ const Function *Visualisation::function() const
return d->m_model->filterFunction(); return d->m_model->filterFunction();
} }
void Visualisation::setMinimumInclusiveCostRatio(double ratio)
{
d->m_model->setMinimumInclusiveCostRatio(ratio);
}
void Visualisation::setModel(DataModel *model) void Visualisation::setModel(DataModel *model)
{ {
QTC_ASSERT(!d->m_model->sourceModel() && model, return); // only set once! QTC_ASSERT(!d->m_model->sourceModel() && model, return); // only set once!
@@ -450,28 +424,26 @@ void Visualisation::populateScene()
const QColor background = CallgrindHelper::colorForString(text); const QColor background = CallgrindHelper::colorForString(text);
item->setBrush(background); item->setBrush(background);
item->setData(FunctionGraphicsItem::FunctionCallKey, QVariant::fromValue(d->m_model->filterFunction())); item->setData(FunctionGraphicsItem::FunctionCallKey, QVariant::fromValue(d->m_model->filterFunction()));
item->textItem()->setRotateText(false);
// NOTE: workaround wrong tooltip being show, no idea why... // NOTE: workaround wrong tooltip being show, no idea why...
item->setZValue(-1); item->setZValue(-1);
d->m_scene.addItem(item); d->m_scene.addItem(item);
} }
// add the canvas elements to the scene // add the canvas elements to the scene
qreal used = 0; qreal used = sceneHeight * 0.1;
foreach (const Pair &cost, costs) foreach (const Pair &cost, costs)
{ {
const QModelIndex &index = cost.first; const QModelIndex &index = cost.first;
const QString text = index.data().toString(); const QString text = index.data().toString();
const qreal width = (sceneWidth * cost.second) / total; const qreal height = (sceneHeight * 0.9 * cost.second) / total;
const qreal height = sceneHeight * 0.9;
FunctionGraphicsItem *item = new FunctionGraphicsItem(text, used, sceneHeight - height, width, height); FunctionGraphicsItem *item = new FunctionGraphicsItem(text, 0, used, sceneWidth, height);
const QColor background = CallgrindHelper::colorForString(text); const QColor background = CallgrindHelper::colorForString(text);
item->setBrush(background); item->setBrush(background);
item->setData(FunctionGraphicsItem::FunctionCallKey, index.data(DataModel::FunctionRole)); item->setData(FunctionGraphicsItem::FunctionCallKey, index.data(DataModel::FunctionRole));
d->m_scene.addItem(item); d->m_scene.addItem(item);
used += width; used += height;
} }
} }

2
src/plugins/callgrind/callgrindvisualisation.h
View File

@@ -66,6 +66,8 @@ public:
void setFunction(const Valgrind::Callgrind::Function *function); void setFunction(const Valgrind::Callgrind::Function *function);
const Valgrind::Callgrind::Function *function() const; const Valgrind::Callgrind::Function *function() const;
void setMinimumInclusiveCostRatio(double ratio);
public slots: public slots:
void setText(const QString &message); void setText(const QString &message);

25
src/plugins/callgrind/callgrindwidgethandler.cpp
View File

@@ -36,10 +36,6 @@
#include "callgrindengine.h" #include "callgrindengine.h"
#include "callgrindvisualisation.h" #include "callgrindvisualisation.h"
#ifndef DISABLE_CALLGRIND_WORKAROUNDS
#include "workarounds.h"
#endif
#include <analyzerbase/analyzerconstants.h> #include <analyzerbase/analyzerconstants.h>
#include <coreplugin/coreconstants.h> #include <coreplugin/coreconstants.h>
#include <coreplugin/icore.h> #include <coreplugin/icore.h>
@@ -129,6 +125,7 @@ void CallgrindWidgetHandler::ensureDockWidgets()
return; return;
QWidget *parenWidget = qobject_cast<QWidget *>(parent()); QWidget *parenWidget = qobject_cast<QWidget *>(parent());
m_visualisation = new Visualisation(parenWidget); m_visualisation = new Visualisation(parenWidget);
m_visualisation->setFrameStyle(QFrame::NoFrame);
m_visualisation->setObjectName("Valgrind.CallgrindWidgetHandler.Visualisation"); m_visualisation->setObjectName("Valgrind.CallgrindWidgetHandler.Visualisation");
m_visualisation->setModel(m_dataModel); m_visualisation->setModel(m_dataModel);
connect(m_visualisation, SIGNAL(functionActivated(const Valgrind::Callgrind::Function*)), connect(m_visualisation, SIGNAL(functionActivated(const Valgrind::Callgrind::Function*)),
@@ -137,6 +134,7 @@ void CallgrindWidgetHandler::ensureDockWidgets()
m_callersView = new CostView(parenWidget); m_callersView = new CostView(parenWidget);
m_callersView->sortByColumn(CallModel::CostColumn); m_callersView->sortByColumn(CallModel::CostColumn);
m_callersView->setObjectName("Valgrind.CallgrindWidgetHandler.CallersView"); m_callersView->setObjectName("Valgrind.CallgrindWidgetHandler.CallersView");
m_callersView->setFrameStyle(QFrame::NoFrame);
// enable sorting // enable sorting
QSortFilterProxyModel *callerProxy = new QSortFilterProxyModel(m_callersModel); QSortFilterProxyModel *callerProxy = new QSortFilterProxyModel(m_callersModel);
callerProxy->setSourceModel(m_callersModel); callerProxy->setSourceModel(m_callersModel);
@@ -148,6 +146,7 @@ void CallgrindWidgetHandler::ensureDockWidgets()
m_calleesView = new CostView(parenWidget); m_calleesView = new CostView(parenWidget);
m_calleesView->sortByColumn(CallModel::CostColumn); m_calleesView->sortByColumn(CallModel::CostColumn);
m_calleesView->setObjectName("Valgrind.CallgrindWidgetHandler.CalleesView"); m_calleesView->setObjectName("Valgrind.CallgrindWidgetHandler.CalleesView");
m_calleesView->setFrameStyle(QFrame::NoFrame);
// enable sorting // enable sorting
QSortFilterProxyModel *calleeProxy = new QSortFilterProxyModel(m_calleesModel); QSortFilterProxyModel *calleeProxy = new QSortFilterProxyModel(m_calleesModel);
calleeProxy->setSourceModel(m_calleesModel); calleeProxy->setSourceModel(m_calleesModel);
@@ -247,7 +246,7 @@ void CallgrindWidgetHandler::populateActions(QLayout *layout)
menu->addAction(m_costRelative); menu->addAction(m_costRelative);
// show costs relative to parent // show costs relative to parent
m_costRelativeToParent = new QAction(tr("Relative Costs To Parent"), this); m_costRelativeToParent = new QAction(tr("Relative Costs to Parent"), this);
///FIXME: icon ///FIXME: icon
m_costRelativeToParent->setToolTip(tr("Show costs relative to parent functions inclusive cost.")); m_costRelativeToParent->setToolTip(tr("Show costs relative to parent functions inclusive cost."));
m_costRelativeToParent->setCheckable(true); m_costRelativeToParent->setCheckable(true);
@@ -333,8 +332,19 @@ void CallgrindWidgetHandler::doClear(bool clearParseData)
void CallgrindWidgetHandler::slotRequestDump() void CallgrindWidgetHandler::slotRequestDump()
{ {
setBusy(true);
m_visualisation->setText(tr("Populating...")); m_visualisation->setText(tr("Populating..."));
emit dumpRequested(); }
void CallgrindWidgetHandler::setBusy(bool busy)
{
QCursor cursor(busy ? Qt::BusyCursor : Qt::ArrowCursor);
QList<QWidget *> widgets;
widgets << m_flatView << m_calleesView << m_callersView << m_visualisation;
foreach(QWidget *widget, widgets) {
widget->setCursor(cursor);
}
} }
void CallgrindWidgetHandler::selectFunction(const Function *func) void CallgrindWidgetHandler::selectFunction(const Function *func)
@@ -510,6 +520,9 @@ void CallgrindWidgetHandler::setParseData(ParseData *data)
// clear history for new data // clear history for new data
m_stackBrowser->clear(); m_stackBrowser->clear();
// unset busy state
setBusy(false);
} }
void CallgrindWidgetHandler::updateEventCombo() void CallgrindWidgetHandler::updateEventCombo()

8
src/plugins/callgrind/callgrindwidgethandler.h
View File

@@ -94,10 +94,6 @@ public:
Callgrind::Internal::CostDelegate::CostFormat costFormat() const; Callgrind::Internal::CostDelegate::CostFormat costFormat() const;
signals: signals:
void dumpRequested();
void resetRequested();
void pauseToggled(bool checked);
void functionSelected(const Valgrind::Callgrind::Function *); void functionSelected(const Valgrind::Callgrind::Function *);
void costFormatChanged(Callgrind::Internal::CostDelegate::CostFormat format); void costFormatChanged(Callgrind::Internal::CostDelegate::CostFormat format);
@@ -121,6 +117,9 @@ private slots:
void slotGoToOverview(); void slotGoToOverview();
void stackBrowserChanged(); void stackBrowserChanged();
/// If \param busy is true, all widgets get a busy cursor when hovered
void setBusy(bool busy);
void dataFunctionSelected(const QModelIndex &index); void dataFunctionSelected(const QModelIndex &index);
void calleeFunctionSelected(const QModelIndex &index); void calleeFunctionSelected(const QModelIndex &index);
void callerFunctionSelected(const QModelIndex &index); void callerFunctionSelected(const QModelIndex &index);
@@ -138,6 +137,7 @@ private:
Valgrind::Callgrind::CallModel *m_callersModel; Valgrind::Callgrind::CallModel *m_callersModel;
Valgrind::Callgrind::CallModel *m_calleesModel; Valgrind::Callgrind::CallModel *m_calleesModel;
// callgrind widgets
CostView *m_flatView; CostView *m_flatView;
CostView *m_callersView; CostView *m_callersView;
CostView *m_calleesView; CostView *m_calleesView;

21
src/plugins/valgrindtoolbase/valgrindengine.cpp
View File

@@ -41,6 +41,10 @@
#include <coreplugin/progressmanager/futureprogress.h> #include <coreplugin/progressmanager/futureprogress.h>
#include <extensionsystem/pluginmanager.h> #include <extensionsystem/pluginmanager.h>
#include <projectexplorer/applicationrunconfiguration.h> #include <projectexplorer/applicationrunconfiguration.h>
#include <analyzerbase/analyzermanager.h>
#include <QtGui/QApplication>
#include <QtGui/QMainWindow>
#define VALGRIND_DEBUG_OUTPUT 0 #define VALGRIND_DEBUG_OUTPUT 0
@@ -53,6 +57,7 @@ ValgrindEngine::ValgrindEngine(const AnalyzerStartParameters &sp,
: IAnalyzerEngine(sp, runConfiguration), : IAnalyzerEngine(sp, runConfiguration),
m_settings(0), m_settings(0),
m_progress(new QFutureInterface<void>()), m_progress(new QFutureInterface<void>()),
m_progressWatcher(new QFutureWatcher<void>()),
m_isStopping(false) m_isStopping(false)
{ {
if (runConfiguration) if (runConfiguration)
@@ -60,6 +65,11 @@ ValgrindEngine::ValgrindEngine(const AnalyzerStartParameters &sp,
if (!m_settings) if (!m_settings)
m_settings = AnalyzerGlobalSettings::instance(); m_settings = AnalyzerGlobalSettings::instance();
connect(m_progressWatcher, SIGNAL(canceled()),
this, SLOT(handleProgressCanceled()));
connect(m_progressWatcher, SIGNAL(finished()),
this, SLOT(handleProgressFinished()));
} }
ValgrindEngine::~ValgrindEngine() ValgrindEngine::~ValgrindEngine()
@@ -75,6 +85,7 @@ void ValgrindEngine::start()
progressTitle(), "valgrind"); progressTitle(), "valgrind");
fp->setKeepOnFinish(Core::FutureProgress::DontKeepOnFinish); fp->setKeepOnFinish(Core::FutureProgress::DontKeepOnFinish);
m_progress->reportStarted(); m_progress->reportStarted();
m_progressWatcher->setFuture(m_progress->future());
#if VALGRIND_DEBUG_OUTPUT #if VALGRIND_DEBUG_OUTPUT
emit standardOutputReceived(tr("Valgrind options: %1").arg(toolArguments().join(" "))); emit standardOutputReceived(tr("Valgrind options: %1").arg(toolArguments().join(" ")));
@@ -119,6 +130,16 @@ QString ValgrindEngine::executable() const
return startParameters().debuggee; return startParameters().debuggee;
} }
void ValgrindEngine::handleProgressCanceled()
{
AnalyzerManager::instance()->stopTool();
}
void ValgrindEngine::handleProgressFinished()
{
QApplication::alert(Core::ICore::instance()->mainWindow(), 3000);
}
void ValgrindEngine::runnerFinished() void ValgrindEngine::runnerFinished()
{ {
emit standardOutputReceived(tr("** Analyzing finished **")); emit standardOutputReceived(tr("** Analyzing finished **"));

4
src/plugins/valgrindtoolbase/valgrindengine.h
View File

@@ -48,6 +48,7 @@
#include <QtCore/QString> #include <QtCore/QString>
#include <QtCore/QByteArray> #include <QtCore/QByteArray>
#include <QtCore/QFutureInterface> #include <QtCore/QFutureInterface>
#include <QtCore/QFutureWatcher>
namespace Analyzer { namespace Analyzer {
class AnalyzerSettings; class AnalyzerSettings;
@@ -76,8 +77,11 @@ protected:
Analyzer::AnalyzerSettings *m_settings; Analyzer::AnalyzerSettings *m_settings;
QFutureInterface<void> *m_progress; QFutureInterface<void> *m_progress;
QFutureWatcher<void> *m_progressWatcher;
private slots: private slots:
void handleProgressCanceled();
void handleProgressFinished();
void runnerFinished(); void runnerFinished();
void receiveStandardOutput(const QByteArray &); void receiveStandardOutput(const QByteArray &);