Katana_mirror/katie
1
0
Fork 0
mirror of https://bitbucket.org/smil3y/katie.git synced 2025-02-24 02:42:55 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

get rid of QThreadStorage

Browse source 
Signed-off-by: Ivailo Monev <xakepa10@laimg.moc>
This commit is contained in:
Ivailo Monev 2019-05-14 23:09:55 +00:00
parent 0ceffd10b5
commit e49dfa18ba
12 changed files with 3 additions and 640 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
scripts/namefsck.py
View file

@ -762,8 +762,6 @@ classlist = {
"QtGui",
"QThread",
"QThreadPool",
"QThreadStorage",
"QThreadStorageData",
"QTileRules",
"QTime",
"QTimeEdit",

2
src/core/CMakeLists.txt
View file

@ -4,7 +4,6 @@ set(EXTRA_CORE_LIBS ${ZLIB_LIBRARIES} ${OPENSSL_LIBRARIES})
set(CORE_PUBLIC_HEADERS
${CORE_PUBLIC_HEADERS}
QVarLengthArray
QThreadStorageData
QList
QMutableStringListIterator
QSystemSemaphore
@ -20,7 +19,6 @@ set(CORE_PUBLIC_HEADERS
QLinkedListIterator
QDynamicPropertyChangeEvent
QHash
QThreadStorage
QTextStreamManipulator
QMutableMapIterator
QLinkedListNode

6
src/core/kernel/qcoreapplication.cpp
View file

@ -56,7 +56,6 @@
#include <qtextcodec.h>
#include <qthread.h>
#include <qthreadpool.h>
#include <qthreadstorage.h>
#include <qthread_p.h>
#include <qelapsedtimer.h>
#include <qlibraryinfo.h>
@ -270,11 +269,6 @@ QCoreApplicationPrivate::QCoreApplicationPrivate(int &aargc, char **aargv)
QCoreApplicationPrivate::~QCoreApplicationPrivate()
{
if (threadData) {
#ifndef QT_NO_THREAD
void *data = &threadData->tls;
QThreadStorageData::finish((void **)data);
#endif
// need to clear the state of the mainData, just in case a new QCoreApplication comes along.
QMutexLocker locker(&threadData->postEventList.mutex);
for (int i = 0; i < threadData->postEventList.size(); ++i) {

5
src/core/thread/qthread.cpp
View file

@ -40,7 +40,6 @@
****************************************************************************/
#include "qthread.h"
#include "qthreadstorage.h"
#include "qmutex.h"
#include "qmutexpool_p.h"
#include "qreadwritelock.h"
@ -255,8 +254,8 @@ QThreadPrivate::~QThreadPrivate()
wait(), consider listening for the finished() signal. Instead of
the sleep() functions, consider using QTimer.
\sa {Thread Support in Qt}, QThreadStorage, {Synchronizing Threads}
{Mandelbrot Example}, {Semaphores Example}, {Wait Conditions Example}
\sa {Thread Support in Qt}, {Synchronizing Threads}, {Mandelbrot Example},
{Semaphores Example}, {Wait Conditions Example}
*/
/*!

1
src/core/thread/qthread_p.h
View file

@ -242,7 +242,6 @@ public:
Qt::HANDLE threadId;
QStack<QEventLoop *> eventLoops;
QVector<void *> tls;
QThread *thread;
QAbstractEventDispatcher *eventDispatcher;
QPostEventList postEventList;

3
src/core/thread/qthread_unix.cpp
View file

@ -43,7 +43,6 @@
#include "qplatformdefs.h"
#include <qcoreapplication_p.h>
#include "qthreadstorage.h"
#include "qthread_p.h"
#include "qdebug.h"
@ -289,13 +288,11 @@ void QThreadPrivate::finish(void *arg)
d->isInFinish = true;
d->priority = QThread::InheritPriority;
bool terminated = d->terminated;
void *data = &d->data->tls;
locker.unlock();
if (terminated)
emit thr->terminated();
emit thr->finished();
QCoreApplication::sendPostedEvents(Q_NULLPTR, QEvent::DeferredDelete);
QThreadStorageData::finish((void **)data);
locker.relock();
d->terminated = false;

335
src/core/thread/qthreadstorage.cpp
View file

@ -1,335 +0,0 @@
/****************************************************************************
**
** Copyright (C) 2015 The Qt Company Ltd.
** Contact: http://www.qt.io/licensing/
**
** This file is part of the QtCore module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see http://www.qt.io/terms-conditions. For further
** information use the contact form at http://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 or version 3 as published by the Free
** Software Foundation and appearing in the file LICENSE.LGPLv21 and
** LICENSE.LGPLv3 included in the packaging of this file. Please review the
** following information to ensure the GNU Lesser General Public License
** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** As a special exception, The Qt Company gives you certain additional
** rights. These rights are described in The Qt Company LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "qthreadstorage.h"
#ifndef QT_NO_THREAD
#include "qthread.h"
#include "qthread_p.h"
#include "qmutex.h"
#include <string.h>
QT_BEGIN_NAMESPACE
// #define THREADSTORAGE_DEBUG
#ifdef THREADSTORAGE_DEBUG
# include <stdio.h>
# include <stdarg.h>
void qtsDebug(const char *fmt, ...)
{
va_list va;
va_start(va, fmt);
fprintf(stderr, "QThreadStorage: ");
vfprintf(stderr, fmt, va);
fprintf(stderr, "\n");
va_end(va);
}
#endif
Q_GLOBAL_STATIC(QMutex, threadStorageMutex)
typedef QVector<void (*)(void *)> DestructorMap;
Q_GLOBAL_STATIC(DestructorMap, destructors)
QThreadStorageData::QThreadStorageData(void (*func)(void *))
{
QMutexLocker locker(threadStorageMutex());
DestructorMap *destr = destructors();
if (!destr) {
/*
the destructors vector has already been destroyed, yet a new
QThreadStorage is being allocated. this can only happen during global
destruction, at which point we assume that there is only one thread.
in order to keep QThreadStorage working, we need somewhere to store
the data, best place we have in this situation is at the tail of the
current thread's tls vector. the destructor is ignored, since we have
no where to store it, and no way to actually call it.
*/
QThreadData *data = QThreadData::current();
id = data->tls.count();
#ifdef THREADSTORAGE_DEBUG
qtsDebug("QThreadStorageData: Allocated id %d, destructor %p cannot be stored", id, func);
#endif
return;
}
for (id = 0; id < destr->count(); id++) {
if (destr->at(id) == 0)
break;
}
if (id == destr->count()) {
destr->append(func);
} else {
(*destr)[id] = func;
}
#ifdef THREADSTORAGE_DEBUG
qtsDebug("QThreadStorageData: Allocated id %d, destructor %p", id, func);
#endif
}
QThreadStorageData::~QThreadStorageData()
{
#ifdef THREADSTORAGE_DEBUG
qtsDebug("QThreadStorageData: Released id %d", id);
#endif
QMutexLocker locker(threadStorageMutex());
if (destructors())
(*destructors())[id] = 0;
}
void **QThreadStorageData::get() const
{
QThreadData *data = QThreadData::current();
if (!data) {
qWarning("QThreadStorage::get: QThreadStorage can only be used with threads started with QThread");
return 0;
}
QVector<void *> &tls = data->tls;
if (tls.size() <= id)
tls.resize(id + 1);
void **v = &tls[id];
#ifdef THREADSTORAGE_DEBUG
qtsDebug("QThreadStorageData: Returning storage %d, data %p, for thread %p",
id, *v, data->thread);
#endif
return *v ? v : 0;
}
void **QThreadStorageData::set(void *p)
{
QThreadData *data = QThreadData::current();
if (!data) {
qWarning("QThreadStorage::set: QThreadStorage can only be used with threads started with QThread");
return 0;
}
QVector<void *> &tls = data->tls;
if (tls.size() <= id)
tls.resize(id + 1);
void *&value = tls[id];
// delete any previous data
if (value != 0) {
#ifdef THREADSTORAGE_DEBUG
qtsDebug("QThreadStorageData: Deleting previous storage %d, data %p, for thread %p",
id, value, data->thread);
#endif
QMutexLocker locker(threadStorageMutex());
DestructorMap *destr = destructors();
void (*destructor)(void *) = destr ? destr->value(id) : 0;
locker.unlock();
void *q = value;
value = 0;
if (destructor)
destructor(q);
}
// store new data
value = p;
#ifdef THREADSTORAGE_DEBUG
qtsDebug("QThreadStorageData: Set storage %d for thread %p to %p", id, data->thread, p);
#endif
return &value;
}
void QThreadStorageData::finish(void **p)
{
QVector<void *> *tls = reinterpret_cast<QVector<void *> *>(p);
if (!tls || tls->isEmpty() || !threadStorageMutex())
return; // nothing to do
#ifdef THREADSTORAGE_DEBUG
qtsDebug("QThreadStorageData: Destroying storage for thread %p", QThread::currentThread());
#endif
while (!tls->isEmpty()) {
void *&value = tls->last();
void *q = value;
value = 0;
int i = tls->size() - 1;
tls->resize(i);
if (!q) {
// data already deleted
continue;
}
QMutexLocker locker(threadStorageMutex());
void (*destructor)(void *) = destructors()->value(i);
locker.unlock();
if (!destructor) {
if (QThread::currentThread())
qWarning("QThreadStorage: Thread %p exited after QThreadStorage %d destroyed",
QThread::currentThread(), i);
continue;
}
destructor(q); //crash here might mean the thread exited after qthreadstorage was destroyed
if (tls->size() > i) {
//re reset the tls in case it has been recreated by its own destructor.
(*tls)[i] = 0;
}
}
tls->clear();
}
/*!
\class QThreadStorage
\brief The QThreadStorage class provides per-thread data storage.
\threadsafe
\ingroup thread
QThreadStorage is a template class that provides per-thread data
storage.
The setLocalData() function stores a single thread-specific value
for the calling thread. The data can be accessed later using
localData().
The hasLocalData() function allows the programmer to determine if
data has previously been set using the setLocalData() function.
This is also useful for lazy initializiation.
If T is a pointer type, QThreadStorage takes ownership of the data
(which must be created on the heap with \c new) and deletes it when
the thread exits, either normally or via termination.
For example, the following code uses QThreadStorage to store a
single cache for each thread that calls the cacheObject() and
removeFromCache() functions. The cache is automatically
deleted when the calling thread exits.
\snippet doc/src/snippets/threads/threads.cpp 7
\snippet doc/src/snippets/threads/threads.cpp 8
\snippet doc/src/snippets/threads/threads.cpp 9
\section1 Caveats
\list
\o The QThreadStorage destructor does not delete per-thread data.
QThreadStorage only deletes per-thread data when the thread exits
or when setLocalData() is called multiple times.
\o QThreadStorage can be used to store data for the \c main()
thread. QThreadStorage deletes all data set for the \c main()
thread when QApplication is destroyed, regardless of whether or
not the \c main() thread has actually finished.
\endlist
\sa QThread
*/
/*!
\fn QThreadStorage::QThreadStorage()
Constructs a new per-thread data storage object.
*/
/*!
\fn QThreadStorage::~QThreadStorage()
Destroys the per-thread data storage object.
Note: The per-thread data stored is not deleted. Any data left
in QThreadStorage is leaked. Make sure that all threads using
QThreadStorage have exited before deleting the QThreadStorage.
\sa hasLocalData()
*/
/*!
\fn bool QThreadStorage::hasLocalData() const
If T is a pointer type, returns true if the calling thread has
non-zero data available.
If T is a value type, returns whether the data has already been
constructed by calling setLocalData or localData.
\sa localData()
*/
/*!
\fn T &QThreadStorage::localData()
Returns a reference to the data that was set by the calling
thread.
If no data has been set, this will create a default constructed
instance of type T.
\sa hasLocalData()
*/
/*!
\fn const T QThreadStorage::localData() const
\overload
Returns a copy of the data that was set by the calling thread.
\sa hasLocalData()
*/
/*!
\fn void QThreadStorage::setLocalData(T data)
Sets the local data for the calling thread to \a data. It can be
accessed later using the localData() functions.
If T is a pointer type, QThreadStorage takes ownership of the data
and deletes it automatically either when the thread exits (either
normally or via termination) or when setLocalData() is called again.
\sa localData(), hasLocalData()
*/
#endif // QT_NO_THREAD
QT_END_NAMESPACE

156
src/core/thread/qthreadstorage.h
View file

@ -1,156 +0,0 @@
/****************************************************************************
**
** Copyright (C) 2015 The Qt Company Ltd.
** Contact: http://www.qt.io/licensing/
**
** This file is part of the QtCore module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see http://www.qt.io/terms-conditions. For further
** information use the contact form at http://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 or version 3 as published by the Free
** Software Foundation and appearing in the file LICENSE.LGPLv21 and
** LICENSE.LGPLv3 included in the packaging of this file. Please review the
** following information to ensure the GNU Lesser General Public License
** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** As a special exception, The Qt Company gives you certain additional
** rights. These rights are described in The Qt Company LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef QTHREADSTORAGE_H
#define QTHREADSTORAGE_H
#include <QtCore/qglobal.h>
#ifndef QT_NO_THREAD
QT_BEGIN_HEADER
QT_BEGIN_NAMESPACE
class Q_CORE_EXPORT QThreadStorageData
{
public:
explicit QThreadStorageData(void (*func)(void *));
~QThreadStorageData();
void** get() const;
void** set(void* p);
static void finish(void**);
int id;
};
// pointer specialization
template <typename T>
inline
T *&qThreadStorage_localData(QThreadStorageData &d, T **)
{
void **v = d.get();
if (!v) v = d.set(Q_NULLPTR);
return *(reinterpret_cast<T**>(v));
}
template <typename T>
inline
T *qThreadStorage_localData_const(const QThreadStorageData &d, T **)
{
void **v = d.get();
return v ? *(reinterpret_cast<T**>(v)) : 0;
}
template <typename T>
inline
void qThreadStorage_setLocalData(QThreadStorageData &d, T **t)
{ (void) d.set(*t); }
template <typename T>
inline
void qThreadStorage_deleteData(void *d, T **)
{ delete static_cast<T *>(d); }
// value-based specialization
template <typename T>
inline
T &qThreadStorage_localData(QThreadStorageData &d, T *)
{
void **v = d.get();
if (!v) v = d.set(new T());
return *(reinterpret_cast<T*>(*v));
}
template <typename T>
inline
T qThreadStorage_localData_const(const QThreadStorageData &d, T *)
{
void **v = d.get();
return v ? *(reinterpret_cast<T*>(*v)) : T();
}
template <typename T>
inline
void qThreadStorage_setLocalData(QThreadStorageData &d, T *t)
{ (void) d.set(new T(*t)); }
template <typename T>
inline
void qThreadStorage_deleteData(void *d, T *)
{ delete static_cast<T *>(d); }
template <class T>
class QThreadStorage
{
private:
QThreadStorageData d;
Q_DISABLE_COPY(QThreadStorage)
static inline void deleteData(void *x)
{ qThreadStorage_deleteData(x, reinterpret_cast<T*>(0)); }
public:
inline QThreadStorage() : d(deleteData) { }
inline ~QThreadStorage() { }
inline bool hasLocalData() const
{ return d.get() != 0; }
inline T& localData()
{ return qThreadStorage_localData(d, reinterpret_cast<T*>(0)); }
inline T localData() const
{ return qThreadStorage_localData_const(d, reinterpret_cast<T*>(0)); }
inline void setLocalData(T t)
{ qThreadStorage_setLocalData(d, &t); }
};
QT_END_NAMESPACE
QT_END_HEADER
#endif // QT_NO_THREAD
#endif // QTHREADSTORAGE_H

2
src/core/thread/thread.cmake
View file

@ -4,7 +4,6 @@ set(CORE_HEADERS
${CMAKE_CURRENT_SOURCE_DIR}/thread/qreadwritelock.h
${CMAKE_CURRENT_SOURCE_DIR}/thread/qsemaphore.h
${CMAKE_CURRENT_SOURCE_DIR}/thread/qthread.h
${CMAKE_CURRENT_SOURCE_DIR}/thread/qthreadstorage.h
${CMAKE_CURRENT_SOURCE_DIR}/thread/qwaitcondition.h
${CMAKE_CURRENT_SOURCE_DIR}/thread/qatomic.h
@ -23,7 +22,6 @@ set(CORE_SOURCES
${CMAKE_CURRENT_SOURCE_DIR}/thread/qmutexpool.cpp
${CMAKE_CURRENT_SOURCE_DIR}/thread/qsemaphore.cpp
${CMAKE_CURRENT_SOURCE_DIR}/thread/qthread.cpp
${CMAKE_CURRENT_SOURCE_DIR}/thread/qthreadstorage.cpp
${CMAKE_CURRENT_SOURCE_DIR}/thread/qmutex_unix.cpp
${CMAKE_CURRENT_SOURCE_DIR}/thread/qthread_unix.cpp
${CMAKE_CURRENT_SOURCE_DIR}/thread/qwaitcondition_unix.cpp

3
src/shared/qclass_lib_map.h
View file

@ -69,7 +69,6 @@ static const ClassInfoEntry qclass_lib_map[] = {
{ "QWriteLocker", "QtCore/qreadwritelock.h"},
{ "QSemaphore", "QtCore/qsemaphore.h"},
{ "QThread", "QtCore/qthread.h"},
{ "QThreadStorageData", "QtCore/qthreadstorage.h"},
{ "QWaitCondition", "QtCore/qwaitcondition.h"},
{ "QFactoryInterface", "QtCore/qfactoryinterface.h"},
{ "QLibrary", "QtCore/qlibrary.h"},
@ -697,6 +696,6 @@ static const ClassInfoEntry qclass_lib_map[] = {
{ "QFormBuilder", "QtUiTools/formbuilder.h"},
{ "QUiLoader", "QtUiTools/quiloader.h"},
};
static const int qclass_lib_count = 691;
static const int qclass_lib_count = 690;
#endif

3
tests/benchmarks/core/thread/qthreadstorage/CMakeLists.txt
View file

@ -1,3 +0,0 @@
katie_test(tst_bench_qthreadstorage
${CMAKE_CURRENT_SOURCE_DIR}/tst_qthreadstorage.cpp
)

125
tests/benchmarks/core/thread/qthreadstorage/tst_qthreadstorage.cpp
View file

@ -1,125 +0,0 @@
/****************************************************************************
**
** Copyright (C) 2015 The Qt Company Ltd.
** Contact: http://www.qt.io/licensing/
**
** This file is part of the test suite of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see http://www.qt.io/terms-conditions. For further
** information use the contact form at http://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 or version 3 as published by the Free
** Software Foundation and appearing in the file LICENSE.LGPLv21 and
** LICENSE.LGPLv3 included in the packaging of this file. Please review the
** following information to ensure the GNU Lesser General Public License
** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** As a special exception, The Qt Company gives you certain additional
** rights. These rights are described in The Qt Company LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include <qtest.h>
#include <QtCore>
//TESTED_FILES=
QThreadStorage<int *> dummy[8];
QThreadStorage<QString *> tls1;
class tst_QThreadStorage : public QObject
{
Q_OBJECT
public:
tst_QThreadStorage();
virtual ~tst_QThreadStorage();
public slots:
void init();
void cleanup();
private slots:
void construct();
void get();
void set();
};
tst_QThreadStorage::tst_QThreadStorage()
{
}
tst_QThreadStorage::~tst_QThreadStorage()
{
}
void tst_QThreadStorage::init()
{
dummy[1].setLocalData(new int(5));
dummy[2].setLocalData(new int(4));
dummy[3].setLocalData(new int(3));
tls1.setLocalData(new QString());
}
void tst_QThreadStorage::cleanup()
{
}
void tst_QThreadStorage::construct()
{
QBENCHMARK {
QThreadStorage<int *> ts;
}
}
void tst_QThreadStorage::get()
{
QThreadStorage<int *> ts;
ts.setLocalData(new int(45));
int count = 0;
QBENCHMARK {
int *i = ts.localData();
count += *i;
}
ts.setLocalData(0);
}
void tst_QThreadStorage::set()
{
QThreadStorage<int *> ts;
int count = 0;
QBENCHMARK {
ts.setLocalData(new int(count));
count++;
}
ts.setLocalData(0);
}
QTEST_MAIN(tst_QThreadStorage)
#include "moc_tst_qthreadstorage.cpp"