![]() |
Home |
This example demonstrates how to use QtSharedMemory to access a block of shared memory between threads.
factory.h:
/**************************************************************************** ** ** Copyright (C) 2003-2007 Trolltech ASA. All rights reserved. ** ** This file is part of a Qt Solutions component. ** ** Licensees holding a valid Qt Solutions License Agreement may use this ** file in accordance with the rights, responsibilities, and obligations ** contained therein. Please consult your licensing agreement or contact ** [email protected] if any conditions of this licensing are not clear ** to you. ** ** Further information about Qt Solutions licensing is available at: ** http://www.trolltech.com/products/qt/addon/solutions/ ** or by contacting [email protected]. ** ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. ** ****************************************************************************/ #ifndef FACTORY_H #define FACTORY_H #include <QThread> #include <QList> #include <qtsharedmemory.h> class Worker : public QThread { public: inline Worker(int count) { cnt = count; } void run(); private: int cnt; }; class Factory { public: Factory(int workers); ~Factory(); void startCounting(); private: QList<Worker *> workers; QtSharedMemory sharedMemory; }; #endif
factory.cpp:
/**************************************************************************** ** ** Copyright (C) 2003-2007 Trolltech ASA. All rights reserved. ** ** This file is part of a Qt Solutions component. ** ** Licensees holding a valid Qt Solutions License Agreement may use this ** file in accordance with the rights, responsibilities, and obligations ** contained therein. Please consult your licensing agreement or contact ** [email protected] if any conditions of this licensing are not clear ** to you. ** ** Further information about Qt Solutions licensing is available at: ** http://www.trolltech.com/products/qt/addon/solutions/ ** or by contacting [email protected]. ** ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. ** ****************************************************************************/ #include "factory.h" #include <qtsharedmemory.h> #ifdef Q_OS_UNIX #include <unistd.h> #endif #ifdef Q_OS_WIN32 #include <qt_windows.h> #endif static void qt_sleep(int seconds) { #ifdef Q_OS_WIN32 Sleep(seconds * 1000); #else sleep(seconds); #endif } /* Constructs a factory with \a nworkers workers, each working in its own thread. Each worker gets a share of the job of counting to 1000000. Adjusting the number of threads may change the overall time spent to reach the number 1000000. All counting is synchronous across threads. */ Factory::Factory(int nworkers) : sharedMemory("Shared memory segment used for counting") { int cnt = 1000000; int share = cnt / nworkers; for (int i = 0; i < nworkers; ++i) { if (i == nworkers - 1) share = cnt; workers.append(new Worker(share)); cnt -= share; } } Factory::~Factory() { for (int i=0; i<workers.size(); ++i) delete workers[i]; } /* Creates the shared memory segment and starts the workers. Waits for all workers to detach from the segment, then destroys it. */ void Factory::startCounting() { // Create the segment if (sharedMemory.exists()) sharedMemory.destroy(QtSharedMemory::ForceNoWait); if (!sharedMemory.create(16)) { qFatal("Unable to allocate shared memory: %s", sharedMemory.errorString().toLatin1().constData()); return; } // Start all the threads qDebug("Starting count to 1000000 using %i threads", workers.count()); QList<Worker *>::iterator it; for (it = workers.begin(); it != workers.end(); ++it) (*it)->start(); // Loop until an error occurs, or until all threads are done int lastValue = 0; bool allDone; do { allDone = true; QList<Worker *>::iterator it; for (it = workers.begin(); it != workers.end(); ++it) { if (!(*it)->isFinished()) { allDone = false; break; } } if (sharedMemory.lock() && sharedMemory.attach()) { int value = *(int *)sharedMemory.data(); qDebug("Progress: %7i/%7i | %3i%% | %7i/sec", value, 1000000, value * 100 / 1000000, (value - lastValue)); lastValue = value; } else if (sharedMemory.error() != QtSharedMemory::OutOfResources) { qDebug("The factory was unable to attach to the segment: %s", sharedMemory.errorString().toLatin1().constData()); allDone = true; } sharedMemory.detach(); sharedMemory.unlock(); if (!allDone) qt_sleep(1); } while (!allDone); // Destroy the segment if (!sharedMemory.destroy()) { qDebug("Failed to destroy the segment: %s", sharedMemory.errorString().toLatin1().constData()); } } /* A worker increments the first integer of the shared memory segment by one, cnt times. It does this in a locked region to avoid race conditions which are very likely to occur here. */ void Worker::run() { // Initialize and attach to the shared memory segment QtSharedMemory mem("Shared memory segment used for counting"); // Loop cnt times, incrementing the first int value in the shared // memory segment in a locked region. for (int i = 0; i < cnt; ++i) { if (!mem.lock()) { qDebug("A worker failed to lock the segment: %s", mem.errorString().toLatin1().constData()); break; } if (!mem.attach()) { if (mem.error() == QtSharedMemory::OutOfResources) { // out of resources qt_sleep(1); continue; } qDebug("A worker failed to attach to the segment: %s", mem.errorString().toLatin1().constData()); break; } // A sequence of operations that is likely to cause // unsynchronized access to break. volatile int *array = (int *) mem.data(); volatile int a = array[0]; ++a; array[0] = a; mem.detach(); mem.unlock(); } }
main.cpp:
/**************************************************************************** ** ** Copyright (C) 2003-2007 Trolltech ASA. All rights reserved. ** ** This file is part of a Qt Solutions component. ** ** Licensees holding a valid Qt Solutions License Agreement may use this ** file in accordance with the rights, responsibilities, and obligations ** contained therein. Please consult your licensing agreement or contact ** [email protected] if any conditions of this licensing are not clear ** to you. ** ** Further information about Qt Solutions licensing is available at: ** http://www.trolltech.com/products/qt/addon/solutions/ ** or by contacting [email protected]. ** ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. ** ****************************************************************************/ #include "factory.h" int main(int argc, char *argv[]) { int threads = argc > 1 ? QString(argv[1]).toInt() : 0; if (argc < 2 || threads < 1) { qDebug("Usage: %s <nthreads>", argv[0]); qDebug("Counts to 1000000 using nthreads (at least 1) threads"); return 1; } if (threads > 7) { qDebug("*** WARNING: Certain operating systems allow only a limited number"); qDebug(" of shared memory attachments per process. See also"); qDebug(" the QtSharedMemory::attach() documentation."); } Factory f(threads); f.startCounting(); return 0; };
threadcounter.pro:
TEMPLATE = app CONFIG -= moc CONFIG += thread debug console INCLUDEPATH += . include(../../src/qtsharedmemory.pri) # Input SOURCES += main.cpp factory.cpp HEADERS += factory.h
Copyright © 2008 Nokia Corporation and/or its subsidiary(-ies) | Trademarks | Qt Solutions |