runnerType Class Reference

Collaboration diagram for runnerType:

Public Member Functions
	runnerType (dirQueueType &dirQueue)
void	sum (counterType &other)
unsigned int	getDirsDone () const
void	process (dirQueueType &dirQueue)

Static Public Member Functions
static std::forward_list< runnerType > &	runners ()
static void	newWorker (dirQueueType &dirQueue)
static void	finish (counterType &sumCounter, bool verbose)

Public Attributes
std::thread	worker

Static Public Attributes
static unsigned int	nWorkers

Private Attributes
counterType	counter
unsigned int	dirsDone

Static Private Attributes
static std::mutex	listMutex
static std::condition_variable	cv
static std::atomic< unsigned int >	nActiveWorkers

Detailed Description

Definition at line 148 of file dirCount.cpp.

Constructor & Destructor Documentation

runnerType()

runnerType::runnerType ( dirQueueType &  dirQueue )

inline

Definition at line 161 of file dirCount.cpp.

                                      : dirsDone(0) {
        worker = std::thread(&runnerType::process, this, std::ref(dirQueue));
    }

References process(), and worker.

Here is the call graph for this function:

Member Function Documentation

finish()

static void runnerType::finish ( counterType &  sumCounter, bool  verbose  )

inlinestatic

Definition at line 173 of file dirCount.cpp.

                                                              {
        std::unique_lock<decltype(listMutex)> lock(listMutex);
        cv.wait(lock, [] {return nActiveWorkers == 0;});
        for (auto& runner : runners()) {
            runner.worker.join();
            runner.sum(sumCounter);
        }
        if (verbose) {
            unsigned int realizedThreads(0);
            unsigned int unusedThreads(0);
            for (auto& runner : runners()) {
                realizedThreads++;
                if (runner.getDirsDone() == 0) {
                    unusedThreads++;
                }
            }
            std::cerr << "of " << realizedThreads << " threads " << unusedThreads << " were not used\n";
        }
    }

References cv, listMutex, nActiveWorkers, runners(), and verbose.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

getDirsDone()

unsigned int runnerType::getDirsDone ( ) const

inline

Definition at line 198 of file dirCount.cpp.

                                     {
        return dirsDone;
    }

References dirsDone.

newWorker()

static void runnerType::newWorker ( dirQueueType &  dirQueue )

inlinestatic

Definition at line 165 of file dirCount.cpp.

                                                  {
        std::unique_lock<decltype(listMutex)> lock(listMutex);
        if (nWorkers < nThreads) {
            nWorkers++;
            nActiveWorkers++;
            runners().emplace_front(dirQueue);
        }
    }

References listMutex, nActiveWorkers, nThreads, nWorkers, and runners().

Referenced by main(), and process().

Here is the call graph for this function:

Here is the caller graph for this function:

process()

void runnerType::process ( dirQueueType &  dirQueue )

inline

Definition at line 201 of file dirCount.cpp.

                                         {
        while (auto path = dirQueue.dequeue()) {
            dirsDone++;
            static timer::anchor a("opendir");
            timer::instanceUnscoped i(a);
            auto result = opendir(path->c_str());
            i.stop();
            if (result == nullptr) {
                if (errno == EACCES && ignoreAccess) {
                    counter.count(counterType::specials::denied);
                    continue;
                } else if (errno == ENOENT) {
                    counter.count(counterType::specials::noent);
                    continue;
                } else if (errno == ENOTDIR) {
                    counter.count(counterType::specials::notdir);
                    continue;
                }
                throwcall::badval(result, nullptr, "can't open directory ", *path);
            }
            scoped::Dir dir(*path, result);
            static timer::anchor b("readdir");
            timer::instanceUnscoped I(b);
            while (auto entry = readdir(dir)) {
                I.stop();
                if (entry->d_name[entry->d_name[0] != '.' ? 0 : entry->d_name[1] != '.' ? 1 : 2] == '\0') {
                    I.restart();
                    continue; // skip . .. and empty strings
                }
                counter.count(entry->d_type);
                if (entry->d_type == DT_DIR) {
                    std::string subdir(*path);
                    subdir += "/";
                    subdir += entry->d_name;
                    dirQueue.emplace(subdir);
                    newWorker(dirQueue);
                } else if (entry->d_type == DT_UNKNOWN && reportUnknowns) {
                    std::string item(*path);
                    item += "/";
                    item += entry->d_name;
                    std::unique_lock<decltype(unknownListMutex)> lock(unknownListMutex); //(NOLINT clang-analyzer-alpha.core.CastToStruct)
                    unknownList.emplace_front(item);
                }
                I.restart();
            }
        }
        std::unique_lock<decltype(listMutex)> lock;
        --nActiveWorkers;
        cv.notify_one();
    }

References throwcall::badval(), counterType::count(), counter, cv, MyWaitQueues::simple< T >::dequeue(), dirsDone, MyWaitQueues::simple< T >::emplace(), ignoreAccess, listMutex, nActiveWorkers, newWorker(), reportUnknowns, timer::instanceUnscoped::restart(), timer::instanceUnscoped::stop(), unknownList, and unknownListMutex.

Referenced by runnerType().

Here is the call graph for this function:

Here is the caller graph for this function:

runners()

static std::forward_list<runnerType>& runnerType::runners ( )

inlinestatic

Definition at line 155 of file dirCount.cpp.

                                                  {
        static std::forward_list<runnerType> list;
        return list;
    }

Referenced by finish(), and newWorker().

Here is the caller graph for this function:

sum()

void runnerType::sum ( counterType &  other )

inline

Definition at line 195 of file dirCount.cpp.

                                 {
        counter.sum(other);
    }

References counter, and counterType::sum().

Here is the call graph for this function:

Member Data Documentation

counter

counterType runnerType::counter

private

Definition at line 149 of file dirCount.cpp.

Referenced by process(), and sum().

dirsDone

unsigned int runnerType::dirsDone

private

Definition at line 150 of file dirCount.cpp.

Referenced by getDirsDone(), and process().

worker

std::thread runnerType::worker

Definition at line 160 of file dirCount.cpp.

Referenced by runnerType().

---

The documentation for this class was generated from the following file:

• src/dirCount.cpp (v0.19-24-g0617ca1 with changes)