RequestQueue.h

/*
 * Copyright (c) 2008-2014, Pedigree Developers
 *
 * Please see the CONTRIB file in the root of the source tree for a full
 * list of contributors.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#ifndef REQUEST_QUEUE_H
#define REQUEST_QUEUE_H

#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/process/ConditionVariable.h"
#include "pedigree/kernel/process/Mutex.h"
#include "pedigree/kernel/processor/state_forward.h"
#include "pedigree/kernel/processor/types.h"
#include "pedigree/kernel/utilities/String.h"
#ifdef THREADS
#include "pedigree/kernel/machine/TimerHandler.h"
#endif

class Thread;

#define REQUEST_QUEUE_NUM_PRIORITIES 4

class EXPORTED_PUBLIC RequestQueue
{
    friend class Thread;

#ifdef THREADS
    class RequestQueueOverrunChecker : public TimerHandler
    {
        friend class RequestQueue;

        RequestQueueOverrunChecker() : m_LastQueueSize(0), m_Tick(0), queue(0)
        {
        }

      private:
        virtual void timer(uint64_t delta, InterruptState &state);

        size_t m_LastQueueSize;
        uint64_t m_Tick;

        RequestQueue *queue;
    };
#endif

  public:
    RequestQueue(const String &name);
    virtual ~RequestQueue();

    // Action to perform when a duplicate request is found in the queue.
    enum ActionOnDuplicate
    {
        // Block waiting for it to complete, and return its return value.
        Block,
        // Ignore the duplicate and create a new request.
        NewRequest,
        // Return immediately, ignoring the result from the request.
        ReturnImmediately
    };

    virtual void initialise();

    virtual void destroy();

    MUST_USE_RESULT uint64_t addRequest(
        size_t priority, uint64_t p1 = 0, uint64_t p2 = 0, uint64_t p3 = 0,
        uint64_t p4 = 0, uint64_t p5 = 0, uint64_t p6 = 0, uint64_t p7 = 0,
        uint64_t p8 = 0);

    MUST_USE_RESULT uint64_t addRequest(
        size_t priority, ActionOnDuplicate action, uint64_t p1 = 0,
        uint64_t p2 = 0, uint64_t p3 = 0, uint64_t p4 = 0, uint64_t p5 = 0,
        uint64_t p6 = 0, uint64_t p7 = 0, uint64_t p8 = 0);

    uint64_t addAsyncRequest(
        size_t priority, uint64_t p1 = 0, uint64_t p2 = 0, uint64_t p3 = 0,
        uint64_t p4 = 0, uint64_t p5 = 0, uint64_t p6 = 0, uint64_t p7 = 0,
        uint64_t p8 = 0);

    void halt();

    void resume();

  protected:
    virtual uint64_t executeRequest(
        uint64_t p1, uint64_t p2, uint64_t p3, uint64_t p4, uint64_t p5,
        uint64_t p6, uint64_t p7, uint64_t p8) = 0;

    RequestQueue(const RequestQueue &);
    void operator=(const RequestQueue &);

    class Request
    {
      public:
        Request()
            : p1(0), p2(0), p3(0), p4(0), p5(0), p6(0), p7(0), p8(0), ret(0),
#ifdef THREADS
              mutex(true), pThread(0),
#endif
              bReject(false), bCompleted(false), next(0), refcnt(0), owner(0),
              priority(0)
        {
        }
        ~Request()
        {
        }
        uint64_t p1, p2, p3, p4, p5, p6, p7, p8;
        uint64_t ret;
#ifdef THREADS
        Mutex mutex;
        Thread *pThread;
#endif
        bool bReject;
        bool bCompleted;
        Request *next;
        size_t refcnt;
        RequestQueue *owner;
        size_t priority;

      private:
        Request(const Request &);
        void operator=(const Request &);
    };

    virtual bool compareRequests(const Request &a, const Request &b)
    {
        return false;
    }

    bool isRequestValid(const Request *r);

    static int trampoline(void *p);

    static int doAsync(void *p);

    int work();

    Request *getNextRequest();

    Request *m_pRequestQueue[REQUEST_QUEUE_NUM_PRIORITIES];

    volatile bool m_Stop;

#ifdef THREADS

    Mutex m_RequestQueueMutex;

    ConditionVariable m_RequestQueueCondition;

    ConditionVariable m_AsyncRequestQueueCondition;

    Thread *m_pThread;

    bool m_Halted;
    Mutex m_HaltAcknowledged;

    RequestQueueOverrunChecker m_OverrunChecker;
#endif

    size_t m_nMaxAsyncRequests;
    size_t m_nAsyncRequests;

    size_t m_nTotalRequests;

    String m_Name;
};

#endif