Adding upstream version 1:10.5.12.upstream/1%10.5.12upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 223 insertions, 0 deletions

diff --git a/storage/tokudb/tokudb_background.h b/storage/tokudb/tokudb_background.h
new file mode 100644
index 00000000..bf5eb97a
--- /dev/null
+++ b/storage/tokudb/tokudb_background.h
@@ -0,0 +1,223 @@
+/* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+// vim: ft=cpp:expandtab:ts=8:sw=4:softtabstop=4:
+#ident "$Id$"
+/*======
+This file is part of TokuDB
+
+
+Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved.
+
+    TokuDB is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License, version 2,
+    as published by the Free Software Foundation.
+
+    TokuDB 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 General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with TokuDB.  If not, see <http://www.gnu.org/licenses/>.
+
+======= */
+
+#ident "Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved."
+
+#ifndef _TOKUDB_BACKGROUND_H
+#define _TOKUDB_BACKGROUND_H
+
+#include "hatoku_hton.h"
+#include <atomic>
+#include <list>
+
+namespace tokudb {
+namespace background {
+
+class job_manager_t {
+public:
+    class job_t {
+    public:
+        // NO default constructor
+        job_t() = delete;
+
+        job_t(bool user_scheduled);
+
+        virtual ~job_t();
+
+        // method that runs the job
+        inline void run();
+
+        // method that tells the job to cancel ASAP
+        inline void cancel();
+
+        // method that tells the job to clean up/free resources on cancel
+        // or completion
+        inline void destroy();
+
+        // method that returns a 'key' string for finding a specific job
+        // (or jobs) usually used to find jobs to cancel
+        virtual const char* key() = 0;
+
+        // method to obtain the database name the job is scheduled on
+        virtual const char* database() = 0;
+
+        // method to obtain the table name the job is scheduled on
+        virtual const char* table() = 0;
+
+        // method to obtain the type of job
+        virtual const char* type() = 0;
+
+        // method to obtain a stringized list of job parameters
+        virtual const char* parameters() = 0;
+
+        // method to obtain a sting identifying the current status of the job
+        virtual const char* status() = 0;
+
+        inline bool running() const;
+
+        inline bool cancelled() const;
+
+        inline uint64_t id() const;
+
+        inline bool user_scheduled() const;
+
+        inline time_t scheduled_time() const;
+
+        inline time_t started_time() const;
+
+    protected:
+        // derived classed implement this to actually run their job
+        virtual void on_run() {};
+
+        // derived classes implement this to cancel their job
+        virtual void on_cancel() {};
+
+        // derived classes implement this to clean up/free resources
+        virtual void on_destroy() {};
+
+    private:
+        static std::atomic<uint64_t> _next_id;
+        std::atomic<bool>   _running;
+        std::atomic<bool>   _cancelled;
+        uint64_t            _id;
+        bool                _user_scheduled;
+        time_t              _scheduled_time;
+        time_t              _started_time;
+    };
+
+    // pfn for iterate callback
+    typedef void (*pfn_iterate_t)(class job_t*, void*);
+
+public:
+    void* operator new(size_t sz);
+    void operator delete(void* p);
+
+    job_manager_t();
+
+    ~job_manager_t();
+
+    // creates/initializes a singleton bjm
+    void initialize();
+
+    // destroys a bjm singleton
+    // cancels all jobs abd frees all resources
+    void destroy();
+
+    // schedules or runs a job depending on the 'background' value
+    // job specifics all depend on the implementation od 'job'
+    // background jobs will be executed in a FIFO fashion
+    // two jobs with the same key can not run concurrently
+    // if a foreground job is attempted, any currently scheduled or running
+    // background jobs will be cancelled first
+    // if another foreground job is already running, a new foreground job with
+    // the same key will be rejected
+    bool run_job(job_t* newjob, bool background);
+
+    // cancels any background job with a matching key
+    bool cancel_job(const char* key);
+
+    // iterates currently pending and running background jobs, calling
+    // 'callback' with the 'extra' data provided and the original 'extra'
+    // data passed when the job was scheduled
+    void iterate_jobs(pfn_iterate_t callback, void* extra) const;
+
+    // lock the bjm, this prevents anyone from running, cancelling or iterating
+    // jobs in the bjm.
+    inline void lock();
+    inline void unlock();
+
+private:
+    static void* thread_func(void* v);
+
+    void* real_thread_func();
+
+    // _mutex MUST be held on entry, will release and reaquire on exit
+    void run(job_t* job);
+
+    // _mutex MUST be held on entry
+    void cancel(job_t* job);
+private:
+    typedef std::list<job_t*> jobs_t;
+
+    mutable tokudb::thread::mutex_t     _mutex;
+    mutable tokudb::thread::semaphore_t _sem;
+    mutable tokudb::thread::thread_t    _thread;
+    jobs_t                              _background_jobs;
+    jobs_t                              _foreground_jobs;
+    std::atomic<bool>                   _shutdown;
+};
+
+extern job_manager_t*    _job_manager;
+
+bool initialize();
+bool destroy();
+
+inline void job_manager_t::lock() {
+    assert_debug(!_mutex.is_owned_by_me());
+    mutex_t_lock(_mutex);
+}
+inline void job_manager_t::unlock() {
+    assert_debug(_mutex.is_owned_by_me());
+    mutex_t_unlock(_mutex);
+}
+
+inline void job_manager_t::job_t::run() {
+    if (!_cancelled) {
+        _running = true;
+        _started_time = ::time(0);
+        on_run();
+        _running = false;
+    }
+}
+inline void job_manager_t::job_t::cancel() {
+    _cancelled = true;
+    if (_running)
+        on_cancel();
+    while (_running) tokudb::time::sleep_microsec(500000);
+    destroy();
+}
+void job_manager_t::job_t::destroy() {
+    on_destroy();
+}
+inline bool job_manager_t::job_t::running() const {
+    return _running;
+}
+inline bool job_manager_t::job_t::cancelled() const {
+    return _cancelled;
+}
+inline uint64_t job_manager_t::job_t::id() const {
+    return _id;
+}
+inline bool job_manager_t::job_t::user_scheduled() const {
+    return _user_scheduled;
+}
+inline time_t job_manager_t::job_t::scheduled_time() const {
+    return _scheduled_time;
+}
+inline time_t job_manager_t::job_t::started_time() const {
+    return _started_time;
+}
+} // namespace background
+} // namespace tokudb
+
+#endif // _TOKUDB_BACKGROUND_H